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

#include "ClientHandleParent.h"
#include "ClientSourceParent.h"
#include "mozilla/dom/PClientManagerParent.h"

namespace mozilla {
namespace dom {

ClientSourceParent*
ClientHandleOpParent::GetSource() const
{
  auto handle = static_cast<ClientHandleParent*>(Manager());
  return handle->GetSource();
}

void
ClientHandleOpParent::ActorDestroy(ActorDestroyReason aReason)
{
  mPromiseRequestHolder.DisconnectIfExists();
}

void
ClientHandleOpParent::Init(const ClientOpConstructorArgs& aArgs)
{
  ClientSourceParent* source = GetSource();
  if (!source) {
    Unused << PClientHandleOpParent::Send__delete__(this, NS_ERROR_DOM_ABORT_ERR);
    return;
  }

  RefPtr<ClientOpPromise> p;

  // ClientPostMessageArgs can contain PBlob actors.  This means we
  // can't just forward the args from one PBackground manager to
  // another.  Instead, unpack the structured clone data and repack
  // it into a new set of arguments.
  if (aArgs.type() == ClientOpConstructorArgs::TClientPostMessageArgs) {
    const ClientPostMessageArgs& orig = aArgs.get_ClientPostMessageArgs();

    ClientPostMessageArgs rebuild;
    rebuild.serviceWorker() = orig.serviceWorker();

    StructuredCloneData data;
    data.BorrowFromClonedMessageDataForBackgroundParent(orig.clonedData());
    if (!data.BuildClonedMessageDataForBackgroundParent(source->Manager()->Manager(),
                                                        rebuild.clonedData())) {
      Unused << PClientHandleOpParent::Send__delete__(this, NS_ERROR_DOM_ABORT_ERR);
      return;
    }

    p = source->StartOp(rebuild);
  }

  // Other argument types can just be forwarded straight through.
  else {
    p = source->StartOp(aArgs);
  }

  // Capturing 'this' is safe here because we disconnect the promise in
  // ActorDestroy() which ensures neither lambda is called if the actor
  // is destroyed before the source operation completes.
  p->Then(GetCurrentThreadSerialEventTarget(), __func__,
    [this] (const ClientOpResult& aResult) {
      mPromiseRequestHolder.Complete();
      Unused << PClientHandleOpParent::Send__delete__(this, aResult);
    },
    [this] (nsresult aRv) {
      mPromiseRequestHolder.Complete();
      Unused << PClientHandleOpParent::Send__delete__(this, aRv);
    })->Track(mPromiseRequestHolder);
}

} // namespace dom
} // namespace mozilla