dom/workers/WorkerRef.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "WorkerRef.h"
   8
   9 #include "mozilla/Unused.h"
  10 #include "WorkerHolder.h"
  11 #include "WorkerRunnable.h"
  12 #include "WorkerPrivate.h"
  13
  14 namespace mozilla {
  15 namespace dom {
  16
  17 namespace {
  18
  19 // This runnable is used to release the StrongWorkerRef on the worker thread
  20 // when a ThreadSafeWorkerRef is released.
  21 class ReleaseRefControlRunnable final : public WorkerControlRunnable {
  22  public:
  23   ReleaseRefControlRunnable(WorkerPrivate* aWorkerPrivate,
  24                             already_AddRefed<StrongWorkerRef> aRef)
  25       : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount),
  26         mRef(std::move(aRef)) {
  27     MOZ_ASSERT(mRef);
  28   }
  29
  30   bool PreDispatch(WorkerPrivate* aWorkerPrivate) override { return true; }
  31
  32   void PostDispatch(WorkerPrivate* aWorkerPrivate,
  33                     bool aDispatchResult) override {}
  34
  35   bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {
  36     mRef = nullptr;
  37     return true;
  38   }
  39
  40  private:
  41   RefPtr<StrongWorkerRef> mRef;
  42 };
  43
  44 }  // namespace
  45
  46 // ----------------------------------------------------------------------------
  47 // WorkerRef::Holder
  48
  49 class WorkerRef::Holder final : public mozilla::dom::WorkerHolder {
  50  public:
  51   Holder(const char* aName, WorkerRef* aWorkerRef, Behavior aBehavior)
  52       : mozilla::dom::WorkerHolder(aName, aBehavior), mWorkerRef(aWorkerRef) {}
  53
  54   bool Notify(WorkerStatus aStatus) override {
  55     MOZ_ASSERT(mWorkerRef);
  56
  57     if (aStatus < Canceling) {
  58       return true;
  59     }
  60
  61     // Let's keep this object alive for the whole Notify() execution.
  62     RefPtr<WorkerRef> workerRef;
  63     workerRef = mWorkerRef;
  64
  65     workerRef->Notify();
  66     return true;
  67   }
  68
  69  public:
  70   WorkerRef* mWorkerRef;
  71 };
  72
  73 // ----------------------------------------------------------------------------
  74 // WorkerRef
  75
  76 WorkerRef::WorkerRef(WorkerPrivate* aWorkerPrivate)
  77     : mWorkerPrivate(aWorkerPrivate) {
  78   MOZ_ASSERT(aWorkerPrivate);
  79   aWorkerPrivate->AssertIsOnWorkerThread();
  80 }
  81
  82 WorkerRef::~WorkerRef() { NS_ASSERT_OWNINGTHREAD(WorkerRef); }
  83
  84 void WorkerRef::Notify() {
  85   MOZ_ASSERT(mHolder);
  86   NS_ASSERT_OWNINGTHREAD(WorkerRef);
  87
  88   if (!mCallback) {
  89     return;
  90   }
  91
  92   std::function<void()> callback = std::move(mCallback);
  93   MOZ_ASSERT(!mCallback);
  94
  95   callback();
  96 }
  97
  98 // ----------------------------------------------------------------------------
  99 // WeakWorkerRef
 100
 101 /* static */
 102 already_AddRefed<WeakWorkerRef> WeakWorkerRef::Create(
 103     WorkerPrivate* aWorkerPrivate, std::function<void()>&& aCallback) {
 104   MOZ_ASSERT(aWorkerPrivate);
 105   aWorkerPrivate->AssertIsOnWorkerThread();
 106
 107   RefPtr<WeakWorkerRef> ref = new WeakWorkerRef(aWorkerPrivate);
 108
 109   // This holder doesn't keep the worker alive.
 110   UniquePtr<Holder> holder(new Holder("WeakWorkerRef::Holder", ref,
 111                                       WorkerHolder::AllowIdleShutdownStart));
 112   if (NS_WARN_IF(!holder->HoldWorker(aWorkerPrivate, Canceling))) {
 113     return nullptr;
 114   }
 115
 116   ref->mHolder = std::move(holder);
 117   ref->mCallback = std::move(aCallback);
 118
 119   return ref.forget();
 120 }
 121
 122 WeakWorkerRef::WeakWorkerRef(WorkerPrivate* aWorkerPrivate)
 123     : WorkerRef(aWorkerPrivate) {}
 124
 125 WeakWorkerRef::~WeakWorkerRef() = default;
 126
 127 void WeakWorkerRef::Notify() {
 128   WorkerRef::Notify();
 129
 130   mHolder = nullptr;
 131   mWorkerPrivate = nullptr;
 132 }
 133
 134 WorkerPrivate* WeakWorkerRef::GetPrivate() const {
 135   NS_ASSERT_OWNINGTHREAD(WeakWorkerRef);
 136   return mWorkerPrivate;
 137 }
 138
 139 WorkerPrivate* WeakWorkerRef::GetUnsafePrivate() const {
 140   return mWorkerPrivate;
 141 }
 142
 143 // ----------------------------------------------------------------------------
 144 // StrongWorkerRef
 145
 146 /* static */
 147 already_AddRefed<StrongWorkerRef> StrongWorkerRef::Create(
 148     WorkerPrivate* const aWorkerPrivate, const char* const aName,
 149     std::function<void()>&& aCallback) {
 150   if (RefPtr<StrongWorkerRef> ref =
 151           CreateImpl(aWorkerPrivate, aName, Canceling)) {
 152     ref->mCallback = std::move(aCallback);
 153     return ref.forget();
 154   }
 155   return nullptr;
 156 }
 157
 158 /* static */
 159 already_AddRefed<StrongWorkerRef> StrongWorkerRef::CreateForcibly(
 160     WorkerPrivate* const aWorkerPrivate, const char* const aName) {
 161   return CreateImpl(aWorkerPrivate, aName, Killing);
 162 }
 163
 164 /* static */
 165 already_AddRefed<StrongWorkerRef> StrongWorkerRef::CreateImpl(
 166     WorkerPrivate* const aWorkerPrivate, const char* const aName,
 167     WorkerStatus const aFailStatus) {
 168   MOZ_ASSERT(aWorkerPrivate);
 169   MOZ_ASSERT(aName);
 170
 171   RefPtr<StrongWorkerRef> ref = new StrongWorkerRef(aWorkerPrivate);
 172
 173   // The worker is kept alive by this holder.
 174   UniquePtr<Holder> holder(
 175       new Holder(aName, ref, WorkerHolder::PreventIdleShutdownStart));
 176   if (NS_WARN_IF(!holder->HoldWorker(aWorkerPrivate, aFailStatus))) {
 177     return nullptr;
 178   }
 179
 180   ref->mHolder = std::move(holder);
 181
 182   return ref.forget();
 183 }
 184
 185 StrongWorkerRef::StrongWorkerRef(WorkerPrivate* aWorkerPrivate)
 186     : WorkerRef(aWorkerPrivate) {}
 187
 188 StrongWorkerRef::~StrongWorkerRef() { NS_ASSERT_OWNINGTHREAD(StrongWorkerRef); }
 189
 190 WorkerPrivate* StrongWorkerRef::Private() const {
 191   MOZ_ASSERT(mHolder);
 192   NS_ASSERT_OWNINGTHREAD(StrongWorkerRef);
 193   return mWorkerPrivate;
 194 }
 195
 196 // ----------------------------------------------------------------------------
 197 // ThreadSafeWorkerRef
 198
 199 ThreadSafeWorkerRef::ThreadSafeWorkerRef(StrongWorkerRef* aRef) : mRef(aRef) {
 200   MOZ_ASSERT(aRef);
 201   aRef->Private()->AssertIsOnWorkerThread();
 202 }
 203
 204 ThreadSafeWorkerRef::~ThreadSafeWorkerRef() {
 205   // Let's release the StrongWorkerRef on the correct thread.
 206   if (!mRef->mWorkerPrivate->IsOnWorkerThread()) {
 207     WorkerPrivate* workerPrivate = mRef->mWorkerPrivate;
 208     RefPtr<ReleaseRefControlRunnable> r =
 209         new ReleaseRefControlRunnable(workerPrivate, mRef.forget());
 210     r->Dispatch();
 211     return;
 212   }
 213 }
 214
 215 WorkerPrivate* ThreadSafeWorkerRef::Private() const {
 216   return mRef->mWorkerPrivate;
 217 }
 218
 219 }  // namespace dom
 220 }  // namespace mozilla