dom/clients/manager/ClientHandle.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "ClientHandle.h"
   8
   9 #include "ClientHandleChild.h"
  10 #include "ClientHandleOpChild.h"
  11 #include "ClientManager.h"
  12 #include "ClientPrincipalUtils.h"
  13 #include "ClientState.h"
  14 #include "mozilla/dom/PClientManagerChild.h"
  15 #include "mozilla/dom/ServiceWorkerDescriptor.h"
  16 #include "mozilla/dom/ipc/StructuredCloneData.h"
  17
  18 namespace mozilla::dom {
  19
  20 using mozilla::dom::ipc::StructuredCloneData;
  21
  22 ClientHandle::~ClientHandle() { Shutdown(); }
  23
  24 void ClientHandle::Shutdown() {
  25   NS_ASSERT_OWNINGTHREAD(ClientSource);
  26   if (IsShutdown()) {
  27     return;
  28   }
  29
  30   ShutdownThing();
  31
  32   mManager = nullptr;
  33 }
  34
  35 void ClientHandle::StartOp(const ClientOpConstructorArgs& aArgs,
  36                            const ClientOpCallback&& aResolveCallback,
  37                            const ClientOpCallback&& aRejectCallback) {
  38   // Hold a ref to the client until the remote operation completes.  Otherwise
  39   // the ClientHandle might get de-refed and teardown the actor before we
  40   // get an answer.
  41   RefPtr<ClientHandle> kungFuGrip = this;
  42
  43   MaybeExecute(
  44       [&aArgs, kungFuGrip, aRejectCallback,
  45        resolve = std::move(aResolveCallback)](ClientHandleChild* aActor) {
  46         MOZ_DIAGNOSTIC_ASSERT(aActor);
  47         ClientHandleOpChild* actor = new ClientHandleOpChild(
  48             kungFuGrip, aArgs, std::move(resolve), std::move(aRejectCallback));
  49         if (!aActor->SendPClientHandleOpConstructor(actor, aArgs)) {
  50           // Constructor failure will call reject callback via ActorDestroy()
  51           return;
  52         }
  53       },
  54       [aRejectCallback] {
  55         MOZ_DIAGNOSTIC_ASSERT(aRejectCallback);
  56         CopyableErrorResult rv;
  57         rv.ThrowInvalidStateError("Client has been destroyed");
  58         aRejectCallback(rv);
  59       });
  60 }
  61
  62 void ClientHandle::OnShutdownThing() {
  63   NS_ASSERT_OWNINGTHREAD(ClientHandle);
  64   if (!mDetachPromise) {
  65     return;
  66   }
  67   mDetachPromise->Resolve(true, __func__);
  68 }
  69
  70 ClientHandle::ClientHandle(ClientManager* aManager,
  71                            nsISerialEventTarget* aSerialEventTarget,
  72                            const ClientInfo& aClientInfo)
  73     : mManager(aManager),
  74       mSerialEventTarget(aSerialEventTarget),
  75       mClientInfo(aClientInfo) {
  76   MOZ_DIAGNOSTIC_ASSERT(mManager);
  77   MOZ_DIAGNOSTIC_ASSERT(mSerialEventTarget);
  78   MOZ_ASSERT(mSerialEventTarget->IsOnCurrentThread());
  79 }
  80
  81 void ClientHandle::Activate(PClientManagerChild* aActor) {
  82   NS_ASSERT_OWNINGTHREAD(ClientHandle);
  83
  84   if (IsShutdown()) {
  85     return;
  86   }
  87
  88   PClientHandleChild* actor =
  89       aActor->SendPClientHandleConstructor(mClientInfo.ToIPC());
  90   if (!actor) {
  91     Shutdown();
  92     return;
  93   }
  94
  95   ActivateThing(static_cast<ClientHandleChild*>(actor));
  96 }
  97
  98 void ClientHandle::ExecutionReady(const ClientInfo& aClientInfo) {
  99   mClientInfo = aClientInfo;
 100 }
 101
 102 const ClientInfo& ClientHandle::Info() const { return mClientInfo; }
 103
 104 RefPtr<GenericErrorResultPromise> ClientHandle::Control(
 105     const ServiceWorkerDescriptor& aServiceWorker) {
 106   RefPtr<GenericErrorResultPromise::Private> outerPromise =
 107       new GenericErrorResultPromise::Private(__func__);
 108
 109   // We should never have a cross-origin controller.  Since this would be
 110   // same-origin policy violation we do a full release assertion here.
 111   MOZ_RELEASE_ASSERT(ClientMatchPrincipalInfo(mClientInfo.PrincipalInfo(),
 112                                               aServiceWorker.PrincipalInfo()));
 113
 114   StartOp(
 115       ClientControlledArgs(aServiceWorker.ToIPC()),
 116       [outerPromise](const ClientOpResult& aResult) {
 117         outerPromise->Resolve(true, __func__);
 118       },
 119       [outerPromise](const ClientOpResult& aResult) {
 120         outerPromise->Reject(aResult.get_CopyableErrorResult(), __func__);
 121       });
 122
 123   return outerPromise;
 124 }
 125
 126 RefPtr<ClientStatePromise> ClientHandle::Focus(CallerType aCallerType) {
 127   RefPtr<ClientStatePromise::Private> outerPromise =
 128       new ClientStatePromise::Private(__func__);
 129
 130   StartOp(
 131       ClientFocusArgs(aCallerType),
 132       [outerPromise](const ClientOpResult& aResult) {
 133         outerPromise->Resolve(
 134             ClientState::FromIPC(aResult.get_IPCClientState()), __func__);
 135       },
 136       [outerPromise](const ClientOpResult& aResult) {
 137         outerPromise->Reject(aResult.get_CopyableErrorResult(), __func__);
 138       });
 139
 140   return outerPromise;
 141 }
 142
 143 RefPtr<GenericErrorResultPromise> ClientHandle::PostMessage(
 144     StructuredCloneData& aData, const ServiceWorkerDescriptor& aSource) {
 145   if (IsShutdown()) {
 146     CopyableErrorResult rv;
 147     rv.ThrowInvalidStateError("Client has been destroyed");
 148     return GenericErrorResultPromise::CreateAndReject(rv, __func__);
 149   }
 150
 151   ClientPostMessageArgs args;
 152   args.serviceWorker() = aSource.ToIPC();
 153
 154   if (!aData.BuildClonedMessageData(args.clonedData())) {
 155     CopyableErrorResult rv;
 156     rv.ThrowInvalidStateError("Failed to clone data");
 157     return GenericErrorResultPromise::CreateAndReject(rv, __func__);
 158   }
 159
 160   RefPtr<GenericErrorResultPromise::Private> outerPromise =
 161       new GenericErrorResultPromise::Private(__func__);
 162
 163   StartOp(
 164       std::move(args),
 165       [outerPromise](const ClientOpResult& aResult) {
 166         outerPromise->Resolve(true, __func__);
 167       },
 168       [outerPromise](const ClientOpResult& aResult) {
 169         outerPromise->Reject(aResult.get_CopyableErrorResult(), __func__);
 170       });
 171
 172   return outerPromise;
 173 }
 174
 175 RefPtr<GenericPromise> ClientHandle::OnDetach() {
 176   NS_ASSERT_OWNINGTHREAD(ClientSource);
 177
 178   if (!mDetachPromise) {
 179     mDetachPromise = new GenericPromise::Private(__func__);
 180     if (IsShutdown()) {
 181       mDetachPromise->Resolve(true, __func__);
 182     }
 183   }
 184
 185   return mDetachPromise;
 186 }
 187
 188 void ClientHandle::EvictFromBFCache() {
 189   ClientEvictBFCacheArgs args;
 190   StartOp(
 191       std::move(args), [](const ClientOpResult& aResult) {},
 192       [](const ClientOpResult& aResult) {});
 193 }
 194
 195 }  // namespace mozilla::dom