/* -*- 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