gecko-dev/dom/clients/manager/ClientHandle.cpp

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

#include "ClientHandleChild.h"
#include "ClientHandleOpChild.h"
#include "ClientManager.h"
#include "ClientPrincipalUtils.h"
#include "ClientState.h"
#include "mozilla/dom/PClientManagerChild.h"
#include "mozilla/dom/ServiceWorkerDescriptor.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"

namespace mozilla {
namespace dom {

using mozilla::dom::ipc::StructuredCloneData;

ClientHandle::~ClientHandle()
{
  Shutdown();
}

void
ClientHandle::Shutdown()
{
  NS_ASSERT_OWNINGTHREAD(ClientSource);
  if (IsShutdown()) {
    return;
  }

  ShutdownThing();

  mManager = nullptr;
}

void
ClientHandle::StartOp(const ClientOpConstructorArgs& aArgs,
                      const ClientOpCallback&& aResolveCallback,
                      const ClientOpCallback&& aRejectCallback)
{
  // Hold a ref to the client until the remote operation completes.  Otherwise
  // the ClientHandle might get de-refed and teardown the actor before we
  // get an answer.
  RefPtr<ClientHandle> kungFuGrip = this;

  MaybeExecute([aArgs, kungFuGrip, aRejectCallback,
                resolve = std::move(aResolveCallback)] (ClientHandleChild* aActor) {
    MOZ_DIAGNOSTIC_ASSERT(aActor);
    ClientHandleOpChild* actor =
      new ClientHandleOpChild(kungFuGrip, aArgs, std::move(resolve),
                              std::move(aRejectCallback));
    if (!aActor->SendPClientHandleOpConstructor(actor, aArgs)) {
      // Constructor failure will call reject callback via ActorDestroy()
      return;
    }
  }, [aRejectCallback] {
    MOZ_DIAGNOSTIC_ASSERT(aRejectCallback);
    aRejectCallback(NS_ERROR_DOM_INVALID_STATE_ERR);
  });
}

void
ClientHandle::OnShutdownThing()
{
  NS_ASSERT_OWNINGTHREAD(ClientHandle);
  if (!mDetachPromise) {
    return;
  }
  mDetachPromise->Resolve(true, __func__);
}

ClientHandle::ClientHandle(ClientManager* aManager,
                           nsISerialEventTarget* aSerialEventTarget,
                           const ClientInfo& aClientInfo)
  : mManager(aManager)
  , mSerialEventTarget(aSerialEventTarget)
  , mClientInfo(aClientInfo)
{
  MOZ_DIAGNOSTIC_ASSERT(mManager);
  MOZ_DIAGNOSTIC_ASSERT(mSerialEventTarget);
  MOZ_ASSERT(mSerialEventTarget->IsOnCurrentThread());
}

void
ClientHandle::Activate(PClientManagerChild* aActor)
{
  NS_ASSERT_OWNINGTHREAD(ClientHandle);

  if (IsShutdown()) {
    return;
  }

  PClientHandleChild* actor =
    aActor->SendPClientHandleConstructor(mClientInfo.ToIPC());
  if (!actor) {
    Shutdown();
    return;
  }

  ActivateThing(static_cast<ClientHandleChild*>(actor));
}

void
ClientHandle::ExecutionReady(const ClientInfo& aClientInfo)
{
  mClientInfo = aClientInfo;
}

const ClientInfo&
ClientHandle::Info() const
{
  return mClientInfo;
}

RefPtr<GenericPromise>
ClientHandle::Control(const ServiceWorkerDescriptor& aServiceWorker)
{
  RefPtr<GenericPromise::Private> outerPromise =
    new GenericPromise::Private(__func__);

  // We should never have a cross-origin controller.  Since this would be
  // same-origin policy violation we do a full release assertion here.
  MOZ_RELEASE_ASSERT(ClientMatchPrincipalInfo(mClientInfo.PrincipalInfo(),
                                              aServiceWorker.PrincipalInfo()));

  StartOp(ClientControlledArgs(aServiceWorker.ToIPC()),
    [outerPromise](const ClientOpResult& aResult) {
      outerPromise->Resolve(true, __func__);
    },
    [outerPromise](const ClientOpResult& aResult) {
      outerPromise->Reject(aResult.get_nsresult(), __func__);
    });

  return outerPromise.forget();
}

RefPtr<ClientStatePromise>
ClientHandle::Focus()
{
  RefPtr<ClientStatePromise::Private> outerPromise =
    new ClientStatePromise::Private(__func__);

  StartOp(ClientFocusArgs(),
    [outerPromise](const ClientOpResult& aResult) {
      outerPromise->Resolve(ClientState::FromIPC(aResult.get_IPCClientState()), __func__);
    }, [outerPromise](const ClientOpResult& aResult) {
      outerPromise->Reject(aResult.get_nsresult(), __func__);
    });

  RefPtr<ClientStatePromise> ref = outerPromise.get();
  return ref.forget();
}

RefPtr<GenericPromise>
ClientHandle::PostMessage(StructuredCloneData& aData,
                          const ServiceWorkerDescriptor& aSource)
{
  RefPtr<GenericPromise> ref;

  if (IsShutdown()) {
    ref = GenericPromise::CreateAndReject(NS_ERROR_DOM_INVALID_STATE_ERR, __func__);
    return ref.forget();
  }

  ClientPostMessageArgs args;
  args.serviceWorker() = aSource.ToIPC();

  if (!aData.BuildClonedMessageDataForBackgroundChild(GetActor()->Manager()->Manager(),
                                                      args.clonedData())) {
    ref = GenericPromise::CreateAndReject(NS_ERROR_DOM_INVALID_STATE_ERR, __func__);
    return ref.forget();
  }

  RefPtr<GenericPromise::Private> outerPromise =
    new GenericPromise::Private(__func__);

  StartOp(args,
    [outerPromise](const ClientOpResult& aResult) {
      outerPromise->Resolve(true, __func__);
    }, [outerPromise](const ClientOpResult& aResult) {
      outerPromise->Reject(aResult.get_nsresult(), __func__);
    });

  ref = outerPromise.get();
  return ref.forget();
}

RefPtr<GenericPromise>
ClientHandle::OnDetach()
{
  NS_ASSERT_OWNINGTHREAD(ClientSource);

  if (!mDetachPromise) {
    mDetachPromise = new GenericPromise::Private(__func__);
    if (IsShutdown()) {
      mDetachPromise->Resolve(true, __func__);
    }
  }

  RefPtr<GenericPromise> ref(mDetachPromise);
  return std::move(ref);
}

} // namespace dom
} // namespace mozilla