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 "mozilla/dom/WorkerRef.h"
   8
   9 #include "nsDebug.h"
  10 #include "WorkerRunnable.h"
  11 #include "WorkerPrivate.h"
  12
  13 namespace mozilla::dom {
  14
  15 namespace {
  16
  17 // This runnable is used to release the StrongWorkerRef on the worker thread
  18 // when a ThreadSafeWorkerRef is released.
  19 class ReleaseRefControlRunnable final : public WorkerControlRunnable {
  20  public:
  21   ReleaseRefControlRunnable(WorkerPrivate* aWorkerPrivate,
  22                             already_AddRefed<StrongWorkerRef> aRef)
  23       : WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount),
  24         mRef(std::move(aRef)) {
  25     MOZ_ASSERT(mRef);
  26   }
  27
  28   bool PreDispatch(WorkerPrivate* aWorkerPrivate) override { return true; }
  29
  30   void PostDispatch(WorkerPrivate* aWorkerPrivate,
  31                     bool aDispatchResult) override {}
  32
  33   bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {
  34     mRef = nullptr;
  35     return true;
  36   }
  37
  38  private:
  39   RefPtr<StrongWorkerRef> mRef;
  40 };
  41
  42 }  // namespace
  43
  44 // ----------------------------------------------------------------------------
  45 // WorkerRef
  46
  47 WorkerRef::WorkerRef(WorkerPrivate* aWorkerPrivate, const char* aName,
  48                      bool aIsPreventingShutdown)
  49     : mWorkerPrivate(aWorkerPrivate),
  50       mName(aName),
  51       mIsPreventingShutdown(aIsPreventingShutdown),
  52       mHolding(false) {
  53   MOZ_ASSERT(aWorkerPrivate);
  54   MOZ_ASSERT(aName);
  55
  56   aWorkerPrivate->AssertIsOnWorkerThread();
  57 }
  58
  59 WorkerRef::~WorkerRef() {
  60   NS_ASSERT_OWNINGTHREAD(WorkerRef);
  61   ReleaseWorker();
  62 }
  63
  64 void WorkerRef::ReleaseWorker() {
  65   if (mHolding) {
  66     MOZ_ASSERT(mWorkerPrivate);
  67
  68     mWorkerPrivate->RemoveWorkerRef(this);
  69     mWorkerPrivate = nullptr;
  70
  71     mHolding = false;
  72   }
  73 }
  74
  75 bool WorkerRef::HoldWorker(WorkerStatus aStatus) {
  76   MOZ_ASSERT(mWorkerPrivate);
  77   MOZ_ASSERT(!mHolding);
  78
  79   if (NS_WARN_IF(!mWorkerPrivate->AddWorkerRef(this, aStatus))) {
  80     return false;
  81   }
  82
  83   mHolding = true;
  84   return true;
  85 }
  86
  87 void WorkerRef::Notify() {
  88   NS_ASSERT_OWNINGTHREAD(WorkerRef);
  89
  90   if (!mCallback) {
  91     return;
  92   }
  93
  94   MoveOnlyFunction<void()> callback = std::move(mCallback);
  95   MOZ_ASSERT(!mCallback);
  96
  97   callback();
  98 }
  99
 100 // ----------------------------------------------------------------------------
 101 // WeakWorkerRef
 102
 103 /* static */
 104 already_AddRefed<WeakWorkerRef> WeakWorkerRef::Create(
 105     WorkerPrivate* aWorkerPrivate, MoveOnlyFunction<void()>&& aCallback) {
 106   MOZ_ASSERT(aWorkerPrivate);
 107   aWorkerPrivate->AssertIsOnWorkerThread();
 108
 109   RefPtr<WeakWorkerRef> ref = new WeakWorkerRef(aWorkerPrivate);
 110   if (!ref->HoldWorker(Canceling)) {
 111     return nullptr;
 112   }
 113
 114   ref->mCallback = std::move(aCallback);
 115
 116   return ref.forget();
 117 }
 118
 119 WeakWorkerRef::WeakWorkerRef(WorkerPrivate* aWorkerPrivate)
 120     : WorkerRef(aWorkerPrivate, "WeakWorkerRef", false) {}
 121
 122 WeakWorkerRef::~WeakWorkerRef() = default;
 123
 124 void WeakWorkerRef::Notify() {
 125   MOZ_ASSERT(mHolding);
 126   MOZ_ASSERT(mWorkerPrivate);
 127
 128   // Notify could drop the last reference to this object. We must keep it alive
 129   // in order to call ReleaseWorker() immediately after.
 130   RefPtr<WeakWorkerRef> kungFuGrip = this;
 131
 132   WorkerRef::Notify();
 133   ReleaseWorker();
 134 }
 135
 136 WorkerPrivate* WeakWorkerRef::GetPrivate() const {
 137   NS_ASSERT_OWNINGTHREAD(WeakWorkerRef);
 138   return mWorkerPrivate;
 139 }
 140
 141 WorkerPrivate* WeakWorkerRef::GetUnsafePrivate() const {
 142   return mWorkerPrivate;
 143 }
 144
 145 // ----------------------------------------------------------------------------
 146 // StrongWorkerRef
 147
 148 /* static */
 149 already_AddRefed<StrongWorkerRef> StrongWorkerRef::Create(
 150     WorkerPrivate* const aWorkerPrivate, const char* const aName,
 151     MoveOnlyFunction<void()>&& aCallback) {
 152   if (RefPtr<StrongWorkerRef> ref =
 153           CreateImpl(aWorkerPrivate, aName, Canceling)) {
 154     ref->mCallback = std::move(aCallback);
 155     return ref.forget();
 156   }
 157   return nullptr;
 158 }
 159
 160 /* static */
 161 already_AddRefed<StrongWorkerRef> StrongWorkerRef::CreateForcibly(
 162     WorkerPrivate* const aWorkerPrivate, const char* const aName) {
 163   return CreateImpl(aWorkerPrivate, aName, Killing);
 164 }
 165
 166 /* static */
 167 already_AddRefed<StrongWorkerRef> StrongWorkerRef::CreateImpl(
 168     WorkerPrivate* const aWorkerPrivate, const char* const aName,
 169     WorkerStatus const aFailStatus) {
 170   MOZ_ASSERT(aWorkerPrivate);
 171   MOZ_ASSERT(aName);
 172
 173   RefPtr<StrongWorkerRef> ref = new StrongWorkerRef(aWorkerPrivate, aName);
 174   if (!ref->HoldWorker(aFailStatus)) {
 175     return nullptr;
 176   }
 177
 178   return ref.forget();
 179 }
 180
 181 StrongWorkerRef::StrongWorkerRef(WorkerPrivate* aWorkerPrivate,
 182                                  const char* aName)
 183     : WorkerRef(aWorkerPrivate, aName, true) {}
 184
 185 StrongWorkerRef::~StrongWorkerRef() = default;
 186
 187 WorkerPrivate* StrongWorkerRef::Private() const {
 188   NS_ASSERT_OWNINGTHREAD(StrongWorkerRef);
 189   return mWorkerPrivate;
 190 }
 191
 192 // ----------------------------------------------------------------------------
 193 // ThreadSafeWorkerRef
 194
 195 ThreadSafeWorkerRef::ThreadSafeWorkerRef(StrongWorkerRef* aRef) : mRef(aRef) {
 196   MOZ_ASSERT(aRef);
 197   aRef->Private()->AssertIsOnWorkerThread();
 198 }
 199
 200 ThreadSafeWorkerRef::~ThreadSafeWorkerRef() {
 201   // Let's release the StrongWorkerRef on the correct thread.
 202   if (!mRef->mWorkerPrivate->IsOnWorkerThread()) {
 203     WorkerPrivate* workerPrivate = mRef->mWorkerPrivate;
 204     RefPtr<ReleaseRefControlRunnable> r =
 205         new ReleaseRefControlRunnable(workerPrivate, mRef.forget());
 206     r->Dispatch();
 207     return;
 208   }
 209 }
 210
 211 WorkerPrivate* ThreadSafeWorkerRef::Private() const {
 212   return mRef->mWorkerPrivate;
 213 }
 214
 215 // ----------------------------------------------------------------------------
 216 // IPCWorkerRef
 217
 218 /* static */
 219 already_AddRefed<IPCWorkerRef> IPCWorkerRef::Create(
 220     WorkerPrivate* aWorkerPrivate, const char* aName,
 221     MoveOnlyFunction<void()>&& aCallback) {
 222   MOZ_ASSERT(aWorkerPrivate);
 223   aWorkerPrivate->AssertIsOnWorkerThread();
 224
 225   RefPtr<IPCWorkerRef> ref = new IPCWorkerRef(aWorkerPrivate, aName);
 226   if (!ref->HoldWorker(Canceling)) {
 227     return nullptr;
 228   }
 229
 230   ref->mCallback = std::move(aCallback);
 231
 232   return ref.forget();
 233 }
 234
 235 IPCWorkerRef::IPCWorkerRef(WorkerPrivate* aWorkerPrivate, const char* aName)
 236     : WorkerRef(aWorkerPrivate, aName, false) {}
 237
 238 IPCWorkerRef::~IPCWorkerRef() = default;
 239
 240 WorkerPrivate* IPCWorkerRef::Private() const {
 241   NS_ASSERT_OWNINGTHREAD(IPCWorkerRef);
 242   return mWorkerPrivate;
 243 }
 244
 245 }  // namespace mozilla::dom