summaryrefslogtreecommitdiff
path: root/dom/base/EventSource.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/base/EventSource.cpp')
-rw-r--r--dom/base/EventSource.cpp1457
1 files changed, 1100 insertions, 357 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<EventSource> 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<nsIURI> mSrc;
+ uint32_t mReconnectionTime; // in ms
+ nsCOMPtr<nsIPrincipal> mPrincipal;
+ nsString mOrigin;
+ nsCOMPtr<nsITimer> mTimer;
+ nsCOMPtr<nsIHttpChannel> 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<nsIUnicodeDecoder> 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<WorkerHolder> 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<nsresult> 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<Message*>(mMessagesToDispatch.PopFront());
+ }
- nsCOMPtr<nsIObserverService> 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<CleanupRunnable> 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<Message*>(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<nsIScriptGlobalObject> sgo = do_QueryInterface(aOwner);
- NS_ENSURE_STATE(sgo);
- // XXXbz why are we checking this? This doesn't match anything in the spec.
- nsCOMPtr<nsIScriptContext> scriptContext = sgo->GetContext();
- NS_ENSURE_STATE(scriptContext);
-
- nsCOMPtr<nsIScriptObjectPrincipal> scriptPrincipal =
- do_QueryInterface(aOwner);
- NS_ENSURE_STATE(scriptPrincipal);
- nsCOMPtr<nsIPrincipal> 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<nsIPrincipal> 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<nsIDocument> doc = GetDocumentIfCurrent();
- if (doc) {
- mLoadGroup = doc->GetDocumentLoadGroup();
- }
+nsresult
+EventSourceImpl::ParseURL(const nsAString& aURL)
+{
+ AssertIsOnMainThread();
// get the src
nsCOMPtr<nsIURI> 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<nsIObserverService> 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<nsIObserverService> 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<JSObject*> aGivenProto)
-{
- return EventSourceBinding::Wrap(aCx, this, aGivenProto);
-}
-
-/* static */ already_AddRefed<EventSource>
-EventSource::Constructor(const GlobalObject& aGlobal,
- const nsAString& aURL,
- const EventSourceInit& aEventSourceInitDict,
- ErrorResult& aRv)
-{
- nsCOMPtr<nsPIDOMWindowInner> ownerWindow =
- do_QueryInterface(aGlobal.GetAsSupports());
- if (!ownerWindow) {
- aRv.Throw(NS_ERROR_UNEXPECTED);
- return nullptr;
- }
- MOZ_ASSERT(ownerWindow->IsInnerWindow());
-
- RefPtr<EventSource> 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<nsPIDOMWindowInner> window = do_QueryInterface(aSubject);
- if (!GetOwner() || window != GetOwner()) {
+ if (!mEventSource->GetOwner() || window != mEventSource->GetOwner()) {
return NS_OK;
}
DebugOnly<nsresult> 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<nsIThreadRetargetableRequest> 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<EventSource*>(aClosure);
+ EventSourceImpl* thisObject = static_cast<EventSourceImpl*>(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<EventSourceImpl> mEventSourceImpl;
+ UniquePtr<char[]> mData;
+ uint32_t mLength;
+ public:
+ DataAvailableRunnable(EventSourceImpl* aEventSourceImpl,
+ UniquePtr<char[]> 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<char[]>(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<nsIRunnable> 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<nsIRequest> 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<nsIChannelEventSink*>(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<nsIPromptFactory> wwatch =
@@ -554,8 +913,8 @@ EventSource::GetInterface(const nsIID & aIID,
// of the dialogs works as it should when using tabs.
nsCOMPtr<nsPIDOMWindowOuter> 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<nsIURI> baseURI;
// first we try from document->GetBaseURI()
- nsCOMPtr<nsIDocument> doc = GetDocumentIfCurrent();
+ nsCOMPtr<nsIDocument> 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<nsIDocument> doc = GetDocumentIfCurrent();
+ AssertIsOnMainThread();
+ nsCOMPtr<nsIDocument> 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<nsIDocument> doc = GetDocumentIfCurrent();
+ nsCOMPtr<nsIDocument> doc = mEventSource->GetDocumentIfCurrent();
nsSecurityFlags securityFlags =
nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS;
- if (mWithCredentials) {
+ if (mEventSource->mWithCredentials) {
securityFlags |= nsILoadInfo::SEC_COOKIES_INCLUDE;
}
nsCOMPtr<nsIChannel> channel;
// If we have the document, use it
if (doc) {
+ nsCOMPtr<nsILoadGroup> 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> 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<CallRestartConnection> 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> 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<nsIStringBundleService> 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> 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<EventSource> thisObject = static_cast<EventSource*>(aClosure);
+ AssertIsOnMainThread();
+ RefPtr<EventSourceImpl> thisObject = static_cast<EventSourceImpl*>(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<nsIRunnable> 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> 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<nsIRunnable> 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<MessageEvent> event = new MessageEvent(this, nullptr, nullptr);
+ RefPtr<MessageEvent> event = new MessageEvent(mEventSource, nullptr,
+ nullptr);
event->InitMessageEvent(nullptr, message->mEventName, false, false, jsData,
mOrigin, message->mLastEventID, nullptr,
Sequence<OwningNonNull<MessagePort>>());
event->SetTrusted(true);
- rv = DispatchDOMEvent(nullptr, static_cast<Event*>(event), nullptr,
- nullptr);
+ rv = mEventSource->DispatchDOMEvent(nullptr, static_cast<Event*>(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<EventSourceImpl> mEventSourceImpl;
+
+public:
+ WorkerRunnableDispatcher(EventSourceImpl* aImpl,
+ WorkerPrivate* aWorkerPrivate,
+ already_AddRefed<nsIRunnable> 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<nsIRunnable> 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<nsIRunnable> event(aEvent);
+ return Dispatch(event.forget(), aFlags);
+}
+
+NS_IMETHODIMP
+EventSourceImpl::Dispatch(already_AddRefed<nsIRunnable> aEvent, uint32_t aFlags)
+{
+ nsCOMPtr<nsIRunnable> 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<WorkerRunnableDispatcher> event =
+ new WorkerRunnableDispatcher(this, mWorkerPrivate, event_ref.forget());
+
+ if (!event->Dispatch()) {
+ return NS_ERROR_FAILURE;
+ }
+ return NS_OK;
+}
+
+
+NS_IMETHODIMP
+EventSourceImpl::DelayedDispatch(already_AddRefed<nsIRunnable> 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> 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>
+EventSource::Constructor(const GlobalObject& aGlobal, const nsAString& aURL,
+ const EventSourceInit& aEventSourceInitDict,
+ ErrorResult& aRv)
+{
+ nsCOMPtr<nsPIDOMWindowInner> ownerWindow =
+ do_QueryInterface(aGlobal.GetAsSupports());
+
+ MOZ_ASSERT(!NS_IsMainThread() ||
+ (ownerWindow && ownerWindow->IsInnerWindow()));
+
+ RefPtr<EventSource> eventSource =
+ new EventSource(ownerWindow, aEventSourceInitDict.mWithCredentials);
+ RefPtr<EventSourceImpl> eventSourceImp = eventSource->mImpl;
+
+ if (NS_IsMainThread()) {
+ // Get principal from document and init EventSourceImpl
+ nsCOMPtr<nsIScriptObjectPrincipal> scriptPrincipal =
+ do_QueryInterface(aGlobal.GetAsSupports());
+ if (!scriptPrincipal) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+ nsCOMPtr<nsIPrincipal> 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<InitRunnable> 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<JSObject*> 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
generated by cgit v1.2.3 (git 2.26.2) at 2024-11-10 00:10:23 +0000