Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


Quellcodebibliothek Statistik Leitseite products/sources/formale Sprachen/GAP/pkg/modules/doc/ (Browser von der Mozilla Stiftung Version 136.0.1^©) Datei vom 22.11.2024 mit Größe 9 kB

Quelle WorkerRef.cpp Sprache: C

/* -*- 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 "nsDebug.h"
#include "WorkerRunnable.h"
#include "WorkerPrivate.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

quality100%

¤ Dauer der Verarbeitung: 0.17 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.