dom/cache/CacheChild.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/CacheChild.h"
   8
   9 #include "mozilla/Unused.h"
  10 #include "mozilla/dom/cache/ActorUtils.h"
  11 #include "mozilla/dom/cache/Cache.h"
  12 #include "mozilla/dom/cache/CacheOpChild.h"
  13 #include "CacheWorkerRef.h"
  14
  15 namespace mozilla::dom::cache {
  16
  17 // Declared in ActorUtils.h
  18 already_AddRefed<PCacheChild> AllocPCacheChild() {
  19   return MakeAndAddRef<CacheChild>();
  20 }
  21
  22 // Declared in ActorUtils.h
  23 void DeallocPCacheChild(PCacheChild* aActor) { delete aActor; }
  24
  25 CacheChild::CacheChild()
  26     : mListener(nullptr), mLocked(false), mDelayedDestroy(false) {
  27   MOZ_COUNT_CTOR(cache::CacheChild);
  28 }
  29
  30 CacheChild::~CacheChild() {
  31   MOZ_COUNT_DTOR(cache::CacheChild);
  32   NS_ASSERT_OWNINGTHREAD(CacheChild);
  33   MOZ_DIAGNOSTIC_ASSERT(!mListener);
  34   MOZ_DIAGNOSTIC_ASSERT(!mLocked);
  35 }
  36
  37 void CacheChild::SetListener(Cache* aListener) {
  38   NS_ASSERT_OWNINGTHREAD(CacheChild);
  39   MOZ_DIAGNOSTIC_ASSERT(!mListener);
  40   mListener = aListener;
  41   MOZ_DIAGNOSTIC_ASSERT(mListener);
  42 }
  43
  44 void CacheChild::ClearListener() {
  45   NS_ASSERT_OWNINGTHREAD(CacheChild);
  46   MOZ_DIAGNOSTIC_ASSERT(mListener);
  47   mListener = nullptr;
  48 }
  49
  50 void CacheChild::ExecuteOp(nsIGlobalObject* aGlobal, Promise* aPromise,
  51                            nsISupports* aParent, const CacheOpArgs& aArgs) {
  52   MOZ_ALWAYS_TRUE(SendPCacheOpConstructor(
  53       new CacheOpChild(GetWorkerRefPtr().clonePtr(), aGlobal, aParent, aPromise,
  54                        this),
  55       aArgs));
  56 }
  57
  58 void CacheChild::StartDestroyFromListener() {
  59   NS_ASSERT_OWNINGTHREAD(CacheChild);
  60
  61   // The listener should be held alive by any async operations, so if it
  62   // is going away then there must not be any child actors.  This in turn
  63   // ensures that StartDestroy() will not trigger the delayed path.
  64   MOZ_DIAGNOSTIC_ASSERT(NumChildActors() == 0);
  65   StartDestroy();
  66 }
  67
  68 void CacheChild::DestroyInternal() {
  69   RefPtr<Cache> listener = mListener;
  70
  71   // StartDestroy() can get called from either Cache or the WorkerRef.
  72   // Theoretically we can get double called if the right race happens.  Handle
  73   // that by just ignoring the second StartDestroy() call.
  74   if (!listener) {
  75     return;
  76   }
  77
  78   listener->DestroyInternal(this);
  79
  80   // Cache listener should call ClearListener() in DestroyInternal()
  81   MOZ_DIAGNOSTIC_ASSERT(!mListener);
  82
  83   // Start actor destruction from parent process
  84   QM_WARNONLY_TRY(OkIf(SendTeardown()));
  85 }
  86
  87 void CacheChild::StartDestroy() {
  88   NS_ASSERT_OWNINGTHREAD(CacheChild);
  89
  90   if (NumChildActors() != 0 || mLocked) {
  91     mDelayedDestroy = true;
  92     return;
  93   }
  94
  95   DestroyInternal();
  96 }
  97
  98 void CacheChild::ActorDestroy(ActorDestroyReason aReason) {
  99   NS_ASSERT_OWNINGTHREAD(CacheChild);
 100   RefPtr<Cache> listener = mListener;
 101   if (listener) {
 102     listener->DestroyInternal(this);
 103     // Cache listener should call ClearListener() in DestroyInternal()
 104     MOZ_DIAGNOSTIC_ASSERT(!mListener);
 105   }
 106
 107   RemoveWorkerRef();
 108 }
 109
 110 void CacheChild::NoteDeletedActor() {
 111   // Check to see if DestroyInternal was delayed because there were still active
 112   // CacheOpChilds when StartDestroy was called from WorkerRef notification. If
 113   // the last CacheOpChild is getting destructed; it's the time for us to
 114   // SendTearDown to the other side.
 115   if (NumChildActors() == 1 && mDelayedDestroy && !mLocked) DestroyInternal();
 116 }
 117
 118 already_AddRefed<PCacheOpChild> CacheChild::AllocPCacheOpChild(
 119     const CacheOpArgs& aOpArgs) {
 120   MOZ_CRASH("CacheOpChild should be manually constructed.");
 121   return nullptr;
 122 }
 123
 124 void CacheChild::Lock() {
 125   NS_ASSERT_OWNINGTHREAD(CacheChild);
 126   MOZ_DIAGNOSTIC_ASSERT(!mLocked);
 127   mLocked = true;
 128 }
 129
 130 void CacheChild::Unlock() {
 131   NS_ASSERT_OWNINGTHREAD(CacheChild);
 132   MOZ_DIAGNOSTIC_ASSERT(mLocked);
 133   mLocked = false;
 134 }
 135
 136 }  // namespace mozilla::dom::cache