gecko-dev/dom/workers/WorkerRunnable.cpp

/* -*- 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 "WorkerRunnable.h"

#include "WorkerScope.h"
#include "js/RootingAPI.h"
#include "jsapi.h"
#include "jsfriendapi.h"
#include "mozilla/AlreadyAddRefed.h"
#include "mozilla/AppShutdown.h"
#include "mozilla/Assertions.h"
#include "mozilla/CycleCollectedJSContext.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/Logging.h"
#include "mozilla/Maybe.h"
#include "mozilla/Telemetry.h"
#include "mozilla/TelemetryHistogramEnums.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/Unused.h"
#include "mozilla/dom/ScriptSettings.h"
#include "mozilla/dom/Worker.h"
#include "mozilla/dom/WorkerCommon.h"
#include "nsDebug.h"
#include "nsGlobalWindowInner.h"
#include "nsID.h"
#include "nsIEventTarget.h"
#include "nsIGlobalObject.h"
#include "nsIRunnable.h"
#include "nsThreadUtils.h"
#include "nsWrapperCacheInlines.h"

namespace mozilla::dom {

static mozilla::LazyLogModule sWorkerRunnableLog("WorkerRunnable");

#ifdef LOG
#  undef LOG
#endif
#define LOG(args) MOZ_LOG(sWorkerRunnableLog, LogLevel::Verbose, args);

namespace {

const nsIID kWorkerRunnableIID = {
    0x320cc0b5,
    0xef12,
    0x4084,
    {0x88, 0x6e, 0xca, 0x6a, 0x81, 0xe4, 0x1d, 0x68}};

}  // namespace

#ifdef DEBUG
WorkerRunnable::WorkerRunnable(const char* aName)
#  ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
    : mName(aName) {
  LOG(("WorkerRunnable::WorkerRunnable [%p] (%s)", this, mName));
}
#  else
{
  LOG(("WorkerRunnable::WorkerRunnable [%p]", this));
}
#  endif
#endif

// static
WorkerRunnable* WorkerRunnable::FromRunnable(nsIRunnable* aRunnable) {
  MOZ_ASSERT(aRunnable);

  WorkerRunnable* runnable;
  nsresult rv = aRunnable->QueryInterface(kWorkerRunnableIID,
                                          reinterpret_cast<void**>(&runnable));
  if (NS_FAILED(rv)) {
    return nullptr;
  }

  MOZ_ASSERT(runnable);
  return runnable;
}

bool WorkerRunnable::Dispatch(WorkerPrivate* aWorkerPrivate) {
  LOG(("WorkerRunnable::Dispatch [%p] aWorkerPrivate: %p", this,
       aWorkerPrivate));
  MOZ_DIAGNOSTIC_ASSERT(aWorkerPrivate);
  bool ok = PreDispatch(aWorkerPrivate);
  if (ok) {
    ok = DispatchInternal(aWorkerPrivate);
  }
  PostDispatch(aWorkerPrivate, ok);
  return ok;
}

NS_IMETHODIMP WorkerRunnable::Run() { return NS_OK; }

NS_IMPL_ADDREF(WorkerRunnable)
NS_IMPL_RELEASE(WorkerRunnable)

#ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
NS_IMETHODIMP
WorkerRunnable::GetName(nsACString& aName) {
  if (mName) {
    aName.AssignASCII(mName);
  } else {
    aName.Truncate();
  }
  return NS_OK;
}
#endif

NS_INTERFACE_MAP_BEGIN(WorkerRunnable)
  NS_INTERFACE_MAP_ENTRY(nsIRunnable)
#ifdef MOZ_COLLECTING_RUNNABLE_TELEMETRY
  NS_INTERFACE_MAP_ENTRY(nsINamed)
#endif
  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIRunnable)
  // kWorkerRunnableIID is special in that it does not AddRef its result.
  if (aIID.Equals(kWorkerRunnableIID)) {
    *aInstancePtr = this;
    return NS_OK;
  } else
NS_INTERFACE_MAP_END

WorkerParentThreadRunnable::WorkerParentThreadRunnable(const char* aName)
    : WorkerRunnable(aName) {
  LOG(("WorkerParentThreadRunnable::WorkerParentThreadRunnable [%p]", this));
}

WorkerParentThreadRunnable::~WorkerParentThreadRunnable() = default;

bool WorkerParentThreadRunnable::PreDispatch(WorkerPrivate* aWorkerPrivate) {
#ifdef DEBUG
  MOZ_ASSERT(aWorkerPrivate);
  aWorkerPrivate->AssertIsOnWorkerThread();
#endif
  return true;
}

bool WorkerParentThreadRunnable::DispatchInternal(
    WorkerPrivate* aWorkerPrivate) {
  LOG(("WorkerParentThreadRunnable::DispatchInternal [%p]", this));
  mWorkerParentRef = aWorkerPrivate->GetWorkerParentRef();
  RefPtr<WorkerParentThreadRunnable> runnable(this);
  return NS_SUCCEEDED(aWorkerPrivate->DispatchToParent(runnable.forget()));
}

void WorkerParentThreadRunnable::PostDispatch(WorkerPrivate* aWorkerPrivate,
                                              bool aDispatchResult) {
#ifdef DEBUG
  MOZ_ASSERT(aWorkerPrivate);
  aWorkerPrivate->AssertIsOnWorkerThread();
#endif
}

bool WorkerParentThreadRunnable::PreRun(WorkerPrivate* aWorkerPrivate) {
  return true;
}

void WorkerParentThreadRunnable::PostRun(JSContext* aCx,
                                         WorkerPrivate* aWorkerPrivate,
                                         bool aRunResult) {
  MOZ_ASSERT(aCx);
#ifdef DEBUG
  MOZ_ASSERT(aWorkerPrivate);
  aWorkerPrivate->AssertIsOnParentThread();
#endif
}

NS_IMETHODIMP
WorkerParentThreadRunnable::Run() {
  LOG(("WorkerParentThreadRunnable::Run [%p]", this));
  RefPtr<WorkerPrivate> workerPrivate;
  MOZ_ASSERT(mWorkerParentRef);
  workerPrivate = mWorkerParentRef->Private();
  if (!workerPrivate) {
    NS_WARNING("Worker has already shut down!!!");
    return NS_OK;
  }
#ifdef DEBUG
  workerPrivate->AssertIsOnParentThread();
#endif

  WorkerPrivate* parent = workerPrivate->GetParent();
  bool isOnMainThread = !parent;
  bool result = PreRun(workerPrivate);
  MOZ_ASSERT(result);

  LOG(("WorkerParentThreadRunnable::Run [%p] WorkerPrivate: %p, parent: %p",
       this, workerPrivate.get(), parent));

  // Track down the appropriate global, if any, to use for the AutoEntryScript.
  nsCOMPtr<nsIGlobalObject> globalObject;
  if (isOnMainThread) {
    MOZ_ASSERT(isOnMainThread == NS_IsMainThread());
    globalObject = nsGlobalWindowInner::Cast(workerPrivate->GetWindow());
  } else {
    MOZ_ASSERT(parent == GetCurrentThreadWorkerPrivate());
    globalObject = parent->GlobalScope();
    MOZ_DIAGNOSTIC_ASSERT(globalObject);
  }
  // We might run script as part of WorkerRun, so we need an AutoEntryScript.
  // This is part of the HTML spec for workers at:
  // http://www.whatwg.org/specs/web-apps/current-work/#run-a-worker
  // If we don't have a globalObject we have to use an AutoJSAPI instead, but
  // this is OK as we won't be running script in these circumstances.
  Maybe<mozilla::dom::AutoJSAPI> maybeJSAPI;
  Maybe<mozilla::dom::AutoEntryScript> aes;
  JSContext* cx;
  AutoJSAPI* jsapi;

  if (globalObject) {
    aes.emplace(globalObject, "Worker parent thread runnable", isOnMainThread);
    jsapi = aes.ptr();
    cx = aes->cx();
  } else {
    maybeJSAPI.emplace();
    maybeJSAPI->Init();
    jsapi = maybeJSAPI.ptr();
    cx = jsapi->cx();
  }

  // Note that we can't assert anything about
  // workerPrivate->ParentEventTargetRef()->GetWrapper()
  // existing, since it may in fact have been GCed (and we may be one of the
  // runnables cleaning up the worker as a result).

  // If we are on the parent thread and that thread is not the main thread,
  // then we must be a dedicated worker (because there are no
  // Shared/ServiceWorkers whose parent is itself a worker) and then we
  // definitely have a globalObject.  If it _is_ the main thread, globalObject
  // can be null for workers started from JSMs or other non-window contexts,
  // sadly.
  MOZ_ASSERT_IF(!isOnMainThread,
                workerPrivate->IsDedicatedWorker() && globalObject);

  // If we're on the parent thread we might be in a null realm in the
  // situation described above when globalObject is null.  Make sure to enter
  // the realm of the worker's reflector if there is one.  There might
  // not be one if we're just starting to compile the script for this worker.
  Maybe<JSAutoRealm> ar;
  if (workerPrivate->IsDedicatedWorker() &&
      workerPrivate->ParentEventTargetRef() &&
      workerPrivate->ParentEventTargetRef()->GetWrapper()) {
    JSObject* wrapper = workerPrivate->ParentEventTargetRef()->GetWrapper();

    // If we're on the parent thread and have a reflector and a globalObject,
    // then the realms of cx, globalObject, and the worker's reflector
    // should all match.
    MOZ_ASSERT_IF(globalObject,
                  js::GetNonCCWObjectRealm(wrapper) == js::GetContextRealm(cx));
    MOZ_ASSERT_IF(globalObject,
                  js::GetNonCCWObjectRealm(wrapper) ==
                      js::GetNonCCWObjectRealm(
                          globalObject->GetGlobalJSObjectPreserveColor()));

    // If we're on the parent thread and have a reflector, then our
    // JSContext had better be either in the null realm (and hence
    // have no globalObject) or in the realm of our reflector.
    MOZ_ASSERT(!js::GetContextRealm(cx) ||
                   js::GetNonCCWObjectRealm(wrapper) == js::GetContextRealm(cx),
               "Must either be in the null compartment or in our reflector "
               "compartment");

    ar.emplace(cx, wrapper);
  }

  MOZ_ASSERT(!jsapi->HasException());
  result = WorkerRun(cx, workerPrivate);
  jsapi->ReportException();

  // It would be nice to avoid passing a JSContext to PostRun, but in the case
  // of ScriptExecutorRunnable we need to know the current compartment on the
  // JSContext (the one we set up based on the global returned from PreRun) so
  // that we can sanely do exception reporting.  In particular, we want to make
  // sure that we do our JS_SetPendingException while still in that compartment,
  // because otherwise we might end up trying to create a cross-compartment
  // wrapper when we try to move the JS exception from our runnable's
  // ErrorResult to the JSContext, and that's not desirable in this case.
  //
  // We _could_ skip passing a JSContext here and then in
  // ScriptExecutorRunnable::PostRun end up grabbing it from the WorkerPrivate
  // and looking at its current compartment.  But that seems like slightly weird
  // action-at-a-distance...
  //
  // In any case, we do NOT try to change the compartment on the JSContext at
  // this point; in the one case in which we could do that
  // (CompileScriptRunnable) it actually doesn't matter which compartment we're
  // in for PostRun.
  PostRun(cx, workerPrivate, result);
  MOZ_ASSERT(!jsapi->HasException());

  return result ? NS_OK : NS_ERROR_FAILURE;
}

nsresult WorkerParentThreadRunnable::Cancel() {
  LOG(("WorkerParentThreadRunnable::Cancel [%p]", this));
  return NS_OK;
}

WorkerParentControlRunnable::WorkerParentControlRunnable(const char* aName)
    : WorkerParentThreadRunnable(aName) {}

WorkerParentControlRunnable::~WorkerParentControlRunnable() = default;

nsresult WorkerParentControlRunnable::Cancel() {
  LOG(("WorkerParentControlRunnable::Cancel [%p]", this));
  if (NS_FAILED(Run())) {
    NS_WARNING("WorkerParentControlRunnable::Run() failed.");
  }
  return NS_OK;
}

WorkerThreadRunnable::WorkerThreadRunnable(const char* aName)
    : WorkerRunnable(aName), mCallingCancelWithinRun(false) {
  LOG(("WorkerThreadRunnable::WorkerThreadRunnable [%p]", this));
}

nsIGlobalObject* WorkerThreadRunnable::DefaultGlobalObject(
    WorkerPrivate* aWorkerPrivate) const {
  MOZ_DIAGNOSTIC_ASSERT(aWorkerPrivate);
  if (IsDebuggerRunnable()) {
    return aWorkerPrivate->DebuggerGlobalScope();
  }
  return aWorkerPrivate->GlobalScope();
}

bool WorkerThreadRunnable::PreDispatch(WorkerPrivate* aWorkerPrivate) {
  MOZ_ASSERT(aWorkerPrivate);
#ifdef DEBUG
  aWorkerPrivate->AssertIsOnParentThread();
#endif
  return true;
}

bool WorkerThreadRunnable::DispatchInternal(WorkerPrivate* aWorkerPrivate) {
  LOG(("WorkerThreadRunnable::DispatchInternal [%p]", this));
  RefPtr<WorkerThreadRunnable> runnable(this);
  return NS_SUCCEEDED(aWorkerPrivate->Dispatch(runnable.forget()));
}

void WorkerThreadRunnable::PostDispatch(WorkerPrivate* aWorkerPrivate,
                                        bool aDispatchResult) {
  MOZ_ASSERT(aWorkerPrivate);
#ifdef DEBUG
  aWorkerPrivate->AssertIsOnParentThread();
#endif
}

bool WorkerThreadRunnable::PreRun(WorkerPrivate* aWorkerPrivate) {
  return true;
}

void WorkerThreadRunnable::PostRun(JSContext* aCx,
                                   WorkerPrivate* aWorkerPrivate,
                                   bool aRunResult) {
  MOZ_ASSERT(aCx);
  MOZ_ASSERT(aWorkerPrivate);

#ifdef DEBUG
  aWorkerPrivate->AssertIsOnWorkerThread();
#endif
}

NS_IMETHODIMP
WorkerThreadRunnable::Run() {
  LOG(("WorkerThreadRunnable::Run [%p]", this));

  // The Worker initialization fails, there is no valid WorkerPrivate and
  // WorkerJSContext to run this WorkerThreadRunnable.
  if (mCleanPreStartDispatching) {
    LOG(("Clean the pre-start dispatched WorkerThreadRunnable [%p]", this));
    return NS_OK;
  }

  WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
  MOZ_ASSERT_DEBUG_OR_FUZZING(workerPrivate);
#ifdef DEBUG
  workerPrivate->AssertIsOnWorkerThread();
#endif

  if (!mCallingCancelWithinRun &&
      workerPrivate->CancelBeforeWorkerScopeConstructed()) {
    mCallingCancelWithinRun = true;
    Cancel();
    mCallingCancelWithinRun = false;
    return NS_OK;
  }

  bool result = PreRun(workerPrivate);
  if (!result) {
    workerPrivate->AssertIsOnWorkerThread();
    MOZ_ASSERT(!JS_IsExceptionPending(workerPrivate->GetJSContext()));
    // We can't enter a useful realm on the JSContext here; just pass it
    // in as-is.
    PostRun(workerPrivate->GetJSContext(), workerPrivate, false);
    return NS_ERROR_FAILURE;
  }

  // Track down the appropriate global, if any, to use for the AutoEntryScript.
  nsCOMPtr<nsIGlobalObject> globalObject =
      workerPrivate->GetCurrentEventLoopGlobal();
  if (!globalObject) {
    globalObject = DefaultGlobalObject(workerPrivate);
    // Our worker thread may not be in a good state here if there is no
    // JSContext avaliable.  The way this manifests itself is that
    // globalObject ends up null (though it's not clear to me how we can be
    // running runnables at all when default globalObject(DebuggerGlobalScope
    // for debugger runnable, and GlobalScope for normal runnables) is returning
    // false!) and then when we try to init the AutoJSAPI either
    // CycleCollectedJSContext::Get() returns null or it has a null JSContext.
    // In any case, we used to have a check for
    // GetCurrentWorkerThreadJSContext() being non-null here and that seems to
    // avoid the problem, so let's keep doing that check even if we don't need
    // the JSContext here at all.
    if (NS_WARN_IF(!globalObject && !GetCurrentWorkerThreadJSContext())) {
      return NS_ERROR_FAILURE;
    }
  }

  // We might run script as part of WorkerRun, so we need an AutoEntryScript.
  // This is part of the HTML spec for workers at:
  // http://www.whatwg.org/specs/web-apps/current-work/#run-a-worker
  // If we don't have a globalObject we have to use an AutoJSAPI instead, but
  // this is OK as we won't be running script in these circumstances.
  Maybe<mozilla::dom::AutoJSAPI> maybeJSAPI;
  Maybe<mozilla::dom::AutoEntryScript> aes;
  JSContext* cx;
  AutoJSAPI* jsapi;
  if (globalObject) {
    aes.emplace(globalObject, "Worker runnable", false);
    jsapi = aes.ptr();
    cx = aes->cx();
  } else {
    maybeJSAPI.emplace();
    maybeJSAPI->Init();
    jsapi = maybeJSAPI.ptr();
    cx = jsapi->cx();
  }

  MOZ_ASSERT(!jsapi->HasException());
  result = WorkerRun(cx, workerPrivate);
  jsapi->ReportException();

  // We can't even assert that this didn't create our global, since in the case
  // of CompileScriptRunnable it _does_.

  // It would be nice to avoid passing a JSContext to PostRun, but in the case
  // of ScriptExecutorRunnable we need to know the current compartment on the
  // JSContext (the one we set up based on the global returned from PreRun) so
  // that we can sanely do exception reporting.  In particular, we want to make
  // sure that we do our JS_SetPendingException while still in that compartment,
  // because otherwise we might end up trying to create a cross-compartment
  // wrapper when we try to move the JS exception from our runnable's
  // ErrorResult to the JSContext, and that's not desirable in this case.
  //
  // We _could_ skip passing a JSContext here and then in
  // ScriptExecutorRunnable::PostRun end up grabbing it from the WorkerPrivate
  // and looking at its current compartment.  But that seems like slightly weird
  // action-at-a-distance...
  //
  // In any case, we do NOT try to change the compartment on the JSContext at
  // this point; in the one case in which we could do that
  // (CompileScriptRunnable) it actually doesn't matter which compartment we're
  // in for PostRun.
  PostRun(cx, workerPrivate, result);
  MOZ_ASSERT(!jsapi->HasException());

  return result ? NS_OK : NS_ERROR_FAILURE;
}

nsresult WorkerThreadRunnable::Cancel() {
  LOG(("WorkerThreadRunnable::Cancel [%p]", this));
  return NS_OK;
}

void WorkerDebuggerRunnable::PostDispatch(WorkerPrivate* aWorkerPrivate,
                                          bool aDispatchResult) {}

WorkerSyncRunnable::WorkerSyncRunnable(nsIEventTarget* aSyncLoopTarget,
                                       const char* aName)
    : WorkerThreadRunnable(aName), mSyncLoopTarget(aSyncLoopTarget) {}

WorkerSyncRunnable::WorkerSyncRunnable(
    nsCOMPtr<nsIEventTarget>&& aSyncLoopTarget, const char* aName)
    : WorkerThreadRunnable(aName),
      mSyncLoopTarget(std::move(aSyncLoopTarget)) {}

WorkerSyncRunnable::~WorkerSyncRunnable() = default;

bool WorkerSyncRunnable::DispatchInternal(WorkerPrivate* aWorkerPrivate) {
  if (mSyncLoopTarget) {
#ifdef DEBUG
    aWorkerPrivate->AssertValidSyncLoop(mSyncLoopTarget);
#endif
    RefPtr<WorkerSyncRunnable> runnable(this);
    return NS_SUCCEEDED(
        mSyncLoopTarget->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL));
  }

  return WorkerThreadRunnable::DispatchInternal(aWorkerPrivate);
}

void MainThreadWorkerSyncRunnable::PostDispatch(WorkerPrivate* aWorkerPrivate,
                                                bool aDispatchResult) {}

MainThreadStopSyncLoopRunnable::MainThreadStopSyncLoopRunnable(
    nsCOMPtr<nsIEventTarget>&& aSyncLoopTarget, nsresult aResult)
    : WorkerSyncRunnable(std::move(aSyncLoopTarget)), mResult(aResult) {
  LOG(("MainThreadStopSyncLoopRunnable::MainThreadStopSyncLoopRunnable [%p]",
       this));

  AssertIsOnMainThread();
}

nsresult MainThreadStopSyncLoopRunnable::Cancel() {
  LOG(("MainThreadStopSyncLoopRunnable::Cancel [%p]", this));
  nsresult rv = Run();
  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Run() failed");

  return rv;
}

bool MainThreadStopSyncLoopRunnable::WorkerRun(JSContext* aCx,
                                               WorkerPrivate* aWorkerPrivate) {
  aWorkerPrivate->AssertIsOnWorkerThread();
  MOZ_ASSERT(mSyncLoopTarget);

  nsCOMPtr<nsIEventTarget> syncLoopTarget;
  mSyncLoopTarget.swap(syncLoopTarget);

  aWorkerPrivate->StopSyncLoop(syncLoopTarget, mResult);
  return true;
}

bool MainThreadStopSyncLoopRunnable::DispatchInternal(
    WorkerPrivate* aWorkerPrivate) {
  MOZ_ASSERT(mSyncLoopTarget);
#ifdef DEBUG
  aWorkerPrivate->AssertValidSyncLoop(mSyncLoopTarget);
#endif
  RefPtr<MainThreadStopSyncLoopRunnable> runnable(this);
  return NS_SUCCEEDED(
      mSyncLoopTarget->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL));
}

void MainThreadStopSyncLoopRunnable::PostDispatch(WorkerPrivate* aWorkerPrivate,
                                                  bool aDispatchResult) {}

WorkerControlRunnable::WorkerControlRunnable(const char* aName)
    : WorkerThreadRunnable(aName) {}

nsresult WorkerControlRunnable::Cancel() {
  LOG(("WorkerControlRunnable::Cancel [%p]", this));
  if (NS_FAILED(Run())) {
    NS_WARNING("WorkerControlRunnable::Run() failed.");
  }

  return NS_OK;
}

WorkerMainThreadRunnable::WorkerMainThreadRunnable(
    WorkerPrivate* aWorkerPrivate, const nsACString& aTelemetryKey,
    const char* const aName)
    : mozilla::Runnable("dom::WorkerMainThreadRunnable"),
      mTelemetryKey(aTelemetryKey),
      mName(aName) {
  aWorkerPrivate->AssertIsOnWorkerThread();
}

WorkerMainThreadRunnable::~WorkerMainThreadRunnable() = default;

void WorkerMainThreadRunnable::Dispatch(WorkerPrivate* aWorkerPrivate,
                                        WorkerStatus aFailStatus,
                                        mozilla::ErrorResult& aRv) {
  aWorkerPrivate->AssertIsOnWorkerThread();

  TimeStamp startTime = TimeStamp::NowLoRes();

  RefPtr<StrongWorkerRef> workerRef;
  if (aFailStatus < Canceling) {
    // Nothing but logging debugging messages in the WorkerRef's
    // shutdown callback.
    // Stopping syncLoop in the shutdown callback could cause memory leaks or
    // UAF when the main thread job completes.
    workerRef =
        StrongWorkerRef::Create(aWorkerPrivate, mName, [self = RefPtr{this}]() {
          LOG(
              ("WorkerMainThreadRunnable::Dispatch [%p](%s) Worker starts to "
               "shutdown while underlying SyncLoop is still running",
               self.get(), self->mName));
        });
  } else {
    LOG(
        ("WorkerMainThreadRunnable::Dispatch [%p](%s) Creating a SyncLoop when"
         "the Worker is shutting down",
         this, mName));
    workerRef = StrongWorkerRef::CreateForcibly(aWorkerPrivate, mName);
  }
  if (!workerRef) {
    // WorkerRef creation can fail if the worker is not in a valid status.
    aRv.ThrowInvalidStateError("The worker has already shut down");
    return;
  }
  mWorkerRef = MakeRefPtr<ThreadSafeWorkerRef>(workerRef);

  AutoSyncLoopHolder syncLoop(aWorkerPrivate, aFailStatus);

  mSyncLoopTarget = syncLoop.GetSerialEventTarget();
  if (!mSyncLoopTarget) {
    // SyncLoop creation can fail if the worker is shutting down.
    aRv.ThrowInvalidStateError("The worker is shutting down");
    return;
  }

  DebugOnly<nsresult> rv = aWorkerPrivate->DispatchToMainThread(this);
  MOZ_ASSERT(
      NS_SUCCEEDED(rv),
      "Should only fail after xpcom-shutdown-threads and we're gone by then");

  bool success = NS_SUCCEEDED(syncLoop.Run());

  // syncLoop is done, release WorkerRef to unblock shutdown.
  mWorkerRef = nullptr;

  Telemetry::Accumulate(
      Telemetry::SYNC_WORKER_OPERATION, mTelemetryKey,
      static_cast<uint32_t>(
          (TimeStamp::NowLoRes() - startTime).ToMilliseconds()));

  Unused << startTime;  // Shut the compiler up.

  if (!success) {
    aRv.ThrowUncatchableException();
  }
}

NS_IMETHODIMP
WorkerMainThreadRunnable::Run() {
  AssertIsOnMainThread();

  // This shouldn't be necessary once we're better about making sure no workers
  // are created during shutdown in earlier phases.
  if (AppShutdown::IsInOrBeyond(ShutdownPhase::XPCOMShutdownThreads)) {
    return NS_ERROR_ILLEGAL_DURING_SHUTDOWN;
  }

  bool runResult = MainThreadRun();

  RefPtr<MainThreadStopSyncLoopRunnable> response =
      new MainThreadStopSyncLoopRunnable(std::move(mSyncLoopTarget),
                                         runResult ? NS_OK : NS_ERROR_FAILURE);

  MOZ_ASSERT(mWorkerRef);
  MOZ_ALWAYS_TRUE(response->Dispatch(mWorkerRef->Private()));

  return NS_OK;
}

bool WorkerSameThreadRunnable::PreDispatch(WorkerPrivate* aWorkerPrivate) {
  aWorkerPrivate->AssertIsOnWorkerThread();
  return true;
}

void WorkerSameThreadRunnable::PostDispatch(WorkerPrivate* aWorkerPrivate,
                                            bool aDispatchResult) {
  aWorkerPrivate->AssertIsOnWorkerThread();
}

WorkerProxyToMainThreadRunnable::WorkerProxyToMainThreadRunnable()
    : mozilla::Runnable("dom::WorkerProxyToMainThreadRunnable") {}

WorkerProxyToMainThreadRunnable::~WorkerProxyToMainThreadRunnable() = default;

bool WorkerProxyToMainThreadRunnable::Dispatch(WorkerPrivate* aWorkerPrivate) {
  MOZ_ASSERT(aWorkerPrivate);
  aWorkerPrivate->AssertIsOnWorkerThread();

  RefPtr<StrongWorkerRef> workerRef = StrongWorkerRef::Create(
      aWorkerPrivate, "WorkerProxyToMainThreadRunnable");
  if (NS_WARN_IF(!workerRef)) {
    RunBackOnWorkerThreadForCleanup(aWorkerPrivate);
    return false;
  }

  MOZ_ASSERT(!mWorkerRef);
  mWorkerRef = new ThreadSafeWorkerRef(workerRef);

  if (ForMessaging()
          ? NS_WARN_IF(NS_FAILED(
                aWorkerPrivate->DispatchToMainThreadForMessaging(this)))
          : NS_WARN_IF(NS_FAILED(aWorkerPrivate->DispatchToMainThread(this)))) {
    ReleaseWorker();
    RunBackOnWorkerThreadForCleanup(aWorkerPrivate);
    return false;
  }

  return true;
}

NS_IMETHODIMP
WorkerProxyToMainThreadRunnable::Run() {
  AssertIsOnMainThread();
  RunOnMainThread(mWorkerRef->Private());
  PostDispatchOnMainThread();
  return NS_OK;
}

void WorkerProxyToMainThreadRunnable::PostDispatchOnMainThread() {
  class ReleaseRunnable final : public MainThreadWorkerControlRunnable {
    RefPtr<WorkerProxyToMainThreadRunnable> mRunnable;

   public:
    explicit ReleaseRunnable(WorkerProxyToMainThreadRunnable* aRunnable)
        : MainThreadWorkerControlRunnable("ReleaseRunnable"),
          mRunnable(aRunnable) {
      MOZ_ASSERT(aRunnable);
    }

    virtual nsresult Cancel() override {
      MOZ_ASSERT(GetCurrentThreadWorkerPrivate());
      Unused << WorkerRun(nullptr, GetCurrentThreadWorkerPrivate());
      return NS_OK;
    }

    virtual bool WorkerRun(JSContext* aCx,
                           WorkerPrivate* aWorkerPrivate) override {
      MOZ_ASSERT(aWorkerPrivate);
      aWorkerPrivate->AssertIsOnWorkerThread();

      if (mRunnable) {
        mRunnable->RunBackOnWorkerThreadForCleanup(aWorkerPrivate);

        // Let's release the worker thread.
        mRunnable->ReleaseWorker();
        mRunnable = nullptr;
      }

      return true;
    }

   private:
    ~ReleaseRunnable() = default;
  };

  RefPtr<WorkerControlRunnable> runnable = new ReleaseRunnable(this);
  Unused << NS_WARN_IF(!runnable->Dispatch(mWorkerRef->Private()));
}

void WorkerProxyToMainThreadRunnable::ReleaseWorker() { mWorkerRef = nullptr; }

}  // namespace mozilla::dom