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