dom/clients/manager/ClientSource.h

   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 #ifndef _mozilla_dom_ClientSource_h
   7 #define _mozilla_dom_ClientSource_h
   8
   9 #include "mozilla/dom/ClientInfo.h"
  10 #include "mozilla/dom/ClientOpPromise.h"
  11 #include "mozilla/dom/ClientThing.h"
  12 #include "mozilla/dom/ServiceWorkerDescriptor.h"
  13 #include "mozilla/ResultVariant.h"
  14 #include "mozilla/Variant.h"
  15
  16 #ifdef XP_WIN
  17 #  undef PostMessage
  18 #endif
  19
  20 class nsIContentSecurityPolicy;
  21 class nsIDocShell;
  22 class nsIGlobalObject;
  23 class nsISerialEventTarget;
  24 class nsPIDOMWindowInner;
  25
  26 namespace mozilla {
  27 class ErrorResult;
  28
  29 namespace dom {
  30
  31 class ClientControlledArgs;
  32 class ClientFocusArgs;
  33 class ClientGetInfoAndStateArgs;
  34 class ClientManager;
  35 class ClientPostMessageArgs;
  36 class ClientSourceChild;
  37 class ClientSourceConstructorArgs;
  38 class ClientSourceExecutionReadyArgs;
  39 class ClientState;
  40 class ClientWindowState;
  41 class PClientManagerChild;
  42 class WorkerPrivate;
  43
  44 // ClientSource is an RAII style class that is designed to be held via
  45 // a UniquePtr<>.  When created ClientSource will register the existence
  46 // of a client in the cross-process ClientManagerService.  When the
  47 // ClientSource is destroyed then client entry will be removed.  Code
  48 // that represents globals or browsing environments, such as nsGlobalWindow
  49 // or WorkerPrivate, should use ClientManager to create a ClientSource.
  50 class ClientSource final : public ClientThing<ClientSourceChild> {
  51   friend class ClientManager;
  52
  53   NS_DECL_OWNINGTHREAD
  54
  55   RefPtr<ClientManager> mManager;
  56   nsCOMPtr<nsISerialEventTarget> mEventTarget;
  57
  58   Variant<Nothing, RefPtr<nsPIDOMWindowInner>, nsCOMPtr<nsIDocShell>,
  59           WorkerPrivate*>
  60       mOwner;
  61
  62   ClientInfo mClientInfo;
  63   Maybe<ServiceWorkerDescriptor> mController;
  64   Maybe<nsCOMPtr<nsIPrincipal>> mPrincipal;
  65
  66   // Contained a de-duplicated list of ServiceWorker scope strings
  67   // for which this client has called navigator.serviceWorker.register().
  68   // Typically there will be either be zero or one scope strings, but
  69   // there could be more.  We keep this list until the client is closed.
  70   AutoTArray<nsCString, 1> mRegisteringScopeList;
  71
  72   void Shutdown();
  73
  74   void ExecutionReady(const ClientSourceExecutionReadyArgs& aArgs);
  75
  76   WorkerPrivate* GetWorkerPrivate() const;
  77
  78   nsIDocShell* GetDocShell() const;
  79
  80   nsIGlobalObject* GetGlobal() const;
  81
  82   Result<bool, ErrorResult> MaybeCreateInitialDocument();
  83
  84   Result<ClientState, ErrorResult> SnapshotWindowState();
  85
  86   // Private methods called by ClientManager
  87   ClientSource(ClientManager* aManager, nsISerialEventTarget* aEventTarget,
  88                const ClientSourceConstructorArgs& aArgs);
  89
  90   void Activate(PClientManagerChild* aActor);
  91
  92  public:
  93   ~ClientSource();
  94
  95   nsPIDOMWindowInner* GetInnerWindow() const;
  96
  97   void WorkerExecutionReady(WorkerPrivate* aWorkerPrivate);
  98
  99   nsresult WindowExecutionReady(nsPIDOMWindowInner* aInnerWindow);
 100
 101   nsresult DocShellExecutionReady(nsIDocShell* aDocShell);
 102
 103   void Freeze();
 104
 105   void Thaw();
 106
 107   void EvictFromBFCache();
 108
 109   RefPtr<ClientOpPromise> EvictFromBFCacheOp();
 110
 111   const ClientInfo& Info() const;
 112
 113   // Trigger a synchronous IPC ping to the parent process to confirm that
 114   // the ClientSource actor has been created.  This should only be used
 115   // by the WorkerPrivate startup code to deal with a ClientHandle::Control()
 116   // call racing on the main thread.  Do not call this in other circumstances!
 117   void WorkerSyncPing(WorkerPrivate* aWorkerPrivate);
 118
 119   // Synchronously mark the ClientSource as controlled by the given service
 120   // worker.  This can happen as a result of a remote operation or directly
 121   // by local code.  For example, if a client's initial network load is
 122   // intercepted by a controlling service worker then this should be called
 123   // immediately.
 124   //
 125   // Note, there is no way to clear the controlling service worker because
 126   // the specification does not allow that operation.
 127   void SetController(const ServiceWorkerDescriptor& aServiceWorker);
 128
 129   // Mark the ClientSource as controlled using the remote operation arguments.
 130   // This will in turn call SetController().
 131   RefPtr<ClientOpPromise> Control(const ClientControlledArgs& aArgs);
 132
 133   // Inherit the controller from a local parent client.  This requires both
 134   // setting our immediate controller field and also updating the parent-side
 135   // data structure.
 136   void InheritController(const ServiceWorkerDescriptor& aServiceWorker);
 137
 138   // Get the ClientSource's current controlling service worker, if one has
 139   // been set.
 140   const Maybe<ServiceWorkerDescriptor>& GetController() const;
 141
 142   // Note that the client has reached DOMContentLoaded.  Only applies to window
 143   // clients.
 144   void NoteDOMContentLoaded();
 145
 146   // TODO: Convert Focus() to MOZ_CAN_RUN_SCRIPT
 147   MOZ_CAN_RUN_SCRIPT_BOUNDARY RefPtr<ClientOpPromise> Focus(
 148       const ClientFocusArgs& aArgs);
 149
 150   RefPtr<ClientOpPromise> PostMessage(const ClientPostMessageArgs& aArgs);
 151
 152   RefPtr<ClientOpPromise> GetInfoAndState(
 153       const ClientGetInfoAndStateArgs& aArgs);
 154
 155   Result<ClientState, ErrorResult> SnapshotState();
 156
 157   nsISerialEventTarget* EventTarget() const;
 158
 159   void SetCsp(nsIContentSecurityPolicy* aCsp);
 160   void SetPreloadCsp(nsIContentSecurityPolicy* aPreloadCSP);
 161   void SetCspInfo(const mozilla::ipc::CSPInfo& aCSPInfo);
 162   const Maybe<mozilla::ipc::CSPInfo>& GetCspInfo();
 163
 164   void SetAgentClusterId(const nsID& aId) {
 165     mClientInfo.SetAgentClusterId(aId);
 166   }
 167
 168   void Traverse(nsCycleCollectionTraversalCallback& aCallback,
 169                 const char* aName, uint32_t aFlags);
 170
 171   void NoteCalledRegisterForServiceWorkerScope(const nsACString& aScope);
 172
 173   bool CalledRegisterForServiceWorkerScope(const nsACString& aScope);
 174
 175   nsIPrincipal* GetPrincipal();
 176 };
 177
 178 inline void ImplCycleCollectionUnlink(UniquePtr<ClientSource>& aField) {
 179   aField.reset();
 180 }
 181
 182 inline void ImplCycleCollectionTraverse(
 183     nsCycleCollectionTraversalCallback& aCallback,
 184     UniquePtr<ClientSource>& aField, const char* aName, uint32_t aFlags) {
 185   if (aField) {
 186     aField->Traverse(aCallback, aName, aFlags);
 187   }
 188 }
 189
 190 }  // namespace dom
 191 }  // namespace mozilla
 192
 193 #endif  // _mozilla_dom_ClientSource_h