gecko-dev/dom/serviceworkers/ServiceWorkerRegistrationImpl.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 "ServiceWorkerRegistrationImpl.h"

#include "ipc/ErrorIPCUtils.h"
#include "mozilla/dom/Promise.h"
#include "mozilla/dom/PromiseWorkerProxy.h"
#include "mozilla/dom/PushManagerBinding.h"
#include "mozilla/dom/PushManager.h"
#include "mozilla/dom/ServiceWorkerRegistrationBinding.h"
#include "mozilla/dom/WorkerCommon.h"
#include "mozilla/dom/WorkerPrivate.h"
#include "mozilla/dom/WorkerRef.h"
#include "mozilla/dom/WorkerScope.h"
#include "mozilla/Services.h"
#include "mozilla/Unused.h"
#include "nsCycleCollectionParticipant.h"
#include "nsNetUtil.h"
#include "nsServiceManagerUtils.h"
#include "ServiceWorker.h"
#include "ServiceWorkerManager.h"
#include "ServiceWorkerPrivate.h"
#include "ServiceWorkerRegistration.h"
#include "ServiceWorkerUnregisterCallback.h"

#include "mozilla/dom/Document.h"
#include "nsIServiceWorkerManager.h"
#include "nsISupportsPrimitives.h"
#include "nsPIDOMWindow.h"
#include "nsContentUtils.h"

namespace mozilla {
namespace dom {

////////////////////////////////////////////////////
// Main Thread implementation

ServiceWorkerRegistrationMainThread::ServiceWorkerRegistrationMainThread(
    const ServiceWorkerRegistrationDescriptor& aDescriptor)
    : mOuter(nullptr),
      mDescriptor(aDescriptor),
      mScope(NS_ConvertUTF8toUTF16(aDescriptor.Scope())),
      mListeningForEvents(false) {
  MOZ_ASSERT(NS_IsMainThread());
}

ServiceWorkerRegistrationMainThread::~ServiceWorkerRegistrationMainThread() {
  MOZ_DIAGNOSTIC_ASSERT(!mListeningForEvents);
  MOZ_DIAGNOSTIC_ASSERT(!mOuter);
}

// XXXnsm, maybe this can be optimized to only add when a event handler is
// registered.
void ServiceWorkerRegistrationMainThread::StartListeningForEvents() {
  MOZ_ASSERT(NS_IsMainThread());
  MOZ_ASSERT(!mListeningForEvents);
  MOZ_DIAGNOSTIC_ASSERT(!mInfo);

  RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance();
  NS_ENSURE_TRUE_VOID(swm);

  mInfo =
      swm->GetRegistration(mDescriptor.PrincipalInfo(), mDescriptor.Scope());
  NS_ENSURE_TRUE_VOID(mInfo);

  mInfo->AddInstance(this, mDescriptor);
  mListeningForEvents = true;
}

void ServiceWorkerRegistrationMainThread::StopListeningForEvents() {
  MOZ_ASSERT(NS_IsMainThread());
  if (!mListeningForEvents) {
    return;
  }

  MOZ_DIAGNOSTIC_ASSERT(mInfo);
  mInfo->RemoveInstance(this);
  mInfo = nullptr;

  mListeningForEvents = false;
}

void ServiceWorkerRegistrationMainThread::RegistrationRemovedInternal() {
  MOZ_ASSERT(NS_IsMainThread());
  // Its possible for the binding object to be collected while we the
  // runnable to call this method is in the event queue.  Double check
  // whether there is still anything to do here.
  if (mOuter) {
    mOuter->RegistrationRemoved();
  }
  StopListeningForEvents();
}

// NB: These functions use NS_ENSURE_TRUE_VOID to be noisy about preconditions
// that would otherwise cause things to silently not happen if they were false.
void ServiceWorkerRegistrationMainThread::UpdateState(
    const ServiceWorkerRegistrationDescriptor& aDescriptor) {
  NS_ENSURE_TRUE_VOID(mOuter);

  nsIGlobalObject* global = mOuter->GetParentObject();
  NS_ENSURE_TRUE_VOID(global);

  RefPtr<ServiceWorkerRegistrationMainThread> self = this;
  nsCOMPtr<nsIRunnable> r =
      NS_NewRunnableFunction("ServiceWorkerRegistrationMainThread::UpdateState",
                             [self, desc = std::move(aDescriptor)]() mutable {
                               self->mDescriptor = std::move(desc);
                               NS_ENSURE_TRUE_VOID(self->mOuter);
                               self->mOuter->UpdateState(self->mDescriptor);
                             });

  Unused << global->EventTargetFor(TaskCategory::Other)
                ->Dispatch(r.forget(), NS_DISPATCH_NORMAL);
}

void ServiceWorkerRegistrationMainThread::FireUpdateFound() {
  NS_ENSURE_TRUE_VOID(mOuter);

  nsIGlobalObject* global = mOuter->GetParentObject();
  NS_ENSURE_TRUE_VOID(global);

  RefPtr<ServiceWorkerRegistrationMainThread> self = this;
  nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction(
      "ServiceWorkerRegistrationMainThread::FireUpdateFound", [self]() mutable {
        NS_ENSURE_TRUE_VOID(self->mOuter);
        self->mOuter->MaybeDispatchUpdateFoundRunnable();
      });

  Unused << global->EventTargetFor(TaskCategory::Other)
                ->Dispatch(r.forget(), NS_DISPATCH_NORMAL);
}

void ServiceWorkerRegistrationMainThread::RegistrationRemoved() {
  NS_ENSURE_TRUE_VOID(mOuter);

  nsIGlobalObject* global = mOuter->GetParentObject();
  NS_ENSURE_TRUE_VOID(global);

  // Queue a runnable to clean up the registration.  This is necessary
  // because there may be runnables in the event queue already to
  // update the registration state.  We want to let those run
  // if possible before clearing our mOuter reference.
  nsCOMPtr<nsIRunnable> r = NewRunnableMethod(
      "ServiceWorkerRegistrationMainThread::RegistrationRemoved", this,
      &ServiceWorkerRegistrationMainThread::RegistrationRemovedInternal);

  Unused << global->EventTargetFor(TaskCategory::Other)
                ->Dispatch(r.forget(), NS_DISPATCH_NORMAL);
}

bool ServiceWorkerRegistrationMainThread::MatchesDescriptor(
    const ServiceWorkerRegistrationDescriptor& aDescriptor) {
  return mOuter->MatchesDescriptor(aDescriptor);
}

void ServiceWorkerRegistrationMainThread::SetServiceWorkerRegistration(
    ServiceWorkerRegistration* aReg) {
  MOZ_DIAGNOSTIC_ASSERT(aReg);
  MOZ_DIAGNOSTIC_ASSERT(!mOuter);
  mOuter = aReg;
  StartListeningForEvents();
}

void ServiceWorkerRegistrationMainThread::ClearServiceWorkerRegistration(
    ServiceWorkerRegistration* aReg) {
  MOZ_ASSERT_IF(mOuter, mOuter == aReg);
  StopListeningForEvents();
  mOuter = nullptr;
}

namespace {

void UpdateInternal(nsIPrincipal* aPrincipal, const nsACString& aScope,
                    ServiceWorkerUpdateFinishCallback* aCallback) {
  MOZ_ASSERT(NS_IsMainThread());
  MOZ_ASSERT(aPrincipal);
  MOZ_ASSERT(aCallback);

  RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance();
  if (!swm) {
    // browser shutdown
    return;
  }

  swm->Update(aPrincipal, aScope, aCallback);
}

class MainThreadUpdateCallback final
    : public ServiceWorkerUpdateFinishCallback {
  RefPtr<ServiceWorkerRegistrationPromise::Private> mPromise;

  ~MainThreadUpdateCallback() {
    mPromise->Reject(NS_ERROR_DOM_ABORT_ERR, __func__);
  }

 public:
  MainThreadUpdateCallback()
      : mPromise(new ServiceWorkerRegistrationPromise::Private(__func__)) {}

  void UpdateSucceeded(ServiceWorkerRegistrationInfo* aRegistration) override {
    mPromise->Resolve(aRegistration->Descriptor(), __func__);
  }

  void UpdateFailed(ErrorResult& aStatus) override {
    mPromise->Reject(std::move(aStatus), __func__);
  }

  RefPtr<ServiceWorkerRegistrationPromise> Promise() const { return mPromise; }
};

class WorkerThreadUpdateCallback final
    : public ServiceWorkerUpdateFinishCallback {
  RefPtr<ThreadSafeWorkerRef> mWorkerRef;
  RefPtr<ServiceWorkerRegistrationPromise::Private> mPromise;

  ~WorkerThreadUpdateCallback() = default;

 public:
  WorkerThreadUpdateCallback(
      RefPtr<ThreadSafeWorkerRef>&& aWorkerRef,
      ServiceWorkerRegistrationPromise::Private* aPromise)
      : mWorkerRef(std::move(aWorkerRef)), mPromise(aPromise) {
    MOZ_ASSERT(NS_IsMainThread());
  }

  void UpdateSucceeded(ServiceWorkerRegistrationInfo* aRegistration) override {
    mPromise->Resolve(aRegistration->Descriptor(), __func__);
    mWorkerRef = nullptr;
  }

  void UpdateFailed(ErrorResult& aStatus) override {
    mPromise->Reject(std::move(aStatus), __func__);
    mWorkerRef = nullptr;
  }
};

class SWRUpdateRunnable final : public Runnable {
  class TimerCallback final : public nsITimerCallback {
    RefPtr<ServiceWorkerPrivate> mPrivate;
    RefPtr<Runnable> mRunnable;

   public:
    TimerCallback(ServiceWorkerPrivate* aPrivate, Runnable* aRunnable)
        : mPrivate(aPrivate), mRunnable(aRunnable) {
      MOZ_ASSERT(mPrivate);
      MOZ_ASSERT(aRunnable);
    }

    NS_IMETHOD
    Notify(nsITimer* aTimer) override {
      mRunnable->Run();
      mPrivate->RemoveISupports(aTimer);

      return NS_OK;
    }

    NS_DECL_THREADSAFE_ISUPPORTS

   private:
    ~TimerCallback() {}
  };

 public:
  SWRUpdateRunnable(StrongWorkerRef* aWorkerRef,
                    ServiceWorkerRegistrationPromise::Private* aPromise,
                    const ServiceWorkerDescriptor& aDescriptor)
      : Runnable("dom::SWRUpdateRunnable"),
        mMutex("SWRUpdateRunnable"),
        mWorkerRef(new ThreadSafeWorkerRef(aWorkerRef)),
        mPromise(aPromise),
        mDescriptor(aDescriptor),
        mDelayed(false) {
    MOZ_DIAGNOSTIC_ASSERT(mWorkerRef);
    MOZ_DIAGNOSTIC_ASSERT(mPromise);
  }

  NS_IMETHOD
  Run() override {
    MOZ_ASSERT(NS_IsMainThread());
    ErrorResult result;

    nsCOMPtr<nsIPrincipal> principal = mDescriptor.GetPrincipal();
    if (NS_WARN_IF(!principal)) {
      mPromise->Reject(NS_ERROR_DOM_INVALID_STATE_ERR, __func__);
      return NS_OK;
    }

    RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance();
    if (NS_WARN_IF(!swm)) {
      mPromise->Reject(NS_ERROR_DOM_INVALID_STATE_ERR, __func__);
      return NS_OK;
    }

    // This will delay update jobs originating from a service worker thread.
    // We don't currently handle ServiceWorkerRegistration.update() from other
    // worker types. Also, we assume this registration matches self.registration
    // on the service worker global. This is ok for now because service worker
    // globals are the only worker contexts where we expose
    // ServiceWorkerRegistration.
    RefPtr<ServiceWorkerRegistrationInfo> registration =
        swm->GetRegistration(principal, mDescriptor.Scope());
    if (NS_WARN_IF(!registration)) {
      return NS_OK;
    }

    RefPtr<ServiceWorkerInfo> worker =
        registration->GetByDescriptor(mDescriptor);
    uint32_t delay = registration->GetUpdateDelay();

    // if we have a timer object, it means we've already been delayed once.
    if (delay && !mDelayed) {
      nsCOMPtr<nsITimerCallback> cb =
          new TimerCallback(worker->WorkerPrivate(), this);
      Result<nsCOMPtr<nsITimer>, nsresult> result = NS_NewTimerWithCallback(
          cb, delay, nsITimer::TYPE_ONE_SHOT,
          SystemGroup::EventTargetFor(TaskCategory::Other));

      nsCOMPtr<nsITimer> timer = result.unwrapOr(nullptr);
      if (NS_WARN_IF(!timer)) {
        return NS_OK;
      }

      mDelayed = true;

      // We're storing the timer object on the calling service worker's private.
      // ServiceWorkerPrivate will drop the reference if the worker terminates,
      // which will cancel the timer.
      if (!worker->WorkerPrivate()->MaybeStoreISupports(timer)) {
        // The worker thread is already shutting down.  Just cancel the timer
        // and let the update runnable be destroyed.
        timer->Cancel();
        return NS_OK;
      }

      return NS_OK;
    }

    RefPtr<ServiceWorkerRegistrationPromise::Private> promise;
    {
      MutexAutoLock lock(mMutex);
      promise.swap(mPromise);
    }

    RefPtr<WorkerThreadUpdateCallback> cb =
        new WorkerThreadUpdateCallback(std::move(mWorkerRef), promise);
    UpdateInternal(principal, mDescriptor.Scope(), cb);

    return NS_OK;
  }

 private:
  ~SWRUpdateRunnable() {
    MutexAutoLock lock(mMutex);
    if (mPromise) {
      mPromise->Reject(NS_ERROR_DOM_INVALID_STATE_ERR, __func__);
    }
  }

  // Protects promise access across threads
  Mutex mMutex;

  RefPtr<ThreadSafeWorkerRef> mWorkerRef;
  RefPtr<ServiceWorkerRegistrationPromise::Private> mPromise;
  const ServiceWorkerDescriptor mDescriptor;
  bool mDelayed;
};

NS_IMPL_ISUPPORTS(SWRUpdateRunnable::TimerCallback, nsITimerCallback)

class WorkerUnregisterCallback final
    : public nsIServiceWorkerUnregisterCallback {
  RefPtr<ThreadSafeWorkerRef> mWorkerRef;
  RefPtr<GenericPromise::Private> mPromise;

 public:
  NS_DECL_ISUPPORTS

  WorkerUnregisterCallback(RefPtr<ThreadSafeWorkerRef>&& aWorkerRef,
                           RefPtr<GenericPromise::Private>&& aPromise)
      : mWorkerRef(std::move(aWorkerRef)), mPromise(std::move(aPromise)) {
    MOZ_DIAGNOSTIC_ASSERT(mWorkerRef);
    MOZ_DIAGNOSTIC_ASSERT(mPromise);
  }

  NS_IMETHOD
  UnregisterSucceeded(bool aState) override {
    mPromise->Resolve(aState, __func__);
    mWorkerRef = nullptr;
    return NS_OK;
  }

  NS_IMETHOD
  UnregisterFailed() override {
    mPromise->Reject(NS_ERROR_DOM_SECURITY_ERR, __func__);
    mWorkerRef = nullptr;
    return NS_OK;
  }

 private:
  ~WorkerUnregisterCallback() = default;
};

NS_IMPL_ISUPPORTS(WorkerUnregisterCallback, nsIServiceWorkerUnregisterCallback);

/*
 * If the worker goes away, we still continue to unregister, but we don't try to
 * resolve the worker Promise (which doesn't exist by that point).
 */
class StartUnregisterRunnable final : public Runnable {
  // The promise is protected by the mutex.
  Mutex mMutex;

  RefPtr<ThreadSafeWorkerRef> mWorkerRef;
  RefPtr<GenericPromise::Private> mPromise;
  const ServiceWorkerRegistrationDescriptor mDescriptor;

  ~StartUnregisterRunnable() {
    MutexAutoLock lock(mMutex);
    if (mPromise) {
      mPromise->Reject(NS_ERROR_DOM_INVALID_STATE_ERR, __func__);
    }
  }

 public:
  StartUnregisterRunnable(
      StrongWorkerRef* aWorkerRef, GenericPromise::Private* aPromise,
      const ServiceWorkerRegistrationDescriptor& aDescriptor)
      : Runnable("dom::StartUnregisterRunnable"),
        mMutex("StartUnregisterRunnable"),
        mWorkerRef(new ThreadSafeWorkerRef(aWorkerRef)),
        mPromise(aPromise),
        mDescriptor(aDescriptor) {
    MOZ_DIAGNOSTIC_ASSERT(mWorkerRef);
    MOZ_DIAGNOSTIC_ASSERT(mPromise);
  }

  NS_IMETHOD
  Run() override {
    MOZ_ASSERT(NS_IsMainThread());

    nsCOMPtr<nsIPrincipal> principal = mDescriptor.GetPrincipal();
    if (!principal) {
      mPromise->Reject(NS_ERROR_DOM_INVALID_STATE_ERR, __func__);
      return NS_OK;
    }

    nsCOMPtr<nsIServiceWorkerManager> swm =
        mozilla::services::GetServiceWorkerManager();
    if (!swm) {
      mPromise->Reject(NS_ERROR_DOM_INVALID_STATE_ERR, __func__);
      return NS_OK;
    }

    RefPtr<GenericPromise::Private> promise;
    {
      MutexAutoLock lock(mMutex);
      promise = mPromise.forget();
    }

    RefPtr<WorkerUnregisterCallback> cb =
        new WorkerUnregisterCallback(std::move(mWorkerRef), std::move(promise));

    nsresult rv = swm->Unregister(principal, cb,
                                  NS_ConvertUTF8toUTF16(mDescriptor.Scope()));
    if (NS_WARN_IF(NS_FAILED(rv))) {
      mPromise->Reject(rv, __func__);
      return NS_OK;
    }

    return NS_OK;
  }
};

}  // namespace

void ServiceWorkerRegistrationMainThread::Update(
    ServiceWorkerRegistrationCallback&& aSuccessCB,
    ServiceWorkerFailureCallback&& aFailureCB) {
  MOZ_ASSERT(NS_IsMainThread());
  MOZ_DIAGNOSTIC_ASSERT(mOuter);

  nsIGlobalObject* global = mOuter->GetParentObject();
  if (!global) {
    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));
    return;
  }

  nsCOMPtr<nsIPrincipal> principal = mDescriptor.GetPrincipal();
  if (!principal) {
    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));
    return;
  }

  RefPtr<MainThreadUpdateCallback> cb = new MainThreadUpdateCallback();
  UpdateInternal(principal, NS_ConvertUTF16toUTF8(mScope), cb);

  auto holder =
      MakeRefPtr<DOMMozPromiseRequestHolder<ServiceWorkerRegistrationPromise>>(
          global);

  cb->Promise()
      ->Then(
          global->EventTargetFor(TaskCategory::Other), __func__,
          [successCB = std::move(aSuccessCB),
           holder](const ServiceWorkerRegistrationDescriptor& aDescriptor) {
            holder->Complete();
            successCB(aDescriptor);
          },
          [failureCB = std::move(aFailureCB),
           holder](const CopyableErrorResult& aRv) {
            holder->Complete();
            failureCB(CopyableErrorResult(aRv));
          })
      ->Track(*holder);
}

void ServiceWorkerRegistrationMainThread::Unregister(
    ServiceWorkerBoolCallback&& aSuccessCB,
    ServiceWorkerFailureCallback&& aFailureCB) {
  MOZ_ASSERT(NS_IsMainThread());
  MOZ_DIAGNOSTIC_ASSERT(mOuter);

  nsIGlobalObject* global = mOuter->GetParentObject();
  if (!global) {
    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));
    return;
  }

  nsCOMPtr<nsIServiceWorkerManager> swm =
      mozilla::services::GetServiceWorkerManager();
  if (!swm) {
    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));
    return;
  }

  nsCOMPtr<nsIPrincipal> principal = mDescriptor.GetPrincipal();
  if (!principal) {
    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));
    return;
  }

  RefPtr<UnregisterCallback> cb = new UnregisterCallback();

  nsresult rv = swm->Unregister(principal, cb,
                                NS_ConvertUTF8toUTF16(mDescriptor.Scope()));
  if (NS_FAILED(rv)) {
    aFailureCB(CopyableErrorResult(rv));
    return;
  }

  auto holder = MakeRefPtr<DOMMozPromiseRequestHolder<GenericPromise>>(global);

  cb->Promise()
      ->Then(
          global->EventTargetFor(TaskCategory::Other), __func__,
          [successCB = std::move(aSuccessCB), holder](bool aResult) {
            holder->Complete();
            successCB(aResult);
          },
          [failureCB = std::move(aFailureCB), holder](nsresult aRv) {
            holder->Complete();
            failureCB(CopyableErrorResult(aRv));
          })
      ->Track(*holder);
}

////////////////////////////////////////////////////
// Worker Thread implementation

class WorkerListener final : public ServiceWorkerRegistrationListener {
  ServiceWorkerRegistrationDescriptor mDescriptor;
  nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> mInfo;
  nsCOMPtr<nsISerialEventTarget> mEventTarget;
  bool mListeningForEvents;

  // Set and unset on worker thread, used on main-thread and protected by mutex.
  ServiceWorkerRegistrationWorkerThread* mRegistration;

  Mutex mMutex;

 public:
  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WorkerListener, override)

  WorkerListener(ServiceWorkerRegistrationWorkerThread* aReg,
                 const ServiceWorkerRegistrationDescriptor& aDescriptor,
                 nsISerialEventTarget* aEventTarget)
      : mDescriptor(aDescriptor),
        mEventTarget(aEventTarget),
        mListeningForEvents(false),
        mRegistration(aReg),
        mMutex("WorkerListener::mMutex") {
    MOZ_ASSERT(IsCurrentThreadRunningWorker());
    MOZ_ASSERT(mEventTarget);
    MOZ_ASSERT(mRegistration);
  }

  void StartListeningForEvents() {
    MOZ_ASSERT(NS_IsMainThread());
    MOZ_DIAGNOSTIC_ASSERT(!mListeningForEvents);
    MOZ_DIAGNOSTIC_ASSERT(!mInfo);

    RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance();
    NS_ENSURE_TRUE_VOID(swm);

    RefPtr<ServiceWorkerRegistrationInfo> info =
        swm->GetRegistration(mDescriptor.PrincipalInfo(), mDescriptor.Scope());
    NS_ENSURE_TRUE_VOID(info);

    mInfo = new nsMainThreadPtrHolder<ServiceWorkerRegistrationInfo>(
        "WorkerListener::mInfo", info);

    mInfo->AddInstance(this, mDescriptor);
    mListeningForEvents = true;
  }

  void StopListeningForEvents() {
    MOZ_ASSERT(NS_IsMainThread());

    if (!mListeningForEvents) {
      return;
    }

    MOZ_DIAGNOSTIC_ASSERT(mInfo);
    mInfo->RemoveInstance(this);
    mListeningForEvents = false;
  }

  // ServiceWorkerRegistrationListener
  void UpdateState(
      const ServiceWorkerRegistrationDescriptor& aDescriptor) override {
    MOZ_ASSERT(NS_IsMainThread());

    mDescriptor = aDescriptor;

    nsCOMPtr<nsIRunnable> r =
        NewCancelableRunnableMethod<ServiceWorkerRegistrationDescriptor>(
            "WorkerListener::UpdateState", this,
            &WorkerListener::UpdateStateOnWorkerThread, aDescriptor);

    Unused << mEventTarget->Dispatch(r.forget(), NS_DISPATCH_NORMAL);
  }

  void FireUpdateFound() override {
    MOZ_ASSERT(NS_IsMainThread());

    nsCOMPtr<nsIRunnable> r = NewCancelableRunnableMethod(
        "WorkerListener::FireUpdateFound", this,
        &WorkerListener::FireUpdateFoundOnWorkerThread);

    Unused << mEventTarget->Dispatch(r.forget(), NS_DISPATCH_NORMAL);
  }

  void UpdateStateOnWorkerThread(
      const ServiceWorkerRegistrationDescriptor& aDescriptor) {
    MOZ_ASSERT(IsCurrentThreadRunningWorker());
    if (mRegistration) {
      mRegistration->UpdateState(aDescriptor);
    }
  }

  void FireUpdateFoundOnWorkerThread() {
    MOZ_ASSERT(IsCurrentThreadRunningWorker());
    if (mRegistration) {
      mRegistration->FireUpdateFound();
    }
  }

  void RegistrationRemoved() override;

  void GetScope(nsAString& aScope) const override {
    CopyUTF8toUTF16(mDescriptor.Scope(), aScope);
  }

  bool MatchesDescriptor(
      const ServiceWorkerRegistrationDescriptor& aDescriptor) override {
    // TODO: Not implemented
    return false;
  }

  void ClearRegistration() {
    MOZ_ASSERT(IsCurrentThreadRunningWorker());
    MutexAutoLock lock(mMutex);
    mRegistration = nullptr;
  }

 private:
  ~WorkerListener() { MOZ_ASSERT(!mListeningForEvents); }
};

ServiceWorkerRegistrationWorkerThread::ServiceWorkerRegistrationWorkerThread(
    const ServiceWorkerRegistrationDescriptor& aDescriptor)
    : mOuter(nullptr),
      mDescriptor(aDescriptor),
      mScope(NS_ConvertUTF8toUTF16(aDescriptor.Scope())) {}

ServiceWorkerRegistrationWorkerThread::
    ~ServiceWorkerRegistrationWorkerThread() {
  MOZ_DIAGNOSTIC_ASSERT(!mListener);
  MOZ_DIAGNOSTIC_ASSERT(!mOuter);
}

void ServiceWorkerRegistrationWorkerThread::RegistrationRemoved() {
  // The SWM notifying us that the registration was removed on the MT may
  // race with ClearServiceWorkerRegistration() on the worker thread.  So
  // double-check that mOuter is still valid.
  if (mOuter) {
    mOuter->RegistrationRemoved();
  }
}

void ServiceWorkerRegistrationWorkerThread::SetServiceWorkerRegistration(
    ServiceWorkerRegistration* aReg) {
  MOZ_DIAGNOSTIC_ASSERT(aReg);
  MOZ_DIAGNOSTIC_ASSERT(!mOuter);
  mOuter = aReg;
  InitListener();
}

void ServiceWorkerRegistrationWorkerThread::ClearServiceWorkerRegistration(
    ServiceWorkerRegistration* aReg) {
  MOZ_ASSERT_IF(mOuter, mOuter == aReg);
  ReleaseListener();
  mOuter = nullptr;
}

void ServiceWorkerRegistrationWorkerThread::Update(
    ServiceWorkerRegistrationCallback&& aSuccessCB,
    ServiceWorkerFailureCallback&& aFailureCB) {
  if (NS_WARN_IF(!mWorkerRef->GetPrivate())) {
    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));
    return;
  }

  RefPtr<StrongWorkerRef> workerRef = StrongWorkerRef::Create(
      mWorkerRef->GetPrivate(), "ServiceWorkerRegistration::Update");
  if (NS_WARN_IF(!workerRef)) {
    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));
    return;
  }

  nsIGlobalObject* global = workerRef->Private()->GlobalScope();
  if (NS_WARN_IF(!global)) {
    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));
    return;
  }

  // Eventually we need to support all workers, but for right now this
  // code assumes we're on a service worker global as self.registration.
  if (NS_WARN_IF(!workerRef->Private()->IsServiceWorker())) {
    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));
    return;
  }

  // Avoid infinite update loops by ignoring update() calls during top
  // level script evaluation.  See:
  // https://github.com/slightlyoff/ServiceWorker/issues/800
  if (workerRef->Private()->IsLoadingWorkerScript()) {
    aSuccessCB(mDescriptor);
    return;
  }

  auto promise =
      MakeRefPtr<ServiceWorkerRegistrationPromise::Private>(__func__);
  auto holder =
      MakeRefPtr<DOMMozPromiseRequestHolder<ServiceWorkerRegistrationPromise>>(
          global);

  promise
      ->Then(
          global->EventTargetFor(TaskCategory::Other), __func__,
          [successCB = std::move(aSuccessCB),
           holder](const ServiceWorkerRegistrationDescriptor& aDescriptor) {
            holder->Complete();
            successCB(aDescriptor);
          },
          [failureCB = std::move(aFailureCB),
           holder](const CopyableErrorResult& aRv) {
            holder->Complete();
            failureCB(CopyableErrorResult(aRv));
          })
      ->Track(*holder);

  RefPtr<SWRUpdateRunnable> r = new SWRUpdateRunnable(
      workerRef, promise, workerRef->Private()->GetServiceWorkerDescriptor());

  nsresult rv = workerRef->Private()->DispatchToMainThread(r.forget());
  if (NS_FAILED(rv)) {
    promise->Reject(NS_ERROR_DOM_INVALID_STATE_ERR, __func__);
    return;
  }
}

void ServiceWorkerRegistrationWorkerThread::Unregister(
    ServiceWorkerBoolCallback&& aSuccessCB,
    ServiceWorkerFailureCallback&& aFailureCB) {
  if (NS_WARN_IF(!mWorkerRef->GetPrivate())) {
    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));
    return;
  }

  RefPtr<StrongWorkerRef> workerRef =
      StrongWorkerRef::Create(mWorkerRef->GetPrivate(), __func__);
  if (NS_WARN_IF(!workerRef)) {
    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));
    return;
  }

  // Eventually we need to support all workers, but for right now this
  // code assumes we're on a service worker global as self.registration.
  if (NS_WARN_IF(!workerRef->Private()->IsServiceWorker())) {
    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));
    return;
  }

  nsIGlobalObject* global = workerRef->Private()->GlobalScope();
  if (!global) {
    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));
    return;
  }

  auto promise = MakeRefPtr<GenericPromise::Private>(__func__);
  auto holder = MakeRefPtr<DOMMozPromiseRequestHolder<GenericPromise>>(global);

  promise
      ->Then(
          global->EventTargetFor(TaskCategory::Other), __func__,
          [successCB = std::move(aSuccessCB), holder](bool aResult) {
            holder->Complete();
            successCB(aResult);
          },
          [failureCB = std::move(aFailureCB), holder](nsresult aRv) {
            holder->Complete();
            failureCB(CopyableErrorResult(aRv));
          })
      ->Track(*holder);

  RefPtr<StartUnregisterRunnable> r =
      new StartUnregisterRunnable(workerRef, promise, mDescriptor);

  nsresult rv = workerRef->Private()->DispatchToMainThread(r);
  if (NS_FAILED(rv)) {
    promise->Reject(NS_ERROR_DOM_INVALID_STATE_ERR, __func__);
    return;
  }
}

void ServiceWorkerRegistrationWorkerThread::InitListener() {
  MOZ_ASSERT(!mListener);
  WorkerPrivate* worker = GetCurrentThreadWorkerPrivate();
  MOZ_ASSERT(worker);
  worker->AssertIsOnWorkerThread();

  RefPtr<ServiceWorkerRegistrationWorkerThread> self = this;
  mWorkerRef = WeakWorkerRef::Create(worker, [self]() {
    self->ReleaseListener();

    // Break the ref-cycle immediately when the worker thread starts to
    // teardown.  We must make sure its GC'd before the worker RuntimeService is
    // destroyed.  The WorkerListener may not be able to post a runnable
    // clearing this value after shutdown begins and thus delaying cleanup too
    // late.
    self->mOuter = nullptr;
  });

  if (NS_WARN_IF(!mWorkerRef)) {
    return;
  }

  mListener =
      new WorkerListener(this, mDescriptor, worker->HybridEventTarget());

  nsCOMPtr<nsIRunnable> r =
      NewRunnableMethod("dom::WorkerListener::StartListeningForEvents",
                        mListener, &WorkerListener::StartListeningForEvents);
  MOZ_ALWAYS_SUCCEEDS(worker->DispatchToMainThread(r.forget()));
}

void ServiceWorkerRegistrationWorkerThread::ReleaseListener() {
  if (!mListener) {
    return;
  }

  MOZ_ASSERT(IsCurrentThreadRunningWorker());

  mListener->ClearRegistration();

  nsCOMPtr<nsIRunnable> r = NewCancelableRunnableMethod(
      "dom::WorkerListener::StopListeningForEvents", mListener,
      &WorkerListener::StopListeningForEvents);
  // Calling GetPrivate() is safe because this method is called when the
  // WorkerRef is notified.
  MOZ_ALWAYS_SUCCEEDS(
      mWorkerRef->GetPrivate()->DispatchToMainThread(r.forget()));

  mListener = nullptr;
  mWorkerRef = nullptr;
}

void ServiceWorkerRegistrationWorkerThread::UpdateState(
    const ServiceWorkerRegistrationDescriptor& aDescriptor) {
  if (mOuter) {
    mOuter->UpdateState(aDescriptor);
  }
}

void ServiceWorkerRegistrationWorkerThread::FireUpdateFound() {
  if (mOuter) {
    mOuter->MaybeDispatchUpdateFoundRunnable();
  }
}

class RegistrationRemovedWorkerRunnable final : public WorkerRunnable {
  RefPtr<WorkerListener> mListener;

 public:
  RegistrationRemovedWorkerRunnable(WorkerPrivate* aWorkerPrivate,
                                    WorkerListener* aListener)
      : WorkerRunnable(aWorkerPrivate), mListener(aListener) {
    // Need this assertion for now since runnables which modify busy count can
    // only be dispatched from parent thread to worker thread and we don't deal
    // with nested workers. SW threads can't be nested.
    MOZ_ASSERT(aWorkerPrivate->IsServiceWorker());
  }

  bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {
    MOZ_ASSERT(aWorkerPrivate);
    aWorkerPrivate->AssertIsOnWorkerThread();
    mListener->RegistrationRemoved();
    return true;
  }
};

void WorkerListener::RegistrationRemoved() {
  MutexAutoLock lock(mMutex);
  if (!mRegistration) {
    return;
  }

  if (NS_IsMainThread()) {
    RefPtr<WorkerRunnable> r = new RegistrationRemovedWorkerRunnable(
        mRegistration->GetWorkerPrivate(lock), this);
    Unused << r->Dispatch();

    StopListeningForEvents();
    return;
  }

  mRegistration->RegistrationRemoved();
}

WorkerPrivate* ServiceWorkerRegistrationWorkerThread::GetWorkerPrivate(
    const MutexAutoLock& aProofOfLock) {
  // In this case, calling GetUnsafePrivate() is ok because we have a proof of
  // mutex lock.
  MOZ_ASSERT(mWorkerRef && mWorkerRef->GetUnsafePrivate());
  return mWorkerRef->GetUnsafePrivate();
}

}  // namespace dom
}  // namespace mozilla