Bug 1580448 - JSProcessActor API;r=nika

This patch introduces the bulk of JSProcessActor{Child, Parent}.

Differential Revision: https://phabricator.services.mozilla.com/D64595

Author: David Teller

dom/chrome-webidl/JSProcessActor.webidl

@@ -0,0 +1,76 @@
+/* -*- 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/. */
+
+/**
+ * An actor architecture designed to allow compositional parent/content
+ * communications. The lifetime of a JSProcessActor{Child, Parent} is the `ContentParent`
+ * (for the parent-side) / `ContentChild` (for the child-side).
+ */
+
+interface nsISupports;
+
+/**
+ * Base class for parent-side actor.
+ */
+[ChromeOnly, Exposed=Window]
+interface JSProcessActorParent {
+  [ChromeOnly]
+  constructor();
+
+  readonly attribute nsIContentParent manager;
+};
+JSProcessActorParent includes JSActor;
+
+[ChromeOnly, Exposed=Window]
+interface JSProcessActorChild {
+  [ChromeOnly]
+  constructor();
+
+  readonly attribute nsIContentChild manager;
+};
+JSProcessActorChild includes JSActor;
+
+
+/**
+ * Used by `ChromeUtils.registerProcessActor()` to register actors.
+ */
+dictionary ProcessActorOptions {
+  /**
+   * An array of remote type which restricts the actor is allowed to instantiate
+   * in specific process type. If this is defined, the prefix of process type
+   * matches the remote type by prefix match is allowed to instantiate, ex: if
+   * Fission is enabled, the prefix of process type will be `webIsolated`, it
+   * can prefix match remote type either `web` or `webIsolated`. If not passed,
+   * all content processes are allowed to instantiate the actor.
+   */
+  sequence<DOMString> remoteTypes;
+
+  /** This fields are used for configuring individual sides of the actor. */
+  ProcessActorSidedOptions parent;
+  ProcessActorChildOptions child;
+};
+
+dictionary ProcessActorSidedOptions {
+  /**
+   * The JSM path which should be loaded for the actor on this side.
+   * If not passed, the specified side cannot receive messages, but may send
+   * them using `sendAsyncMessage` or `sendQuery`.
+   */
+  required ByteString moduleURI;
+};
+
+dictionary ProcessActorChildOptions : ProcessActorSidedOptions {
+  /**
+   * An array of observer topics to listen to. An observer will be added for each
+   * topic in the list.
+   *
+   * Observer notifications in the list use nsGlobalContentInner or
+   * nsGlobalContentOuter object as their subject, and the events will only be
+   * dispatched to the corresponding content actor. If additional observer
+   * notification's subjects are needed, please file a bug for that.
+   **/
+  sequence<ByteString> observers;
+};

dom/chrome-webidl/JSWindowActor.webidl

@@ -4,6 +4,15 @@
  * 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/. */
 
+/**
+ * An actor architecture designed to allow compositional parent/content
+ * communications. The lifetime of a JSWindowActor{Child, Parent} is the `WindowGlobalParent`
+ * (for the parent-side) / `WindowGlobalChild` (for the child-side).
+ *
+ * See https://firefox-source-docs.mozilla.org/dom/Fission.html#jswindowactor for
+ * more details on how to use this architecture.
+ */
+
 interface nsISupports;
 
 [ChromeOnly, Exposed=Window]

dom/chrome-webidl/moz.build

@@ -50,6 +50,7 @@ WEBIDL_FILES = [
     'InspectorUtils.webidl',
     'IteratorResult.webidl',
     'JSActor.webidl',
+    'JSProcessActor.webidl',
     'JSWindowActor.webidl',
     'L10nOverlays.webidl',
     'Localization.webidl',

dom/ipc/ContentChild.cpp

@@ -49,6 +49,8 @@
 #include "mozilla/dom/IPCBlobInputStreamChild.h"
 #include "mozilla/dom/IPCBlobUtils.h"
 #include "mozilla/dom/JSActorService.h"
+#include "mozilla/dom/JSProcessActorBinding.h"
+#include "mozilla/dom/JSProcessActorChild.h"
 #include "mozilla/dom/LSObject.h"
 #include "mozilla/dom/MemoryReportRequest.h"
 #include "mozilla/dom/PLoginReputationChild.h"
@@ -74,6 +76,7 @@
 #include "mozilla/ipc/FileDescriptorSetChild.h"
 #include "mozilla/ipc/FileDescriptorUtils.h"
 #include "mozilla/ipc/GeckoChildProcessHost.h"
+#include "mozilla/ipc/InProcessChild.h"
 #include "mozilla/ipc/LibrarySandboxPreload.h"
 #include "mozilla/ipc/ProcessChild.h"
 #include "mozilla/ipc/PChildToParentStreamChild.h"
@@ -2622,10 +2625,11 @@ mozilla::ipc::IPCResult ContentChild::RecvInitBlobURLs(
   return IPC_OK();
 }
 
-mozilla::ipc::IPCResult ContentChild::RecvInitJSWindowActorInfos(
-    nsTArray<JSWindowActorInfo>&& aInfos) {
+mozilla::ipc::IPCResult ContentChild::RecvInitJSActorInfos(
+    nsTArray<JSProcessActorInfo>&& aContentInfos,
+    nsTArray<JSWindowActorInfo>&& aWindowInfos) {
   RefPtr<JSActorService> actSvc = JSActorService::GetSingleton();
-  actSvc->LoadJSWindowActorInfos(aInfos);
+  actSvc->LoadJSActorInfos(aContentInfos, aWindowInfos);
   return IPC_OK();
 }
 
@@ -2636,6 +2640,13 @@ mozilla::ipc::IPCResult ContentChild::RecvUnregisterJSWindowActor(
   return IPC_OK();
 }
 
+mozilla::ipc::IPCResult ContentChild::RecvUnregisterJSProcessActor(
+    const nsCString& aName) {
+  RefPtr<JSActorService> actSvc = JSActorService::GetSingleton();
+  actSvc->UnregisterProcessActor(aName);
+  return IPC_OK();
+}
+
 mozilla::ipc::IPCResult ContentChild::RecvLastPrivateDocShellDestroyed() {
   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
   obs->NotifyObservers(nullptr, "last-pb-context-exited", nullptr);
@@ -4191,6 +4202,62 @@ NS_IMETHODIMP ContentChild::GetChildID(uint64_t* aOut) {
   return NS_OK;
 }
 
+IPCResult ContentChild::RecvRawMessage(const JSActorMessageMeta& aMeta,
+                                       const ClonedMessageData& aData,
+                                       const ClonedMessageData& aStack) {
+  StructuredCloneData data;
+  data.BorrowFromClonedMessageDataForChild(aData);
+  StructuredCloneData stack;
+  stack.BorrowFromClonedMessageDataForChild(aStack);
+  ReceiveRawMessage(aMeta, std::move(data), std::move(stack));
+  return IPC_OK();
+}
+
+void ContentChild::ReceiveRawMessage(const JSActorMessageMeta& aMeta,
+                                     StructuredCloneData&& aData,
+                                     StructuredCloneData&& aStack) {
+  RefPtr<JSProcessActorChild> actor =
+      GetActor(aMeta.actorName(), IgnoreErrors());
+  if (actor) {
+    actor->ReceiveRawMessage(aMeta, std::move(aData), std::move(aStack));
+  }
+}
+
+already_AddRefed<mozilla::dom::JSProcessActorChild> ContentChild::GetActor(
+    const nsACString& aName, ErrorResult& aRv) {
+  if (!CanSend()) {
+    aRv.ThrowInvalidStateError(
+        "Cannot get JSProcessActor, process is shutting down");
+    return nullptr;
+  }
+
+  // Check if this actor has already been created, and return it if it has.
+  if (mProcessActors.Contains(aName)) {
+    return mProcessActors.Get(aName);
+  }
+
+  // Otherwise, we want to create a new instance of this actor.
+  JS::RootedObject obj(RootingCx());
+  ConstructActor(aName, &obj, aRv);
+  if (aRv.Failed()) {
+    return nullptr;
+  }
+
+  // Unwrap our actor to a JSProcessActorChild object.
+  RefPtr<JSProcessActorChild> actor;
+  if (NS_FAILED(UNWRAP_OBJECT(JSProcessActorChild, &obj, actor))) {
+    aRv.ThrowTypeMismatchError(
+        "Constructed actor does not inherit from JSProcessActorChild");
+    return nullptr;
+  }
+
+  MOZ_RELEASE_ASSERT(!actor->Manager(),
+                     "mManager was already initialized once!");
+  actor->Init(aName, this);
+  mProcessActors.Put(aName, RefPtr{actor});
+  return actor.forget();
+}
+
 }  // namespace dom
 
 #if defined(__OpenBSD__) && defined(MOZ_SANDBOX)

dom/ipc/ContentChild.h

@@ -12,6 +12,8 @@
 #include "mozilla/Attributes.h"
 #include "mozilla/UniquePtr.h"
 #include "mozilla/dom/BrowserBridgeChild.h"
+#include "mozilla/dom/ProcessActor.h"
+#include "mozilla/dom/JSProcessActorChild.h"
 #include "mozilla/dom/PBrowserOrId.h"
 #include "mozilla/dom/PContentChild.h"
 #include "mozilla/dom/RemoteBrowser.h"
@@ -42,6 +44,7 @@ struct LookAndFeelInt;
 class nsDocShellLoadState;
 class nsFrameLoader;
 class nsIOpenWindowInfo;
+class JSProcessActorChild;
 
 namespace mozilla {
 class RemoteSpellcheckEngineChild;
@@ -78,7 +81,8 @@ class ContentChild final
       public nsIContentChild,
       public nsIWindowProvider,
       public mozilla::ipc::IShmemAllocator,
-      public mozilla::ipc::ChildToParentStreamActorManager {
+      public mozilla::ipc::ChildToParentStreamActorManager,
+      public ProcessActor {
   typedef mozilla::dom::ClonedMessageData ClonedMessageData;
   typedef mozilla::ipc::FileDescriptor FileDescriptor;
   typedef mozilla::ipc::PFileDescriptorSetChild PFileDescriptorSetChild;
@@ -390,19 +394,22 @@ class ContentChild final
 
   // Call RemoteTypePrefix() on the result to remove URIs if you want to use
   // this for telemetry.
-  const nsAString& GetRemoteType() const;
+  const nsAString& GetRemoteType() const override;
 
   mozilla::ipc::IPCResult RecvInitServiceWorkers(
       const ServiceWorkerConfiguration& aConfig);
 
   mozilla::ipc::IPCResult RecvInitBlobURLs(
       nsTArray<BlobURLRegistrationData>&& aRegistations);
 
-  mozilla::ipc::IPCResult RecvInitJSWindowActorInfos(
-      nsTArray<JSWindowActorInfo>&& aInfos);
+  mozilla::ipc::IPCResult RecvInitJSActorInfos(
+      nsTArray<JSProcessActorInfo>&& aContentInfos,
+      nsTArray<JSWindowActorInfo>&& aWindowInfos);
 
   mozilla::ipc::IPCResult RecvUnregisterJSWindowActor(const nsCString& aName);
 
+  mozilla::ipc::IPCResult RecvUnregisterJSProcessActor(const nsCString& aName);
+
   mozilla::ipc::IPCResult RecvLastPrivateDocShellDestroyed();
 
   mozilla::ipc::IPCResult RecvNotifyProcessPriorityChanged(
@@ -701,6 +708,10 @@ class ContentChild final
   PFileDescriptorSetChild* SendPFileDescriptorSetConstructor(
       const FileDescriptor& aFD) override;
 
+  // Get a JS actor object by name.
+  already_AddRefed<mozilla::dom::JSProcessActorChild> GetActor(
+      const nsACString& aName, ErrorResult& aRv);
+
  private:
   static void ForceKillTimerCallback(nsITimer* aTimer, void* aClosure);
   void StartForceKillTimer();
@@ -793,6 +804,17 @@ class ContentChild final
   mozilla::ipc::IPCResult RecvDisplayLoadError(
       const MaybeDiscarded<BrowsingContext>& aContext, const nsAString& aURI);
 
+  mozilla::ipc::IPCResult RecvRawMessage(const JSActorMessageMeta& aMeta,
+                                         const ClonedMessageData& aData,
+                                         const ClonedMessageData& aStack);
+
+  void ReceiveRawMessage(const JSActorMessageMeta& aMeta,
+                         ipc::StructuredCloneData&& aData,
+                         ipc::StructuredCloneData&& aStack);
+
+  JSActor::Type GetSide() override { return JSActor::Type::Child; }
+
+ private:
 #ifdef NIGHTLY_BUILD
   virtual PContentChild::Result OnMessageReceived(const Message& aMsg) override;
 #else
@@ -884,6 +906,8 @@ class ContentChild final
   // See `BrowsingContext::mEpochs` for an explanation of this field.
   uint64_t mBrowsingContextFieldEpoch = 0;
 
+  nsRefPtrHashtable<nsCStringHashKey, JSProcessActorChild> mProcessActors;
+
   DISALLOW_EVIL_CONSTRUCTORS(ContentChild);
 };
 

dom/ipc/ContentParent.cpp

@@ -93,6 +93,7 @@
 #include "mozilla/dom/IPCBlobInputStreamParent.h"
 #include "mozilla/dom/IPCBlobUtils.h"
 #include "mozilla/dom/JSActorService.h"
+#include "mozilla/dom/JSProcessActorBinding.h"
 #include "mozilla/dom/LocalStorageCommon.h"
 #include "mozilla/dom/MediaController.h"
 #include "mozilla/dom/MemoryReportRequest.h"
@@ -2613,12 +2614,16 @@ bool ContentParent::InitInternal(ProcessPriority aInitialPriority) {
     }
   }
 
-  // Send down WindowActorOptions at startup to content process.
+  // Send down { Parent, Window }ActorOptions at startup to content process.
   RefPtr<JSActorService> actorSvc = JSActorService::GetSingleton();
   if (actorSvc) {
-    nsTArray<JSWindowActorInfo> infos;
-    actorSvc->GetJSWindowActorInfos(infos);
-    Unused << SendInitJSWindowActorInfos(infos);
+    nsTArray<JSProcessActorInfo> contentInfos;
+    actorSvc->GetJSProcessActorInfos(contentInfos);
+
+    nsTArray<JSWindowActorInfo> windowInfos;
+    actorSvc->GetJSWindowActorInfos(windowInfos);
+
+    Unused << SendInitJSActorInfos(contentInfos, windowInfos);
   }
 
   // Start up nsPluginHost and run FindPlugins to cache the plugin list.
@@ -6421,6 +6426,63 @@ NS_IMETHODIMP ContentParent::GetChildID(uint64_t* aOut) {
   return NS_OK;
 }
 
+IPCResult ContentParent::RecvRawMessage(const JSActorMessageMeta& aMeta,
+                                        const ClonedMessageData& aData,
+                                        const ClonedMessageData& aStack) {
+  StructuredCloneData data;
+  data.BorrowFromClonedMessageDataForParent(aData);
+  StructuredCloneData stack;
+  stack.BorrowFromClonedMessageDataForParent(aStack);
+  ReceiveRawMessage(aMeta, std::move(data), std::move(stack));
+  return IPC_OK();
+}
+
+void ContentParent::ReceiveRawMessage(const JSActorMessageMeta& aMeta,
+                                      StructuredCloneData&& aData,
+                                      StructuredCloneData&& aStack) {
+  RefPtr<JSProcessActorParent> actor =
+      GetActor(aMeta.actorName(), IgnoreErrors());
+  if (actor) {
+    actor->ReceiveRawMessage(aMeta, std::move(aData), std::move(aStack));
+  }
+}
+
+already_AddRefed<JSProcessActorParent> ContentParent::GetActor(
+    const nsACString& aName, ErrorResult& aRv) {
+  if (!CanSend()) {
+    aRv.ThrowInvalidStateError(nsPrintfCString("Cannot get actor '%s': content parent is ready to communicate.",
+      PromiseFlatCString(aName).get()
+    ));
+    return nullptr;
+  }
+
+  // Check if this actor has already been created, and return it if it has.
+  if (mProcessActors.Contains(aName)) {
+    return do_AddRef(mProcessActors.GetWeak(aName));
+  }
+
+  // Otherwise, we want to create a new instance of this actor.
+  JS::RootedObject obj(RootingCx());
+  ConstructActor(aName, &obj, aRv);
+  if (aRv.Failed()) {
+    return nullptr;
+  }
+
+  // Unwrap our actor to a JSProcessActorParent object.
+  RefPtr<JSProcessActorParent> actor;
+  if (NS_FAILED(UNWRAP_OBJECT(JSProcessActorParent, &obj, actor))) {
+    aRv.ThrowTypeMismatchError(
+        "Constructed actor does not inherit from JSProcessActorParent");
+    return nullptr;
+  }
+
+  MOZ_RELEASE_ASSERT(!actor->Manager(),
+                     "mManager was already initialized once!");
+  actor->Init(aName, this);
+  mProcessActors.Put(aName, RefPtr{actor});
+  return actor.forget();
+}
+
 }  // namespace dom
 }  // namespace mozilla