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