Bug 1478101 - Split AbortSignal in 2 classes: AbortSignal and AbortSignalImpl, r=bz

dom/abort/AbortSignal.cpp

@@ -12,14 +12,63 @@
 namespace mozilla {
 namespace dom {
 
+// AbortSignalImpl
+// ----------------------------------------------------------------------------
+
+AbortSignalImpl::AbortSignalImpl(bool aAborted)
+  : mAborted(aAborted)
+{}
+
+bool
+AbortSignalImpl::Aborted() const
+{
+  return mAborted;
+}
+
+void
+AbortSignalImpl::Abort()
+{
+  if (mAborted) {
+    return;
+  }
+
+  mAborted = true;
+
+  // Let's inform the followers.
+  for (AbortFollower* follower : mFollowers) {
+    follower->Abort();
+  }
+}
+
+void
+AbortSignalImpl::AddFollower(AbortFollower* aFollower)
+{
+  MOZ_DIAGNOSTIC_ASSERT(aFollower);
+  if (!mFollowers.Contains(aFollower)) {
+    mFollowers.AppendElement(aFollower);
+  }
+}
+
+void
+AbortSignalImpl::RemoveFollower(AbortFollower* aFollower)
+{
+  MOZ_DIAGNOSTIC_ASSERT(aFollower);
+  mFollowers.RemoveElement(aFollower);
+}
+
+// AbortSignal
+// ----------------------------------------------------------------------------
+
 NS_IMPL_CYCLE_COLLECTION_CLASS(AbortSignal)
 
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(AbortSignal,
                                                   DOMEventTargetHelper)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFollowingSignal)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(AbortSignal,
                                                 DOMEventTargetHelper)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mFollowingSignal)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(AbortSignal)
@@ -31,11 +80,7 @@ NS_IMPL_RELEASE_INHERITED(AbortSignal, DOMEventTargetHelper)
 AbortSignal::AbortSignal(nsIGlobalObject* aGlobalObject,
                          bool aAborted)
   : DOMEventTargetHelper(aGlobalObject)
-  , mAborted(aAborted)
+  , AbortSignalImpl(aAborted)
-{}
-
-AbortSignal::AbortSignal(bool aAborted)
-  : mAborted(aAborted)
 {}
 
 JSObject*
@@ -44,22 +89,10 @@ AbortSignal::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
   return AbortSignal_Binding::Wrap(aCx, this, aGivenProto);
 }
 
-bool
-AbortSignal::Aborted() const
-{
-  return mAborted;
-}
-
 void
 AbortSignal::Abort()
 {
-  MOZ_ASSERT(!mAborted);
+  AbortSignalImpl::Abort();
-  mAborted = true;
-
-  // Let's inform the followers.
-  for (uint32_t i = 0; i < mFollowers.Length(); ++i) {
-    mFollowers[i]->Abort();
-  }
 
   EventInit init;
   init.mBubbles = false;
@@ -72,22 +105,6 @@ AbortSignal::Abort()
   DispatchEvent(*event);
 }
 
-void
-AbortSignal::AddFollower(AbortFollower* aFollower)
-{
-  MOZ_DIAGNOSTIC_ASSERT(aFollower);
-  if (!mFollowers.Contains(aFollower)) {
-    mFollowers.AppendElement(aFollower);
-  }
-}
-
-void
-AbortSignal::RemoveFollower(AbortFollower* aFollower)
-{
-  MOZ_DIAGNOSTIC_ASSERT(aFollower);
-  mFollowers.RemoveElement(aFollower);
-}
-
 // AbortFollower
 // ----------------------------------------------------------------------------
 
@@ -97,7 +114,7 @@ AbortFollower::~AbortFollower()
 }
 
 void
-AbortFollower::Follow(AbortSignal* aSignal)
+AbortFollower::Follow(AbortSignalImpl* aSignal)
 {
   MOZ_DIAGNOSTIC_ASSERT(aSignal);
 

dom/abort/AbortSignal.h

@@ -13,15 +13,17 @@ namespace mozilla {
 namespace dom {
 
 class AbortSignal;
+class AbortSignalImpl;
 
-// This class must be implemented by objects who want to follow a AbortSignal.
+// This class must be implemented by objects who want to follow a
+// AbortSignalImpl.
 class AbortFollower
 {
 public:
   virtual void Abort() = 0;
 
   void
-  Follow(AbortSignal* aSignal);
+  Follow(AbortSignalImpl* aSignal);
 
   void
   Unfollow();
@@ -32,21 +34,16 @@ public:
 protected:
   virtual ~AbortFollower();
 
-  RefPtr<AbortSignal> mFollowingSignal;
+  // Subclasses of AbortFollower must Traverse/Unlink this member.
+  RefPtr<AbortSignalImpl> mFollowingSignal;
 };
 
-class AbortSignal final : public DOMEventTargetHelper
+// Any subclass of this class must Traverse/Unlink mFollowingSignal.
-                        , public AbortFollower
+class AbortSignalImpl : public AbortFollower
+                      , public nsISupports
 {
 public:
-  NS_DECL_ISUPPORTS_INHERITED
+  explicit AbortSignalImpl(bool aAborted);
-  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(AbortSignal, DOMEventTargetHelper)
-
-  AbortSignal(nsIGlobalObject* aGlobalObject, bool aAborted);
-  explicit AbortSignal(bool aAborted);
-
-  JSObject*
-  WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
 
   bool
   Aborted() const;
@@ -54,23 +51,43 @@ public:
   void
   Abort() override;
 
-  IMPL_EVENT_HANDLER(abort);
-
   void
   AddFollower(AbortFollower* aFollower);
 
   void
   RemoveFollower(AbortFollower* aFollower);
 
-private:
+protected:
-  ~AbortSignal() = default;
+  virtual ~AbortSignalImpl() = default;
 
+private:
   // Raw pointers. AbortFollower unregisters itself in the DTOR.
   nsTArray<AbortFollower*> mFollowers;
 
   bool mAborted;
 };
 
+class AbortSignal final : public DOMEventTargetHelper
+                        , public AbortSignalImpl
+{
+public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(AbortSignal, DOMEventTargetHelper)
+
+  AbortSignal(nsIGlobalObject* aGlobalObject, bool aAborted);
+
+  JSObject*
+  WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
+
+  IMPL_EVENT_HANDLER(abort);
+
+  void
+  Abort() override;
+
+private:
+  ~AbortSignal() = default;
+};
+
 } // dom namespace
 } // mozilla namespace
 

dom/fetch/Fetch.cpp

@@ -74,21 +74,44 @@ AbortStream(JSContext* aCx, JS::Handle<JSObject*> aStream)
 
 } // anonymous
 
-// This class helps the proxying of AbortSignal changes cross threads.
+class AbortSignalMainThread final : public AbortSignalImpl
+{
+public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS(AbortSignalMainThread)
+
+  explicit AbortSignalMainThread(bool aAborted)
+    : AbortSignalImpl(aAborted)
+  {}
+
+private:
+  ~AbortSignalMainThread() = default;
+};
+
+NS_IMPL_CYCLE_COLLECTION(AbortSignalMainThread, mFollowingSignal)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(AbortSignalMainThread)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(AbortSignalMainThread)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(AbortSignalMainThread)
+
+// This class helps the proxying of AbortSignalImpl changes cross threads.
 class AbortSignalProxy final : public AbortFollower
 {
   // This is created and released on the main-thread.
-  RefPtr<AbortSignal> mSignalMainThread;
+  RefPtr<AbortSignalImpl> mSignalImplMainThread;
 
   // The main-thread event target for runnable dispatching.
   nsCOMPtr<nsIEventTarget> mMainThreadEventTarget;
 
-  // This value is used only for the creation of AbortSignal on the
+  // This value is used only for the creation of AbortSignalImpl on the
   // main-thread. They are not updated.
   const bool mAborted;
 
-  // This runnable propagates changes from the AbortSignal on workers to the
+  // This runnable propagates changes from the AbortSignalImpl on workers to the
-  // AbortSignal on main-thread.
+  // AbortSignalImpl on main-thread.
   class AbortSignalProxyRunnable final : public Runnable
   {
     RefPtr<AbortSignalProxy> mProxy;
@@ -103,8 +126,9 @@ class AbortSignalProxy final : public AbortFollower
     Run() override
     {
       MOZ_ASSERT(NS_IsMainThread());
-      AbortSignal* signal = mProxy->GetOrCreateSignalForMainThread();
+      AbortSignalImpl* signalImpl =
-      signal->Abort();
+        mProxy->GetOrCreateSignalImplForMainThread();
+      signalImpl->Abort();
       return NS_OK;
     }
   };
@@ -112,12 +136,13 @@ class AbortSignalProxy final : public AbortFollower
 public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(AbortSignalProxy)
 
-  AbortSignalProxy(AbortSignal* aSignal, nsIEventTarget* aMainThreadEventTarget)
+  AbortSignalProxy(AbortSignalImpl* aSignalImpl,
+                   nsIEventTarget* aMainThreadEventTarget)
     : mMainThreadEventTarget(aMainThreadEventTarget)
-    , mAborted(aSignal->Aborted())
+    , mAborted(aSignalImpl->Aborted())
   {
     MOZ_ASSERT(mMainThreadEventTarget);
-    Follow(aSignal);
+    Follow(aSignalImpl);
   }
 
   void
@@ -128,18 +153,18 @@ public:
     mMainThreadEventTarget->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
   }
 
-  AbortSignal*
+  AbortSignalImpl*
-  GetOrCreateSignalForMainThread()
+  GetOrCreateSignalImplForMainThread()
   {
     MOZ_ASSERT(NS_IsMainThread());
-    if (!mSignalMainThread) {
+    if (!mSignalImplMainThread) {
-      mSignalMainThread = new AbortSignal(mAborted);
+      mSignalImplMainThread = new AbortSignalMainThread(mAborted);
     }
-    return mSignalMainThread;
+    return mSignalImplMainThread;
   }
 
-  AbortSignal*
+  AbortSignalImpl*
-  GetSignalForTargetThread()
+  GetSignalImplForTargetThread()
   {
     return mFollowingSignal;
   }
@@ -154,8 +179,8 @@ private:
   ~AbortSignalProxy()
   {
     NS_ProxyRelease(
-      "AbortSignalProxy::mSignalMainThread",
+      "AbortSignalProxy::mSignalImplMainThread",
-      mMainThreadEventTarget, mSignalMainThread.forget());
+      mMainThreadEventTarget, mSignalImplMainThread.forget());
   }
 };
 
@@ -173,7 +198,7 @@ public:
   // Returns null if worker is shutting down.
   static already_AddRefed<WorkerFetchResolver>
   Create(WorkerPrivate* aWorkerPrivate, Promise* aPromise,
-         AbortSignal* aSignal, FetchObserver* aObserver)
+         AbortSignalImpl* aSignalImpl, FetchObserver* aObserver)
   {
     MOZ_ASSERT(aWorkerPrivate);
     aWorkerPrivate->AssertIsOnWorkerThread();
@@ -184,9 +209,10 @@ public:
     }
 
     RefPtr<AbortSignalProxy> signalProxy;
-    if (aSignal) {
+    if (aSignalImpl) {
       signalProxy =
-        new AbortSignalProxy(aSignal, aWorkerPrivate->MainThreadEventTarget());
+        new AbortSignalProxy(aSignalImpl,
+                             aWorkerPrivate->MainThreadEventTarget());
     }
 
     RefPtr<WorkerFetchResolver> r =
@@ -205,7 +231,7 @@ public:
     return r.forget();
   }
 
-  AbortSignal*
+  AbortSignalImpl*
   GetAbortSignalForMainThread()
   {
     MOZ_ASSERT(NS_IsMainThread());
@@ -214,10 +240,10 @@ public:
       return nullptr;
     }
 
-    return mSignalProxy->GetOrCreateSignalForMainThread();
+    return mSignalProxy->GetOrCreateSignalImplForMainThread();
   }
 
-  AbortSignal*
+  AbortSignalImpl*
   GetAbortSignalForTargetThread()
   {
     mPromiseProxy->GetWorkerPrivate()->AssertIsOnWorkerThread();
@@ -226,7 +252,7 @@ public:
       return nullptr;
     }
 
-    return mSignalProxy->GetSignalForTargetThread();
+    return mSignalProxy->GetSignalImplForTargetThread();
   }
 
   PromiseWorkerProxy*
@@ -307,7 +333,7 @@ class MainThreadFetchResolver final : public FetchDriverObserver
   RefPtr<Promise> mPromise;
   RefPtr<Response> mResponse;
   RefPtr<FetchObserver> mFetchObserver;
-  RefPtr<AbortSignal> mSignal;
+  RefPtr<AbortSignalImpl> mSignalImpl;
   const bool mMozErrors;
 
   nsCOMPtr<nsILoadGroup> mLoadGroup;
@@ -315,10 +341,10 @@ class MainThreadFetchResolver final : public FetchDriverObserver
   NS_DECL_OWNINGTHREAD
 public:
   MainThreadFetchResolver(Promise* aPromise, FetchObserver* aObserver,
-                          AbortSignal* aSignal, bool aMozErrors)
+                          AbortSignalImpl* aSignalImpl, bool aMozErrors)
     : mPromise(aPromise)
     , mFetchObserver(aObserver)
-    , mSignal(aSignal)
+    , mSignalImpl(aSignalImpl)
     , mMozErrors(aMozErrors)
   {}
 
@@ -415,11 +441,12 @@ public:
       fetch->SetController(mController);
     }
 
-    RefPtr<AbortSignal> signal = mResolver->GetAbortSignalForMainThread();
+    RefPtr<AbortSignalImpl> signalImpl =
+      mResolver->GetAbortSignalForMainThread();
 
     // ...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);
+    return fetch->Fetch(signalImpl, mResolver);
   }
 };
 
@@ -456,9 +483,9 @@ FetchRequest(nsIGlobalObject* aGlobal, const RequestOrUSVString& aInput,
   }
 
   RefPtr<InternalRequest> r = request->GetInternalRequest();
-  RefPtr<AbortSignal> signal = request->GetSignal();
+  RefPtr<AbortSignalImpl> signalImpl = request->GetSignalImpl();
 
-  if (signal && signal->Aborted()) {
+  if (signalImpl && signalImpl->Aborted()) {
     // Already aborted signal rejects immediately.
     aRv.Throw(NS_ERROR_DOM_ABORT_ERR);
     return nullptr;
@@ -466,7 +493,7 @@ FetchRequest(nsIGlobalObject* aGlobal, const RequestOrUSVString& aInput,
 
   RefPtr<FetchObserver> observer;
   if (aInit.mObserve.WasPassed()) {
-    observer = new FetchObserver(aGlobal, signal);
+    observer = new FetchObserver(aGlobal, signalImpl);
     aInit.mObserve.Value().HandleEvent(*observer);
   }
 
@@ -505,7 +532,8 @@ FetchRequest(nsIGlobalObject* aGlobal, const RequestOrUSVString& aInput,
     Telemetry::Accumulate(Telemetry::FETCH_IS_MAINTHREAD, 1);
 
     RefPtr<MainThreadFetchResolver> resolver =
-      new MainThreadFetchResolver(p, observer, signal, request->MozErrors());
+      new MainThreadFetchResolver(p, observer, signalImpl,
+                                  request->MozErrors());
     RefPtr<FetchDriver> fetch =
       new FetchDriver(r, principal, loadGroup,
                       aGlobal->EventTargetFor(TaskCategory::Other),
@@ -513,7 +541,7 @@ FetchRequest(nsIGlobalObject* aGlobal, const RequestOrUSVString& aInput,
                       isTrackingFetch);
     fetch->SetDocument(doc);
     resolver->SetLoadGroup(loadGroup);
-    aRv = fetch->Fetch(signal, resolver);
+    aRv = fetch->Fetch(signalImpl, resolver);
     if (NS_WARN_IF(aRv.Failed())) {
       return nullptr;
     }
@@ -528,7 +556,7 @@ FetchRequest(nsIGlobalObject* aGlobal, const RequestOrUSVString& aInput,
     }
 
     RefPtr<WorkerFetchResolver> resolver =
-      WorkerFetchResolver::Create(worker, p, signal, observer);
+      WorkerFetchResolver::Create(worker, p, signalImpl, observer);
     if (!resolver) {
       NS_WARNING("Could not keep the worker alive.");
       aRv.Throw(NS_ERROR_DOM_ABORT_ERR);
@@ -562,7 +590,7 @@ MainThreadFetchResolver::OnResponseAvailableInternal(InternalResponse* aResponse
     }
 
     nsCOMPtr<nsIGlobalObject> go = mPromise->GetParentObject();
-    mResponse = new Response(go, aResponse, mSignal);
+    mResponse = new Response(go, aResponse, mSignalImpl);
     mPromise->MaybeResolve(mResponse);
   } else {
     if (mFetchObserver) {
@@ -1150,8 +1178,8 @@ already_AddRefed<Promise>
 FetchBody<Derived>::ConsumeBody(JSContext* aCx, FetchConsumeType aType,
                                 ErrorResult& aRv)
 {
-  RefPtr<AbortSignal> signal = DerivedClass()->GetSignal();
+  RefPtr<AbortSignalImpl> signalImpl = DerivedClass()->GetSignalImpl();
-  if (signal && signal->Aborted()) {
+  if (signalImpl && signalImpl->Aborted()) {
     aRv.Throw(NS_ERROR_DOM_ABORT_ERR);
     return nullptr;
   }
@@ -1170,7 +1198,7 @@ FetchBody<Derived>::ConsumeBody(JSContext* aCx, FetchConsumeType aType,
 
   RefPtr<Promise> promise =
     FetchBodyConsumer<Derived>::Create(global, mMainThreadEventTarget, this,
-                                       signal, aType, aRv);
+                                       signalImpl, aType, aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return nullptr;
   }
@@ -1224,17 +1252,17 @@ FetchBody<Derived>::SetReadableStreamBody(JSContext* aCx, JSObject* aBody)
   MOZ_ASSERT(aBody);
   mReadableStreamBody = aBody;
 
-  RefPtr<AbortSignal> signal = DerivedClass()->GetSignal();
+  RefPtr<AbortSignalImpl> signalImpl = DerivedClass()->GetSignalImpl();
-  if (!signal) {
+  if (!signalImpl) {
     return;
   }
 
-  bool aborted = signal->Aborted();
+  bool aborted = signalImpl->Aborted();
   if (aborted) {
     JS::Rooted<JSObject*> body(aCx, mReadableStreamBody);
     AbortStream(aCx, body);
   } else if (!IsFollowing()) {
-    Follow(signal);
+    Follow(signalImpl);
   }
 }
 
@@ -1282,12 +1310,12 @@ FetchBody<Derived>::GetBody(JSContext* aCx,
     }
   }
 
-  RefPtr<AbortSignal> signal = DerivedClass()->GetSignal();
+  RefPtr<AbortSignalImpl> signalImpl = DerivedClass()->GetSignalImpl();
-  if (signal) {
+  if (signalImpl) {
-    if (signal->Aborted()) {
+    if (signalImpl->Aborted()) {
       AbortStream(aCx, body);
     } else if (!IsFollowing()) {
-      Follow(signal);
+      Follow(signalImpl);
     }
   }
 

dom/fetch/Fetch.h

@@ -249,8 +249,8 @@ public:
     mBodyUsed = true;
   }
 
-  virtual AbortSignal*
+  virtual AbortSignalImpl*
-  GetSignal() const = 0;
+  GetSignalImpl() const = 0;
 
   // AbortFollower
   void

dom/fetch/FetchConsumer.cpp

@@ -338,7 +338,7 @@ template <class Derived>
 FetchBodyConsumer<Derived>::Create(nsIGlobalObject* aGlobal,
                                    nsIEventTarget* aMainThreadEventTarget,
                                    FetchBody<Derived>* aBody,
-                                   AbortSignal* aSignal,
+                                   AbortSignalImpl* aSignalImpl,
                                    FetchConsumeType aType,
                                    ErrorResult& aRv)
 {
@@ -406,8 +406,8 @@ FetchBodyConsumer<Derived>::Create(nsIGlobalObject* aGlobal,
     return nullptr;
   }
 
-  if (aSignal) {
+  if (aSignalImpl) {
-    consumer->Follow(aSignal);
+    consumer->Follow(aSignalImpl);
   }
 
   return promise.forget();

dom/fetch/FetchConsumer.h

@@ -39,7 +39,7 @@ public:
   Create(nsIGlobalObject* aGlobal,
          nsIEventTarget* aMainThreadEventTarget,
          FetchBody<Derived>* aBody,
-         AbortSignal* aSignal,
+         AbortSignalImpl* aSignalImpl,
          FetchConsumeType aType,
          ErrorResult& aRv);
 

dom/fetch/FetchDriver.cpp

@@ -362,7 +362,7 @@ FetchDriver::~FetchDriver()
 }
 
 nsresult
-FetchDriver::Fetch(AbortSignal* aSignal, FetchDriverObserver* aObserver)
+FetchDriver::Fetch(AbortSignalImpl* aSignalImpl, FetchDriverObserver* aObserver)
 {
   AssertIsOnMainThread();
 #ifdef DEBUG
@@ -391,13 +391,13 @@ FetchDriver::Fetch(AbortSignal* aSignal, FetchDriverObserver* aObserver)
 
   // If the signal is aborted, it's time to inform the observer and terminate
   // the operation.
-  if (aSignal) {
+  if (aSignalImpl) {
-    if (aSignal->Aborted()) {
+    if (aSignalImpl->Aborted()) {
       Abort();
       return NS_OK;
     }
 
-    Follow(aSignal);
+    Follow(aSignalImpl);
   }
 
   rv = HttpFetch(mRequest->GetPreferredAlternativeDataType());

dom/fetch/FetchDriver.h

@@ -113,7 +113,7 @@ public:
               PerformanceStorage* aPerformanceStorage,
               bool aIsTrackingFetch);
 
-  nsresult Fetch(AbortSignal* aSignal,
+  nsresult Fetch(AbortSignalImpl* aSignalImpl,
                  FetchDriverObserver* aObserver);
 
   void

dom/fetch/FetchObserver.cpp

@@ -27,12 +27,12 @@ NS_IMPL_ADDREF_INHERITED(FetchObserver, DOMEventTargetHelper)
 NS_IMPL_RELEASE_INHERITED(FetchObserver, DOMEventTargetHelper)
 
 FetchObserver::FetchObserver(nsIGlobalObject* aGlobal,
-                             AbortSignal* aSignal)
+                             AbortSignalImpl* aSignalImpl)
   : DOMEventTargetHelper(aGlobal)
   , mState(FetchState::Requesting)
 {
-  if (aSignal) {
+  if (aSignalImpl) {
-    Follow(aSignal);
+    Follow(aSignalImpl);
   }
 }
 

dom/fetch/FetchObserver.h

@@ -21,7 +21,7 @@ public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(FetchObserver, DOMEventTargetHelper)
 
-  FetchObserver(nsIGlobalObject* aGlobal, AbortSignal* aSignal);
+  FetchObserver(nsIGlobalObject* aGlobal, AbortSignalImpl* aSignalImpl);
 
   JSObject*
   WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;

dom/fetch/Request.cpp

@@ -64,7 +64,7 @@ Request::Request(nsIGlobalObject* aOwner, InternalRequest* aRequest,
   if (aSignal) {
     // If we don't have a signal as argument, we will create it when required by
     // content, otherwise the Request's signal must follow what has been passed.
-    mSignal = new AbortSignal(aSignal->Aborted());
+    mSignal = new AbortSignal(aOwner, aSignal->Aborted());
     if (!mSignal->Aborted()) {
       mSignal->Follow(aSignal);
     }
@@ -626,14 +626,14 @@ AbortSignal*
 Request::GetOrCreateSignal()
 {
   if (!mSignal) {
-    mSignal = new AbortSignal(false);
+    mSignal = new AbortSignal(mOwner, false);
   }
 
   return mSignal;
 }
 
-AbortSignal*
+AbortSignalImpl*
-Request::GetSignal() const
+Request::GetSignalImpl() const
 {
   return mSignal;
 }

dom/fetch/Request.h

@@ -167,9 +167,9 @@ public:
   AbortSignal*
   GetOrCreateSignal();
 
-  // This can return a null AbortSignal.
+  // This can return a null AbortSignalImpl.
-  AbortSignal*
+  AbortSignalImpl*
-  GetSignal() const override;
+  GetSignalImpl() const override;
 
 private:
   ~Request();

dom/fetch/Response.cpp

@@ -37,7 +37,7 @@ NS_IMPL_CYCLE_COLLECTION_CLASS(Response)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Response)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mOwner)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mHeaders)
-  NS_IMPL_CYCLE_COLLECTION_UNLINK(mSignal)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mSignalImpl)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mFetchStreamReader)
 
   tmp->mReadableStreamBody = nullptr;
@@ -49,7 +49,7 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Response)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOwner)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mHeaders)
-  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSignal)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSignalImpl)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFetchStreamReader)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
@@ -66,10 +66,10 @@ NS_INTERFACE_MAP_END
 
 Response::Response(nsIGlobalObject* aGlobal,
                    InternalResponse* aInternalResponse,
-                   AbortSignal* aSignal)
+                   AbortSignalImpl* aSignalImpl)
   : FetchBody<Response>(aGlobal)
   , mInternalResponse(aInternalResponse)
-  , mSignal(aSignal)
+  , mSignalImpl(aSignalImpl)
 {
   MOZ_ASSERT(aInternalResponse->Headers()->Guard() == HeadersGuardEnum::Immutable ||
              aInternalResponse->Headers()->Guard() == HeadersGuardEnum::Response);
@@ -344,7 +344,7 @@ Response::Clone(JSContext* aCx, ErrorResult& aRv)
       ? InternalResponse::eDontCloneInputStream
       : InternalResponse::eCloneInputStream);
 
-  RefPtr<Response> response = new Response(mOwner, ir, mSignal);
+  RefPtr<Response> response = new Response(mOwner, ir, GetSignalImpl());
 
   if (body) {
     // Maybe we have a body, but we receive null from MaybeTeeReadableStreamBody
@@ -387,7 +387,7 @@ Response::CloneUnfiltered(JSContext* aCx, ErrorResult& aRv)
       : InternalResponse::eCloneInputStream);
 
   RefPtr<InternalResponse> ir = clone->Unfiltered();
-  RefPtr<Response> ref = new Response(mOwner, ir, mSignal);
+  RefPtr<Response> ref = new Response(mOwner, ir, GetSignalImpl());
 
   if (body) {
     // Maybe we have a body, but we receive null from MaybeTeeReadableStreamBody

dom/fetch/Response.h

@@ -34,7 +34,7 @@ class Response final : public nsISupports
 
 public:
   Response(nsIGlobalObject* aGlobal, InternalResponse* aInternalResponse,
-           AbortSignal* aSignal);
+           AbortSignalImpl* aSignalImpl);
 
   Response(const Response& aOther) = delete;
 
@@ -140,10 +140,10 @@ public:
   already_AddRefed<InternalResponse>
   GetInternalResponse() const;
 
-  AbortSignal*
+  AbortSignalImpl*
-  GetSignal() const override
+  GetSignalImpl() const override
   {
-    return mSignal;
+    return mSignalImpl;
   }
 
 private:
@@ -152,7 +152,7 @@ private:
   RefPtr<InternalResponse> mInternalResponse;
   // Lazily created
   RefPtr<Headers> mHeaders;
-  RefPtr<AbortSignal> mSignal;
+  RefPtr<AbortSignalImpl> mSignalImpl;
 };
 
 } // namespace dom