summaryrefslogtreecommitdiffstats
path: root/dom/workers/ServiceWorkerPrivate.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/workers/ServiceWorkerPrivate.cpp')
-rw-r--r--dom/workers/ServiceWorkerPrivate.cpp2088
1 files changed, 2088 insertions, 0 deletions
diff --git a/dom/workers/ServiceWorkerPrivate.cpp b/dom/workers/ServiceWorkerPrivate.cpp
new file mode 100644
index 000000000..eaa548f95
--- /dev/null
+++ b/dom/workers/ServiceWorkerPrivate.cpp
@@ -0,0 +1,2088 @@
+/* -*- 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 "ServiceWorkerPrivate.h"
+
+#include "ServiceWorkerManager.h"
+#include "nsContentUtils.h"
+#include "nsIHttpChannelInternal.h"
+#include "nsIHttpHeaderVisitor.h"
+#include "nsINetworkInterceptController.h"
+#include "nsIPushErrorReporter.h"
+#include "nsISupportsImpl.h"
+#include "nsIUploadChannel2.h"
+#include "nsNetUtil.h"
+#include "nsProxyRelease.h"
+#include "nsQueryObject.h"
+#include "nsStreamUtils.h"
+#include "nsStringStream.h"
+#include "WorkerRunnable.h"
+#include "WorkerScope.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/dom/FetchUtil.h"
+#include "mozilla/dom/IndexedDatabaseManager.h"
+#include "mozilla/dom/InternalHeaders.h"
+#include "mozilla/dom/NotificationEvent.h"
+#include "mozilla/dom/PromiseNativeHandler.h"
+#include "mozilla/dom/PushEventBinding.h"
+#include "mozilla/dom/RequestBinding.h"
+#include "mozilla/Unused.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+BEGIN_WORKERS_NAMESPACE
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(ServiceWorkerPrivate)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(ServiceWorkerPrivate)
+NS_IMPL_CYCLE_COLLECTION(ServiceWorkerPrivate, mSupportsArray)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ServiceWorkerPrivate)
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver)
+NS_INTERFACE_MAP_END
+
+// Tracks the "dom.disable_open_click_delay" preference. Modified on main
+// thread, read on worker threads.
+// It is updated every time a "notificationclick" event is dispatched. While
+// this is done without synchronization, at the worst, the thread will just get
+// an older value within which a popup is allowed to be displayed, which will
+// still be a valid value since it was set prior to dispatching the runnable.
+Atomic<uint32_t> gDOMDisableOpenClickDelay(0);
+
+// Used to keep track of pending waitUntil as well as in-flight extendable events.
+// When the last token is released, we attempt to terminate the worker.
+class KeepAliveToken final : public nsISupports
+{
+public:
+ NS_DECL_ISUPPORTS
+
+ explicit KeepAliveToken(ServiceWorkerPrivate* aPrivate)
+ : mPrivate(aPrivate)
+ {
+ AssertIsOnMainThread();
+ MOZ_ASSERT(aPrivate);
+ mPrivate->AddToken();
+ }
+
+private:
+ ~KeepAliveToken()
+ {
+ AssertIsOnMainThread();
+ mPrivate->ReleaseToken();
+ }
+
+ RefPtr<ServiceWorkerPrivate> mPrivate;
+};
+
+NS_IMPL_ISUPPORTS0(KeepAliveToken)
+
+ServiceWorkerPrivate::ServiceWorkerPrivate(ServiceWorkerInfo* aInfo)
+ : mInfo(aInfo)
+ , mDebuggerCount(0)
+ , mTokenCount(0)
+{
+ AssertIsOnMainThread();
+ MOZ_ASSERT(aInfo);
+
+ mIdleWorkerTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
+ MOZ_ASSERT(mIdleWorkerTimer);
+}
+
+ServiceWorkerPrivate::~ServiceWorkerPrivate()
+{
+ MOZ_ASSERT(!mWorkerPrivate);
+ MOZ_ASSERT(!mTokenCount);
+ MOZ_ASSERT(!mInfo);
+ MOZ_ASSERT(mSupportsArray.IsEmpty());
+
+ mIdleWorkerTimer->Cancel();
+}
+
+namespace {
+
+class MessageWaitUntilHandler final : public PromiseNativeHandler
+{
+ nsMainThreadPtrHandle<nsISupports> mKeepAliveToken;
+
+ ~MessageWaitUntilHandler()
+ {
+ }
+
+public:
+ explicit MessageWaitUntilHandler(const nsMainThreadPtrHandle<nsISupports>& aKeepAliveToken)
+ : mKeepAliveToken(aKeepAliveToken)
+ {
+ MOZ_ASSERT(mKeepAliveToken);
+ }
+
+ void
+ ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override
+ {
+ mKeepAliveToken = nullptr;
+ }
+
+ void
+ RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override
+ {
+ mKeepAliveToken = nullptr;
+ }
+
+ NS_DECL_THREADSAFE_ISUPPORTS
+};
+
+NS_IMPL_ISUPPORTS0(MessageWaitUntilHandler)
+
+} // anonymous namespace
+
+nsresult
+ServiceWorkerPrivate::SendMessageEvent(JSContext* aCx,
+ JS::Handle<JS::Value> aMessage,
+ const Optional<Sequence<JS::Value>>& aTransferable,
+ UniquePtr<ServiceWorkerClientInfo>&& aClientInfo)
+{
+ ErrorResult rv(SpawnWorkerIfNeeded(MessageEvent, nullptr));
+ if (NS_WARN_IF(rv.Failed())) {
+ return rv.StealNSResult();
+ }
+
+ nsMainThreadPtrHandle<nsISupports> token(
+ new nsMainThreadPtrHolder<nsISupports>(CreateEventKeepAliveToken()));
+
+ RefPtr<PromiseNativeHandler> handler = new MessageWaitUntilHandler(token);
+
+ mWorkerPrivate->PostMessageToServiceWorker(aCx, aMessage, aTransferable,
+ Move(aClientInfo), handler,
+ rv);
+ return rv.StealNSResult();
+}
+
+namespace {
+
+class CheckScriptEvaluationWithCallback final : public WorkerRunnable
+{
+ nsMainThreadPtrHandle<KeepAliveToken> mKeepAliveToken;
+ RefPtr<LifeCycleEventCallback> mCallback;
+#ifdef DEBUG
+ bool mDone;
+#endif
+
+public:
+ CheckScriptEvaluationWithCallback(WorkerPrivate* aWorkerPrivate,
+ KeepAliveToken* aKeepAliveToken,
+ LifeCycleEventCallback* aCallback)
+ : WorkerRunnable(aWorkerPrivate)
+ , mKeepAliveToken(new nsMainThreadPtrHolder<KeepAliveToken>(aKeepAliveToken))
+ , mCallback(aCallback)
+#ifdef DEBUG
+ , mDone(false)
+#endif
+ {
+ AssertIsOnMainThread();
+ }
+
+ ~CheckScriptEvaluationWithCallback()
+ {
+ MOZ_ASSERT(mDone);
+ }
+
+ bool
+ WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
+ {
+ aWorkerPrivate->AssertIsOnWorkerThread();
+ Done(aWorkerPrivate->WorkerScriptExecutedSuccessfully());
+
+ return true;
+ }
+
+ nsresult
+ Cancel() override
+ {
+ Done(false);
+ return WorkerRunnable::Cancel();
+ }
+
+private:
+ void
+ Done(bool aResult)
+ {
+#ifdef DEBUG
+ mDone = true;
+#endif
+ mCallback->SetResult(aResult);
+ MOZ_ALWAYS_SUCCEEDS(mWorkerPrivate->DispatchToMainThread(mCallback));
+ }
+};
+
+} // anonymous namespace
+
+nsresult
+ServiceWorkerPrivate::CheckScriptEvaluation(LifeCycleEventCallback* aCallback)
+{
+ nsresult rv = SpawnWorkerIfNeeded(LifeCycleEvent, nullptr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<KeepAliveToken> token = CreateEventKeepAliveToken();
+ RefPtr<WorkerRunnable> r = new CheckScriptEvaluationWithCallback(mWorkerPrivate,
+ token,
+ aCallback);
+ if (NS_WARN_IF(!r->Dispatch())) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+namespace {
+
+// Holds the worker alive until the waitUntil promise is resolved or
+// rejected.
+class KeepAliveHandler final
+{
+ // Use an internal class to listen for the promise resolve/reject
+ // callbacks. This class also registers a feature so that it can
+ // preemptively cleanup if the service worker is timed out and
+ // terminated.
+ class InternalHandler final : public PromiseNativeHandler
+ , public WorkerHolder
+ {
+ nsMainThreadPtrHandle<KeepAliveToken> mKeepAliveToken;
+
+ // Worker thread only
+ WorkerPrivate* mWorkerPrivate;
+ RefPtr<Promise> mPromise;
+ bool mWorkerHolderAdded;
+
+ ~InternalHandler()
+ {
+ MaybeCleanup();
+ }
+
+ bool
+ UseWorkerHolder()
+ {
+ MOZ_ASSERT(mWorkerPrivate);
+ mWorkerPrivate->AssertIsOnWorkerThread();
+ MOZ_ASSERT(!mWorkerHolderAdded);
+ mWorkerHolderAdded = HoldWorker(mWorkerPrivate, Terminating);
+ return mWorkerHolderAdded;
+ }
+
+ void
+ MaybeCleanup()
+ {
+ MOZ_ASSERT(mWorkerPrivate);
+ mWorkerPrivate->AssertIsOnWorkerThread();
+ if (!mPromise) {
+ return;
+ }
+ if (mWorkerHolderAdded) {
+ ReleaseWorker();
+ }
+ mPromise = nullptr;
+ mKeepAliveToken = nullptr;
+ }
+
+ void
+ ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override
+ {
+ MOZ_ASSERT(mWorkerPrivate);
+ mWorkerPrivate->AssertIsOnWorkerThread();
+ MaybeCleanup();
+ }
+
+ void
+ RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override
+ {
+ MOZ_ASSERT(mWorkerPrivate);
+ mWorkerPrivate->AssertIsOnWorkerThread();
+ MaybeCleanup();
+ }
+
+ bool
+ Notify(Status aStatus) override
+ {
+ MOZ_ASSERT(mWorkerPrivate);
+ mWorkerPrivate->AssertIsOnWorkerThread();
+ if (aStatus < Terminating) {
+ return true;
+ }
+ MaybeCleanup();
+ return true;
+ }
+
+ InternalHandler(const nsMainThreadPtrHandle<KeepAliveToken>& aKeepAliveToken,
+ WorkerPrivate* aWorkerPrivate,
+ Promise* aPromise)
+ : mKeepAliveToken(aKeepAliveToken)
+ , mWorkerPrivate(aWorkerPrivate)
+ , mPromise(aPromise)
+ , mWorkerHolderAdded(false)
+ {
+ MOZ_ASSERT(mKeepAliveToken);
+ MOZ_ASSERT(mWorkerPrivate);
+ MOZ_ASSERT(mPromise);
+ }
+
+ public:
+ static already_AddRefed<InternalHandler>
+ Create(const nsMainThreadPtrHandle<KeepAliveToken>& aKeepAliveToken,
+ WorkerPrivate* aWorkerPrivate,
+ Promise* aPromise)
+ {
+ RefPtr<InternalHandler> ref = new InternalHandler(aKeepAliveToken,
+ aWorkerPrivate,
+ aPromise);
+
+ if (NS_WARN_IF(!ref->UseWorkerHolder())) {
+ return nullptr;
+ }
+
+ return ref.forget();
+ }
+
+ NS_DECL_ISUPPORTS
+ };
+
+ // This is really just a wrapper class to keep the InternalHandler
+ // private. We don't want any code to accidentally call
+ // Promise::AppendNativeHandler() without also referencing the promise.
+ // Therefore we force all code through the static CreateAndAttachToPromise()
+ // and use the private InternalHandler object.
+ KeepAliveHandler() = delete;
+ ~KeepAliveHandler() = delete;
+
+public:
+ // Create a private handler object and attach it to the given Promise.
+ // This will also create a strong ref to the Promise in a ref cycle. The
+ // ref cycle is broken when the Promise is fulfilled or the worker thread
+ // is Terminated.
+ static void
+ CreateAndAttachToPromise(const nsMainThreadPtrHandle<KeepAliveToken>& aKeepAliveToken,
+ Promise* aPromise)
+ {
+ WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
+ MOZ_ASSERT(workerPrivate);
+ workerPrivate->AssertIsOnWorkerThread();
+ MOZ_ASSERT(aKeepAliveToken);
+ MOZ_ASSERT(aPromise);
+
+ // This creates a strong ref to the promise.
+ RefPtr<InternalHandler> handler = InternalHandler::Create(aKeepAliveToken,
+ workerPrivate,
+ aPromise);
+ if (NS_WARN_IF(!handler)) {
+ return;
+ }
+
+ // This then creates a strong ref cycle between the promise and the
+ // handler. The cycle is broken when the Promise is fulfilled or
+ // the worker thread is Terminated.
+ aPromise->AppendNativeHandler(handler);
+ }
+};
+
+NS_IMPL_ISUPPORTS0(KeepAliveHandler::InternalHandler)
+
+class RegistrationUpdateRunnable : public Runnable
+{
+ nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> mRegistration;
+ const bool mNeedTimeCheck;
+
+public:
+ RegistrationUpdateRunnable(nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration,
+ bool aNeedTimeCheck)
+ : mRegistration(aRegistration)
+ , mNeedTimeCheck(aNeedTimeCheck)
+ {
+ MOZ_DIAGNOSTIC_ASSERT(mRegistration);
+ }
+
+ NS_IMETHOD
+ Run() override
+ {
+ if (mNeedTimeCheck) {
+ mRegistration->MaybeScheduleTimeCheckAndUpdate();
+ } else {
+ mRegistration->MaybeScheduleUpdate();
+ }
+ return NS_OK;
+ }
+};
+
+class ExtendableEventWorkerRunnable : public WorkerRunnable
+{
+protected:
+ nsMainThreadPtrHandle<KeepAliveToken> mKeepAliveToken;
+
+public:
+ ExtendableEventWorkerRunnable(WorkerPrivate* aWorkerPrivate,
+ KeepAliveToken* aKeepAliveToken)
+ : WorkerRunnable(aWorkerPrivate)
+ {
+ AssertIsOnMainThread();
+ MOZ_ASSERT(aWorkerPrivate);
+ MOZ_ASSERT(aKeepAliveToken);
+
+ mKeepAliveToken =
+ new nsMainThreadPtrHolder<KeepAliveToken>(aKeepAliveToken);
+ }
+
+ bool
+ DispatchExtendableEventOnWorkerScope(JSContext* aCx,
+ WorkerGlobalScope* aWorkerScope,
+ ExtendableEvent* aEvent,
+ PromiseNativeHandler* aPromiseHandler)
+ {
+ MOZ_ASSERT(aWorkerScope);
+ MOZ_ASSERT(aEvent);
+ nsCOMPtr<nsIGlobalObject> sgo = aWorkerScope;
+ WidgetEvent* internalEvent = aEvent->WidgetEventPtr();
+
+ ErrorResult result;
+ result = aWorkerScope->DispatchDOMEvent(nullptr, aEvent, nullptr, nullptr);
+ if (NS_WARN_IF(result.Failed()) || internalEvent->mFlags.mExceptionWasRaised) {
+ result.SuppressException();
+ return false;
+ }
+
+ RefPtr<Promise> waitUntilPromise = aEvent->GetPromise();
+ if (!waitUntilPromise) {
+ waitUntilPromise =
+ Promise::Resolve(sgo, aCx, JS::UndefinedHandleValue, result);
+ MOZ_RELEASE_ASSERT(!result.Failed());
+ }
+
+ MOZ_ASSERT(waitUntilPromise);
+
+ // Make sure to append the caller's promise handler before attaching
+ // our keep alive handler. This can avoid terminating the worker
+ // before a success result is delivered to the caller in cases where
+ // the idle timeout has been set to zero. This low timeout value is
+ // sometimes set in tests.
+ if (aPromiseHandler) {
+ waitUntilPromise->AppendNativeHandler(aPromiseHandler);
+ }
+
+ KeepAliveHandler::CreateAndAttachToPromise(mKeepAliveToken,
+ waitUntilPromise);
+
+ return true;
+ }
+};
+
+// Handle functional event
+// 9.9.7 If the time difference in seconds calculated by the current time minus
+// registration's last update check time is greater than 86400, invoke Soft Update
+// algorithm.
+class ExtendableFunctionalEventWorkerRunnable : public ExtendableEventWorkerRunnable
+{
+protected:
+ nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> mRegistration;
+public:
+ ExtendableFunctionalEventWorkerRunnable(WorkerPrivate* aWorkerPrivate,
+ KeepAliveToken* aKeepAliveToken,
+ nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration)
+ : ExtendableEventWorkerRunnable(aWorkerPrivate, aKeepAliveToken)
+ , mRegistration(aRegistration)
+ {
+ MOZ_DIAGNOSTIC_ASSERT(aRegistration);
+ }
+
+ void
+ PostRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate, bool aRunResult)
+ {
+ // Sub-class PreRun() or WorkerRun() methods could clear our mRegistration.
+ if (mRegistration) {
+ nsCOMPtr<nsIRunnable> runnable =
+ new RegistrationUpdateRunnable(mRegistration, true /* time check */);
+ aWorkerPrivate->DispatchToMainThread(runnable.forget());
+ }
+
+ ExtendableEventWorkerRunnable::PostRun(aCx, aWorkerPrivate, aRunResult);
+ }
+};
+
+/*
+ * Fires 'install' event on the ServiceWorkerGlobalScope. Modifies busy count
+ * since it fires the event. This is ok since there can't be nested
+ * ServiceWorkers, so the parent thread -> worker thread requirement for
+ * runnables is satisfied.
+ */
+class LifecycleEventWorkerRunnable : public ExtendableEventWorkerRunnable
+{
+ nsString mEventName;
+ RefPtr<LifeCycleEventCallback> mCallback;
+
+public:
+ LifecycleEventWorkerRunnable(WorkerPrivate* aWorkerPrivate,
+ KeepAliveToken* aToken,
+ const nsAString& aEventName,
+ LifeCycleEventCallback* aCallback)
+ : ExtendableEventWorkerRunnable(aWorkerPrivate, aToken)
+ , mEventName(aEventName)
+ , mCallback(aCallback)
+ {
+ AssertIsOnMainThread();
+ }
+
+ bool
+ WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
+ {
+ MOZ_ASSERT(aWorkerPrivate);
+ return DispatchLifecycleEvent(aCx, aWorkerPrivate);
+ }
+
+ nsresult
+ Cancel() override
+ {
+ mCallback->SetResult(false);
+ MOZ_ALWAYS_SUCCEEDS(mWorkerPrivate->DispatchToMainThread(mCallback));
+
+ return WorkerRunnable::Cancel();
+ }
+
+private:
+ bool
+ DispatchLifecycleEvent(JSContext* aCx, WorkerPrivate* aWorkerPrivate);
+
+};
+
+/*
+ * Used to handle ExtendableEvent::waitUntil() and catch abnormal worker
+ * termination during the execution of life cycle events. It is responsible
+ * with advancing the job queue for install/activate tasks.
+ */
+class LifeCycleEventWatcher final : public PromiseNativeHandler,
+ public WorkerHolder
+{
+ WorkerPrivate* mWorkerPrivate;
+ RefPtr<LifeCycleEventCallback> mCallback;
+ bool mDone;
+
+ ~LifeCycleEventWatcher()
+ {
+ if (mDone) {
+ return;
+ }
+
+ MOZ_ASSERT(GetCurrentThreadWorkerPrivate() == mWorkerPrivate);
+ // XXXcatalinb: If all the promises passed to waitUntil go out of scope,
+ // the resulting Promise.all will be cycle collected and it will drop its
+ // native handlers (including this object). Instead of waiting for a timeout
+ // we report the failure now.
+ ReportResult(false);
+ }
+
+public:
+ NS_DECL_ISUPPORTS
+
+ LifeCycleEventWatcher(WorkerPrivate* aWorkerPrivate,
+ LifeCycleEventCallback* aCallback)
+ : mWorkerPrivate(aWorkerPrivate)
+ , mCallback(aCallback)
+ , mDone(false)
+ {
+ MOZ_ASSERT(aWorkerPrivate);
+ aWorkerPrivate->AssertIsOnWorkerThread();
+ }
+
+ bool
+ Init()
+ {
+ MOZ_ASSERT(mWorkerPrivate);
+ mWorkerPrivate->AssertIsOnWorkerThread();
+
+ // We need to listen for worker termination in case the event handler
+ // never completes or never resolves the waitUntil promise. There are
+ // two possible scenarios:
+ // 1. The keepAlive token expires and the worker is terminated, in which
+ // case the registration/update promise will be rejected
+ // 2. A new service worker is registered which will terminate the current
+ // installing worker.
+ if (NS_WARN_IF(!HoldWorker(mWorkerPrivate, Terminating))) {
+ NS_WARNING("LifeCycleEventWatcher failed to add feature.");
+ ReportResult(false);
+ return false;
+ }
+
+ return true;
+ }
+
+ bool
+ Notify(Status aStatus) override
+ {
+ if (aStatus < Terminating) {
+ return true;
+ }
+
+ MOZ_ASSERT(GetCurrentThreadWorkerPrivate() == mWorkerPrivate);
+ ReportResult(false);
+
+ return true;
+ }
+
+ void
+ ReportResult(bool aResult)
+ {
+ mWorkerPrivate->AssertIsOnWorkerThread();
+
+ if (mDone) {
+ return;
+ }
+ mDone = true;
+
+ mCallback->SetResult(aResult);
+ nsresult rv = mWorkerPrivate->DispatchToMainThread(mCallback);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ NS_RUNTIMEABORT("Failed to dispatch life cycle event handler.");
+ }
+
+ ReleaseWorker();
+ }
+
+ void
+ ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override
+ {
+ MOZ_ASSERT(GetCurrentThreadWorkerPrivate() == mWorkerPrivate);
+ mWorkerPrivate->AssertIsOnWorkerThread();
+
+ ReportResult(true);
+ }
+
+ void
+ RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override
+ {
+ MOZ_ASSERT(GetCurrentThreadWorkerPrivate() == mWorkerPrivate);
+ mWorkerPrivate->AssertIsOnWorkerThread();
+
+ ReportResult(false);
+
+ // Note, all WaitUntil() rejections are reported to client consoles
+ // by the WaitUntilHandler in ServiceWorkerEvents. This ensures that
+ // errors in non-lifecycle events like FetchEvent and PushEvent are
+ // reported properly.
+ }
+};
+
+NS_IMPL_ISUPPORTS0(LifeCycleEventWatcher)
+
+bool
+LifecycleEventWorkerRunnable::DispatchLifecycleEvent(JSContext* aCx,
+ WorkerPrivate* aWorkerPrivate)
+{
+ aWorkerPrivate->AssertIsOnWorkerThread();
+ MOZ_ASSERT(aWorkerPrivate->IsServiceWorker());
+
+ RefPtr<ExtendableEvent> event;
+ RefPtr<EventTarget> target = aWorkerPrivate->GlobalScope();
+
+ if (mEventName.EqualsASCII("install") || mEventName.EqualsASCII("activate")) {
+ ExtendableEventInit init;
+ init.mBubbles = false;
+ init.mCancelable = false;
+ event = ExtendableEvent::Constructor(target, mEventName, init);
+ } else {
+ MOZ_CRASH("Unexpected lifecycle event");
+ }
+
+ event->SetTrusted(true);
+
+ // It is important to initialize the watcher before actually dispatching
+ // the event in order to catch worker termination while the event handler
+ // is still executing. This can happen with infinite loops, for example.
+ RefPtr<LifeCycleEventWatcher> watcher =
+ new LifeCycleEventWatcher(aWorkerPrivate, mCallback);
+
+ if (!watcher->Init()) {
+ return true;
+ }
+
+ if (!DispatchExtendableEventOnWorkerScope(aCx, aWorkerPrivate->GlobalScope(),
+ event, watcher)) {
+ watcher->ReportResult(false);
+ }
+
+ return true;
+}
+
+} // anonymous namespace
+
+nsresult
+ServiceWorkerPrivate::SendLifeCycleEvent(const nsAString& aEventType,
+ LifeCycleEventCallback* aCallback,
+ nsIRunnable* aLoadFailure)
+{
+ nsresult rv = SpawnWorkerIfNeeded(LifeCycleEvent, aLoadFailure);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<KeepAliveToken> token = CreateEventKeepAliveToken();
+ RefPtr<WorkerRunnable> r = new LifecycleEventWorkerRunnable(mWorkerPrivate,
+ token,
+ aEventType,
+ aCallback);
+ if (NS_WARN_IF(!r->Dispatch())) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+namespace {
+
+class PushErrorReporter final : public PromiseNativeHandler
+{
+ WorkerPrivate* mWorkerPrivate;
+ nsString mMessageId;
+
+ ~PushErrorReporter()
+ {
+ }
+
+public:
+ NS_DECL_THREADSAFE_ISUPPORTS
+
+ PushErrorReporter(WorkerPrivate* aWorkerPrivate,
+ const nsAString& aMessageId)
+ : mWorkerPrivate(aWorkerPrivate)
+ , mMessageId(aMessageId)
+ {
+ mWorkerPrivate->AssertIsOnWorkerThread();
+ }
+
+ void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override
+ {
+ mWorkerPrivate->AssertIsOnWorkerThread();
+ mWorkerPrivate = nullptr;
+ // Do nothing; we only use this to report errors to the Push service.
+ }
+
+ void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override
+ {
+ Report(nsIPushErrorReporter::DELIVERY_UNHANDLED_REJECTION);
+ }
+
+ void Report(uint16_t aReason = nsIPushErrorReporter::DELIVERY_INTERNAL_ERROR)
+ {
+ WorkerPrivate* workerPrivate = mWorkerPrivate;
+ mWorkerPrivate->AssertIsOnWorkerThread();
+ mWorkerPrivate = nullptr;
+
+ if (NS_WARN_IF(aReason > nsIPushErrorReporter::DELIVERY_INTERNAL_ERROR) ||
+ mMessageId.IsEmpty()) {
+ return;
+ }
+ nsCOMPtr<nsIRunnable> runnable =
+ NewRunnableMethod<uint16_t>(this,
+ &PushErrorReporter::ReportOnMainThread, aReason);
+ MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
+ workerPrivate->DispatchToMainThread(runnable.forget())));
+ }
+
+ void ReportOnMainThread(uint16_t aReason)
+ {
+ AssertIsOnMainThread();
+ nsCOMPtr<nsIPushErrorReporter> reporter =
+ do_GetService("@mozilla.org/push/Service;1");
+ if (reporter) {
+ nsresult rv = reporter->ReportDeliveryError(mMessageId, aReason);
+ Unused << NS_WARN_IF(NS_FAILED(rv));
+ }
+ }
+};
+
+NS_IMPL_ISUPPORTS0(PushErrorReporter)
+
+class SendPushEventRunnable final : public ExtendableFunctionalEventWorkerRunnable
+{
+ nsString mMessageId;
+ Maybe<nsTArray<uint8_t>> mData;
+
+public:
+ SendPushEventRunnable(WorkerPrivate* aWorkerPrivate,
+ KeepAliveToken* aKeepAliveToken,
+ const nsAString& aMessageId,
+ const Maybe<nsTArray<uint8_t>>& aData,
+ nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> aRegistration)
+ : ExtendableFunctionalEventWorkerRunnable(
+ aWorkerPrivate, aKeepAliveToken, aRegistration)
+ , mMessageId(aMessageId)
+ , mData(aData)
+ {
+ AssertIsOnMainThread();
+ MOZ_ASSERT(aWorkerPrivate);
+ MOZ_ASSERT(aWorkerPrivate->IsServiceWorker());
+ }
+
+ bool
+ WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
+ {
+ MOZ_ASSERT(aWorkerPrivate);
+ GlobalObject globalObj(aCx, aWorkerPrivate->GlobalScope()->GetWrapper());
+
+ RefPtr<PushErrorReporter> errorReporter =
+ new PushErrorReporter(aWorkerPrivate, mMessageId);
+
+ PushEventInit pei;
+ if (mData) {
+ const nsTArray<uint8_t>& bytes = mData.ref();
+ JSObject* data = Uint8Array::Create(aCx, bytes.Length(), bytes.Elements());
+ if (!data) {
+ errorReporter->Report();
+ return false;
+ }
+ pei.mData.Construct().SetAsArrayBufferView().Init(data);
+ }
+ pei.mBubbles = false;
+ pei.mCancelable = false;
+
+ ErrorResult result;
+ RefPtr<PushEvent> event =
+ PushEvent::Constructor(globalObj, NS_LITERAL_STRING("push"), pei, result);
+ if (NS_WARN_IF(result.Failed())) {
+ result.SuppressException();
+ errorReporter->Report();
+ return false;
+ }
+ event->SetTrusted(true);
+
+ if (!DispatchExtendableEventOnWorkerScope(aCx, aWorkerPrivate->GlobalScope(),
+ event, errorReporter)) {
+ errorReporter->Report(nsIPushErrorReporter::DELIVERY_UNCAUGHT_EXCEPTION);
+ }
+
+ return true;
+ }
+};
+
+class SendPushSubscriptionChangeEventRunnable final : public ExtendableEventWorkerRunnable
+{
+
+public:
+ explicit SendPushSubscriptionChangeEventRunnable(
+ WorkerPrivate* aWorkerPrivate, KeepAliveToken* aKeepAliveToken)
+ : ExtendableEventWorkerRunnable(aWorkerPrivate, aKeepAliveToken)
+ {
+ AssertIsOnMainThread();
+ MOZ_ASSERT(aWorkerPrivate);
+ MOZ_ASSERT(aWorkerPrivate->IsServiceWorker());
+ }
+
+ bool
+ WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
+ {
+ MOZ_ASSERT(aWorkerPrivate);
+
+ RefPtr<EventTarget> target = aWorkerPrivate->GlobalScope();
+
+ ExtendableEventInit init;
+ init.mBubbles = false;
+ init.mCancelable = false;
+
+ RefPtr<ExtendableEvent> event =
+ ExtendableEvent::Constructor(target,
+ NS_LITERAL_STRING("pushsubscriptionchange"),
+ init);
+
+ event->SetTrusted(true);
+
+ DispatchExtendableEventOnWorkerScope(aCx, aWorkerPrivate->GlobalScope(),
+ event, nullptr);
+
+ return true;
+ }
+};
+
+} // anonymous namespace
+
+nsresult
+ServiceWorkerPrivate::SendPushEvent(const nsAString& aMessageId,
+ const Maybe<nsTArray<uint8_t>>& aData,
+ ServiceWorkerRegistrationInfo* aRegistration)
+{
+ nsresult rv = SpawnWorkerIfNeeded(PushEvent, nullptr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<KeepAliveToken> token = CreateEventKeepAliveToken();
+
+ nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> regInfo(
+ new nsMainThreadPtrHolder<ServiceWorkerRegistrationInfo>(aRegistration, false));
+
+ RefPtr<WorkerRunnable> r = new SendPushEventRunnable(mWorkerPrivate,
+ token,
+ aMessageId,
+ aData,
+ regInfo);
+
+ if (mInfo->State() == ServiceWorkerState::Activating) {
+ mPendingFunctionalEvents.AppendElement(r.forget());
+ return NS_OK;
+ }
+
+ MOZ_ASSERT(mInfo->State() == ServiceWorkerState::Activated);
+
+ if (NS_WARN_IF(!r->Dispatch())) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+nsresult
+ServiceWorkerPrivate::SendPushSubscriptionChangeEvent()
+{
+ nsresult rv = SpawnWorkerIfNeeded(PushSubscriptionChangeEvent, nullptr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<KeepAliveToken> token = CreateEventKeepAliveToken();
+ RefPtr<WorkerRunnable> r =
+ new SendPushSubscriptionChangeEventRunnable(mWorkerPrivate, token);
+ if (NS_WARN_IF(!r->Dispatch())) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+namespace {
+
+static void
+DummyNotificationTimerCallback(nsITimer* aTimer, void* aClosure)
+{
+ // Nothing.
+}
+
+class AllowWindowInteractionHandler;
+
+class ClearWindowAllowedRunnable final : public WorkerRunnable
+{
+public:
+ ClearWindowAllowedRunnable(WorkerPrivate* aWorkerPrivate,
+ AllowWindowInteractionHandler* aHandler)
+ : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount)
+ , mHandler(aHandler)
+ { }
+
+private:
+ bool
+ PreDispatch(WorkerPrivate* aWorkerPrivate) override
+ {
+ // WorkerRunnable asserts that the dispatch is from parent thread if
+ // the busy count modification is WorkerThreadUnchangedBusyCount.
+ // Since this runnable will be dispatched from the timer thread, we override
+ // PreDispatch and PostDispatch to skip the check.
+ return true;
+ }
+
+ void
+ PostDispatch(WorkerPrivate* aWorkerPrivate, bool aDispatchResult) override
+ {
+ // Silence bad assertions.
+ }
+
+ bool
+ WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override;
+
+ nsresult
+ Cancel() override
+ {
+ // Always ensure the handler is released on the worker thread, even if we
+ // are cancelled.
+ mHandler = nullptr;
+ return WorkerRunnable::Cancel();
+ }
+
+ RefPtr<AllowWindowInteractionHandler> mHandler;
+};
+
+class AllowWindowInteractionHandler final : public PromiseNativeHandler
+{
+ friend class ClearWindowAllowedRunnable;
+ nsCOMPtr<nsITimer> mTimer;
+
+ ~AllowWindowInteractionHandler()
+ {
+ }
+
+ void
+ ClearWindowAllowed(WorkerPrivate* aWorkerPrivate)
+ {
+ MOZ_ASSERT(aWorkerPrivate);
+ aWorkerPrivate->AssertIsOnWorkerThread();
+
+ if (!mTimer) {
+ return;
+ }
+
+ // XXXcatalinb: This *might* be executed after the global was unrooted, in
+ // which case GlobalScope() will return null. Making the check here just
+ // to be safe.
+ WorkerGlobalScope* globalScope = aWorkerPrivate->GlobalScope();
+ if (!globalScope) {
+ return;
+ }
+
+ globalScope->ConsumeWindowInteraction();
+ mTimer->Cancel();
+ mTimer = nullptr;
+ MOZ_ALWAYS_TRUE(aWorkerPrivate->ModifyBusyCountFromWorker(false));
+ }
+
+ void
+ StartClearWindowTimer(WorkerPrivate* aWorkerPrivate)
+ {
+ MOZ_ASSERT(aWorkerPrivate);
+ aWorkerPrivate->AssertIsOnWorkerThread();
+ MOZ_ASSERT(!mTimer);
+
+ nsresult rv;
+ nsCOMPtr<nsITimer> timer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return;
+ }
+
+ RefPtr<ClearWindowAllowedRunnable> r =
+ new ClearWindowAllowedRunnable(aWorkerPrivate, this);
+
+ RefPtr<TimerThreadEventTarget> target =
+ new TimerThreadEventTarget(aWorkerPrivate, r);
+
+ rv = timer->SetTarget(target);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return;
+ }
+
+ // The important stuff that *has* to be reversed.
+ if (NS_WARN_IF(!aWorkerPrivate->ModifyBusyCountFromWorker(true))) {
+ return;
+ }
+ aWorkerPrivate->GlobalScope()->AllowWindowInteraction();
+ timer.swap(mTimer);
+
+ // We swap first and then initialize the timer so that even if initializing
+ // fails, we still clean the busy count and interaction count correctly.
+ // The timer can't be initialized before modifying the busy count since the
+ // timer thread could run and call the timeout but the worker may
+ // already be terminating and modifying the busy count could fail.
+ rv = mTimer->InitWithFuncCallback(DummyNotificationTimerCallback, nullptr,
+ gDOMDisableOpenClickDelay,
+ nsITimer::TYPE_ONE_SHOT);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ ClearWindowAllowed(aWorkerPrivate);
+ return;
+ }
+ }
+
+public:
+ NS_DECL_ISUPPORTS
+
+ explicit AllowWindowInteractionHandler(WorkerPrivate* aWorkerPrivate)
+ {
+ StartClearWindowTimer(aWorkerPrivate);
+ }
+
+ void
+ ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override
+ {
+ WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(aCx);
+ ClearWindowAllowed(workerPrivate);
+ }
+
+ void
+ RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override
+ {
+ WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(aCx);
+ ClearWindowAllowed(workerPrivate);
+ }
+};
+
+NS_IMPL_ISUPPORTS0(AllowWindowInteractionHandler)
+
+bool
+ClearWindowAllowedRunnable::WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
+{
+ mHandler->ClearWindowAllowed(aWorkerPrivate);
+ mHandler = nullptr;
+ return true;
+}
+
+class SendNotificationEventRunnable final : public ExtendableEventWorkerRunnable
+{
+ const nsString mEventName;
+ const nsString mID;
+ const nsString mTitle;
+ const nsString mDir;
+ const nsString mLang;
+ const nsString mBody;
+ const nsString mTag;
+ const nsString mIcon;
+ const nsString mData;
+ const nsString mBehavior;
+ const nsString mScope;
+
+public:
+ SendNotificationEventRunnable(WorkerPrivate* aWorkerPrivate,
+ KeepAliveToken* aKeepAliveToken,
+ const nsAString& aEventName,
+ const nsAString& aID,
+ const nsAString& aTitle,
+ const nsAString& aDir,
+ const nsAString& aLang,
+ const nsAString& aBody,
+ const nsAString& aTag,
+ const nsAString& aIcon,
+ const nsAString& aData,
+ const nsAString& aBehavior,
+ const nsAString& aScope)
+ : ExtendableEventWorkerRunnable(aWorkerPrivate, aKeepAliveToken)
+ , mEventName(aEventName)
+ , mID(aID)
+ , mTitle(aTitle)
+ , mDir(aDir)
+ , mLang(aLang)
+ , mBody(aBody)
+ , mTag(aTag)
+ , mIcon(aIcon)
+ , mData(aData)
+ , mBehavior(aBehavior)
+ , mScope(aScope)
+ {
+ AssertIsOnMainThread();
+ MOZ_ASSERT(aWorkerPrivate);
+ MOZ_ASSERT(aWorkerPrivate->IsServiceWorker());
+ }
+
+ bool
+ WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
+ {
+ MOZ_ASSERT(aWorkerPrivate);
+
+ RefPtr<EventTarget> target = do_QueryObject(aWorkerPrivate->GlobalScope());
+
+ ErrorResult result;
+ RefPtr<Notification> notification =
+ Notification::ConstructFromFields(aWorkerPrivate->GlobalScope(), mID,
+ mTitle, mDir, mLang, mBody, mTag, mIcon,
+ mData, mScope, result);
+ if (NS_WARN_IF(result.Failed())) {
+ return false;
+ }
+
+ NotificationEventInit nei;
+ nei.mNotification = notification;
+ nei.mBubbles = false;
+ nei.mCancelable = false;
+
+ RefPtr<NotificationEvent> event =
+ NotificationEvent::Constructor(target, mEventName,
+ nei, result);
+ if (NS_WARN_IF(result.Failed())) {
+ return false;
+ }
+
+ event->SetTrusted(true);
+ aWorkerPrivate->GlobalScope()->AllowWindowInteraction();
+ RefPtr<AllowWindowInteractionHandler> allowWindowInteraction =
+ new AllowWindowInteractionHandler(aWorkerPrivate);
+ if (!DispatchExtendableEventOnWorkerScope(aCx, aWorkerPrivate->GlobalScope(),
+ event, allowWindowInteraction)) {
+ allowWindowInteraction->RejectedCallback(aCx, JS::UndefinedHandleValue);
+ }
+ aWorkerPrivate->GlobalScope()->ConsumeWindowInteraction();
+
+ return true;
+ }
+};
+
+} // namespace anonymous
+
+nsresult
+ServiceWorkerPrivate::SendNotificationEvent(const nsAString& aEventName,
+ const nsAString& aID,
+ const nsAString& aTitle,
+ const nsAString& aDir,
+ const nsAString& aLang,
+ const nsAString& aBody,
+ const nsAString& aTag,
+ const nsAString& aIcon,
+ const nsAString& aData,
+ const nsAString& aBehavior,
+ const nsAString& aScope)
+{
+ WakeUpReason why;
+ if (aEventName.EqualsLiteral(NOTIFICATION_CLICK_EVENT_NAME)) {
+ why = NotificationClickEvent;
+ gDOMDisableOpenClickDelay = Preferences::GetInt("dom.disable_open_click_delay");
+ } else if (aEventName.EqualsLiteral(NOTIFICATION_CLOSE_EVENT_NAME)) {
+ why = NotificationCloseEvent;
+ } else {
+ MOZ_ASSERT_UNREACHABLE("Invalid notification event name");
+ return NS_ERROR_FAILURE;
+ }
+
+ nsresult rv = SpawnWorkerIfNeeded(why, nullptr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<KeepAliveToken> token = CreateEventKeepAliveToken();
+
+ RefPtr<WorkerRunnable> r =
+ new SendNotificationEventRunnable(mWorkerPrivate, token,
+ aEventName, aID, aTitle, aDir, aLang,
+ aBody, aTag, aIcon, aData, aBehavior,
+ aScope);
+ if (NS_WARN_IF(!r->Dispatch())) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+namespace {
+
+// Inheriting ExtendableEventWorkerRunnable so that the worker is not terminated
+// while handling the fetch event, though that's very unlikely.
+class FetchEventRunnable : public ExtendableFunctionalEventWorkerRunnable
+ , public nsIHttpHeaderVisitor {
+ nsMainThreadPtrHandle<nsIInterceptedChannel> mInterceptedChannel;
+ const nsCString mScriptSpec;
+ nsTArray<nsCString> mHeaderNames;
+ nsTArray<nsCString> mHeaderValues;
+ nsCString mSpec;
+ nsCString mFragment;
+ nsCString mMethod;
+ nsString mClientId;
+ bool mIsReload;
+ RequestCache mCacheMode;
+ RequestMode mRequestMode;
+ RequestRedirect mRequestRedirect;
+ RequestCredentials mRequestCredentials;
+ nsContentPolicyType mContentPolicyType;
+ nsCOMPtr<nsIInputStream> mUploadStream;
+ nsCString mReferrer;
+ ReferrerPolicy mReferrerPolicy;
+ nsString mIntegrity;
+public:
+ FetchEventRunnable(WorkerPrivate* aWorkerPrivate,
+ KeepAliveToken* aKeepAliveToken,
+ nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel,
+ // CSP checks might require the worker script spec
+ // later on.
+ const nsACString& aScriptSpec,
+ nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration,
+ const nsAString& aDocumentId,
+ bool aIsReload)
+ : ExtendableFunctionalEventWorkerRunnable(
+ aWorkerPrivate, aKeepAliveToken, aRegistration)
+ , mInterceptedChannel(aChannel)
+ , mScriptSpec(aScriptSpec)
+ , mClientId(aDocumentId)
+ , mIsReload(aIsReload)
+ , mCacheMode(RequestCache::Default)
+ , mRequestMode(RequestMode::No_cors)
+ , mRequestRedirect(RequestRedirect::Follow)
+ // By default we set it to same-origin since normal HTTP fetches always
+ // send credentials to same-origin websites unless explicitly forbidden.
+ , mRequestCredentials(RequestCredentials::Same_origin)
+ , mContentPolicyType(nsIContentPolicy::TYPE_INVALID)
+ , mReferrer(kFETCH_CLIENT_REFERRER_STR)
+ , mReferrerPolicy(ReferrerPolicy::_empty)
+ {
+ MOZ_ASSERT(aWorkerPrivate);
+ }
+
+ NS_DECL_ISUPPORTS_INHERITED
+
+ NS_IMETHOD
+ VisitHeader(const nsACString& aHeader, const nsACString& aValue) override
+ {
+ mHeaderNames.AppendElement(aHeader);
+ mHeaderValues.AppendElement(aValue);
+ return NS_OK;
+ }
+
+ nsresult
+ Init()
+ {
+ AssertIsOnMainThread();
+ nsCOMPtr<nsIChannel> channel;
+ nsresult rv = mInterceptedChannel->GetChannel(getter_AddRefs(channel));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<nsIURI> uri;
+ rv = mInterceptedChannel->GetSecureUpgradedChannelURI(getter_AddRefs(uri));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Normally we rely on the Request constructor to strip the fragment, but
+ // when creating the FetchEvent we bypass the constructor. So strip the
+ // fragment manually here instead. We can't do it later when we create
+ // the Request because that code executes off the main thread.
+ nsCOMPtr<nsIURI> uriNoFragment;
+ rv = uri->CloneIgnoringRef(getter_AddRefs(uriNoFragment));
+ NS_ENSURE_SUCCESS(rv, rv);
+ rv = uriNoFragment->GetSpec(mSpec);
+ NS_ENSURE_SUCCESS(rv, rv);
+ rv = uri->GetRef(mFragment);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ uint32_t loadFlags;
+ rv = channel->GetLoadFlags(&loadFlags);
+ NS_ENSURE_SUCCESS(rv, rv);
+ nsCOMPtr<nsILoadInfo> loadInfo;
+ rv = channel->GetLoadInfo(getter_AddRefs(loadInfo));
+ NS_ENSURE_SUCCESS(rv, rv);
+ mContentPolicyType = loadInfo->InternalContentPolicyType();
+
+ nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(channel);
+ MOZ_ASSERT(httpChannel, "How come we don't have an HTTP channel?");
+
+ nsAutoCString referrer;
+ // Ignore the return value since the Referer header may not exist.
+ httpChannel->GetRequestHeader(NS_LITERAL_CSTRING("Referer"), referrer);
+ if (!referrer.IsEmpty()) {
+ mReferrer = referrer;
+ }
+
+ uint32_t referrerPolicy = 0;
+ rv = httpChannel->GetReferrerPolicy(&referrerPolicy);
+ NS_ENSURE_SUCCESS(rv, rv);
+ switch (referrerPolicy) {
+ case nsIHttpChannel::REFERRER_POLICY_NO_REFERRER:
+ mReferrerPolicy = ReferrerPolicy::No_referrer;
+ break;
+ case nsIHttpChannel::REFERRER_POLICY_ORIGIN:
+ mReferrerPolicy = ReferrerPolicy::Origin;
+ break;
+ case nsIHttpChannel::REFERRER_POLICY_NO_REFERRER_WHEN_DOWNGRADE:
+ mReferrerPolicy = ReferrerPolicy::No_referrer_when_downgrade;
+ break;
+ case nsIHttpChannel::REFERRER_POLICY_ORIGIN_WHEN_XORIGIN:
+ mReferrerPolicy = ReferrerPolicy::Origin_when_cross_origin;
+ break;
+ case nsIHttpChannel::REFERRER_POLICY_UNSAFE_URL:
+ mReferrerPolicy = ReferrerPolicy::Unsafe_url;
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("Invalid Referrer Policy enum value?");
+ break;
+ }
+
+ rv = httpChannel->GetRequestMethod(mMethod);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<nsIHttpChannelInternal> internalChannel = do_QueryInterface(httpChannel);
+ NS_ENSURE_TRUE(internalChannel, NS_ERROR_NOT_AVAILABLE);
+
+ mRequestMode = InternalRequest::MapChannelToRequestMode(channel);
+
+ // This is safe due to static_asserts in ServiceWorkerManager.cpp.
+ uint32_t redirectMode;
+ internalChannel->GetRedirectMode(&redirectMode);
+ mRequestRedirect = static_cast<RequestRedirect>(redirectMode);
+
+ // This is safe due to static_asserts in ServiceWorkerManager.cpp.
+ uint32_t cacheMode;
+ internalChannel->GetFetchCacheMode(&cacheMode);
+ mCacheMode = static_cast<RequestCache>(cacheMode);
+
+ internalChannel->GetIntegrityMetadata(mIntegrity);
+
+ mRequestCredentials = InternalRequest::MapChannelToRequestCredentials(channel);
+
+ rv = httpChannel->VisitNonDefaultRequestHeaders(this);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<nsIUploadChannel2> uploadChannel = do_QueryInterface(httpChannel);
+ if (uploadChannel) {
+ MOZ_ASSERT(!mUploadStream);
+ bool bodyHasHeaders = false;
+ rv = uploadChannel->GetUploadStreamHasHeaders(&bodyHasHeaders);
+ NS_ENSURE_SUCCESS(rv, rv);
+ nsCOMPtr<nsIInputStream> uploadStream;
+ rv = uploadChannel->CloneUploadStream(getter_AddRefs(uploadStream));
+ NS_ENSURE_SUCCESS(rv, rv);
+ if (bodyHasHeaders) {
+ HandleBodyWithHeaders(uploadStream);
+ } else {
+ mUploadStream = uploadStream;
+ }
+ }
+
+ return NS_OK;
+ }
+
+ bool
+ WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
+ {
+ MOZ_ASSERT(aWorkerPrivate);
+ return DispatchFetchEvent(aCx, aWorkerPrivate);
+ }
+
+ nsresult
+ Cancel() override
+ {
+ nsCOMPtr<nsIRunnable> runnable = new ResumeRequest(mInterceptedChannel);
+ if (NS_FAILED(mWorkerPrivate->DispatchToMainThread(runnable))) {
+ NS_WARNING("Failed to resume channel on FetchEventRunnable::Cancel()!\n");
+ }
+ WorkerRunnable::Cancel();
+ return NS_OK;
+ }
+
+private:
+ ~FetchEventRunnable() {}
+
+ class ResumeRequest final : public Runnable {
+ nsMainThreadPtrHandle<nsIInterceptedChannel> mChannel;
+ public:
+ explicit ResumeRequest(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel)
+ : mChannel(aChannel)
+ {
+ }
+
+ NS_IMETHOD Run() override
+ {
+ AssertIsOnMainThread();
+ nsresult rv = mChannel->ResetInterception();
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "Failed to resume intercepted network request");
+ return rv;
+ }
+ };
+
+ bool
+ DispatchFetchEvent(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
+ {
+ MOZ_ASSERT(aCx);
+ MOZ_ASSERT(aWorkerPrivate);
+ MOZ_ASSERT(aWorkerPrivate->IsServiceWorker());
+ GlobalObject globalObj(aCx, aWorkerPrivate->GlobalScope()->GetWrapper());
+
+ RefPtr<InternalHeaders> internalHeaders = new InternalHeaders(HeadersGuardEnum::Request);
+ MOZ_ASSERT(mHeaderNames.Length() == mHeaderValues.Length());
+ for (uint32_t i = 0; i < mHeaderNames.Length(); i++) {
+ ErrorResult result;
+ internalHeaders->Set(mHeaderNames[i], mHeaderValues[i], result);
+ if (NS_WARN_IF(result.Failed())) {
+ result.SuppressException();
+ return false;
+ }
+ }
+
+ ErrorResult result;
+ internalHeaders->SetGuard(HeadersGuardEnum::Immutable, result);
+ if (NS_WARN_IF(result.Failed())) {
+ result.SuppressException();
+ return false;
+ }
+ RefPtr<InternalRequest> internalReq = new InternalRequest(mSpec,
+ mFragment,
+ mMethod,
+ internalHeaders.forget(),
+ mCacheMode,
+ mRequestMode,
+ mRequestRedirect,
+ mRequestCredentials,
+ NS_ConvertUTF8toUTF16(mReferrer),
+ mReferrerPolicy,
+ mContentPolicyType,
+ mIntegrity);
+ internalReq->SetBody(mUploadStream);
+ // For Telemetry, note that this Request object was created by a Fetch event.
+ internalReq->SetCreatedByFetchEvent();
+
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(globalObj.GetAsSupports());
+ if (NS_WARN_IF(!global)) {
+ return false;
+ }
+ RefPtr<Request> request = new Request(global, internalReq);
+
+ MOZ_ASSERT_IF(internalReq->IsNavigationRequest(),
+ request->Redirect() == RequestRedirect::Manual);
+
+ RootedDictionary<FetchEventInit> init(aCx);
+ init.mRequest = request;
+ init.mBubbles = false;
+ init.mCancelable = true;
+ if (!mClientId.IsEmpty()) {
+ init.mClientId = mClientId;
+ }
+ init.mIsReload = mIsReload;
+ RefPtr<FetchEvent> event =
+ FetchEvent::Constructor(globalObj, NS_LITERAL_STRING("fetch"), init, result);
+ if (NS_WARN_IF(result.Failed())) {
+ result.SuppressException();
+ return false;
+ }
+
+ event->PostInit(mInterceptedChannel, mRegistration, mScriptSpec);
+ event->SetTrusted(true);
+
+ RefPtr<EventTarget> target = do_QueryObject(aWorkerPrivate->GlobalScope());
+ nsresult rv2 = target->DispatchDOMEvent(nullptr, event, nullptr, nullptr);
+ if (NS_WARN_IF(NS_FAILED(rv2)) || !event->WaitToRespond()) {
+ nsCOMPtr<nsIRunnable> runnable;
+ if (event->DefaultPrevented(aCx)) {
+ event->ReportCanceled();
+ } else if (event->WidgetEventPtr()->mFlags.mExceptionWasRaised) {
+ // Exception logged via the WorkerPrivate ErrorReporter
+ } else {
+ runnable = new ResumeRequest(mInterceptedChannel);
+ }
+
+ if (!runnable) {
+ runnable = new CancelChannelRunnable(mInterceptedChannel,
+ mRegistration,
+ NS_ERROR_INTERCEPTION_FAILED);
+ }
+
+ MOZ_ALWAYS_SUCCEEDS(mWorkerPrivate->DispatchToMainThread(runnable.forget()));
+ }
+
+ RefPtr<Promise> waitUntilPromise = event->GetPromise();
+ if (waitUntilPromise) {
+ KeepAliveHandler::CreateAndAttachToPromise(mKeepAliveToken,
+ waitUntilPromise);
+ }
+
+ return true;
+ }
+
+ nsresult
+ HandleBodyWithHeaders(nsIInputStream* aUploadStream)
+ {
+ // We are dealing with an nsMIMEInputStream which uses string input streams
+ // under the hood, so all of the data is available synchronously.
+ bool nonBlocking = false;
+ nsresult rv = aUploadStream->IsNonBlocking(&nonBlocking);
+ NS_ENSURE_SUCCESS(rv, rv);
+ if (NS_WARN_IF(!nonBlocking)) {
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+ nsAutoCString body;
+ rv = NS_ConsumeStream(aUploadStream, UINT32_MAX, body);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Extract the headers in the beginning of the buffer
+ nsAutoCString::const_iterator begin, end;
+ body.BeginReading(begin);
+ body.EndReading(end);
+ const nsAutoCString::const_iterator body_end = end;
+ nsAutoCString headerName, headerValue;
+ bool emptyHeader = false;
+ while (FetchUtil::ExtractHeader(begin, end, headerName,
+ headerValue, &emptyHeader) &&
+ !emptyHeader) {
+ mHeaderNames.AppendElement(headerName);
+ mHeaderValues.AppendElement(headerValue);
+ headerName.Truncate();
+ headerValue.Truncate();
+ }
+
+ // Replace the upload stream with one only containing the body text.
+ nsCOMPtr<nsIStringInputStream> strStream =
+ do_CreateInstance(NS_STRINGINPUTSTREAM_CONTRACTID, &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+ // Skip past the "\r\n" that separates the headers and the body.
+ ++begin;
+ ++begin;
+ body.Assign(Substring(begin, body_end));
+ rv = strStream->SetData(body.BeginReading(), body.Length());
+ NS_ENSURE_SUCCESS(rv, rv);
+ mUploadStream = strStream;
+
+ return NS_OK;
+ }
+};
+
+NS_IMPL_ISUPPORTS_INHERITED(FetchEventRunnable, WorkerRunnable, nsIHttpHeaderVisitor)
+
+} // anonymous namespace
+
+nsresult
+ServiceWorkerPrivate::SendFetchEvent(nsIInterceptedChannel* aChannel,
+ nsILoadGroup* aLoadGroup,
+ const nsAString& aDocumentId,
+ bool aIsReload)
+{
+ AssertIsOnMainThread();
+
+ // if the ServiceWorker script fails to load for some reason, just resume
+ // the original channel.
+ nsCOMPtr<nsIRunnable> failRunnable =
+ NewRunnableMethod(aChannel, &nsIInterceptedChannel::ResetInterception);
+
+ nsresult rv = SpawnWorkerIfNeeded(FetchEvent, failRunnable, aLoadGroup);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsMainThreadPtrHandle<nsIInterceptedChannel> handle(
+ new nsMainThreadPtrHolder<nsIInterceptedChannel>(aChannel, false));
+
+ RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance();
+ if (NS_WARN_IF(!mInfo || !swm)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ RefPtr<ServiceWorkerRegistrationInfo> registration =
+ swm->GetRegistration(mInfo->GetPrincipal(), mInfo->Scope());
+
+ // Its possible the registration is removed between starting the interception
+ // and actually dispatching the fetch event. In these cases we simply
+ // want to restart the original network request. Since this is a normal
+ // condition we handle the reset here instead of returning an error which
+ // would in turn trigger a console report.
+ if (!registration) {
+ aChannel->ResetInterception();
+ return NS_OK;
+ }
+
+ nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> regInfo(
+ new nsMainThreadPtrHolder<ServiceWorkerRegistrationInfo>(registration, false));
+
+ RefPtr<KeepAliveToken> token = CreateEventKeepAliveToken();
+
+ RefPtr<FetchEventRunnable> r =
+ new FetchEventRunnable(mWorkerPrivate, token, handle,
+ mInfo->ScriptSpec(), regInfo,
+ aDocumentId, aIsReload);
+ rv = r->Init();
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ if (mInfo->State() == ServiceWorkerState::Activating) {
+ mPendingFunctionalEvents.AppendElement(r.forget());
+ return NS_OK;
+ }
+
+ MOZ_ASSERT(mInfo->State() == ServiceWorkerState::Activated);
+
+ if (NS_WARN_IF(!r->Dispatch())) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+nsresult
+ServiceWorkerPrivate::SpawnWorkerIfNeeded(WakeUpReason aWhy,
+ nsIRunnable* aLoadFailedRunnable,
+ nsILoadGroup* aLoadGroup)
+{
+ AssertIsOnMainThread();
+
+ // XXXcatalinb: We need to have a separate load group that's linked to
+ // an existing tab child to pass security checks on b2g.
+ // This should be fixed in bug 1125961, but for now we enforce updating
+ // the overriden load group when intercepting a fetch.
+ MOZ_ASSERT_IF(aWhy == FetchEvent, aLoadGroup);
+
+ if (mWorkerPrivate) {
+ mWorkerPrivate->UpdateOverridenLoadGroup(aLoadGroup);
+ RenewKeepAliveToken(aWhy);
+
+ return NS_OK;
+ }
+
+ // Sanity check: mSupportsArray should be empty if we're about to
+ // spin up a new worker.
+ MOZ_ASSERT(mSupportsArray.IsEmpty());
+
+ if (NS_WARN_IF(!mInfo)) {
+ NS_WARNING("Trying to wake up a dead service worker.");
+ return NS_ERROR_FAILURE;
+ }
+
+ // TODO(catalinb): Bug 1192138 - Add telemetry for service worker wake-ups.
+
+ // Ensure that the IndexedDatabaseManager is initialized
+ Unused << NS_WARN_IF(!IndexedDatabaseManager::GetOrCreate());
+
+ WorkerLoadInfo info;
+ nsresult rv = NS_NewURI(getter_AddRefs(info.mBaseURI), mInfo->ScriptSpec(),
+ nullptr, nullptr);
+
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ info.mResolvedScriptURI = info.mBaseURI;
+ MOZ_ASSERT(!mInfo->CacheName().IsEmpty());
+ info.mServiceWorkerCacheName = mInfo->CacheName();
+ info.mServiceWorkerID = mInfo->ID();
+ info.mLoadGroup = aLoadGroup;
+ info.mLoadFailedAsyncRunnable = aLoadFailedRunnable;
+
+ rv = info.mBaseURI->GetHost(info.mDomain);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ info.mPrincipal = mInfo->GetPrincipal();
+
+ nsContentUtils::StorageAccess access =
+ nsContentUtils::StorageAllowedForPrincipal(info.mPrincipal);
+ info.mStorageAllowed = access > nsContentUtils::StorageAccess::ePrivateBrowsing;
+ info.mOriginAttributes = mInfo->GetOriginAttributes();
+
+ nsCOMPtr<nsIContentSecurityPolicy> csp;
+ rv = info.mPrincipal->GetCsp(getter_AddRefs(csp));
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ info.mCSP = csp;
+ if (info.mCSP) {
+ rv = info.mCSP->GetAllowsEval(&info.mReportCSPViolations,
+ &info.mEvalAllowed);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+ } else {
+ info.mEvalAllowed = true;
+ info.mReportCSPViolations = false;
+ }
+
+ WorkerPrivate::OverrideLoadInfoLoadGroup(info);
+
+ AutoJSAPI jsapi;
+ jsapi.Init();
+ ErrorResult error;
+ NS_ConvertUTF8toUTF16 scriptSpec(mInfo->ScriptSpec());
+
+ mWorkerPrivate = WorkerPrivate::Constructor(jsapi.cx(),
+ scriptSpec,
+ false, WorkerTypeService,
+ mInfo->Scope(), &info, error);
+ if (NS_WARN_IF(error.Failed())) {
+ return error.StealNSResult();
+ }
+
+ RenewKeepAliveToken(aWhy);
+
+ return NS_OK;
+}
+
+void
+ServiceWorkerPrivate::StoreISupports(nsISupports* aSupports)
+{
+ AssertIsOnMainThread();
+ MOZ_ASSERT(mWorkerPrivate);
+ MOZ_ASSERT(!mSupportsArray.Contains(aSupports));
+
+ mSupportsArray.AppendElement(aSupports);
+}
+
+void
+ServiceWorkerPrivate::RemoveISupports(nsISupports* aSupports)
+{
+ AssertIsOnMainThread();
+ mSupportsArray.RemoveElement(aSupports);
+}
+
+void
+ServiceWorkerPrivate::TerminateWorker()
+{
+ AssertIsOnMainThread();
+
+ mIdleWorkerTimer->Cancel();
+ mIdleKeepAliveToken = nullptr;
+ if (mWorkerPrivate) {
+ if (Preferences::GetBool("dom.serviceWorkers.testing.enabled")) {
+ nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+ if (os) {
+ os->NotifyObservers(this, "service-worker-shutdown", nullptr);
+ }
+ }
+
+ Unused << NS_WARN_IF(!mWorkerPrivate->Terminate());
+ mWorkerPrivate = nullptr;
+ mSupportsArray.Clear();
+
+ // Any pending events are never going to fire on this worker. Cancel
+ // them so that intercepted channels can be reset and other resources
+ // cleaned up.
+ nsTArray<RefPtr<WorkerRunnable>> pendingEvents;
+ mPendingFunctionalEvents.SwapElements(pendingEvents);
+ for (uint32_t i = 0; i < pendingEvents.Length(); ++i) {
+ pendingEvents[i]->Cancel();
+ }
+ }
+}
+
+void
+ServiceWorkerPrivate::NoteDeadServiceWorkerInfo()
+{
+ AssertIsOnMainThread();
+ mInfo = nullptr;
+ TerminateWorker();
+}
+
+void
+ServiceWorkerPrivate::Activated()
+{
+ AssertIsOnMainThread();
+
+ // If we had to queue up events due to the worker activating, that means
+ // the worker must be currently running. We should be called synchronously
+ // when the worker becomes activated.
+ MOZ_ASSERT_IF(!mPendingFunctionalEvents.IsEmpty(), mWorkerPrivate);
+
+ nsTArray<RefPtr<WorkerRunnable>> pendingEvents;
+ mPendingFunctionalEvents.SwapElements(pendingEvents);
+
+ for (uint32_t i = 0; i < pendingEvents.Length(); ++i) {
+ RefPtr<WorkerRunnable> r = pendingEvents[i].forget();
+ if (NS_WARN_IF(!r->Dispatch())) {
+ NS_WARNING("Failed to dispatch pending functional event!");
+ }
+ }
+}
+
+nsresult
+ServiceWorkerPrivate::GetDebugger(nsIWorkerDebugger** aResult)
+{
+ AssertIsOnMainThread();
+ MOZ_ASSERT(aResult);
+
+ if (!mDebuggerCount) {
+ return NS_OK;
+ }
+
+ MOZ_ASSERT(mWorkerPrivate);
+
+ nsCOMPtr<nsIWorkerDebugger> debugger = do_QueryInterface(mWorkerPrivate->Debugger());
+ debugger.forget(aResult);
+
+ return NS_OK;
+}
+
+nsresult
+ServiceWorkerPrivate::AttachDebugger()
+{
+ AssertIsOnMainThread();
+
+ // When the first debugger attaches to a worker, we spawn a worker if needed,
+ // and cancel the idle timeout. The idle timeout should not be reset until
+ // the last debugger detached from the worker.
+ if (!mDebuggerCount) {
+ nsresult rv = SpawnWorkerIfNeeded(AttachEvent, nullptr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mIdleWorkerTimer->Cancel();
+ }
+
+ ++mDebuggerCount;
+
+ return NS_OK;
+}
+
+nsresult
+ServiceWorkerPrivate::DetachDebugger()
+{
+ AssertIsOnMainThread();
+
+ if (!mDebuggerCount) {
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ --mDebuggerCount;
+
+ // When the last debugger detaches from a worker, we either reset the idle
+ // timeout, or terminate the worker if there are no more active tokens.
+ if (!mDebuggerCount) {
+ if (mTokenCount) {
+ ResetIdleTimeout();
+ } else {
+ TerminateWorker();
+ }
+ }
+
+ return NS_OK;
+}
+
+bool
+ServiceWorkerPrivate::IsIdle() const
+{
+ AssertIsOnMainThread();
+ return mTokenCount == 0 || (mTokenCount == 1 && mIdleKeepAliveToken);
+}
+
+namespace {
+
+class ServiceWorkerPrivateTimerCallback final : public nsITimerCallback
+{
+public:
+ typedef void (ServiceWorkerPrivate::*Method)(nsITimer*);
+
+ ServiceWorkerPrivateTimerCallback(ServiceWorkerPrivate* aServiceWorkerPrivate,
+ Method aMethod)
+ : mServiceWorkerPrivate(aServiceWorkerPrivate)
+ , mMethod(aMethod)
+ {
+ }
+
+ NS_IMETHOD
+ Notify(nsITimer* aTimer) override
+ {
+ (mServiceWorkerPrivate->*mMethod)(aTimer);
+ mServiceWorkerPrivate = nullptr;
+ return NS_OK;
+ }
+
+private:
+ ~ServiceWorkerPrivateTimerCallback() = default;
+
+ RefPtr<ServiceWorkerPrivate> mServiceWorkerPrivate;
+ Method mMethod;
+
+ NS_DECL_THREADSAFE_ISUPPORTS
+};
+
+NS_IMPL_ISUPPORTS(ServiceWorkerPrivateTimerCallback, nsITimerCallback);
+
+} // anonymous namespace
+
+void
+ServiceWorkerPrivate::NoteIdleWorkerCallback(nsITimer* aTimer)
+{
+ AssertIsOnMainThread();
+
+ MOZ_ASSERT(aTimer == mIdleWorkerTimer, "Invalid timer!");
+
+ // Release ServiceWorkerPrivate's token, since the grace period has ended.
+ mIdleKeepAliveToken = nullptr;
+
+ if (mWorkerPrivate) {
+ // If we still have a workerPrivate at this point it means there are pending
+ // waitUntil promises. Wait a bit more until we forcibly terminate the
+ // worker.
+ uint32_t timeout = Preferences::GetInt("dom.serviceWorkers.idle_extended_timeout");
+ nsCOMPtr<nsITimerCallback> cb = new ServiceWorkerPrivateTimerCallback(
+ this, &ServiceWorkerPrivate::TerminateWorkerCallback);
+ DebugOnly<nsresult> rv =
+ mIdleWorkerTimer->InitWithCallback(cb, timeout, nsITimer::TYPE_ONE_SHOT);
+ MOZ_ASSERT(NS_SUCCEEDED(rv));
+ }
+}
+
+void
+ServiceWorkerPrivate::TerminateWorkerCallback(nsITimer* aTimer)
+{
+ AssertIsOnMainThread();
+
+ MOZ_ASSERT(aTimer == this->mIdleWorkerTimer, "Invalid timer!");
+
+ // mInfo must be non-null at this point because NoteDeadServiceWorkerInfo
+ // which zeroes it calls TerminateWorker which cancels our timer which will
+ // ensure we don't get invoked even if the nsTimerEvent is in the event queue.
+ ServiceWorkerManager::LocalizeAndReportToAllClients(
+ mInfo->Scope(),
+ "ServiceWorkerGraceTimeoutTermination",
+ nsTArray<nsString> { NS_ConvertUTF8toUTF16(mInfo->Scope()) });
+
+ TerminateWorker();
+}
+
+void
+ServiceWorkerPrivate::RenewKeepAliveToken(WakeUpReason aWhy)
+{
+ // We should have an active worker if we're renewing the keep alive token.
+ MOZ_ASSERT(mWorkerPrivate);
+
+ // If there is at least one debugger attached to the worker, the idle worker
+ // timeout was canceled when the first debugger attached to the worker. It
+ // should not be reset until the last debugger detaches from the worker.
+ if (!mDebuggerCount) {
+ ResetIdleTimeout();
+ }
+
+ if (!mIdleKeepAliveToken) {
+ mIdleKeepAliveToken = new KeepAliveToken(this);
+ }
+}
+
+void
+ServiceWorkerPrivate::ResetIdleTimeout()
+{
+ uint32_t timeout = Preferences::GetInt("dom.serviceWorkers.idle_timeout");
+ nsCOMPtr<nsITimerCallback> cb = new ServiceWorkerPrivateTimerCallback(
+ this, &ServiceWorkerPrivate::NoteIdleWorkerCallback);
+ DebugOnly<nsresult> rv =
+ mIdleWorkerTimer->InitWithCallback(cb, timeout, nsITimer::TYPE_ONE_SHOT);
+ MOZ_ASSERT(NS_SUCCEEDED(rv));
+}
+
+void
+ServiceWorkerPrivate::AddToken()
+{
+ AssertIsOnMainThread();
+ ++mTokenCount;
+}
+
+void
+ServiceWorkerPrivate::ReleaseToken()
+{
+ AssertIsOnMainThread();
+
+ MOZ_ASSERT(mTokenCount > 0);
+ --mTokenCount;
+ if (!mTokenCount) {
+ TerminateWorker();
+ }
+
+ // mInfo can be nullptr here if NoteDeadServiceWorkerInfo() is called while
+ // the KeepAliveToken is being proxy released as a runnable.
+ else if (mInfo && IsIdle()) {
+ RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance();
+ if (swm) {
+ swm->WorkerIsIdle(mInfo);
+ }
+ }
+}
+
+already_AddRefed<KeepAliveToken>
+ServiceWorkerPrivate::CreateEventKeepAliveToken()
+{
+ AssertIsOnMainThread();
+ MOZ_ASSERT(mWorkerPrivate);
+ MOZ_ASSERT(mIdleKeepAliveToken);
+ RefPtr<KeepAliveToken> ref = new KeepAliveToken(this);
+ return ref.forget();
+}
+
+void
+ServiceWorkerPrivate::AddPendingWindow(Runnable* aPendingWindow)
+{
+ AssertIsOnMainThread();
+ pendingWindows.AppendElement(aPendingWindow);
+}
+
+nsresult
+ServiceWorkerPrivate::Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aData)
+{
+ AssertIsOnMainThread();
+
+ nsCString topic(aTopic);
+ if (!topic.Equals(NS_LITERAL_CSTRING("BrowserChrome:Ready"))) {
+ MOZ_ASSERT(false, "Unexpected topic.");
+ return NS_ERROR_FAILURE;
+ }
+
+ nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+ NS_ENSURE_STATE(os);
+ os->RemoveObserver(static_cast<nsIObserver*>(this), "BrowserChrome:Ready");
+
+ size_t len = pendingWindows.Length();
+ for (int i = len-1; i >= 0; i--) {
+ RefPtr<Runnable> runnable = pendingWindows[i];
+ MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
+ pendingWindows.RemoveElementAt(i);
+ }
+
+ return NS_OK;
+}
+
+END_WORKERS_NAMESPACE