1 files changed, 26 insertions, 26 deletions

diff --git a/dom/fetch/Fetch.cpp b/dom/fetch/Fetch.cpp
index 04aa7fd91..4dbe2de0a 100644
--- a/dom/fetch/Fetch.cpp
+++ b/dom/fetch/Fetch.cpp
@@ -53,24 +53,24 @@ 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;
 
-  // 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)
+    explicit AbortSignalProxyRunnable(AbortSignalProxy* aProxy)
       : mProxy(aProxy)
     {}
 
@@ -78,16 +78,16 @@ class FetchSignalProxy final : public FetchSignal::Follower
     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)
 
-  explicit FetchSignalProxy(FetchSignal* aSignal)
+  explicit AbortSignalProxy(AbortSignal* aSignal)
     : mAborted(aSignal->Aborted())
   {
     Follow(aSignal);
@@ -96,17 +96,17 @@ public:
   void
   Aborted() override
   {
-    RefPtr<FetchSignalProxyRunnable> runnable =
-      new FetchSignalProxyRunnable(this);
+    RefPtr<AbortSignalProxyRunnable> runnable =
+      new AbortSignalProxyRunnable(this);
     NS_DispatchToMainThread(runnable);
   }
 
-  FetchSignal*
+  AbortSignal*
   GetOrCreateSignalForMainThread()
   {
     MOZ_ASSERT(NS_IsMainThread());
     if (!mSignalMainThread) {
-      mSignalMainThread = new FetchSignal(mAborted);
+      mSignalMainThread = new AbortSignal(mAborted);
     }
     return mSignalMainThread;
   }
@@ -118,7 +118,7 @@ public:
   }
 
 private:
-  ~FetchSignalProxy()
+  ~AbortSignalProxy()
   {
     NS_ReleaseOnMainThread(mSignalMainThread.forget());
   }
@@ -133,14 +133,14 @@ class WorkerFetchResolver final : public FetchDriverObserver
   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();
@@ -150,9 +150,9 @@ public:
       return nullptr;
     }
 
-    RefPtr<FetchSignalProxy> signalProxy;
+    RefPtr<AbortSignalProxy> signalProxy;
     if (aSignal) {
-      signalProxy = new FetchSignalProxy(aSignal);
+      signalProxy = new AbortSignalProxy(aSignal);
     }
 
     RefPtr<WorkerFetchResolver> r =
@@ -160,8 +160,8 @@ public:
     return r.forget();
   }
 
-  FetchSignal*
-  GetFetchSignal()
+  AbortSignal*
+  GetAbortSignal()
   {
     MOZ_ASSERT(NS_IsMainThread());
 
@@ -183,7 +183,7 @@ public:
 
 private:
    WorkerFetchResolver(PromiseWorkerProxy* aProxy,
-                       FetchSignalProxy* aSignalProxy,
+                       AbortSignalProxy* aSignalProxy,
                        FetchObserver* aObserver)
     : mPromiseProxy(aProxy)
     , mSignalProxy(aSignalProxy)
@@ -287,7 +287,7 @@ public:
       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.
@@ -329,7 +329,7 @@ FetchRequest(nsIGlobalObject* aGlobal, const RequestOrUSVString& aInput,
 
   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.