Bug 1378342 - AbortSignal/AbortController - part 2 - Renaming FetchController/FetchSignal, r=bkelly
☠☠ backed out by 591f78a8d99d ☠ ☠
authorAndrea Marchesini <amarchesini@mozilla.com>
Tue, 29 Aug 2017 07:30:19 +0200
changeset 429434 e5c6f95530f2684c92a6b36251067317abbcd6a5
parent 429433 81c100a42bb60c4d0a1f0a52cf33ebe250bdbcc3
child 429435 203ad2fab9aad74fa6349d7fe54aaa5977ae78ca
push id1567
push userjlorenzo@mozilla.com
push dateThu, 02 Nov 2017 12:36:05 +0000
treeherdermozilla-release@e512c14a0406 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbkelly
bugs1378342
milestone57.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1378342 - AbortSignal/AbortController - part 2 - Renaming FetchController/FetchSignal, r=bkelly
dom/abort/AbortController.cpp
dom/abort/AbortController.h
dom/abort/AbortSignal.cpp
dom/abort/AbortSignal.h
dom/abort/FetchController.cpp
dom/abort/FetchController.h
dom/abort/FetchSignal.cpp
dom/abort/FetchSignal.h
dom/abort/moz.build
dom/abort/tests/file_abort_controller.html
dom/abort/tests/file_fetch_controller.html
dom/abort/tests/mochitest.ini
dom/abort/tests/test_abort_controller.html
dom/abort/tests/test_fetch_controller.html
dom/abort/tests/worker_abort_controller.js
dom/abort/tests/worker_fetch_controller.js
dom/fetch/Fetch.cpp
dom/fetch/FetchDriver.cpp
dom/fetch/FetchDriver.h
dom/fetch/FetchObserver.cpp
dom/fetch/FetchObserver.h
dom/fetch/Request.h
dom/tests/mochitest/fetch/file_fetch_observer.html
dom/tests/mochitest/fetch/test_fetch_observer.html
dom/webidl/AbortController.webidl
dom/webidl/AbortSignal.webidl
dom/webidl/FetchController.webidl
dom/webidl/FetchSignal.webidl
dom/webidl/Request.webidl
dom/webidl/moz.build
dom/workers/WorkerPrefs.h
rename from dom/abort/FetchController.cpp
rename to dom/abort/AbortController.cpp
--- a/dom/abort/FetchController.cpp
+++ b/dom/abort/AbortController.cpp
@@ -1,127 +1,127 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include "FetchController.h"
-#include "FetchSignal.h"
-#include "mozilla/dom/FetchControllerBinding.h"
+#include "AbortController.h"
+#include "AbortSignal.h"
+#include "mozilla/dom/AbortControllerBinding.h"
 #include "WorkerPrivate.h"
 
 namespace mozilla {
 namespace dom {
 
-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(FetchController, mGlobal, mSignal,
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(AbortController, mGlobal, mSignal,
                                       mFollowingSignal)
 
-NS_IMPL_CYCLE_COLLECTING_ADDREF(FetchController)
-NS_IMPL_CYCLE_COLLECTING_RELEASE(FetchController)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(AbortController)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(AbortController)
 
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(FetchController)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(AbortController)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
 /* static */ bool
-FetchController::IsEnabled(JSContext* aCx, JSObject* aGlobal)
+AbortController::IsEnabled(JSContext* aCx, JSObject* aGlobal)
 {
   if (NS_IsMainThread()) {
-    return Preferences::GetBool("dom.fetchController.enabled", false);
+    return Preferences::GetBool("dom.abortController.enabled", false);
   }
 
   using namespace workers;
 
   // Otherwise, check the pref via the WorkerPrivate
   WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(aCx);
   if (!workerPrivate) {
     return false;
   }
 
-  return workerPrivate->FetchControllerEnabled();
+  return workerPrivate->AbortControllerEnabled();
 }
 
-/* static */ already_AddRefed<FetchController>
-FetchController::Constructor(const GlobalObject& aGlobal, ErrorResult& aRv)
+/* static */ already_AddRefed<AbortController>
+AbortController::Constructor(const GlobalObject& aGlobal, ErrorResult& aRv)
 {
   nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
   if (!global) {
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
 
-  RefPtr<FetchController> fetchController = new FetchController(global);
-  return fetchController.forget();
+  RefPtr<AbortController> abortController = new AbortController(global);
+  return abortController.forget();
 }
 
-FetchController::FetchController(nsIGlobalObject* aGlobal)
+AbortController::AbortController(nsIGlobalObject* aGlobal)
   : mGlobal(aGlobal)
   , mAborted(false)
 {}
 
 JSObject*
-FetchController::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+AbortController::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
-  return FetchControllerBinding::Wrap(aCx, this, aGivenProto);
+  return AbortControllerBinding::Wrap(aCx, this, aGivenProto);
 }
 
 nsIGlobalObject*
-FetchController::GetParentObject() const
+AbortController::GetParentObject() const
 {
   return mGlobal;
 }
 
-FetchSignal*
-FetchController::Signal()
+AbortSignal*
+AbortController::Signal()
 {
   if (!mSignal) {
-    mSignal = new FetchSignal(this, mAborted);
+    mSignal = new AbortSignal(this, mAborted);
   }
 
   return mSignal;
 }
 
 void
-FetchController::Abort()
+AbortController::Abort()
 {
   if (mAborted) {
     return;
   }
 
   mAborted = true;
 
   if (mSignal) {
     mSignal->Abort();
   }
 }
 
 void
-FetchController::Follow(FetchSignal& aSignal)
+AbortController::Follow(AbortSignal& aSignal)
 {
-  FetchSignal::Follower::Follow(&aSignal);
+  AbortSignal::Follower::Follow(&aSignal);
 }
 
 void
-FetchController::Unfollow(FetchSignal& aSignal)
+AbortController::Unfollow(AbortSignal& aSignal)
 {
   if (mFollowingSignal != &aSignal) {
     return;
   }
 
-  FetchSignal::Follower::Unfollow();
+  AbortSignal::Follower::Unfollow();
 }
 
-FetchSignal*
-FetchController::Following() const
+AbortSignal*
+AbortController::Following() const
 {
   return mFollowingSignal;
 }
 
 void
-FetchController::Aborted()
+AbortController::Aborted()
 {
   Abort();
 }
 
 } // dom namespace
 } // mozilla namespace
rename from dom/abort/FetchController.h
rename to dom/abort/AbortController.h
--- a/dom/abort/FetchController.h
+++ b/dom/abort/AbortController.h
@@ -1,71 +1,71 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef mozilla_dom_FetchController_h
-#define mozilla_dom_FetchController_h
+#ifndef mozilla_dom_AbortController_h
+#define mozilla_dom_AbortController_h
 
 #include "mozilla/dom/BindingDeclarations.h"
-#include "mozilla/dom/FetchSignal.h"
+#include "mozilla/dom/AbortSignal.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsWrapperCache.h"
 
 namespace mozilla {
 namespace dom {
 
-class FetchController final : public nsISupports
+class AbortController final : public nsISupports
                             , public nsWrapperCache
-                            , public FetchSignal::Follower
+                            , public AbortSignal::Follower
 {
 public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(FetchController)
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(AbortController)
 
   static bool
   IsEnabled(JSContext* aCx, JSObject* aGlobal);
 
-  static already_AddRefed<FetchController>
+  static already_AddRefed<AbortController>
   Constructor(const GlobalObject& aGlobal, ErrorResult& aRv);
 
-  explicit FetchController(nsIGlobalObject* aGlobal);
+  explicit AbortController(nsIGlobalObject* aGlobal);
 
   JSObject*
   WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
 
   nsIGlobalObject*
   GetParentObject() const;
 
-  FetchSignal*
+  AbortSignal*
   Signal();
 
   void
   Abort();
 
   void
-  Follow(FetchSignal& aSignal);
+  Follow(AbortSignal& aSignal);
 
   void
-  Unfollow(FetchSignal& aSignal);
+  Unfollow(AbortSignal& aSignal);
 
-  FetchSignal*
+  AbortSignal*
   Following() const;
 
-  // FetchSignal::Follower
+  // AbortSignal::Follower
 
   void Aborted() override;
 
 private:
-  ~FetchController() = default;
+  ~AbortController() = default;
 
   nsCOMPtr<nsIGlobalObject> mGlobal;
-  RefPtr<FetchSignal> mSignal;
+  RefPtr<AbortSignal> mSignal;
 
   bool mAborted;
 };
 
 } // dom namespace
 } // mozilla namespace
 
-#endif // mozilla_dom_FetchController_h
+#endif // mozilla_dom_AbortController_h
rename from dom/abort/FetchSignal.cpp
rename to dom/abort/AbortSignal.cpp
--- a/dom/abort/FetchSignal.cpp
+++ b/dom/abort/AbortSignal.cpp
@@ -1,64 +1,64 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include "FetchSignal.h"
+#include "AbortSignal.h"
 #include "mozilla/dom/Event.h"
-#include "mozilla/dom/FetchSignalBinding.h"
+#include "mozilla/dom/AbortSignalBinding.h"
 
 namespace mozilla {
 namespace dom {
 
-NS_IMPL_CYCLE_COLLECTION_CLASS(FetchSignal)
+NS_IMPL_CYCLE_COLLECTION_CLASS(AbortSignal)
 
-NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(FetchSignal,
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(AbortSignal,
                                                   DOMEventTargetHelper)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mController)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(FetchSignal,
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(AbortSignal,
                                                 DOMEventTargetHelper)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mController)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(FetchSignal)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(AbortSignal)
 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
 
-NS_IMPL_ADDREF_INHERITED(FetchSignal, DOMEventTargetHelper)
-NS_IMPL_RELEASE_INHERITED(FetchSignal, DOMEventTargetHelper)
+NS_IMPL_ADDREF_INHERITED(AbortSignal, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(AbortSignal, DOMEventTargetHelper)
 
-FetchSignal::FetchSignal(FetchController* aController,
+AbortSignal::AbortSignal(AbortController* aController,
                          bool aAborted)
   : DOMEventTargetHelper(aController->GetParentObject())
   , mController(aController)
   , mAborted(aAborted)
 {}
 
-FetchSignal::FetchSignal(bool aAborted)
+AbortSignal::AbortSignal(bool aAborted)
   : mAborted(aAborted)
 {}
 
 JSObject*
-FetchSignal::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+AbortSignal::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
-  return FetchSignalBinding::Wrap(aCx, this, aGivenProto);
+  return AbortSignalBinding::Wrap(aCx, this, aGivenProto);
 }
 
 bool
-FetchSignal::Aborted() const
+AbortSignal::Aborted() const
 {
   return mAborted;
 }
 
 void
-FetchSignal::Abort()
+AbortSignal::Abort()
 {
   MOZ_ASSERT(!mAborted);
   mAborted = true;
 
   // Let's inform the followers.
   for (uint32_t i = 0; i < mFollowers.Length(); ++i) {
     mFollowers[i]->Aborted();
   }
@@ -73,77 +73,77 @@ FetchSignal::Abort()
     Event::Constructor(this, NS_LITERAL_STRING("abort"), init);
   event->SetTrusted(true);
 
   bool dummy;
   DispatchEvent(event, &dummy);
 }
 
 void
-FetchSignal::AddFollower(FetchSignal::Follower* aFollower)
+AbortSignal::AddFollower(AbortSignal::Follower* aFollower)
 {
   MOZ_DIAGNOSTIC_ASSERT(aFollower);
   if (!mFollowers.Contains(aFollower)) {
     mFollowers.AppendElement(aFollower);
   }
 }
 
 void
-FetchSignal::RemoveFollower(FetchSignal::Follower* aFollower)
+AbortSignal::RemoveFollower(AbortSignal::Follower* aFollower)
 {
   MOZ_DIAGNOSTIC_ASSERT(aFollower);
   mFollowers.RemoveElement(aFollower);
 }
 
 bool
-FetchSignal::CanAcceptFollower(FetchSignal::Follower* aFollower) const
+AbortSignal::CanAcceptFollower(AbortSignal::Follower* aFollower) const
 {
   MOZ_DIAGNOSTIC_ASSERT(aFollower);
 
   if (!mController) {
     return true;
   }
 
   if (aFollower == mController) {
     return false;
   }
 
-  FetchSignal* following = mController->Following();
+  AbortSignal* following = mController->Following();
   if (!following) {
     return true;
   }
 
   return following->CanAcceptFollower(aFollower);
 }
 
-// FetchSignal::Follower
+// AbortSignal::Follower
 // ----------------------------------------------------------------------------
 
-FetchSignal::Follower::~Follower()
+AbortSignal::Follower::~Follower()
 {
   Unfollow();
 }
 
 void
-FetchSignal::Follower::Follow(FetchSignal* aSignal)
+AbortSignal::Follower::Follow(AbortSignal* aSignal)
 {
   MOZ_DIAGNOSTIC_ASSERT(aSignal);
 
   if (!aSignal->CanAcceptFollower(this)) {
     return;
   }
 
   Unfollow();
 
   mFollowingSignal = aSignal;
   aSignal->AddFollower(this);
 }
 
 void
-FetchSignal::Follower::Unfollow()
+AbortSignal::Follower::Unfollow()
 {
   if (mFollowingSignal) {
     mFollowingSignal->RemoveFollower(this);
     mFollowingSignal = nullptr;
   }
 }
 
 } // dom namespace
rename from dom/abort/FetchSignal.h
rename to dom/abort/AbortSignal.h
--- a/dom/abort/FetchSignal.h
+++ b/dom/abort/AbortSignal.h
@@ -1,51 +1,51 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef mozilla_dom_FetchSignal_h
-#define mozilla_dom_FetchSignal_h
+#ifndef mozilla_dom_AbortSignal_h
+#define mozilla_dom_AbortSignal_h
 
 #include "mozilla/DOMEventTargetHelper.h"
 
 namespace mozilla {
 namespace dom {
 
-class FetchController;
-class FetchSignal;
+class AbortController;
+class AbortSignal;
 
-class FetchSignal final : public DOMEventTargetHelper
+class AbortSignal final : public DOMEventTargetHelper
 {
 public:
-  // This class must be implemented by objects who want to follow a FetchSignal.
+  // This class must be implemented by objects who want to follow a AbortSignal.
   class Follower
   {
   public:
     virtual void Aborted() = 0;
 
   protected:
     virtual ~Follower();
 
     void
-    Follow(FetchSignal* aSignal);
+    Follow(AbortSignal* aSignal);
 
     void
     Unfollow();
 
-    RefPtr<FetchSignal> mFollowingSignal;
+    RefPtr<AbortSignal> mFollowingSignal;
   };
 
   NS_DECL_ISUPPORTS_INHERITED
-  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(FetchSignal, DOMEventTargetHelper)
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(AbortSignal, DOMEventTargetHelper)
 
-  FetchSignal(FetchController* aController, bool aAborted);
-  explicit FetchSignal(bool aAborted);
+  AbortSignal(AbortController* aController, bool aAborted);
+  explicit AbortSignal(bool aAborted);
 
   JSObject*
   WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
 
   bool
   Aborted() const;
 
   void
@@ -58,22 +58,22 @@ public:
 
   void
   RemoveFollower(Follower* aFollower);
 
   bool
   CanAcceptFollower(Follower* aFollower) const;
 
 private:
-  ~FetchSignal() = default;
+  ~AbortSignal() = default;
 
-  RefPtr<FetchController> mController;
+  RefPtr<AbortController> mController;
 
   // Raw pointers. Follower unregisters itself in the DTOR.
   nsTArray<Follower*> mFollowers;
 
   bool mAborted;
 };
 
 } // dom namespace
 } // mozilla namespace
 
-#endif // mozilla_dom_FetchSignal_h
+#endif // mozilla_dom_AbortSignal_h
--- a/dom/abort/moz.build
+++ b/dom/abort/moz.build
@@ -5,22 +5,22 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 with Files("**"):
     BUG_COMPONENT = ("Core", "DOM")
 
 TEST_DIRS += ['tests']
 
 EXPORTS.mozilla.dom += [
-    'FetchController.h',
-    'FetchSignal.h',
+    'AbortController.h',
+    'AbortSignal.h',
 ]
 
 UNIFIED_SOURCES += [
-    'FetchController.cpp',
-    'FetchSignal.cpp',
+    'AbortController.cpp',
+    'AbortSignal.cpp',
 ]
 
 LOCAL_INCLUDES += [
     '../workers',
 ]
 
 FINAL_LIBRARY = 'xul'
rename from dom/abort/tests/file_fetch_controller.html
rename to dom/abort/tests/file_abort_controller.html
--- a/dom/abort/tests/file_fetch_controller.html
+++ b/dom/abort/tests/file_abort_controller.html
@@ -3,127 +3,127 @@ function ok(a, msg) {
   parent.postMessage({ type: "check", status: !!a, message: msg }, "*");
 }
 
 function is(a, b, msg) {
   ok(a === b, msg);
 }
 
 function testWebIDL() {
-  ok("FetchController" in self, "We have a FetchController prototype");
-  ok("FetchSignal" in self, "We have a FetchSignal prototype");
+  ok("AbortController" in self, "We have a AbortController prototype");
+  ok("AbortSignal" in self, "We have a AbortSignal prototype");
 
-  var fc = new FetchController();
-  ok(!!fc, "FetchController can be created");
-  ok(fc instanceof FetchController, "FetchController is a FetchController");
+  var ac = new AbortController();
+  ok(!!ac, "AbortController can be created");
+  ok(ac instanceof AbortController, "AbortController is a AbortController");
 
-  ok(!!fc.signal, "FetchController has a signal");
-  ok(fc.signal instanceof FetchSignal, "fetchSignal is a FetchSignal");
-  is(fc.signal.aborted, false, "By default FetchSignal.aborted is false");
+  ok(!!ac.signal, "AbortController has a signal");
+  ok(ac.signal instanceof AbortSignal, "abortSignal is a AbortSignal");
+  is(ac.signal.aborted, false, "By default AbortSignal.aborted is false");
   next();
 }
 
 function testUpdateData() {
-  var fc = new FetchController();
+  var ac = new AbortController();
  
-  is(fc.signal.aborted, false, "By default FetchSignal.aborted is false");
+  is(ac.signal.aborted, false, "By default AbortSignal.aborted is false");
  
-  fc.abort();
-  is(fc.signal.aborted, true, "Signal is aborted");
+  ac.abort();
+  is(ac.signal.aborted, true, "Signal is aborted");
  
   next();
 }
  
 function testFollowingOurself() {
   // Let's follow ourself
-  var fc = new FetchController();
-  fc.follow(fc.signal);
+  var ac = new AbortController();
+  ac.follow(ac.signal);
  
-  fc.abort();
-  is(fc.signal.aborted, true, "Signal is aborted");
+  ac.abort();
+  is(ac.signal.aborted, true, "Signal is aborted");
  
   next();
 }
  
 function testFollowingOther() {
   // Let's follow another one
-  var fc1 = new FetchController();
-  var fc2 = new FetchController();
-  fc1.follow(fc2.signal);
+  var ac1 = new AbortController();
+  var ac2 = new AbortController();
+  ac1.follow(ac2.signal);
  
-  fc2.abort();
+  ac2.abort();
  
-  is(fc1.signal.aborted, true, "Signal is aborted");
-  is(fc2.signal.aborted, true, "Signal is aborted");
+  is(ac1.signal.aborted, true, "Signal is aborted");
+  is(ac2.signal.aborted, true, "Signal is aborted");
  
   next();
 }
 
 function testFollowingLoop() {
-  // fc1 -> fc2 -> fc3 -> fc1
-  var fc1 = new FetchController();
-  var fc2 = new FetchController();
-  var fc3 = new FetchController();
-  fc1.follow(fc2.signal);
-  fc2.follow(fc3.signal);
-  fc3.follow(fc1.signal);
+  // ac1 -> ac2 -> ac3 -> ac1
+  var ac1 = new AbortController();
+  var ac2 = new AbortController();
+  var ac3 = new AbortController();
+  ac1.follow(ac2.signal);
+  ac2.follow(ac3.signal);
+  ac3.follow(ac1.signal);
  
-  fc3.abort();
+  ac3.abort();
  
-  is(fc1.signal.aborted, true, "Signal is aborted");
-  is(fc2.signal.aborted, true, "Signal is aborted");
-  is(fc3.signal.aborted, true, "Signal is aborted");
+  is(ac1.signal.aborted, true, "Signal is aborted");
+  is(ac2.signal.aborted, true, "Signal is aborted");
+  is(ac3.signal.aborted, true, "Signal is aborted");
  
   next();
 }
  
 function testAbortEvent() {
-  var fc = new FetchController();
-  fc.signal.onabort = function(e) {
+  var ac = new AbortController();
+  ac.signal.onabort = function(e) {
     is(e.type, "abort", "Abort received");
     next();
   }
-  fc.abort();
+  ac.abort();
 }
  
 function testAbortedFetch() {
-  var fc = new FetchController();
-  fc.abort();
+  var ac = new AbortController();
+  ac.abort();
 
-  fetch('slow.sjs', { signal: fc.signal }).then(() => {
+  fetch('slow.sjs', { signal: ac.signal }).then(() => {
     ok(false, "Fetch should not return a resolved promise");
   }, e => {
     is(e.name, "AbortError", "We have an abort error");
   }).then(next);
 }
 
 function testFetchAndAbort() {
-  var fc = new FetchController();
+  var ac = new AbortController();
 
-  var p = fetch('slow.sjs', { signal: fc.signal });
-  fc.abort();
+  var p = fetch('slow.sjs', { signal: ac.signal });
+  ac.abort();
 
   p.then(() => {
     ok(false, "Fetch should not return a resolved promise");
   }, e => {
     is(e.name, "AbortError", "We have an abort error");
   }).then(next);
 }
 
 function testWorkerAbortedFetch() {
-  var w = new Worker('worker_fetch_controller.js');
+  var w = new Worker('worker_abort_controller.js');
   w.onmessage = function(e) {
     ok(e.data, "Abort + Fetch works in workers");
     next();
   }
   w.postMessage('testWorkerAbortedFetch');
 }
 
 function testWorkerFetchAndAbort() {
-  var w = new Worker('worker_fetch_controller.js');
+  var w = new Worker('worker_abort_controller.js');
   w.onmessage = function(e) {
     ok(e.data, "Abort + Fetch works in workers");
     next();
   }
   w.postMessage('testWorkerFetchAndAbort');
 }
 
 var steps = [
--- a/dom/abort/tests/mochitest.ini
+++ b/dom/abort/tests/mochitest.ini
@@ -1,6 +1,6 @@
 [DEFAULT]
 support-files =
-  file_fetch_controller.html
-  worker_fetch_controller.js
+  file_abort_controller.html
+  worker_abort_controller.js
 
-[test_fetch_controller.html]
+[test_abort_controller.html]
rename from dom/abort/tests/test_fetch_controller.html
rename to dom/abort/tests/test_abort_controller.html
--- a/dom/abort/tests/test_fetch_controller.html
+++ b/dom/abort/tests/test_abort_controller.html
@@ -1,25 +1,25 @@
 <!--
   Any copyright is dedicated to the Public Domain.
   http://creativecommons.org/publicdomain/zero/1.0/
 -->
 <!DOCTYPE HTML>
 <html>
 <head>
-  <title>Test FetchController</title>
+  <title>Test AbortController</title>
   <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
   <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
 </head>
 <body>
 <script class="testbody" type="text/javascript">
 
-SpecialPowers.pushPrefEnv({"set": [["dom.fetchController.enabled", true ]]}, () => {
+SpecialPowers.pushPrefEnv({"set": [["dom.abortController.enabled", true ]]}, () => {
   let ifr = document.createElement('iframe');
-  ifr.src = "file_fetch_controller.html";
+  ifr.src = "file_abort_controller.html";
   document.body.appendChild(ifr);
 
   onmessage = function(e) {
     if (e.data.type == "finish") {
       SimpleTest.finish();
       return;
     }
 
rename from dom/abort/tests/worker_fetch_controller.js
rename to dom/abort/tests/worker_abort_controller.js
--- a/dom/abort/tests/worker_fetch_controller.js
+++ b/dom/abort/tests/worker_abort_controller.js
@@ -1,24 +1,24 @@
 function testWorkerAbortedFetch() {
-  var fc = new FetchController();
-  fc.abort();
+  var ac = new AbortController();
+  ac.abort();
 
-  fetch('slow.sjs', { signal: fc.signal }).then(() => {
+  fetch('slow.sjs', { signal: ac.signal }).then(() => {
     postMessage(false);
   }, e => {
     postMessage(e.name == "AbortError");
   });
 }
 
 function testWorkerFetchAndAbort() {
-  var fc = new FetchController();
+  var ac = new AbortController();
 
-  var p = fetch('slow.sjs', { signal: fc.signal });
-  fc.abort();
+  var p = fetch('slow.sjs', { signal: ac.signal });
+  ac.abort();
 
   p.then(() => {
     postMessage(false);
   }, e => {
     postMessage(e.name == "AbortError");
   });
 }
 
--- a/dom/fetch/Fetch.cpp
+++ b/dom/fetch/Fetch.cpp
@@ -51,134 +51,134 @@
 #include "WorkerScope.h"
 #include "Workers.h"
 
 namespace mozilla {
 namespace dom {
 
 using namespace workers;
 
-// This class helps the proxying of FetchSignal changes cross threads.
-class FetchSignalProxy final : public FetchSignal::Follower
+// This class helps the proxying of AbortSignal changes cross threads.
+class AbortSignalProxy final : public AbortSignal::Follower
 {
   // This is created and released on the main-thread.
-  RefPtr<FetchSignal> mSignalMainThread;
+  RefPtr<AbortSignal> mSignalMainThread;
 
   // The main-thread event target for runnable dispatching.
   nsCOMPtr<nsIEventTarget> mMainThreadEventTarget;
 
-  // This value is used only for the creation of FetchSignal on the
+  // This value is used only for the creation of AbortSignal on the
   // main-thread. They are not updated.
   const bool mAborted;
 
-  // This runnable propagates changes from the FetchSignal on workers to the
-  // FetchSignal on main-thread.
-  class FetchSignalProxyRunnable final : public Runnable
+  // This runnable propagates changes from the AbortSignal on workers to the
+  // AbortSignal on main-thread.
+  class AbortSignalProxyRunnable final : public Runnable
   {
-    RefPtr<FetchSignalProxy> mProxy;
+    RefPtr<AbortSignalProxy> mProxy;
 
   public:
-    explicit FetchSignalProxyRunnable(FetchSignalProxy* aProxy)
-      : Runnable("dom::FetchSignalProxy::FetchSignalProxyRunnable")
+    explicit AbortSignalProxyRunnable(AbortSignalProxy* aProxy)
+      : Runnable("dom::AbortSignalProxy::AbortSignalProxyRunnable")
       , mProxy(aProxy)
     {}
 
     NS_IMETHOD
     Run() override
     {
       MOZ_ASSERT(NS_IsMainThread());
-      FetchSignal* signal = mProxy->GetOrCreateSignalForMainThread();
+      AbortSignal* signal = mProxy->GetOrCreateSignalForMainThread();
       signal->Abort();
       return NS_OK;
     }
   };
 
 public:
-  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(FetchSignalProxy)
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(AbortSignalProxy)
 
-  FetchSignalProxy(FetchSignal* aSignal, nsIEventTarget* aMainThreadEventTarget)
+  AbortSignalProxy(AbortSignal* aSignal, nsIEventTarget* aMainThreadEventTarget)
     : mMainThreadEventTarget(aMainThreadEventTarget)
     , mAborted(aSignal->Aborted())
   {
     MOZ_ASSERT(mMainThreadEventTarget);
     Follow(aSignal);
   }
 
   void
   Aborted() override
   {
-    RefPtr<FetchSignalProxyRunnable> runnable =
-      new FetchSignalProxyRunnable(this);
+    RefPtr<AbortSignalProxyRunnable> runnable =
+      new AbortSignalProxyRunnable(this);
     mMainThreadEventTarget->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
   }
 
-  FetchSignal*
+  AbortSignal*
   GetOrCreateSignalForMainThread()
   {
     MOZ_ASSERT(NS_IsMainThread());
     if (!mSignalMainThread) {
-      mSignalMainThread = new FetchSignal(mAborted);
+      mSignalMainThread = new AbortSignal(mAborted);
     }
     return mSignalMainThread;
   }
 
   void
   Shutdown()
   {
     Unfollow();
   }
 
 private:
-  ~FetchSignalProxy()
+  ~AbortSignalProxy()
   {
     NS_ProxyRelease(
-      "FetchSignalProxy::mSignalMainThread",
+      "AbortSignalProxy::mSignalMainThread",
       mMainThreadEventTarget, mSignalMainThread.forget());
   }
 };
 
 class WorkerFetchResolver final : public FetchDriverObserver
 {
   friend class MainThreadFetchRunnable;
   friend class WorkerDataAvailableRunnable;
   friend class WorkerFetchResponseEndBase;
   friend class WorkerFetchResponseEndRunnable;
   friend class WorkerFetchResponseRunnable;
 
   RefPtr<PromiseWorkerProxy> mPromiseProxy;
-  RefPtr<FetchSignalProxy> mSignalProxy;
+  RefPtr<AbortSignalProxy> mSignalProxy;
   RefPtr<FetchObserver> mFetchObserver;
 
 public:
   // Returns null if worker is shutting down.
   static already_AddRefed<WorkerFetchResolver>
   Create(workers::WorkerPrivate* aWorkerPrivate, Promise* aPromise,
-         FetchSignal* aSignal, FetchObserver* aObserver)
+         AbortSignal* aSignal, FetchObserver* aObserver)
   {
     MOZ_ASSERT(aWorkerPrivate);
     aWorkerPrivate->AssertIsOnWorkerThread();
     RefPtr<PromiseWorkerProxy> proxy =
       PromiseWorkerProxy::Create(aWorkerPrivate, aPromise);
     if (!proxy) {
       return nullptr;
     }
 
-    RefPtr<FetchSignalProxy> signalProxy;
+    RefPtr<AbortSignalProxy> signalProxy;
     if (aSignal) {
       signalProxy =
-        new FetchSignalProxy(aSignal, aWorkerPrivate->MainThreadEventTarget());
+        new AbortSignalProxy(aSignal, aWorkerPrivate->MainThreadEventTarget());
     }
 
     RefPtr<WorkerFetchResolver> r =
       new WorkerFetchResolver(proxy, signalProxy, aObserver);
     return r.forget();
   }
 
-  FetchSignal*
-  GetFetchSignal()
+  AbortSignal*
+  GetAbortSignal()
   {
     MOZ_ASSERT(NS_IsMainThread());
 
     if (!mSignalProxy) {
       return nullptr;
     }
 
     return mSignalProxy->GetOrCreateSignalForMainThread();
@@ -190,17 +190,17 @@ public:
   void
   OnResponseEnd(FetchDriverObserver::EndReason eReason) override;
 
   void
   OnDataAvailable() override;
 
 private:
    WorkerFetchResolver(PromiseWorkerProxy* aProxy,
-                       FetchSignalProxy* aSignalProxy,
+                       AbortSignalProxy* aSignalProxy,
                        FetchObserver* aObserver)
     : mPromiseProxy(aProxy)
     , mSignalProxy(aSignalProxy)
     , mFetchObserver(aObserver)
   {
     MOZ_ASSERT(!NS_IsMainThread());
     MOZ_ASSERT(mPromiseProxy);
   }
@@ -301,17 +301,17 @@ public:
                               workerPrivate->MainThreadEventTarget(), false);
       nsAutoCString spec;
       if (proxy->GetWorkerPrivate()->GetBaseURI()) {
         proxy->GetWorkerPrivate()->GetBaseURI()->GetAsciiSpec(spec);
       }
       fetch->SetWorkerScript(spec);
     }
 
-    RefPtr<FetchSignal> signal = mResolver->GetFetchSignal();
+    RefPtr<AbortSignal> signal = mResolver->GetAbortSignal();
 
     // ...but release it before calling Fetch, because mResolver's callback can
     // be called synchronously and they want the mutex, too.
     return fetch->Fetch(signal, mResolver);
   }
 };
 
 already_AddRefed<Promise>
@@ -343,17 +343,17 @@ FetchRequest(nsIGlobalObject* aGlobal, c
 
   RefPtr<Request> request = Request::Constructor(global, aInput, aInit, aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return nullptr;
   }
 
   RefPtr<InternalRequest> r = request->GetInternalRequest();
 
-  RefPtr<FetchSignal> signal;
+  RefPtr<AbortSignal> signal;
   if (aInit.mSignal.WasPassed()) {
     signal = &aInit.mSignal.Value();
     // Let's FetchDriver to deal with an already aborted signal.
   }
 
   RefPtr<FetchObserver> observer;
   if (aInit.mObserve.WasPassed()) {
     observer = new FetchObserver(aGlobal, signal);
--- a/dom/fetch/FetchDriver.cpp
+++ b/dom/fetch/FetchDriver.cpp
@@ -68,17 +68,17 @@ FetchDriver::FetchDriver(InternalRequest
 FetchDriver::~FetchDriver()
 {
   // We assert this since even on failures, we should call
   // FailWithNetworkError().
   MOZ_ASSERT(mResponseAvailableCalled);
 }
 
 nsresult
-FetchDriver::Fetch(FetchSignal* aSignal, FetchDriverObserver* aObserver)
+FetchDriver::Fetch(AbortSignal* aSignal, FetchDriverObserver* aObserver)
 {
   workers::AssertIsOnMainThread();
 #ifdef DEBUG
   MOZ_ASSERT(!mFetchCalled);
   mFetchCalled = true;
 #endif
 
   mObserver = aObserver;
--- a/dom/fetch/FetchDriver.h
+++ b/dom/fetch/FetchDriver.h
@@ -7,17 +7,17 @@
 #ifndef mozilla_dom_FetchDriver_h
 #define mozilla_dom_FetchDriver_h
 
 #include "nsIChannelEventSink.h"
 #include "nsIInterfaceRequestor.h"
 #include "nsIStreamListener.h"
 #include "nsIThreadRetargetableStreamListener.h"
 #include "mozilla/ConsoleReportCollector.h"
-#include "mozilla/dom/FetchSignal.h"
+#include "mozilla/dom/AbortSignal.h"
 #include "mozilla/dom/SRIMetadata.h"
 #include "mozilla/RefPtr.h"
 
 #include "mozilla/DebugOnly.h"
 #include "mozilla/net/ReferrerPolicy.h"
 
 class nsIConsoleReportCollector;
 class nsIDocument;
@@ -80,46 +80,46 @@ protected:
 private:
   bool mGotResponseAvailable;
 };
 
 class FetchDriver final : public nsIStreamListener,
                           public nsIChannelEventSink,
                           public nsIInterfaceRequestor,
                           public nsIThreadRetargetableStreamListener,
-                          public FetchSignal::Follower
+                          public AbortSignal::Follower
 {
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIREQUESTOBSERVER
   NS_DECL_NSISTREAMLISTENER
   NS_DECL_NSICHANNELEVENTSINK
   NS_DECL_NSIINTERFACEREQUESTOR
   NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER
 
   FetchDriver(InternalRequest* aRequest,
               nsIPrincipal* aPrincipal,
               nsILoadGroup* aLoadGroup,
               nsIEventTarget* aMainThreadEventTarget,
               bool aIsTrackingFetch);
 
-  nsresult Fetch(FetchSignal* aSignal,
+  nsresult Fetch(AbortSignal* aSignal,
                  FetchDriverObserver* aObserver);
 
   void
   SetDocument(nsIDocument* aDocument);
 
   void
   SetWorkerScript(const nsACString& aWorkerScirpt)
   {
     MOZ_ASSERT(!aWorkerScirpt.IsEmpty());
     mWorkerScript = aWorkerScirpt;
   }
 
-  // FetchSignal::Follower
+  // AbortSignal::Follower
 
   void
   Aborted() override;
 
 private:
   nsCOMPtr<nsIPrincipal> mPrincipal;
   nsCOMPtr<nsILoadGroup> mLoadGroup;
   RefPtr<InternalRequest> mRequest;
--- a/dom/fetch/FetchObserver.cpp
+++ b/dom/fetch/FetchObserver.cpp
@@ -40,17 +40,17 @@ FetchObserver::IsEnabled(JSContext* aCx,
   if (!workerPrivate) {
     return false;
   }
 
   return workerPrivate->FetchObserverEnabled();
 }
 
 FetchObserver::FetchObserver(nsIGlobalObject* aGlobal,
-                             FetchSignal* aSignal)
+                             AbortSignal* aSignal)
   : DOMEventTargetHelper(aGlobal)
   , mState(FetchState::Requesting)
 {
   if (aSignal) {
     Follow(aSignal);
   }
 }
 
--- a/dom/fetch/FetchObserver.h
+++ b/dom/fetch/FetchObserver.h
@@ -4,32 +4,32 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_dom_FetchObserver_h
 #define mozilla_dom_FetchObserver_h
 
 #include "mozilla/DOMEventTargetHelper.h"
 #include "mozilla/dom/FetchObserverBinding.h"
-#include "mozilla/dom/FetchSignal.h"
+#include "mozilla/dom/AbortSignal.h"
 
 namespace mozilla {
 namespace dom {
 
 class FetchObserver final : public DOMEventTargetHelper
-                          , public FetchSignal::Follower
+                          , public AbortSignal::Follower
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(FetchObserver, DOMEventTargetHelper)
 
   static bool
   IsEnabled(JSContext* aCx, JSObject* aGlobal);
 
-  FetchObserver(nsIGlobalObject* aGlobal, FetchSignal* aSignal);
+  FetchObserver(nsIGlobalObject* aGlobal, AbortSignal* aSignal);
 
   JSObject*
   WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
 
   FetchState
   State() const;
 
   IMPL_EVENT_HANDLER(statechange);
--- a/dom/fetch/Request.h
+++ b/dom/fetch/Request.h
@@ -7,17 +7,16 @@
 #ifndef mozilla_dom_Request_h
 #define mozilla_dom_Request_h
 
 #include "nsIContentPolicy.h"
 #include "nsISupportsImpl.h"
 #include "nsWrapperCache.h"
 
 #include "mozilla/dom/Fetch.h"
-#include "mozilla/dom/FetchSignal.h"
 #include "mozilla/dom/InternalRequest.h"
 // Required here due to certain WebIDL enums/classes being declared in both
 // files.
 #include "mozilla/dom/RequestBinding.h"
 
 namespace mozilla {
 namespace dom {
 
--- a/dom/tests/mochitest/fetch/file_fetch_observer.html
+++ b/dom/tests/mochitest/fetch/file_fetch_observer.html
@@ -14,72 +14,72 @@ function testObserver() {
     ok(!!o, "We have an observer");
     ok(o instanceof FetchObserver, "The correct object has been passed");
     is(o.state, "requesting", "By default the state is requesting");
     next();
   }});
 }
 
 function testObserveAbort() {
-  var fc = new FetchController();
+  var ac = new AbortController();
 
   fetch('http://mochi.test:8888/tests/dom/tests/mochitest/fetch/slow.sjs', {
-    signal: fc.signal,
+    signal: ac.signal,
     observe: o => {
       o.onstatechange = () => {
         ok(true, "StateChange event dispatched");
         if (o.state == "aborted") {
           ok(true, "Aborted!");
           next();
         }
       }
-      fc.abort();
+      ac.abort();
     }
   });
 }
 
 function testObserveComplete() {
-  var fc = new FetchController();
+  var ac = new AbortController();
 
   fetch('http://mochi.test:8888/tests/dom/tests/mochitest/fetch/slow.sjs', {
-    signal: fc.signal,
+    signal: ac.signal,
     observe: o => {
       o.onstatechange = () => {
         ok(true, "StateChange event dispatched");
         if (o.state == "complete") {
           ok(true, "Operation completed");
           next();
         }
       }
     }
   });
 }
 
 function testObserveErrored() {
-  var fc = new FetchController();
+  var ac = new AbortController();
 
   fetch('foo: bar', {
-    signal: fc.signal,
+    signal: ac.signal,
     observe: o => {
       o.onstatechange = () => {
         ok(true, "StateChange event dispatched");
         if (o.state == "errored") {
           ok(true, "Operation completed");
           next();
         }
       }
     }
   });
 }
 
 function testObserveResponding() {
-  var fc = new FetchController();
+  var ac = new AbortController();
 
   fetch('http://mochi.test:8888/tests/dom/tests/mochitest/fetch/slow.sjs', {
-    signal: fc.signal,
+    signal: ac.signal,
     observe: o => {
       o.onstatechange = () => {
         if (o.state == "responding") {
           ok(true, "We have responding events");
           next();
         }
       }
     }
--- a/dom/tests/mochitest/fetch/test_fetch_observer.html
+++ b/dom/tests/mochitest/fetch/test_fetch_observer.html
@@ -8,17 +8,17 @@
   <title>Test FetchObserver</title>
   <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
   <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
 </head>
 <body>
 <script class="testbody" type="text/javascript">
 
 SpecialPowers.pushPrefEnv({"set": [["dom.fetchObserver.enabled", true ],
-                                   ["dom.fetchController.enabled", true ]]}, () => {
+                                   ["dom.abortController.enabled", true ]]}, () => {
   let ifr = document.createElement('iframe');
   ifr.src = "file_fetch_observer.html";
   document.body.appendChild(ifr);
 
   onmessage = function(e) {
     if (e.data.type == "finish") {
       SimpleTest.finish();
       return;
rename from dom/webidl/FetchController.webidl
rename to dom/webidl/AbortController.webidl
--- a/dom/webidl/FetchController.webidl
+++ b/dom/webidl/AbortController.webidl
@@ -1,15 +1,18 @@
 /* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * The origin of this IDL file is
+ * https://dom.spec.whatwg.org/#abortcontroller
  */
 
 [Constructor(), Exposed=(Window,Worker),
- Func="FetchController::IsEnabled"]
-interface FetchController {
-  readonly attribute FetchSignal signal;
+ Func="AbortController::IsEnabled"]
+interface AbortController {
+  readonly attribute AbortSignal signal;
 
   void abort();
-  void follow(FetchSignal signal);
-  void unfollow(FetchSignal signal);
+  void follow(AbortSignal signal);
+  void unfollow(AbortSignal signal);
 };
rename from dom/webidl/FetchSignal.webidl
rename to dom/webidl/AbortSignal.webidl
--- a/dom/webidl/FetchSignal.webidl
+++ b/dom/webidl/AbortSignal.webidl
@@ -1,13 +1,16 @@
 /* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * The origin of this IDL file is
+ * https://dom.spec.whatwg.org/#abortsignal
  */
 
 [Exposed=(Window,Worker),
- Func="FetchController::IsEnabled"]
-interface FetchSignal : EventTarget {
+ Func="AbortController::IsEnabled"]
+interface AbortSignal : EventTarget {
   readonly attribute boolean aborted;
 
   attribute EventHandler onabort;
 };
--- a/dom/webidl/Request.webidl
+++ b/dom/webidl/Request.webidl
@@ -43,18 +43,18 @@ dictionary RequestInit {
   USVString referrer;
   ReferrerPolicy referrerPolicy;
   RequestMode mode;
   RequestCredentials credentials;
   RequestCache cache;
   RequestRedirect redirect;
   DOMString integrity;
 
-  [Func="FetchController::IsEnabled"]
-  FetchSignal signal;
+  [Func="AbortController::IsEnabled"]
+  AbortSignal signal;
 
   [Func="FetchObserver::IsEnabled"]
   ObserverCallback observe;
 };
 
 // Gecko currently does not ship RequestContext, so please don't use it in IDL
 // that is exposed to script.
 enum RequestContext {
--- a/dom/webidl/moz.build
+++ b/dom/webidl/moz.build
@@ -373,16 +373,18 @@ GENERATED_WEBIDL_FILES = [
 
 PREPROCESSED_WEBIDL_FILES = [
     'Navigator.webidl',
     'Node.webidl',
     'Window.webidl',
 ]
 
 WEBIDL_FILES = [
+    'AbortController.webidl',
+    'AbortSignal.webidl',
     'AbstractWorker.webidl',
     'AddonManager.webidl',
     'AnalyserNode.webidl',
     'Animatable.webidl',
     'Animation.webidl',
     'AnimationEffectReadOnly.webidl',
     'AnimationEffectTiming.webidl',
     'AnimationEffectTimingReadOnly.webidl',
@@ -510,20 +512,18 @@ WEBIDL_FILES = [
     'EventHandler.webidl',
     'EventListener.webidl',
     'EventSource.webidl',
     'EventTarget.webidl',
     'ExtendableEvent.webidl',
     'ExtendableMessageEvent.webidl',
     'FakePluginTagInit.webidl',
     'Fetch.webidl',
-    'FetchController.webidl',
     'FetchEvent.webidl',
     'FetchObserver.webidl',
-    'FetchSignal.webidl',
     'File.webidl',
     'FileList.webidl',
     'FileMode.webidl',
     'FileReader.webidl',
     'FileReaderSync.webidl',
     'FileSystem.webidl',
     'FileSystemDirectoryEntry.webidl',
     'FileSystemDirectoryReader.webidl',
--- a/dom/workers/WorkerPrefs.h
+++ b/dom/workers/WorkerPrefs.h
@@ -37,17 +37,17 @@ WORKER_SIMPLE_PREF("dom.serviceWorkers.o
 WORKER_SIMPLE_PREF("dom.storageManager.enabled", StorageManagerEnabled, STORAGEMANAGER_ENABLED)
 WORKER_SIMPLE_PREF("dom.promise_rejection_events.enabled", PromiseRejectionEventsEnabled, PROMISE_REJECTION_EVENTS_ENABLED)
 WORKER_SIMPLE_PREF("dom.push.enabled", PushEnabled, PUSH_ENABLED)
 WORKER_SIMPLE_PREF("dom.streams.enabled", StreamsEnabled, STREAMS_ENABLED)
 WORKER_SIMPLE_PREF("dom.requestcontext.enabled", RequestContextEnabled, REQUESTCONTEXT_ENABLED)
 WORKER_SIMPLE_PREF("gfx.offscreencanvas.enabled", OffscreenCanvasEnabled, OFFSCREENCANVAS_ENABLED)
 WORKER_SIMPLE_PREF("dom.webkitBlink.dirPicker.enabled", WebkitBlinkDirectoryPickerEnabled, DOM_WEBKITBLINK_DIRPICKER_WEBKITBLINK)
 WORKER_SIMPLE_PREF("dom.netinfo.enabled", NetworkInformationEnabled, NETWORKINFORMATION_ENABLED)
-WORKER_SIMPLE_PREF("dom.fetchController.enabled", FetchControllerEnabled, FETCHCONTROLLER_ENABLED)
+WORKER_SIMPLE_PREF("dom.abortController.enabled", AbortControllerEnabled, ABORTCONTROLLER_ENABLED)
 WORKER_SIMPLE_PREF("dom.fetchObserver.enabled", FetchObserverEnabled, FETCHOBSERVER_ENABLED)
 WORKER_SIMPLE_PREF("privacy.resistFingerprinting", ResistFingerprintingEnabled, RESISTFINGERPRINTING_ENABLED)
 WORKER_PREF("intl.accept_languages", PrefLanguagesChanged)
 WORKER_PREF("general.appname.override", AppNameOverrideChanged)
 WORKER_PREF("general.appversion.override", AppVersionOverrideChanged)
 WORKER_PREF("general.platform.override", PlatformOverrideChanged)
 #ifdef JS_GC_ZEAL
 WORKER_PREF("dom.workers.options.gcZeal", LoadGCZealOptions)