/* -*- 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/CacheChild.h"

#include "mozilla/Unused.h"

#include "mozilla/dom/cache/ActorUtils.h"

#include "mozilla/dom/cache/Cache.h"

#include "mozilla/dom/cache/CacheOpChild.h"

namespace mozilla {

namespace dom {

namespace cache {

// Declared in ActorUtils.h

PCacheChild*

AllocPCacheChild()

{

  return new CacheChild();

}

// Declared in ActorUtils.h

void

DeallocPCacheChild(PCacheChild* aActor)

{

  delete aActor;

}

CacheChild::CacheChild()

  : mListener(nullptr)

  , mNumChildActors(0)

  , mDelayedDestroy(false)

  , mLocked(false)

{

  MOZ_COUNT_CTOR(cache::CacheChild);

}

CacheChild::~CacheChild()

{

  MOZ_COUNT_DTOR(cache::CacheChild);

  NS_ASSERT_OWNINGTHREAD(CacheChild);

  MOZ_DIAGNOSTIC_ASSERT(!mListener);

  MOZ_DIAGNOSTIC_ASSERT(!mNumChildActors);

  MOZ_DIAGNOSTIC_ASSERT(!mLocked);

}

void

CacheChild::SetListener(Cache* aListener)

{

  NS_ASSERT_OWNINGTHREAD(CacheChild);

  MOZ_DIAGNOSTIC_ASSERT(!mListener);

  mListener = aListener;

  MOZ_DIAGNOSTIC_ASSERT(mListener);

}

void

CacheChild::ClearListener()

{

  NS_ASSERT_OWNINGTHREAD(CacheChild);

  MOZ_DIAGNOSTIC_ASSERT(mListener);

  mListener = nullptr;

}

void

CacheChild::ExecuteOp(nsIGlobalObject* aGlobal, Promise* aPromise,

                      nsISupports* aParent, const CacheOpArgs& aArgs)

{

  mNumChildActors += 1;

  MOZ_ALWAYS_TRUE(SendPCacheOpConstructor(

    new CacheOpChild(GetWorkerHolder(), aGlobal, aParent, aPromise), aArgs));

}

void

CacheChild::StartDestroyFromListener()

{

  NS_ASSERT_OWNINGTHREAD(CacheChild);

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

CacheChild::StartDestroy()

{

  NS_ASSERT_OWNINGTHREAD(CacheChild);

  // 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.  Also, delay destruction if we

  // have been explicitly locked by someone using us on the stack.

  if (mNumChildActors || mLocked) {

    mDelayedDestroy = true;

    return;

  }

  RefPtr<Cache> listener = mListener;

  // StartDestroy() can get called from either Cache or the WorkerHolder.

  // 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);

  // Cache listener should call ClearListener() in DestroyInternal()

  MOZ_DIAGNOSTIC_ASSERT(!mListener);

  // Start actor destruction from parent process

  Unused << SendTeardown();

}

void

CacheChild::ActorDestroy(ActorDestroyReason aReason)

{

  NS_ASSERT_OWNINGTHREAD(CacheChild);

  RefPtr<Cache> listener = mListener;

  if (listener) {

    listener->DestroyInternal(this);

    // Cache listener should call ClearListener() in DestroyInternal()

    MOZ_DIAGNOSTIC_ASSERT(!mListener);

  }

  RemoveWorkerHolder();

}

PCacheOpChild*

CacheChild::AllocPCacheOpChild(const CacheOpArgs& aOpArgs)

{

  MOZ_CRASH("CacheOpChild should be manually constructed.");

  return nullptr;

}

bool

CacheChild::DeallocPCacheOpChild(PCacheOpChild* aActor)

{

  delete aActor;

  NoteDeletedActor();

  return true;

}

void

CacheChild::NoteDeletedActor()

{

  mNumChildActors -= 1;

  MaybeFlushDelayedDestroy();

}

void

CacheChild::MaybeFlushDelayedDestroy()

{

  if (!mNumChildActors && !mLocked && mDelayedDestroy) {

    StartDestroy();

  }

}

void

CacheChild::Lock()

{

  NS_ASSERT_OWNINGTHREAD(CacheChild);

  MOZ_DIAGNOSTIC_ASSERT(!mLocked);

  mLocked = true;

}

void

CacheChild::Unlock()

{

  NS_ASSERT_OWNINGTHREAD(CacheChild);

  MOZ_DIAGNOSTIC_ASSERT(mLocked);

  mLocked = false;

  MaybeFlushDelayedDestroy();

}

} // namespace cache

} // namespace dom

} // namespace mozilla