/* -*- 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/cache/CacheStorageChild.h" #include "mozilla/Unused.h" #include "mozilla/dom/cache/CacheChild.h" #include "mozilla/dom/cache/CacheOpChild.h" #include "mozilla/dom/cache/CacheStorage.h" namespace mozilla { namespace dom { namespace cache { // declared in ActorUtils.h void DeallocPCacheStorageChild(PCacheStorageChild* aActor) { delete aActor; } CacheStorageChild::CacheStorageChild(CacheStorage* aListener, CacheWorkerHolder* aWorkerHolder) : mListener(aListener) , mNumChildActors(0) , mDelayedDestroy(false) { MOZ_COUNT_CTOR(cache::CacheStorageChild); MOZ_DIAGNOSTIC_ASSERT(mListener); SetWorkerHolder(aWorkerHolder); } CacheStorageChild::~CacheStorageChild() { MOZ_COUNT_DTOR(cache::CacheStorageChild); NS_ASSERT_OWNINGTHREAD(CacheStorageChild); MOZ_DIAGNOSTIC_ASSERT(!mListener); } void CacheStorageChild::ClearListener() { NS_ASSERT_OWNINGTHREAD(CacheStorageChild); MOZ_DIAGNOSTIC_ASSERT(mListener); mListener = nullptr; } void CacheStorageChild::ExecuteOp(nsIGlobalObject* aGlobal, Promise* aPromise, nsISupports* aParent, const CacheOpArgs& aArgs) { mNumChildActors += 1; Unused << SendPCacheOpConstructor( new CacheOpChild(GetWorkerHolder(), aGlobal, aParent, aPromise), aArgs); } void CacheStorageChild::StartDestroyFromListener() { NS_ASSERT_OWNINGTHREAD(CacheStorageChild); // The listener should be held alive by any async operations, so if it // is going away then there must not be any child actors. This in turn // ensures that StartDestroy() will not trigger the delayed path. MOZ_DIAGNOSTIC_ASSERT(!mNumChildActors); StartDestroy(); } void CacheStorageChild::StartDestroy() { NS_ASSERT_OWNINGTHREAD(CacheStorageChild); // If we have outstanding child actors, then don't destroy ourself yet. // The child actors should be short lived and we should allow them to complete // if possible. NoteDeletedActor() will call back into this Shutdown() // method when the last child actor is gone. if (mNumChildActors) { mDelayedDestroy = true; return; } RefPtr<CacheStorage> listener = mListener; // StartDestroy() can get called from either CacheStorage or the // CacheWorkerHolder. // Theoretically we can get double called if the right race happens. Handle // that by just ignoring the second StartDestroy() call. if (!listener) { return; } listener->DestroyInternal(this); // CacheStorage listener should call ClearListener() in DestroyInternal() MOZ_DIAGNOSTIC_ASSERT(!mListener); // Start actor destruction from parent process Unused << SendTeardown(); } void CacheStorageChild::ActorDestroy(ActorDestroyReason aReason) { NS_ASSERT_OWNINGTHREAD(CacheStorageChild); RefPtr<CacheStorage> listener = mListener; if (listener) { listener->DestroyInternal(this); // CacheStorage listener should call ClearListener() in DestroyInternal() MOZ_DIAGNOSTIC_ASSERT(!mListener); } RemoveWorkerHolder(); } PCacheOpChild* CacheStorageChild::AllocPCacheOpChild(const CacheOpArgs& aOpArgs) { MOZ_CRASH("CacheOpChild should be manually constructed."); return nullptr; } bool CacheStorageChild::DeallocPCacheOpChild(PCacheOpChild* aActor) { delete aActor; NoteDeletedActor(); return true; } void CacheStorageChild::NoteDeletedActor() { MOZ_DIAGNOSTIC_ASSERT(mNumChildActors); mNumChildActors -= 1; if (!mNumChildActors && mDelayedDestroy) { StartDestroy(); } } } // namespace cache } // namespace dom } // namespace mozilla