dom/cache/CacheWorkerRef.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/cache/CacheWorkerRef.h"
   8
   9 #include "mozilla/dom/cache/ActorChild.h"
  10 #include "mozilla/dom/WorkerPrivate.h"
  11 #include "mozilla/dom/WorkerRef.h"
  12
  13 namespace mozilla::dom::cache {
  14
  15 namespace {
  16 // XXX Move this to mfbt, or do we already have something like this? Or remove
  17 // the need for that by changing StrongWorkerRef/IPCWorkerRef?
  18
  19 template <class T>
  20 class FakeCopyable {
  21  public:
  22   explicit FakeCopyable(T&& aTarget) : mTarget(std::forward<T>(aTarget)) {}
  23
  24   FakeCopyable(FakeCopyable&&) = default;
  25
  26   FakeCopyable(const FakeCopyable& aOther)
  27       : mTarget(std::move(const_cast<FakeCopyable&>(aOther).mTarget)) {
  28     MOZ_CRASH("Do not copy.");
  29   }
  30
  31   template <typename... Args>
  32   auto operator()(Args&&... aArgs) {
  33     return mTarget(std::forward<Args>(aArgs)...);
  34   }
  35
  36  private:
  37   T mTarget;
  38 };
  39
  40 }  // namespace
  41
  42 // static
  43 SafeRefPtr<CacheWorkerRef> CacheWorkerRef::Create(WorkerPrivate* aWorkerPrivate,
  44                                                   Behavior aBehavior) {
  45   MOZ_DIAGNOSTIC_ASSERT(aWorkerPrivate);
  46
  47   // XXX This looks as if this could be simplified now by moving into the ctor
  48   // of CacheWorkerRef, since we can now use SafeRefPtrFromThis in the ctor
  49   auto workerRef =
  50       MakeSafeRefPtr<CacheWorkerRef>(aBehavior, ConstructorGuard{});
  51   auto notify =
  52       FakeCopyable([workerRef = workerRef.clonePtr()] { workerRef->Notify(); });
  53   if (aBehavior == eStrongWorkerRef) {
  54     workerRef->mStrongWorkerRef = StrongWorkerRef::Create(
  55         aWorkerPrivate, "CacheWorkerRef-Strong", std::move(notify));
  56   } else {
  57     MOZ_ASSERT(aBehavior == eIPCWorkerRef);
  58     workerRef->mIPCWorkerRef = IPCWorkerRef::Create(
  59         aWorkerPrivate, "CacheWorkerRef-IPC", std::move(notify));
  60   }
  61
  62   if (NS_WARN_IF(!workerRef->mIPCWorkerRef && !workerRef->mStrongWorkerRef)) {
  63     return nullptr;
  64   }
  65
  66   return workerRef;
  67 }
  68
  69 // static
  70 SafeRefPtr<CacheWorkerRef> CacheWorkerRef::PreferBehavior(
  71     SafeRefPtr<CacheWorkerRef> aCurrentRef, Behavior aBehavior) {
  72   if (!aCurrentRef) {
  73     return nullptr;
  74   }
  75
  76   SafeRefPtr<CacheWorkerRef> orig = std::move(aCurrentRef);
  77   if (orig->mBehavior == aBehavior) {
  78     return orig;
  79   }
  80
  81   WorkerPrivate* workerPrivate = nullptr;
  82   if (orig->mBehavior == eStrongWorkerRef) {
  83     workerPrivate = orig->mStrongWorkerRef->Private();
  84   } else {
  85     MOZ_ASSERT(orig->mBehavior == eIPCWorkerRef);
  86     workerPrivate = orig->mIPCWorkerRef->Private();
  87   }
  88
  89   MOZ_ASSERT(workerPrivate);
  90
  91   SafeRefPtr<CacheWorkerRef> replace = Create(workerPrivate, aBehavior);
  92   return static_cast<bool>(replace) ? std::move(replace) : std::move(orig);
  93 }
  94
  95 void CacheWorkerRef::AddActor(ActorChild& aActor) {
  96   NS_ASSERT_OWNINGTHREAD(CacheWorkerRef);
  97   MOZ_ASSERT(!mActorList.Contains(&aActor));
  98
  99   mActorList.AppendElement(WrapNotNullUnchecked(&aActor));
 100
 101   // Allow an actor to be added after we've entered the Notifying case.  We
 102   // can't stop the actor creation from racing with out destruction of the
 103   // other actors and we need to wait for this extra one to close as well.
 104   // Signal it should destroy itself right away.
 105   if (mNotified) {
 106     aActor.StartDestroy();
 107   }
 108 }
 109
 110 void CacheWorkerRef::RemoveActor(ActorChild& aActor) {
 111   NS_ASSERT_OWNINGTHREAD(CacheWorkerRef);
 112
 113 #if defined(RELEASE_OR_BETA)
 114   mActorList.RemoveElement(&aActor);
 115 #else
 116   MOZ_DIAGNOSTIC_ASSERT(mActorList.RemoveElement(&aActor));
 117 #endif
 118
 119   MOZ_ASSERT(!mActorList.Contains(&aActor));
 120
 121   if (mActorList.IsEmpty()) {
 122     mStrongWorkerRef = nullptr;
 123     mIPCWorkerRef = nullptr;
 124   }
 125 }
 126
 127 bool CacheWorkerRef::Notified() const { return mNotified; }
 128
 129 void CacheWorkerRef::Notify() {
 130   NS_ASSERT_OWNINGTHREAD(CacheWorkerRef);
 131
 132   mNotified = true;
 133
 134   // Start the asynchronous destruction of our actors.  These will call back
 135   // into RemoveActor() once the actor is destroyed.
 136   for (const auto& actor : mActorList) {
 137     actor->StartDestroy();
 138   }
 139 }
 140
 141 CacheWorkerRef::CacheWorkerRef(Behavior aBehavior, ConstructorGuard)
 142     : mBehavior(aBehavior), mNotified(false) {}
 143
 144 CacheWorkerRef::~CacheWorkerRef() {
 145   NS_ASSERT_OWNINGTHREAD(CacheWorkerRef);
 146   MOZ_DIAGNOSTIC_ASSERT(mActorList.IsEmpty());
 147 }
 148
 149 }  // namespace mozilla::dom::cache