From b52731f9e00920ad9e750069bf5e2f4547cb0893 Mon Sep 17 00:00:00 2001 From: Brian Smith Date: Thu, 18 Aug 2022 16:30:38 -0500 Subject: Issue #1990 - Part 1 - EventSource for workers - Mozilla Bug 1267903 --- dom/base/EventSource.cpp | 1457 +++++++++++++++++++++++++++++++---------- dom/base/EventSource.h | 214 ++---- dom/webidl/EventSource.webidl | 3 +- 3 files changed, 1139 insertions(+), 535 deletions(-) diff --git a/dom/base/EventSource.cpp b/dom/base/EventSource.cpp index cd3672c74f..f4aad9ab49 100644 --- a/dom/base/EventSource.cpp +++ b/dom/base/EventSource.cpp @@ -13,7 +13,10 @@ #include "mozilla/dom/MessageEvent.h" #include "mozilla/dom/MessageEventBinding.h" #include "mozilla/dom/ScriptSettings.h" - +#include "mozilla/dom/WorkerPrivate.h" +#include "mozilla/dom/WorkerRunnable.h" +#include "mozilla/dom/WorkerScope.h" +#include "mozilla/UniquePtrExtensions.h" #include "nsAutoPtr.h" #include "nsNetUtil.h" #include "nsIAuthPrompt.h" @@ -30,6 +33,7 @@ #include "nsIObserverService.h" #include "nsIScriptObjectPrincipal.h" #include "nsJSUtils.h" +#include "nsIThreadRetargetableRequest.h" #include "nsIAsyncVerifyRedirectCallback.h" #include "nsIScriptError.h" #include "mozilla/dom/EncodingUtils.h" @@ -44,6 +48,8 @@ namespace mozilla { namespace dom { +using namespace workers; + #define REPLACEMENT_CHAR (char16_t)0xFFFD #define BOM_CHAR (char16_t)0xFEFF #define SPACE_CHAR (char16_t)0x0020 @@ -51,112 +57,379 @@ namespace dom { #define LF_CHAR (char16_t)0x000A #define COLON_CHAR (char16_t)0x003A -#define DEFAULT_BUFFER_SIZE 4096 - // Reconnection time related values in milliseconds. The default one is equal // to the default value of the pref dom.server-events.default-reconnection-time #define MIN_RECONNECTION_TIME_VALUE 500 #define DEFAULT_RECONNECTION_TIME_VALUE 5000 #define MAX_RECONNECTION_TIME_VALUE PR_IntervalToMilliseconds(DELAY_INTERVAL_LIMIT) -EventSource::EventSource(nsPIDOMWindowInner* aOwnerWindow) : - DOMEventTargetHelper(aOwnerWindow), - mStatus(PARSE_STATE_OFF), - mFrozen(false), - mErrorLoadOnRedirect(false), - mGoingToDispatchAllMessages(false), - mWithCredentials(false), - mWaitingForOnStopRequest(false), - mLastConvertionResult(NS_OK), - mReadyState(CONNECTING), - mScriptLine(0), - mScriptColumn(0), - mInnerWindowID(0) -{ -} - -EventSource::~EventSource() +class EventSourceImpl final : public nsIObserver + , public nsIStreamListener + , public nsIChannelEventSink + , public nsIInterfaceRequestor + , public nsSupportsWeakReference + , public nsIEventTarget + , public nsIThreadRetargetableStreamListener { - Close(); -} - -//----------------------------------------------------------------------------- -// EventSource::nsISupports -//----------------------------------------------------------------------------- +public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIOBSERVER + NS_DECL_NSIREQUESTOBSERVER + NS_DECL_NSISTREAMLISTENER + NS_DECL_NSICHANNELEVENTSINK + NS_DECL_NSIINTERFACEREQUESTOR + NS_DECL_NSIEVENTTARGET + NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER + + explicit EventSourceImpl(EventSource* aEventSource); + + enum { + CONNECTING = 0U, + OPEN = 1U, + CLOSED = 2U + }; + + void Close(); + + void Init(nsIPrincipal* aPrincipal, const nsAString& aURL, ErrorResult& aRv); + + nsresult GetBaseURI(nsIURI** aBaseURI); + + void SetupHttpChannel(); + nsresult SetupReferrerPolicy(); + nsresult InitChannelAndRequestEventSource(); + nsresult ResetConnection(); + void ResetDecoder(); + nsresult SetReconnectionTimeout(); + + void AnnounceConnection(); + void DispatchAllMessageEvents(); + nsresult RestartConnection(); + void ReestablishConnection(); + void DispatchFailConnection(); + void FailConnection(); + + nsresult Thaw(); + nsresult Freeze(); + + static void TimerCallback(nsITimer* aTimer, void* aClosure); + + nsresult PrintErrorOnConsole(const char* aBundleURI, + const char16_t* aError, + const char16_t** aFormatStrings, + uint32_t aFormatStringsLen); + nsresult ConsoleError(); + + static nsresult StreamReaderFunc(nsIInputStream* aInputStream, + void* aClosure, + const char* aFromRawSegment, + uint32_t aToOffset, + uint32_t aCount, + uint32_t* aWriteCount); + void ParseSegment(const char* aBuffer, uint32_t aLength); + nsresult SetFieldAndClear(); + nsresult ClearFields(); + nsresult ResetEvent(); + nsresult DispatchCurrentMessageEvent(); + nsresult ParseCharacter(char16_t aChr); + nsresult CheckHealthOfRequestCallback(nsIRequest* aRequestCallback); + nsresult OnRedirectVerifyCallback(nsresult result); + nsresult ParseURL(const nsAString& aURL); + nsresult AddWindowObservers(); + void RemoveWindowObservers(); + + void CloseInternal(); + void CleanupOnMainThread(); + void AddRefObject(); + void ReleaseObject(); + + bool RegisterWorkerHolder(); + void UnregisterWorkerHolder(); + + void AssertIsOnTargetThread() const + { + MOZ_ASSERT(IsTargetThread()); + } -NS_IMPL_CYCLE_COLLECTION_CLASS(EventSource) + bool IsTargetThread() const + { + return NS_IsMainThread() == mIsMainThread; + } -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(EventSource) - bool isBlack = tmp->IsBlack(); - if (isBlack || tmp->mWaitingForOnStopRequest) { - if (tmp->mListenerManager) { - tmp->mListenerManager->MarkForCC(); - } - if (!isBlack && tmp->PreservingWrapper()) { - // This marks the wrapper black. - tmp->GetWrapper(); + uint16_t ReadyState() + { + if (mEventSource) { + MutexAutoLock lock(mMutex); + return mEventSource->mReadyState; } - return true; + // EventSourceImpl keeps EventSource alive. If mEventSource is null, it + // means that the EventSource has been closed. + return CLOSED; } -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(EventSource) - return tmp->IsBlack(); -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END + void SetReadyState(uint16_t aReadyState) + { + MOZ_ASSERT(mEventSource); + MutexAutoLock lock(mMutex); + mEventSource->mReadyState = aReadyState; + } -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(EventSource) - return tmp->IsBlack(); -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END + bool IsFrozen() + { + MutexAutoLock lock(mMutex); + return mFrozen; + } -NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(EventSource, - DOMEventTargetHelper) -NS_IMPL_CYCLE_COLLECTION_TRACE_END + void SetFrozen(bool aFrozen) + { + MutexAutoLock lock(mMutex); + mFrozen = aFrozen; + } -NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(EventSource, - DOMEventTargetHelper) - NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSrc) - NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLoadGroup) - NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mHttpChannel) - NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTimer) - NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mUnicodeDecoder) -NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + bool IsClosed() + { + return ReadyState() == CLOSED; + } + + RefPtr mEventSource; + + /** + * A simple state machine used to manage the event-source's line buffer + * + * PARSE_STATE_OFF -> PARSE_STATE_BEGIN_OF_STREAM + * + * PARSE_STATE_BEGIN_OF_STREAM -> PARSE_STATE_BOM_WAS_READ | + * PARSE_STATE_CR_CHAR | + * PARSE_STATE_BEGIN_OF_LINE | + * PARSE_STATE_COMMENT | + * PARSE_STATE_FIELD_NAME + * + * PARSE_STATE_BOM_WAS_READ -> PARSE_STATE_CR_CHAR | + * PARSE_STATE_BEGIN_OF_LINE | + * PARSE_STATE_COMMENT | + * PARSE_STATE_FIELD_NAME + * + * PARSE_STATE_CR_CHAR -> PARSE_STATE_CR_CHAR | + * PARSE_STATE_COMMENT | + * PARSE_STATE_FIELD_NAME | + * PARSE_STATE_BEGIN_OF_LINE + * + * PARSE_STATE_COMMENT -> PARSE_STATE_CR_CHAR | + * PARSE_STATE_BEGIN_OF_LINE + * + * PARSE_STATE_FIELD_NAME -> PARSE_STATE_CR_CHAR | + * PARSE_STATE_BEGIN_OF_LINE | + * PARSE_STATE_FIRST_CHAR_OF_FIELD_VALUE + * + * PARSE_STATE_FIRST_CHAR_OF_FIELD_VALUE -> PARSE_STATE_FIELD_VALUE | + * PARSE_STATE_CR_CHAR | + * PARSE_STATE_BEGIN_OF_LINE + * + * PARSE_STATE_FIELD_VALUE -> PARSE_STATE_CR_CHAR | + * PARSE_STATE_BEGIN_OF_LINE + * + * PARSE_STATE_BEGIN_OF_LINE -> PARSE_STATE_CR_CHAR | + * PARSE_STATE_COMMENT | + * PARSE_STATE_FIELD_NAME | + * PARSE_STATE_BEGIN_OF_LINE + * + * Whenever the parser find an empty line or the end-of-file + * it dispatches the stacked event. + * + */ + enum ParserStatus { + PARSE_STATE_OFF = 0, + PARSE_STATE_BEGIN_OF_STREAM, + PARSE_STATE_BOM_WAS_READ, + PARSE_STATE_CR_CHAR, + PARSE_STATE_COMMENT, + PARSE_STATE_FIELD_NAME, + PARSE_STATE_FIRST_CHAR_OF_FIELD_VALUE, + PARSE_STATE_FIELD_VALUE, + PARSE_STATE_BEGIN_OF_LINE + }; + + // Connection related data members. Should only be accessed on main thread. + nsCOMPtr mSrc; + uint32_t mReconnectionTime; // in ms + nsCOMPtr mPrincipal; + nsString mOrigin; + nsCOMPtr mTimer; + nsCOMPtr mHttpChannel; + + struct Message + { + nsString mEventName; + nsString mLastEventID; + nsString mData; + }; + + // Message related data members. May be set / initialized when initializing + // EventSourceImpl on target thread but should only be used on target thread. + nsString mLastEventID; + Message mCurrentMessage; + nsDeque mMessagesToDispatch; + ParserStatus mStatus; + nsCOMPtr mUnicodeDecoder; + nsresult mLastConvertionResult; + nsString mLastFieldName; + nsString mLastFieldValue; + + // EventSourceImpl internal states. + // The worker private where the EventSource is created. nullptr if created on + // main thread. (accessed on worker thread only) + WorkerPrivate* mWorkerPrivate; + // Holder to worker to keep worker alive. (accessed on worker thread only) + nsAutoPtr mWorkerHolder; + // This mutex protects mFrozen and mEventSource->mReadyState that are used in + // different threads. + mozilla::Mutex mMutex; + // Whether the window is frozen. May be set on main thread and read on target + // thread. Use mMutex to protect it before accessing it. + bool mFrozen; + // There are some messages are going to be dispatched when thaw. + bool mGoingToDispatchAllMessages; + // Whether the EventSource is run on main thread. + bool mIsMainThread; + // Whether the EventSourceImpl is going to be destroyed. + bool mIsClosing; + + // Event Source owner information: + // - the script file name + // - source code line number and column number where the Event Source object + // was constructed. + // - the ID of the inner window where the script lives. Note that this may not + // be the same as the Event Source owner window. + // These attributes are used for error reporting. Should only be accessed on + // target thread + nsString mScriptFile; + uint32_t mScriptLine; + uint32_t mScriptColumn; + uint64_t mInnerWindowID; + +private: + // prevent bad usage + EventSourceImpl(const EventSourceImpl& x) = delete; + EventSourceImpl& operator=(const EventSourceImpl& x) = delete; + ~EventSourceImpl() + { + if (IsClosed()) { + return; + } + // If we threw during Init we never called Close + SetReadyState(CLOSED); + CloseInternal(); + } +}; + +NS_IMPL_ISUPPORTS(EventSourceImpl, + nsIObserver, + nsIStreamListener, + nsIRequestObserver, + nsIChannelEventSink, + nsIInterfaceRequestor, + nsISupportsWeakReference, + nsIEventTarget, + nsIThreadRetargetableStreamListener) + +EventSourceImpl::EventSourceImpl(EventSource* aEventSource) + : mEventSource(aEventSource) + , mReconnectionTime(0) + , mStatus(PARSE_STATE_OFF) + , mLastConvertionResult(NS_OK) + , mMutex("EventSourceImpl::mMutex") + , mFrozen(false) + , mGoingToDispatchAllMessages(false) + , mIsMainThread(NS_IsMainThread()) + , mIsClosing(false) + , mScriptLine(0) + , mScriptColumn(0) + , mInnerWindowID(0) +{ + MOZ_ASSERT(mEventSource); + if (!mIsMainThread) { + mWorkerPrivate = GetCurrentThreadWorkerPrivate(); + MOZ_ASSERT(mWorkerPrivate); + mEventSource->mIsMainThread = false; + } + SetReadyState(CONNECTING); +} -NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(EventSource, - DOMEventTargetHelper) - tmp->Close(); -NS_IMPL_CYCLE_COLLECTION_UNLINK_END +class CleanupRunnable final : public WorkerMainThreadRunnable +{ +public: + explicit CleanupRunnable(EventSourceImpl* aEventSourceImpl) + : WorkerMainThreadRunnable(aEventSourceImpl->mWorkerPrivate, + NS_LITERAL_CSTRING("EventSource :: Cleanup")) + , mImpl(aEventSourceImpl) + { + mImpl->mWorkerPrivate->AssertIsOnWorkerThread(); + } -NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(EventSource) - NS_INTERFACE_MAP_ENTRY(nsIObserver) - NS_INTERFACE_MAP_ENTRY(nsIRequestObserver) - NS_INTERFACE_MAP_ENTRY(nsIStreamListener) - NS_INTERFACE_MAP_ENTRY(nsIChannelEventSink) - NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor) - NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) -NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + bool MainThreadRun() override + { + mImpl->CleanupOnMainThread(); + return true; + } -NS_IMPL_ADDREF_INHERITED(EventSource, DOMEventTargetHelper) -NS_IMPL_RELEASE_INHERITED(EventSource, DOMEventTargetHelper) +protected: + // Raw pointer because this runnable is sync. + EventSourceImpl* mImpl; +}; void -EventSource::DisconnectFromOwner() +EventSourceImpl::Close() { - DOMEventTargetHelper::DisconnectFromOwner(); - Close(); + if (IsClosed()) { + return; + } + SetReadyState(CLOSED); + // Asynchronously call CloseInternal to prevent EventSourceImpl from being + // synchronously destoryed while dispatching DOM event. + DebugOnly rv = + Dispatch(NewRunnableMethod(this, &EventSourceImpl::CloseInternal), + NS_DISPATCH_NORMAL); + MOZ_ASSERT(NS_SUCCEEDED(rv)); } void -EventSource::Close() +EventSourceImpl::CloseInternal() { - if (mReadyState == CLOSED) { + AssertIsOnTargetThread(); + MOZ_ASSERT(IsClosed()); + if (mIsClosing) { return; } + mIsClosing = true; + while (mMessagesToDispatch.GetSize() != 0) { + delete static_cast(mMessagesToDispatch.PopFront()); + } - nsCOMPtr os = mozilla::services::GetObserverService(); - if (os) { - os->RemoveObserver(this, DOM_WINDOW_DESTROYED_TOPIC); - os->RemoveObserver(this, DOM_WINDOW_FROZEN_TOPIC); - os->RemoveObserver(this, DOM_WINDOW_THAWED_TOPIC); + if (NS_IsMainThread()) { + CleanupOnMainThread(); + } else { + ErrorResult rv; + // run CleanupOnMainThread synchronously on main thread since it touches + // observers and members only can be accessed on main thread. + RefPtr runnable = new CleanupRunnable(this); + runnable->Dispatch(Killing, rv); + MOZ_ASSERT(!rv.Failed()); + UnregisterWorkerHolder(); + } + + SetFrozen(false); + ResetDecoder(); + mUnicodeDecoder = nullptr; + // UpdateDontKeepAlive() can release the object. Don't access to any members + // after it. + mEventSource->UpdateDontKeepAlive(); +} + +void EventSourceImpl::CleanupOnMainThread() +{ + AssertIsOnMainThread(); + if (mIsMainThread) { + RemoveWindowObservers(); } if (mTimer) { @@ -165,59 +438,57 @@ EventSource::Close() } ResetConnection(); - - ClearFields(); - - while (mMessagesToDispatch.GetSize() != 0) { - delete static_cast(mMessagesToDispatch.PopFront()); - } - + mPrincipal = nullptr; mSrc = nullptr; - mFrozen = false; - - mUnicodeDecoder = nullptr; - - mReadyState = CLOSED; } -nsresult -EventSource::Init(nsISupports* aOwner, - const nsAString& aURL, - bool aWithCredentials) +class InitRunnable final : public WorkerMainThreadRunnable { - if (mReadyState != CONNECTING) { - return NS_ERROR_DOM_SECURITY_ERR; +public: + explicit InitRunnable(EventSourceImpl* aEventSourceImpl, + const nsAString& aURL) + : WorkerMainThreadRunnable(aEventSourceImpl->mWorkerPrivate, + NS_LITERAL_CSTRING("EventSource :: Init")) + , mImpl(aEventSourceImpl) + , mURL(aURL) + { + mImpl->mWorkerPrivate->AssertIsOnWorkerThread(); } - nsCOMPtr sgo = do_QueryInterface(aOwner); - NS_ENSURE_STATE(sgo); - // XXXbz why are we checking this? This doesn't match anything in the spec. - nsCOMPtr scriptContext = sgo->GetContext(); - NS_ENSURE_STATE(scriptContext); - - nsCOMPtr scriptPrincipal = - do_QueryInterface(aOwner); - NS_ENSURE_STATE(scriptPrincipal); - nsCOMPtr principal = scriptPrincipal->GetPrincipal(); - NS_ENSURE_STATE(principal); + bool MainThreadRun() override + { + // Get principal from worker's owner document or from worker. + WorkerPrivate* wp = mImpl->mWorkerPrivate; + while (wp->GetParent()) { + wp = wp->GetParent(); + } + nsPIDOMWindowInner* window = wp->GetWindow(); + nsIDocument* doc = window ? window->GetExtantDoc() : nullptr; + nsCOMPtr principal = doc ? doc->NodePrincipal() : + wp->GetPrincipal(); + if (!principal) { + mRv = NS_ERROR_FAILURE; + return true; + } + ErrorResult rv; + mImpl->Init(principal, mURL, rv); + mRv = rv.StealNSResult(); + return true; + } - mPrincipal = principal; - mWithCredentials = aWithCredentials; + nsresult ErrorCode() const { return mRv; } - // The conditional here is historical and not necessarily sane. - if (JSContext *cx = nsContentUtils::GetCurrentJSContext()) { - nsJSUtils::GetCallingLocation(cx, mScriptFile, &mScriptLine, - &mScriptColumn); - mInnerWindowID = nsJSUtils::GetCurrentlyRunningCodeInnerWindowID(cx); - } +protected: + // Raw pointer because this runnable is sync. + EventSourceImpl* mImpl; + const nsAString& mURL; + nsresult mRv; +}; - // Get the load group for the page. When requesting we'll add ourselves to it. - // This way any pending requests will be automatically aborted if the user - // leaves the page. - nsCOMPtr doc = GetDocumentIfCurrent(); - if (doc) { - mLoadGroup = doc->GetDocumentLoadGroup(); - } +nsresult +EventSourceImpl::ParseURL(const nsAString& aURL) +{ + AssertIsOnMainThread(); // get the src nsCOMPtr baseURI; nsresult rv = GetBaseURI(getter_AddRefs(baseURI)); @@ -227,28 +498,79 @@ EventSource::Init(nsISupports* aOwner, rv = NS_NewURI(getter_AddRefs(srcURI), aURL, nullptr, baseURI); NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SYNTAX_ERR); - // we observe when the window freezes and thaws + nsAutoString origin; + rv = nsContentUtils::GetUTFOrigin(srcURI, origin); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoCString spec; + rv = srcURI->GetSpec(spec); + NS_ENSURE_SUCCESS(rv, rv); + + mEventSource->mOriginalURL = NS_ConvertUTF8toUTF16(spec); + mSrc = srcURI; + mOrigin = origin; + return NS_OK; +} + +nsresult +EventSourceImpl::AddWindowObservers() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(mIsMainThread); nsCOMPtr os = mozilla::services::GetObserverService(); NS_ENSURE_STATE(os); - rv = os->AddObserver(this, DOM_WINDOW_DESTROYED_TOPIC, true); + nsresult rv = os->AddObserver(this, DOM_WINDOW_DESTROYED_TOPIC, true); NS_ENSURE_SUCCESS(rv, rv); rv = os->AddObserver(this, DOM_WINDOW_FROZEN_TOPIC, true); NS_ENSURE_SUCCESS(rv, rv); rv = os->AddObserver(this, DOM_WINDOW_THAWED_TOPIC, true); NS_ENSURE_SUCCESS(rv, rv); + return NS_OK; +} - nsAutoString origin; - rv = nsContentUtils::GetUTFOrigin(srcURI, origin); - NS_ENSURE_SUCCESS(rv, rv); +void +EventSourceImpl::RemoveWindowObservers() +{ + AssertIsOnMainThread(); + MOZ_ASSERT(mIsMainThread); + nsCOMPtr os = mozilla::services::GetObserverService(); + if (os) { + os->RemoveObserver(this, DOM_WINDOW_DESTROYED_TOPIC); + os->RemoveObserver(this, DOM_WINDOW_FROZEN_TOPIC); + os->RemoveObserver(this, DOM_WINDOW_THAWED_TOPIC); + } +} - nsAutoCString spec; - rv = srcURI->GetSpec(spec); - NS_ENSURE_SUCCESS(rv, rv); +void +EventSourceImpl::Init(nsIPrincipal* aPrincipal, + const nsAString& aURL, + ErrorResult& aRv) +{ + AssertIsOnMainThread(); + MOZ_ASSERT(aPrincipal); + if (IsClosed()) { + return; + } + mPrincipal = aPrincipal; + aRv = ParseURL(aURL); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + // The conditional here is historical and not necessarily sane. + if (JSContext* cx = nsContentUtils::GetCurrentJSContext()) { + nsJSUtils::GetCallingLocation(cx, mScriptFile, &mScriptLine, + &mScriptColumn); + mInnerWindowID = nsJSUtils::GetCurrentlyRunningCodeInnerWindowID(cx); + } - mOriginalURL = NS_ConvertUTF8toUTF16(spec); - mSrc = srcURI; - mOrigin = origin; + if (mIsMainThread) { + // we observe when the window freezes and thaws + aRv = AddWindowObservers(); + if (NS_WARN_IF(aRv.Failed())) { + return; + } + } mReconnectionTime = Preferences::GetInt("dom.server-events.default-reconnection-time", @@ -260,61 +582,34 @@ EventSource::Init(nsISupports* aOwner, // url parameter, so we don't care about the InitChannelAndRequestEventSource // result. InitChannelAndRequestEventSource(); - - return NS_OK; -} - -/* virtual */ JSObject* -EventSource::WrapObject(JSContext* aCx, JS::Handle aGivenProto) -{ - return EventSourceBinding::Wrap(aCx, this, aGivenProto); -} - -/* static */ already_AddRefed -EventSource::Constructor(const GlobalObject& aGlobal, - const nsAString& aURL, - const EventSourceInit& aEventSourceInitDict, - ErrorResult& aRv) -{ - nsCOMPtr ownerWindow = - do_QueryInterface(aGlobal.GetAsSupports()); - if (!ownerWindow) { - aRv.Throw(NS_ERROR_UNEXPECTED); - return nullptr; - } - MOZ_ASSERT(ownerWindow->IsInnerWindow()); - - RefPtr eventSource = new EventSource(ownerWindow); - aRv = eventSource->Init(aGlobal.GetAsSupports(), aURL, - aEventSourceInitDict.mWithCredentials); - return eventSource.forget(); } //----------------------------------------------------------------------------- -// EventSource::nsIObserver +// EventSourceImpl::nsIObserver //----------------------------------------------------------------------------- NS_IMETHODIMP -EventSource::Observe(nsISupports* aSubject, - const char* aTopic, - const char16_t* aData) +EventSourceImpl::Observe(nsISupports* aSubject, + const char* aTopic, + const char16_t* aData) { - if (mReadyState == CLOSED) { + AssertIsOnMainThread(); + if (IsClosed()) { return NS_OK; } nsCOMPtr window = do_QueryInterface(aSubject); - if (!GetOwner() || window != GetOwner()) { + if (!mEventSource->GetOwner() || window != mEventSource->GetOwner()) { return NS_OK; } DebugOnly rv; if (strcmp(aTopic, DOM_WINDOW_FROZEN_TOPIC) == 0) { rv = Freeze(); - NS_ASSERTION(NS_SUCCEEDED(rv), "Freeze() failed"); + MOZ_ASSERT(NS_SUCCEEDED(rv), "Freeze() failed"); } else if (strcmp(aTopic, DOM_WINDOW_THAWED_TOPIC) == 0) { rv = Thaw(); - NS_ASSERTION(NS_SUCCEEDED(rv), "Thaw() failed"); + MOZ_ASSERT(NS_SUCCEEDED(rv), "Thaw() failed"); } else if (strcmp(aTopic, DOM_WINDOW_DESTROYED_TOPIC) == 0) { Close(); } @@ -323,13 +618,16 @@ EventSource::Observe(nsISupports* aSubject, } //----------------------------------------------------------------------------- -// EventSource::nsIStreamListener +// EventSourceImpl::nsIStreamListener //----------------------------------------------------------------------------- NS_IMETHODIMP -EventSource::OnStartRequest(nsIRequest *aRequest, - nsISupports *ctxt) +EventSourceImpl::OnStartRequest(nsIRequest* aRequest, nsISupports* aCtxt) { + AssertIsOnMainThread(); + if (IsClosed()) { + return NS_ERROR_ABORT; + } nsresult rv = CheckHealthOfRequestCallback(aRequest); NS_ENSURE_SUCCESS(rv, rv); @@ -364,88 +662,148 @@ EventSource::OnStartRequest(nsIRequest *aRequest, return NS_ERROR_ABORT; } - rv = NS_DispatchToMainThread(NewRunnableMethod(this, &EventSource::AnnounceConnection)); + if (!mIsMainThread) { + // Try to retarget to worker thread, otherwise fall back to main thread. + nsCOMPtr rr = do_QueryInterface(httpChannel); + if (rr) { + rv = rr->RetargetDeliveryTo(this); + NS_ENSURE_SUCCESS(rv, rv); + } + } + rv = Dispatch(NewRunnableMethod(this, &EventSourceImpl::AnnounceConnection), + NS_DISPATCH_NORMAL); NS_ENSURE_SUCCESS(rv, rv); - mStatus = PARSE_STATE_BEGIN_OF_STREAM; - return NS_OK; } // this method parses the characters as they become available instead of // buffering them. nsresult -EventSource::StreamReaderFunc(nsIInputStream *aInputStream, - void *aClosure, - const char *aFromRawSegment, - uint32_t aToOffset, - uint32_t aCount, - uint32_t *aWriteCount) +EventSourceImpl::StreamReaderFunc(nsIInputStream* aInputStream, + void* aClosure, + const char* aFromRawSegment, + uint32_t aToOffset, + uint32_t aCount, + uint32_t* aWriteCount) { - EventSource* thisObject = static_cast(aClosure); + EventSourceImpl* thisObject = static_cast(aClosure); + thisObject->AssertIsOnTargetThread(); if (!thisObject || !aWriteCount) { NS_WARNING("EventSource cannot read from stream: no aClosure or aWriteCount"); return NS_ERROR_FAILURE; } + thisObject->ParseSegment((const char*)aFromRawSegment, aCount); + *aWriteCount = aCount; + return NS_OK; +} - *aWriteCount = 0; - +void +EventSourceImpl::ParseSegment(const char* aBuffer, uint32_t aLength) +{ + AssertIsOnTargetThread(); + if (IsClosed()) { + return; + } int32_t srcCount, outCount; char16_t out[2]; - nsresult rv; - - const char *p = aFromRawSegment, - *end = aFromRawSegment + aCount; + const char* p = aBuffer; + const char* end = aBuffer + aLength; do { - srcCount = aCount - (p - aFromRawSegment); + srcCount = aLength - (p - aBuffer); outCount = 2; - thisObject->mLastConvertionResult = - thisObject->mUnicodeDecoder->Convert(p, &srcCount, out, &outCount); - MOZ_ASSERT(thisObject->mLastConvertionResult != NS_ERROR_ILLEGAL_INPUT); + mLastConvertionResult = + mUnicodeDecoder->Convert(p, &srcCount, out, &outCount); + MOZ_ASSERT(mLastConvertionResult != NS_ERROR_ILLEGAL_INPUT); for (int32_t i = 0; i < outCount; ++i) { - rv = thisObject->ParseCharacter(out[i]); - NS_ENSURE_SUCCESS(rv, rv); + nsresult rv = ParseCharacter(out[i]); + NS_ENSURE_SUCCESS_VOID(rv); } p = p + srcCount; } while (p < end && - thisObject->mLastConvertionResult != NS_PARTIAL_MORE_INPUT && - thisObject->mLastConvertionResult != NS_OK); - - *aWriteCount = aCount; - return NS_OK; + mLastConvertionResult != NS_PARTIAL_MORE_INPUT && + mLastConvertionResult != NS_OK); } +class DataAvailableRunnable final : public Runnable +{ + private: + RefPtr mEventSourceImpl; + UniquePtr mData; + uint32_t mLength; + public: + DataAvailableRunnable(EventSourceImpl* aEventSourceImpl, + UniquePtr aData, + uint32_t aLength) + : mEventSourceImpl(aEventSourceImpl) + , mData(Move(aData)) + , mLength(aLength) + { + } + + NS_IMETHOD Run() override + { + mEventSourceImpl->ParseSegment(mData.get(), mLength); + return NS_OK; + } +}; + NS_IMETHODIMP -EventSource::OnDataAvailable(nsIRequest *aRequest, - nsISupports *aContext, - nsIInputStream *aInputStream, - uint64_t aOffset, - uint32_t aCount) +EventSourceImpl::OnDataAvailable(nsIRequest* aRequest, + nsISupports* aContext, + nsIInputStream* aInputStream, + uint64_t aOffset, + uint32_t aCount) { + // Although we try to retarget OnDataAvailable to target thread, it may fail + // and fallback to main thread. NS_ENSURE_ARG_POINTER(aInputStream); + if (IsClosed()) { + return NS_ERROR_ABORT; + } nsresult rv = CheckHealthOfRequestCallback(aRequest); NS_ENSURE_SUCCESS(rv, rv); uint32_t totalRead; - return aInputStream->ReadSegments(EventSource::StreamReaderFunc, this, + if (IsTargetThread()) { + rv = aInputStream->ReadSegments(EventSourceImpl::StreamReaderFunc, this, aCount, &totalRead); + } else { + // This could be happened when fail to retarget to target thread and + // fallback to the main thread. + AssertIsOnMainThread(); + auto data = MakeUniqueFallible(aCount); + if (!data) { + return NS_ERROR_OUT_OF_MEMORY; + } + rv = aInputStream->Read(data.get(), aCount, &totalRead); + NS_ENSURE_SUCCESS(rv, rv); + MOZ_ASSERT(totalRead <= aCount, "EventSource read more than available!!"); + + nsCOMPtr dataAvailable = + new DataAvailableRunnable(this, Move(data), totalRead); + + MOZ_ASSERT(mWorkerPrivate); + rv = Dispatch(dataAvailable.forget(), NS_DISPATCH_NORMAL); + } + return rv; } NS_IMETHODIMP -EventSource::OnStopRequest(nsIRequest *aRequest, - nsISupports *aContext, - nsresult aStatusCode) +EventSourceImpl::OnStopRequest(nsIRequest* aRequest, + nsISupports* aContext, + nsresult aStatusCode) { - mWaitingForOnStopRequest = false; + AssertIsOnMainThread(); - if (mReadyState == CLOSED) { + if (IsClosed()) { return NS_ERROR_ABORT; } - + MOZ_ASSERT(mSrc); // "Network errors that prevents the connection from being established in the // first place (e.g. DNS errors), must cause the user agent to asynchronously // reestablish the connection. @@ -468,24 +826,25 @@ EventSource::OnStopRequest(nsIRequest *aRequest, nsresult rv = CheckHealthOfRequestCallback(aRequest); NS_ENSURE_SUCCESS(rv, rv); - ClearFields(); - - rv = NS_DispatchToMainThread(NewRunnableMethod(this, &EventSource::ReestablishConnection)); + rv = Dispatch( + NewRunnableMethod(this, &EventSourceImpl::ReestablishConnection), + NS_DISPATCH_NORMAL); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } //----------------------------------------------------------------------------- -// EventSource::nsIChannelEventSink +// EventSourceImpl::nsIChannelEventSink //----------------------------------------------------------------------------- NS_IMETHODIMP -EventSource::AsyncOnChannelRedirect(nsIChannel *aOldChannel, - nsIChannel *aNewChannel, - uint32_t aFlags, - nsIAsyncVerifyRedirectCallback *aCallback) +EventSourceImpl::AsyncOnChannelRedirect(nsIChannel* aOldChannel, + nsIChannel* aNewChannel, + uint32_t aFlags, + nsIAsyncVerifyRedirectCallback* aCallback) { + AssertIsOnMainThread(); nsCOMPtr aOldRequest = do_QueryInterface(aOldChannel); NS_PRECONDITION(aOldRequest, "Redirect from a null request?"); @@ -502,7 +861,7 @@ EventSource::AsyncOnChannelRedirect(nsIChannel *aOldChannel, (NS_SUCCEEDED(newURI->SchemeIs("http", &isValidScheme)) && isValidScheme) || (NS_SUCCEEDED(newURI->SchemeIs("https", &isValidScheme)) && isValidScheme); - rv = CheckInnerWindowCorrectness(); + rv = mEventSource->CheckInnerWindowCorrectness(); if (NS_FAILED(rv) || !isValidScheme) { DispatchFailConnection(); return NS_ERROR_DOM_SECURITY_ERR; @@ -528,13 +887,13 @@ EventSource::AsyncOnChannelRedirect(nsIChannel *aOldChannel, } //----------------------------------------------------------------------------- -// EventSource::nsIInterfaceRequestor +// EventSourceImpl::nsIInterfaceRequestor //----------------------------------------------------------------------------- NS_IMETHODIMP -EventSource::GetInterface(const nsIID & aIID, - void **aResult) +EventSourceImpl::GetInterface(const nsIID& aIID, void** aResult) { + AssertIsOnMainThread(); if (aIID.Equals(NS_GET_IID(nsIChannelEventSink))) { *aResult = static_cast(this); NS_ADDREF_THIS(); @@ -543,7 +902,7 @@ EventSource::GetInterface(const nsIID & aIID, if (aIID.Equals(NS_GET_IID(nsIAuthPrompt)) || aIID.Equals(NS_GET_IID(nsIAuthPrompt2))) { - nsresult rv = CheckInnerWindowCorrectness(); + nsresult rv = mEventSource->CheckInnerWindowCorrectness(); NS_ENSURE_SUCCESS(rv, NS_ERROR_UNEXPECTED); nsCOMPtr wwatch = @@ -554,8 +913,8 @@ EventSource::GetInterface(const nsIID & aIID, // of the dialogs works as it should when using tabs. nsCOMPtr window; - if (GetOwner()) { - window = GetOwner()->GetOuterWindow(); + if (mEventSource->GetOwner()) { + window = mEventSource->GetOwner()->GetOuterWindow(); } return wwatch->GetPrompt(window, aIID, aResult); @@ -564,9 +923,17 @@ EventSource::GetInterface(const nsIID & aIID, return QueryInterface(aIID, aResult); } +NS_IMETHODIMP +EventSourceImpl::IsOnCurrentThread(bool* aResult) +{ + *aResult = IsTargetThread(); + return NS_OK; +} + nsresult -EventSource::GetBaseURI(nsIURI **aBaseURI) +EventSourceImpl::GetBaseURI(nsIURI** aBaseURI) { + AssertIsOnMainThread(); NS_ENSURE_ARG_POINTER(aBaseURI); *aBaseURI = nullptr; @@ -574,7 +941,7 @@ EventSource::GetBaseURI(nsIURI **aBaseURI) nsCOMPtr baseURI; // first we try from document->GetBaseURI() - nsCOMPtr doc = GetDocumentIfCurrent(); + nsCOMPtr doc = mEventSource->GetDocumentIfCurrent(); if (doc) { baseURI = doc->GetBaseURI(); } @@ -592,8 +959,9 @@ EventSource::GetBaseURI(nsIURI **aBaseURI) } void -EventSource::SetupHttpChannel() +EventSourceImpl::SetupHttpChannel() { + AssertIsOnMainThread(); mHttpChannel->SetRequestMethod(NS_LITERAL_CSTRING("GET")); /* set the http request headers */ @@ -610,9 +978,10 @@ EventSource::SetupHttpChannel() } nsresult -EventSource::SetupReferrerPolicy() +EventSourceImpl::SetupReferrerPolicy() { - nsCOMPtr doc = GetDocumentIfCurrent(); + AssertIsOnMainThread(); + nsCOMPtr doc = mEventSource->GetDocumentIfCurrent(); if (doc) { nsresult rv = mHttpChannel->SetReferrerWithPolicy(doc->GetDocumentURI(), doc->GetReferrerPolicy()); @@ -623,9 +992,10 @@ EventSource::SetupReferrerPolicy() } nsresult -EventSource::InitChannelAndRequestEventSource() +EventSourceImpl::InitChannelAndRequestEventSource() { - if (mReadyState == CLOSED) { + AssertIsOnMainThread(); + if (IsClosed()) { return NS_ERROR_ABORT; } @@ -633,7 +1003,7 @@ EventSource::InitChannelAndRequestEventSource() (NS_SUCCEEDED(mSrc->SchemeIs("http", &isValidScheme)) && isValidScheme) || (NS_SUCCEEDED(mSrc->SchemeIs("https", &isValidScheme)) && isValidScheme); - nsresult rv = CheckInnerWindowCorrectness(); + nsresult rv = mEventSource->CheckInnerWindowCorrectness(); if (NS_FAILED(rv) || !isValidScheme) { DispatchFailConnection(); return NS_ERROR_DOM_SECURITY_ERR; @@ -642,24 +1012,25 @@ EventSource::InitChannelAndRequestEventSource() nsLoadFlags loadFlags; loadFlags = nsIRequest::LOAD_BACKGROUND | nsIRequest::LOAD_BYPASS_CACHE; - nsCOMPtr doc = GetDocumentIfCurrent(); + nsCOMPtr doc = mEventSource->GetDocumentIfCurrent(); nsSecurityFlags securityFlags = nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS; - if (mWithCredentials) { + if (mEventSource->mWithCredentials) { securityFlags |= nsILoadInfo::SEC_COOKIES_INCLUDE; } nsCOMPtr channel; // If we have the document, use it if (doc) { + nsCOMPtr loadGroup = doc->GetDocumentLoadGroup(); rv = NS_NewChannel(getter_AddRefs(channel), mSrc, doc, securityFlags, nsIContentPolicy::TYPE_INTERNAL_EVENTSOURCE, - mLoadGroup, // loadGroup + loadGroup, nullptr, // aCallbacks loadFlags); // aLoadFlags } else { @@ -669,7 +1040,7 @@ EventSource::InitChannelAndRequestEventSource() mPrincipal, securityFlags, nsIContentPolicy::TYPE_INTERNAL_EVENTSOURCE, - mLoadGroup, // loadGroup + nullptr, // loadGroup nullptr, // aCallbacks loadFlags); // aLoadFlags } @@ -698,18 +1069,17 @@ EventSource::InitChannelAndRequestEventSource() DispatchFailConnection(); return rv; } - mWaitingForOnStopRequest = true; + // Create the connection. Ask EventSource to hold reference until Close is + // called or network error is received. + mEventSource->UpdateMustKeepAlive(); return rv; } void -EventSource::AnnounceConnection() +EventSourceImpl::AnnounceConnection() { - if (mReadyState == CLOSED) { - return; - } - - if (mReadyState != CONNECTING) { + AssertIsOnTargetThread(); + if (ReadyState() != CONNECTING) { NS_WARNING("Unexpected mReadyState!!!"); return; } @@ -718,87 +1088,117 @@ EventSource::AnnounceConnection() // the readyState attribute to OPEN and queue a task to fire a simple event // named open at the EventSource object. - mReadyState = OPEN; + SetReadyState(OPEN); - nsresult rv = CheckInnerWindowCorrectness(); + nsresult rv = mEventSource->CheckInnerWindowCorrectness(); if (NS_FAILED(rv)) { return; } - - RefPtr event = NS_NewDOMEvent(this, nullptr, nullptr); - - // it doesn't bubble, and it isn't cancelable - event->InitEvent(NS_LITERAL_STRING("open"), false, false); - event->SetTrusted(true); - - rv = DispatchDOMEvent(nullptr, event, nullptr, nullptr); + rv = mEventSource->CreateAndDispatchSimpleEvent(NS_LITERAL_STRING("open")); if (NS_FAILED(rv)) { - NS_WARNING("Failed to dispatch the open event!!!"); + NS_WARNING("Failed to dispatch the error event!!!"); return; } } nsresult -EventSource::ResetConnection() +EventSourceImpl::ResetConnection() { + AssertIsOnMainThread(); if (mHttpChannel) { mHttpChannel->Cancel(NS_ERROR_ABORT); + mHttpChannel = nullptr; } + return NS_OK; +} +void +EventSourceImpl::ResetDecoder() +{ + AssertIsOnTargetThread(); if (mUnicodeDecoder) { mUnicodeDecoder->Reset(); } + mStatus = PARSE_STATE_OFF; mLastConvertionResult = NS_OK; + ClearFields(); +} - mHttpChannel = nullptr; - mStatus = PARSE_STATE_OFF; +class CallRestartConnection final : public WorkerMainThreadRunnable +{ +public: + explicit CallRestartConnection(EventSourceImpl* aEventSourceImpl) + : WorkerMainThreadRunnable( + aEventSourceImpl->mWorkerPrivate, + NS_LITERAL_CSTRING("EventSource :: RestartConnection")) + , mImpl(aEventSourceImpl) + { + mImpl->mWorkerPrivate->AssertIsOnWorkerThread(); + } - mReadyState = CONNECTING; + bool MainThreadRun() override + { + mImpl->RestartConnection(); + return true; + } + +protected: + // Raw pointer because this runnable is sync. + EventSourceImpl* mImpl; +}; +nsresult +EventSourceImpl::RestartConnection() +{ + AssertIsOnMainThread(); + nsresult rv = ResetConnection(); + NS_ENSURE_SUCCESS(rv, rv); + rv = SetReconnectionTimeout(); + NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } void -EventSource::ReestablishConnection() +EventSourceImpl::ReestablishConnection() { - if (mReadyState == CLOSED) { + AssertIsOnTargetThread(); + if (IsClosed()) { return; } - nsresult rv = ResetConnection(); - if (NS_FAILED(rv)) { - NS_WARNING("Failed to reset the connection!!!"); - return; + nsresult rv; + if (mIsMainThread) { + rv = RestartConnection(); + } else { + RefPtr runnable = new CallRestartConnection(this); + ErrorResult result; + runnable->Dispatch(Terminating, result); + MOZ_ASSERT(!result.Failed()); + rv = result.StealNSResult(); } - - rv = CheckInnerWindowCorrectness(); if (NS_FAILED(rv)) { return; } - RefPtr event = NS_NewDOMEvent(this, nullptr, nullptr); - - // it doesn't bubble, and it isn't cancelable - event->InitEvent(NS_LITERAL_STRING("error"), false, false); - event->SetTrusted(true); - - rv = DispatchDOMEvent(nullptr, event, nullptr, nullptr); + rv = mEventSource->CheckInnerWindowCorrectness(); if (NS_FAILED(rv)) { - NS_WARNING("Failed to dispatch the error event!!!"); return; } - rv = SetReconnectionTimeout(); + SetReadyState(CONNECTING); + ResetDecoder(); + rv = mEventSource->CreateAndDispatchSimpleEvent(NS_LITERAL_STRING("error")); if (NS_FAILED(rv)) { - NS_WARNING("Failed to set the timeout for reestablishing the connection!!!"); + NS_WARNING("Failed to dispatch the error event!!!"); return; } } nsresult -EventSource::SetReconnectionTimeout() +EventSourceImpl::SetReconnectionTimeout() { - if (mReadyState == CLOSED) { + AssertIsOnMainThread(); + if (IsClosed()) { return NS_ERROR_ABORT; } @@ -817,11 +1217,12 @@ EventSource::SetReconnectionTimeout() } nsresult -EventSource::PrintErrorOnConsole(const char *aBundleURI, - const char16_t *aError, - const char16_t **aFormatStrings, - uint32_t aFormatStringsLen) +EventSourceImpl::PrintErrorOnConsole(const char* aBundleURI, + const char16_t* aError, + const char16_t** aFormatStrings, + uint32_t aFormatStringsLen) { + AssertIsOnMainThread(); nsCOMPtr bundleService = mozilla::services::GetStringBundleService(); NS_ENSURE_STATE(bundleService); @@ -866,16 +1267,17 @@ EventSource::PrintErrorOnConsole(const char *aBundleURI, } nsresult -EventSource::ConsoleError() +EventSourceImpl::ConsoleError() { + AssertIsOnMainThread(); nsAutoCString targetSpec; nsresult rv = mSrc->GetSpec(targetSpec); NS_ENSURE_SUCCESS(rv, rv); NS_ConvertUTF8toUTF16 specUTF16(targetSpec); - const char16_t *formatStrings[] = { specUTF16.get() }; + const char16_t* formatStrings[] = { specUTF16.get() }; - if (mReadyState == CONNECTING) { + if (ReadyState() == CONNECTING) { rv = PrintErrorOnConsole("chrome://global/locale/appstrings.properties", u"connectionFailure", formatStrings, ArrayLength(formatStrings)); @@ -889,63 +1291,61 @@ EventSource::ConsoleError() return NS_OK; } -nsresult -EventSource::DispatchFailConnection() -{ - - return NS_DispatchToMainThread(NewRunnableMethod(this, &EventSource::FailConnection)); -} - void -EventSource::FailConnection() +EventSourceImpl::DispatchFailConnection() { - if (mReadyState == CLOSED) { + AssertIsOnMainThread(); + if (IsClosed()) { return; } - nsresult rv = ConsoleError(); if (NS_FAILED(rv)) { NS_WARNING("Failed to print to the console error"); } + rv = Dispatch(NewRunnableMethod(this, &EventSourceImpl::FailConnection), + NS_DISPATCH_NORMAL); + MOZ_ASSERT(NS_SUCCEEDED(rv)); +} - // When a user agent is to fail the connection, the user agent must set the - // readyState attribute to CLOSED and queue a task to fire a simple event - // named error at the EventSource object. - - Close(); // it sets mReadyState to CLOSED - - rv = CheckInnerWindowCorrectness(); - if (NS_FAILED(rv)) { +void +EventSourceImpl::FailConnection() +{ + AssertIsOnTargetThread(); + if (IsClosed()) { return; } - - RefPtr event = NS_NewDOMEvent(this, nullptr, nullptr); - - // it doesn't bubble, and it isn't cancelable - event->InitEvent(NS_LITERAL_STRING("error"), false, false); - event->SetTrusted(true); - - rv = DispatchDOMEvent(nullptr, event, nullptr, nullptr); - if (NS_FAILED(rv)) { - NS_WARNING("Failed to dispatch the error event!!!"); - return; + // Must change state to closed before firing event to content. + SetReadyState(CLOSED); + // When a user agent is to fail the connection, the user agent must set the + // readyState attribute to CLOSED and queue a task to fire a simple event + // named error at the EventSource object. + nsresult rv = mEventSource->CheckInnerWindowCorrectness(); + if (NS_SUCCEEDED(rv)) { + rv = mEventSource->CreateAndDispatchSimpleEvent(NS_LITERAL_STRING("error")); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to dispatch the error event!!!"); + } } + // Call CloseInternal in the end of function because it may release + // EventSourceImpl. + CloseInternal(); } // static void -EventSource::TimerCallback(nsITimer* aTimer, void* aClosure) +EventSourceImpl::TimerCallback(nsITimer* aTimer, void* aClosure) { - RefPtr thisObject = static_cast(aClosure); + AssertIsOnMainThread(); + RefPtr thisObject = static_cast(aClosure); - if (thisObject->mReadyState == CLOSED) { + if (thisObject->IsClosed()) { return; } NS_PRECONDITION(!thisObject->mHttpChannel, "the channel hasn't been cancelled!!"); - if (!thisObject->mFrozen) { + if (!thisObject->IsFrozen()) { nsresult rv = thisObject->InitChannelAndRequestEventSource(); if (NS_FAILED(rv)) { NS_WARNING("thisObject->InitChannelAndRequestEventSource() failed"); @@ -955,24 +1355,25 @@ EventSource::TimerCallback(nsITimer* aTimer, void* aClosure) } nsresult -EventSource::Thaw() +EventSourceImpl::Thaw() { - if (mReadyState == CLOSED || !mFrozen) { + AssertIsOnMainThread(); + if (IsClosed() || !IsFrozen()) { return NS_OK; } - NS_ASSERTION(!mHttpChannel, "the connection hasn't been closed!!!"); + MOZ_ASSERT(!mHttpChannel, "the connection hasn't been closed!!!"); - mFrozen = false; + SetFrozen(false); nsresult rv; if (!mGoingToDispatchAllMessages && mMessagesToDispatch.GetSize() > 0) { nsCOMPtr event = - NewRunnableMethod(this, &EventSource::DispatchAllMessageEvents); + NewRunnableMethod(this, &EventSourceImpl::DispatchAllMessageEvents); NS_ENSURE_STATE(event); mGoingToDispatchAllMessages = true; - rv = NS_DispatchToMainThread(event); + rv = Dispatch(event.forget(), NS_DISPATCH_NORMAL); NS_ENSURE_SUCCESS(rv, rv); } @@ -983,20 +1384,22 @@ EventSource::Thaw() } nsresult -EventSource::Freeze() +EventSourceImpl::Freeze() { - if (mReadyState == CLOSED || mFrozen) { + AssertIsOnMainThread(); + if (IsClosed() || IsFrozen()) { return NS_OK; } - NS_ASSERTION(!mHttpChannel, "the connection hasn't been closed!!!"); - mFrozen = true; + MOZ_ASSERT(!mHttpChannel, "the connection hasn't been closed!!!"); + SetFrozen(true); return NS_OK; } nsresult -EventSource::DispatchCurrentMessageEvent() +EventSourceImpl::DispatchCurrentMessageEvent() { + AssertIsOnTargetThread(); nsAutoPtr message(new Message()); *message = mCurrentMessage; @@ -1007,8 +1410,8 @@ EventSource::DispatchCurrentMessageEvent() } // removes the trailing LF from mData - NS_ASSERTION(message->mData.CharAt(message->mData.Length() - 1) == LF_CHAR, - "Invalid trailing character! LF was expected instead."); + MOZ_ASSERT(message->mData.CharAt(message->mData.Length() - 1) == LF_CHAR, + "Invalid trailing character! LF was expected instead."); message->mData.SetLength(message->mData.Length() - 1); if (message->mEventName.IsEmpty()) { @@ -1027,34 +1430,42 @@ EventSource::DispatchCurrentMessageEvent() if (!mGoingToDispatchAllMessages) { nsCOMPtr event = - NewRunnableMethod(this, &EventSource::DispatchAllMessageEvents); + NewRunnableMethod(this, &EventSourceImpl::DispatchAllMessageEvents); NS_ENSURE_STATE(event); mGoingToDispatchAllMessages = true; - return NS_DispatchToMainThread(event); + return Dispatch(event.forget(), NS_DISPATCH_NORMAL); } return NS_OK; } void -EventSource::DispatchAllMessageEvents() +EventSourceImpl::DispatchAllMessageEvents() { - if (mReadyState == CLOSED || mFrozen) { + AssertIsOnTargetThread(); + if (IsClosed() || IsFrozen()) { return; } mGoingToDispatchAllMessages = false; - nsresult rv = CheckInnerWindowCorrectness(); + nsresult rv = mEventSource->CheckInnerWindowCorrectness(); if (NS_FAILED(rv)) { return; } AutoJSAPI jsapi; - if (NS_WARN_IF(!jsapi.Init(GetOwner()))) { - return; + if (mIsMainThread) { + if (NS_WARN_IF(!jsapi.Init(mEventSource->GetOwner()))) { + return; + } + } else { + MOZ_ASSERT(mWorkerPrivate); + if (NS_WARN_IF(!jsapi.Init(mWorkerPrivate->GlobalScope()))) { + return; + } } JSContext* cx = jsapi.cx(); @@ -1077,29 +1488,33 @@ EventSource::DispatchAllMessageEvents() // create an event that uses the MessageEvent interface, // which does not bubble, is not cancelable, and has no default action - RefPtr event = new MessageEvent(this, nullptr, nullptr); + RefPtr event = new MessageEvent(mEventSource, nullptr, + nullptr); event->InitMessageEvent(nullptr, message->mEventName, false, false, jsData, mOrigin, message->mLastEventID, nullptr, Sequence>()); event->SetTrusted(true); - rv = DispatchDOMEvent(nullptr, static_cast(event), nullptr, - nullptr); + rv = mEventSource->DispatchDOMEvent(nullptr, static_cast(event), + nullptr, nullptr); if (NS_FAILED(rv)) { NS_WARNING("Failed to dispatch the message event!!!"); return; } mLastEventID.Assign(message->mLastEventID); + if (IsClosed() || IsFrozen()) { + return; + } } } nsresult -EventSource::ClearFields() +EventSourceImpl::ClearFields() { + AssertIsOnTargetThread(); // mLastEventID and mReconnectionTime must be cached - mCurrentMessage.mEventName.Truncate(); mCurrentMessage.mLastEventID.Truncate(); mCurrentMessage.mData.Truncate(); @@ -1111,8 +1526,9 @@ EventSource::ClearFields() } nsresult -EventSource::SetFieldAndClear() +EventSourceImpl::SetFieldAndClear() { + AssertIsOnTargetThread(); if (mLastFieldName.IsEmpty()) { mLastFieldValue.Truncate(); return NS_OK; @@ -1121,8 +1537,8 @@ EventSource::SetFieldAndClear() char16_t first_char; first_char = mLastFieldName.CharAt(0); - switch (first_char) // with no case folding performed - { + // with no case folding performed + switch (first_char) { case char16_t('d'): if (mLastFieldName.EqualsLiteral("data")) { // If the field name is "data" append the field value to the data @@ -1147,7 +1563,7 @@ EventSource::SetFieldAndClear() case char16_t('r'): if (mLastFieldName.EqualsLiteral("retry")) { - uint32_t newValue=0; + uint32_t newValue = 0; uint32_t i = 0; // we must ensure that there are only digits bool assign = true; for (i = 0; i < mLastFieldValue.Length(); ++i) { @@ -1182,12 +1598,14 @@ EventSource::SetFieldAndClear() } nsresult -EventSource::CheckHealthOfRequestCallback(nsIRequest *aRequestCallback) +EventSourceImpl::CheckHealthOfRequestCallback(nsIRequest* aRequestCallback) { + // This function could be run on target thread if http channel support + // nsIThreadRetargetableRequest. otherwise, it's run on main thread. + // check if we have been closed or if the request has been canceled // or if we have been frozen - if (mReadyState == CLOSED || !mHttpChannel || - mFrozen || mErrorLoadOnRedirect) { + if (IsClosed() || IsFrozen() || !mHttpChannel) { return NS_ERROR_ABORT; } @@ -1203,16 +1621,16 @@ EventSource::CheckHealthOfRequestCallback(nsIRequest *aRequestCallback) } nsresult -EventSource::ParseCharacter(char16_t aChr) +EventSourceImpl::ParseCharacter(char16_t aChr) { + AssertIsOnTargetThread(); nsresult rv; - if (mReadyState == CLOSED) { + if (IsClosed()) { return NS_ERROR_ABORT; } - switch (mStatus) - { + switch (mStatus) { case PARSE_STATE_OFF: NS_ERROR("Invalid state"); return NS_ERROR_FAILURE; @@ -1351,5 +1769,330 @@ EventSource::ParseCharacter(char16_t aChr) return NS_OK; } +void +EventSourceImpl::AddRefObject() +{ + AddRef(); +} + +void +EventSourceImpl::ReleaseObject() +{ + Release(); +} + +namespace { +class EventSourceWorkerHolder final : public WorkerHolder +{ +public: + explicit EventSourceWorkerHolder(EventSourceImpl* aEventSourceImpl) + : mEventSourceImpl(aEventSourceImpl) + { + } + + bool Notify(Status aStatus) override + { + MOZ_ASSERT(aStatus > workers::Running); + if (aStatus >= Canceling) { + mEventSourceImpl->Close(); + } + return true; + } + +private: + // Raw pointer because the EventSourceImpl object keeps alive the holder. + EventSourceImpl* mEventSourceImpl; +}; + +class WorkerRunnableDispatcher final : public WorkerRunnable +{ + RefPtr mEventSourceImpl; + +public: + WorkerRunnableDispatcher(EventSourceImpl* aImpl, + WorkerPrivate* aWorkerPrivate, + already_AddRefed aEvent) + : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount) + , mEventSourceImpl(aImpl) + , mEvent(Move(aEvent)) + { + } + + bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override + { + aWorkerPrivate->AssertIsOnWorkerThread(); + return !NS_FAILED(mEvent->Run()); + } + + void PostRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate, + bool aRunResult) override + { + } + + bool PreDispatch(WorkerPrivate* aWorkerPrivate) override + { + // We don't call WorkerRunnable::PreDispatch because it would assert the + // wrong thing about which thread we're on. We're on whichever thread the + // channel implementation is running on (probably the main thread or + // transport thread). + return true; + } + + void PostDispatch(WorkerPrivate* aWorkerPrivate, + bool aDispatchResult) override + { + // We don't call WorkerRunnable::PostDispatch because it would assert the + // wrong thing about which thread we're on. We're on whichever thread the + // channel implementation is running on (probably the main thread or + // transport thread). + } + +private: + nsCOMPtr mEvent; +}; + +} // namespace + +bool EventSourceImpl::RegisterWorkerHolder() +{ + MOZ_ASSERT(mWorkerPrivate); + mWorkerPrivate->AssertIsOnWorkerThread(); + MOZ_ASSERT(!mWorkerHolder); + mWorkerHolder = new EventSourceWorkerHolder(this); + if (NS_WARN_IF(!mWorkerHolder->HoldWorker(mWorkerPrivate, Canceling))) { + mWorkerHolder = nullptr; + return false; + } + return true; +} + +void EventSourceImpl::UnregisterWorkerHolder() +{ + // RegisterWorkerHolder fail will destroy EventSourceImpl and invoke + // UnregisterWorkerHolder. + MOZ_ASSERT(IsClosed()); + MOZ_ASSERT(mWorkerPrivate); + mWorkerPrivate->AssertIsOnWorkerThread(); + // The DTOR of this WorkerHolder will release the worker for us. + mWorkerHolder = nullptr; + mWorkerPrivate = nullptr; +} + +//----------------------------------------------------------------------------- +// EventSourceImpl::nsIEventTarget +//----------------------------------------------------------------------------- +NS_IMETHODIMP +EventSourceImpl::DispatchFromScript(nsIRunnable* aEvent, uint32_t aFlags) +{ + nsCOMPtr event(aEvent); + return Dispatch(event.forget(), aFlags); +} + +NS_IMETHODIMP +EventSourceImpl::Dispatch(already_AddRefed aEvent, uint32_t aFlags) +{ + nsCOMPtr event_ref(aEvent); + if (mIsMainThread) { + return NS_DispatchToMainThread(event_ref.forget()); + } + MOZ_ASSERT(mWorkerPrivate); + // If the target is a worker, we have to use a custom WorkerRunnableDispatcher + // runnable. + RefPtr event = + new WorkerRunnableDispatcher(this, mWorkerPrivate, event_ref.forget()); + + if (!event->Dispatch()) { + return NS_ERROR_FAILURE; + } + return NS_OK; +} + + +NS_IMETHODIMP +EventSourceImpl::DelayedDispatch(already_AddRefed aEvent, + uint32_t aDelayMs) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +//----------------------------------------------------------------------------- +// EventSourceImpl::nsIThreadRetargetableStreamListener +//----------------------------------------------------------------------------- +NS_IMETHODIMP +EventSourceImpl::CheckListenerChain() +{ + MOZ_ASSERT(NS_IsMainThread(), "Should be on the main thread!"); + return NS_OK; +} +//////////////////////////////////////////////////////////////////////////////// +// EventSource +//////////////////////////////////////////////////////////////////////////////// + +EventSource::EventSource(nsPIDOMWindowInner* aOwnerWindow, + bool aWithCredentials) + : DOMEventTargetHelper(aOwnerWindow) + , mWithCredentials(aWithCredentials) + , mIsMainThread(true) + , mKeepingAlive(false) +{ + mImpl = new EventSourceImpl(this); +} + +EventSource::~EventSource() +{ +} + +nsresult +EventSource::CreateAndDispatchSimpleEvent(const nsAString& aName) +{ + RefPtr event = NS_NewDOMEvent(this, nullptr, nullptr); + // it doesn't bubble, and it isn't cancelable + event->InitEvent(aName, false, false); + event->SetTrusted(true); + return DispatchDOMEvent(nullptr, event, nullptr, nullptr); +} + +/* static */ already_AddRefed +EventSource::Constructor(const GlobalObject& aGlobal, const nsAString& aURL, + const EventSourceInit& aEventSourceInitDict, + ErrorResult& aRv) +{ + nsCOMPtr ownerWindow = + do_QueryInterface(aGlobal.GetAsSupports()); + + MOZ_ASSERT(!NS_IsMainThread() || + (ownerWindow && ownerWindow->IsInnerWindow())); + + RefPtr eventSource = + new EventSource(ownerWindow, aEventSourceInitDict.mWithCredentials); + RefPtr eventSourceImp = eventSource->mImpl; + + if (NS_IsMainThread()) { + // Get principal from document and init EventSourceImpl + nsCOMPtr scriptPrincipal = + do_QueryInterface(aGlobal.GetAsSupports()); + if (!scriptPrincipal) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + nsCOMPtr principal = scriptPrincipal->GetPrincipal(); + if (!principal) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + eventSourceImp->Init(principal, aURL, aRv); + } else { + // In workers we have to keep the worker alive using a WorkerHolder in order + // to dispatch messages correctly. + if (!eventSourceImp->RegisterWorkerHolder()) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + RefPtr runnable = new InitRunnable(eventSourceImp, aURL); + runnable->Dispatch(Terminating, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + aRv = runnable->ErrorCode(); + } + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + return eventSource.forget(); +} + +// nsWrapperCache +JSObject* +EventSource::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) +{ + return EventSourceBinding::Wrap(aCx, this, aGivenProto); +} + +void +EventSource::Close() +{ + AssertIsOnTargetThread(); + if (mImpl) { + mImpl->Close(); + } +} + +void +EventSource::UpdateMustKeepAlive() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mImpl); + if (mKeepingAlive) { + return; + } + mKeepingAlive = true; + mImpl->AddRefObject(); +} + +void +EventSource::UpdateDontKeepAlive() +{ + // Here we could not have mImpl. + MOZ_ASSERT(NS_IsMainThread() == mIsMainThread); + if (mKeepingAlive) { + MOZ_ASSERT(mImpl); + mKeepingAlive = false; + mImpl->mEventSource = nullptr; + mImpl->ReleaseObject(); + } + mImpl = nullptr; +} + +//----------------------------------------------------------------------------- +// EventSource::nsISupports +//----------------------------------------------------------------------------- + +NS_IMPL_CYCLE_COLLECTION_CLASS(EventSource) + +NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(EventSource) + bool isBlack = tmp->IsBlack(); + if (isBlack || tmp->mKeepingAlive) { + if (tmp->mListenerManager) { + tmp->mListenerManager->MarkForCC(); + } + if (!isBlack && tmp->PreservingWrapper()) { + // This marks the wrapper black. + tmp->GetWrapper(); + } + return true; + } +NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END + +NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(EventSource) + return tmp->IsBlack(); +NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END + +NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(EventSource) + return tmp->IsBlack(); +NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(EventSource, + DOMEventTargetHelper) +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(EventSource, + DOMEventTargetHelper) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(EventSource, + DOMEventTargetHelper) + if (tmp->mImpl) { + tmp->mImpl->Close(); + MOZ_ASSERT(!tmp->mImpl); + } +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(EventSource) +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +NS_IMPL_ADDREF_INHERITED(EventSource, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(EventSource, DOMEventTargetHelper) + } // namespace dom } // namespace mozilla diff --git a/dom/base/EventSource.h b/dom/base/EventSource.h index b22cebd47a..cd43481908 100644 --- a/dom/base/EventSource.h +++ b/dom/base/EventSource.h @@ -35,221 +35,81 @@ namespace dom { struct EventSourceInit; +class EventSourceImpl; + class EventSource final : public DOMEventTargetHelper - , public nsIObserver - , public nsIStreamListener - , public nsIChannelEventSink - , public nsIInterfaceRequestor - , public nsSupportsWeakReference { + friend class EventSourceImpl; public: - explicit EventSource(nsPIDOMWindowInner* aOwnerWindow); NS_DECL_ISUPPORTS_INHERITED NS_DECL_CYCLE_COLLECTION_SKIPPABLE_SCRIPT_HOLDER_CLASS_INHERITED( EventSource, DOMEventTargetHelper) - NS_DECL_NSIOBSERVER - NS_DECL_NSISTREAMLISTENER - NS_DECL_NSIREQUESTOBSERVER - NS_DECL_NSICHANNELEVENTSINK - NS_DECL_NSIINTERFACEREQUESTOR + // EventTarget + void DisconnectFromOwner() override + { + DOMEventTargetHelper::DisconnectFromOwner(); + Close(); + } - // nsWrapperCache - virtual JSObject* WrapObject(JSContext* aCx, JS::Handle aGivenProto) override; + JSObject* WrapObject(JSContext* aCx, + JS::Handle aGivenProto) override; // WebIDL - nsPIDOMWindowInner* - GetParentObject() const - { - return GetOwner(); - } static already_AddRefed Constructor(const GlobalObject& aGlobal, const nsAString& aURL, - const EventSourceInit& aEventSourceInitDict, - ErrorResult& aRv); + const EventSourceInit& aEventSourceInitDict, ErrorResult& aRv); void GetUrl(nsAString& aURL) const { + AssertIsOnTargetThread(); aURL = mOriginalURL; } + bool WithCredentials() const { + AssertIsOnTargetThread(); return mWithCredentials; } - enum { - CONNECTING = 0U, - OPEN = 1U, - CLOSED = 2U - }; uint16_t ReadyState() const { + AssertIsOnTargetThread(); return mReadyState; } IMPL_EVENT_HANDLER(open) IMPL_EVENT_HANDLER(message) IMPL_EVENT_HANDLER(error) - void Close(); - virtual void DisconnectFromOwner() override; + void Close(); -protected: +private: + EventSource(nsPIDOMWindowInner* aOwnerWindow, bool aWithCredentials); virtual ~EventSource(); + // prevent bad usage + EventSource(const EventSource& x) = delete; + EventSource& operator=(const EventSource& x) = delete; - MOZ_IS_CLASS_INIT - nsresult Init(nsISupports* aOwner, - const nsAString& aURL, - bool aWithCredentials); - - nsresult GetBaseURI(nsIURI **aBaseURI); - - void SetupHttpChannel(); - nsresult SetupReferrerPolicy(); - nsresult InitChannelAndRequestEventSource(); - nsresult ResetConnection(); - nsresult DispatchFailConnection(); - nsresult SetReconnectionTimeout(); - - void AnnounceConnection(); - void DispatchAllMessageEvents(); - void ReestablishConnection(); - void FailConnection(); - - nsresult Thaw(); - nsresult Freeze(); - - static void TimerCallback(nsITimer *aTimer, void *aClosure); - - nsresult PrintErrorOnConsole(const char *aBundleURI, - const char16_t *aError, - const char16_t **aFormatStrings, - uint32_t aFormatStringsLen); - nsresult ConsoleError(); - - static nsresult StreamReaderFunc(nsIInputStream *aInputStream, - void *aClosure, - const char *aFromRawSegment, - uint32_t aToOffset, - uint32_t aCount, - uint32_t *aWriteCount); - nsresult SetFieldAndClear(); - nsresult ClearFields(); - nsresult ResetEvent(); - nsresult DispatchCurrentMessageEvent(); - nsresult ParseCharacter(char16_t aChr); - nsresult CheckHealthOfRequestCallback(nsIRequest *aRequestCallback); - nsresult OnRedirectVerifyCallback(nsresult result); - - nsCOMPtr mSrc; - - nsString mLastEventID; - uint32_t mReconnectionTime; // in ms - - struct Message { - nsString mEventName; - nsString mLastEventID; - nsString mData; - }; - nsDeque mMessagesToDispatch; - Message mCurrentMessage; - - /** - * A simple state machine used to manage the event-source's line buffer - * - * PARSE_STATE_OFF -> PARSE_STATE_BEGIN_OF_STREAM - * - * PARSE_STATE_BEGIN_OF_STREAM -> PARSE_STATE_BOM_WAS_READ | - * PARSE_STATE_CR_CHAR | - * PARSE_STATE_BEGIN_OF_LINE | - * PARSE_STATE_COMMENT | - * PARSE_STATE_FIELD_NAME - * - * PARSE_STATE_BOM_WAS_READ -> PARSE_STATE_CR_CHAR | - * PARSE_STATE_BEGIN_OF_LINE | - * PARSE_STATE_COMMENT | - * PARSE_STATE_FIELD_NAME - * - * PARSE_STATE_CR_CHAR -> PARSE_STATE_CR_CHAR | - * PARSE_STATE_COMMENT | - * PARSE_STATE_FIELD_NAME | - * PARSE_STATE_BEGIN_OF_LINE - * - * PARSE_STATE_COMMENT -> PARSE_STATE_CR_CHAR | - * PARSE_STATE_BEGIN_OF_LINE - * - * PARSE_STATE_FIELD_NAME -> PARSE_STATE_CR_CHAR | - * PARSE_STATE_BEGIN_OF_LINE | - * PARSE_STATE_FIRST_CHAR_OF_FIELD_VALUE - * - * PARSE_STATE_FIRST_CHAR_OF_FIELD_VALUE -> PARSE_STATE_FIELD_VALUE | - * PARSE_STATE_CR_CHAR | - * PARSE_STATE_BEGIN_OF_LINE - * - * PARSE_STATE_FIELD_VALUE -> PARSE_STATE_CR_CHAR | - * PARSE_STATE_BEGIN_OF_LINE - * - * PARSE_STATE_BEGIN_OF_LINE -> PARSE_STATE_CR_CHAR | - * PARSE_STATE_COMMENT | - * PARSE_STATE_FIELD_NAME | - * PARSE_STATE_BEGIN_OF_LINE - * - * Whenever the parser find an empty line or the end-of-file - * it dispatches the stacked event. - * - */ - enum ParserStatus { - PARSE_STATE_OFF, - PARSE_STATE_BEGIN_OF_STREAM, - PARSE_STATE_BOM_WAS_READ, - PARSE_STATE_CR_CHAR, - PARSE_STATE_COMMENT, - PARSE_STATE_FIELD_NAME, - PARSE_STATE_FIRST_CHAR_OF_FIELD_VALUE, - PARSE_STATE_FIELD_VALUE, - PARSE_STATE_BEGIN_OF_LINE - }; - ParserStatus mStatus; - - bool mFrozen; - bool mErrorLoadOnRedirect; - bool mGoingToDispatchAllMessages; - bool mWithCredentials; - bool mWaitingForOnStopRequest; - - // used while reading the input streams - nsCOMPtr mUnicodeDecoder; - nsresult mLastConvertionResult; - nsString mLastFieldName; - nsString mLastFieldValue; - - nsCOMPtr mLoadGroup; - - nsCOMPtr mHttpChannel; + void AssertIsOnTargetThread() const + { + MOZ_ASSERT(NS_IsMainThread() == mIsMainThread); + } - nsCOMPtr mTimer; + nsresult CreateAndDispatchSimpleEvent(const nsAString& aName); - uint16_t mReadyState; + // Raw pointer because this EventSourceImpl is created, managed and destroyed + // by EventSource. + EventSourceImpl* mImpl; nsString mOriginalURL; + uint16_t mReadyState; + bool mWithCredentials; + bool mIsMainThread; + // This is used to keep EventSourceImpl instance when there is a connection. + bool mKeepingAlive; - nsCOMPtr mPrincipal; - nsString mOrigin; - - // Event Source owner information: - // - the script file name - // - source code line number and column number where the Event Source object - // was constructed. - // - the ID of the inner window where the script lives. Note that this may not - // be the same as the Event Source owner window. - // These attributes are used for error reporting. - nsString mScriptFile; - uint32_t mScriptLine; - uint32_t mScriptColumn; - uint64_t mInnerWindowID; - -private: - EventSource(const EventSource& x); // prevent bad usage - EventSource& operator=(const EventSource& x); + void UpdateMustKeepAlive(); + void UpdateDontKeepAlive(); }; } // namespace dom diff --git a/dom/webidl/EventSource.webidl b/dom/webidl/EventSource.webidl index 1e8e9978e5..f6d54c3bd9 100644 --- a/dom/webidl/EventSource.webidl +++ b/dom/webidl/EventSource.webidl @@ -11,7 +11,8 @@ * and create derivative works of this document. */ -[Constructor(USVString url, optional EventSourceInit eventSourceInitDict)] +[Exposed=(Window,DedicatedWorker,SharedWorker), + Constructor(USVString url, optional EventSourceInit eventSourceInitDict)] interface EventSource : EventTarget { [Constant] readonly attribute DOMString url; -- cgit v1.2.3 From 10dbd42596d2465e7648f2826b4f6ad7645e2f77 Mon Sep 17 00:00:00 2001 From: Brian Smith Date: Thu, 18 Aug 2022 16:35:40 -0500 Subject: Issue #1990 - Part 2 - Fix crash when incorrectly access EventSourceImpl::mEventSource. - Mozilla Bug 1333099 --- dom/base/EventSource.cpp | 69 +++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 57 insertions(+), 12 deletions(-) diff --git a/dom/base/EventSource.cpp b/dom/base/EventSource.cpp index f4aad9ab49..b59fccd484 100644 --- a/dom/base/EventSource.cpp +++ b/dom/base/EventSource.cpp @@ -158,8 +158,8 @@ public: uint16_t ReadyState() { + MutexAutoLock lock(mMutex); if (mEventSource) { - MutexAutoLock lock(mMutex); return mEventSource->mReadyState; } // EventSourceImpl keeps EventSource alive. If mEventSource is null, it @@ -169,8 +169,9 @@ public: void SetReadyState(uint16_t aReadyState) { - MOZ_ASSERT(mEventSource); MutexAutoLock lock(mMutex); + MOZ_ASSERT(mEventSource); + MOZ_ASSERT(!mIsShutDown); mEventSource->mReadyState = aReadyState; } @@ -191,6 +192,19 @@ public: return ReadyState() == CLOSED; } + void ShutDown() + { + MutexAutoLock lock(mMutex); + MOZ_ASSERT(!mIsShutDown); + mIsShutDown = true; + } + + bool IsShutDown() + { + MutexAutoLock lock(mMutex); + return mIsShutDown; + } + RefPtr mEventSource; /** @@ -292,7 +306,7 @@ public: // Whether the EventSource is run on main thread. bool mIsMainThread; // Whether the EventSourceImpl is going to be destroyed. - bool mIsClosing; + bool mIsShutDown; // Event Source owner information: // - the script file name @@ -341,7 +355,7 @@ EventSourceImpl::EventSourceImpl(EventSource* aEventSource) , mFrozen(false) , mGoingToDispatchAllMessages(false) , mIsMainThread(NS_IsMainThread()) - , mIsClosing(false) + , mIsShutDown(false) , mScriptLine(0) , mScriptColumn(0) , mInnerWindowID(0) @@ -397,14 +411,12 @@ EventSourceImpl::CloseInternal() { AssertIsOnTargetThread(); MOZ_ASSERT(IsClosed()); - if (mIsClosing) { + if (IsShutDown()) { return; } - mIsClosing = true; - while (mMessagesToDispatch.GetSize() != 0) { - delete static_cast(mMessagesToDispatch.PopFront()); - } + // Invoke CleanupOnMainThread before cleaning any members. It will call + // ShutDown, which is supposed to be called before cleaning any members. if (NS_IsMainThread()) { CleanupOnMainThread(); } else { @@ -417,6 +429,9 @@ EventSourceImpl::CloseInternal() UnregisterWorkerHolder(); } + while (mMessagesToDispatch.GetSize() != 0) { + delete static_cast(mMessagesToDispatch.PopFront()); + } SetFrozen(false); ResetDecoder(); mUnicodeDecoder = nullptr; @@ -428,6 +443,11 @@ EventSourceImpl::CloseInternal() void EventSourceImpl::CleanupOnMainThread() { AssertIsOnMainThread(); + MOZ_ASSERT(IsClosed()); + + // Call ShutDown before cleaning any members. + ShutDown(); + if (mIsMainThread) { RemoveWindowObservers(); } @@ -489,6 +509,7 @@ nsresult EventSourceImpl::ParseURL(const nsAString& aURL) { AssertIsOnMainThread(); + MOZ_ASSERT(!IsShutDown()); // get the src nsCOMPtr baseURI; nsresult rv = GetBaseURI(getter_AddRefs(baseURI)); @@ -517,6 +538,7 @@ EventSourceImpl::AddWindowObservers() { AssertIsOnMainThread(); MOZ_ASSERT(mIsMainThread); + MOZ_ASSERT(!IsShutDown()); nsCOMPtr os = mozilla::services::GetObserverService(); NS_ENSURE_STATE(os); @@ -534,6 +556,7 @@ EventSourceImpl::RemoveWindowObservers() { AssertIsOnMainThread(); MOZ_ASSERT(mIsMainThread); + MOZ_ASSERT(IsClosed()); nsCOMPtr os = mozilla::services::GetObserverService(); if (os) { os->RemoveObserver(this, DOM_WINDOW_DESTROYED_TOPIC); @@ -549,9 +572,7 @@ EventSourceImpl::Init(nsIPrincipal* aPrincipal, { AssertIsOnMainThread(); MOZ_ASSERT(aPrincipal); - if (IsClosed()) { - return; - } + MOZ_ASSERT(ReadyState() == CONNECTING); mPrincipal = aPrincipal; aRv = ParseURL(aURL); if (NS_WARN_IF(aRv.Failed())) { @@ -693,6 +714,7 @@ EventSourceImpl::StreamReaderFunc(nsIInputStream* aInputStream, NS_WARNING("EventSource cannot read from stream: no aClosure or aWriteCount"); return NS_ERROR_FAILURE; } + MOZ_ASSERT(!thisObject->IsShutDown()); thisObject->ParseSegment((const char*)aFromRawSegment, aCount); *aWriteCount = aCount; return NS_OK; @@ -845,6 +867,9 @@ EventSourceImpl::AsyncOnChannelRedirect(nsIChannel* aOldChannel, nsIAsyncVerifyRedirectCallback* aCallback) { AssertIsOnMainThread(); + if (IsClosed()) { + return NS_ERROR_ABORT; + } nsCOMPtr aOldRequest = do_QueryInterface(aOldChannel); NS_PRECONDITION(aOldRequest, "Redirect from a null request?"); @@ -894,6 +919,11 @@ NS_IMETHODIMP EventSourceImpl::GetInterface(const nsIID& aIID, void** aResult) { AssertIsOnMainThread(); + + if (IsClosed()) { + return NS_ERROR_FAILURE; + } + if (aIID.Equals(NS_GET_IID(nsIChannelEventSink))) { *aResult = static_cast(this); NS_ADDREF_THIS(); @@ -934,6 +964,7 @@ nsresult EventSourceImpl::GetBaseURI(nsIURI** aBaseURI) { AssertIsOnMainThread(); + MOZ_ASSERT(!IsShutDown()); NS_ENSURE_ARG_POINTER(aBaseURI); *aBaseURI = nullptr; @@ -962,6 +993,7 @@ void EventSourceImpl::SetupHttpChannel() { AssertIsOnMainThread(); + MOZ_ASSERT(!IsShutDown()); mHttpChannel->SetRequestMethod(NS_LITERAL_CSTRING("GET")); /* set the http request headers */ @@ -981,6 +1013,7 @@ nsresult EventSourceImpl::SetupReferrerPolicy() { AssertIsOnMainThread(); + MOZ_ASSERT(!IsShutDown()); nsCOMPtr doc = mEventSource->GetDocumentIfCurrent(); if (doc) { nsresult rv = mHttpChannel->SetReferrerWithPolicy(doc->GetDocumentURI(), @@ -1151,6 +1184,9 @@ nsresult EventSourceImpl::RestartConnection() { AssertIsOnMainThread(); + if (IsClosed()) { + return NS_ERROR_ABORT; + } nsresult rv = ResetConnection(); NS_ENSURE_SUCCESS(rv, rv); rv = SetReconnectionTimeout(); @@ -1223,6 +1259,7 @@ EventSourceImpl::PrintErrorOnConsole(const char* aBundleURI, uint32_t aFormatStringsLen) { AssertIsOnMainThread(); + MOZ_ASSERT(!IsShutDown()); nsCOMPtr bundleService = mozilla::services::GetStringBundleService(); NS_ENSURE_STATE(bundleService); @@ -1270,6 +1307,7 @@ nsresult EventSourceImpl::ConsoleError() { AssertIsOnMainThread(); + MOZ_ASSERT(!IsShutDown()); nsAutoCString targetSpec; nsresult rv = mSrc->GetSpec(targetSpec); NS_ENSURE_SUCCESS(rv, rv); @@ -1400,6 +1438,7 @@ nsresult EventSourceImpl::DispatchCurrentMessageEvent() { AssertIsOnTargetThread(); + MOZ_ASSERT(!IsShutDown()); nsAutoPtr message(new Message()); *message = mCurrentMessage; @@ -1528,6 +1567,7 @@ EventSourceImpl::ClearFields() nsresult EventSourceImpl::SetFieldAndClear() { + MOZ_ASSERT(!IsShutDown()); AssertIsOnTargetThread(); if (mLastFieldName.IsEmpty()) { mLastFieldValue.Truncate(); @@ -1855,6 +1895,7 @@ private: bool EventSourceImpl::RegisterWorkerHolder() { + MOZ_ASSERT(!IsShutDown()); MOZ_ASSERT(mWorkerPrivate); mWorkerPrivate->AssertIsOnWorkerThread(); MOZ_ASSERT(!mWorkerHolder); @@ -1895,6 +1936,10 @@ EventSourceImpl::Dispatch(already_AddRefed aEvent, uint32_t aFlags) if (mIsMainThread) { return NS_DispatchToMainThread(event_ref.forget()); } + + if (IsShutDown()) { + return NS_OK; + } MOZ_ASSERT(mWorkerPrivate); // If the target is a worker, we have to use a custom WorkerRunnableDispatcher // runnable. -- cgit v1.2.3 From 3596656ea4622777ec70558e64a7d70c3578bad7 Mon Sep 17 00:00:00 2001 From: Brian Smith Date: Thu, 18 Aug 2022 17:57:47 -0500 Subject: Issue #1990 - Part 3 - Fix build issue due to missing nsIThreadRetargetableStreamListener definition. --- dom/base/EventSource.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/dom/base/EventSource.cpp b/dom/base/EventSource.cpp index b59fccd484..866ff1a91d 100644 --- a/dom/base/EventSource.cpp +++ b/dom/base/EventSource.cpp @@ -34,6 +34,7 @@ #include "nsIScriptObjectPrincipal.h" #include "nsJSUtils.h" #include "nsIThreadRetargetableRequest.h" +#include "nsIThreadRetargetableStreamListener.h" #include "nsIAsyncVerifyRedirectCallback.h" #include "nsIScriptError.h" #include "mozilla/dom/EncodingUtils.h" -- cgit v1.2.3 From bbc3e455b064320170be03996a87a493f3c18106 Mon Sep 17 00:00:00 2001 From: Brian Smith Date: Mon, 22 Aug 2022 13:23:34 -0500 Subject: Issue #1990 - Part 4 - Add a number of Mozilla patches from between Part 1 and 2. 1334081 - prevent null pointer dereference in StreamReaderFunc. 1330631 - Convert the EventSourceImpl::Message to be UniquePtr. 1337619 - Reset mGoingToDispatchAllMessages flag before early return. --- dom/base/EventSource.cpp | 45 ++++++++++++++++++--------------------------- 1 file changed, 18 insertions(+), 27 deletions(-) diff --git a/dom/base/EventSource.cpp b/dom/base/EventSource.cpp index 866ff1a91d..3bd1fae52d 100644 --- a/dom/base/EventSource.cpp +++ b/dom/base/EventSource.cpp @@ -129,7 +129,7 @@ public: uint32_t* aWriteCount); void ParseSegment(const char* aBuffer, uint32_t aLength); nsresult SetFieldAndClear(); - nsresult ClearFields(); + void ClearFields(); nsresult ResetEvent(); nsresult DispatchCurrentMessageEvent(); nsresult ParseCharacter(char16_t aChr); @@ -282,7 +282,7 @@ public: // Message related data members. May be set / initialized when initializing // EventSourceImpl on target thread but should only be used on target thread. nsString mLastEventID; - Message mCurrentMessage; + UniquePtr mCurrentMessage; nsDeque mMessagesToDispatch; ParserStatus mStatus; nsCOMPtr mUnicodeDecoder; @@ -710,12 +710,11 @@ EventSourceImpl::StreamReaderFunc(nsIInputStream* aInputStream, uint32_t* aWriteCount) { EventSourceImpl* thisObject = static_cast(aClosure); - thisObject->AssertIsOnTargetThread(); if (!thisObject || !aWriteCount) { NS_WARNING("EventSource cannot read from stream: no aClosure or aWriteCount"); return NS_ERROR_FAILURE; } - MOZ_ASSERT(!thisObject->IsShutDown()); + thisObject->AssertIsOnTargetThread(); thisObject->ParseSegment((const char*)aFromRawSegment, aCount); *aWriteCount = aCount; return NS_OK; @@ -1439,13 +1438,11 @@ nsresult EventSourceImpl::DispatchCurrentMessageEvent() { AssertIsOnTargetThread(); - MOZ_ASSERT(!IsShutDown()); - nsAutoPtr message(new Message()); - *message = mCurrentMessage; + UniquePtr message(Move(mCurrentMessage)); ClearFields(); - if (message->mData.IsEmpty()) { + if (!message || message->mData.IsEmpty()) { return NS_OK; } @@ -1463,7 +1460,7 @@ EventSourceImpl::DispatchCurrentMessageEvent() } size_t sizeBefore = mMessagesToDispatch.GetSize(); - mMessagesToDispatch.Push(message.forget()); + mMessagesToDispatch.Push(message.release()); NS_ENSURE_TRUE(mMessagesToDispatch.GetSize() == sizeBefore + 1, NS_ERROR_OUT_OF_MEMORY); @@ -1485,12 +1482,12 @@ void EventSourceImpl::DispatchAllMessageEvents() { AssertIsOnTargetThread(); + mGoingToDispatchAllMessages = false; + if (IsClosed() || IsFrozen()) { return; } - mGoingToDispatchAllMessages = false; - nsresult rv = mEventSource->CheckInnerWindowCorrectness(); if (NS_FAILED(rv)) { return; @@ -1510,9 +1507,7 @@ EventSourceImpl::DispatchAllMessageEvents() JSContext* cx = jsapi.cx(); while (mMessagesToDispatch.GetSize() > 0) { - nsAutoPtr - message(static_cast(mMessagesToDispatch.PopFront())); - + UniquePtr message(static_cast(mMessagesToDispatch.PopFront())); // Now we can turn our string into a jsval JS::Rooted jsData(cx); { @@ -1550,19 +1545,13 @@ EventSourceImpl::DispatchAllMessageEvents() } } -nsresult +void EventSourceImpl::ClearFields() { AssertIsOnTargetThread(); - // mLastEventID and mReconnectionTime must be cached - mCurrentMessage.mEventName.Truncate(); - mCurrentMessage.mLastEventID.Truncate(); - mCurrentMessage.mData.Truncate(); - + mCurrentMessage = nullptr; mLastFieldName.Truncate(); mLastFieldValue.Truncate(); - - return NS_OK; } nsresult @@ -1574,7 +1563,9 @@ EventSourceImpl::SetFieldAndClear() mLastFieldValue.Truncate(); return NS_OK; } - + if (!mCurrentMessage) { + mCurrentMessage = MakeUnique(); + } char16_t first_char; first_char = mLastFieldName.CharAt(0); @@ -1585,20 +1576,20 @@ EventSourceImpl::SetFieldAndClear() // If the field name is "data" append the field value to the data // buffer, then append a single U+000A LINE FEED (LF) character // to the data buffer. - mCurrentMessage.mData.Append(mLastFieldValue); - mCurrentMessage.mData.Append(LF_CHAR); + mCurrentMessage->mData.Append(mLastFieldValue); + mCurrentMessage->mData.Append(LF_CHAR); } break; case char16_t('e'): if (mLastFieldName.EqualsLiteral("event")) { - mCurrentMessage.mEventName.Assign(mLastFieldValue); + mCurrentMessage->mEventName.Assign(mLastFieldValue); } break; case char16_t('i'): if (mLastFieldName.EqualsLiteral("id")) { - mCurrentMessage.mLastEventID.Assign(mLastFieldValue); + mCurrentMessage->mLastEventID.Assign(mLastFieldValue); } break; -- cgit v1.2.3 From d6f18548a664b82489daeebf18fd3051f3edc8ac Mon Sep 17 00:00:00 2001 From: Brian Smith Date: Thu, 25 Aug 2022 21:59:08 -0500 Subject: Issue #1990 - Part 5 - Common up the skippability implementations that are basically copy/pastes of the DOMEventTargetHelper one. Mozilla Bug Bug 1333540. Skipped the renamed of various functions, but otherwise a direct port. --- dom/base/EventSource.cpp | 32 ++++++-------------------------- dom/base/EventSource.h | 4 ++-- dom/base/WebSocket.cpp | 32 ++++++-------------------------- dom/base/WebSocket.h | 4 ++-- dom/events/DOMEventTargetHelper.cpp | 5 +++-- dom/xhr/XMLHttpRequestMainThread.cpp | 31 +++++++------------------------ dom/xhr/XMLHttpRequestMainThread.h | 6 ++++-- 7 files changed, 30 insertions(+), 84 deletions(-) diff --git a/dom/base/EventSource.cpp b/dom/base/EventSource.cpp index 3bd1fae52d..35a7835cf4 100644 --- a/dom/base/EventSource.cpp +++ b/dom/base/EventSource.cpp @@ -2087,32 +2087,6 @@ EventSource::UpdateDontKeepAlive() NS_IMPL_CYCLE_COLLECTION_CLASS(EventSource) -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(EventSource) - bool isBlack = tmp->IsBlack(); - if (isBlack || tmp->mKeepingAlive) { - if (tmp->mListenerManager) { - tmp->mListenerManager->MarkForCC(); - } - if (!isBlack && tmp->PreservingWrapper()) { - // This marks the wrapper black. - tmp->GetWrapper(); - } - return true; - } -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END - -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(EventSource) - return tmp->IsBlack(); -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END - -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(EventSource) - return tmp->IsBlack(); -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END - -NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(EventSource, - DOMEventTargetHelper) -NS_IMPL_CYCLE_COLLECTION_TRACE_END - NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(EventSource, DOMEventTargetHelper) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END @@ -2125,6 +2099,12 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(EventSource, } NS_IMPL_CYCLE_COLLECTION_UNLINK_END +bool +EventSource::IsCertainlyAliveForCC() const +{ + return mKeepingAlive; +} + NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(EventSource) NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) diff --git a/dom/base/EventSource.h b/dom/base/EventSource.h index cd43481908..e36afac1d6 100644 --- a/dom/base/EventSource.h +++ b/dom/base/EventSource.h @@ -42,8 +42,8 @@ class EventSource final : public DOMEventTargetHelper friend class EventSourceImpl; public: NS_DECL_ISUPPORTS_INHERITED - NS_DECL_CYCLE_COLLECTION_SKIPPABLE_SCRIPT_HOLDER_CLASS_INHERITED( - EventSource, DOMEventTargetHelper) + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(EventSource, DOMEventTargetHelper) + virtual bool IsCertainlyAliveForCC() const override; // EventTarget void DisconnectFromOwner() override diff --git a/dom/base/WebSocket.cpp b/dom/base/WebSocket.cpp index 19a687cba3..fe06bc93a4 100644 --- a/dom/base/WebSocket.cpp +++ b/dom/base/WebSocket.cpp @@ -1402,32 +1402,6 @@ WebSocket::ConstructorCommon(const GlobalObject& aGlobal, NS_IMPL_CYCLE_COLLECTION_CLASS(WebSocket) -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(WebSocket) - bool isBlack = tmp->IsBlack(); - if (isBlack || tmp->mKeepingAlive) { - if (tmp->mListenerManager) { - tmp->mListenerManager->MarkForCC(); - } - if (!isBlack && tmp->PreservingWrapper()) { - // This marks the wrapper black. - tmp->GetWrapper(); - } - return true; - } -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END - -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(WebSocket) - return tmp->IsBlack(); -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END - -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(WebSocket) - return tmp->IsBlack(); -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END - -NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(WebSocket, - DOMEventTargetHelper) -NS_IMPL_CYCLE_COLLECTION_TRACE_END - NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(WebSocket, DOMEventTargetHelper) if (tmp->mImpl) { @@ -1444,6 +1418,12 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(WebSocket, } NS_IMPL_CYCLE_COLLECTION_UNLINK_END +bool +WebSocket::IsCertainlyAliveForCC() const +{ + return mKeepingAlive; +} + NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(WebSocket) NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) diff --git a/dom/base/WebSocket.h b/dom/base/WebSocket.h index 2eedeb3bab..605ef825c1 100644 --- a/dom/base/WebSocket.h +++ b/dom/base/WebSocket.h @@ -45,8 +45,8 @@ public: public: NS_DECL_ISUPPORTS_INHERITED - NS_DECL_CYCLE_COLLECTION_SKIPPABLE_SCRIPT_HOLDER_CLASS_INHERITED( - WebSocket, DOMEventTargetHelper) + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(WebSocket, DOMEventTargetHelper) + virtual bool IsCertainlyAliveForCC() const override; // EventTarget virtual void EventListenerAdded(nsIAtom* aType) override; diff --git a/dom/events/DOMEventTargetHelper.cpp b/dom/events/DOMEventTargetHelper.cpp index ef5b29fa5c..458d85215f 100644 --- a/dom/events/DOMEventTargetHelper.cpp +++ b/dom/events/DOMEventTargetHelper.cpp @@ -52,11 +52,12 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(DOMEventTargetHelper) NS_IMPL_CYCLE_COLLECTION_UNLINK_END NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(DOMEventTargetHelper) - if (tmp->IsBlack() || tmp->IsCertainlyAliveForCC()) { + bool isBlack = tmp->IsBlack(); + if (isBlack || tmp->IsCertainlyAliveForCC()) { if (tmp->mListenerManager) { tmp->mListenerManager->MarkForCC(); } - if (!tmp->IsBlack() && tmp->PreservingWrapper()) { + if (!isBlack && tmp->PreservingWrapper()) { // This marks the wrapper black. tmp->GetWrapper(); } diff --git a/dom/xhr/XMLHttpRequestMainThread.cpp b/dom/xhr/XMLHttpRequestMainThread.cpp index ad999c3584..2c3c3ce295 100644 --- a/dom/xhr/XMLHttpRequestMainThread.cpp +++ b/dom/xhr/XMLHttpRequestMainThread.cpp @@ -310,30 +310,7 @@ XMLHttpRequestMainThread::SetRequestObserver(nsIRequestObserver* aObserver) mRequestObserver = aObserver; } -NS_IMPL_CYCLE_COLLECTION_CLASS(XMLHttpRequestMainThread) - -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(XMLHttpRequestMainThread) - bool isBlack = tmp->IsBlack(); - if (isBlack || tmp->mWaitingForOnStopRequest) { - if (tmp->mListenerManager) { - tmp->mListenerManager->MarkForCC(); - } - if (!isBlack && tmp->PreservingWrapper()) { - // This marks the wrapper black. - tmp->GetWrapper(); - } - return true; - } -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END - -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(XMLHttpRequestMainThread) - return tmp-> - IsBlackAndDoesNotNeedTracing(static_cast(tmp)); -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END - -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(XMLHttpRequestMainThread) - return tmp->IsBlack(); -NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END + NS_IMPL_CYCLE_COLLECTION_CLASS(XMLHttpRequestMainThread) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(XMLHttpRequestMainThread, XMLHttpRequestEventTarget) @@ -380,6 +357,12 @@ NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(XMLHttpRequestMainThread, NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mResultJSON) NS_IMPL_CYCLE_COLLECTION_TRACE_END +bool +XMLHttpRequestMainThread::IsCertainlyAliveForCC() const +{ + return mWaitingForOnStopRequest; +} + // QueryInterface implementation for XMLHttpRequestMainThread NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(XMLHttpRequestMainThread) NS_INTERFACE_MAP_ENTRY(nsIXMLHttpRequest) diff --git a/dom/xhr/XMLHttpRequestMainThread.h b/dom/xhr/XMLHttpRequestMainThread.h index 5f1a729011..4a6eeec2ef 100644 --- a/dom/xhr/XMLHttpRequestMainThread.h +++ b/dom/xhr/XMLHttpRequestMainThread.h @@ -525,8 +525,10 @@ public: void SetRequestObserver(nsIRequestObserver* aObserver); - NS_DECL_CYCLE_COLLECTION_SKIPPABLE_SCRIPT_HOLDER_CLASS_INHERITED(XMLHttpRequestMainThread, - XMLHttpRequest) + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(XMLHttpRequestMainThread, + XMLHttpRequest) + virtual bool IsCertainlyAliveForCC() const override; + bool AllowUploadProgress(); virtual void DisconnectFromOwner() override; -- cgit v1.2.3 From 860800629b179e2598801749080911607334e678 Mon Sep 17 00:00:00 2001 From: Brian Smith Date: Fri, 26 Aug 2022 14:21:47 -0500 Subject: Issue #1990 - Part 6 - Fix for infinite loop from Release() on shutdown worker. If the worker is shut down, call Cancel() on the Runnable, this will prevent nsInputStreamReadyEvents to be called again when deallocated. --- dom/base/EventSource.cpp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/dom/base/EventSource.cpp b/dom/base/EventSource.cpp index 35a7835cf4..06cabc3098 100644 --- a/dom/base/EventSource.cpp +++ b/dom/base/EventSource.cpp @@ -1930,6 +1930,13 @@ EventSourceImpl::Dispatch(already_AddRefed aEvent, uint32_t aFlags) } if (IsShutDown()) { + // If the worker is shut down, we don't want to leave this event hanging. + // If it is a cancelable we should call Cancel() to make sure it stops. + // That way we can safely return NS_OK to prevent shutdown error messages. + nsCOMPtr cancelable = do_QueryInterface(event_ref); + if (cancelable) { + cancelable->Cancel(); + } return NS_OK; } MOZ_ASSERT(mWorkerPrivate); -- cgit v1.2.3