From e1a0b51543d35ed68aa9ad46373ec7448234ae3b Mon Sep 17 00:00:00 2001 From: Andrea Marchesini Date: Sun, 26 Aug 2018 14:16:21 +0200 Subject: [PATCH] Bug 1478101 - Split AbortSignal in 2 classes: AbortSignal and AbortSignalImpl, r=bz --- dom/abort/AbortSignal.cpp | 87 +++++++++++++++---------- dom/abort/AbortSignal.h | 51 ++++++++++----- dom/fetch/Fetch.cpp | 126 ++++++++++++++++++++++-------------- dom/fetch/Fetch.h | 4 +- dom/fetch/FetchConsumer.cpp | 6 +- dom/fetch/FetchConsumer.h | 2 +- dom/fetch/FetchDriver.cpp | 8 +-- dom/fetch/FetchDriver.h | 2 +- dom/fetch/FetchObserver.cpp | 6 +- dom/fetch/FetchObserver.h | 2 +- dom/fetch/Request.cpp | 8 +-- dom/fetch/Request.h | 6 +- dom/fetch/Response.cpp | 12 ++-- dom/fetch/Response.h | 10 +-- 14 files changed, 196 insertions(+), 134 deletions(-) diff --git a/dom/abort/AbortSignal.cpp b/dom/abort/AbortSignal.cpp index e2165d0eda15..0ff2da050b27 100644 --- a/dom/abort/AbortSignal.cpp +++ b/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) -{} - -AbortSignal::AbortSignal(bool aAborted) - : mAborted(aAborted) + , AbortSignalImpl(aAborted) {} JSObject* @@ -44,22 +89,10 @@ AbortSignal::WrapObject(JSContext* aCx, JS::Handle aGivenProto) return AbortSignal_Binding::Wrap(aCx, this, aGivenProto); } -bool -AbortSignal::Aborted() const -{ - return mAborted; -} - void AbortSignal::Abort() { - MOZ_ASSERT(!mAborted); - mAborted = true; - - // Let's inform the followers. - for (uint32_t i = 0; i < mFollowers.Length(); ++i) { - mFollowers[i]->Abort(); - } + AbortSignalImpl::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); diff --git a/dom/abort/AbortSignal.h b/dom/abort/AbortSignal.h index e50c99ea6f3b..e3560c04fe02 100644 --- a/dom/abort/AbortSignal.h +++ b/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 mFollowingSignal; + // Subclasses of AbortFollower must Traverse/Unlink this member. + RefPtr mFollowingSignal; }; -class AbortSignal final : public DOMEventTargetHelper - , public AbortFollower +// Any subclass of this class must Traverse/Unlink mFollowingSignal. +class AbortSignalImpl : public AbortFollower + , public nsISupports { public: - NS_DECL_ISUPPORTS_INHERITED - NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(AbortSignal, DOMEventTargetHelper) - - AbortSignal(nsIGlobalObject* aGlobalObject, bool aAborted); - explicit AbortSignal(bool aAborted); - - JSObject* - WrapObject(JSContext* aCx, JS::Handle aGivenProto) override; + explicit AbortSignalImpl(bool aAborted); bool Aborted() const; @@ -54,23 +51,43 @@ public: void Abort() override; - IMPL_EVENT_HANDLER(abort); - void AddFollower(AbortFollower* aFollower); void RemoveFollower(AbortFollower* aFollower); -private: - ~AbortSignal() = default; +protected: + virtual ~AbortSignalImpl() = default; +private: // Raw pointers. AbortFollower unregisters itself in the DTOR. nsTArray 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 aGivenProto) override; + + IMPL_EVENT_HANDLER(abort); + + void + Abort() override; + +private: + ~AbortSignal() = default; +}; + } // dom namespace } // mozilla namespace diff --git a/dom/fetch/Fetch.cpp b/dom/fetch/Fetch.cpp index 6450bddaac37..036f21eced2a 100644 --- a/dom/fetch/Fetch.cpp +++ b/dom/fetch/Fetch.cpp @@ -74,21 +74,44 @@ AbortStream(JSContext* aCx, JS::Handle 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 mSignalMainThread; + RefPtr mSignalImplMainThread; // The main-thread event target for runnable dispatching. nsCOMPtr 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 - // AbortSignal on main-thread. + // This runnable propagates changes from the AbortSignalImpl on workers to the + // AbortSignalImpl on main-thread. class AbortSignalProxyRunnable final : public Runnable { RefPtr mProxy; @@ -103,8 +126,9 @@ class AbortSignalProxy final : public AbortFollower Run() override { MOZ_ASSERT(NS_IsMainThread()); - AbortSignal* signal = mProxy->GetOrCreateSignalForMainThread(); - signal->Abort(); + AbortSignalImpl* signalImpl = + 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* - GetOrCreateSignalForMainThread() + AbortSignalImpl* + GetOrCreateSignalImplForMainThread() { MOZ_ASSERT(NS_IsMainThread()); - if (!mSignalMainThread) { - mSignalMainThread = new AbortSignal(mAborted); + if (!mSignalImplMainThread) { + mSignalImplMainThread = new AbortSignalMainThread(mAborted); } - return mSignalMainThread; + return mSignalImplMainThread; } - AbortSignal* - GetSignalForTargetThread() + AbortSignalImpl* + GetSignalImplForTargetThread() { return mFollowingSignal; } @@ -154,8 +179,8 @@ private: ~AbortSignalProxy() { NS_ProxyRelease( - "AbortSignalProxy::mSignalMainThread", - mMainThreadEventTarget, mSignalMainThread.forget()); + "AbortSignalProxy::mSignalImplMainThread", + mMainThreadEventTarget, mSignalImplMainThread.forget()); } }; @@ -173,7 +198,7 @@ public: // Returns null if worker is shutting down. static already_AddRefed Create(WorkerPrivate* aWorkerPrivate, Promise* aPromise, - AbortSignal* aSignal, FetchObserver* aObserver) + AbortSignalImpl* aSignalImpl, FetchObserver* aObserver) { MOZ_ASSERT(aWorkerPrivate); aWorkerPrivate->AssertIsOnWorkerThread(); @@ -184,9 +209,10 @@ public: } RefPtr signalProxy; - if (aSignal) { + if (aSignalImpl) { signalProxy = - new AbortSignalProxy(aSignal, aWorkerPrivate->MainThreadEventTarget()); + new AbortSignalProxy(aSignalImpl, + aWorkerPrivate->MainThreadEventTarget()); } RefPtr 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 mPromise; RefPtr mResponse; RefPtr mFetchObserver; - RefPtr mSignal; + RefPtr mSignalImpl; const bool mMozErrors; nsCOMPtr 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 signal = mResolver->GetAbortSignalForMainThread(); + RefPtr 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 r = request->GetInternalRequest(); - RefPtr signal = request->GetSignal(); + RefPtr 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 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 resolver = - new MainThreadFetchResolver(p, observer, signal, request->MozErrors()); + new MainThreadFetchResolver(p, observer, signalImpl, + request->MozErrors()); RefPtr 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 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 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 FetchBody::ConsumeBody(JSContext* aCx, FetchConsumeType aType, ErrorResult& aRv) { - RefPtr signal = DerivedClass()->GetSignal(); - if (signal && signal->Aborted()) { + RefPtr signalImpl = DerivedClass()->GetSignalImpl(); + if (signalImpl && signalImpl->Aborted()) { aRv.Throw(NS_ERROR_DOM_ABORT_ERR); return nullptr; } @@ -1170,7 +1198,7 @@ FetchBody::ConsumeBody(JSContext* aCx, FetchConsumeType aType, RefPtr promise = FetchBodyConsumer::Create(global, mMainThreadEventTarget, this, - signal, aType, aRv); + signalImpl, aType, aRv); if (NS_WARN_IF(aRv.Failed())) { return nullptr; } @@ -1224,17 +1252,17 @@ FetchBody::SetReadableStreamBody(JSContext* aCx, JSObject* aBody) MOZ_ASSERT(aBody); mReadableStreamBody = aBody; - RefPtr signal = DerivedClass()->GetSignal(); - if (!signal) { + RefPtr signalImpl = DerivedClass()->GetSignalImpl(); + if (!signalImpl) { return; } - bool aborted = signal->Aborted(); + bool aborted = signalImpl->Aborted(); if (aborted) { JS::Rooted body(aCx, mReadableStreamBody); AbortStream(aCx, body); } else if (!IsFollowing()) { - Follow(signal); + Follow(signalImpl); } } @@ -1282,12 +1310,12 @@ FetchBody::GetBody(JSContext* aCx, } } - RefPtr signal = DerivedClass()->GetSignal(); - if (signal) { - if (signal->Aborted()) { + RefPtr signalImpl = DerivedClass()->GetSignalImpl(); + if (signalImpl) { + if (signalImpl->Aborted()) { AbortStream(aCx, body); } else if (!IsFollowing()) { - Follow(signal); + Follow(signalImpl); } } diff --git a/dom/fetch/Fetch.h b/dom/fetch/Fetch.h index d6567fc7a41e..35e84ddfce43 100644 --- a/dom/fetch/Fetch.h +++ b/dom/fetch/Fetch.h @@ -249,8 +249,8 @@ public: mBodyUsed = true; } - virtual AbortSignal* - GetSignal() const = 0; + virtual AbortSignalImpl* + GetSignalImpl() const = 0; // AbortFollower void diff --git a/dom/fetch/FetchConsumer.cpp b/dom/fetch/FetchConsumer.cpp index d92b8a647582..c04921695bc3 100644 --- a/dom/fetch/FetchConsumer.cpp +++ b/dom/fetch/FetchConsumer.cpp @@ -338,7 +338,7 @@ template FetchBodyConsumer::Create(nsIGlobalObject* aGlobal, nsIEventTarget* aMainThreadEventTarget, FetchBody* aBody, - AbortSignal* aSignal, + AbortSignalImpl* aSignalImpl, FetchConsumeType aType, ErrorResult& aRv) { @@ -406,8 +406,8 @@ FetchBodyConsumer::Create(nsIGlobalObject* aGlobal, return nullptr; } - if (aSignal) { - consumer->Follow(aSignal); + if (aSignalImpl) { + consumer->Follow(aSignalImpl); } return promise.forget(); diff --git a/dom/fetch/FetchConsumer.h b/dom/fetch/FetchConsumer.h index e02b2eaf7fe1..1bc0dac2b49b 100644 --- a/dom/fetch/FetchConsumer.h +++ b/dom/fetch/FetchConsumer.h @@ -39,7 +39,7 @@ public: Create(nsIGlobalObject* aGlobal, nsIEventTarget* aMainThreadEventTarget, FetchBody* aBody, - AbortSignal* aSignal, + AbortSignalImpl* aSignalImpl, FetchConsumeType aType, ErrorResult& aRv); diff --git a/dom/fetch/FetchDriver.cpp b/dom/fetch/FetchDriver.cpp index 0845440595ba..320ba81a1f58 100644 --- a/dom/fetch/FetchDriver.cpp +++ b/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 (aSignal->Aborted()) { + if (aSignalImpl) { + if (aSignalImpl->Aborted()) { Abort(); return NS_OK; } - Follow(aSignal); + Follow(aSignalImpl); } rv = HttpFetch(mRequest->GetPreferredAlternativeDataType()); diff --git a/dom/fetch/FetchDriver.h b/dom/fetch/FetchDriver.h index 64d01093e03a..315a10fc8944 100644 --- a/dom/fetch/FetchDriver.h +++ b/dom/fetch/FetchDriver.h @@ -113,7 +113,7 @@ public: PerformanceStorage* aPerformanceStorage, bool aIsTrackingFetch); - nsresult Fetch(AbortSignal* aSignal, + nsresult Fetch(AbortSignalImpl* aSignalImpl, FetchDriverObserver* aObserver); void diff --git a/dom/fetch/FetchObserver.cpp b/dom/fetch/FetchObserver.cpp index 0e7afd18f0ec..9fd117857f74 100644 --- a/dom/fetch/FetchObserver.cpp +++ b/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) { - Follow(aSignal); + if (aSignalImpl) { + Follow(aSignalImpl); } } diff --git a/dom/fetch/FetchObserver.h b/dom/fetch/FetchObserver.h index bd77f03633a0..9e2e8a11e5da 100644 --- a/dom/fetch/FetchObserver.h +++ b/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 aGivenProto) override; diff --git a/dom/fetch/Request.cpp b/dom/fetch/Request.cpp index 64686a0b82a4..c2cc685eaebf 100644 --- a/dom/fetch/Request.cpp +++ b/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* -Request::GetSignal() const +AbortSignalImpl* +Request::GetSignalImpl() const { return mSignal; } diff --git a/dom/fetch/Request.h b/dom/fetch/Request.h index abad76958315..2fd9f436ed35 100644 --- a/dom/fetch/Request.h +++ b/dom/fetch/Request.h @@ -167,9 +167,9 @@ public: AbortSignal* GetOrCreateSignal(); - // This can return a null AbortSignal. - AbortSignal* - GetSignal() const override; + // This can return a null AbortSignalImpl. + AbortSignalImpl* + GetSignalImpl() const override; private: ~Request(); diff --git a/dom/fetch/Response.cpp b/dom/fetch/Response.cpp index f16997a608be..b64d31ad37ab 100644 --- a/dom/fetch/Response.cpp +++ b/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(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 = new Response(mOwner, ir, mSignal); + RefPtr 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 ir = clone->Unfiltered(); - RefPtr ref = new Response(mOwner, ir, mSignal); + RefPtr ref = new Response(mOwner, ir, GetSignalImpl()); if (body) { // Maybe we have a body, but we receive null from MaybeTeeReadableStreamBody diff --git a/dom/fetch/Response.h b/dom/fetch/Response.h index 18777acb9622..d650b61361d8 100644 --- a/dom/fetch/Response.h +++ b/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 GetInternalResponse() const; - AbortSignal* - GetSignal() const override + AbortSignalImpl* + GetSignalImpl() const override { - return mSignal; + return mSignalImpl; } private: @@ -152,7 +152,7 @@ private: RefPtr mInternalResponse; // Lazily created RefPtr mHeaders; - RefPtr mSignal; + RefPtr mSignalImpl; }; } // namespace dom