tor-browser

WorkerRef.cpp (7388B)

---

/* -*- 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 "mozilla/dom/WorkerRef.h"

#include "WorkerPrivate.h"
#include "WorkerRunnable.h"
#include "nsDebug.h"

namespace mozilla::dom {

namespace {

// This runnable is used to release the StrongWorkerRef on the worker thread
// when a ThreadSafeWorkerRef is released.
class ReleaseRefControlRunnable final : public WorkerControlRunnable {
public:
 ReleaseRefControlRunnable(WorkerPrivate* aWorkerPrivate,
                           already_AddRefed<StrongWorkerRef> aRef)
     : WorkerControlRunnable("ReleaseRefControlRunnable"),
       mRef(std::move(aRef)) {
   MOZ_ASSERT(mRef);
 }

 bool PreDispatch(WorkerPrivate* aWorkerPrivate) override { return true; }

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

 bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override {
   mRef = nullptr;
   return true;
 }

private:
 RefPtr<StrongWorkerRef> mRef;
};

}  // namespace

// ----------------------------------------------------------------------------
// WorkerRef

WorkerRef::WorkerRef(WorkerPrivate* aWorkerPrivate, const char* aName,
                    bool aIsPreventingShutdown)
   :
#ifdef DEBUG
     mDebugMutex("WorkerRef"),
#endif
     mWorkerPrivate(aWorkerPrivate),
     mName(aName),
     mIsPreventingShutdown(aIsPreventingShutdown),
     mHolding(false) {
 MOZ_ASSERT(aWorkerPrivate);
 MOZ_ASSERT(aName);

 aWorkerPrivate->AssertIsOnWorkerThread();
}

WorkerRef::~WorkerRef() {
 NS_ASSERT_OWNINGTHREAD(WorkerRef);
 ReleaseWorker();
}

void WorkerRef::ReleaseWorker() {
 if (mHolding) {
   MOZ_ASSERT(mWorkerPrivate);

   if (mIsPreventingShutdown) {
     mWorkerPrivate->AssertIsNotPotentiallyLastGCCCRunning();
   }
   mWorkerPrivate->RemoveWorkerRef(this);
   mWorkerPrivate = nullptr;

   mHolding = false;
 }
}

bool WorkerRef::HoldWorker(WorkerStatus aStatus) {
 MOZ_ASSERT(mWorkerPrivate);
 MOZ_ASSERT(!mHolding);

 if (NS_WARN_IF(!mWorkerPrivate->AddWorkerRef(this, aStatus))) {
   return false;
 }

 mHolding = true;
 return true;
}

void WorkerRef::Notify() {
 NS_ASSERT_OWNINGTHREAD(WorkerRef);

 if (!mCallback) {
   return;
 }

 MoveOnlyFunction<void()> callback = std::move(mCallback);
 MOZ_ASSERT(!mCallback);

 callback();
}

// ----------------------------------------------------------------------------
// WeakWorkerRef

/* static */
already_AddRefed<WeakWorkerRef> WeakWorkerRef::Create(
   WorkerPrivate* aWorkerPrivate, MoveOnlyFunction<void()>&& aCallback) {
 MOZ_ASSERT(aWorkerPrivate);
 aWorkerPrivate->AssertIsOnWorkerThread();

 RefPtr<WeakWorkerRef> ref = new WeakWorkerRef(aWorkerPrivate);
 if (!ref->HoldWorker(Canceling)) {
   return nullptr;
 }

 ref->mCallback = std::move(aCallback);

 return ref.forget();
}

WeakWorkerRef::WeakWorkerRef(WorkerPrivate* aWorkerPrivate)
   : WorkerRef(aWorkerPrivate, "WeakWorkerRef", false) {}

WeakWorkerRef::~WeakWorkerRef() = default;

void WeakWorkerRef::Notify() {
 MOZ_ASSERT(mHolding);
 MOZ_ASSERT(mWorkerPrivate);

 // Notify could drop the last reference to this object. We must keep it alive
 // in order to call ReleaseWorker() immediately after.
 RefPtr<WeakWorkerRef> kungFuGrip = this;

 WorkerRef::Notify();
 ReleaseWorker();
}

WorkerPrivate* WeakWorkerRef::GetPrivate() const {
 NS_ASSERT_OWNINGTHREAD(WeakWorkerRef);
 return mWorkerPrivate;
}

WorkerPrivate* WeakWorkerRef::GetUnsafePrivate() const {
 return mWorkerPrivate;
}

// ----------------------------------------------------------------------------
// StrongWorkerRef

/* static */
already_AddRefed<StrongWorkerRef> StrongWorkerRef::Create(
   WorkerPrivate* const aWorkerPrivate, const char* const aName,
   MoveOnlyFunction<void()>&& aCallback) {
 if (RefPtr<StrongWorkerRef> ref =
         CreateImpl(aWorkerPrivate, aName, Canceling)) {
   ref->mCallback = std::move(aCallback);
   return ref.forget();
 }
 return nullptr;
}

/* static */
already_AddRefed<StrongWorkerRef> StrongWorkerRef::CreateForcibly(
   WorkerPrivate* const aWorkerPrivate, const char* const aName) {
 return CreateImpl(aWorkerPrivate, aName, Killing);
}

/* static */
already_AddRefed<StrongWorkerRef> StrongWorkerRef::CreateImpl(
   WorkerPrivate* const aWorkerPrivate, const char* const aName,
   WorkerStatus const aFailStatus) {
 MOZ_ASSERT(aWorkerPrivate);
 MOZ_ASSERT(aName);

 RefPtr<StrongWorkerRef> ref = new StrongWorkerRef(aWorkerPrivate, aName);
 if (!ref->HoldWorker(aFailStatus)) {
   return nullptr;
 }

 return ref.forget();
}

StrongWorkerRef::StrongWorkerRef(WorkerPrivate* aWorkerPrivate,
                                const char* aName)
   : WorkerRef(aWorkerPrivate, aName, true) {}

StrongWorkerRef::~StrongWorkerRef() = default;

WorkerPrivate* StrongWorkerRef::Private() const {
 NS_ASSERT_OWNINGTHREAD(StrongWorkerRef);
 return mWorkerPrivate;
}

// ----------------------------------------------------------------------------
// ThreadSafeWorkerRef

ThreadSafeWorkerRef::ThreadSafeWorkerRef(StrongWorkerRef* aRef) : mRef(aRef) {
 MOZ_ASSERT(aRef);
 aRef->Private()->AssertIsOnWorkerThread();
}

ThreadSafeWorkerRef::~ThreadSafeWorkerRef() {
 // Let's release the StrongWorkerRef on the correct thread.
 if (!mRef->mWorkerPrivate->IsOnWorkerThread()) {
   WorkerPrivate* workerPrivate = mRef->mWorkerPrivate;
   RefPtr<ReleaseRefControlRunnable> r =
       new ReleaseRefControlRunnable(workerPrivate, mRef.forget());
   r->Dispatch(workerPrivate);
   return;
 }
}

WorkerPrivate* ThreadSafeWorkerRef::Private() const {
 return mRef->mWorkerPrivate;
}

// ----------------------------------------------------------------------------
// IPCWorkerRef

/* static */
already_AddRefed<IPCWorkerRef> IPCWorkerRef::Create(
   WorkerPrivate* aWorkerPrivate, const char* aName,
   MoveOnlyFunction<void()>&& aCallback) {
 MOZ_ASSERT(aWorkerPrivate);
 aWorkerPrivate->AssertIsOnWorkerThread();

 RefPtr<IPCWorkerRef> ref = new IPCWorkerRef(aWorkerPrivate, aName);
 if (!ref->HoldWorker(Canceling)) {
   return nullptr;
 }
 ref->SetActorCount(1);
 ref->mCallback = std::move(aCallback);

 return ref.forget();
}

IPCWorkerRef::IPCWorkerRef(WorkerPrivate* aWorkerPrivate, const char* aName)
   : WorkerRef(aWorkerPrivate, aName, false), mActorCount(0) {}

IPCWorkerRef::~IPCWorkerRef() {
 NS_ASSERT_OWNINGTHREAD(IPCWorkerRef);
 // explicit type convertion to avoid undefined behavior of uint32_t overflow.
 mWorkerPrivate->AdjustNonblockingCCBackgroundActorCount(
     (int32_t)-mActorCount);
 ReleaseWorker();
};

WorkerPrivate* IPCWorkerRef::Private() const {
 NS_ASSERT_OWNINGTHREAD(IPCWorkerRef);
 return mWorkerPrivate;
}

void IPCWorkerRef::SetActorCount(uint32_t aCount) {
 NS_ASSERT_OWNINGTHREAD(IPCWorkerRef);
 // explicit type convertion to avoid undefined behavior of uint32_t overflow.
 mWorkerPrivate->AdjustNonblockingCCBackgroundActorCount((int32_t)aCount -
                                                         (int32_t)mActorCount);
 mActorCount = aCount;
}

}  // namespace mozilla::dom