diff options
Diffstat (limited to 'dom/base/EventSource.cpp')
| -rw-r--r-- | dom/base/EventSource.cpp | 1356 |
1 files changed, 1356 insertions, 0 deletions
diff --git a/dom/base/EventSource.cpp b/dom/base/EventSource.cpp new file mode 100644 index 000000000..754a2d13b --- /dev/null +++ b/dom/base/EventSource.cpp @@ -0,0 +1,1356 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/EventSource.h" + +#include "mozilla/ArrayUtils.h" +#include "mozilla/DebugOnly.h" +#include "mozilla/LoadInfo.h" +#include "mozilla/DOMEventTargetHelper.h" +#include "mozilla/dom/EventSourceBinding.h" +#include "mozilla/dom/MessageEvent.h" +#include "mozilla/dom/MessageEventBinding.h" +#include "mozilla/dom/ScriptSettings.h" + +#include "nsAutoPtr.h" +#include "nsNetUtil.h" +#include "nsIAuthPrompt.h" +#include "nsIAuthPrompt2.h" +#include "nsIInputStream.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsMimeTypes.h" +#include "nsIPromptFactory.h" +#include "nsIWindowWatcher.h" +#include "nsPresContext.h" +#include "nsContentPolicyUtils.h" +#include "nsIStringBundle.h" +#include "nsIConsoleService.h" +#include "nsIObserverService.h" +#include "nsIScriptObjectPrincipal.h" +#include "nsJSUtils.h" +#include "nsIAsyncVerifyRedirectCallback.h" +#include "nsIScriptError.h" +#include "mozilla/dom/EncodingUtils.h" +#include "nsIContentSecurityPolicy.h" +#include "nsContentUtils.h" +#include "mozilla/Preferences.h" +#include "xpcpublic.h" +#include "nsWrapperCacheInlines.h" +#include "mozilla/Attributes.h" +#include "nsError.h" + +namespace mozilla { +namespace dom { + +#define REPLACEMENT_CHAR (char16_t)0xFFFD +#define BOM_CHAR (char16_t)0xFEFF +#define SPACE_CHAR (char16_t)0x0020 +#define CR_CHAR (char16_t)0x000D +#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() +{ + Close(); +} + +//----------------------------------------------------------------------------- +// EventSource::nsISupports +//----------------------------------------------------------------------------- + +NS_IMPL_CYCLE_COLLECTION_CLASS(EventSource) + +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(); + } + 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(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 + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(EventSource, + DOMEventTargetHelper) + tmp->Close(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +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) + +NS_IMPL_ADDREF_INHERITED(EventSource, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(EventSource, DOMEventTargetHelper) + +void +EventSource::DisconnectFromOwner() +{ + DOMEventTargetHelper::DisconnectFromOwner(); + Close(); +} + +void +EventSource::Close() +{ + if (mReadyState == CLOSED) { + return; + } + + 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 (mTimer) { + mTimer->Cancel(); + mTimer = nullptr; + } + + ResetConnection(); + + ClearFields(); + + while (mMessagesToDispatch.GetSize() != 0) { + delete static_cast<Message*>(mMessagesToDispatch.PopFront()); + } + + mSrc = nullptr; + mFrozen = false; + + mUnicodeDecoder = nullptr; + + mReadyState = CLOSED; +} + +nsresult +EventSource::Init(nsISupports* aOwner, + const nsAString& aURL, + bool aWithCredentials) +{ + if (mReadyState != CONNECTING) { + return NS_ERROR_DOM_SECURITY_ERR; + } + + 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); + + mPrincipal = principal; + mWithCredentials = aWithCredentials; + + // The conditional here is historical and not necessarily sane. + if (JSContext *cx = nsContentUtils::GetCurrentJSContext()) { + nsJSUtils::GetCallingLocation(cx, mScriptFile, &mScriptLine, + &mScriptColumn); + mInnerWindowID = nsJSUtils::GetCurrentlyRunningCodeInnerWindowID(cx); + } + + // 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(); + } + // get the src + nsCOMPtr<nsIURI> baseURI; + nsresult rv = GetBaseURI(getter_AddRefs(baseURI)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIURI> srcURI; + 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 + nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService(); + NS_ENSURE_STATE(os); + + 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); + + nsAutoString origin; + rv = nsContentUtils::GetUTFOrigin(srcURI, origin); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoCString spec; + rv = srcURI->GetSpec(spec); + NS_ENSURE_SUCCESS(rv, rv); + + mOriginalURL = NS_ConvertUTF8toUTF16(spec); + mSrc = srcURI; + mOrigin = origin; + + mReconnectionTime = + Preferences::GetInt("dom.server-events.default-reconnection-time", + DEFAULT_RECONNECTION_TIME_VALUE); + + mUnicodeDecoder = EncodingUtils::DecoderForEncoding("UTF-8"); + + // the constructor should throw a SYNTAX_ERROR only if it fails resolving the + // 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 +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +EventSource::Observe(nsISupports* aSubject, + const char* aTopic, + const char16_t* aData) +{ + if (mReadyState == CLOSED) { + return NS_OK; + } + + nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(aSubject); + if (!GetOwner() || window != GetOwner()) { + return NS_OK; + } + + DebugOnly<nsresult> rv; + if (strcmp(aTopic, DOM_WINDOW_FROZEN_TOPIC) == 0) { + rv = Freeze(); + NS_ASSERTION(NS_SUCCEEDED(rv), "Freeze() failed"); + } else if (strcmp(aTopic, DOM_WINDOW_THAWED_TOPIC) == 0) { + rv = Thaw(); + NS_ASSERTION(NS_SUCCEEDED(rv), "Thaw() failed"); + } else if (strcmp(aTopic, DOM_WINDOW_DESTROYED_TOPIC) == 0) { + Close(); + } + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// EventSource::nsIStreamListener +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +EventSource::OnStartRequest(nsIRequest *aRequest, + nsISupports *ctxt) +{ + nsresult rv = CheckHealthOfRequestCallback(aRequest); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aRequest, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + nsresult status; + rv = aRequest->GetStatus(&status); + NS_ENSURE_SUCCESS(rv, rv); + + if (NS_FAILED(status)) { + // EventSource::OnStopRequest will evaluate if it shall either reestablish + // or fail the connection + return NS_ERROR_ABORT; + } + + uint32_t httpStatus; + rv = httpChannel->GetResponseStatus(&httpStatus); + NS_ENSURE_SUCCESS(rv, rv); + + if (httpStatus != 200) { + DispatchFailConnection(); + return NS_ERROR_ABORT; + } + + nsAutoCString contentType; + rv = httpChannel->GetContentType(contentType); + NS_ENSURE_SUCCESS(rv, rv); + + if (!contentType.EqualsLiteral(TEXT_EVENT_STREAM)) { + DispatchFailConnection(); + return NS_ERROR_ABORT; + } + + rv = NS_DispatchToMainThread(NewRunnableMethod(this, &EventSource::AnnounceConnection)); + 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) +{ + EventSource* thisObject = static_cast<EventSource*>(aClosure); + if (!thisObject || !aWriteCount) { + NS_WARNING("EventSource cannot read from stream: no aClosure or aWriteCount"); + return NS_ERROR_FAILURE; + } + + *aWriteCount = 0; + + int32_t srcCount, outCount; + char16_t out[2]; + nsresult rv; + + const char *p = aFromRawSegment, + *end = aFromRawSegment + aCount; + + do { + srcCount = aCount - (p - aFromRawSegment); + outCount = 2; + + thisObject->mLastConvertionResult = + thisObject->mUnicodeDecoder->Convert(p, &srcCount, out, &outCount); + MOZ_ASSERT(thisObject->mLastConvertionResult != NS_ERROR_ILLEGAL_INPUT); + + for (int32_t i = 0; i < outCount; ++i) { + rv = thisObject->ParseCharacter(out[i]); + NS_ENSURE_SUCCESS(rv, rv); + } + p = p + srcCount; + } while (p < end && + thisObject->mLastConvertionResult != NS_PARTIAL_MORE_INPUT && + thisObject->mLastConvertionResult != NS_OK); + + *aWriteCount = aCount; + return NS_OK; +} + +NS_IMETHODIMP +EventSource::OnDataAvailable(nsIRequest *aRequest, + nsISupports *aContext, + nsIInputStream *aInputStream, + uint64_t aOffset, + uint32_t aCount) +{ + NS_ENSURE_ARG_POINTER(aInputStream); + + nsresult rv = CheckHealthOfRequestCallback(aRequest); + NS_ENSURE_SUCCESS(rv, rv); + + uint32_t totalRead; + return aInputStream->ReadSegments(EventSource::StreamReaderFunc, this, + aCount, &totalRead); +} + +NS_IMETHODIMP +EventSource::OnStopRequest(nsIRequest *aRequest, + nsISupports *aContext, + nsresult aStatusCode) +{ + mWaitingForOnStopRequest = false; + + if (mReadyState == CLOSED) { + return NS_ERROR_ABORT; + } + + // "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. + // + // (...) the cancelation of the fetch algorithm by the user agent (e.g. in + // response to window.stop() or the user canceling the network connection + // manually) must cause the user agent to fail the connection. + + if (NS_FAILED(aStatusCode) && + aStatusCode != NS_ERROR_CONNECTION_REFUSED && + aStatusCode != NS_ERROR_NET_TIMEOUT && + aStatusCode != NS_ERROR_NET_RESET && + aStatusCode != NS_ERROR_NET_INTERRUPT && + aStatusCode != NS_ERROR_PROXY_CONNECTION_REFUSED && + aStatusCode != NS_ERROR_DNS_LOOKUP_QUEUE_FULL) { + DispatchFailConnection(); + return NS_ERROR_ABORT; + } + + nsresult rv = CheckHealthOfRequestCallback(aRequest); + NS_ENSURE_SUCCESS(rv, rv); + + ClearFields(); + + rv = NS_DispatchToMainThread(NewRunnableMethod(this, &EventSource::ReestablishConnection)); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// EventSource::nsIChannelEventSink +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +EventSource::AsyncOnChannelRedirect(nsIChannel *aOldChannel, + nsIChannel *aNewChannel, + uint32_t aFlags, + nsIAsyncVerifyRedirectCallback *aCallback) +{ + nsCOMPtr<nsIRequest> aOldRequest = do_QueryInterface(aOldChannel); + NS_PRECONDITION(aOldRequest, "Redirect from a null request?"); + + nsresult rv = CheckHealthOfRequestCallback(aOldRequest); + NS_ENSURE_SUCCESS(rv, rv); + + NS_PRECONDITION(aNewChannel, "Redirect without a channel?"); + + nsCOMPtr<nsIURI> newURI; + rv = NS_GetFinalChannelURI(aNewChannel, getter_AddRefs(newURI)); + NS_ENSURE_SUCCESS(rv, rv); + + bool isValidScheme = + (NS_SUCCEEDED(newURI->SchemeIs("http", &isValidScheme)) && isValidScheme) || + (NS_SUCCEEDED(newURI->SchemeIs("https", &isValidScheme)) && isValidScheme); + + rv = CheckInnerWindowCorrectness(); + if (NS_FAILED(rv) || !isValidScheme) { + DispatchFailConnection(); + return NS_ERROR_DOM_SECURITY_ERR; + } + + // update our channel + + mHttpChannel = do_QueryInterface(aNewChannel); + NS_ENSURE_STATE(mHttpChannel); + + SetupHttpChannel(); + // The HTTP impl already copies over the referrer and referrer policy on + // redirects, so we don't need to SetupReferrerPolicy(). + + if ((aFlags & nsIChannelEventSink::REDIRECT_PERMANENT) != 0) { + rv = NS_GetFinalChannelURI(mHttpChannel, getter_AddRefs(mSrc)); + NS_ENSURE_SUCCESS(rv, rv); + } + + aCallback->OnRedirectVerifyCallback(NS_OK); + + return NS_OK; +} + +//----------------------------------------------------------------------------- +// EventSource::nsIInterfaceRequestor +//----------------------------------------------------------------------------- + +NS_IMETHODIMP +EventSource::GetInterface(const nsIID & aIID, + void **aResult) +{ + if (aIID.Equals(NS_GET_IID(nsIChannelEventSink))) { + *aResult = static_cast<nsIChannelEventSink*>(this); + NS_ADDREF_THIS(); + return NS_OK; + } + + if (aIID.Equals(NS_GET_IID(nsIAuthPrompt)) || + aIID.Equals(NS_GET_IID(nsIAuthPrompt2))) { + nsresult rv = CheckInnerWindowCorrectness(); + NS_ENSURE_SUCCESS(rv, NS_ERROR_UNEXPECTED); + + nsCOMPtr<nsIPromptFactory> wwatch = + do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + // Get the an auth prompter for our window so that the parenting + // of the dialogs works as it should when using tabs. + + nsCOMPtr<nsPIDOMWindowOuter> window; + if (GetOwner()) { + window = GetOwner()->GetOuterWindow(); + } + + return wwatch->GetPrompt(window, aIID, aResult); + } + + return QueryInterface(aIID, aResult); +} + +nsresult +EventSource::GetBaseURI(nsIURI **aBaseURI) +{ + NS_ENSURE_ARG_POINTER(aBaseURI); + + *aBaseURI = nullptr; + + nsCOMPtr<nsIURI> baseURI; + + // first we try from document->GetBaseURI() + nsCOMPtr<nsIDocument> doc = GetDocumentIfCurrent(); + if (doc) { + baseURI = doc->GetBaseURI(); + } + + // otherwise we get from the doc's principal + if (!baseURI) { + nsresult rv = mPrincipal->GetURI(getter_AddRefs(baseURI)); + NS_ENSURE_SUCCESS(rv, rv); + } + + NS_ENSURE_STATE(baseURI); + + baseURI.forget(aBaseURI); + return NS_OK; +} + +void +EventSource::SetupHttpChannel() +{ + mHttpChannel->SetRequestMethod(NS_LITERAL_CSTRING("GET")); + + /* set the http request headers */ + + mHttpChannel->SetRequestHeader(NS_LITERAL_CSTRING("Accept"), + NS_LITERAL_CSTRING(TEXT_EVENT_STREAM), false); + + // LOAD_BYPASS_CACHE already adds the Cache-Control: no-cache header + + if (!mLastEventID.IsEmpty()) { + mHttpChannel->SetRequestHeader(NS_LITERAL_CSTRING("Last-Event-ID"), + NS_ConvertUTF16toUTF8(mLastEventID), false); + } +} + +nsresult +EventSource::SetupReferrerPolicy() +{ + nsCOMPtr<nsIDocument> doc = GetDocumentIfCurrent(); + if (doc) { + nsresult rv = mHttpChannel->SetReferrerWithPolicy(doc->GetDocumentURI(), + doc->GetReferrerPolicy()); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; +} + +nsresult +EventSource::InitChannelAndRequestEventSource() +{ + if (mReadyState == CLOSED) { + return NS_ERROR_ABORT; + } + + bool isValidScheme = + (NS_SUCCEEDED(mSrc->SchemeIs("http", &isValidScheme)) && isValidScheme) || + (NS_SUCCEEDED(mSrc->SchemeIs("https", &isValidScheme)) && isValidScheme); + + nsresult rv = CheckInnerWindowCorrectness(); + if (NS_FAILED(rv) || !isValidScheme) { + DispatchFailConnection(); + return NS_ERROR_DOM_SECURITY_ERR; + } + + nsLoadFlags loadFlags; + loadFlags = nsIRequest::LOAD_BACKGROUND | nsIRequest::LOAD_BYPASS_CACHE; + + nsCOMPtr<nsIDocument> doc = GetDocumentIfCurrent(); + + nsSecurityFlags securityFlags = + nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS; + + if (mWithCredentials) { + securityFlags |= nsILoadInfo::SEC_COOKIES_INCLUDE; + } + + nsCOMPtr<nsIChannel> channel; + // If we have the document, use it + if (doc) { + rv = NS_NewChannel(getter_AddRefs(channel), + mSrc, + doc, + securityFlags, + nsIContentPolicy::TYPE_INTERNAL_EVENTSOURCE, + mLoadGroup, // loadGroup + nullptr, // aCallbacks + loadFlags); // aLoadFlags + } else { + // otherwise use the principal + rv = NS_NewChannel(getter_AddRefs(channel), + mSrc, + mPrincipal, + securityFlags, + nsIContentPolicy::TYPE_INTERNAL_EVENTSOURCE, + mLoadGroup, // loadGroup + nullptr, // aCallbacks + loadFlags); // aLoadFlags + } + + NS_ENSURE_SUCCESS(rv, rv); + + mHttpChannel = do_QueryInterface(channel); + NS_ENSURE_TRUE(mHttpChannel, NS_ERROR_NO_INTERFACE); + + SetupHttpChannel(); + rv = SetupReferrerPolicy(); + NS_ENSURE_SUCCESS(rv, rv); + +#ifdef DEBUG + { + nsCOMPtr<nsIInterfaceRequestor> notificationCallbacks; + mHttpChannel->GetNotificationCallbacks(getter_AddRefs(notificationCallbacks)); + MOZ_ASSERT(!notificationCallbacks); + } +#endif + mHttpChannel->SetNotificationCallbacks(this); + + // Start reading from the channel + rv = mHttpChannel->AsyncOpen2(this); + if (NS_FAILED(rv)) { + DispatchFailConnection(); + return rv; + } + mWaitingForOnStopRequest = true; + return rv; +} + +void +EventSource::AnnounceConnection() +{ + if (mReadyState == CLOSED) { + return; + } + + if (mReadyState != CONNECTING) { + NS_WARNING("Unexpected mReadyState!!!"); + return; + } + + // When a user agent is to announce the connection, the user agent must set + // the readyState attribute to OPEN and queue a task to fire a simple event + // named open at the EventSource object. + + mReadyState = OPEN; + + nsresult 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("open"), false, false); + event->SetTrusted(true); + + rv = DispatchDOMEvent(nullptr, event, nullptr, nullptr); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to dispatch the open event!!!"); + return; + } +} + +nsresult +EventSource::ResetConnection() +{ + if (mHttpChannel) { + mHttpChannel->Cancel(NS_ERROR_ABORT); + } + + if (mUnicodeDecoder) { + mUnicodeDecoder->Reset(); + } + mLastConvertionResult = NS_OK; + + mHttpChannel = nullptr; + mStatus = PARSE_STATE_OFF; + + mReadyState = CONNECTING; + + return NS_OK; +} + +void +EventSource::ReestablishConnection() +{ + if (mReadyState == CLOSED) { + return; + } + + nsresult rv = ResetConnection(); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to reset the connection!!!"); + return; + } + + 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); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to dispatch the error event!!!"); + return; + } + + rv = SetReconnectionTimeout(); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to set the timeout for reestablishing the connection!!!"); + return; + } +} + +nsresult +EventSource::SetReconnectionTimeout() +{ + if (mReadyState == CLOSED) { + return NS_ERROR_ABORT; + } + + // the timer will be used whenever the requests are going finished. + if (!mTimer) { + mTimer = do_CreateInstance("@mozilla.org/timer;1"); + NS_ENSURE_STATE(mTimer); + } + + nsresult rv = mTimer->InitWithFuncCallback(TimerCallback, this, + mReconnectionTime, + nsITimer::TYPE_ONE_SHOT); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +EventSource::PrintErrorOnConsole(const char *aBundleURI, + const char16_t *aError, + const char16_t **aFormatStrings, + uint32_t aFormatStringsLen) +{ + nsCOMPtr<nsIStringBundleService> bundleService = + mozilla::services::GetStringBundleService(); + NS_ENSURE_STATE(bundleService); + + nsCOMPtr<nsIStringBundle> strBundle; + nsresult rv = + bundleService->CreateBundle(aBundleURI, getter_AddRefs(strBundle)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIConsoleService> console( + do_GetService(NS_CONSOLESERVICE_CONTRACTID, &rv)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIScriptError> errObj( + do_CreateInstance(NS_SCRIPTERROR_CONTRACTID, &rv)); + NS_ENSURE_SUCCESS(rv, rv); + + // Localize the error message + nsXPIDLString message; + if (aFormatStrings) { + rv = strBundle->FormatStringFromName(aError, aFormatStrings, + aFormatStringsLen, + getter_Copies(message)); + } else { + rv = strBundle->GetStringFromName(aError, getter_Copies(message)); + } + NS_ENSURE_SUCCESS(rv, rv); + + rv = errObj->InitWithWindowID(message, + mScriptFile, + EmptyString(), + mScriptLine, mScriptColumn, + nsIScriptError::errorFlag, + "Event Source", mInnerWindowID); + NS_ENSURE_SUCCESS(rv, rv); + + // print the error message directly to the JS console + rv = console->LogMessage(errObj); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +EventSource::ConsoleError() +{ + nsAutoCString targetSpec; + nsresult rv = mSrc->GetSpec(targetSpec); + NS_ENSURE_SUCCESS(rv, rv); + + NS_ConvertUTF8toUTF16 specUTF16(targetSpec); + const char16_t *formatStrings[] = { specUTF16.get() }; + + if (mReadyState == CONNECTING) { + rv = PrintErrorOnConsole("chrome://global/locale/appstrings.properties", + u"connectionFailure", + formatStrings, ArrayLength(formatStrings)); + } else { + rv = PrintErrorOnConsole("chrome://global/locale/appstrings.properties", + u"netInterrupt", + formatStrings, ArrayLength(formatStrings)); + } + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +EventSource::DispatchFailConnection() +{ + + return NS_DispatchToMainThread(NewRunnableMethod(this, &EventSource::FailConnection)); +} + +void +EventSource::FailConnection() +{ + if (mReadyState == CLOSED) { + return; + } + + nsresult rv = ConsoleError(); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to print to the console error"); + } + + // 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)) { + 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; + } +} + +// static +void +EventSource::TimerCallback(nsITimer* aTimer, void* aClosure) +{ + RefPtr<EventSource> thisObject = static_cast<EventSource*>(aClosure); + + if (thisObject->mReadyState == CLOSED) { + return; + } + + NS_PRECONDITION(!thisObject->mHttpChannel, + "the channel hasn't been cancelled!!"); + + if (!thisObject->mFrozen) { + nsresult rv = thisObject->InitChannelAndRequestEventSource(); + if (NS_FAILED(rv)) { + NS_WARNING("thisObject->InitChannelAndRequestEventSource() failed"); + return; + } + } +} + +nsresult +EventSource::Thaw() +{ + if (mReadyState == CLOSED || !mFrozen) { + return NS_OK; + } + + NS_ASSERTION(!mHttpChannel, "the connection hasn't been closed!!!"); + + mFrozen = false; + nsresult rv; + if (!mGoingToDispatchAllMessages && mMessagesToDispatch.GetSize() > 0) { + nsCOMPtr<nsIRunnable> event = + NewRunnableMethod(this, &EventSource::DispatchAllMessageEvents); + NS_ENSURE_STATE(event); + + mGoingToDispatchAllMessages = true; + + rv = NS_DispatchToMainThread(event); + NS_ENSURE_SUCCESS(rv, rv); + } + + rv = InitChannelAndRequestEventSource(); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +EventSource::Freeze() +{ + if (mReadyState == CLOSED || mFrozen) { + return NS_OK; + } + + NS_ASSERTION(!mHttpChannel, "the connection hasn't been closed!!!"); + mFrozen = true; + return NS_OK; +} + +nsresult +EventSource::DispatchCurrentMessageEvent() +{ + nsAutoPtr<Message> message(new Message()); + *message = mCurrentMessage; + + ClearFields(); + + if (message->mData.IsEmpty()) { + return NS_OK; + } + + // removes the trailing LF from mData + NS_ASSERTION(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()) { + message->mEventName.AssignLiteral("message"); + } + + if (message->mLastEventID.IsEmpty() && !mLastEventID.IsEmpty()) { + message->mLastEventID.Assign(mLastEventID); + } + + size_t sizeBefore = mMessagesToDispatch.GetSize(); + mMessagesToDispatch.Push(message.forget()); + NS_ENSURE_TRUE(mMessagesToDispatch.GetSize() == sizeBefore + 1, + NS_ERROR_OUT_OF_MEMORY); + + + if (!mGoingToDispatchAllMessages) { + nsCOMPtr<nsIRunnable> event = + NewRunnableMethod(this, &EventSource::DispatchAllMessageEvents); + NS_ENSURE_STATE(event); + + mGoingToDispatchAllMessages = true; + + return NS_DispatchToMainThread(event); + } + + return NS_OK; +} + +void +EventSource::DispatchAllMessageEvents() +{ + if (mReadyState == CLOSED || mFrozen) { + return; + } + + mGoingToDispatchAllMessages = false; + + nsresult rv = CheckInnerWindowCorrectness(); + if (NS_FAILED(rv)) { + return; + } + + AutoJSAPI jsapi; + if (NS_WARN_IF(!jsapi.Init(GetOwner()))) { + return; + } + JSContext* cx = jsapi.cx(); + + while (mMessagesToDispatch.GetSize() > 0) { + nsAutoPtr<Message> + message(static_cast<Message*>(mMessagesToDispatch.PopFront())); + + // Now we can turn our string into a jsval + JS::Rooted<JS::Value> jsData(cx); + { + JSString* jsString; + jsString = JS_NewUCStringCopyN(cx, + message->mData.get(), + message->mData.Length()); + NS_ENSURE_TRUE_VOID(jsString); + + jsData.setString(jsString); + } + + // 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); + + 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); + if (NS_FAILED(rv)) { + NS_WARNING("Failed to dispatch the message event!!!"); + return; + } + + mLastEventID.Assign(message->mLastEventID); + } +} + +nsresult +EventSource::ClearFields() +{ + // mLastEventID and mReconnectionTime must be cached + + mCurrentMessage.mEventName.Truncate(); + mCurrentMessage.mLastEventID.Truncate(); + mCurrentMessage.mData.Truncate(); + + mLastFieldName.Truncate(); + mLastFieldValue.Truncate(); + + return NS_OK; +} + +nsresult +EventSource::SetFieldAndClear() +{ + if (mLastFieldName.IsEmpty()) { + mLastFieldValue.Truncate(); + return NS_OK; + } + + char16_t first_char; + first_char = mLastFieldName.CharAt(0); + + switch (first_char) // with no case folding performed + { + case char16_t('d'): + if (mLastFieldName.EqualsLiteral("data")) { + // 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); + } + break; + + case char16_t('e'): + if (mLastFieldName.EqualsLiteral("event")) { + mCurrentMessage.mEventName.Assign(mLastFieldValue); + } + break; + + case char16_t('i'): + if (mLastFieldName.EqualsLiteral("id")) { + mCurrentMessage.mLastEventID.Assign(mLastFieldValue); + } + break; + + case char16_t('r'): + if (mLastFieldName.EqualsLiteral("retry")) { + 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) { + if (mLastFieldValue.CharAt(i) < (char16_t)'0' || + mLastFieldValue.CharAt(i) > (char16_t)'9') { + assign = false; + break; + } + newValue = newValue*10 + + (((uint32_t)mLastFieldValue.CharAt(i))- + ((uint32_t)((char16_t)'0'))); + } + + if (assign) { + if (newValue < MIN_RECONNECTION_TIME_VALUE) { + mReconnectionTime = MIN_RECONNECTION_TIME_VALUE; + } else if (newValue > MAX_RECONNECTION_TIME_VALUE) { + mReconnectionTime = MAX_RECONNECTION_TIME_VALUE; + } else { + mReconnectionTime = newValue; + } + } + break; + } + break; + } + + mLastFieldName.Truncate(); + mLastFieldValue.Truncate(); + + return NS_OK; +} + +nsresult +EventSource::CheckHealthOfRequestCallback(nsIRequest *aRequestCallback) +{ + // 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) { + return NS_ERROR_ABORT; + } + + nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aRequestCallback); + NS_ENSURE_STATE(httpChannel); + + if (httpChannel != mHttpChannel) { + NS_WARNING("wrong channel from request callback"); + return NS_ERROR_ABORT; + } + + return NS_OK; +} + +nsresult +EventSource::ParseCharacter(char16_t aChr) +{ + nsresult rv; + + if (mReadyState == CLOSED) { + return NS_ERROR_ABORT; + } + + switch (mStatus) + { + case PARSE_STATE_OFF: + NS_ERROR("Invalid state"); + return NS_ERROR_FAILURE; + break; + + case PARSE_STATE_BEGIN_OF_STREAM: + if (aChr == BOM_CHAR) { + mStatus = PARSE_STATE_BOM_WAS_READ; // ignore it + } else if (aChr == CR_CHAR) { + mStatus = PARSE_STATE_CR_CHAR; + } else if (aChr == LF_CHAR) { + mStatus = PARSE_STATE_BEGIN_OF_LINE; + } else if (aChr == COLON_CHAR) { + mStatus = PARSE_STATE_COMMENT; + } else { + mLastFieldName += aChr; + mStatus = PARSE_STATE_FIELD_NAME; + } + + break; + + case PARSE_STATE_BOM_WAS_READ: + if (aChr == CR_CHAR) { + mStatus = PARSE_STATE_CR_CHAR; + } else if (aChr == LF_CHAR) { + mStatus = PARSE_STATE_BEGIN_OF_LINE; + } else if (aChr == COLON_CHAR) { + mStatus = PARSE_STATE_COMMENT; + } else { + mLastFieldName += aChr; + mStatus = PARSE_STATE_FIELD_NAME; + } + break; + + case PARSE_STATE_CR_CHAR: + if (aChr == CR_CHAR) { + rv = DispatchCurrentMessageEvent(); // there is an empty line (CRCR) + NS_ENSURE_SUCCESS(rv, rv); + } else if (aChr == LF_CHAR) { + mStatus = PARSE_STATE_BEGIN_OF_LINE; + } else if (aChr == COLON_CHAR) { + mStatus = PARSE_STATE_COMMENT; + } else { + mLastFieldName += aChr; + mStatus = PARSE_STATE_FIELD_NAME; + } + + break; + + case PARSE_STATE_COMMENT: + if (aChr == CR_CHAR) { + mStatus = PARSE_STATE_CR_CHAR; + } else if (aChr == LF_CHAR) { + mStatus = PARSE_STATE_BEGIN_OF_LINE; + } + + break; + + case PARSE_STATE_FIELD_NAME: + if (aChr == CR_CHAR) { + rv = SetFieldAndClear(); + NS_ENSURE_SUCCESS(rv, rv); + + mStatus = PARSE_STATE_CR_CHAR; + } else if (aChr == LF_CHAR) { + rv = SetFieldAndClear(); + NS_ENSURE_SUCCESS(rv, rv); + + mStatus = PARSE_STATE_BEGIN_OF_LINE; + } else if (aChr == COLON_CHAR) { + mStatus = PARSE_STATE_FIRST_CHAR_OF_FIELD_VALUE; + } else { + mLastFieldName += aChr; + } + + break; + + case PARSE_STATE_FIRST_CHAR_OF_FIELD_VALUE: + if (aChr == CR_CHAR) { + rv = SetFieldAndClear(); + NS_ENSURE_SUCCESS(rv, rv); + + mStatus = PARSE_STATE_CR_CHAR; + } else if (aChr == LF_CHAR) { + rv = SetFieldAndClear(); + NS_ENSURE_SUCCESS(rv, rv); + + mStatus = PARSE_STATE_BEGIN_OF_LINE; + } else if (aChr == SPACE_CHAR) { + mStatus = PARSE_STATE_FIELD_VALUE; + } else { + mLastFieldValue += aChr; + mStatus = PARSE_STATE_FIELD_VALUE; + } + + break; + + case PARSE_STATE_FIELD_VALUE: + if (aChr == CR_CHAR) { + rv = SetFieldAndClear(); + NS_ENSURE_SUCCESS(rv, rv); + + mStatus = PARSE_STATE_CR_CHAR; + } else if (aChr == LF_CHAR) { + rv = SetFieldAndClear(); + NS_ENSURE_SUCCESS(rv, rv); + + mStatus = PARSE_STATE_BEGIN_OF_LINE; + } else { + mLastFieldValue += aChr; + } + + break; + + case PARSE_STATE_BEGIN_OF_LINE: + if (aChr == CR_CHAR) { + rv = DispatchCurrentMessageEvent(); // there is an empty line + NS_ENSURE_SUCCESS(rv, rv); + + mStatus = PARSE_STATE_CR_CHAR; + } else if (aChr == LF_CHAR) { + rv = DispatchCurrentMessageEvent(); // there is an empty line + NS_ENSURE_SUCCESS(rv, rv); + + mStatus = PARSE_STATE_BEGIN_OF_LINE; + } else if (aChr == COLON_CHAR) { + mStatus = PARSE_STATE_COMMENT; + } else { + mLastFieldName += aChr; + mStatus = PARSE_STATE_FIELD_NAME; + } + + break; + } + + return NS_OK; +} + +} // namespace dom +} // namespace mozilla |