Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

244 files changed, 58350 insertions, 0 deletions

diff --git a/dom/ipc/BrowserBridgeChild.cpp b/dom/ipc/BrowserBridgeChild.cpp
new file mode 100644
index 0000000000..3a2f7d8f84
--- /dev/null
+++ b/dom/ipc/BrowserBridgeChild.cpp
@@ -0,0 +1,249 @@
+/* -*- 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/. */
+
+#ifdef ACCESSIBILITY
+#  include "mozilla/a11y/DocAccessible.h"
+#  include "mozilla/a11y/DocManager.h"
+#  include "mozilla/a11y/OuterDocAccessible.h"
+#endif
+#include "mozilla/dom/BrowserBridgeChild.h"
+#include "mozilla/dom/BrowserBridgeHost.h"
+#include "mozilla/dom/BrowsingContext.h"
+#include "mozilla/dom/MozFrameLoaderOwnerBinding.h"
+#include "mozilla/PresShell.h"
+#include "nsFocusManager.h"
+#include "nsFrameLoader.h"
+#include "nsFrameLoaderOwner.h"
+#include "nsObjectLoadingContent.h"
+#include "nsQueryObject.h"
+#include "nsSubDocumentFrame.h"
+#include "nsView.h"
+
+using namespace mozilla::ipc;
+
+mozilla::LazyLogModule gBrowserChildFocusLog("BrowserChildFocus");
+
+#define LOGBROWSERCHILDFOCUS(args) \
+  MOZ_LOG(gBrowserChildFocusLog, mozilla::LogLevel::Debug, args)
+
+namespace mozilla::dom {
+
+BrowserBridgeChild::BrowserBridgeChild(BrowsingContext* aBrowsingContext,
+                                       TabId aId, const LayersId& aLayersId)
+    : mId{aId}, mLayersId{aLayersId}, mBrowsingContext(aBrowsingContext) {}
+
+BrowserBridgeChild::~BrowserBridgeChild() {}
+
+already_AddRefed<BrowserBridgeHost> BrowserBridgeChild::FinishInit(
+    nsFrameLoader* aFrameLoader) {
+  MOZ_DIAGNOSTIC_ASSERT(!mFrameLoader);
+  mFrameLoader = aFrameLoader;
+
+  RefPtr<Element> owner = mFrameLoader->GetOwnerContent();
+  Document* doc = owner->OwnerDoc();
+  doc->OOPChildLoadStarted(this);
+
+#if defined(ACCESSIBILITY)
+  if (a11y::DocAccessible* docAcc = a11y::GetExistingDocAccessible(doc)) {
+    if (a11y::LocalAccessible* ownerAcc = docAcc->GetAccessible(owner)) {
+      if (a11y::OuterDocAccessible* outerAcc = ownerAcc->AsOuterDoc()) {
+        outerAcc->SendEmbedderAccessible(this);
+      }
+    }
+  }
+#endif  // defined(ACCESSIBILITY)
+
+  return MakeAndAddRef<BrowserBridgeHost>(this);
+}
+
+nsILoadContext* BrowserBridgeChild::GetLoadContext() {
+  return mBrowsingContext;
+}
+
+void BrowserBridgeChild::NavigateByKey(bool aForward,
+                                       bool aForDocumentNavigation) {
+  Unused << SendNavigateByKey(aForward, aForDocumentNavigation);
+}
+
+void BrowserBridgeChild::Activate(uint64_t aActionId) {
+  LOGBROWSERCHILDFOCUS(
+      ("BrowserBridgeChild::Activate actionid: %" PRIu64, aActionId));
+  Unused << SendActivate(aActionId);
+}
+
+void BrowserBridgeChild::Deactivate(bool aWindowLowering, uint64_t aActionId) {
+  Unused << SendDeactivate(aWindowLowering, aActionId);
+}
+
+/*static*/
+BrowserBridgeChild* BrowserBridgeChild::GetFrom(nsFrameLoader* aFrameLoader) {
+  if (!aFrameLoader) {
+    return nullptr;
+  }
+  return aFrameLoader->GetBrowserBridgeChild();
+}
+
+/*static*/
+BrowserBridgeChild* BrowserBridgeChild::GetFrom(nsIContent* aContent) {
+  RefPtr<nsFrameLoaderOwner> loaderOwner = do_QueryObject(aContent);
+  if (!loaderOwner) {
+    return nullptr;
+  }
+  RefPtr<nsFrameLoader> frameLoader = loaderOwner->GetFrameLoader();
+  return GetFrom(frameLoader);
+}
+
+mozilla::ipc::IPCResult BrowserBridgeChild::RecvRequestFocus(
+    const bool& aCanRaise, const CallerType aCallerType) {
+  // Adapted from BrowserParent
+  RefPtr<Element> owner = mFrameLoader->GetOwnerContent();
+  if (!owner) {
+    return IPC_OK();
+  }
+  nsContentUtils::RequestFrameFocus(*owner, aCanRaise, aCallerType);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserBridgeChild::RecvMoveFocus(
+    const bool& aForward, const bool& aForDocumentNavigation) {
+  // Adapted from BrowserParent
+  RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager();
+  if (!fm) {
+    return IPC_OK();
+  }
+
+  RefPtr<Element> owner = mFrameLoader->GetOwnerContent();
+  if (!owner) {
+    return IPC_OK();
+  }
+
+  RefPtr<Element> dummy;
+
+  uint32_t type =
+      aForward
+          ? (aForDocumentNavigation
+                 ? static_cast<uint32_t>(nsIFocusManager::MOVEFOCUS_FORWARDDOC)
+                 : static_cast<uint32_t>(nsIFocusManager::MOVEFOCUS_FORWARD))
+          : (aForDocumentNavigation
+                 ? static_cast<uint32_t>(nsIFocusManager::MOVEFOCUS_BACKWARDDOC)
+                 : static_cast<uint32_t>(nsIFocusManager::MOVEFOCUS_BACKWARD));
+  fm->MoveFocus(nullptr, owner, type, nsIFocusManager::FLAG_BYKEY,
+                getter_AddRefs(dummy));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserBridgeChild::RecvMaybeFireEmbedderLoadEvents(
+    EmbedderElementEventType aFireEventAtEmbeddingElement) {
+  RefPtr<Element> owner = mFrameLoader->GetOwnerContent();
+  if (!owner) {
+    return IPC_OK();
+  }
+
+  if (aFireEventAtEmbeddingElement == EmbedderElementEventType::LoadEvent) {
+    nsEventStatus status = nsEventStatus_eIgnore;
+    WidgetEvent event(/* aIsTrusted = */ true, eLoad);
+    event.mFlags.mBubbles = false;
+    event.mFlags.mCancelable = false;
+    EventDispatcher::Dispatch(owner, nullptr, &event, nullptr, &status);
+  } else if (aFireEventAtEmbeddingElement ==
+             EmbedderElementEventType::ErrorEvent) {
+    mFrameLoader->FireErrorEvent();
+  }
+
+  UnblockOwnerDocsLoadEvent();
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserBridgeChild::RecvScrollRectIntoView(
+    const nsRect& aRect, const ScrollAxis& aVertical,
+    const ScrollAxis& aHorizontal, const ScrollFlags& aScrollFlags,
+    const int32_t& aAppUnitsPerDevPixel) {
+  RefPtr<Element> owner = mFrameLoader->GetOwnerContent();
+  if (!owner) {
+    return IPC_OK();
+  }
+
+  nsIFrame* frame = owner->GetPrimaryFrame();
+  if (!frame) {
+    return IPC_OK();
+  }
+
+  nsSubDocumentFrame* subdocumentFrame = do_QueryFrame(frame);
+  if (!subdocumentFrame) {
+    return IPC_OK();
+  }
+
+  nsPoint extraOffset = subdocumentFrame->GetExtraOffset();
+
+  int32_t parentAPD = frame->PresContext()->AppUnitsPerDevPixel();
+  nsRect rect =
+      aRect.ScaleToOtherAppUnitsRoundOut(aAppUnitsPerDevPixel, parentAPD);
+  rect += extraOffset;
+  RefPtr<PresShell> presShell = frame->PresShell();
+  presShell->ScrollFrameIntoView(frame, Some(rect), aVertical, aHorizontal,
+                                 aScrollFlags);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserBridgeChild::RecvSubFrameCrashed() {
+  if (RefPtr<nsFrameLoaderOwner> frameLoaderOwner =
+          do_QueryObject(mFrameLoader->GetOwnerContent())) {
+    frameLoaderOwner->SubframeCrashed();
+  }
+  return IPC_OK();
+}
+
+void BrowserBridgeChild::ActorDestroy(ActorDestroyReason aWhy) {
+  if (mFrameLoader) {
+    mFrameLoader->DestroyComplete();
+  }
+
+  if (!mBrowsingContext) {
+    // This BBC was never valid, skip teardown.
+    return;
+  }
+
+  // Ensure we unblock our document's 'load' event (in case the OOP-iframe has
+  // been removed before it finished loading, or its subprocess crashed):
+  UnblockOwnerDocsLoadEvent();
+}
+
+void BrowserBridgeChild::UnblockOwnerDocsLoadEvent() {
+  if (!mHadInitialLoad) {
+    mHadInitialLoad = true;
+
+    if (Document* doc = mBrowsingContext->GetParent()->GetExtantDocument()) {
+      doc->OOPChildLoadDone(this);
+    }
+  }
+}
+
+mozilla::ipc::IPCResult BrowserBridgeChild::RecvIntrinsicSizeOrRatioChanged(
+    const Maybe<IntrinsicSize>& aIntrinsicSize,
+    const Maybe<AspectRatio>& aIntrinsicRatio) {
+  if (RefPtr<Element> owner = mFrameLoader->GetOwnerContent()) {
+    if (nsCOMPtr<nsIObjectLoadingContent> olc = do_QueryInterface(owner)) {
+      static_cast<nsObjectLoadingContent*>(olc.get())
+          ->SubdocumentIntrinsicSizeOrRatioChanged(aIntrinsicSize,
+                                                   aIntrinsicRatio);
+    }
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserBridgeChild::RecvImageLoadComplete(
+    const nsresult& aResult) {
+  if (RefPtr<Element> owner = mFrameLoader->GetOwnerContent()) {
+    if (nsCOMPtr<nsIObjectLoadingContent> olc = do_QueryInterface(owner)) {
+      static_cast<nsObjectLoadingContent*>(olc.get())
+          ->SubdocumentImageLoadComplete(aResult);
+    }
+  }
+  return IPC_OK();
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/BrowserBridgeChild.h b/dom/ipc/BrowserBridgeChild.h
new file mode 100644
index 0000000000..60e29d2483
--- /dev/null
+++ b/dom/ipc/BrowserBridgeChild.h
@@ -0,0 +1,119 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_BrowserBridgeChild_h
+#define mozilla_dom_BrowserBridgeChild_h
+
+#include "mozilla/dom/PBrowserBridgeChild.h"
+#include "mozilla/dom/BrowserChild.h"
+#include "mozilla/dom/ipc/IdType.h"
+
+namespace mozilla::dom {
+class BrowsingContext;
+class ContentChild;
+class BrowserBridgeHost;
+
+/**
+ * BrowserBridgeChild implements the child actor part of the PBrowserBridge
+ * protocol. See PBrowserBridge for more information.
+ */
+class BrowserBridgeChild : public PBrowserBridgeChild {
+ public:
+  typedef mozilla::layers::LayersId LayersId;
+
+  NS_INLINE_DECL_REFCOUNTING(BrowserBridgeChild, final);
+
+  BrowserChild* Manager() {
+    MOZ_ASSERT(CanSend());
+    return static_cast<BrowserChild*>(PBrowserBridgeChild::Manager());
+  }
+
+  TabId GetTabId() { return mId; }
+
+  LayersId GetLayersId() { return mLayersId; }
+
+  nsFrameLoader* GetFrameLoader() const { return mFrameLoader; }
+
+  BrowsingContext* GetBrowsingContext() { return mBrowsingContext; }
+
+  nsILoadContext* GetLoadContext();
+
+  void NavigateByKey(bool aForward, bool aForDocumentNavigation);
+
+  void Activate(uint64_t aActionId);
+
+  void Deactivate(bool aWindowLowering, uint64_t aActionId);
+
+  already_AddRefed<BrowserBridgeHost> FinishInit(nsFrameLoader* aFrameLoader);
+
+#if defined(ACCESSIBILITY)
+  void SetEmbedderAccessible(PDocAccessibleChild* aDoc, uint64_t aID) {
+    MOZ_ASSERT((aDoc && aID) || (!aDoc && !aID));
+    mEmbedderAccessibleID = aID;
+    Unused << SendSetEmbedderAccessible(aDoc, aID);
+  }
+
+  uint64_t GetEmbedderAccessibleID() { return mEmbedderAccessibleID; }
+#endif  // defined(ACCESSIBILITY)
+
+  static BrowserBridgeChild* GetFrom(nsFrameLoader* aFrameLoader);
+
+  static BrowserBridgeChild* GetFrom(nsIContent* aContent);
+
+  BrowserBridgeChild(BrowsingContext* aBrowsingContext, TabId aId,
+                     const LayersId& aLayersId);
+
+ protected:
+  friend class ContentChild;
+  friend class PBrowserBridgeChild;
+
+  mozilla::ipc::IPCResult RecvRequestFocus(const bool& aCanRaise,
+                                           const CallerType aCallerType);
+
+  mozilla::ipc::IPCResult RecvMoveFocus(const bool& aForward,
+                                        const bool& aForDocumentNavigation);
+
+  // TODO: Use MOZ_CAN_RUN_SCRIPT when it gains IPDL support (bug 1539864)
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult
+  RecvMaybeFireEmbedderLoadEvents(
+      EmbedderElementEventType aFireEventAtEmbeddingElement);
+
+  mozilla::ipc::IPCResult RecvIntrinsicSizeOrRatioChanged(
+      const Maybe<IntrinsicSize>& aIntrinsicSize,
+      const Maybe<AspectRatio>& aIntrinsicRatio);
+
+  mozilla::ipc::IPCResult RecvImageLoadComplete(const nsresult& aResult);
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  mozilla::ipc::IPCResult RecvScrollRectIntoView(
+      const nsRect& aRect, const ScrollAxis& aVertical,
+      const ScrollAxis& aHorizontal, const ScrollFlags& aScrollFlags,
+      const int32_t& aAppUnitsPerDevPixel);
+
+  mozilla::ipc::IPCResult RecvSubFrameCrashed();
+
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+
+ private:
+  ~BrowserBridgeChild();
+
+  void UnblockOwnerDocsLoadEvent();
+
+  TabId mId;
+  LayersId mLayersId;
+  bool mHadInitialLoad = false;
+  RefPtr<nsFrameLoader> mFrameLoader;
+  RefPtr<BrowsingContext> mBrowsingContext;
+#if defined(ACCESSIBILITY)
+  // We need to keep track of the embedder accessible id we last sent to the
+  // parent process.
+  uint64_t mEmbedderAccessibleID = 0;
+#endif  // defined(ACCESSIBILITY)
+};
+
+}  // namespace mozilla::dom
+
+#endif  // !defined(mozilla_dom_BrowserBridgeParent_h)
diff --git a/dom/ipc/BrowserBridgeHost.cpp b/dom/ipc/BrowserBridgeHost.cpp
new file mode 100644
index 0000000000..2cb8decd58
--- /dev/null
+++ b/dom/ipc/BrowserBridgeHost.cpp
@@ -0,0 +1,91 @@
+/* -*- 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 "mozilla/dom/BrowserBridgeHost.h"
+
+#include "mozilla/Unused.h"
+#include "mozilla/dom/Element.h"
+#include "nsFrameLoader.h"
+
+namespace mozilla::dom {
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(BrowserBridgeHost)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTION(BrowserBridgeHost)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(BrowserBridgeHost)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(BrowserBridgeHost)
+
+BrowserBridgeHost::BrowserBridgeHost(BrowserBridgeChild* aChild)
+    : mBridge(aChild) {}
+
+TabId BrowserBridgeHost::GetTabId() const { return mBridge->GetTabId(); }
+
+mozilla::layers::LayersId BrowserBridgeHost::GetLayersId() const {
+  return mBridge->GetLayersId();
+}
+
+BrowsingContext* BrowserBridgeHost::GetBrowsingContext() const {
+  return mBridge->GetBrowsingContext();
+}
+
+nsILoadContext* BrowserBridgeHost::GetLoadContext() const {
+  return mBridge->GetLoadContext();
+}
+
+bool BrowserBridgeHost::CanRecv() const {
+  return mBridge && mBridge->CanRecv();
+}
+
+void BrowserBridgeHost::LoadURL(nsDocShellLoadState* aLoadState) {
+  MOZ_ASSERT(aLoadState);
+  Unused << mBridge->SendLoadURL(WrapNotNull(aLoadState));
+}
+
+void BrowserBridgeHost::ResumeLoad(uint64_t aPendingSwitchId) {
+  Unused << mBridge->SendResumeLoad(aPendingSwitchId);
+}
+
+void BrowserBridgeHost::DestroyStart() {
+  // We don't clear the bridge until BrowserBridgeChild::ActorDestroy is called,
+  // which will end up calling DestroyComplete().
+  if (mBridge) {
+    Unused << mBridge->SendBeginDestroy();
+  }
+}
+
+void BrowserBridgeHost::DestroyComplete() { mBridge = nullptr; }
+
+bool BrowserBridgeHost::Show(const OwnerShowInfo& aShowInfo) {
+  Unused << mBridge->SendShow(aShowInfo);
+  return true;
+}
+
+void BrowserBridgeHost::UpdateDimensions(const nsIntRect& aRect,
+                                         const ScreenIntSize& aSize) {
+  Unused << mBridge->SendUpdateDimensions(aRect, aSize);
+}
+
+void BrowserBridgeHost::UpdateEffects(EffectsInfo aEffects) {
+  if (!mBridge || mEffectsInfo == aEffects) {
+    return;
+  }
+  mEffectsInfo = aEffects;
+  Unused << mBridge->SendUpdateEffects(mEffectsInfo);
+}
+
+already_AddRefed<nsIWidget> BrowserBridgeHost::GetWidget() const {
+  RefPtr<Element> owner = mBridge->GetFrameLoader()->GetOwnerContent();
+  nsCOMPtr<nsIWidget> widget = nsContentUtils::WidgetForContent(owner);
+  if (!widget) {
+    widget = nsContentUtils::WidgetForDocument(owner->OwnerDoc());
+  }
+  return widget.forget();
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/BrowserBridgeHost.h b/dom/ipc/BrowserBridgeHost.h
new file mode 100644
index 0000000000..09f2f4dfdd
--- /dev/null
+++ b/dom/ipc/BrowserBridgeHost.h
@@ -0,0 +1,68 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_BrowserBridgeHost_h
+#define mozilla_dom_BrowserBridgeHost_h
+
+#include "mozilla/dom/RemoteBrowser.h"
+#include "mozilla/dom/BrowserBridgeChild.h"
+
+namespace mozilla::dom {
+
+/**
+ * BrowserBridgeHost manages a remote browser from a content process.
+ *
+ * It is used via the RemoteBrowser interface in nsFrameLoader and proxies
+ * work to the chrome process via PBrowserBridge.
+ *
+ * See `dom/docs/Fission-IPC-Diagram.svg` for an overview of the DOM IPC
+ * actors.
+ */
+class BrowserBridgeHost : public RemoteBrowser {
+ public:
+  typedef mozilla::layers::LayersId LayersId;
+
+  explicit BrowserBridgeHost(BrowserBridgeChild* aChild);
+
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS(BrowserBridgeHost)
+
+  // Get the IPDL actor for the BrowserBridgeChild.
+  BrowserBridgeChild* GetActor() { return mBridge; }
+
+  BrowserHost* AsBrowserHost() override { return nullptr; }
+  BrowserBridgeHost* AsBrowserBridgeHost() override { return this; }
+
+  TabId GetTabId() const override;
+  LayersId GetLayersId() const override;
+  BrowsingContext* GetBrowsingContext() const override;
+  nsILoadContext* GetLoadContext() const override;
+  bool CanRecv() const override;
+
+  void LoadURL(nsDocShellLoadState* aLoadState) override;
+  void ResumeLoad(uint64_t aPendingSwitchId) override;
+  void DestroyStart() override;
+  void DestroyComplete() override;
+
+  bool Show(const OwnerShowInfo&) override;
+  void UpdateDimensions(const nsIntRect& aRect,
+                        const ScreenIntSize& aSize) override;
+
+  void UpdateEffects(EffectsInfo aInfo) override;
+
+ private:
+  virtual ~BrowserBridgeHost() = default;
+
+  already_AddRefed<nsIWidget> GetWidget() const;
+
+  // The IPDL actor for proxying browser operations
+  RefPtr<BrowserBridgeChild> mBridge;
+  EffectsInfo mEffectsInfo;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_BrowserBridgeHost_h
diff --git a/dom/ipc/BrowserBridgeParent.cpp b/dom/ipc/BrowserBridgeParent.cpp
new file mode 100644
index 0000000000..0d91b506db
--- /dev/null
+++ b/dom/ipc/BrowserBridgeParent.cpp
@@ -0,0 +1,310 @@
+/* -*- 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/. */
+
+#ifdef ACCESSIBILITY
+#  include "mozilla/a11y/DocAccessibleParent.h"
+#  include "nsAccessibilityService.h"
+#endif
+
+#include "mozilla/Monitor.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/dom/BrowserBridgeParent.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/ContentProcessManager.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/dom/BrowsingContextGroup.h"
+#include "mozilla/dom/WindowGlobalParent.h"
+#include "mozilla/ipc/Endpoint.h"
+#include "mozilla/layers/InputAPZContext.h"
+
+using namespace mozilla::ipc;
+using namespace mozilla::layout;
+using namespace mozilla::hal;
+
+namespace mozilla::dom {
+
+BrowserBridgeParent::BrowserBridgeParent() = default;
+
+BrowserBridgeParent::~BrowserBridgeParent() { Destroy(); }
+
+nsresult BrowserBridgeParent::InitWithProcess(
+    BrowserParent* aParentBrowser, ContentParent* aContentParent,
+    const WindowGlobalInit& aWindowInit, uint32_t aChromeFlags, TabId aTabId) {
+  MOZ_ASSERT(!CanSend(),
+             "This should be called before the object is connected to IPC");
+  MOZ_DIAGNOSTIC_ASSERT(!aContentParent->IsLaunching());
+  MOZ_DIAGNOSTIC_ASSERT(!aContentParent->IsDead());
+
+  RefPtr<CanonicalBrowsingContext> browsingContext =
+      CanonicalBrowsingContext::Get(aWindowInit.context().mBrowsingContextId);
+  if (!browsingContext || browsingContext->IsDiscarded()) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  MOZ_DIAGNOSTIC_ASSERT(
+      !browsingContext->GetBrowserParent(),
+      "BrowsingContext must have had previous BrowserParent cleared");
+
+  MOZ_DIAGNOSTIC_ASSERT(
+      aParentBrowser->Manager() != aContentParent,
+      "Cannot create OOP iframe in the same process as its parent document");
+
+  // Unfortunately, due to the current racy destruction of BrowsingContext
+  // instances when Fission is enabled, while `browsingContext` may not be
+  // discarded, an ancestor might be.
+  //
+  // A discarded ancestor will cause us issues when creating our `BrowserParent`
+  // in the new content process, so abort the attempt if we have one.
+  //
+  // FIXME: We should never have a non-discarded BrowsingContext with discarded
+  // ancestors. (bug 1634759)
+  if (NS_WARN_IF(!browsingContext->AncestorsAreCurrent())) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  // Ensure that our content process is subscribed to our newly created
+  // BrowsingContextGroup.
+  browsingContext->Group()->EnsureHostProcess(aContentParent);
+  browsingContext->SetOwnerProcessId(aContentParent->ChildID());
+
+  // Construct the BrowserParent object for our subframe.
+  auto browserParent = MakeRefPtr<BrowserParent>(
+      aContentParent, aTabId, *aParentBrowser, browsingContext, aChromeFlags);
+  browserParent->SetBrowserBridgeParent(this);
+
+  // Open a remote endpoint for our PBrowser actor.
+  ManagedEndpoint<PBrowserChild> childEp =
+      aContentParent->OpenPBrowserEndpoint(browserParent);
+  if (NS_WARN_IF(!childEp.IsValid())) {
+    MOZ_ASSERT(false, "Browser Open Endpoint Failed");
+    return NS_ERROR_FAILURE;
+  }
+
+  ContentProcessManager* cpm = ContentProcessManager::GetSingleton();
+  if (!cpm) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  cpm->RegisterRemoteFrame(browserParent);
+
+  RefPtr<WindowGlobalParent> windowParent =
+      WindowGlobalParent::CreateDisconnected(aWindowInit);
+  if (!windowParent) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  ManagedEndpoint<PWindowGlobalChild> windowChildEp =
+      browserParent->OpenPWindowGlobalEndpoint(windowParent);
+  if (NS_WARN_IF(!windowChildEp.IsValid())) {
+    MOZ_ASSERT(false, "WindowGlobal Open Endpoint Failed");
+    return NS_ERROR_FAILURE;
+  }
+
+  MOZ_DIAGNOSTIC_ASSERT(!browsingContext->IsDiscarded(),
+                        "bc cannot have become discarded");
+
+  // Tell the content process to set up its PBrowserChild.
+  bool ok = aContentParent->SendConstructBrowser(
+      std::move(childEp), std::move(windowChildEp), aTabId,
+      browserParent->AsIPCTabContext(), aWindowInit, aChromeFlags,
+      aContentParent->ChildID(), aContentParent->IsForBrowser(),
+      /* aIsTopLevel */ false);
+  if (NS_WARN_IF(!ok)) {
+    MOZ_ASSERT(false, "Browser Constructor Failed");
+    return NS_ERROR_FAILURE;
+  }
+
+  // Set our BrowserParent object to the newly created browser.
+  mBrowserParent = std::move(browserParent);
+  mBrowserParent->SetOwnerElement(aParentBrowser->GetOwnerElement());
+  mBrowserParent->InitRendering();
+
+  GetBrowsingContext()->SetCurrentBrowserParent(mBrowserParent);
+
+  windowParent->Init();
+  return NS_OK;
+}
+
+CanonicalBrowsingContext* BrowserBridgeParent::GetBrowsingContext() {
+  return mBrowserParent->GetBrowsingContext();
+}
+
+BrowserParent* BrowserBridgeParent::Manager() {
+  MOZ_ASSERT(CanSend());
+  return static_cast<BrowserParent*>(PBrowserBridgeParent::Manager());
+}
+
+void BrowserBridgeParent::Destroy() {
+  if (mBrowserParent) {
+#ifdef ACCESSIBILITY
+    if (mEmbedderAccessibleDoc && !mEmbedderAccessibleDoc->IsShutdown()) {
+      mEmbedderAccessibleDoc->RemovePendingOOPChildDoc(this);
+    }
+#endif
+    mBrowserParent->Destroy();
+    mBrowserParent->SetBrowserBridgeParent(nullptr);
+    mBrowserParent = nullptr;
+  }
+  if (CanSend()) {
+    Unused << Send__delete__(this);
+  }
+}
+
+IPCResult BrowserBridgeParent::RecvShow(const OwnerShowInfo& aOwnerInfo) {
+  mBrowserParent->AttachWindowRenderer();
+  Unused << mBrowserParent->SendShow(mBrowserParent->GetShowInfo(), aOwnerInfo);
+  return IPC_OK();
+}
+
+IPCResult BrowserBridgeParent::RecvScrollbarPreferenceChanged(
+    ScrollbarPreference aPref) {
+  Unused << mBrowserParent->SendScrollbarPreferenceChanged(aPref);
+  return IPC_OK();
+}
+
+IPCResult BrowserBridgeParent::RecvLoadURL(nsDocShellLoadState* aLoadState) {
+  Unused << mBrowserParent->SendLoadURL(WrapNotNull(aLoadState),
+                                        mBrowserParent->GetShowInfo());
+  return IPC_OK();
+}
+
+IPCResult BrowserBridgeParent::RecvResumeLoad(uint64_t aPendingSwitchID) {
+  mBrowserParent->ResumeLoad(aPendingSwitchID);
+  return IPC_OK();
+}
+
+IPCResult BrowserBridgeParent::RecvUpdateDimensions(
+    const nsIntRect& aRect, const ScreenIntSize& aSize) {
+  mBrowserParent->UpdateDimensions(aRect, aSize);
+  return IPC_OK();
+}
+
+IPCResult BrowserBridgeParent::RecvUpdateEffects(const EffectsInfo& aEffects) {
+  Unused << mBrowserParent->SendUpdateEffects(aEffects);
+  return IPC_OK();
+}
+
+IPCResult BrowserBridgeParent::RecvUpdateRemotePrintSettings(
+    const embedding::PrintData& aPrintData) {
+  Unused << mBrowserParent->SendUpdateRemotePrintSettings(aPrintData);
+  return IPC_OK();
+}
+
+IPCResult BrowserBridgeParent::RecvRenderLayers(
+    const bool& aEnabled, const layers::LayersObserverEpoch& aEpoch) {
+  Unused << mBrowserParent->SendRenderLayers(aEnabled, aEpoch);
+  return IPC_OK();
+}
+
+IPCResult BrowserBridgeParent::RecvNavigateByKey(
+    const bool& aForward, const bool& aForDocumentNavigation) {
+  Unused << mBrowserParent->SendNavigateByKey(aForward, aForDocumentNavigation);
+  return IPC_OK();
+}
+
+IPCResult BrowserBridgeParent::RecvBeginDestroy() {
+  Destroy();
+  return IPC_OK();
+}
+
+IPCResult BrowserBridgeParent::RecvDispatchSynthesizedMouseEvent(
+    const WidgetMouseEvent& aEvent) {
+  if (aEvent.mMessage != eMouseMove ||
+      aEvent.mReason != WidgetMouseEvent::eSynthesized) {
+    return IPC_FAIL(this, "Unexpected event type");
+  }
+
+  WidgetMouseEvent event = aEvent;
+  // Convert mRefPoint from the dispatching child process coordinate space
+  // to the parent coordinate space. The SendRealMouseEvent call will convert
+  // it into the dispatchee child process coordinate space
+  event.mRefPoint = Manager()->TransformChildToParent(event.mRefPoint);
+  // We need to set up an InputAPZContext on the stack because
+  // BrowserParent::SendRealMouseEvent requires one. But the only thing in
+  // that context that is actually used in this scenario is the layers id,
+  // and we already have that on the mouse event.
+  layers::InputAPZContext context(
+      layers::ScrollableLayerGuid(event.mLayersId, 0,
+                                  layers::ScrollableLayerGuid::NULL_SCROLL_ID),
+      0, nsEventStatus_eIgnore);
+  mBrowserParent->SendRealMouseEvent(event);
+  return IPC_OK();
+}
+
+IPCResult BrowserBridgeParent::RecvWillChangeProcess() {
+  Unused << mBrowserParent->SendWillChangeProcess();
+  return IPC_OK();
+}
+
+IPCResult BrowserBridgeParent::RecvActivate(uint64_t aActionId) {
+  mBrowserParent->Activate(aActionId);
+  return IPC_OK();
+}
+
+IPCResult BrowserBridgeParent::RecvDeactivate(const bool& aWindowLowering,
+                                              uint64_t aActionId) {
+  mBrowserParent->Deactivate(aWindowLowering, aActionId);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserBridgeParent::RecvUpdateRemoteStyle(
+    const StyleImageRendering& aImageRendering) {
+  Unused << mBrowserParent->SendUpdateRemoteStyle(aImageRendering);
+  return IPC_OK();
+}
+
+#ifdef ACCESSIBILITY
+a11y::DocAccessibleParent* BrowserBridgeParent::GetDocAccessibleParent() {
+  auto* embeddedBrowser = GetBrowserParent();
+  if (!embeddedBrowser) {
+    return nullptr;
+  }
+  a11y::DocAccessibleParent* docAcc =
+      embeddedBrowser->GetTopLevelDocAccessible();
+  return docAcc && !docAcc->IsShutdown() ? docAcc : nullptr;
+}
+
+IPCResult BrowserBridgeParent::RecvSetEmbedderAccessible(
+    PDocAccessibleParent* aDoc, uint64_t aID) {
+#  if defined(ANDROID)
+  MonitorAutoLock mal(nsAccessibilityService::GetAndroidMonitor());
+#  endif
+  MOZ_ASSERT(aDoc || mEmbedderAccessibleDoc,
+             "Embedder doc shouldn't be cleared if it wasn't set");
+  MOZ_ASSERT(!mEmbedderAccessibleDoc || !aDoc || mEmbedderAccessibleDoc == aDoc,
+             "Embedder doc shouldn't change from one doc to another");
+  if (!aDoc && mEmbedderAccessibleDoc &&
+      !mEmbedderAccessibleDoc->IsShutdown()) {
+    // We're clearing the embedder doc, so remove the pending child doc addition
+    // (if any).
+    mEmbedderAccessibleDoc->RemovePendingOOPChildDoc(this);
+  }
+  mEmbedderAccessibleDoc = static_cast<a11y::DocAccessibleParent*>(aDoc);
+  mEmbedderAccessibleID = aID;
+  if (!aDoc) {
+    MOZ_ASSERT(!aID);
+    return IPC_OK();
+  }
+  MOZ_ASSERT(aID);
+  if (GetDocAccessibleParent()) {
+    // The embedded DocAccessibleParent has already been created. This can
+    // happen if, for example, an iframe is hidden and then shown or
+    // an iframe is reflowed by layout.
+    mEmbedderAccessibleDoc->AddChildDoc(this);
+  }
+  return IPC_OK();
+}
+
+a11y::DocAccessibleParent* BrowserBridgeParent::GetEmbedderAccessibleDoc() {
+  return mEmbedderAccessibleDoc && !mEmbedderAccessibleDoc->IsShutdown()
+             ? mEmbedderAccessibleDoc.get()
+             : nullptr;
+}
+#endif
+
+void BrowserBridgeParent::ActorDestroy(ActorDestroyReason aWhy) { Destroy(); }
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/BrowserBridgeParent.h b/dom/ipc/BrowserBridgeParent.h
new file mode 100644
index 0000000000..7f49cea4d5
--- /dev/null
+++ b/dom/ipc/BrowserBridgeParent.h
@@ -0,0 +1,124 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_BrowserBridgeParent_h
+#define mozilla_dom_BrowserBridgeParent_h
+
+#include "mozilla/dom/PBrowserBridgeParent.h"
+#include "mozilla/dom/ipc/IdType.h"
+#include "mozilla/dom/WindowGlobalTypes.h"
+
+namespace mozilla {
+
+namespace a11y {
+class DocAccessibleParent;
+}
+
+namespace embedding {
+class PrintData;
+}
+
+namespace dom {
+
+class BrowserParent;
+
+/**
+ * BrowserBridgeParent implements the parent actor part of the PBrowserBridge
+ * protocol. See PBrowserBridge for more information.
+ */
+class BrowserBridgeParent : public PBrowserBridgeParent {
+ public:
+  NS_INLINE_DECL_REFCOUNTING(BrowserBridgeParent, final);
+
+  BrowserBridgeParent();
+
+  nsresult InitWithProcess(BrowserParent* aParentBrowser,
+                           ContentParent* aContentParent,
+                           const WindowGlobalInit& aWindowInit,
+                           uint32_t aChromeFlags, TabId aTabId);
+
+  BrowserParent* GetBrowserParent() { return mBrowserParent; }
+
+  CanonicalBrowsingContext* GetBrowsingContext();
+
+  // Get our manager actor.
+  BrowserParent* Manager();
+
+#if defined(ACCESSIBILITY)
+  /**
+   * Get the DocAccessibleParent which contains this iframe.
+   */
+  a11y::DocAccessibleParent* GetEmbedderAccessibleDoc();
+
+  /**
+   * Get the unique id of the OuterDocAccessible associated with this iframe.
+   * This is the id of the RemoteAccessible inside the document returned by
+   * GetEmbedderAccessibleDoc.
+   */
+  uint64_t GetEmbedderAccessibleId() { return mEmbedderAccessibleID; }
+
+  /**
+   * Get the DocAccessibleParent for the embedded document.
+   */
+  a11y::DocAccessibleParent* GetDocAccessibleParent();
+#endif  // defined(ACCESSIBILITY)
+
+  // Tear down this BrowserBridgeParent.
+  void Destroy();
+
+ protected:
+  friend class PBrowserBridgeParent;
+
+  mozilla::ipc::IPCResult RecvShow(const OwnerShowInfo&);
+  mozilla::ipc::IPCResult RecvScrollbarPreferenceChanged(ScrollbarPreference);
+  mozilla::ipc::IPCResult RecvLoadURL(nsDocShellLoadState* aLoadState);
+  mozilla::ipc::IPCResult RecvResumeLoad(uint64_t aPendingSwitchID);
+  mozilla::ipc::IPCResult RecvUpdateDimensions(const nsIntRect& aRect,
+                                               const ScreenIntSize& aSize);
+  mozilla::ipc::IPCResult RecvUpdateEffects(const EffectsInfo& aEffects);
+  mozilla::ipc::IPCResult RecvUpdateRemotePrintSettings(
+      const embedding::PrintData&);
+  mozilla::ipc::IPCResult RecvRenderLayers(const bool& aEnabled,
+                                           const LayersObserverEpoch& aEpoch);
+
+  mozilla::ipc::IPCResult RecvNavigateByKey(const bool& aForward,
+                                            const bool& aForDocumentNavigation);
+  mozilla::ipc::IPCResult RecvBeginDestroy();
+
+  mozilla::ipc::IPCResult RecvDispatchSynthesizedMouseEvent(
+      const WidgetMouseEvent& aEvent);
+
+  mozilla::ipc::IPCResult RecvWillChangeProcess();
+
+  mozilla::ipc::IPCResult RecvActivate(uint64_t aActionId);
+
+  mozilla::ipc::IPCResult RecvDeactivate(const bool& aWindowLowering,
+                                         uint64_t aActionId);
+
+  mozilla::ipc::IPCResult RecvUpdateRemoteStyle(
+      const StyleImageRendering& aImageRendering);
+
+#ifdef ACCESSIBILITY
+  mozilla::ipc::IPCResult RecvSetEmbedderAccessible(PDocAccessibleParent* aDoc,
+                                                    uint64_t aID);
+#endif
+
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+
+ private:
+  ~BrowserBridgeParent();
+
+  RefPtr<BrowserParent> mBrowserParent;
+#ifdef ACCESSIBILITY
+  RefPtr<a11y::DocAccessibleParent> mEmbedderAccessibleDoc;
+  uint64_t mEmbedderAccessibleID = 0;
+#endif  // ACCESSIBILITY
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // !defined(mozilla_dom_BrowserBridgeParent_h)
diff --git a/dom/ipc/BrowserChild.cpp b/dom/ipc/BrowserChild.cpp
new file mode 100644
index 0000000000..95fc4de14d
--- /dev/null
+++ b/dom/ipc/BrowserChild.cpp
@@ -0,0 +1,3848 @@
+/* -*- 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 "base/basictypes.h"
+
+#include "BrowserChild.h"
+
+#ifdef ACCESSIBILITY
+#  include "mozilla/a11y/DocAccessibleChild.h"
+#endif
+#include <algorithm>
+#include <utility>
+
+#include "BrowserParent.h"
+#include "ContentChild.h"
+#include "DocumentInlines.h"
+#include "EventStateManager.h"
+#include "MMPrinter.h"
+#include "PermissionMessageUtils.h"
+#include "PuppetWidget.h"
+#include "StructuredCloneData.h"
+#include "UnitTransforms.h"
+#include "Units.h"
+#include "VRManagerChild.h"
+#include "ipc/nsGUIEventIPC.h"
+#include "js/JSON.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/AsyncEventDispatcher.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/EventForwards.h"
+#include "mozilla/EventListenerManager.h"
+#include "mozilla/HoldDropJSObjects.h"
+#include "mozilla/IMEStateManager.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/NativeKeyBindingsType.h"
+#include "mozilla/NullPrincipal.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/ProcessHangMonitor.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/ResultExtensions.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/Services.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/StaticPrefs_fission.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/TouchEvents.h"
+#include "mozilla/ToString.h"
+#include "mozilla/Unused.h"
+#include "mozilla/dom/AutoPrintEventDispatcher.h"
+#include "mozilla/dom/BrowserBridgeChild.h"
+#include "mozilla/dom/DataTransfer.h"
+#include "mozilla/dom/DocGroup.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/JSWindowActorChild.h"
+#include "mozilla/dom/ImageDocument.h"
+#include "mozilla/dom/LoadURIOptionsBinding.h"
+#include "mozilla/dom/MediaDocument.h"
+#include "mozilla/dom/MessageManagerBinding.h"
+#include "mozilla/dom/MouseEventBinding.h"
+#include "mozilla/dom/Nullable.h"
+#include "mozilla/dom/PBrowser.h"
+#include "mozilla/dom/PaymentRequestChild.h"
+#include "mozilla/dom/PointerEventHandler.h"
+#include "mozilla/dom/SessionStoreUtils.h"
+#include "mozilla/dom/SessionStoreChild.h"
+#include "mozilla/dom/WindowGlobalChild.h"
+#include "mozilla/dom/WindowProxyHolder.h"
+#include "mozilla/gfx/CrossProcessPaint.h"
+#include "mozilla/gfx/Matrix.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/ipc/BackgroundChild.h"
+#include "mozilla/ipc/BackgroundUtils.h"
+#include "mozilla/ipc/PBackgroundChild.h"
+#include "mozilla/ipc/URIUtils.h"
+#include "mozilla/layers/APZCCallbackHelper.h"
+#include "mozilla/layers/TouchActionHelper.h"
+#include "mozilla/layers/APZCTreeManagerChild.h"
+#include "mozilla/layers/APZChild.h"
+#include "mozilla/layers/APZEventState.h"
+#include "mozilla/layers/CompositorBridgeChild.h"
+#include "mozilla/layers/ContentProcessController.h"
+#include "mozilla/layers/DoubleTapToZoom.h"
+#include "mozilla/layers/IAPZCTreeManager.h"
+#include "mozilla/layers/ImageBridgeChild.h"
+#include "mozilla/layers/InputAPZContext.h"
+#include "mozilla/layers/WebRenderLayerManager.h"
+#include "nsBrowserStatusFilter.h"
+#include "nsColorPickerProxy.h"
+#include "nsCommandParams.h"
+#include "nsContentPermissionHelper.h"
+#include "nsContentUtils.h"
+#include "nsDeviceContext.h"
+#include "nsDocShell.h"
+#include "nsDocShellLoadState.h"
+#include "nsEmbedCID.h"
+#include "nsExceptionHandler.h"
+#include "nsFilePickerProxy.h"
+#include "nsFocusManager.h"
+#include "nsGlobalWindow.h"
+#include "nsIBaseWindow.h"
+#include "nsIBrowserDOMWindow.h"
+#include "nsIClassifiedChannel.h"
+#include "nsIDocShell.h"
+#include "nsIFrame.h"
+#include "nsILoadContext.h"
+#include "nsISHEntry.h"
+#include "nsISHistory.h"
+#include "nsIScreenManager.h"
+#include "nsIScriptError.h"
+#include "nsISecureBrowserUI.h"
+#include "nsIURI.h"
+#include "nsIURIMutator.h"
+#include "nsIWeakReferenceUtils.h"
+#include "nsIWebBrowser.h"
+#include "nsIWebProgress.h"
+#include "nsLayoutUtils.h"
+#include "nsNetUtil.h"
+#include "nsIOpenWindowInfo.h"
+#include "nsPIDOMWindow.h"
+#include "nsPIWindowRoot.h"
+#include "nsPointerHashKeys.h"
+#include "nsPrintfCString.h"
+#include "nsQueryActor.h"
+#include "nsQueryObject.h"
+#include "nsRefreshDriver.h"
+#include "nsSandboxFlags.h"
+#include "nsString.h"
+#include "nsTHashtable.h"
+#include "nsThreadManager.h"
+#include "nsThreadUtils.h"
+#include "nsViewManager.h"
+#include "nsViewportInfo.h"
+#include "nsWebBrowser.h"
+#include "nsWindowWatcher.h"
+#include "nsIXULRuntime.h"
+
+#ifdef MOZ_WAYLAND
+#  include "nsAppRunner.h"
+#endif
+
+#ifdef NS_PRINTING
+#  include "mozilla/layout/RemotePrintJobChild.h"
+#  include "nsIPrintSettings.h"
+#  include "nsIPrintSettingsService.h"
+#  include "nsIWebBrowserPrint.h"
+#endif
+
+static mozilla::LazyLogModule sApzChildLog("apz.child");
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::dom::ipc;
+using namespace mozilla::ipc;
+using namespace mozilla::layers;
+using namespace mozilla::layout;
+using namespace mozilla::widget;
+using mozilla::layers::GeckoContentController;
+
+static const char BEFORE_FIRST_PAINT[] = "before-first-paint";
+
+static uint32_t sConsecutiveTouchMoveCount = 0;
+
+using BrowserChildMap = nsTHashMap<nsUint64HashKey, BrowserChild*>;
+static BrowserChildMap* sBrowserChildren;
+StaticMutex sBrowserChildrenMutex;
+
+already_AddRefed<Document> BrowserChild::GetTopLevelDocument() const {
+  nsCOMPtr<nsIDocShell> docShell = do_GetInterface(WebNavigation());
+  nsCOMPtr<Document> doc = docShell ? docShell->GetExtantDocument() : nullptr;
+  return doc.forget();
+}
+
+PresShell* BrowserChild::GetTopLevelPresShell() const {
+  if (RefPtr<Document> doc = GetTopLevelDocument()) {
+    return doc->GetPresShell();
+  }
+  return nullptr;
+}
+
+bool BrowserChild::UpdateFrame(const RepaintRequest& aRequest) {
+  MOZ_ASSERT(aRequest.GetScrollId() != ScrollableLayerGuid::NULL_SCROLL_ID);
+
+  if (aRequest.IsRootContent()) {
+    if (PresShell* presShell = GetTopLevelPresShell()) {
+      // Guard against stale updates (updates meant for a pres shell which
+      // has since been torn down and destroyed).
+      if (aRequest.GetPresShellId() == presShell->GetPresShellId()) {
+        APZCCallbackHelper::UpdateRootFrame(aRequest);
+        return true;
+      }
+    }
+  } else {
+    // aRequest.mIsRoot is false, so we are trying to update a subframe.
+    // This requires special handling.
+    APZCCallbackHelper::UpdateSubFrame(aRequest);
+    return true;
+  }
+  return true;
+}
+
+class BrowserChild::DelayedDeleteRunnable final : public Runnable,
+                                                  public nsIRunnablePriority {
+  RefPtr<BrowserChild> mBrowserChild;
+
+  // In order to try that this runnable runs after everything that could
+  // possibly touch this tab, we send it through the event queue twice.
+  bool mReadyToDelete = false;
+
+ public:
+  explicit DelayedDeleteRunnable(BrowserChild* aBrowserChild)
+      : Runnable("BrowserChild::DelayedDeleteRunnable"),
+        mBrowserChild(aBrowserChild) {
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(aBrowserChild);
+  }
+
+  NS_DECL_ISUPPORTS_INHERITED
+
+ private:
+  ~DelayedDeleteRunnable() {
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(!mBrowserChild);
+  }
+
+  NS_IMETHOD GetPriority(uint32_t* aPriority) override {
+    *aPriority = nsIRunnablePriority::PRIORITY_NORMAL;
+    return NS_OK;
+  }
+
+  NS_IMETHOD
+  Run() override {
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(mBrowserChild);
+
+    if (!mReadyToDelete) {
+      // This time run this runnable at input priority.
+      mReadyToDelete = true;
+      MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(this));
+      return NS_OK;
+    }
+
+    // Check in case ActorDestroy was called after RecvDestroy message.
+    if (mBrowserChild->IPCOpen()) {
+      Unused << PBrowserChild::Send__delete__(mBrowserChild);
+    }
+
+    mBrowserChild = nullptr;
+    return NS_OK;
+  }
+};
+
+NS_IMPL_ISUPPORTS_INHERITED(BrowserChild::DelayedDeleteRunnable, Runnable,
+                            nsIRunnablePriority)
+
+namespace {
+std::map<TabId, RefPtr<BrowserChild>>& NestedBrowserChildMap() {
+  MOZ_ASSERT(NS_IsMainThread());
+  static std::map<TabId, RefPtr<BrowserChild>> sNestedBrowserChildMap;
+  return sNestedBrowserChildMap;
+}
+}  // namespace
+
+already_AddRefed<BrowserChild> BrowserChild::FindBrowserChild(
+    const TabId& aTabId) {
+  auto iter = NestedBrowserChildMap().find(aTabId);
+  if (iter == NestedBrowserChildMap().end()) {
+    return nullptr;
+  }
+  RefPtr<BrowserChild> browserChild = iter->second;
+  return browserChild.forget();
+}
+
+/*static*/
+already_AddRefed<BrowserChild> BrowserChild::Create(
+    ContentChild* aManager, const TabId& aTabId, const TabContext& aContext,
+    BrowsingContext* aBrowsingContext, uint32_t aChromeFlags,
+    bool aIsTopLevel) {
+  RefPtr<BrowserChild> iframe = new BrowserChild(
+      aManager, aTabId, aContext, aBrowsingContext, aChromeFlags, aIsTopLevel);
+  return iframe.forget();
+}
+
+BrowserChild::BrowserChild(ContentChild* aManager, const TabId& aTabId,
+                           const TabContext& aContext,
+                           BrowsingContext* aBrowsingContext,
+                           uint32_t aChromeFlags, bool aIsTopLevel)
+    : TabContext(aContext),
+      mBrowserChildMessageManager(nullptr),
+      mManager(aManager),
+      mBrowsingContext(aBrowsingContext),
+      mChromeFlags(aChromeFlags),
+      mMaxTouchPoints(0),
+      mLayersId{0},
+      mEffectsInfo{EffectsInfo::FullyHidden()},
+      mDynamicToolbarMaxHeight(0),
+      mUniqueId(aTabId),
+      mDidFakeShow(false),
+      mTriedBrowserInit(false),
+      mIgnoreKeyPressEvent(false),
+      mHasValidInnerSize(false),
+      mDestroyed(false),
+      mIsTopLevel(aIsTopLevel),
+      mIsTransparent(false),
+      mIPCOpen(false),
+      mDidSetRealShowInfo(false),
+      mDidLoadURLInit(false),
+      mSkipKeyPress(false),
+      mDidSetEffectsInfo(false),
+      mShouldSendWebProgressEventsToParent(false),
+      mRenderLayers(true),
+      mIsPreservingLayers(false),
+      mLayersObserverEpoch{1},
+#if defined(XP_WIN) && defined(ACCESSIBILITY)
+      mNativeWindowHandle(0),
+#endif
+#if defined(ACCESSIBILITY)
+      mTopLevelDocAccessibleChild(nullptr),
+#endif
+      mCancelContentJSEpoch(0) {
+  mozilla::HoldJSObjects(this);
+
+  // preloaded BrowserChild should not be added to child map
+  if (mUniqueId) {
+    MOZ_ASSERT(NestedBrowserChildMap().find(mUniqueId) ==
+               NestedBrowserChildMap().end());
+    NestedBrowserChildMap()[mUniqueId] = this;
+  }
+  mCoalesceMouseMoveEvents = StaticPrefs::dom_events_coalesce_mousemove();
+  if (mCoalesceMouseMoveEvents) {
+    mCoalescedMouseEventFlusher = new CoalescedMouseMoveFlusher(this);
+  }
+
+  if (StaticPrefs::dom_events_coalesce_touchmove()) {
+    mCoalescedTouchMoveEventFlusher = new CoalescedTouchMoveFlusher(this);
+  }
+}
+
+const CompositorOptions& BrowserChild::GetCompositorOptions() const {
+  // If you're calling this before mCompositorOptions is set, well.. don't.
+  MOZ_ASSERT(mCompositorOptions);
+  return mCompositorOptions.ref();
+}
+
+bool BrowserChild::AsyncPanZoomEnabled() const {
+  // This might get called by the TouchEvent::PrefEnabled code before we have
+  // mCompositorOptions populated (bug 1370089). In that case we just assume
+  // APZ is enabled because we're in a content process (because BrowserChild)
+  // and APZ is probably going to be enabled here since e10s is enabled.
+  return mCompositorOptions ? mCompositorOptions->UseAPZ() : true;
+}
+
+NS_IMETHODIMP
+BrowserChild::Observe(nsISupports* aSubject, const char* aTopic,
+                      const char16_t* aData) {
+  if (!strcmp(aTopic, BEFORE_FIRST_PAINT)) {
+    if (AsyncPanZoomEnabled()) {
+      nsCOMPtr<Document> subject(do_QueryInterface(aSubject));
+      nsCOMPtr<Document> doc(GetTopLevelDocument());
+
+      if (subject == doc) {
+        RefPtr<PresShell> presShell = doc->GetPresShell();
+        if (presShell) {
+          presShell->SetIsFirstPaint(true);
+        }
+
+        APZCCallbackHelper::InitializeRootDisplayport(presShell);
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+void BrowserChild::ContentReceivedInputBlock(uint64_t aInputBlockId,
+                                             bool aPreventDefault) const {
+  if (mApzcTreeManager) {
+    mApzcTreeManager->ContentReceivedInputBlock(aInputBlockId, aPreventDefault);
+  }
+}
+
+void BrowserChild::SetTargetAPZC(
+    uint64_t aInputBlockId,
+    const nsTArray<ScrollableLayerGuid>& aTargets) const {
+  if (mApzcTreeManager) {
+    mApzcTreeManager->SetTargetAPZC(aInputBlockId, aTargets);
+  }
+}
+
+bool BrowserChild::DoUpdateZoomConstraints(
+    const uint32_t& aPresShellId, const ViewID& aViewId,
+    const Maybe<ZoomConstraints>& aConstraints) {
+  if (!mApzcTreeManager || mDestroyed) {
+    return false;
+  }
+
+  ScrollableLayerGuid guid =
+      ScrollableLayerGuid(mLayersId, aPresShellId, aViewId);
+
+  mApzcTreeManager->UpdateZoomConstraints(guid, aConstraints);
+  return true;
+}
+
+nsresult BrowserChild::Init(mozIDOMWindowProxy* aParent,
+                            WindowGlobalChild* aInitialWindowChild) {
+  MOZ_ASSERT_IF(aInitialWindowChild,
+                aInitialWindowChild->BrowsingContext() == mBrowsingContext);
+
+  nsCOMPtr<nsIWidget> widget = nsIWidget::CreatePuppetWidget(this);
+  mPuppetWidget = static_cast<PuppetWidget*>(widget.get());
+  if (!mPuppetWidget) {
+    NS_ERROR("couldn't create fake widget");
+    return NS_ERROR_FAILURE;
+  }
+  mPuppetWidget->InfallibleCreate(nullptr,
+                                  nullptr,  // no parents
+                                  LayoutDeviceIntRect(0, 0, 0, 0),
+                                  nullptr);  // HandleWidgetEvent
+
+  mWebBrowser = nsWebBrowser::Create(this, mPuppetWidget, mBrowsingContext,
+                                     aInitialWindowChild);
+  nsIWebBrowser* webBrowser = mWebBrowser;
+
+  mWebNav = do_QueryInterface(webBrowser);
+  NS_ASSERTION(mWebNav, "nsWebBrowser doesn't implement nsIWebNavigation?");
+
+  // IPC uses a WebBrowser object for which DNS prefetching is turned off
+  // by default. But here we really want it, so enable it explicitly
+  mWebBrowser->SetAllowDNSPrefetch(true);
+
+  nsCOMPtr<nsIDocShell> docShell = do_GetInterface(WebNavigation());
+  MOZ_ASSERT(docShell);
+
+  mStatusFilter = new nsBrowserStatusFilter();
+
+  nsresult rv =
+      mStatusFilter->AddProgressListener(this, nsIWebProgress::NOTIFY_ALL);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  {
+    nsCOMPtr<nsIWebProgress> webProgress = do_QueryInterface(docShell);
+    rv = webProgress->AddProgressListener(mStatusFilter,
+                                          nsIWebProgress::NOTIFY_ALL);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+#ifdef DEBUG
+  nsCOMPtr<nsILoadContext> loadContext = do_GetInterface(WebNavigation());
+  MOZ_ASSERT(loadContext);
+  MOZ_ASSERT(loadContext->UseRemoteTabs() ==
+             !!(mChromeFlags & nsIWebBrowserChrome::CHROME_REMOTE_WINDOW));
+  MOZ_ASSERT(loadContext->UseRemoteSubframes() ==
+             !!(mChromeFlags & nsIWebBrowserChrome::CHROME_FISSION_WINDOW));
+#endif  // defined(DEBUG)
+
+  // Few lines before, baseWindow->Create() will end up creating a new
+  // window root in nsGlobalWindow::SetDocShell.
+  // Then this chrome event handler, will be inherited to inner windows.
+  // We want to also set it to the docshell so that inner windows
+  // and any code that has access to the docshell
+  // can all listen to the same chrome event handler.
+  // XXX: ideally, we would set a chrome event handler earlier,
+  // and all windows, even the root one, will use the docshell one.
+  nsCOMPtr<nsPIDOMWindowOuter> window = do_GetInterface(WebNavigation());
+  NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
+  nsCOMPtr<EventTarget> chromeHandler = window->GetChromeEventHandler();
+  docShell->SetChromeEventHandler(chromeHandler);
+
+  // Window scrollbar flags only affect top level remote frames, not fission
+  // frames.
+  if (mIsTopLevel) {
+    nsContentUtils::SetScrollbarsVisibility(
+        docShell, !!(mChromeFlags & nsIWebBrowserChrome::CHROME_SCROLLBARS));
+  }
+
+  nsWeakPtr weakPtrThis = do_GetWeakReference(
+      static_cast<nsIBrowserChild*>(this));  // for capture by the lambda
+  ContentReceivedInputBlockCallback callback(
+      [weakPtrThis](uint64_t aInputBlockId, bool aPreventDefault) {
+        if (nsCOMPtr<nsIBrowserChild> browserChild =
+                do_QueryReferent(weakPtrThis)) {
+          static_cast<BrowserChild*>(browserChild.get())
+              ->ContentReceivedInputBlock(aInputBlockId, aPreventDefault);
+        }
+      });
+  mAPZEventState = new APZEventState(mPuppetWidget, std::move(callback));
+
+  mIPCOpen = true;
+
+  if (StaticPrefs::browser_sessionstore_platform_collection_AtStartup()) {
+    mSessionStoreChild = SessionStoreChild::GetOrCreate(mBrowsingContext);
+  }
+
+  // We've all set up, make sure our visibility state is consistent. This is
+  // important for OOP iframes, which start off as hidden.
+  UpdateVisibility();
+
+  return NS_OK;
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(BrowserChild)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(BrowserChild)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mBrowserChildMessageManager)
+  tmp->nsMessageManagerScriptExecutor::Unlink();
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mStatusFilter)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mWebNav)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mBrowsingContext)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mSessionStoreChild)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mContentTransformPromise)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_REFERENCE
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(BrowserChild)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBrowserChildMessageManager)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStatusFilter)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWebNav)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBrowsingContext)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSessionStoreChild)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mContentTransformPromise)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(BrowserChild)
+  tmp->nsMessageManagerScriptExecutor::Trace(aCallbacks, aClosure);
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(BrowserChild)
+  NS_INTERFACE_MAP_ENTRY(nsIWebBrowserChrome)
+  NS_INTERFACE_MAP_ENTRY(nsIWebBrowserChromeFocus)
+  NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
+  NS_INTERFACE_MAP_ENTRY(nsIWindowProvider)
+  NS_INTERFACE_MAP_ENTRY(nsIBrowserChild)
+  NS_INTERFACE_MAP_ENTRY(nsIObserver)
+  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+  NS_INTERFACE_MAP_ENTRY(nsITooltipListener)
+  NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener)
+  NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener2)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIBrowserChild)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(BrowserChild)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(BrowserChild)
+
+NS_IMETHODIMP
+BrowserChild::GetChromeFlags(uint32_t* aChromeFlags) {
+  *aChromeFlags = mChromeFlags;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+BrowserChild::SetChromeFlags(uint32_t aChromeFlags) {
+  NS_WARNING("trying to SetChromeFlags from content process?");
+
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+BrowserChild::RemoteDropLinks(
+    const nsTArray<RefPtr<nsIDroppedLinkItem>>& aLinks) {
+  nsTArray<nsString> linksArray;
+  nsresult rv = NS_OK;
+  for (nsIDroppedLinkItem* link : aLinks) {
+    nsString tmp;
+    rv = link->GetUrl(tmp);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+    linksArray.AppendElement(tmp);
+
+    rv = link->GetName(tmp);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+    linksArray.AppendElement(tmp);
+
+    rv = link->GetType(tmp);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+    linksArray.AppendElement(tmp);
+  }
+  bool sent = SendDropLinks(linksArray);
+
+  return sent ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+BrowserChild::ShowAsModal() {
+  NS_WARNING("BrowserChild::ShowAsModal not supported in BrowserChild");
+
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+BrowserChild::IsWindowModal(bool* aRetVal) {
+  *aRetVal = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+BrowserChild::SetLinkStatus(const nsAString& aStatusText) {
+  // We can only send the status after the ipc machinery is set up
+  if (IPCOpen()) {
+    SendSetLinkStatus(aStatusText);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+BrowserChild::SetDimensions(DimensionRequest&& aRequest) {
+  // The parent is in charge of the dimension changes. If JS code wants to
+  // change the dimensions (moveTo, screenX, etc.) we send a message to the
+  // parent about the new requested dimension, the parent does the resize/move
+  // then send a message to the child to update itself. For APIs like screenX
+  // this function is called with only the changed values.  In a series of calls
+  // like window.screenX = 10; window.screenY = 10; for the second call, since
+  // screenX is not yet updated we might accidentally reset back screenX to it's
+  // old value. To avoid this, if a parameter did not change, we want the parent
+  // to handle the unchanged values.
+
+  double scale = mPuppetWidget ? mPuppetWidget->GetDefaultScale().scale : 1.0;
+  SendSetDimensions(aRequest, scale);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+BrowserChild::GetDimensions(DimensionKind aDimensionKind, int32_t* aX,
+                            int32_t* aY, int32_t* aCx, int32_t* aCy) {
+  ScreenIntRect rect = GetOuterRect();
+  if (aDimensionKind == DimensionKind::Inner) {
+    if (aX || aY) {
+      return NS_ERROR_NOT_IMPLEMENTED;
+    }
+    rect.SizeTo(GetInnerSize());
+  }
+  if (aX) {
+    *aX = rect.x;
+  }
+  if (aY) {
+    *aY = rect.y;
+  }
+  if (aCx) {
+    *aCx = rect.width;
+  }
+  if (aCy) {
+    *aCy = rect.height;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+BrowserChild::Blur() { return NS_ERROR_NOT_IMPLEMENTED; }
+
+NS_IMETHODIMP
+BrowserChild::FocusNextElement(bool aForDocumentNavigation) {
+  SendMoveFocus(true, aForDocumentNavigation);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+BrowserChild::FocusPrevElement(bool aForDocumentNavigation) {
+  SendMoveFocus(false, aForDocumentNavigation);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+BrowserChild::GetInterface(const nsIID& aIID, void** aSink) {
+  // XXXbz should we restrict the set of interfaces we hand out here?
+  // See bug 537429
+  return QueryInterface(aIID, aSink);
+}
+
+NS_IMETHODIMP
+BrowserChild::ProvideWindow(nsIOpenWindowInfo* aOpenWindowInfo,
+                            uint32_t aChromeFlags, bool aCalledFromJS,
+                            nsIURI* aURI, const nsAString& aName,
+                            const nsACString& aFeatures, bool aForceNoOpener,
+                            bool aForceNoReferrer, bool aIsPopupRequested,
+                            nsDocShellLoadState* aLoadState, bool* aWindowIsNew,
+                            BrowsingContext** aReturn) {
+  *aReturn = nullptr;
+
+  RefPtr<BrowsingContext> parent = aOpenWindowInfo->GetParent();
+
+  int32_t openLocation = nsWindowWatcher::GetWindowOpenLocation(
+      parent->GetDOMWindow(), aChromeFlags, aCalledFromJS,
+      aOpenWindowInfo->GetIsForPrinting());
+
+  // If it turns out we're opening in the current browser, just hand over the
+  // current browser's docshell.
+  if (openLocation == nsIBrowserDOMWindow::OPEN_CURRENTWINDOW) {
+    nsCOMPtr<nsIWebBrowser> browser = do_GetInterface(WebNavigation());
+    *aWindowIsNew = false;
+
+    nsCOMPtr<mozIDOMWindowProxy> win;
+    MOZ_TRY(browser->GetContentDOMWindow(getter_AddRefs(win)));
+
+    RefPtr<BrowsingContext> bc(
+        nsPIDOMWindowOuter::From(win)->GetBrowsingContext());
+    bc.forget(aReturn);
+    return NS_OK;
+  }
+
+  // Note that ProvideWindowCommon may return NS_ERROR_ABORT if the
+  // open window call was canceled.  It's important that we pass this error
+  // code back to our caller.
+  ContentChild* cc = ContentChild::GetSingleton();
+  return cc->ProvideWindowCommon(
+      WrapNotNull(this), aOpenWindowInfo, aChromeFlags, aCalledFromJS, aURI,
+      aName, aFeatures, aForceNoOpener, aForceNoReferrer, aIsPopupRequested,
+      aLoadState, aWindowIsNew, aReturn);
+}
+
+void BrowserChild::DestroyWindow() {
+  mBrowsingContext = nullptr;
+
+  if (mStatusFilter) {
+    if (nsCOMPtr<nsIWebProgress> webProgress =
+            do_QueryInterface(WebNavigation())) {
+      webProgress->RemoveProgressListener(mStatusFilter);
+    }
+
+    mStatusFilter->RemoveProgressListener(this);
+    mStatusFilter = nullptr;
+  }
+
+  if (mCoalescedMouseEventFlusher) {
+    mCoalescedMouseEventFlusher->RemoveObserver();
+    mCoalescedMouseEventFlusher = nullptr;
+  }
+
+  if (mCoalescedTouchMoveEventFlusher) {
+    mCoalescedTouchMoveEventFlusher->RemoveObserver();
+    mCoalescedTouchMoveEventFlusher = nullptr;
+  }
+
+  if (mSessionStoreChild) {
+    mSessionStoreChild->Stop();
+    mSessionStoreChild = nullptr;
+  }
+
+  // In case we don't have chance to process all entries, clean all data in
+  // the queue.
+  while (mToBeDispatchedMouseData.GetSize() > 0) {
+    UniquePtr<CoalescedMouseData> data(
+        static_cast<CoalescedMouseData*>(mToBeDispatchedMouseData.PopFront()));
+    data.reset();
+  }
+
+  nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(WebNavigation());
+  if (baseWindow) baseWindow->Destroy();
+
+  if (mPuppetWidget) {
+    mPuppetWidget->Destroy();
+  }
+
+  mLayersConnected = Nothing();
+
+  if (mLayersId.IsValid()) {
+    StaticMutexAutoLock lock(sBrowserChildrenMutex);
+
+    MOZ_ASSERT(sBrowserChildren);
+    sBrowserChildren->Remove(uint64_t(mLayersId));
+    if (!sBrowserChildren->Count()) {
+      delete sBrowserChildren;
+      sBrowserChildren = nullptr;
+    }
+    mLayersId = layers::LayersId{0};
+  }
+}
+
+void BrowserChild::ActorDestroy(ActorDestroyReason why) {
+  mIPCOpen = false;
+
+  DestroyWindow();
+
+  if (mBrowserChildMessageManager) {
+    // We should have a message manager if the global is alive, but it
+    // seems sometimes we don't.  Assert in aurora/nightly, but don't
+    // crash in release builds.
+    MOZ_DIAGNOSTIC_ASSERT(mBrowserChildMessageManager->GetMessageManager());
+    if (mBrowserChildMessageManager->GetMessageManager()) {
+      // The messageManager relays messages via the BrowserChild which
+      // no longer exists.
+      mBrowserChildMessageManager->DisconnectMessageManager();
+    }
+  }
+
+  if (GetTabId() != 0) {
+    NestedBrowserChildMap().erase(GetTabId());
+  }
+}
+
+BrowserChild::~BrowserChild() {
+  mAnonymousGlobalScopes.Clear();
+
+  DestroyWindow();
+
+  nsCOMPtr<nsIWebBrowser> webBrowser = do_QueryInterface(WebNavigation());
+  if (webBrowser) {
+    webBrowser->SetContainerWindow(nullptr);
+  }
+
+  mozilla::DropJSObjects(this);
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvWillChangeProcess() {
+  if (mWebBrowser) {
+    mWebBrowser->SetWillChangeProcess();
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvLoadURL(
+    nsDocShellLoadState* aLoadState, const ParentShowInfo& aInfo) {
+  if (!mDidLoadURLInit) {
+    mDidLoadURLInit = true;
+    if (!InitBrowserChildMessageManager()) {
+      return IPC_FAIL_NO_REASON(this);
+    }
+
+    ApplyParentShowInfo(aInfo);
+  }
+  nsAutoCString spec;
+  aLoadState->URI()->GetSpec(spec);
+
+  nsCOMPtr<nsIDocShell> docShell = do_GetInterface(WebNavigation());
+  if (!docShell) {
+    NS_WARNING("WebNavigation does not have a docshell");
+    return IPC_OK();
+  }
+  docShell->LoadURI(aLoadState, true);
+
+  CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::URL, spec);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvCreateAboutBlankContentViewer(
+    nsIPrincipal* aPrincipal, nsIPrincipal* aPartitionedPrincipal) {
+  if (aPrincipal->GetIsExpandedPrincipal() ||
+      aPartitionedPrincipal->GetIsExpandedPrincipal()) {
+    return IPC_FAIL(this, "Cannot create document with an expanded principal");
+  }
+  if (aPrincipal->IsSystemPrincipal() ||
+      aPartitionedPrincipal->IsSystemPrincipal()) {
+    MOZ_ASSERT_UNREACHABLE(
+        "Cannot use CreateAboutBlankContentViewer to create system principal "
+        "document in content");
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIDocShell> docShell = do_GetInterface(WebNavigation());
+  if (!docShell) {
+    MOZ_ASSERT_UNREACHABLE("WebNavigation does not have a docshell");
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIURI> currentURI;
+  MOZ_ALWAYS_SUCCEEDS(
+      WebNavigation()->GetCurrentURI(getter_AddRefs(currentURI)));
+  if (!currentURI || !NS_IsAboutBlank(currentURI)) {
+    NS_WARNING("Can't create a ContentViewer unless on about:blank");
+    return IPC_OK();
+  }
+
+  docShell->CreateAboutBlankContentViewer(aPrincipal, aPartitionedPrincipal,
+                                          nullptr);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvResumeLoad(
+    const uint64_t& aPendingSwitchID, const ParentShowInfo& aInfo) {
+  if (!mDidLoadURLInit) {
+    mDidLoadURLInit = true;
+    if (!InitBrowserChildMessageManager()) {
+      return IPC_FAIL_NO_REASON(this);
+    }
+
+    ApplyParentShowInfo(aInfo);
+  }
+
+  nsresult rv = WebNavigation()->ResumeRedirectedLoad(aPendingSwitchID, -1);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("WebNavigation()->ResumeRedirectedLoad failed");
+  }
+
+  return IPC_OK();
+}
+
+nsresult BrowserChild::CloneDocumentTreeIntoSelf(
+    const MaybeDiscarded<BrowsingContext>& aSourceBC,
+    const embedding::PrintData& aPrintData) {
+#ifdef NS_PRINTING
+  if (NS_WARN_IF(aSourceBC.IsNullOrDiscarded())) {
+    return NS_ERROR_FAILURE;
+  }
+  nsCOMPtr<Document> sourceDocument = aSourceBC.get()->GetDocument();
+  if (NS_WARN_IF(!sourceDocument)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIDocShell> ourDocShell = do_GetInterface(WebNavigation());
+  if (NS_WARN_IF(!ourDocShell)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIContentViewer> cv;
+  ourDocShell->GetContentViewer(getter_AddRefs(cv));
+  if (NS_WARN_IF(!cv)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIPrintSettingsService> printSettingsSvc =
+      do_GetService("@mozilla.org/gfx/printsettings-service;1");
+  if (NS_WARN_IF(!printSettingsSvc)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIPrintSettings> printSettings;
+  nsresult rv =
+      printSettingsSvc->CreateNewPrintSettings(getter_AddRefs(printSettings));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  printSettingsSvc->DeserializeToPrintSettings(aPrintData, printSettings);
+
+  RefPtr<Document> clone;
+  {
+    AutoPrintEventDispatcher dispatcher(*sourceDocument);
+    nsAutoScriptBlocker scriptBlocker;
+    bool hasInProcessCallbacks = false;
+    clone = sourceDocument->CreateStaticClone(ourDocShell, cv, printSettings,
+                                              &hasInProcessCallbacks);
+    if (NS_WARN_IF(!clone)) {
+      return NS_ERROR_FAILURE;
+    }
+  }
+
+  rv = UpdateRemotePrintSettings(aPrintData);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+#endif
+  return NS_OK;
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvCloneDocumentTreeIntoSelf(
+    const MaybeDiscarded<BrowsingContext>& aSourceBC,
+    const embedding::PrintData& aPrintData,
+    CloneDocumentTreeIntoSelfResolver&& aResolve) {
+  nsresult rv = NS_OK;
+
+#ifdef NS_PRINTING
+  rv = CloneDocumentTreeIntoSelf(aSourceBC, aPrintData);
+#endif
+
+  aResolve(NS_SUCCEEDED(rv));
+  return IPC_OK();
+}
+
+nsresult BrowserChild::UpdateRemotePrintSettings(
+    const embedding::PrintData& aPrintData) {
+#ifdef NS_PRINTING
+  nsCOMPtr<nsIDocShell> ourDocShell = do_GetInterface(WebNavigation());
+  if (NS_WARN_IF(!ourDocShell)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  RefPtr<Document> doc = ourDocShell->GetExtantDocument();
+  if (NS_WARN_IF(!doc) || NS_WARN_IF(!doc->IsStaticDocument())) {
+    return NS_ERROR_FAILURE;
+  }
+
+  RefPtr<BrowsingContext> bc = ourDocShell->GetBrowsingContext();
+  if (NS_WARN_IF(!bc)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIPrintSettingsService> printSettingsSvc =
+      do_GetService("@mozilla.org/gfx/printsettings-service;1");
+  if (NS_WARN_IF(!printSettingsSvc)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIPrintSettings> printSettings;
+  nsresult rv =
+      printSettingsSvc->CreateNewPrintSettings(getter_AddRefs(printSettings));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  printSettingsSvc->DeserializeToPrintSettings(aPrintData, printSettings);
+
+  bc->PreOrderWalk([&](BrowsingContext* aBc) {
+    if (nsCOMPtr<nsIDocShell> inProcess = aBc->GetDocShell()) {
+      nsCOMPtr<nsIContentViewer> cv;
+      inProcess->GetContentViewer(getter_AddRefs(cv));
+      if (NS_WARN_IF(!cv)) {
+        return BrowsingContext::WalkFlag::Skip;
+      }
+      // The CanRunScript analysis is not smart enough to see across
+      // the std::function PreOrderWalk uses, so we cheat a bit here, but it is
+      // fine because PreOrderWalk does deal with arbitrary script changing the
+      // BC tree, and our code above is simple enough and keeps strong refs to
+      // everything.
+      ([&]() MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+        RefPtr<RemotePrintJobChild> printJob =
+            static_cast<RemotePrintJobChild*>(
+                aPrintData.remotePrintJob().AsChild());
+        cv->SetPrintSettingsForSubdocument(printSettings, printJob);
+      }());
+    } else if (RefPtr<BrowserBridgeChild> remoteChild =
+                   BrowserBridgeChild::GetFrom(aBc->GetEmbedderElement())) {
+      Unused << remoteChild->SendUpdateRemotePrintSettings(aPrintData);
+      return BrowsingContext::WalkFlag::Skip;
+    }
+    return BrowsingContext::WalkFlag::Next;
+  });
+#endif
+
+  return NS_OK;
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvUpdateRemotePrintSettings(
+    const embedding::PrintData& aPrintData) {
+#ifdef NS_PRINTING
+  UpdateRemotePrintSettings(aPrintData);
+#endif
+
+  return IPC_OK();
+}
+
+void BrowserChild::DoFakeShow(const ParentShowInfo& aParentShowInfo) {
+  OwnerShowInfo ownerInfo{ScreenIntSize(), ScrollbarPreference::Auto,
+                          nsSizeMode_Normal};
+  RecvShow(aParentShowInfo, ownerInfo);
+  mDidFakeShow = true;
+}
+
+void BrowserChild::ApplyParentShowInfo(const ParentShowInfo& aInfo) {
+  // Even if we already set real show info, the dpi / rounding & scale may still
+  // be invalid (if BrowserParent wasn't able to get widget it would just send
+  // 0). So better to always set up-to-date values here.
+  if (aInfo.dpi() > 0) {
+    mPuppetWidget->UpdateBackingScaleCache(aInfo.dpi(), aInfo.widgetRounding(),
+                                           aInfo.defaultScale());
+  }
+
+  if (mDidSetRealShowInfo) {
+    return;
+  }
+
+  if (!aInfo.fakeShowInfo()) {
+    // Once we've got one ShowInfo from parent, no need to update the values
+    // anymore.
+    mDidSetRealShowInfo = true;
+  }
+
+  mIsTransparent = aInfo.isTransparent();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvShow(
+    const ParentShowInfo& aParentInfo, const OwnerShowInfo& aOwnerInfo) {
+  bool res = true;
+
+  mPuppetWidget->SetSizeMode(aOwnerInfo.sizeMode());
+  if (!mDidFakeShow) {
+    nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(WebNavigation());
+    if (!baseWindow) {
+      NS_ERROR("WebNavigation() doesn't QI to nsIBaseWindow");
+      return IPC_FAIL_NO_REASON(this);
+    }
+
+    baseWindow->SetVisibility(true);
+    res = InitBrowserChildMessageManager();
+  }
+
+  ApplyParentShowInfo(aParentInfo);
+
+  if (!mIsTopLevel) {
+    RecvScrollbarPreferenceChanged(aOwnerInfo.scrollbarPreference());
+  }
+
+  if (!res) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+
+  UpdateVisibility();
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvInitRendering(
+    const TextureFactoryIdentifier& aTextureFactoryIdentifier,
+    const layers::LayersId& aLayersId,
+    const CompositorOptions& aCompositorOptions, const bool& aLayersConnected) {
+  mLayersConnected = Some(aLayersConnected);
+  mLayersConnectRequested = Some(aLayersConnected);
+  InitRenderingState(aTextureFactoryIdentifier, aLayersId, aCompositorOptions);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvScrollbarPreferenceChanged(
+    ScrollbarPreference aPreference) {
+  MOZ_ASSERT(!mIsTopLevel,
+             "Scrollbar visibility should be derived from chrome flags for "
+             "top-level windows");
+  if (nsCOMPtr<nsIDocShell> docShell = do_GetInterface(WebNavigation())) {
+    nsDocShell::Cast(docShell)->SetScrollbarPreference(aPreference);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvCompositorOptionsChanged(
+    const CompositorOptions& aNewOptions) {
+  MOZ_ASSERT(mCompositorOptions);
+
+  // The only compositor option we currently support changing is APZ
+  // enablement. Even that is only partially supported for now:
+  //   * Going from APZ to non-APZ is fine - we just flip the stored flag.
+  //     Note that we keep the actors (mApzcTreeManager, and the APZChild
+  //     created in InitAPZState()) around (read on for why).
+  //   * Going from non-APZ to APZ is only supported if we were using
+  //     APZ initially (at InitRendering() time) and we are transitioning
+  //     back. In this case, we just reuse the actors which we kept around.
+  //     Fully supporting a non-APZ to APZ transition (i.e. even in cases
+  //     where we initialized as non-APZ) would require setting up the actors
+  //     here. (In that case, we would also have the options of destroying
+  //     the actors in the APZ --> non-APZ case, and always re-creating them
+  //     during a non-APZ --> APZ transition).
+  mCompositorOptions->SetUseAPZ(aNewOptions.UseAPZ());
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvUpdateDimensions(
+    const DimensionInfo& aDimensionInfo) {
+  if (mLayersConnected.isNothing()) {
+    return IPC_OK();
+  }
+
+  mUnscaledOuterRect = aDimensionInfo.rect();
+  mClientOffset = aDimensionInfo.clientOffset();
+  mChromeOffset = aDimensionInfo.chromeOffset();
+  MOZ_ASSERT_IF(!IsTopLevel(), mChromeOffset == LayoutDeviceIntPoint());
+
+  SetUnscaledInnerSize(aDimensionInfo.size());
+  if (!mHasValidInnerSize && aDimensionInfo.size().width != 0 &&
+      aDimensionInfo.size().height != 0) {
+    mHasValidInnerSize = true;
+  }
+
+  ScreenIntSize screenSize = GetInnerSize();
+  ScreenIntRect screenRect = GetOuterRect();
+
+  // Make sure to set the size on the document viewer first.  The
+  // MobileViewportManager needs the content viewer size to be updated before
+  // the reflow, otherwise it gets a stale size when it computes a new CSS
+  // viewport.
+  nsCOMPtr<nsIBaseWindow> baseWin = do_QueryInterface(WebNavigation());
+  baseWin->SetPositionAndSize(0, 0, screenSize.width, screenSize.height,
+                              nsIBaseWindow::eRepaint);
+
+  mPuppetWidget->Resize(screenRect.x + mClientOffset.x + mChromeOffset.x,
+                        screenRect.y + mClientOffset.y + mChromeOffset.y,
+                        screenSize.width, screenSize.height, true);
+
+  RecvSafeAreaInsetsChanged(mPuppetWidget->GetSafeAreaInsets());
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvSizeModeChanged(
+    const nsSizeMode& aSizeMode) {
+  mPuppetWidget->SetSizeMode(aSizeMode);
+  if (!mPuppetWidget->IsVisible()) {
+    return IPC_OK();
+  }
+  nsCOMPtr<Document> document(GetTopLevelDocument());
+  if (!document) {
+    return IPC_OK();
+  }
+  nsPresContext* presContext = document->GetPresContext();
+  if (presContext) {
+    presContext->SizeModeChanged(aSizeMode);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvChildToParentMatrix(
+    const Maybe<gfx::Matrix4x4>& aMatrix,
+    const ScreenRect& aTopLevelViewportVisibleRectInBrowserCoords) {
+  mChildToParentConversionMatrix =
+      LayoutDeviceToLayoutDeviceMatrix4x4::FromUnknownMatrix(aMatrix);
+  mTopLevelViewportVisibleRectInBrowserCoords =
+      aTopLevelViewportVisibleRectInBrowserCoords;
+
+  if (mContentTransformPromise) {
+    mContentTransformPromise->MaybeResolveWithUndefined();
+    mContentTransformPromise = nullptr;
+  }
+
+  // Trigger an intersection observation update since ancestor viewports
+  // changed.
+  if (RefPtr<Document> toplevelDoc = GetTopLevelDocument()) {
+    if (nsPresContext* pc = toplevelDoc->GetPresContext()) {
+      pc->RefreshDriver()->EnsureIntersectionObservationsUpdateHappens();
+    }
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvUpdateRemoteStyle(
+    const StyleImageRendering& aImageRendering) {
+  BrowsingContext* context = GetBrowsingContext();
+  if (!context) {
+    return IPC_OK();
+  }
+
+  Document* document = context->GetDocument();
+  if (!document) {
+    return IPC_OK();
+  }
+
+  if (document->IsImageDocument()) {
+    document->AsImageDocument()->UpdateRemoteStyle(aImageRendering);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvDynamicToolbarMaxHeightChanged(
+    const ScreenIntCoord& aHeight) {
+#if defined(MOZ_WIDGET_ANDROID)
+  mDynamicToolbarMaxHeight = aHeight;
+
+  RefPtr<Document> document = GetTopLevelDocument();
+  if (!document) {
+    return IPC_OK();
+  }
+
+  if (RefPtr<nsPresContext> presContext = document->GetPresContext()) {
+    presContext->SetDynamicToolbarMaxHeight(aHeight);
+  }
+#endif
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvDynamicToolbarOffsetChanged(
+    const ScreenIntCoord& aOffset) {
+#if defined(MOZ_WIDGET_ANDROID)
+  RefPtr<Document> document = GetTopLevelDocument();
+  if (!document) {
+    return IPC_OK();
+  }
+
+  if (nsPresContext* presContext = document->GetPresContext()) {
+    presContext->UpdateDynamicToolbarOffset(aOffset);
+  }
+#endif
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvSuppressDisplayport(
+    const bool& aEnabled) {
+  if (RefPtr<PresShell> presShell = GetTopLevelPresShell()) {
+    presShell->SuppressDisplayport(aEnabled);
+  }
+  return IPC_OK();
+}
+
+void BrowserChild::HandleDoubleTap(const CSSPoint& aPoint,
+                                   const Modifiers& aModifiers,
+                                   const ScrollableLayerGuid& aGuid) {
+  MOZ_LOG(
+      sApzChildLog, LogLevel::Debug,
+      ("Handling double tap at %s with %p %p\n", ToString(aPoint).c_str(),
+       mBrowserChildMessageManager ? mBrowserChildMessageManager->GetWrapper()
+                                   : nullptr,
+       mBrowserChildMessageManager.get()));
+
+  if (!mBrowserChildMessageManager) {
+    return;
+  }
+
+  // Note: there is nothing to do with the modifiers here, as we are not
+  // synthesizing any sort of mouse event.
+  RefPtr<Document> document = GetTopLevelDocument();
+  ZoomTarget zoomTarget = CalculateRectToZoomTo(document, aPoint);
+  // The double-tap can be dispatched by any scroll frame (so |aGuid| could be
+  // the guid of any scroll frame), but the zoom-to-rect operation must be
+  // performed by the root content scroll frame, so query its identifiers
+  // for the SendZoomToRect() call rather than using the ones from |aGuid|.
+  uint32_t presShellId;
+  ViewID viewId;
+  if (APZCCallbackHelper::GetOrCreateScrollIdentifiers(
+          document->GetDocumentElement(), &presShellId, &viewId) &&
+      mApzcTreeManager) {
+    ScrollableLayerGuid guid(mLayersId, presShellId, viewId);
+
+    mApzcTreeManager->ZoomToRect(guid, zoomTarget,
+                                 ZoomToRectBehavior::DEFAULT_BEHAVIOR);
+  }
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvHandleTap(
+    const GeckoContentController::TapType& aType,
+    const LayoutDevicePoint& aPoint, const Modifiers& aModifiers,
+    const ScrollableLayerGuid& aGuid, const uint64_t& aInputBlockId) {
+  // IPDL doesn't hold a strong reference to protocols as they're not required
+  // to be refcounted. This function can run script, which may trigger a nested
+  // event loop, which may release this, so we hold a strong reference here.
+  RefPtr<BrowserChild> kungFuDeathGrip(this);
+  RefPtr<PresShell> presShell = GetTopLevelPresShell();
+  if (!presShell) {
+    return IPC_OK();
+  }
+  if (!presShell->GetPresContext()) {
+    return IPC_OK();
+  }
+  CSSToLayoutDeviceScale scale(
+      presShell->GetPresContext()->CSSToDevPixelScale());
+  CSSPoint point = aPoint / scale;
+
+  // Stash the guid in InputAPZContext so that when the visual-to-layout
+  // transform is applied to the event's coordinates, we use the right transform
+  // based on the scroll frame being targeted.
+  // The other values don't really matter.
+  InputAPZContext context(aGuid, aInputBlockId, nsEventStatus_eSentinel);
+
+  switch (aType) {
+    case GeckoContentController::TapType::eSingleTap:
+      if (mBrowserChildMessageManager) {
+        mAPZEventState->ProcessSingleTap(point, scale, aModifiers, 1,
+                                         aInputBlockId);
+      }
+      break;
+    case GeckoContentController::TapType::eDoubleTap:
+      HandleDoubleTap(point, aModifiers, aGuid);
+      break;
+    case GeckoContentController::TapType::eSecondTap:
+      if (mBrowserChildMessageManager) {
+        mAPZEventState->ProcessSingleTap(point, scale, aModifiers, 2,
+                                         aInputBlockId);
+      }
+      break;
+    case GeckoContentController::TapType::eLongTap:
+      if (mBrowserChildMessageManager) {
+        RefPtr<APZEventState> eventState(mAPZEventState);
+        eventState->ProcessLongTap(presShell, point, scale, aModifiers,
+                                   aInputBlockId);
+      }
+      break;
+    case GeckoContentController::TapType::eLongTapUp:
+      if (mBrowserChildMessageManager) {
+        RefPtr<APZEventState> eventState(mAPZEventState);
+        eventState->ProcessLongTapUp(presShell, point, scale, aModifiers);
+      }
+      break;
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvNormalPriorityHandleTap(
+    const GeckoContentController::TapType& aType,
+    const LayoutDevicePoint& aPoint, const Modifiers& aModifiers,
+    const ScrollableLayerGuid& aGuid, const uint64_t& aInputBlockId) {
+  // IPDL doesn't hold a strong reference to protocols as they're not required
+  // to be refcounted. This function can run script, which may trigger a nested
+  // event loop, which may release this, so we hold a strong reference here.
+  RefPtr<BrowserChild> kungFuDeathGrip(this);
+  return RecvHandleTap(aType, aPoint, aModifiers, aGuid, aInputBlockId);
+}
+
+bool BrowserChild::NotifyAPZStateChange(
+    const ViewID& aViewId,
+    const layers::GeckoContentController::APZStateChange& aChange,
+    const int& aArg, Maybe<uint64_t> aInputBlockId) {
+  mAPZEventState->ProcessAPZStateChange(aViewId, aChange, aArg, aInputBlockId);
+  nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+  if (aChange ==
+      layers::GeckoContentController::APZStateChange::eTransformEnd) {
+    // This is used by tests to determine when the APZ is done doing whatever
+    // it's doing. XXX generify this as needed when writing additional tests.
+    observerService->NotifyObservers(nullptr, "APZ:TransformEnd", nullptr);
+    observerService->NotifyObservers(nullptr, "PanZoom:StateChange",
+                                     u"NOTHING");
+  } else if (aChange ==
+             layers::GeckoContentController::APZStateChange::eTransformBegin) {
+    observerService->NotifyObservers(nullptr, "PanZoom:StateChange",
+                                     u"PANNING");
+  }
+  return true;
+}
+
+void BrowserChild::StartScrollbarDrag(
+    const layers::AsyncDragMetrics& aDragMetrics) {
+  ScrollableLayerGuid guid(mLayersId, aDragMetrics.mPresShellId,
+                           aDragMetrics.mViewId);
+
+  if (mApzcTreeManager) {
+    mApzcTreeManager->StartScrollbarDrag(guid, aDragMetrics);
+  }
+}
+
+void BrowserChild::ZoomToRect(const uint32_t& aPresShellId,
+                              const ScrollableLayerGuid::ViewID& aViewId,
+                              const CSSRect& aRect, const uint32_t& aFlags) {
+  ScrollableLayerGuid guid(mLayersId, aPresShellId, aViewId);
+
+  if (mApzcTreeManager) {
+    mApzcTreeManager->ZoomToRect(guid, ZoomTarget{aRect}, aFlags);
+  }
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvActivate(uint64_t aActionId) {
+  MOZ_ASSERT(mWebBrowser);
+  mWebBrowser->FocusActivate(aActionId);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvDeactivate(uint64_t aActionId) {
+  MOZ_ASSERT(mWebBrowser);
+  mWebBrowser->FocusDeactivate(aActionId);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvStopIMEStateManagement() {
+  IMEStateManager::StopIMEStateManagement();
+  return IPC_OK();
+}
+
+void BrowserChild::ProcessPendingCoalescedTouchData() {
+  MOZ_ASSERT(StaticPrefs::dom_events_coalesce_touchmove());
+
+  if (mCoalescedTouchData.IsEmpty()) {
+    return;
+  }
+
+  if (mCoalescedTouchMoveEventFlusher) {
+    mCoalescedTouchMoveEventFlusher->RemoveObserver();
+  }
+
+  UniquePtr<WidgetTouchEvent> touchMoveEvent =
+      mCoalescedTouchData.TakeCoalescedEvent();
+  Unused << RecvRealTouchEvent(*touchMoveEvent,
+                               mCoalescedTouchData.GetScrollableLayerGuid(),
+                               mCoalescedTouchData.GetInputBlockId(),
+                               mCoalescedTouchData.GetApzResponse());
+}
+
+void BrowserChild::ProcessPendingCoalescedMouseDataAndDispatchEvents() {
+  if (!mCoalesceMouseMoveEvents || !mCoalescedMouseEventFlusher) {
+    // We don't enable mouse coalescing or we are destroying BrowserChild.
+    return;
+  }
+
+  // We may reentry the event loop and push more data to
+  // mToBeDispatchedMouseData while dispatching an event.
+
+  // We may have some pending coalesced data while dispatch an event and reentry
+  // the event loop. In that case we don't have chance to consume the remainding
+  // pending data until we get new mouse events. Get some helps from
+  // mCoalescedMouseEventFlusher to trigger it.
+  mCoalescedMouseEventFlusher->StartObserver();
+
+  while (mToBeDispatchedMouseData.GetSize() > 0) {
+    UniquePtr<CoalescedMouseData> data(
+        static_cast<CoalescedMouseData*>(mToBeDispatchedMouseData.PopFront()));
+
+    UniquePtr<WidgetMouseEvent> event = data->TakeCoalescedEvent();
+    if (event) {
+      // Dispatch the pending events. Using HandleRealMouseButtonEvent
+      // to bypass the coalesce handling in RecvRealMouseMoveEvent. Can't use
+      // RecvRealMouseButtonEvent because we may also put some mouse events
+      // other than mousemove.
+      HandleRealMouseButtonEvent(*event, data->GetScrollableLayerGuid(),
+                                 data->GetInputBlockId());
+    }
+  }
+  // mCoalescedMouseEventFlusher may be destroyed when reentrying the event
+  // loop.
+  if (mCoalescedMouseEventFlusher) {
+    mCoalescedMouseEventFlusher->RemoveObserver();
+  }
+}
+
+LayoutDeviceToLayoutDeviceMatrix4x4
+BrowserChild::GetChildToParentConversionMatrix() const {
+  if (mChildToParentConversionMatrix) {
+    return *mChildToParentConversionMatrix;
+  }
+  LayoutDevicePoint offset(GetChromeOffset());
+  return LayoutDeviceToLayoutDeviceMatrix4x4::Translation(offset);
+}
+
+Maybe<ScreenRect> BrowserChild::GetTopLevelViewportVisibleRectInBrowserCoords()
+    const {
+  if (!mChildToParentConversionMatrix) {
+    return Nothing();
+  }
+  return Some(mTopLevelViewportVisibleRectInBrowserCoords);
+}
+
+void BrowserChild::FlushAllCoalescedMouseData() {
+  MOZ_ASSERT(mCoalesceMouseMoveEvents);
+
+  // Move all entries from mCoalescedMouseData to mToBeDispatchedMouseData.
+  for (const auto& data : mCoalescedMouseData.Values()) {
+    if (!data || data->IsEmpty()) {
+      continue;
+    }
+    UniquePtr<CoalescedMouseData> dispatchData =
+        MakeUnique<CoalescedMouseData>();
+
+    dispatchData->RetrieveDataFrom(*data);
+    mToBeDispatchedMouseData.Push(dispatchData.release());
+  }
+  mCoalescedMouseData.Clear();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvRealMouseMoveEvent(
+    const WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId) {
+  if (mCoalesceMouseMoveEvents && mCoalescedMouseEventFlusher) {
+    CoalescedMouseData* data =
+        mCoalescedMouseData.GetOrInsertNew(aEvent.pointerId);
+    MOZ_ASSERT(data);
+    if (data->CanCoalesce(aEvent, aGuid, aInputBlockId)) {
+      data->Coalesce(aEvent, aGuid, aInputBlockId);
+      mCoalescedMouseEventFlusher->StartObserver();
+      return IPC_OK();
+    }
+    // Can't coalesce current mousemove event. Put the coalesced mousemove data
+    // with the same pointer id to mToBeDispatchedMouseData, coalesce the
+    // current one, and process all pending data in mToBeDispatchedMouseData.
+    UniquePtr<CoalescedMouseData> dispatchData =
+        MakeUnique<CoalescedMouseData>();
+
+    dispatchData->RetrieveDataFrom(*data);
+    mToBeDispatchedMouseData.Push(dispatchData.release());
+
+    // Put new data to replace the old one in the hash table.
+    CoalescedMouseData* newData =
+        mCoalescedMouseData
+            .InsertOrUpdate(aEvent.pointerId, MakeUnique<CoalescedMouseData>())
+            .get();
+    newData->Coalesce(aEvent, aGuid, aInputBlockId);
+
+    // Dispatch all pending mouse events.
+    ProcessPendingCoalescedMouseDataAndDispatchEvents();
+    mCoalescedMouseEventFlusher->StartObserver();
+  } else if (!RecvRealMouseButtonEvent(aEvent, aGuid, aInputBlockId)) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvRealMouseMoveEventForTests(
+    const WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId) {
+  return RecvRealMouseMoveEvent(aEvent, aGuid, aInputBlockId);
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvNormalPriorityRealMouseMoveEvent(
+    const WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId) {
+  return RecvRealMouseMoveEvent(aEvent, aGuid, aInputBlockId);
+}
+
+mozilla::ipc::IPCResult
+BrowserChild::RecvNormalPriorityRealMouseMoveEventForTests(
+    const WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId) {
+  return RecvRealMouseMoveEvent(aEvent, aGuid, aInputBlockId);
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvSynthMouseMoveEvent(
+    const WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId) {
+  if (!RecvRealMouseButtonEvent(aEvent, aGuid, aInputBlockId)) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvNormalPrioritySynthMouseMoveEvent(
+    const WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId) {
+  return RecvSynthMouseMoveEvent(aEvent, aGuid, aInputBlockId);
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvRealMouseButtonEvent(
+    const WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId) {
+  if (mCoalesceMouseMoveEvents && mCoalescedMouseEventFlusher &&
+      aEvent.mMessage != eMouseMove) {
+    // When receiving a mouse event other than mousemove, we have to dispatch
+    // all coalesced events before it. However, we can't dispatch all pending
+    // coalesced events directly because we may reentry the event loop while
+    // dispatching. To make sure we won't dispatch disorder events, we move all
+    // coalesced mousemove events and current event to a deque to dispatch them.
+    // When reentrying the event loop and dispatching more events, we put new
+    // events in the end of the nsQueue and dispatch events from the beginning.
+    FlushAllCoalescedMouseData();
+
+    UniquePtr<CoalescedMouseData> dispatchData =
+        MakeUnique<CoalescedMouseData>();
+
+    dispatchData->Coalesce(aEvent, aGuid, aInputBlockId);
+    mToBeDispatchedMouseData.Push(dispatchData.release());
+
+    ProcessPendingCoalescedMouseDataAndDispatchEvents();
+    return IPC_OK();
+  }
+  HandleRealMouseButtonEvent(aEvent, aGuid, aInputBlockId);
+  return IPC_OK();
+}
+
+void BrowserChild::HandleRealMouseButtonEvent(const WidgetMouseEvent& aEvent,
+                                              const ScrollableLayerGuid& aGuid,
+                                              const uint64_t& aInputBlockId) {
+  WidgetMouseEvent localEvent(aEvent);
+  localEvent.mWidget = mPuppetWidget;
+
+  // We need one InputAPZContext here to propagate |aGuid| to places in
+  // SendSetTargetAPZCNotification() which apply the visual-to-layout transform,
+  // and another below to propagate the |postLayerization| flag (whose value
+  // we don't know until SendSetTargetAPZCNotification() returns) into
+  // the event dispatch code.
+  InputAPZContext context1(aGuid, aInputBlockId, nsEventStatus_eSentinel);
+
+  // Mouse events like eMouseEnterIntoWidget, that are created in the parent
+  // process EventStateManager code, have an input block id which they get from
+  // the InputAPZContext in the parent process stack. However, they did not
+  // actually go through the APZ code and so their mHandledByAPZ flag is false.
+  // Since thos events didn't go through APZ, we don't need to send
+  // notifications for them.
+  RefPtr<DisplayportSetListener> postLayerization;
+  if (aInputBlockId && localEvent.mFlags.mHandledByAPZ) {
+    nsCOMPtr<Document> document(GetTopLevelDocument());
+    postLayerization = APZCCallbackHelper::SendSetTargetAPZCNotification(
+        mPuppetWidget, document, localEvent, aGuid.mLayersId, aInputBlockId);
+  }
+
+  InputAPZContext context2(aGuid, aInputBlockId, nsEventStatus_eSentinel,
+                           postLayerization != nullptr);
+
+  DispatchWidgetEventViaAPZ(localEvent);
+
+  if (aInputBlockId && localEvent.mFlags.mHandledByAPZ) {
+    mAPZEventState->ProcessMouseEvent(localEvent, aInputBlockId);
+  }
+
+  // Do this after the DispatchWidgetEventViaAPZ call above, so that if the
+  // mouse event triggered a post-refresh AsyncDragMetrics message to be sent
+  // to APZ (from scrollbar dragging in nsSliderFrame), then that will reach
+  // APZ before the SetTargetAPZC message. This ensures the drag input block
+  // gets the drag metrics before handling the input events.
+  if (postLayerization) {
+    postLayerization->Register();
+  }
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvNormalPriorityRealMouseButtonEvent(
+    const WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId) {
+  return RecvRealMouseButtonEvent(aEvent, aGuid, aInputBlockId);
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvRealMouseEnterExitWidgetEvent(
+    const WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId) {
+  return RecvRealMouseButtonEvent(aEvent, aGuid, aInputBlockId);
+}
+
+mozilla::ipc::IPCResult
+BrowserChild::RecvNormalPriorityRealMouseEnterExitWidgetEvent(
+    const WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId) {
+  return RecvRealMouseButtonEvent(aEvent, aGuid, aInputBlockId);
+}
+
+nsEventStatus BrowserChild::DispatchWidgetEventViaAPZ(WidgetGUIEvent& aEvent) {
+  aEvent.ResetWaitingReplyFromRemoteProcessState();
+  return APZCCallbackHelper::DispatchWidgetEvent(aEvent);
+}
+
+void BrowserChild::DispatchCoalescedWheelEvent() {
+  UniquePtr<WidgetWheelEvent> wheelEvent =
+      mCoalescedWheelData.TakeCoalescedEvent();
+  MOZ_ASSERT(wheelEvent);
+  DispatchWheelEvent(*wheelEvent, mCoalescedWheelData.GetScrollableLayerGuid(),
+                     mCoalescedWheelData.GetInputBlockId());
+}
+
+void BrowserChild::DispatchWheelEvent(const WidgetWheelEvent& aEvent,
+                                      const ScrollableLayerGuid& aGuid,
+                                      const uint64_t& aInputBlockId) {
+  WidgetWheelEvent localEvent(aEvent);
+  if (aInputBlockId && aEvent.mFlags.mHandledByAPZ) {
+    nsCOMPtr<Document> document(GetTopLevelDocument());
+    RefPtr<DisplayportSetListener> postLayerization =
+        APZCCallbackHelper::SendSetTargetAPZCNotification(
+            mPuppetWidget, document, aEvent, aGuid.mLayersId, aInputBlockId);
+    if (postLayerization) {
+      postLayerization->Register();
+    }
+  }
+
+  localEvent.mWidget = mPuppetWidget;
+
+  // Stash the guid in InputAPZContext so that when the visual-to-layout
+  // transform is applied to the event's coordinates, we use the right transform
+  // based on the scroll frame being targeted.
+  // The other values don't really matter.
+  InputAPZContext context(aGuid, aInputBlockId, nsEventStatus_eSentinel);
+
+  DispatchWidgetEventViaAPZ(localEvent);
+
+  if (localEvent.mCanTriggerSwipe) {
+    SendRespondStartSwipeEvent(aInputBlockId, localEvent.TriggersSwipe());
+  }
+
+  if (aInputBlockId && aEvent.mFlags.mHandledByAPZ) {
+    mAPZEventState->ProcessWheelEvent(localEvent, aInputBlockId);
+  }
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvMouseWheelEvent(
+    const WidgetWheelEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId) {
+  bool isNextWheelEvent = false;
+  // We only coalesce the current event when
+  // 1. It's eWheel (we don't coalesce eOperationStart and eWheelOperationEnd)
+  // 2. It has same attributes as the coalesced wheel event which is not yet
+  //    fired.
+  if (aEvent.mMessage == eWheel) {
+    GetIPCChannel()->PeekMessages(
+        [&isNextWheelEvent](const IPC::Message& aMsg) -> bool {
+          if (aMsg.type() == mozilla::dom::PBrowser::Msg_MouseWheelEvent__ID) {
+            isNextWheelEvent = true;
+          }
+          return false;  // Stop peeking.
+        });
+
+    if (!mCoalescedWheelData.IsEmpty() &&
+        !mCoalescedWheelData.CanCoalesce(aEvent, aGuid, aInputBlockId)) {
+      DispatchCoalescedWheelEvent();
+      MOZ_ASSERT(mCoalescedWheelData.IsEmpty());
+    }
+    mCoalescedWheelData.Coalesce(aEvent, aGuid, aInputBlockId);
+
+    MOZ_ASSERT(!mCoalescedWheelData.IsEmpty());
+    // If the next event isn't a wheel event, make sure we dispatch.
+    if (!isNextWheelEvent) {
+      DispatchCoalescedWheelEvent();
+    }
+  } else {
+    DispatchWheelEvent(aEvent, aGuid, aInputBlockId);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvNormalPriorityMouseWheelEvent(
+    const WidgetWheelEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId) {
+  return RecvMouseWheelEvent(aEvent, aGuid, aInputBlockId);
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvRealTouchEvent(
+    const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse) {
+  MOZ_LOG(sApzChildLog, LogLevel::Debug,
+          ("Receiving touch event of type %d\n", aEvent.mMessage));
+
+  if (StaticPrefs::dom_events_coalesce_touchmove()) {
+    if (aEvent.mMessage == eTouchEnd || aEvent.mMessage == eTouchStart) {
+      ProcessPendingCoalescedTouchData();
+    }
+
+    if (aEvent.mMessage != eTouchMove) {
+      sConsecutiveTouchMoveCount = 0;
+    }
+  }
+
+  WidgetTouchEvent localEvent(aEvent);
+  localEvent.mWidget = mPuppetWidget;
+
+  // Stash the guid in InputAPZContext so that when the visual-to-layout
+  // transform is applied to the event's coordinates, we use the right transform
+  // based on the scroll frame being targeted.
+  // The other values don't really matter.
+  InputAPZContext context(aGuid, aInputBlockId, aApzResponse);
+
+  nsTArray<TouchBehaviorFlags> allowedTouchBehaviors;
+  if (localEvent.mMessage == eTouchStart && AsyncPanZoomEnabled()) {
+    nsCOMPtr<Document> document = GetTopLevelDocument();
+    allowedTouchBehaviors = TouchActionHelper::GetAllowedTouchBehavior(
+        mPuppetWidget, document, localEvent);
+    if (!allowedTouchBehaviors.IsEmpty() && mApzcTreeManager) {
+      mApzcTreeManager->SetAllowedTouchBehavior(aInputBlockId,
+                                                allowedTouchBehaviors);
+    }
+    RefPtr<DisplayportSetListener> postLayerization =
+        APZCCallbackHelper::SendSetTargetAPZCNotification(
+            mPuppetWidget, document, localEvent, aGuid.mLayersId,
+            aInputBlockId);
+    if (postLayerization) {
+      postLayerization->Register();
+    }
+  }
+
+  // Dispatch event to content (potentially a long-running operation)
+  nsEventStatus status = DispatchWidgetEventViaAPZ(localEvent);
+
+  if (!AsyncPanZoomEnabled()) {
+    // We shouldn't have any e10s platforms that have touch events enabled
+    // without APZ.
+    MOZ_ASSERT(false);
+    return IPC_OK();
+  }
+
+  mAPZEventState->ProcessTouchEvent(localEvent, aGuid, aInputBlockId,
+                                    aApzResponse, status,
+                                    std::move(allowedTouchBehaviors));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvNormalPriorityRealTouchEvent(
+    const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse) {
+  return RecvRealTouchEvent(aEvent, aGuid, aInputBlockId, aApzResponse);
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvRealTouchMoveEvent(
+    const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse) {
+  if (StaticPrefs::dom_events_coalesce_touchmove()) {
+    ++sConsecutiveTouchMoveCount;
+    if (mCoalescedTouchMoveEventFlusher) {
+      MOZ_ASSERT(aEvent.mMessage == eTouchMove);
+      if (mCoalescedTouchData.IsEmpty() ||
+          mCoalescedTouchData.CanCoalesce(aEvent, aGuid, aInputBlockId,
+                                          aApzResponse)) {
+        mCoalescedTouchData.Coalesce(aEvent, aGuid, aInputBlockId,
+                                     aApzResponse);
+      } else {
+        UniquePtr<WidgetTouchEvent> touchMoveEvent =
+            mCoalescedTouchData.TakeCoalescedEvent();
+
+        mCoalescedTouchData.Coalesce(aEvent, aGuid, aInputBlockId,
+                                     aApzResponse);
+
+        if (!RecvRealTouchEvent(*touchMoveEvent,
+                                mCoalescedTouchData.GetScrollableLayerGuid(),
+                                mCoalescedTouchData.GetInputBlockId(),
+                                mCoalescedTouchData.GetApzResponse())) {
+          return IPC_FAIL_NO_REASON(this);
+        }
+      }
+
+      if (sConsecutiveTouchMoveCount > 1) {
+        mCoalescedTouchMoveEventFlusher->StartObserver();
+      } else {
+        // Flush the pending coalesced touch in order to avoid the first
+        // touchmove be overridden by the second one.
+        ProcessPendingCoalescedTouchData();
+      }
+      return IPC_OK();
+    }
+  }
+
+  if (!RecvRealTouchEvent(aEvent, aGuid, aInputBlockId, aApzResponse)) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvNormalPriorityRealTouchMoveEvent(
+    const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
+    const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse) {
+  return RecvRealTouchMoveEvent(aEvent, aGuid, aInputBlockId, aApzResponse);
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvRealDragEvent(
+    const WidgetDragEvent& aEvent, const uint32_t& aDragAction,
+    const uint32_t& aDropEffect, nsIPrincipal* aPrincipal,
+    nsIContentSecurityPolicy* aCsp) {
+  WidgetDragEvent localEvent(aEvent);
+  localEvent.mWidget = mPuppetWidget;
+
+  nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession();
+  if (dragSession) {
+    dragSession->SetDragAction(aDragAction);
+    dragSession->SetTriggeringPrincipal(aPrincipal);
+    dragSession->SetCsp(aCsp);
+    RefPtr<DataTransfer> initialDataTransfer = dragSession->GetDataTransfer();
+    if (initialDataTransfer) {
+      initialDataTransfer->SetDropEffectInt(aDropEffect);
+    }
+  }
+
+  if (aEvent.mMessage == eDrop) {
+    bool canDrop = true;
+    if (!dragSession || NS_FAILED(dragSession->GetCanDrop(&canDrop)) ||
+        !canDrop) {
+      localEvent.mMessage = eDragExit;
+    }
+  } else if (aEvent.mMessage == eDragOver) {
+    nsCOMPtr<nsIDragService> dragService =
+        do_GetService("@mozilla.org/widget/dragservice;1");
+    if (dragService) {
+      // This will dispatch 'drag' event at the source if the
+      // drag transaction started in this process.
+      dragService->FireDragEventAtSource(eDrag, aEvent.mModifiers);
+    }
+  }
+
+  DispatchWidgetEventViaAPZ(localEvent);
+  return IPC_OK();
+}
+
+void BrowserChild::RequestEditCommands(NativeKeyBindingsType aType,
+                                       const WidgetKeyboardEvent& aEvent,
+                                       nsTArray<CommandInt>& aCommands) {
+  MOZ_ASSERT(aCommands.IsEmpty());
+
+  if (NS_WARN_IF(aEvent.IsEditCommandsInitialized(aType))) {
+    aCommands = aEvent.EditCommandsConstRef(aType).Clone();
+    return;
+  }
+
+  switch (aType) {
+    case NativeKeyBindingsType::SingleLineEditor:
+    case NativeKeyBindingsType::MultiLineEditor:
+    case NativeKeyBindingsType::RichTextEditor:
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Invalid native key bindings type");
+  }
+
+  // Don't send aEvent to the parent process directly because it'll be marked
+  // as posted to remote process.
+  WidgetKeyboardEvent localEvent(aEvent);
+  SendRequestNativeKeyBindings(static_cast<uint32_t>(aType), localEvent,
+                               &aCommands);
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvNativeSynthesisResponse(
+    const uint64_t& aObserverId, const nsCString& aResponse) {
+  mozilla::widget::AutoObserverNotifier::NotifySavedObserver(aObserverId,
+                                                             aResponse.get());
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvUpdateSHistory() {
+  if (mSessionStoreChild) {
+    mSessionStoreChild->UpdateSHistoryChanges();
+  }
+  return IPC_OK();
+}
+
+// In case handling repeated keys takes much time, we skip firing new ones.
+bool BrowserChild::SkipRepeatedKeyEvent(const WidgetKeyboardEvent& aEvent) {
+  if (mRepeatedKeyEventTime.IsNull() || !aEvent.CanSkipInRemoteProcess() ||
+      (aEvent.mMessage != eKeyDown && aEvent.mMessage != eKeyPress)) {
+    mRepeatedKeyEventTime = TimeStamp();
+    mSkipKeyPress = false;
+    return false;
+  }
+
+  if ((aEvent.mMessage == eKeyDown &&
+       (mRepeatedKeyEventTime > aEvent.mTimeStamp)) ||
+      (mSkipKeyPress && (aEvent.mMessage == eKeyPress))) {
+    // If we skip a keydown event, also the following keypress events should be
+    // skipped.
+    mSkipKeyPress |= aEvent.mMessage == eKeyDown;
+    return true;
+  }
+
+  if (aEvent.mMessage == eKeyDown) {
+    // If keydown wasn't skipped, nor should the possible following keypress.
+    mRepeatedKeyEventTime = TimeStamp();
+    mSkipKeyPress = false;
+  }
+  return false;
+}
+
+void BrowserChild::UpdateRepeatedKeyEventEndTime(
+    const WidgetKeyboardEvent& aEvent) {
+  if (aEvent.mIsRepeat &&
+      (aEvent.mMessage == eKeyDown || aEvent.mMessage == eKeyPress)) {
+    mRepeatedKeyEventTime = TimeStamp::Now();
+  }
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvRealKeyEvent(
+    const WidgetKeyboardEvent& aEvent, const nsID& aUUID) {
+  MOZ_ASSERT_IF(aEvent.mMessage == eKeyPress,
+                aEvent.AreAllEditCommandsInitialized());
+
+  // If content code called preventDefault() on a keydown event, then we don't
+  // want to process any following keypress events.
+  const bool isPrecedingKeyDownEventConsumed =
+      aEvent.mMessage == eKeyPress && mIgnoreKeyPressEvent;
+
+  WidgetKeyboardEvent localEvent(aEvent);
+  localEvent.mWidget = mPuppetWidget;
+  localEvent.mUniqueId = aEvent.mUniqueId;
+
+  if (!SkipRepeatedKeyEvent(aEvent) && !isPrecedingKeyDownEventConsumed) {
+    nsEventStatus status = DispatchWidgetEventViaAPZ(localEvent);
+
+    // Update the end time of the possible repeated event so that we can skip
+    // some incoming events in case event handling took long time.
+    UpdateRepeatedKeyEventEndTime(localEvent);
+
+    if (aEvent.mMessage == eKeyDown) {
+      mIgnoreKeyPressEvent = status == nsEventStatus_eConsumeNoDefault;
+    }
+
+    if (localEvent.mFlags.mIsSuppressedOrDelayed) {
+      localEvent.PreventDefault();
+    }
+
+    // If the event's default isn't prevented but the status is no default,
+    // That means that the event was consumed by EventStateManager or something
+    // which is not a usual event handler.  In such case, prevent its default
+    // as a default handler.  For example, when an eKeyPress event matches
+    // with a content accesskey, and it's executed, preventDefault() of the
+    // event won't be called but the status is set to "no default".  Then,
+    // the event shouldn't be handled by nsMenuBarListener in the main process.
+    if (!localEvent.DefaultPrevented() &&
+        status == nsEventStatus_eConsumeNoDefault) {
+      localEvent.PreventDefault();
+    }
+
+    MOZ_DIAGNOSTIC_ASSERT(!localEvent.PropagationStopped());
+  }
+  // The keyboard event which we ignore should not be handled in the main
+  // process for shortcut key handling.  For notifying if we skipped it, we can
+  // use "stop propagation" flag here because it must be cleared by
+  // `EventTargetChainItem` if we've dispatched it.
+  else {
+    localEvent.StopPropagation();
+  }
+
+  // If we don't need to send a rely for the given keyboard event, we do nothing
+  // anymore here.
+  if (!aEvent.WantReplyFromContentProcess()) {
+    return IPC_OK();
+  }
+
+  // This is an ugly hack, mNoRemoteProcessDispatch is set to true when the
+  // event's PreventDefault() or StopScrollProcessForwarding() is called.
+  // And then, it'll be checked by ParamTraits<mozilla::WidgetEvent>::Write()
+  // whether the event is being sent to remote process unexpectedly.
+  // However, unfortunately, it cannot check the destination.  Therefore,
+  // we need to clear the flag explicitly here because ParamTraits should
+  // keep checking the flag for avoiding regression.
+  localEvent.mFlags.mNoRemoteProcessDispatch = false;
+  SendReplyKeyEvent(localEvent, aUUID);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvNormalPriorityRealKeyEvent(
+    const WidgetKeyboardEvent& aEvent, const nsID& aUUID) {
+  return RecvRealKeyEvent(aEvent, aUUID);
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvCompositionEvent(
+    const WidgetCompositionEvent& aEvent) {
+  WidgetCompositionEvent localEvent(aEvent);
+  localEvent.mWidget = mPuppetWidget;
+  DispatchWidgetEventViaAPZ(localEvent);
+  Unused << SendOnEventNeedingAckHandled(aEvent.mMessage);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvNormalPriorityCompositionEvent(
+    const WidgetCompositionEvent& aEvent) {
+  return RecvCompositionEvent(aEvent);
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvSelectionEvent(
+    const WidgetSelectionEvent& aEvent) {
+  WidgetSelectionEvent localEvent(aEvent);
+  localEvent.mWidget = mPuppetWidget;
+  DispatchWidgetEventViaAPZ(localEvent);
+  Unused << SendOnEventNeedingAckHandled(aEvent.mMessage);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvNormalPrioritySelectionEvent(
+    const WidgetSelectionEvent& aEvent) {
+  return RecvSelectionEvent(aEvent);
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvInsertText(
+    const nsAString& aStringToInsert) {
+  // Use normal event path to reach focused document.
+  WidgetContentCommandEvent localEvent(true, eContentCommandInsertText,
+                                       mPuppetWidget);
+  localEvent.mString = Some(nsString(aStringToInsert));
+  DispatchWidgetEventViaAPZ(localEvent);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvNormalPriorityInsertText(
+    const nsAString& aStringToInsert) {
+  return RecvInsertText(aStringToInsert);
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvPasteTransferable(
+    const IPCTransferableData& aTransferableData, const bool& aIsPrivateData,
+    nsIPrincipal* aRequestingPrincipal,
+    const nsContentPolicyType& aContentPolicyType) {
+  nsresult rv;
+  nsCOMPtr<nsITransferable> trans =
+      do_CreateInstance("@mozilla.org/widget/transferable;1", &rv);
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+  trans->Init(nullptr);
+
+  rv = nsContentUtils::IPCTransferableDataToTransferable(
+      aTransferableData, aIsPrivateData, aRequestingPrincipal,
+      aContentPolicyType, true /* aAddDataFlavor */, trans,
+      false /* aFilterUnknownFlavors */);
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+
+  nsCOMPtr<nsIDocShell> ourDocShell = do_GetInterface(WebNavigation());
+  if (NS_WARN_IF(!ourDocShell)) {
+    return IPC_OK();
+  }
+
+  RefPtr<nsCommandParams> params = new nsCommandParams();
+  rv = params->SetISupports("transferable", trans);
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+
+  ourDocShell->DoCommandWithParams("cmd_pasteTransferable", params);
+  return IPC_OK();
+}
+
+#ifdef ACCESSIBILITY
+a11y::PDocAccessibleChild* BrowserChild::AllocPDocAccessibleChild(
+    PDocAccessibleChild*, const uint64_t&,
+    const MaybeDiscardedBrowsingContext&) {
+  MOZ_ASSERT(false, "should never call this!");
+  return nullptr;
+}
+
+bool BrowserChild::DeallocPDocAccessibleChild(
+    a11y::PDocAccessibleChild* aChild) {
+  delete static_cast<mozilla::a11y::DocAccessibleChild*>(aChild);
+  return true;
+}
+#endif
+
+RefPtr<VsyncMainChild> BrowserChild::GetVsyncChild() {
+  // Initializing mVsyncChild here turns on per-BrowserChild Vsync for a
+  // given platform. Note: this only makes sense if nsWindow returns a
+  // window-specific VsyncSource.
+#if defined(MOZ_WAYLAND)
+  if (IsWaylandEnabled() && !mVsyncChild) {
+    mVsyncChild = MakeRefPtr<VsyncMainChild>();
+    if (!SendPVsyncConstructor(mVsyncChild)) {
+      mVsyncChild = nullptr;
+    }
+  }
+#endif
+  return mVsyncChild;
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvLoadRemoteScript(
+    const nsAString& aURL, const bool& aRunInGlobalScope) {
+  if (!InitBrowserChildMessageManager())
+    // This can happen if we're half-destroyed.  It's not a fatal
+    // error.
+    return IPC_OK();
+
+  JS::Rooted<JSObject*> mm(RootingCx(),
+                           mBrowserChildMessageManager->GetOrCreateWrapper());
+  if (!mm) {
+    // This can happen if we're half-destroyed.  It's not a fatal error.
+    return IPC_OK();
+  }
+
+  LoadScriptInternal(mm, aURL, !aRunInGlobalScope);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvAsyncMessage(
+    const nsAString& aMessage, const ClonedMessageData& aData) {
+  AUTO_PROFILER_LABEL_DYNAMIC_LOSSY_NSSTRING("BrowserChild::RecvAsyncMessage",
+                                             OTHER, aMessage);
+  MMPrinter::Print("BrowserChild::RecvAsyncMessage", aMessage, aData);
+
+  if (!mBrowserChildMessageManager) {
+    return IPC_OK();
+  }
+
+  RefPtr<nsFrameMessageManager> mm =
+      mBrowserChildMessageManager->GetMessageManager();
+
+  // We should have a message manager if the global is alive, but it
+  // seems sometimes we don't.  Assert in aurora/nightly, but don't
+  // crash in release builds.
+  MOZ_DIAGNOSTIC_ASSERT(mm);
+  if (!mm) {
+    return IPC_OK();
+  }
+
+  JS::Rooted<JSObject*> kungFuDeathGrip(
+      dom::RootingCx(), mBrowserChildMessageManager->GetWrapper());
+  StructuredCloneData data;
+  UnpackClonedMessageData(aData, data);
+  mm->ReceiveMessage(static_cast<EventTarget*>(mBrowserChildMessageManager),
+                     nullptr, aMessage, false, &data, nullptr, IgnoreErrors());
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvSwappedWithOtherRemoteLoader(
+    const IPCTabContext& aContext) {
+  nsCOMPtr<nsIDocShell> ourDocShell = do_GetInterface(WebNavigation());
+  if (NS_WARN_IF(!ourDocShell)) {
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> ourWindow = ourDocShell->GetWindow();
+  if (NS_WARN_IF(!ourWindow)) {
+    return IPC_OK();
+  }
+
+  RefPtr<nsDocShell> docShell = static_cast<nsDocShell*>(ourDocShell.get());
+
+  nsCOMPtr<EventTarget> ourEventTarget = nsGlobalWindowOuter::Cast(ourWindow);
+
+  docShell->SetInFrameSwap(true);
+
+  nsContentUtils::FirePageShowEventForFrameLoaderSwap(
+      ourDocShell, ourEventTarget, false, true);
+  nsContentUtils::FirePageHideEventForFrameLoaderSwap(ourDocShell,
+                                                      ourEventTarget, true);
+
+  // Owner content type may have changed, so store the possibly updated context
+  // and notify others.
+  MaybeInvalidTabContext maybeContext(aContext);
+  if (!maybeContext.IsValid()) {
+    NS_ERROR(nsPrintfCString("Received an invalid TabContext from "
+                             "the parent process. (%s)",
+                             maybeContext.GetInvalidReason())
+                 .get());
+    MOZ_CRASH("Invalid TabContext received from the parent process.");
+  }
+
+  if (!UpdateTabContextAfterSwap(maybeContext.GetTabContext())) {
+    MOZ_CRASH("Update to TabContext after swap was denied.");
+  }
+
+  // Ignore previous value of mTriedBrowserInit since owner content has changed.
+  mTriedBrowserInit = true;
+
+  nsContentUtils::FirePageShowEventForFrameLoaderSwap(
+      ourDocShell, ourEventTarget, true, true);
+
+  docShell->SetInFrameSwap(false);
+
+  // This is needed to get visibility state right in cases when we swapped a
+  // visible tab (foreground in visible window) with a non-visible tab.
+  if (RefPtr<Document> doc = docShell->GetDocument()) {
+    doc->UpdateVisibilityState();
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvHandleAccessKey(
+    const WidgetKeyboardEvent& aEvent, nsTArray<uint32_t>&& aCharCodes) {
+  nsCOMPtr<Document> document(GetTopLevelDocument());
+  RefPtr<nsPresContext> pc = document->GetPresContext();
+  if (pc) {
+    if (!pc->EventStateManager()->HandleAccessKey(
+            &(const_cast<WidgetKeyboardEvent&>(aEvent)), pc, aCharCodes)) {
+      // If no accesskey was found, inform the parent so that accesskeys on
+      // menus can be handled.
+      WidgetKeyboardEvent localEvent(aEvent);
+      localEvent.mWidget = mPuppetWidget;
+      SendAccessKeyNotHandled(localEvent);
+    }
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvPrintPreview(
+    const PrintData& aPrintData, const MaybeDiscardedBrowsingContext& aSourceBC,
+    PrintPreviewResolver&& aCallback) {
+#ifdef NS_PRINTING
+  // If we didn't succeed in passing off ownership of aCallback, then something
+  // went wrong.
+  auto sendCallbackError = MakeScopeExit([&] {
+    if (aCallback) {
+      // signal error
+      aCallback(PrintPreviewResultInfo(0, 0, false, false, false, {}, {}, {}));
+    }
+  });
+
+  if (NS_WARN_IF(aSourceBC.IsDiscarded())) {
+    return IPC_OK();
+  }
+
+  RefPtr<nsGlobalWindowOuter> sourceWindow;
+  if (!aSourceBC.IsNull()) {
+    sourceWindow = nsGlobalWindowOuter::Cast(aSourceBC.get()->GetDOMWindow());
+    if (NS_WARN_IF(!sourceWindow)) {
+      return IPC_OK();
+    }
+  } else {
+    nsCOMPtr<nsPIDOMWindowOuter> ourWindow = do_GetInterface(WebNavigation());
+    if (NS_WARN_IF(!ourWindow)) {
+      return IPC_OK();
+    }
+    sourceWindow = nsGlobalWindowOuter::Cast(ourWindow);
+  }
+
+  RefPtr<nsIPrintSettings> printSettings;
+  nsCOMPtr<nsIPrintSettingsService> printSettingsSvc =
+      do_GetService("@mozilla.org/gfx/printsettings-service;1");
+  if (NS_WARN_IF(!printSettingsSvc)) {
+    return IPC_OK();
+  }
+  printSettingsSvc->CreateNewPrintSettings(getter_AddRefs(printSettings));
+  if (NS_WARN_IF(!printSettings)) {
+    return IPC_OK();
+  }
+  printSettingsSvc->DeserializeToPrintSettings(aPrintData, printSettings);
+
+  nsCOMPtr<nsIDocShell> docShellToCloneInto;
+  if (!aSourceBC.IsNull()) {
+    docShellToCloneInto = do_GetInterface(WebNavigation());
+    if (NS_WARN_IF(!docShellToCloneInto)) {
+      return IPC_OK();
+    }
+  }
+
+  sourceWindow->Print(printSettings,
+                      /* aRemotePrintJob = */ nullptr,
+                      /* aListener = */ nullptr, docShellToCloneInto,
+                      nsGlobalWindowOuter::IsPreview::Yes,
+                      nsGlobalWindowOuter::IsForWindowDotPrint::No,
+                      std::move(aCallback), IgnoreErrors());
+#endif
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvExitPrintPreview() {
+#ifdef NS_PRINTING
+  nsCOMPtr<nsIWebBrowserPrint> webBrowserPrint =
+      do_GetInterface(ToSupports(WebNavigation()));
+  if (NS_WARN_IF(!webBrowserPrint)) {
+    return IPC_OK();
+  }
+  webBrowserPrint->ExitPrintPreview();
+#endif
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvPrint(
+    const MaybeDiscardedBrowsingContext& aBc, const PrintData& aPrintData) {
+#ifdef NS_PRINTING
+  if (NS_WARN_IF(aBc.IsNullOrDiscarded())) {
+    return IPC_OK();
+  }
+  RefPtr<nsGlobalWindowOuter> outerWindow =
+      nsGlobalWindowOuter::Cast(aBc.get()->GetDOMWindow());
+  if (NS_WARN_IF(!outerWindow)) {
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIPrintSettingsService> printSettingsSvc =
+      do_GetService("@mozilla.org/gfx/printsettings-service;1");
+  if (NS_WARN_IF(!printSettingsSvc)) {
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIPrintSettings> printSettings;
+  nsresult rv =
+      printSettingsSvc->CreateNewPrintSettings(getter_AddRefs(printSettings));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return IPC_OK();
+  }
+
+  printSettingsSvc->DeserializeToPrintSettings(aPrintData, printSettings);
+  {
+    IgnoredErrorResult rv;
+    RefPtr printJob = static_cast<RemotePrintJobChild*>(
+        aPrintData.remotePrintJob().AsChild());
+    outerWindow->Print(printSettings, printJob,
+                       /* aListener = */ nullptr,
+                       /* aWindowToCloneInto = */ nullptr,
+                       nsGlobalWindowOuter::IsPreview::No,
+                       nsGlobalWindowOuter::IsForWindowDotPrint::No,
+                       /* aPrintPreviewCallback = */ nullptr, rv);
+    if (NS_WARN_IF(rv.Failed())) {
+      return IPC_OK();
+    }
+  }
+#endif
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvUpdateNativeWindowHandle(
+    const uintptr_t& aNewHandle) {
+#if defined(XP_WIN) && defined(ACCESSIBILITY)
+  mNativeWindowHandle = aNewHandle;
+  return IPC_OK();
+#else
+  return IPC_FAIL_NO_REASON(this);
+#endif
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvDestroy() {
+  MOZ_ASSERT(mDestroyed == false);
+  mDestroyed = true;
+
+  nsTArray<PContentPermissionRequestChild*> childArray =
+      nsContentPermissionUtils::GetContentPermissionRequestChildById(
+          GetTabId());
+
+  // Need to close undeleted ContentPermissionRequestChilds before tab is
+  // closed.
+  for (auto& permissionRequestChild : childArray) {
+    auto child = static_cast<RemotePermissionRequest*>(permissionRequestChild);
+    child->Destroy();
+  }
+
+  if (mBrowserChildMessageManager) {
+    // Message handlers are called from the event loop, so it better be safe to
+    // run script.
+    MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
+    mBrowserChildMessageManager->DispatchTrustedEvent(u"unload"_ns);
+  }
+
+  nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+
+  observerService->RemoveObserver(this, BEFORE_FIRST_PAINT);
+
+  // XXX what other code in ~BrowserChild() should we be running here?
+  DestroyWindow();
+
+  // Bounce through the event loop once to allow any delayed teardown runnables
+  // that were just generated to have a chance to run.
+  nsCOMPtr<nsIRunnable> deleteRunnable = new DelayedDeleteRunnable(this);
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(deleteRunnable));
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvRenderLayers(
+    const bool& aEnabled, const layers::LayersObserverEpoch& aEpoch) {
+  // Since requests to change the rendering state come in from both the hang
+  // monitor channel and the PContent channel, we have an ordering problem. This
+  // code ensures that we respect the order in which the requests were made and
+  // ignore stale requests.
+  if (mLayersObserverEpoch >= aEpoch) {
+    return IPC_OK();
+  }
+  mLayersObserverEpoch = aEpoch;
+
+  auto clearPaintWhileInterruptingJS = MakeScopeExit([&] {
+    // We might force a paint, or we might already have painted and this is a
+    // no-op. In either case, once we exit this scope, we need to alert the
+    // ProcessHangMonitor that we've finished responding to what might have
+    // been a request to force paint. This is so that the BackgroundHangMonitor
+    // for force painting can be made to wait again.
+    if (aEnabled) {
+      ProcessHangMonitor::ClearPaintWhileInterruptingJS(mLayersObserverEpoch);
+    }
+  });
+
+  if (aEnabled) {
+    ProcessHangMonitor::MaybeStartPaintWhileInterruptingJS();
+  }
+
+  if (mCompositorOptions) {
+    MOZ_ASSERT(mPuppetWidget);
+    RefPtr<WebRenderLayerManager> lm =
+        mPuppetWidget->GetWindowRenderer()->AsWebRender();
+    if (lm) {
+      // We send the current layer observer epoch to the compositor so that
+      // BrowserParent knows whether a layer update notification corresponds to
+      // the latest RecvRenderLayers request that was made.
+      lm->SetLayersObserverEpoch(mLayersObserverEpoch);
+    }
+  }
+
+  mRenderLayers = aEnabled;
+
+  if (aEnabled && IsVisible()) {
+    // This request is a no-op.
+    // In this case, we still want a MozLayerTreeReady notification to fire
+    // in the parent (so that it knows that the child has updated its epoch).
+    // PaintWhileInterruptingJSNoOp does that.
+    if (IPCOpen()) {
+      Unused << SendPaintWhileInterruptingJSNoOp(mLayersObserverEpoch);
+    }
+    return IPC_OK();
+  }
+
+  // FIXME(emilio): Probably / maybe this shouldn't be needed? See the comment
+  // in MakeVisible(), having the two separate states is not great.
+  UpdateVisibility();
+
+  if (!aEnabled) {
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIDocShell> docShell = do_GetInterface(WebNavigation());
+  if (!docShell) {
+    return IPC_OK();
+  }
+
+  // We don't use BrowserChildBase::GetPresShell() here because that would
+  // create a content viewer if one doesn't exist yet. Creating a content
+  // viewer can cause JS to run, which we want to avoid.
+  // nsIDocShell::GetPresShell returns null if no content viewer exists yet.
+  RefPtr<PresShell> presShell = docShell->GetPresShell();
+  if (!presShell) {
+    return IPC_OK();
+  }
+
+  if (nsIFrame* root = presShell->GetRootFrame()) {
+    root->SchedulePaint();
+  }
+
+  Telemetry::AutoTimer<Telemetry::TABCHILD_PAINT_TIME> timer;
+  // If we need to repaint, let's do that right away. No sense waiting until
+  // we get back to the event loop again. We suppress the display port so
+  // that we only paint what's visible. This ensures that the tab we're
+  // switching to paints as quickly as possible.
+  presShell->SuppressDisplayport(true);
+  if (nsContentUtils::IsSafeToRunScript()) {
+    WebWidget()->PaintNowIfNeeded();
+  } else {
+    RefPtr<nsViewManager> vm = presShell->GetViewManager();
+    if (nsView* view = vm->GetRootView()) {
+      presShell->PaintAndRequestComposite(view, PaintFlags::None);
+    }
+  }
+  presShell->SuppressDisplayport(false);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvNavigateByKey(
+    const bool& aForward, const bool& aForDocumentNavigation) {
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (!fm) {
+    return IPC_OK();
+  }
+
+  RefPtr<Element> result;
+  nsCOMPtr<nsPIDOMWindowOuter> window = do_GetInterface(WebNavigation());
+
+  // Move to the first or last document.
+  {
+    uint32_t type =
+        aForward
+            ? (aForDocumentNavigation
+                   ? static_cast<uint32_t>(nsIFocusManager::MOVEFOCUS_FIRSTDOC)
+                   : static_cast<uint32_t>(nsIFocusManager::MOVEFOCUS_ROOT))
+            : (aForDocumentNavigation
+                   ? static_cast<uint32_t>(nsIFocusManager::MOVEFOCUS_LASTDOC)
+                   : static_cast<uint32_t>(nsIFocusManager::MOVEFOCUS_LAST));
+    uint32_t flags = nsIFocusManager::FLAG_BYKEY;
+    if (aForward || aForDocumentNavigation) {
+      flags |= nsIFocusManager::FLAG_NOSCROLL;
+    }
+    fm->MoveFocus(window, nullptr, type, flags, getter_AddRefs(result));
+  }
+
+  // No valid root element was found, so move to the first focusable element.
+  if (!result && aForward && !aForDocumentNavigation) {
+    fm->MoveFocus(window, nullptr, nsIFocusManager::MOVEFOCUS_FIRST,
+                  nsIFocusManager::FLAG_BYKEY, getter_AddRefs(result));
+  }
+
+  SendRequestFocus(false, CallerType::System);
+  return IPC_OK();
+}
+
+bool BrowserChild::InitBrowserChildMessageManager() {
+  mShouldSendWebProgressEventsToParent = true;
+
+  if (!mBrowserChildMessageManager) {
+    nsCOMPtr<nsPIDOMWindowOuter> window = do_GetInterface(WebNavigation());
+    NS_ENSURE_TRUE(window, false);
+    nsCOMPtr<EventTarget> chromeHandler = window->GetChromeEventHandler();
+    NS_ENSURE_TRUE(chromeHandler, false);
+
+    RefPtr<BrowserChildMessageManager> scope = mBrowserChildMessageManager =
+        new BrowserChildMessageManager(this);
+
+    MOZ_ALWAYS_TRUE(nsMessageManagerScriptExecutor::Init());
+
+    nsCOMPtr<nsPIWindowRoot> root = do_QueryInterface(chromeHandler);
+    if (NS_WARN_IF(!root)) {
+      mBrowserChildMessageManager = nullptr;
+      return false;
+    }
+    root->SetParentTarget(scope);
+  }
+
+  if (!mTriedBrowserInit) {
+    mTriedBrowserInit = true;
+  }
+
+  return true;
+}
+
+void BrowserChild::InitRenderingState(
+    const TextureFactoryIdentifier& aTextureFactoryIdentifier,
+    const layers::LayersId& aLayersId,
+    const CompositorOptions& aCompositorOptions) {
+  mPuppetWidget->InitIMEState();
+
+  MOZ_ASSERT(aLayersId.IsValid());
+  mTextureFactoryIdentifier = aTextureFactoryIdentifier;
+
+  // Pushing layers transactions directly to a separate
+  // compositor context.
+  PCompositorBridgeChild* compositorChild = CompositorBridgeChild::Get();
+  if (!compositorChild) {
+    mLayersConnected = Some(false);
+    NS_WARNING("failed to get CompositorBridgeChild instance");
+    return;
+  }
+
+  mCompositorOptions = Some(aCompositorOptions);
+
+  if (aLayersId.IsValid()) {
+    StaticMutexAutoLock lock(sBrowserChildrenMutex);
+
+    if (!sBrowserChildren) {
+      sBrowserChildren = new BrowserChildMap;
+    }
+    MOZ_ASSERT(!sBrowserChildren->Contains(uint64_t(aLayersId)));
+    sBrowserChildren->InsertOrUpdate(uint64_t(aLayersId), this);
+    mLayersId = aLayersId;
+  }
+
+  // Depending on timing, we might paint too early and fall back to basic
+  // layers. CreateRemoteLayerManager will destroy us if we manage to get a
+  // remote layer manager though, so that's fine.
+  MOZ_ASSERT(!mPuppetWidget->HasWindowRenderer() ||
+             mPuppetWidget->GetWindowRenderer()->GetBackendType() ==
+                 layers::LayersBackend::LAYERS_NONE);
+  bool success = false;
+  if (mLayersConnected == Some(true)) {
+    success = CreateRemoteLayerManager(compositorChild);
+  }
+
+  if (success) {
+    MOZ_ASSERT(mLayersConnected == Some(true));
+    // Succeeded to create "remote" layer manager
+    ImageBridgeChild::IdentifyCompositorTextureHost(mTextureFactoryIdentifier);
+    gfx::VRManagerChild::IdentifyTextureHost(mTextureFactoryIdentifier);
+    InitAPZState();
+    RefPtr<WebRenderLayerManager> lm =
+        mPuppetWidget->GetWindowRenderer()->AsWebRender();
+    if (lm) {
+      lm->SetLayersObserverEpoch(mLayersObserverEpoch);
+    }
+  } else {
+    NS_WARNING("Fallback to FallbackRenderer");
+    mLayersConnected = Some(false);
+  }
+
+  nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+
+  if (observerService) {
+    observerService->AddObserver(this, BEFORE_FIRST_PAINT, false);
+  }
+}
+
+bool BrowserChild::CreateRemoteLayerManager(
+    mozilla::layers::PCompositorBridgeChild* aCompositorChild) {
+  MOZ_ASSERT(aCompositorChild);
+
+  return mPuppetWidget->CreateRemoteLayerManager(
+      [&](WebRenderLayerManager* aLayerManager) -> bool {
+        nsCString error;
+        return aLayerManager->Initialize(aCompositorChild,
+                                         wr::AsPipelineId(mLayersId),
+                                         &mTextureFactoryIdentifier, error);
+      });
+}
+
+void BrowserChild::InitAPZState() {
+  if (!mCompositorOptions->UseAPZ()) {
+    return;
+  }
+  auto cbc = CompositorBridgeChild::Get();
+
+  // Initialize the ApzcTreeManager. This takes multiple casts because of ugly
+  // multiple inheritance.
+  PAPZCTreeManagerChild* baseProtocol =
+      cbc->SendPAPZCTreeManagerConstructor(mLayersId);
+  if (!baseProtocol) {
+    MOZ_ASSERT(false,
+               "Allocating a TreeManager should not fail with APZ enabled");
+    return;
+  }
+  APZCTreeManagerChild* derivedProtocol =
+      static_cast<APZCTreeManagerChild*>(baseProtocol);
+
+  mApzcTreeManager = RefPtr<IAPZCTreeManager>(derivedProtocol);
+
+  // Initialize the GeckoContentController for this tab. We don't hold a
+  // reference because we don't need it. The ContentProcessController will hold
+  // a reference to the tab, and will be destroyed by the compositor or ipdl
+  // during destruction.
+  RefPtr<GeckoContentController> contentController =
+      new ContentProcessController(this);
+  APZChild* apzChild = new APZChild(contentController);
+  cbc->SendPAPZConstructor(apzChild, mLayersId);
+}
+
+IPCResult BrowserChild::RecvUpdateEffects(const EffectsInfo& aEffects) {
+  mDidSetEffectsInfo = true;
+
+  bool needInvalidate = false;
+  if (mEffectsInfo.IsVisible() && aEffects.IsVisible() &&
+      mEffectsInfo != aEffects) {
+    // if we are staying visible and either the visrect or scale changed we need
+    // to invalidate
+    needInvalidate = true;
+  }
+
+  mEffectsInfo = aEffects;
+  UpdateVisibility();
+
+  if (needInvalidate) {
+    nsCOMPtr<nsIDocShell> docShell = do_GetInterface(WebNavigation());
+    if (docShell) {
+      // We don't use BrowserChildBase::GetPresShell() here because that would
+      // create a content viewer if one doesn't exist yet. Creating a content
+      // viewer can cause JS to run, which we want to avoid.
+      // nsIDocShell::GetPresShell returns null if no content viewer exists yet.
+      RefPtr<PresShell> presShell = docShell->GetPresShell();
+      if (presShell) {
+        if (nsIFrame* root = presShell->GetRootFrame()) {
+          root->InvalidateFrame();
+        }
+      }
+    }
+  }
+
+  return IPC_OK();
+}
+
+bool BrowserChild::IsVisible() {
+  return mPuppetWidget && mPuppetWidget->IsVisible();
+}
+
+void BrowserChild::UpdateVisibility() {
+  bool shouldBeVisible = mIsTopLevel ? mRenderLayers : mEffectsInfo.IsVisible();
+  bool isVisible = IsVisible();
+
+  if (shouldBeVisible != isVisible) {
+    if (shouldBeVisible) {
+      MakeVisible();
+    } else {
+      MakeHidden();
+    }
+  }
+}
+
+void BrowserChild::MakeVisible() {
+  if (IsVisible()) {
+    return;
+  }
+
+  if (mPuppetWidget) {
+    mPuppetWidget->Show(true);
+  }
+
+  PresShellActivenessMaybeChanged();
+}
+
+void BrowserChild::MakeHidden() {
+  if (!IsVisible()) {
+    return;
+  }
+
+  // Due to the nested event loop in ContentChild::ProvideWindowCommon,
+  // it's possible to be told to become hidden before we're finished
+  // setting up a layer manager. We should skip clearing cached layers
+  // in that case, since doing so might accidentally put is into
+  // BasicLayers mode.
+  if (mPuppetWidget) {
+    if (mPuppetWidget->HasWindowRenderer()) {
+      ClearCachedResources();
+    }
+    mPuppetWidget->Show(false);
+  }
+
+  PresShellActivenessMaybeChanged();
+}
+
+IPCResult BrowserChild::RecvPreserveLayers(bool aPreserve) {
+  mIsPreservingLayers = aPreserve;
+
+  PresShellActivenessMaybeChanged();
+
+  return IPC_OK();
+}
+
+void BrowserChild::PresShellActivenessMaybeChanged() {
+  // We don't use BrowserChildBase::GetPresShell() here because that would
+  // create a content viewer if one doesn't exist yet. Creating a content
+  // viewer can cause JS to run, which we want to avoid.
+  // nsIDocShell::GetPresShell returns null if no content viewer exists yet.
+  //
+  // When this method is called we don't want to go through the browsing context
+  // because we don't want to change the visibility state of the document, which
+  // has side effects like firing events to content, unblocking media playback,
+  // unthrottling timeouts... PresShell activeness has a lot less side effects.
+  nsCOMPtr<nsIDocShell> docShell = do_GetInterface(WebNavigation());
+  if (!docShell) {
+    return;
+  }
+  RefPtr<PresShell> presShell = docShell->GetPresShell();
+  if (!presShell) {
+    return;
+  }
+  presShell->ActivenessMaybeChanged();
+}
+
+NS_IMETHODIMP
+BrowserChild::GetMessageManager(ContentFrameMessageManager** aResult) {
+  RefPtr<ContentFrameMessageManager> mm(mBrowserChildMessageManager);
+  mm.forget(aResult);
+  return *aResult ? NS_OK : NS_ERROR_FAILURE;
+}
+
+void BrowserChild::SendRequestFocus(bool aCanFocus, CallerType aCallerType) {
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (!fm) {
+    return;
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = do_GetInterface(WebNavigation());
+  if (!window) {
+    return;
+  }
+
+  BrowsingContext* focusedBC = fm->GetFocusedBrowsingContext();
+  if (focusedBC == window->GetBrowsingContext()) {
+    // BrowsingContext has the focus already, do not request again.
+    return;
+  }
+
+  PBrowserChild::SendRequestFocus(aCanFocus, aCallerType);
+}
+
+NS_IMETHODIMP
+BrowserChild::GetTabId(uint64_t* aId) {
+  *aId = GetTabId();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+BrowserChild::GetChromeOuterWindowID(uint64_t* aId) {
+  *aId = ChromeOuterWindowID();
+  return NS_OK;
+}
+
+bool BrowserChild::DoSendBlockingMessage(
+    const nsAString& aMessage, StructuredCloneData& aData,
+    nsTArray<StructuredCloneData>* aRetVal) {
+  ClonedMessageData data;
+  if (!BuildClonedMessageData(aData, data)) {
+    return false;
+  }
+  return SendSyncMessage(PromiseFlatString(aMessage), data, aRetVal);
+}
+
+nsresult BrowserChild::DoSendAsyncMessage(const nsAString& aMessage,
+                                          StructuredCloneData& aData) {
+  ClonedMessageData data;
+  if (!BuildClonedMessageData(aData, data)) {
+    return NS_ERROR_DOM_DATA_CLONE_ERR;
+  }
+  if (!SendAsyncMessage(PromiseFlatString(aMessage), data)) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  return NS_OK;
+}
+
+/* static */
+nsTArray<RefPtr<BrowserChild>> BrowserChild::GetAll() {
+  StaticMutexAutoLock lock(sBrowserChildrenMutex);
+
+  if (!sBrowserChildren) {
+    return {};
+  }
+
+  return ToTArray<nsTArray<RefPtr<BrowserChild>>>(sBrowserChildren->Values());
+}
+
+BrowserChild* BrowserChild::GetFrom(PresShell* aPresShell) {
+  Document* doc = aPresShell->GetDocument();
+  if (!doc) {
+    return nullptr;
+  }
+  nsCOMPtr<nsIDocShell> docShell(doc->GetDocShell());
+  return GetFrom(docShell);
+}
+
+BrowserChild* BrowserChild::GetFrom(layers::LayersId aLayersId) {
+  StaticMutexAutoLock lock(sBrowserChildrenMutex);
+  if (!sBrowserChildren) {
+    return nullptr;
+  }
+  return sBrowserChildren->Get(uint64_t(aLayersId));
+}
+
+void BrowserChild::DidComposite(mozilla::layers::TransactionId aTransactionId,
+                                const TimeStamp& aCompositeStart,
+                                const TimeStamp& aCompositeEnd) {
+  MOZ_ASSERT(mPuppetWidget);
+  RefPtr<WebRenderLayerManager> lm =
+      mPuppetWidget->GetWindowRenderer()->AsWebRender();
+  MOZ_ASSERT(lm);
+
+  if (lm) {
+    lm->DidComposite(aTransactionId, aCompositeStart, aCompositeEnd);
+  }
+}
+
+void BrowserChild::DidRequestComposite(const TimeStamp& aCompositeReqStart,
+                                       const TimeStamp& aCompositeReqEnd) {
+  nsCOMPtr<nsIDocShell> docShellComPtr = do_GetInterface(WebNavigation());
+  if (!docShellComPtr) {
+    return;
+  }
+
+  nsDocShell* docShell = static_cast<nsDocShell*>(docShellComPtr.get());
+
+  if (TimelineConsumers::HasConsumer(docShell)) {
+    // Since we're assuming that it's impossible for content JS to directly
+    // trigger a synchronous paint, we can avoid capturing a stack trace here,
+    // which means we won't run into JS engine reentrancy issues like bug
+    // 1310014.
+    TimelineConsumers::AddMarkerForDocShell(
+        docShell, "CompositeForwardTransaction", aCompositeReqStart,
+        MarkerTracingType::START, MarkerStackRequest::NO_STACK);
+    TimelineConsumers::AddMarkerForDocShell(
+        docShell, "CompositeForwardTransaction", aCompositeReqEnd,
+        MarkerTracingType::END, MarkerStackRequest::NO_STACK);
+  }
+}
+
+void BrowserChild::ClearCachedResources() {
+  MOZ_ASSERT(mPuppetWidget);
+  RefPtr<WebRenderLayerManager> lm =
+      mPuppetWidget->GetWindowRenderer()->AsWebRender();
+  if (lm) {
+    lm->ClearCachedResources();
+  }
+
+  if (nsCOMPtr<Document> document = GetTopLevelDocument()) {
+    nsPresContext* presContext = document->GetPresContext();
+    if (presContext) {
+      presContext->NotifyPaintStatusReset();
+    }
+  }
+}
+
+void BrowserChild::SchedulePaint() {
+  nsCOMPtr<nsIDocShell> docShell = do_GetInterface(WebNavigation());
+  if (!docShell) {
+    return;
+  }
+
+  // We don't use BrowserChildBase::GetPresShell() here because that would
+  // create a content viewer if one doesn't exist yet. Creating a content viewer
+  // can cause JS to run, which we want to avoid. nsIDocShell::GetPresShell
+  // returns null if no content viewer exists yet.
+  if (RefPtr<PresShell> presShell = docShell->GetPresShell()) {
+    if (nsIFrame* root = presShell->GetRootFrame()) {
+      root->SchedulePaint();
+    }
+  }
+}
+
+void BrowserChild::ReinitRendering() {
+  MOZ_ASSERT(mLayersId.IsValid());
+
+  // In some cases, like when we create a windowless browser,
+  // RemoteLayerTreeOwner/BrowserChild is not connected to a compositor.
+  if (mLayersConnectRequested.isNothing() ||
+      mLayersConnectRequested == Some(false)) {
+    return;
+  }
+
+  // Before we establish a new PLayerTransaction, we must connect our layer tree
+  // id, CompositorBridge, and the widget compositor all together again.
+  // Normally this happens in BrowserParent before BrowserChild is given
+  // rendering information.
+  //
+  // In this case, we will send a sync message to our BrowserParent, which in
+  // turn will send a sync message to the Compositor of the widget owning this
+  // tab. This guarantees the correct association is in place before our
+  // PLayerTransaction constructor message arrives on the cross-process
+  // compositor bridge.
+  CompositorOptions options;
+  SendEnsureLayersConnected(&options);
+  mCompositorOptions = Some(options);
+
+  bool success = false;
+  RefPtr<CompositorBridgeChild> cb = CompositorBridgeChild::Get();
+
+  if (cb) {
+    success = CreateRemoteLayerManager(cb);
+  }
+
+  if (!success) {
+    NS_WARNING("failed to recreate layer manager");
+    return;
+  }
+
+  mLayersConnected = Some(true);
+  ImageBridgeChild::IdentifyCompositorTextureHost(mTextureFactoryIdentifier);
+  gfx::VRManagerChild::IdentifyTextureHost(mTextureFactoryIdentifier);
+
+  InitAPZState();
+  RefPtr<WebRenderLayerManager> lm =
+      mPuppetWidget->GetWindowRenderer()->AsWebRender();
+  if (lm) {
+    lm->SetLayersObserverEpoch(mLayersObserverEpoch);
+  }
+
+  if (nsCOMPtr<Document> doc = GetTopLevelDocument()) {
+    doc->NotifyLayerManagerRecreated();
+  }
+
+  if (mRenderLayers) {
+    SchedulePaint();
+  }
+}
+
+void BrowserChild::ReinitRenderingForDeviceReset() {
+  RefPtr<WebRenderLayerManager> lm =
+      mPuppetWidget->GetWindowRenderer()->AsWebRender();
+  if (lm) {
+    lm->DoDestroy(/* aIsSync */ true);
+  }
+
+  // Proceed with destroying and recreating the layer manager.
+  ReinitRendering();
+}
+
+NS_IMETHODIMP
+BrowserChild::OnShowTooltip(int32_t aXCoords, int32_t aYCoords,
+                            const nsAString& aTipText,
+                            const nsAString& aTipDir) {
+  nsString str(aTipText);
+  nsString dir(aTipDir);
+  SendShowTooltip(aXCoords, aYCoords, str, dir);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+BrowserChild::OnHideTooltip() {
+  SendHideTooltip();
+  return NS_OK;
+}
+
+void BrowserChild::NotifyJankedAnimations(
+    const nsTArray<uint64_t>& aJankedAnimations) {
+  MOZ_ASSERT(mPuppetWidget);
+  RefPtr<WebRenderLayerManager> lm =
+      mPuppetWidget->GetWindowRenderer()->AsWebRender();
+  if (lm) {
+    lm->UpdatePartialPrerenderedAnimations(aJankedAnimations);
+  }
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvUIResolutionChanged(
+    const float& aDpi, const int32_t& aRounding, const double& aScale) {
+  ScreenIntSize oldScreenSize = GetInnerSize();
+  if (aDpi > 0) {
+    mPuppetWidget->UpdateBackingScaleCache(aDpi, aRounding, aScale);
+  }
+
+  ScreenIntSize screenSize = GetInnerSize();
+  if (mHasValidInnerSize && oldScreenSize != screenSize) {
+    ScreenIntRect screenRect = GetOuterRect();
+
+    // See RecvUpdateDimensions for the order of these operations.
+    nsCOMPtr<nsIBaseWindow> baseWin = do_QueryInterface(WebNavigation());
+    baseWin->SetPositionAndSize(0, 0, screenSize.width, screenSize.height,
+                                nsIBaseWindow::eRepaint);
+
+    mPuppetWidget->Resize(screenRect.x + mClientOffset.x + mChromeOffset.x,
+                          screenRect.y + mClientOffset.y + mChromeOffset.y,
+                          screenSize.width, screenSize.height, true);
+  }
+
+  nsCOMPtr<Document> document(GetTopLevelDocument());
+  RefPtr<nsPresContext> presContext =
+      document ? document->GetPresContext() : nullptr;
+  if (presContext) {
+    presContext->UIResolutionChangedSync();
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvSafeAreaInsetsChanged(
+    const mozilla::ScreenIntMargin& aSafeAreaInsets) {
+  mPuppetWidget->UpdateSafeAreaInsets(aSafeAreaInsets);
+
+  nsCOMPtr<nsIScreenManager> screenMgr =
+      do_GetService("@mozilla.org/gfx/screenmanager;1");
+  ScreenIntMargin currentSafeAreaInsets;
+  if (screenMgr) {
+    // aSafeAreaInsets is for current screen. But we have to calculate
+    // safe insets for content window.
+    int32_t x, y, cx, cy;
+    GetDimensions(DimensionKind::Outer, &x, &y, &cx, &cy);
+    nsCOMPtr<nsIScreen> screen;
+    screenMgr->ScreenForRect(x, y, cx, cy, getter_AddRefs(screen));
+
+    if (screen) {
+      LayoutDeviceIntRect windowRect(x + mClientOffset.x + mChromeOffset.x,
+                                     y + mClientOffset.y + mChromeOffset.y, cx,
+                                     cy);
+      currentSafeAreaInsets = nsContentUtils::GetWindowSafeAreaInsets(
+          screen, aSafeAreaInsets, windowRect);
+    }
+  }
+
+  if (nsCOMPtr<Document> document = GetTopLevelDocument()) {
+    nsPresContext* presContext = document->GetPresContext();
+    if (presContext) {
+      presContext->SetSafeAreaInsets(currentSafeAreaInsets);
+    }
+  }
+
+  // https://github.com/w3c/csswg-drafts/issues/4670
+  // Actually we don't set this value on sub document. This behaviour is
+  // same as Blink that safe area insets isn't set on sub document.
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvAllowScriptsToClose() {
+  nsCOMPtr<nsPIDOMWindowOuter> window = do_GetInterface(WebNavigation());
+  if (window) {
+    nsGlobalWindowOuter::Cast(window)->AllowScriptsToClose();
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserChild::RecvReleaseAllPointerCapture() {
+  PointerEventHandler::ReleaseAllPointerCapture();
+  return IPC_OK();
+}
+
+PPaymentRequestChild* BrowserChild::AllocPPaymentRequestChild() {
+  MOZ_CRASH(
+      "We should never be manually allocating PPaymentRequestChild actors");
+  return nullptr;
+}
+
+bool BrowserChild::DeallocPPaymentRequestChild(PPaymentRequestChild* actor) {
+  delete actor;
+  return true;
+}
+
+ScreenIntSize BrowserChild::GetInnerSize() {
+  LayoutDeviceIntSize innerSize =
+      RoundedToInt(mUnscaledInnerSize * mPuppetWidget->GetDefaultScale());
+  return ViewAs<ScreenPixel>(
+      innerSize, PixelCastJustification::LayoutDeviceIsScreenForTabDims);
+};
+
+Maybe<nsRect> BrowserChild::GetVisibleRect() const {
+  if (mIsTopLevel) {
+    // We are conservative about visible rects for top-level browsers to avoid
+    // artifacts when resizing
+    return Nothing();
+  }
+
+  return mDidSetEffectsInfo ? Some(mEffectsInfo.mVisibleRect) : Nothing();
+}
+
+Maybe<LayoutDeviceRect>
+BrowserChild::GetTopLevelViewportVisibleRectInSelfCoords() const {
+  if (mIsTopLevel) {
+    return Nothing();
+  }
+
+  if (!mChildToParentConversionMatrix) {
+    // We have no way to tell this remote document visible rect right now.
+    return Nothing();
+  }
+
+  Maybe<LayoutDeviceToLayoutDeviceMatrix4x4> inverse =
+      mChildToParentConversionMatrix->MaybeInverse();
+  if (!inverse) {
+    return Nothing();
+  }
+
+  // Convert the remote document visible rect to the coordinate system of the
+  // iframe document.
+  Maybe<LayoutDeviceRect> rect = UntransformBy(
+      *inverse,
+      ViewAs<LayoutDevicePixel>(
+          mTopLevelViewportVisibleRectInBrowserCoords,
+          PixelCastJustification::ContentProcessIsLayerInUiProcess),
+      LayoutDeviceRect::MaxIntRect());
+  if (!rect) {
+    return Nothing();
+  }
+
+  return rect;
+}
+
+ScreenIntRect BrowserChild::GetOuterRect() {
+  LayoutDeviceIntRect outerRect =
+      RoundedToInt(mUnscaledOuterRect * mPuppetWidget->GetDefaultScale());
+  return ViewAs<ScreenPixel>(
+      outerRect, PixelCastJustification::LayoutDeviceIsScreenForTabDims);
+}
+
+void BrowserChild::PaintWhileInterruptingJS(
+    const layers::LayersObserverEpoch& aEpoch) {
+  if (!IPCOpen() || !mPuppetWidget || !mPuppetWidget->HasWindowRenderer()) {
+    // Don't bother doing anything now. Better to wait until we receive the
+    // message on the PContent channel.
+    return;
+  }
+
+  MOZ_DIAGNOSTIC_ASSERT(nsContentUtils::IsSafeToRunScript());
+  nsAutoScriptBlocker scriptBlocker;
+  RecvRenderLayers(true /* aEnabled */, aEpoch);
+}
+
+void BrowserChild::UnloadLayersWhileInterruptingJS(
+    const layers::LayersObserverEpoch& aEpoch) {
+  if (!IPCOpen() || !mPuppetWidget || !mPuppetWidget->HasWindowRenderer()) {
+    // Don't bother doing anything now. Better to wait until we receive the
+    // message on the PContent channel.
+    return;
+  }
+
+  MOZ_DIAGNOSTIC_ASSERT(nsContentUtils::IsSafeToRunScript());
+  nsAutoScriptBlocker scriptBlocker;
+  RecvRenderLayers(false /* aEnabled */, aEpoch);
+}
+
+nsresult BrowserChild::CanCancelContentJS(
+    nsIRemoteTab::NavigationType aNavigationType, int32_t aNavigationIndex,
+    nsIURI* aNavigationURI, int32_t aEpoch, bool* aCanCancel) {
+  nsresult rv;
+  *aCanCancel = false;
+
+  if (aEpoch <= mCancelContentJSEpoch) {
+    // The next page loaded before we got here, so we shouldn't try to cancel
+    // the content JS.
+    return NS_OK;
+  }
+
+  // If we have session history in the parent we've already performed
+  // the checks following, so we can return early.
+  if (mozilla::SessionHistoryInParent()) {
+    *aCanCancel = true;
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIDocShell> docShell = do_GetInterface(WebNavigation());
+  nsCOMPtr<nsISHistory> history;
+  if (docShell) {
+    history = nsDocShell::Cast(docShell)->GetSessionHistory()->LegacySHistory();
+  }
+
+  if (!history) {
+    return NS_ERROR_FAILURE;
+  }
+
+  int32_t current;
+  rv = history->GetIndex(&current);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (current == -1) {
+    // This tab has no history! Just return.
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsISHEntry> entry;
+  rv = history->GetEntryAtIndex(current, getter_AddRefs(entry));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIURI> currentURI = entry->GetURI();
+  if (!currentURI->SchemeIs("http") && !currentURI->SchemeIs("https") &&
+      !currentURI->SchemeIs("file")) {
+    // Only cancel content JS for http(s) and file URIs. Other URIs are probably
+    // internal and we should just let them run to completion.
+    return NS_OK;
+  }
+
+  if (aNavigationType == nsIRemoteTab::NAVIGATE_BACK) {
+    aNavigationIndex = current - 1;
+  } else if (aNavigationType == nsIRemoteTab::NAVIGATE_FORWARD) {
+    aNavigationIndex = current + 1;
+  } else if (aNavigationType == nsIRemoteTab::NAVIGATE_URL) {
+    if (!aNavigationURI) {
+      return NS_ERROR_FAILURE;
+    }
+
+    if (aNavigationURI->SchemeIs("javascript")) {
+      // "javascript:" URIs don't (necessarily) trigger navigation to a
+      // different page, so don't allow the current page's JS to terminate.
+      return NS_OK;
+    }
+
+    // If navigating directly to a URL (e.g. via hitting Enter in the location
+    // bar), then we can cancel anytime the next URL is different from the
+    // current, *excluding* the ref ("#").
+    bool equals;
+    rv = currentURI->EqualsExceptRef(aNavigationURI, &equals);
+    NS_ENSURE_SUCCESS(rv, rv);
+    *aCanCancel = !equals;
+    return NS_OK;
+  }
+  // Note: aNavigationType may also be NAVIGATE_INDEX, in which case we don't
+  // need to do anything special.
+
+  int32_t delta = aNavigationIndex > current ? 1 : -1;
+  for (int32_t i = current + delta; i != aNavigationIndex + delta; i += delta) {
+    nsCOMPtr<nsISHEntry> nextEntry;
+    // If `i` happens to be negative, this call will fail (which is what we
+    // would want to happen).
+    rv = history->GetEntryAtIndex(i, getter_AddRefs(nextEntry));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsISHEntry> laterEntry = delta == 1 ? nextEntry : entry;
+    nsCOMPtr<nsIURI> thisURI = entry->GetURI();
+    nsCOMPtr<nsIURI> nextURI = nextEntry->GetURI();
+
+    // If we changed origin and the load wasn't in a subframe, we know it was
+    // a full document load, so we can cancel the content JS safely.
+    if (!laterEntry->GetIsSubFrame()) {
+      nsAutoCString thisHost;
+      rv = thisURI->GetPrePath(thisHost);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsAutoCString nextHost;
+      rv = nextURI->GetPrePath(nextHost);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      if (!thisHost.Equals(nextHost)) {
+        *aCanCancel = true;
+        return NS_OK;
+      }
+    }
+
+    entry = nextEntry;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP BrowserChild::OnStateChange(nsIWebProgress* aWebProgress,
+                                          nsIRequest* aRequest,
+                                          uint32_t aStateFlags,
+                                          nsresult aStatus) {
+  if (!IPCOpen() || !mShouldSendWebProgressEventsToParent) {
+    return NS_OK;
+  }
+
+  // We shouldn't need to notify the parent of redirect state changes, since
+  // with DocumentChannel that only happens when we switch to the real channel,
+  // and that's an implementation detail that we can hide.
+  if (aStateFlags & nsIWebProgressListener::STATE_IS_REDIRECTED_DOCUMENT) {
+    return NS_OK;
+  }
+
+  // Our OnStateChange call must have provided the nsIDocShell which the source
+  // comes from. We'll use this to locate the corresponding BrowsingContext in
+  // the parent process.
+  nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(aWebProgress);
+  if (!docShell) {
+    MOZ_ASSERT_UNREACHABLE("aWebProgress is null or not a nsIDocShell?");
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  WebProgressData webProgressData;
+  Maybe<WebProgressStateChangeData> stateChangeData;
+  RequestData requestData;
+
+  MOZ_TRY(PrepareProgressListenerData(aWebProgress, aRequest, webProgressData,
+                                      requestData));
+
+  RefPtr<BrowsingContext> browsingContext = docShell->GetBrowsingContext();
+  if (browsingContext->IsTopContent()) {
+    stateChangeData.emplace();
+
+    stateChangeData->isNavigating() = docShell->GetIsNavigating();
+    stateChangeData->mayEnableCharacterEncodingMenu() =
+        docShell->GetMayEnableCharacterEncodingMenu();
+
+    RefPtr<Document> document = browsingContext->GetExtantDocument();
+    if (document && aStateFlags & nsIWebProgressListener::STATE_STOP) {
+      document->GetContentType(stateChangeData->contentType());
+      document->GetCharacterSet(stateChangeData->charset());
+      stateChangeData->documentURI() = document->GetDocumentURIObject();
+    } else {
+      stateChangeData->contentType().SetIsVoid(true);
+      stateChangeData->charset().SetIsVoid(true);
+    }
+  }
+
+  Unused << SendOnStateChange(webProgressData, requestData, aStateFlags,
+                              aStatus, stateChangeData);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP BrowserChild::OnProgressChange(nsIWebProgress* aWebProgress,
+                                             nsIRequest* aRequest,
+                                             int32_t aCurSelfProgress,
+                                             int32_t aMaxSelfProgress,
+                                             int32_t aCurTotalProgress,
+                                             int32_t aMaxTotalProgress) {
+  if (!IPCOpen() || !mShouldSendWebProgressEventsToParent) {
+    return NS_OK;
+  }
+
+  // FIXME: We currently ignore ProgressChange events from out-of-process
+  // subframes both here and in BrowserParent. We may want to change this
+  // behaviour in the future.
+  if (!GetBrowsingContext()->IsTopContent()) {
+    return NS_OK;
+  }
+
+  // As we're being filtered by nsBrowserStatusFilter, we will be passed either
+  // nullptr or 0 for all arguments other than aCurTotalProgress and
+  // aMaxTotalProgress. Don't bother sending them.
+  MOZ_ASSERT(!aWebProgress);
+  MOZ_ASSERT(!aRequest);
+  MOZ_ASSERT(aCurSelfProgress == 0);
+  MOZ_ASSERT(aMaxSelfProgress == 0);
+
+  Unused << SendOnProgressChange(aCurTotalProgress, aMaxTotalProgress);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP BrowserChild::OnLocationChange(nsIWebProgress* aWebProgress,
+                                             nsIRequest* aRequest,
+                                             nsIURI* aLocation,
+                                             uint32_t aFlags) {
+  if (!IPCOpen() || !mShouldSendWebProgressEventsToParent) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(aWebProgress);
+  if (!docShell) {
+    MOZ_ASSERT_UNREACHABLE("aWebProgress is null or not a nsIDocShell?");
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  RefPtr<BrowsingContext> browsingContext = docShell->GetBrowsingContext();
+  RefPtr<Document> document = browsingContext->GetExtantDocument();
+  if (!document) {
+    return NS_OK;
+  }
+
+  WebProgressData webProgressData;
+  RequestData requestData;
+
+  MOZ_TRY(PrepareProgressListenerData(aWebProgress, aRequest, webProgressData,
+                                      requestData));
+
+  Maybe<WebProgressLocationChangeData> locationChangeData;
+
+  bool canGoBack = false;
+  bool canGoForward = false;
+  if (!mozilla::SessionHistoryInParent()) {
+    MOZ_TRY(WebNavigation()->GetCanGoBack(&canGoBack));
+    MOZ_TRY(WebNavigation()->GetCanGoForward(&canGoForward));
+  }
+
+  if (browsingContext->IsTopContent()) {
+    MOZ_ASSERT(
+        browsingContext == GetBrowsingContext(),
+        "Toplevel content BrowsingContext which isn't GetBrowsingContext()?");
+
+    locationChangeData.emplace();
+
+    document->GetContentType(locationChangeData->contentType());
+    locationChangeData->isNavigating() = docShell->GetIsNavigating();
+    locationChangeData->documentURI() = document->GetDocumentURIObject();
+    document->GetTitle(locationChangeData->title());
+    document->GetCharacterSet(locationChangeData->charset());
+
+    locationChangeData->mayEnableCharacterEncodingMenu() =
+        docShell->GetMayEnableCharacterEncodingMenu();
+
+    locationChangeData->contentPrincipal() = document->NodePrincipal();
+    locationChangeData->contentPartitionedPrincipal() =
+        document->PartitionedPrincipal();
+    locationChangeData->csp() = document->GetCsp();
+    locationChangeData->referrerInfo() = document->ReferrerInfo();
+    locationChangeData->isSyntheticDocument() = document->IsSyntheticDocument();
+
+    if (nsCOMPtr<nsILoadGroup> loadGroup = document->GetDocumentLoadGroup()) {
+      uint64_t requestContextID = 0;
+      MOZ_TRY(loadGroup->GetRequestContextID(&requestContextID));
+      locationChangeData->requestContextID() = Some(requestContextID);
+    }
+
+#ifdef MOZ_CRASHREPORTER
+    if (CrashReporter::GetEnabled()) {
+      nsCOMPtr<nsIURI> annotationURI;
+
+      nsresult rv =
+          NS_MutateURI(aLocation).SetUserPass(""_ns).Finalize(annotationURI);
+
+      if (NS_FAILED(rv)) {
+        // Ignore failures on about: URIs.
+        annotationURI = aLocation;
+      }
+
+      CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::URL,
+                                         annotationURI->GetSpecOrDefault());
+    }
+#endif
+  }
+
+  Unused << SendOnLocationChange(webProgressData, requestData, aLocation,
+                                 aFlags, canGoBack, canGoForward,
+                                 locationChangeData);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP BrowserChild::OnStatusChange(nsIWebProgress* aWebProgress,
+                                           nsIRequest* aRequest,
+                                           nsresult aStatus,
+                                           const char16_t* aMessage) {
+  if (!IPCOpen() || !mShouldSendWebProgressEventsToParent) {
+    return NS_OK;
+  }
+
+  // FIXME: We currently ignore StatusChange from out-of-process subframes both
+  // here and in BrowserParent. We may want to change this behaviour in the
+  // future.
+  if (!GetBrowsingContext()->IsTopContent()) {
+    return NS_OK;
+  }
+
+  // As we're being filtered by nsBrowserStatusFilter, we will be passed either
+  // nullptr or NS_OK for all arguments other than aMessage. Don't bother
+  // sending them.
+  MOZ_ASSERT(!aWebProgress);
+  MOZ_ASSERT(!aRequest);
+  MOZ_ASSERT(aStatus == NS_OK);
+
+  Unused << SendOnStatusChange(nsDependentString(aMessage));
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP BrowserChild::OnSecurityChange(nsIWebProgress* aWebProgress,
+                                             nsIRequest* aRequest,
+                                             uint32_t aState) {
+  // Security changes are now handled entirely in the parent process
+  // so we don't need to worry about forwarding them (and we shouldn't
+  // be receiving any to forward).
+  return NS_OK;
+}
+
+NS_IMETHODIMP BrowserChild::OnContentBlockingEvent(nsIWebProgress* aWebProgress,
+                                                   nsIRequest* aRequest,
+                                                   uint32_t aEvent) {
+  // The OnContentBlockingEvent only happenes in the parent process. It should
+  // not be seen in the content process.
+  MOZ_DIAGNOSTIC_ASSERT(
+      false, "OnContentBlockingEvent should not be seen in content process.");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP BrowserChild::OnProgressChange64(nsIWebProgress* aWebProgress,
+                                               nsIRequest* aRequest,
+                                               int64_t aCurSelfProgress,
+                                               int64_t aMaxSelfProgress,
+                                               int64_t aCurTotalProgress,
+                                               int64_t aMaxTotalProgress) {
+  // All the events we receive are filtered through an nsBrowserStatusFilter,
+  // which accepts ProgressChange64 events, but truncates the progress values to
+  // uint32_t and calls OnProgressChange.
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP BrowserChild::OnRefreshAttempted(nsIWebProgress* aWebProgress,
+                                               nsIURI* aRefreshURI,
+                                               uint32_t aMillis, bool aSameURI,
+                                               bool* aOut) {
+  NS_ENSURE_ARG_POINTER(aOut);
+  *aOut = true;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP BrowserChild::NotifyNavigationFinished() {
+  Unused << SendNavigationFinished();
+  return NS_OK;
+}
+
+nsresult BrowserChild::PrepareRequestData(nsIRequest* aRequest,
+                                          RequestData& aRequestData) {
+  nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
+  if (!channel) {
+    aRequestData.requestURI() = nullptr;
+    return NS_OK;
+  }
+
+  nsresult rv = channel->GetURI(getter_AddRefs(aRequestData.requestURI()));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = channel->GetOriginalURI(
+      getter_AddRefs(aRequestData.originalRequestURI()));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIClassifiedChannel> classifiedChannel = do_QueryInterface(channel);
+  if (classifiedChannel) {
+    rv = classifiedChannel->GetMatchedList(aRequestData.matchedList());
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return NS_OK;
+}
+
+nsresult BrowserChild::PrepareProgressListenerData(
+    nsIWebProgress* aWebProgress, nsIRequest* aRequest,
+    WebProgressData& aWebProgressData, RequestData& aRequestData) {
+  nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(aWebProgress);
+  if (!docShell) {
+    MOZ_ASSERT_UNREACHABLE("aWebProgress is null or not a nsIDocShell?");
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  aWebProgressData.browsingContext() = docShell->GetBrowsingContext();
+  nsresult rv = aWebProgress->GetLoadType(&aWebProgressData.loadType());
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return PrepareRequestData(aRequest, aRequestData);
+}
+
+void BrowserChild::UpdateSessionStore() {
+  if (mSessionStoreChild) {
+    mSessionStoreChild->UpdateSessionStore();
+  }
+}
+
+#ifdef XP_WIN
+RefPtr<PBrowserChild::IsWindowSupportingProtectedMediaPromise>
+BrowserChild::DoesWindowSupportProtectedMedia() {
+  MOZ_ASSERT(
+      NS_IsMainThread(),
+      "Protected media support check should be done on main thread only.");
+  if (mWindowSupportsProtectedMedia) {
+    // If we've already checked and have a cached result, resolve with that.
+    return IsWindowSupportingProtectedMediaPromise::CreateAndResolve(
+        mWindowSupportsProtectedMedia.value(), __func__);
+  }
+  RefPtr<BrowserChild> self = this;
+  // We chain off the promise rather than passing it directly so we can cache
+  // the result and use that for future calls.
+  return SendIsWindowSupportingProtectedMedia(ChromeOuterWindowID())
+      ->Then(
+          GetCurrentSerialEventTarget(), __func__,
+          [self](bool isSupported) {
+            // If a result was cached while this check was inflight, ensure the
+            // results match.
+            MOZ_ASSERT_IF(
+                self->mWindowSupportsProtectedMedia,
+                self->mWindowSupportsProtectedMedia.value() == isSupported);
+            // Cache the response as it will not change during the lifetime
+            // of this object.
+            self->mWindowSupportsProtectedMedia = Some(isSupported);
+            return IsWindowSupportingProtectedMediaPromise::CreateAndResolve(
+                self->mWindowSupportsProtectedMedia.value(), __func__);
+          },
+          [](ResponseRejectReason reason) {
+            return IsWindowSupportingProtectedMediaPromise::CreateAndReject(
+                reason, __func__);
+          });
+}
+#endif
+
+void BrowserChild::NotifyContentBlockingEvent(
+    uint32_t aEvent, nsIChannel* aChannel, bool aBlocked,
+    const nsACString& aTrackingOrigin,
+    const nsTArray<nsCString>& aTrackingFullHashes,
+    const Maybe<
+        mozilla::ContentBlockingNotifier::StorageAccessPermissionGrantedReason>&
+        aReason) {
+  if (!IPCOpen()) {
+    return;
+  }
+
+  RequestData requestData;
+  if (NS_SUCCEEDED(PrepareRequestData(aChannel, requestData))) {
+    Unused << SendNotifyContentBlockingEvent(
+        aEvent, requestData, aBlocked, PromiseFlatCString(aTrackingOrigin),
+        aTrackingFullHashes, aReason);
+  }
+}
+
+NS_IMETHODIMP
+BrowserChild::ContentTransformsReceived(JSContext* aCx,
+                                        dom::Promise** aPromise) {
+  auto* globalObject = xpc::CurrentNativeGlobal(aCx);
+  ErrorResult rv;
+  if (mChildToParentConversionMatrix) {
+    // Already received content transforms
+    RefPtr<Promise> promise =
+        Promise::CreateResolvedWithUndefined(globalObject, rv);
+    promise.forget(aPromise);
+    return rv.StealNSResult();
+  }
+
+  if (!mContentTransformPromise) {
+    mContentTransformPromise = Promise::Create(globalObject, rv);
+  }
+
+  MOZ_ASSERT(globalObject == mContentTransformPromise->GetGlobalObject());
+  NS_IF_ADDREF(*aPromise = mContentTransformPromise);
+  return rv.StealNSResult();
+}
+
+BrowserChildMessageManager::BrowserChildMessageManager(
+    BrowserChild* aBrowserChild)
+    : ContentFrameMessageManager(new nsFrameMessageManager(aBrowserChild)),
+      mBrowserChild(aBrowserChild) {}
+
+BrowserChildMessageManager::~BrowserChildMessageManager() = default;
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(BrowserChildMessageManager)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(BrowserChildMessageManager,
+                                                DOMEventTargetHelper)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mMessageManager);
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mBrowserChild);
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_REFERENCE
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(BrowserChildMessageManager,
+                                                  DOMEventTargetHelper)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMessageManager)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBrowserChild)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(BrowserChildMessageManager)
+  NS_INTERFACE_MAP_ENTRY(nsIMessageSender)
+  NS_INTERFACE_MAP_ENTRY_CONCRETE(ContentFrameMessageManager)
+  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+NS_IMPL_ADDREF_INHERITED(BrowserChildMessageManager, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(BrowserChildMessageManager, DOMEventTargetHelper)
+
+JSObject* BrowserChildMessageManager::WrapObject(
+    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+  return ContentFrameMessageManager_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void BrowserChildMessageManager::MarkForCC() {
+  if (mBrowserChild) {
+    mBrowserChild->MarkScopesForCC();
+  }
+  EventListenerManager* elm = GetExistingListenerManager();
+  if (elm) {
+    elm->MarkForCC();
+  }
+  MessageManagerGlobal::MarkForCC();
+}
+
+Nullable<WindowProxyHolder> BrowserChildMessageManager::GetContent(
+    ErrorResult& aError) {
+  nsCOMPtr<nsIDocShell> docShell = GetDocShell(aError);
+  if (!docShell) {
+    return nullptr;
+  }
+  return WindowProxyHolder(docShell->GetBrowsingContext());
+}
+
+already_AddRefed<nsIDocShell> BrowserChildMessageManager::GetDocShell(
+    ErrorResult& aError) {
+  if (!mBrowserChild) {
+    aError.Throw(NS_ERROR_NULL_POINTER);
+    return nullptr;
+  }
+  nsCOMPtr<nsIDocShell> window =
+      do_GetInterface(mBrowserChild->WebNavigation());
+  return window.forget();
+}
+
+already_AddRefed<nsIEventTarget>
+BrowserChildMessageManager::GetTabEventTarget() {
+  nsCOMPtr<nsIEventTarget> target = EventTargetFor(TaskCategory::Other);
+  return target.forget();
+}
+
+nsresult BrowserChildMessageManager::Dispatch(
+    TaskCategory aCategory, already_AddRefed<nsIRunnable>&& aRunnable) {
+  return DispatcherTrait::Dispatch(aCategory, std::move(aRunnable));
+}
+
+nsISerialEventTarget* BrowserChildMessageManager::EventTargetFor(
+    TaskCategory aCategory) const {
+  return DispatcherTrait::EventTargetFor(aCategory);
+}
+
+AbstractThread* BrowserChildMessageManager::AbstractMainThreadFor(
+    TaskCategory aCategory) {
+  return DispatcherTrait::AbstractMainThreadFor(aCategory);
+}
diff --git a/dom/ipc/BrowserChild.h b/dom/ipc/BrowserChild.h
new file mode 100644
index 0000000000..d55591d10a
--- /dev/null
+++ b/dom/ipc/BrowserChild.h
@@ -0,0 +1,883 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_BrowserChild_h
+#define mozilla_dom_BrowserChild_h
+
+#include "mozilla/dom/ContentFrameMessageManager.h"
+#include "mozilla/dom/PBrowserChild.h"
+#include "nsIWebNavigation.h"
+#include "nsCOMPtr.h"
+#include "nsIWebBrowserChrome.h"
+#include "nsIWebBrowserChromeFocus.h"
+#include "nsIDOMEventListener.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIWindowProvider.h"
+#include "nsIDocShell.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsWeakReference.h"
+#include "nsIBrowserChild.h"
+#include "nsITooltipListener.h"
+#include "nsIWebProgressListener.h"
+#include "nsIWebProgressListener2.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/TabContext.h"
+#include "mozilla/dom/CoalescedMouseData.h"
+#include "mozilla/dom/CoalescedTouchData.h"
+#include "mozilla/dom/CoalescedWheelData.h"
+#include "mozilla/dom/MessageManagerCallback.h"
+#include "mozilla/dom/VsyncMainChild.h"
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/EventForwards.h"
+#include "mozilla/layers/CompositorTypes.h"
+#include "mozilla/layers/APZCCallbackHelper.h"
+#include "mozilla/layers/CompositorOptions.h"
+#include "mozilla/layers/GeckoContentControllerTypes.h"
+#include "mozilla/dom/ipc/IdType.h"
+#include "AudioChannelService.h"
+#include "PuppetWidget.h"
+#include "nsDeque.h"
+#include "nsIRemoteTab.h"
+#include "nsTHashSet.h"
+
+class nsBrowserStatusFilter;
+class nsIDOMWindow;
+class nsIHttpChannel;
+class nsIRequest;
+class nsISerialEventTarget;
+class nsIWebProgress;
+class nsWebBrowser;
+class nsDocShellLoadState;
+
+template <typename T>
+class nsTHashtable;
+template <typename T>
+class nsPtrHashKey;
+
+namespace mozilla {
+enum class NativeKeyBindingsType : uint8_t;
+
+class AbstractThread;
+class PresShell;
+
+namespace layers {
+class APZChild;
+class APZEventState;
+class AsyncDragMetrics;
+class IAPZCTreeManager;
+class ImageCompositeNotification;
+class PCompositorBridgeChild;
+}  // namespace layers
+
+namespace widget {
+struct AutoCacheNativeKeyCommands;
+}  // namespace widget
+
+namespace dom {
+
+class BrowserChild;
+class BrowsingContext;
+class TabGroup;
+class ClonedMessageData;
+class CoalescedMouseData;
+class CoalescedWheelData;
+class SessionStoreChild;
+class RequestData;
+class WebProgressData;
+
+class BrowserChildMessageManager : public ContentFrameMessageManager,
+                                   public nsIMessageSender,
+                                   public DispatcherTrait,
+                                   public nsSupportsWeakReference {
+ public:
+  explicit BrowserChildMessageManager(BrowserChild* aBrowserChild);
+
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(BrowserChildMessageManager,
+                                           DOMEventTargetHelper)
+
+  void MarkForCC();
+
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override;
+
+  virtual Nullable<WindowProxyHolder> GetContent(ErrorResult& aError) override;
+  virtual already_AddRefed<nsIDocShell> GetDocShell(
+      ErrorResult& aError) override;
+  virtual already_AddRefed<nsIEventTarget> GetTabEventTarget() override;
+
+  NS_FORWARD_SAFE_NSIMESSAGESENDER(mMessageManager)
+
+  void GetEventTargetParent(EventChainPreVisitor& aVisitor) override {
+    aVisitor.mForceContentDispatch = true;
+  }
+
+  // Dispatch a runnable related to the global.
+  virtual nsresult Dispatch(mozilla::TaskCategory aCategory,
+                            already_AddRefed<nsIRunnable>&& aRunnable) override;
+
+  virtual nsISerialEventTarget* EventTargetFor(
+      mozilla::TaskCategory aCategory) const override;
+
+  virtual AbstractThread* AbstractMainThreadFor(
+      mozilla::TaskCategory aCategory) override;
+
+  RefPtr<BrowserChild> mBrowserChild;
+
+ protected:
+  ~BrowserChildMessageManager();
+};
+
+/**
+ * BrowserChild implements the child actor part of the PBrowser protocol. See
+ * PBrowser for more information.
+ */
+class BrowserChild final : public nsMessageManagerScriptExecutor,
+                           public ipc::MessageManagerCallback,
+                           public PBrowserChild,
+                           public nsIWebBrowserChrome,
+                           public nsIWebBrowserChromeFocus,
+                           public nsIInterfaceRequestor,
+                           public nsIWindowProvider,
+                           public nsSupportsWeakReference,
+                           public nsIBrowserChild,
+                           public nsIObserver,
+                           public nsIWebProgressListener2,
+                           public TabContext,
+                           public nsITooltipListener,
+                           public mozilla::ipc::IShmemAllocator {
+  using PuppetWidget = mozilla::widget::PuppetWidget;
+  using ClonedMessageData = mozilla::dom::ClonedMessageData;
+  using CoalescedMouseData = mozilla::dom::CoalescedMouseData;
+  using CoalescedWheelData = mozilla::dom::CoalescedWheelData;
+  using APZEventState = mozilla::layers::APZEventState;
+  using TouchBehaviorFlags = mozilla::layers::TouchBehaviorFlags;
+
+  friend class PBrowserChild;
+
+ public:
+  /**
+   * Find BrowserChild of aTabId in the same content process of the
+   * caller.
+   */
+  static already_AddRefed<BrowserChild> FindBrowserChild(const TabId& aTabId);
+
+  // Return a list of all active BrowserChildren.
+  static nsTArray<RefPtr<BrowserChild>> GetAll();
+
+ public:
+  /**
+   * Create a new BrowserChild object.
+   */
+  BrowserChild(ContentChild* aManager, const TabId& aTabId,
+               const TabContext& aContext,
+               dom::BrowsingContext* aBrowsingContext, uint32_t aChromeFlags,
+               bool aIsTopLevel);
+
+  MOZ_CAN_RUN_SCRIPT nsresult Init(mozIDOMWindowProxy* aParent,
+                                   WindowGlobalChild* aInitialWindowChild);
+
+  /** Return a BrowserChild with the given attributes. */
+  static already_AddRefed<BrowserChild> Create(
+      ContentChild* aManager, const TabId& aTabId, const TabContext& aContext,
+      BrowsingContext* aBrowsingContext, uint32_t aChromeFlags,
+      bool aIsTopLevel);
+
+  // Let managees query if it is safe to send messages.
+  bool IsDestroyed() const { return mDestroyed; }
+
+  const TabId GetTabId() const {
+    MOZ_ASSERT(mUniqueId != 0);
+    return mUniqueId;
+  }
+
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_NSIWEBBROWSERCHROME
+  NS_DECL_NSIWEBBROWSERCHROMEFOCUS
+  NS_DECL_NSIINTERFACEREQUESTOR
+  NS_DECL_NSIWINDOWPROVIDER
+  NS_DECL_NSIBROWSERCHILD
+  NS_DECL_NSIOBSERVER
+  NS_DECL_NSIWEBPROGRESSLISTENER
+  NS_DECL_NSIWEBPROGRESSLISTENER2
+  NS_DECL_NSITOOLTIPLISTENER
+
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(BrowserChild,
+                                                         nsIBrowserChild)
+
+  FORWARD_SHMEM_ALLOCATOR_TO(PBrowserChild)
+
+  JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+    return mBrowserChildMessageManager->WrapObject(aCx, aGivenProto);
+  }
+
+  // Get the Document for the top-level window in this tab.
+  already_AddRefed<Document> GetTopLevelDocument() const;
+
+  // Get the pres-shell of the document for the top-level window in this tab.
+  PresShell* GetTopLevelPresShell() const;
+
+  BrowserChildMessageManager* GetMessageManager() {
+    return mBrowserChildMessageManager;
+  }
+
+  bool IsTopLevel() const { return mIsTopLevel; }
+
+  bool ShouldSendWebProgressEventsToParent() const {
+    return mShouldSendWebProgressEventsToParent;
+  }
+
+  /**
+   * MessageManagerCallback methods that we override.
+   */
+  virtual bool DoSendBlockingMessage(
+      const nsAString& aMessage, StructuredCloneData& aData,
+      nsTArray<StructuredCloneData>* aRetVal) override;
+
+  virtual nsresult DoSendAsyncMessage(const nsAString& aMessage,
+                                      StructuredCloneData& aData) override;
+
+  bool DoUpdateZoomConstraints(const uint32_t& aPresShellId,
+                               const ViewID& aViewId,
+                               const Maybe<ZoomConstraints>& aConstraints);
+
+  mozilla::ipc::IPCResult RecvLoadURL(nsDocShellLoadState* aLoadState,
+                                      const ParentShowInfo& aInfo);
+
+  mozilla::ipc::IPCResult RecvCreateAboutBlankContentViewer(
+      nsIPrincipal* aPrincipal, nsIPrincipal* aPartitionedPrincipal);
+
+  mozilla::ipc::IPCResult RecvResumeLoad(const uint64_t& aPendingSwitchID,
+                                         const ParentShowInfo&);
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult
+  RecvCloneDocumentTreeIntoSelf(
+      const MaybeDiscarded<BrowsingContext>& aSourceBC,
+      const embedding::PrintData& aPrintData,
+      CloneDocumentTreeIntoSelfResolver&& aResolve);
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  mozilla::ipc::IPCResult RecvUpdateRemotePrintSettings(
+      const embedding::PrintData& aPrintData);
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  mozilla::ipc::IPCResult RecvShow(const ParentShowInfo&, const OwnerShowInfo&);
+
+  mozilla::ipc::IPCResult RecvInitRendering(
+      const TextureFactoryIdentifier& aTextureFactoryIdentifier,
+      const layers::LayersId& aLayersId,
+      const mozilla::layers::CompositorOptions& aCompositorOptions,
+      const bool& aLayersConnected);
+
+  mozilla::ipc::IPCResult RecvCompositorOptionsChanged(
+      const mozilla::layers::CompositorOptions& aNewOptions);
+
+  mozilla::ipc::IPCResult RecvUpdateDimensions(
+      const mozilla::dom::DimensionInfo& aDimensionInfo);
+  mozilla::ipc::IPCResult RecvSizeModeChanged(const nsSizeMode& aSizeMode);
+
+  mozilla::ipc::IPCResult RecvChildToParentMatrix(
+      const mozilla::Maybe<mozilla::gfx::Matrix4x4>& aMatrix,
+      const mozilla::ScreenRect& aTopLevelViewportVisibleRectInBrowserCoords);
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  mozilla::ipc::IPCResult RecvDynamicToolbarMaxHeightChanged(
+      const mozilla::ScreenIntCoord& aHeight);
+
+  mozilla::ipc::IPCResult RecvDynamicToolbarOffsetChanged(
+      const mozilla::ScreenIntCoord& aOffset);
+
+  mozilla::ipc::IPCResult RecvActivate(uint64_t aActionId);
+
+  mozilla::ipc::IPCResult RecvDeactivate(uint64_t aActionId);
+
+  mozilla::ipc::IPCResult RecvRealMouseMoveEvent(
+      const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId);
+  mozilla::ipc::IPCResult RecvNormalPriorityRealMouseMoveEvent(
+      const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId);
+  mozilla::ipc::IPCResult RecvRealMouseMoveEventForTests(
+      const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId);
+  mozilla::ipc::IPCResult RecvNormalPriorityRealMouseMoveEventForTests(
+      const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId);
+
+  mozilla::ipc::IPCResult RecvSynthMouseMoveEvent(
+      const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId);
+  mozilla::ipc::IPCResult RecvNormalPrioritySynthMouseMoveEvent(
+      const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId);
+
+  mozilla::ipc::IPCResult RecvRealMouseButtonEvent(
+      const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId);
+  mozilla::ipc::IPCResult RecvNormalPriorityRealMouseButtonEvent(
+      const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId);
+
+  mozilla::ipc::IPCResult RecvRealMouseEnterExitWidgetEvent(
+      const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId);
+  mozilla::ipc::IPCResult RecvNormalPriorityRealMouseEnterExitWidgetEvent(
+      const mozilla::WidgetMouseEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId);
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  mozilla::ipc::IPCResult RecvRealDragEvent(const WidgetDragEvent& aEvent,
+                                            const uint32_t& aDragAction,
+                                            const uint32_t& aDropEffect,
+                                            nsIPrincipal* aPrincipal,
+                                            nsIContentSecurityPolicy* aCsp);
+
+  mozilla::ipc::IPCResult RecvRealKeyEvent(
+      const mozilla::WidgetKeyboardEvent& aEvent, const nsID& aUUID);
+
+  mozilla::ipc::IPCResult RecvNormalPriorityRealKeyEvent(
+      const mozilla::WidgetKeyboardEvent& aEvent, const nsID& aUUID);
+
+  mozilla::ipc::IPCResult RecvMouseWheelEvent(
+      const mozilla::WidgetWheelEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId);
+
+  mozilla::ipc::IPCResult RecvNormalPriorityMouseWheelEvent(
+      const mozilla::WidgetWheelEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId);
+
+  mozilla::ipc::IPCResult RecvRealTouchEvent(const WidgetTouchEvent& aEvent,
+                                             const ScrollableLayerGuid& aGuid,
+                                             const uint64_t& aInputBlockId,
+                                             const nsEventStatus& aApzResponse);
+
+  mozilla::ipc::IPCResult RecvNormalPriorityRealTouchEvent(
+      const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse);
+
+  mozilla::ipc::IPCResult RecvRealTouchMoveEvent(
+      const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse);
+
+  mozilla::ipc::IPCResult RecvNormalPriorityRealTouchMoveEvent(
+      const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse);
+
+  mozilla::ipc::IPCResult RecvRealTouchMoveEvent2(
+      const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse) {
+    return RecvRealTouchMoveEvent(aEvent, aGuid, aInputBlockId, aApzResponse);
+  }
+
+  mozilla::ipc::IPCResult RecvNormalPriorityRealTouchMoveEvent2(
+      const WidgetTouchEvent& aEvent, const ScrollableLayerGuid& aGuid,
+      const uint64_t& aInputBlockId, const nsEventStatus& aApzResponse) {
+    return RecvNormalPriorityRealTouchMoveEvent(aEvent, aGuid, aInputBlockId,
+                                                aApzResponse);
+  }
+
+  mozilla::ipc::IPCResult RecvUpdateSHistory();
+
+  mozilla::ipc::IPCResult RecvNativeSynthesisResponse(
+      const uint64_t& aObserverId, const nsCString& aResponse);
+
+  mozilla::ipc::IPCResult RecvCompositionEvent(
+      const mozilla::WidgetCompositionEvent& aEvent);
+
+  mozilla::ipc::IPCResult RecvNormalPriorityCompositionEvent(
+      const mozilla::WidgetCompositionEvent& aEvent);
+
+  mozilla::ipc::IPCResult RecvSelectionEvent(
+      const mozilla::WidgetSelectionEvent& aEvent);
+
+  mozilla::ipc::IPCResult RecvNormalPrioritySelectionEvent(
+      const mozilla::WidgetSelectionEvent& aEvent);
+
+  mozilla::ipc::IPCResult RecvInsertText(const nsAString& aStringToInsert);
+
+  mozilla::ipc::IPCResult RecvUpdateRemoteStyle(
+      const StyleImageRendering& aImageRendering);
+
+  mozilla::ipc::IPCResult RecvNormalPriorityInsertText(
+      const nsAString& aStringToInsert);
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  mozilla::ipc::IPCResult RecvPasteTransferable(
+      const IPCTransferableData& aTransferableData, const bool& aIsPrivateData,
+      nsIPrincipal* aRequestingPrincipal,
+      const nsContentPolicyType& aContentPolicyType);
+
+  mozilla::ipc::IPCResult RecvLoadRemoteScript(const nsAString& aURL,
+                                               const bool& aRunInGlobalScope);
+
+  mozilla::ipc::IPCResult RecvAsyncMessage(const nsAString& aMessage,
+                                           const ClonedMessageData& aData);
+  mozilla::ipc::IPCResult RecvSwappedWithOtherRemoteLoader(
+      const IPCTabContext& aContext);
+
+  mozilla::ipc::IPCResult RecvSafeAreaInsetsChanged(
+      const mozilla::ScreenIntMargin& aSafeAreaInsets);
+
+#ifdef ACCESSIBILITY
+  PDocAccessibleChild* AllocPDocAccessibleChild(
+      PDocAccessibleChild*, const uint64_t&,
+      const MaybeDiscardedBrowsingContext&);
+  bool DeallocPDocAccessibleChild(PDocAccessibleChild*);
+#endif
+
+  RefPtr<VsyncMainChild> GetVsyncChild();
+
+  nsIWebNavigation* WebNavigation() const { return mWebNav; }
+
+  PuppetWidget* WebWidget() { return mPuppetWidget; }
+
+  bool IsTransparent() const { return mIsTransparent; }
+
+  const EffectsInfo& GetEffectsInfo() const { return mEffectsInfo; }
+
+  void SetBackgroundColor(const nscolor& aColor);
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY virtual mozilla::ipc::IPCResult RecvUpdateEffects(
+      const EffectsInfo& aEffects);
+
+  void RequestEditCommands(NativeKeyBindingsType aType,
+                           const WidgetKeyboardEvent& aEvent,
+                           nsTArray<CommandInt>& aCommands);
+
+  bool IsVisible();
+  bool IsPreservingLayers() const { return mIsPreservingLayers; }
+
+  /**
+   * Signal to this BrowserChild that it should be made visible:
+   * activated widget, retained layer tree, etc.  (Respectively,
+   * made not visible.)
+   */
+  MOZ_CAN_RUN_SCRIPT void UpdateVisibility();
+  MOZ_CAN_RUN_SCRIPT void MakeVisible();
+  void MakeHidden();
+  void PresShellActivenessMaybeChanged();
+
+  ContentChild* Manager() const { return mManager; }
+
+  static inline BrowserChild* GetFrom(nsIDocShell* aDocShell) {
+    if (!aDocShell) {
+      return nullptr;
+    }
+
+    nsCOMPtr<nsIBrowserChild> tc = aDocShell->GetBrowserChild();
+    return static_cast<BrowserChild*>(tc.get());
+  }
+
+  static inline BrowserChild* GetFrom(mozIDOMWindow* aWindow) {
+    nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(aWindow);
+    nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(webNav);
+    return GetFrom(docShell);
+  }
+
+  static inline BrowserChild* GetFrom(mozIDOMWindowProxy* aWindow) {
+    nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(aWindow);
+    nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(webNav);
+    return GetFrom(docShell);
+  }
+
+  static BrowserChild* GetFrom(PresShell* aPresShell);
+  static BrowserChild* GetFrom(layers::LayersId aLayersId);
+
+  layers::LayersId GetLayersId() { return mLayersId; }
+  Maybe<bool> IsLayersConnected() { return mLayersConnected; }
+
+  void DidComposite(mozilla::layers::TransactionId aTransactionId,
+                    const TimeStamp& aCompositeStart,
+                    const TimeStamp& aCompositeEnd);
+
+  void DidRequestComposite(const TimeStamp& aCompositeReqStart,
+                           const TimeStamp& aCompositeReqEnd);
+
+  void ClearCachedResources();
+  void SchedulePaint();
+  void ReinitRendering();
+  void ReinitRenderingForDeviceReset();
+
+  void NotifyJankedAnimations(const nsTArray<uint64_t>& aJankedAnimations);
+
+  static inline BrowserChild* GetFrom(nsIDOMWindow* aWindow) {
+    nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(aWindow);
+    nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(webNav);
+    return GetFrom(docShell);
+  }
+
+  mozilla::ipc::IPCResult RecvUIResolutionChanged(const float& aDpi,
+                                                  const int32_t& aRounding,
+                                                  const double& aScale);
+
+  mozilla::ipc::IPCResult RecvHandleAccessKey(const WidgetKeyboardEvent& aEvent,
+                                              nsTArray<uint32_t>&& aCharCodes);
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  mozilla::ipc::IPCResult RecvPrintPreview(const PrintData& aPrintData,
+                                           const MaybeDiscardedBrowsingContext&,
+                                           PrintPreviewResolver&& aCallback);
+
+  mozilla::ipc::IPCResult RecvExitPrintPreview();
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvPrint(
+      const MaybeDiscardedBrowsingContext&, const PrintData&);
+
+  mozilla::ipc::IPCResult RecvUpdateNativeWindowHandle(
+      const uintptr_t& aNewHandle);
+
+  mozilla::ipc::IPCResult RecvWillChangeProcess();
+
+  PPaymentRequestChild* AllocPPaymentRequestChild();
+
+  bool DeallocPPaymentRequestChild(PPaymentRequestChild* aActor);
+
+  LayoutDeviceIntPoint GetClientOffset() const { return mClientOffset; }
+  LayoutDeviceIntPoint GetChromeOffset() const { return mChromeOffset; };
+  ScreenIntCoord GetDynamicToolbarMaxHeight() const {
+    return mDynamicToolbarMaxHeight;
+  };
+
+  bool IPCOpen() const { return mIPCOpen; }
+
+  const mozilla::layers::CompositorOptions& GetCompositorOptions() const;
+  bool AsyncPanZoomEnabled() const;
+
+  ScreenIntSize GetInnerSize();
+  CSSSize GetUnscaledInnerSize() { return mUnscaledInnerSize; }
+
+  Maybe<nsRect> GetVisibleRect() const;
+
+  // Call RecvShow(nsIntSize(0, 0)) and block future calls to RecvShow().
+  void DoFakeShow(const ParentShowInfo&);
+
+  void ContentReceivedInputBlock(uint64_t aInputBlockId,
+                                 bool aPreventDefault) const;
+  void SetTargetAPZC(
+      uint64_t aInputBlockId,
+      const nsTArray<layers::ScrollableLayerGuid>& aTargets) const;
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  mozilla::ipc::IPCResult RecvHandleTap(
+      const layers::GeckoContentController_TapType& aType,
+      const LayoutDevicePoint& aPoint, const Modifiers& aModifiers,
+      const ScrollableLayerGuid& aGuid, const uint64_t& aInputBlockId);
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  mozilla::ipc::IPCResult RecvNormalPriorityHandleTap(
+      const layers::GeckoContentController_TapType& aType,
+      const LayoutDevicePoint& aPoint, const Modifiers& aModifiers,
+      const ScrollableLayerGuid& aGuid, const uint64_t& aInputBlockId);
+
+  bool UpdateFrame(const layers::RepaintRequest& aRequest);
+  bool NotifyAPZStateChange(
+      const ViewID& aViewId,
+      const layers::GeckoContentController_APZStateChange& aChange,
+      const int& aArg, Maybe<uint64_t> aInputBlockId);
+  void StartScrollbarDrag(const layers::AsyncDragMetrics& aDragMetrics);
+  void ZoomToRect(const uint32_t& aPresShellId,
+                  const ScrollableLayerGuid::ViewID& aViewId,
+                  const CSSRect& aRect, const uint32_t& aFlags);
+
+  // Request that the docshell be marked as active.
+  void PaintWhileInterruptingJS(const layers::LayersObserverEpoch& aEpoch);
+
+  void UnloadLayersWhileInterruptingJS(
+      const layers::LayersObserverEpoch& aEpoch);
+
+  nsresult CanCancelContentJS(nsIRemoteTab::NavigationType aNavigationType,
+                              int32_t aNavigationIndex, nsIURI* aNavigationURI,
+                              int32_t aEpoch, bool* aCanCancel);
+
+  layers::LayersObserverEpoch LayersObserverEpoch() const {
+    return mLayersObserverEpoch;
+  }
+
+#if defined(XP_WIN) && defined(ACCESSIBILITY)
+  uintptr_t GetNativeWindowHandle() const { return mNativeWindowHandle; }
+#endif
+
+  BrowsingContext* GetBrowsingContext() const { return mBrowsingContext; }
+
+#if defined(ACCESSIBILITY)
+  void SetTopLevelDocAccessibleChild(PDocAccessibleChild* aTopLevelChild) {
+    mTopLevelDocAccessibleChild = aTopLevelChild;
+  }
+
+  PDocAccessibleChild* GetTopLevelDocAccessibleChild() {
+    return mTopLevelDocAccessibleChild;
+  }
+#endif
+
+  // The transform from the coordinate space of this BrowserChild to the
+  // coordinate space of the native window its BrowserParent is in.
+  mozilla::LayoutDeviceToLayoutDeviceMatrix4x4
+  GetChildToParentConversionMatrix() const;
+
+  // Returns the portion of the visible rect of this remote document in the
+  // top browser window coordinate system.  This is the result of being clipped
+  // by all ancestor viewports.
+  Maybe<ScreenRect> GetTopLevelViewportVisibleRectInBrowserCoords() const;
+
+  // Similar to above GetTopLevelViewportVisibleRectInBrowserCoords(), but in
+  // this out-of-process document's coordinate system.
+  Maybe<LayoutDeviceRect> GetTopLevelViewportVisibleRectInSelfCoords() const;
+
+  // Prepare to dispatch all coalesced mousemove events. We'll move all data
+  // in mCoalescedMouseData to a nsDeque; then we start processing them. We
+  // can't fetch the coalesced event one by one and dispatch it because we may
+  // reentry the event loop and access to the same hashtable. It's called when
+  // dispatching some mouse events other than mousemove.
+  void FlushAllCoalescedMouseData();
+  void ProcessPendingCoalescedMouseDataAndDispatchEvents();
+
+  void ProcessPendingCoalescedTouchData();
+
+  void HandleRealMouseButtonEvent(const WidgetMouseEvent& aEvent,
+                                  const ScrollableLayerGuid& aGuid,
+                                  const uint64_t& aInputBlockId);
+
+  void SetCancelContentJSEpoch(int32_t aEpoch) {
+    mCancelContentJSEpoch = aEpoch;
+  }
+
+  void UpdateSessionStore();
+
+  mozilla::dom::SessionStoreChild* GetSessionStoreChild() {
+    return mSessionStoreChild;
+  }
+
+#ifdef XP_WIN
+  // Check if the window this BrowserChild is associated with supports
+  // protected media (EME) or not.
+  // Returns a promise the will resolve true if the window supports protected
+  // media or false if it does not. The promise will be rejected with an
+  // ResponseRejectReason if the IPC needed to do the check fails. Callers
+  // should treat the reject case as if the window does not support protected
+  // media to ensure robust handling.
+  RefPtr<IsWindowSupportingProtectedMediaPromise>
+  DoesWindowSupportProtectedMedia();
+#endif
+
+  // Notify the content blocking event in the parent process. This sends an IPC
+  // message to the BrowserParent in the parent. The BrowserParent will find the
+  // top-level WindowGlobalParent and notify the event from it.
+  void NotifyContentBlockingEvent(
+      uint32_t aEvent, nsIChannel* aChannel, bool aBlocked,
+      const nsACString& aTrackingOrigin,
+      const nsTArray<nsCString>& aTrackingFullHashes,
+      const Maybe<
+          ContentBlockingNotifier::StorageAccessPermissionGrantedReason>&
+          aReason);
+
+ protected:
+  virtual ~BrowserChild();
+
+  mozilla::ipc::IPCResult RecvDestroy();
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  mozilla::ipc::IPCResult RecvRenderLayers(
+      const bool& aEnabled, const layers::LayersObserverEpoch& aEpoch);
+
+  mozilla::ipc::IPCResult RecvPreserveLayers(bool);
+
+  mozilla::ipc::IPCResult RecvNavigateByKey(const bool& aForward,
+                                            const bool& aForDocumentNavigation);
+
+  mozilla::ipc::IPCResult RecvSuppressDisplayport(const bool& aEnabled);
+
+  mozilla::ipc::IPCResult RecvScrollbarPreferenceChanged(ScrollbarPreference);
+
+  mozilla::ipc::IPCResult RecvStopIMEStateManagement();
+
+  mozilla::ipc::IPCResult RecvAllowScriptsToClose();
+
+  mozilla::ipc::IPCResult RecvReleaseAllPointerCapture();
+
+ private:
+  void HandleDoubleTap(const CSSPoint& aPoint, const Modifiers& aModifiers,
+                       const ScrollableLayerGuid& aGuid);
+
+  void ActorDestroy(ActorDestroyReason why) override;
+
+  bool InitBrowserChildMessageManager();
+
+  void InitRenderingState(
+      const TextureFactoryIdentifier& aTextureFactoryIdentifier,
+      const layers::LayersId& aLayersId,
+      const mozilla::layers::CompositorOptions& aCompositorOptions);
+  void InitAPZState();
+
+  void DestroyWindow();
+
+  void ApplyParentShowInfo(const ParentShowInfo&);
+
+  bool HasValidInnerSize();
+
+  ScreenIntRect GetOuterRect();
+
+  void SetUnscaledInnerSize(const CSSSize& aSize) {
+    mUnscaledInnerSize = aSize;
+  }
+
+  bool SkipRepeatedKeyEvent(const WidgetKeyboardEvent& aEvent);
+
+  void UpdateRepeatedKeyEventEndTime(const WidgetKeyboardEvent& aEvent);
+
+  void DispatchCoalescedWheelEvent();
+
+  /**
+   * Dispatch aEvent on aEvent.mWidget.
+   */
+  nsEventStatus DispatchWidgetEventViaAPZ(WidgetGUIEvent& aEvent);
+
+  void DispatchWheelEvent(const WidgetWheelEvent& aEvent,
+                          const ScrollableLayerGuid& aGuid,
+                          const uint64_t& aInputBlockId);
+
+  void InternalSetDocShellIsActive(bool aIsActive);
+
+  bool CreateRemoteLayerManager(
+      mozilla::layers::PCompositorBridgeChild* aCompositorChild);
+
+  nsresult PrepareRequestData(nsIRequest* aRequest, RequestData& aRequestData);
+  nsresult PrepareProgressListenerData(nsIWebProgress* aWebProgress,
+                                       nsIRequest* aRequest,
+                                       WebProgressData& aWebProgressData,
+                                       RequestData& aRequestData);
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  nsresult UpdateRemotePrintSettings(const embedding::PrintData& aPrintData);
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  nsresult CloneDocumentTreeIntoSelf(
+      const MaybeDiscarded<BrowsingContext>& aSourceBC,
+      const embedding::PrintData& aPrintData);
+
+  class DelayedDeleteRunnable;
+
+  RefPtr<BrowserChildMessageManager> mBrowserChildMessageManager;
+  TextureFactoryIdentifier mTextureFactoryIdentifier;
+  RefPtr<nsWebBrowser> mWebBrowser;
+  nsCOMPtr<nsIWebNavigation> mWebNav;
+  RefPtr<PuppetWidget> mPuppetWidget;
+  nsCOMPtr<nsIURI> mLastURI;
+  RefPtr<ContentChild> mManager;
+  RefPtr<BrowsingContext> mBrowsingContext;
+  RefPtr<nsBrowserStatusFilter> mStatusFilter;
+  uint32_t mChromeFlags;
+  uint32_t mMaxTouchPoints;
+  layers::LayersId mLayersId;
+  CSSRect mUnscaledOuterRect;
+  Maybe<bool> mLayersConnected;
+  Maybe<bool> mLayersConnectRequested;
+  EffectsInfo mEffectsInfo;
+
+  RefPtr<VsyncMainChild> mVsyncChild;
+
+  RefPtr<APZEventState> mAPZEventState;
+
+  // Position of client area relative to the outer window
+  LayoutDeviceIntPoint mClientOffset;
+  // Position of tab, relative to parent widget (typically the window)
+  // NOTE: This value is valuable only for the top level browser.
+  LayoutDeviceIntPoint mChromeOffset;
+  ScreenIntCoord mDynamicToolbarMaxHeight;
+  TabId mUniqueId;
+
+  bool mDidFakeShow : 1;
+  bool mTriedBrowserInit : 1;
+  bool mIgnoreKeyPressEvent : 1;
+  bool mHasValidInnerSize : 1;
+  bool mDestroyed : 1;
+
+  // Whether or not this browser is the child part of the top level PBrowser
+  // actor in a remote browser.
+  bool mIsTopLevel : 1;
+
+  bool mIsTransparent : 1;
+  bool mIPCOpen : 1;
+
+  bool mDidSetRealShowInfo : 1;
+  bool mDidLoadURLInit : 1;
+
+  bool mSkipKeyPress : 1;
+  bool mDidSetEffectsInfo : 1;
+
+  bool mCoalesceMouseMoveEvents : 1;
+
+  bool mShouldSendWebProgressEventsToParent : 1;
+
+  // Whether we are rendering to the compositor or not.
+  bool mRenderLayers : 1;
+
+  // Whether we're artificially preserving layers.
+  bool mIsPreservingLayers : 1;
+
+  // Holds the compositor options for the compositor rendering this tab,
+  // once we find out which compositor that is.
+  Maybe<mozilla::layers::CompositorOptions> mCompositorOptions;
+
+  friend class ContentChild;
+
+  CSSSize mUnscaledInnerSize;
+
+  // Store the end time of the handling of the last repeated keydown/keypress
+  // event so that in case event handling takes time, some repeated events can
+  // be skipped to not flood child process.
+  mozilla::TimeStamp mRepeatedKeyEventTime;
+
+  // Similar to mRepeatedKeyEventTime, store the end time (from parent process)
+  // of handling the last repeated wheel event so that in case event handling
+  // takes time, some repeated events can be skipped to not flood child process.
+  mozilla::TimeStamp mLastWheelProcessedTimeFromParent;
+  mozilla::TimeDuration mLastWheelProcessingDuration;
+
+  // Hash table to track coalesced mousemove events for different pointers.
+  nsClassHashtable<nsUint32HashKey, CoalescedMouseData> mCoalescedMouseData;
+
+  nsDeque<CoalescedMouseData> mToBeDispatchedMouseData;
+
+  CoalescedWheelData mCoalescedWheelData;
+  CoalescedTouchData mCoalescedTouchData;
+
+  RefPtr<CoalescedMouseMoveFlusher> mCoalescedMouseEventFlusher;
+  RefPtr<CoalescedTouchMoveFlusher> mCoalescedTouchMoveEventFlusher;
+
+  RefPtr<layers::IAPZCTreeManager> mApzcTreeManager;
+  RefPtr<SessionStoreChild> mSessionStoreChild;
+
+  // The most recently seen layer observer epoch in RecvSetDocShellIsActive.
+  layers::LayersObserverEpoch mLayersObserverEpoch;
+
+#if defined(XP_WIN) && defined(ACCESSIBILITY)
+  // The handle associated with the native window that contains this tab
+  uintptr_t mNativeWindowHandle;
+#endif  // defined(XP_WIN)
+
+#if defined(ACCESSIBILITY)
+  PDocAccessibleChild* mTopLevelDocAccessibleChild;
+#endif
+  int32_t mCancelContentJSEpoch;
+
+  Maybe<LayoutDeviceToLayoutDeviceMatrix4x4> mChildToParentConversionMatrix;
+  // When mChildToParentConversionMatrix is Nothing() this value is invalid.
+  ScreenRect mTopLevelViewportVisibleRectInBrowserCoords;
+
+#ifdef XP_WIN
+  // Should only be accessed on main thread.
+  Maybe<bool> mWindowSupportsProtectedMedia;
+#endif
+
+  // If set, resolve when we receive ChildToParentMatrix.
+  RefPtr<dom::Promise> mContentTransformPromise;
+
+  DISALLOW_EVIL_CONSTRUCTORS(BrowserChild);
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_BrowserChild_h
diff --git a/dom/ipc/BrowserHost.cpp b/dom/ipc/BrowserHost.cpp
new file mode 100644
index 0000000000..d0ce7c6ba4
--- /dev/null
+++ b/dom/ipc/BrowserHost.cpp
@@ -0,0 +1,289 @@
+/* -*- 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 "mozilla/dom/BrowserHost.h"
+
+#include "mozilla/Unused.h"
+#include "mozilla/dom/CancelContentJSOptionsBinding.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/WindowGlobalParent.h"
+#include "mozilla/ProcessPriorityManager.h"
+
+#include "nsIObserverService.h"
+
+namespace mozilla::dom {
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(BrowserHost)
+  NS_INTERFACE_MAP_ENTRY(nsIRemoteTab)
+  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, RemoteBrowser)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTION_WEAK(BrowserHost, mRoot)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(BrowserHost)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(BrowserHost)
+
+BrowserHost::BrowserHost(BrowserParent* aParent)
+    : mId(aParent->GetTabId()),
+      mRoot(aParent),
+      mEffectsInfo{EffectsInfo::FullyHidden()} {
+  mRoot->SetBrowserHost(this);
+}
+
+BrowserHost* BrowserHost::GetFrom(nsIRemoteTab* aRemoteTab) {
+  return static_cast<BrowserHost*>(aRemoteTab);
+}
+
+TabId BrowserHost::GetTabId() const { return mId; }
+
+mozilla::layers::LayersId BrowserHost::GetLayersId() const {
+  return mRoot->GetLayersId();
+}
+
+BrowsingContext* BrowserHost::GetBrowsingContext() const {
+  return mRoot->GetBrowsingContext();
+}
+
+nsILoadContext* BrowserHost::GetLoadContext() const {
+  RefPtr<nsILoadContext> loadContext = mRoot->GetLoadContext();
+  return loadContext;
+}
+
+bool BrowserHost::CanRecv() const { return mRoot && mRoot->CanRecv(); }
+
+a11y::DocAccessibleParent* BrowserHost::GetTopLevelDocAccessible() const {
+  return mRoot ? mRoot->GetTopLevelDocAccessible() : nullptr;
+}
+
+void BrowserHost::LoadURL(nsDocShellLoadState* aLoadState) {
+  MOZ_ASSERT(aLoadState);
+  mRoot->LoadURL(aLoadState);
+}
+
+void BrowserHost::ResumeLoad(uint64_t aPendingSwitchId) {
+  mRoot->ResumeLoad(aPendingSwitchId);
+}
+
+void BrowserHost::DestroyStart() { mRoot->Destroy(); }
+
+void BrowserHost::DestroyComplete() {
+  if (!mRoot) {
+    return;
+  }
+  mRoot->SetOwnerElement(nullptr);
+  mRoot->Destroy();
+  mRoot->SetBrowserHost(nullptr);
+  mRoot = nullptr;
+
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  if (os) {
+    os->NotifyObservers(NS_ISUPPORTS_CAST(nsIRemoteTab*, this),
+                        "ipc:browser-destroyed", nullptr);
+  }
+}
+
+bool BrowserHost::Show(const OwnerShowInfo& aShowInfo) {
+  return mRoot->Show(aShowInfo);
+}
+
+void BrowserHost::UpdateDimensions(const nsIntRect& aRect,
+                                   const ScreenIntSize& aSize) {
+  mRoot->UpdateDimensions(aRect, aSize);
+}
+
+void BrowserHost::UpdateEffects(EffectsInfo aEffects) {
+  if (!mRoot || mEffectsInfo == aEffects) {
+    return;
+  }
+  mEffectsInfo = aEffects;
+  Unused << mRoot->SendUpdateEffects(mEffectsInfo);
+}
+
+/* attribute boolean renderLayers; */
+NS_IMETHODIMP
+BrowserHost::GetRenderLayers(bool* aRenderLayers) {
+  if (!mRoot) {
+    *aRenderLayers = false;
+    return NS_OK;
+  }
+  *aRenderLayers = mRoot->GetRenderLayers();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+BrowserHost::SetRenderLayers(bool aRenderLayers) {
+  if (!mRoot) {
+    return NS_OK;
+  }
+
+  mRoot->SetRenderLayers(aRenderLayers);
+  return NS_OK;
+}
+
+/* readonly attribute boolean hasLayers; */
+NS_IMETHODIMP
+BrowserHost::GetHasLayers(bool* aHasLayers) {
+  *aHasLayers = mRoot && mRoot->GetHasLayers();
+  return NS_OK;
+}
+
+/* attribute boolean priorityHint; */
+NS_IMETHODIMP
+BrowserHost::SetPriorityHint(bool aPriorityHint) {
+  if (!mRoot) {
+    return NS_OK;
+  }
+  mRoot->SetPriorityHint(aPriorityHint);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+BrowserHost::GetPriorityHint(bool* aPriorityHint) {
+  *aPriorityHint = mRoot && mRoot->GetPriorityHint();
+  return NS_OK;
+}
+
+/* void resolutionChanged (); */
+NS_IMETHODIMP
+BrowserHost::NotifyResolutionChanged() {
+  if (!mRoot) {
+    return NS_OK;
+  }
+  VisitAll([](BrowserParent* aBrowserParent) {
+    aBrowserParent->NotifyResolutionChanged();
+  });
+  return NS_OK;
+}
+
+/* void deprioritize (); */
+NS_IMETHODIMP
+BrowserHost::Deprioritize() {
+  if (!mRoot) {
+    return NS_OK;
+  }
+  auto* bc = GetBrowsingContext()->Canonical();
+  ProcessPriorityManager::BrowserPriorityChanged(bc,
+                                                 /* aPriority = */ false);
+  return NS_OK;
+}
+
+/* void preserveLayers (in boolean aPreserveLayers); */
+NS_IMETHODIMP
+BrowserHost::PreserveLayers(bool aPreserveLayers) {
+  if (!mRoot) {
+    return NS_OK;
+  }
+  VisitAll([&](BrowserParent* aBrowserParent) {
+    aBrowserParent->PreserveLayers(aPreserveLayers);
+  });
+  return NS_OK;
+}
+
+/* readonly attribute uint64_t tabId; */
+NS_IMETHODIMP
+BrowserHost::GetTabId(uint64_t* aTabId) {
+  *aTabId = mId;
+  return NS_OK;
+}
+
+/* readonly attribute uint64_t contentProcessId; */
+NS_IMETHODIMP
+BrowserHost::GetContentProcessId(uint64_t* aContentProcessId) {
+  if (!mRoot) {
+    *aContentProcessId = 0;
+    return NS_OK;
+  }
+  *aContentProcessId = GetContentParent()->ChildID();
+  return NS_OK;
+}
+
+/* readonly attribute int32_t osPid; */
+NS_IMETHODIMP
+BrowserHost::GetOsPid(int32_t* aOsPid) {
+  if (!mRoot) {
+    *aOsPid = 0;
+    return NS_OK;
+  }
+  *aOsPid = GetContentParent()->Pid();
+  return NS_OK;
+}
+
+/* readonly attribute BrowsingContext browsingContext; */
+NS_IMETHODIMP
+BrowserHost::GetBrowsingContext(BrowsingContext** aBc) {
+  if (!mRoot) {
+    *aBc = nullptr;
+    return NS_OK;
+  }
+  RefPtr<BrowsingContext> bc = mRoot->GetBrowsingContext();
+  bc.forget(aBc);
+  return NS_OK;
+}
+
+/* readonly attribute boolean hasPresented; */
+NS_IMETHODIMP
+BrowserHost::GetHasPresented(bool* aHasPresented) {
+  if (!mRoot) {
+    *aHasPresented = false;
+    return NS_OK;
+  }
+  *aHasPresented = mRoot->GetHasPresented();
+  return NS_OK;
+}
+
+/* void transmitPermissionsForPrincipal (in nsIPrincipal aPrincipal); */
+NS_IMETHODIMP
+BrowserHost::TransmitPermissionsForPrincipal(nsIPrincipal* aPrincipal) {
+  if (!mRoot) {
+    return NS_OK;
+  }
+  return GetContentParent()->TransmitPermissionsForPrincipal(aPrincipal);
+}
+
+/* void createAboutBlankContentViewer(in nsIPrincipal aPrincipal, in
+ * nsIPrincipal aPartitionedPrincipal); */
+NS_IMETHODIMP
+BrowserHost::CreateAboutBlankContentViewer(
+    nsIPrincipal* aPrincipal, nsIPrincipal* aPartitionedPrincipal) {
+  if (!mRoot) {
+    return NS_OK;
+  }
+
+  // Ensure the content process has permisisons for the new document we're about
+  // to create in it.
+  nsresult rv = GetContentParent()->TransmitPermissionsForPrincipal(aPrincipal);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  Unused << mRoot->SendCreateAboutBlankContentViewer(aPrincipal,
+                                                     aPartitionedPrincipal);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+BrowserHost::MaybeCancelContentJSExecutionFromScript(
+    nsIRemoteTab::NavigationType aNavigationType,
+    JS::Handle<JS::Value> aCancelContentJSOptions, JSContext* aCx) {
+  // If we're in the process of creating a new window (via window.open), then
+  // the load that called this function isn't a "normal" load and should be
+  // ignored for the purposes of cancelling content JS.
+  if (!mRoot || mRoot->CreatingWindow()) {
+    return NS_OK;
+  }
+  dom::CancelContentJSOptions cancelContentJSOptions;
+  if (!cancelContentJSOptions.Init(aCx, aCancelContentJSOptions)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+  if (StaticPrefs::dom_ipc_cancel_content_js_when_navigating()) {
+    GetContentParent()->CancelContentJSExecutionIfRunning(
+        mRoot, aNavigationType, cancelContentJSOptions);
+  }
+  return NS_OK;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/BrowserHost.h b/dom/ipc/BrowserHost.h
new file mode 100644
index 0000000000..5b651a1df0
--- /dev/null
+++ b/dom/ipc/BrowserHost.h
@@ -0,0 +1,109 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_BrowserHost_h
+#define mozilla_dom_BrowserHost_h
+
+#include "nsIRemoteTab.h"
+#include "mozilla/dom/RemoteBrowser.h"
+#include "mozilla/dom/BrowserParent.h"
+
+class nsPIDOMWindowOuter;
+
+namespace mozilla {
+
+namespace a11y {
+class DocAccessibleParent;
+}  // namespace a11y
+
+namespace dom {
+
+class Element;
+
+/**
+ * BrowserHost manages a remote browser from the chrome process.
+ *
+ * It is used via the RemoteBrowser interface in nsFrameLoader and supports
+ * operations over the tree of BrowserParent/BrowserBridgeParent's.
+ *
+ * See `dom/docs/Fission-IPC-Diagram.svg` for an overview of the DOM IPC
+ * actors.
+ */
+class BrowserHost : public RemoteBrowser,
+                    public nsIRemoteTab,
+                    public nsSupportsWeakReference {
+ public:
+  typedef mozilla::layers::LayersId LayersId;
+
+  explicit BrowserHost(BrowserParent* aParent);
+
+  static BrowserHost* GetFrom(nsIRemoteTab* aRemoteTab);
+
+  // NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  // nsIRemoteTab
+  NS_DECL_NSIREMOTETAB
+
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(BrowserHost, RemoteBrowser)
+
+  // Get the IPDL actor for the root BrowserParent. This method should be
+  // avoided and consumers migrated to use this class.
+  BrowserParent* GetActor() { return mRoot; }
+  ContentParent* GetContentParent() const {
+    return mRoot ? mRoot->Manager() : nullptr;
+  }
+
+  BrowserHost* AsBrowserHost() override { return this; }
+  BrowserBridgeHost* AsBrowserBridgeHost() override { return nullptr; }
+
+  TabId GetTabId() const override;
+  LayersId GetLayersId() const override;
+  BrowsingContext* GetBrowsingContext() const override;
+  nsILoadContext* GetLoadContext() const override;
+  bool CanRecv() const override;
+
+  Element* GetOwnerElement() const { return mRoot->GetOwnerElement(); }
+  already_AddRefed<nsPIDOMWindowOuter> GetParentWindowOuter() const {
+    return mRoot->GetParentWindowOuter();
+  }
+  a11y::DocAccessibleParent* GetTopLevelDocAccessible() const;
+
+  // Visit each BrowserParent in the tree formed by PBrowser and
+  // PBrowserBridge that is anchored by `mRoot`.
+  template <typename Callback>
+  void VisitAll(Callback aCallback) {
+    if (!mRoot) {
+      return;
+    }
+    mRoot->VisitAll(aCallback);
+  }
+
+  void LoadURL(nsDocShellLoadState* aLoadState) override;
+  void ResumeLoad(uint64_t aPendingSwitchId) override;
+  void DestroyStart() override;
+  void DestroyComplete() override;
+
+  bool Show(const OwnerShowInfo&) override;
+  void UpdateDimensions(const nsIntRect& aRect,
+                        const ScreenIntSize& aSize) override;
+
+  void UpdateEffects(EffectsInfo aInfo) override;
+
+ private:
+  virtual ~BrowserHost() = default;
+
+  // The TabID for the root BrowserParent, we cache this so that we can access
+  // it after the remote browser has been destroyed
+  TabId mId;
+  // The root BrowserParent of this remote browser
+  RefPtr<BrowserParent> mRoot;
+  EffectsInfo mEffectsInfo;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_BrowserHost_h
diff --git a/dom/ipc/BrowserParent.cpp b/dom/ipc/BrowserParent.cpp
new file mode 100644
index 0000000000..2fc97d4c64
--- /dev/null
+++ b/dom/ipc/BrowserParent.cpp
@@ -0,0 +1,4120 @@
+/* -*- 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 "base/basictypes.h"
+
+#include "BrowserParent.h"
+#include "mozilla/AlreadyAddRefed.h"
+#include "mozilla/EventForwards.h"
+
+#ifdef ACCESSIBILITY
+#  include "mozilla/a11y/DocAccessibleParent.h"
+#  include "mozilla/a11y/Platform.h"
+#  include "mozilla/a11y/RemoteAccessibleBase.h"
+#  include "nsAccessibilityService.h"
+#endif
+#include "mozilla/Components.h"
+#include "mozilla/dom/BrowserHost.h"
+#include "mozilla/dom/BrowserSessionStore.h"
+#include "mozilla/dom/BrowsingContextGroup.h"
+#include "mozilla/dom/CancelContentJSOptionsBinding.h"
+#include "mozilla/dom/ChromeMessageSender.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/ContentProcessManager.h"
+#include "mozilla/dom/DataTransfer.h"
+#include "mozilla/dom/DataTransferItemList.h"
+#include "mozilla/dom/DocumentInlines.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/indexedDB/ActorsParent.h"
+#include "mozilla/dom/PaymentRequestParent.h"
+#include "mozilla/dom/PointerEventHandler.h"
+#include "mozilla/dom/BrowserBridgeParent.h"
+#include "mozilla/dom/RemoteDragStartData.h"
+#include "mozilla/dom/RemoteWebProgressRequest.h"
+#include "mozilla/dom/SessionHistoryEntry.h"
+#include "mozilla/dom/SessionStoreParent.h"
+#include "mozilla/dom/UserActivation.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/DataSurfaceHelpers.h"
+#include "mozilla/gfx/GPUProcessManager.h"
+#include "mozilla/IMEStateManager.h"
+#include "mozilla/ipc/Endpoint.h"
+#include "mozilla/layers/AsyncDragMetrics.h"
+#include "mozilla/layers/InputAPZContext.h"
+#include "mozilla/layout/RemoteLayerTreeOwner.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MiscEvents.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/NativeKeyBindingsType.h"
+#include "mozilla/net/NeckoChild.h"
+#include "mozilla/net/CookieJarSettings.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/ProcessHangMonitor.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/TextEventDispatcher.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/TouchEvents.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Unused.h"
+#include "nsCOMPtr.h"
+#include "nsContentUtils.h"
+#include "nsDebug.h"
+#include "nsFocusManager.h"
+#include "nsFrameLoader.h"
+#include "nsFrameLoaderOwner.h"
+#include "nsFrameManager.h"
+#include "nsIBaseWindow.h"
+#include "nsIBrowser.h"
+#include "nsIBrowserController.h"
+#include "nsIContent.h"
+#include "nsICookieJarSettings.h"
+#include "nsIDocShell.h"
+#include "nsIDocShellTreeOwner.h"
+#include "nsImportModule.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsILoadInfo.h"
+#include "nsIPromptFactory.h"
+#include "nsIURI.h"
+#include "nsIWebBrowserChrome.h"
+#include "nsIWebProtocolHandlerRegistrar.h"
+#include "nsIWindowWatcher.h"
+#include "nsIXPConnect.h"
+#include "nsIXULBrowserWindow.h"
+#include "nsIAppWindow.h"
+#include "nsLayoutUtils.h"
+#include "nsQueryActor.h"
+#include "nsSHistory.h"
+#include "nsViewManager.h"
+#include "nsVariant.h"
+#include "nsIWidget.h"
+#include "nsNetUtil.h"
+#ifndef XP_WIN
+#  include "nsJARProtocolHandler.h"
+#endif
+#include "nsPIDOMWindow.h"
+#include "nsPrintfCString.h"
+#include "nsQueryObject.h"
+#include "nsServiceManagerUtils.h"
+#include "nsThreadUtils.h"
+#include "PermissionMessageUtils.h"
+#include "StructuredCloneData.h"
+#include "ColorPickerParent.h"
+#include "FilePickerParent.h"
+#include "BrowserChild.h"
+#include "nsNetCID.h"
+#include "nsIAuthInformation.h"
+#include "nsIAuthPromptCallback.h"
+#include "nsAuthInformationHolder.h"
+#include "nsICancelable.h"
+#include "gfxUtils.h"
+#include "nsILoginManagerAuthPrompter.h"
+#include "nsPIWindowRoot.h"
+#include "nsReadableUtils.h"
+#include "nsIAuthPrompt2.h"
+#include "gfxDrawable.h"
+#include "ImageOps.h"
+#include "UnitTransforms.h"
+#include <algorithm>
+#include "mozilla/NullPrincipal.h"
+#include "mozilla/WebBrowserPersistDocumentParent.h"
+#include "ProcessPriorityManager.h"
+#include "nsString.h"
+#include "IHistory.h"
+#include "mozilla/dom/WindowGlobalParent.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/ProfilerLabels.h"
+#include "MMPrinter.h"
+#include "mozilla/dom/CrashReport.h"
+#include "nsISecureBrowserUI.h"
+#include "nsIXULRuntime.h"
+#include "VsyncSource.h"
+#include "nsSubDocumentFrame.h"
+
+#ifdef XP_WIN
+#  include "FxRWindowManager.h"
+#endif
+
+#if defined(XP_WIN) && defined(ACCESSIBILITY)
+#  include "mozilla/a11y/AccessibleWrap.h"
+#  include "mozilla/a11y/Compatibility.h"
+#  include "mozilla/a11y/nsWinUtils.h"
+#endif
+
+#ifdef MOZ_ANDROID_HISTORY
+#  include "GeckoViewHistory.h"
+#endif
+
+#if defined(MOZ_WIDGET_ANDROID)
+#  include "mozilla/widget/nsWindow.h"
+#endif  // defined(MOZ_WIDGET_ANDROID)
+
+using namespace mozilla::dom;
+using namespace mozilla::ipc;
+using namespace mozilla::layers;
+using namespace mozilla::layout;
+using namespace mozilla::services;
+using namespace mozilla::widget;
+using namespace mozilla::gfx;
+
+using mozilla::LazyLogModule;
+
+extern mozilla::LazyLogModule gSHIPBFCacheLog;
+
+LazyLogModule gBrowserFocusLog("BrowserFocus");
+
+#define LOGBROWSERFOCUS(args) \
+  MOZ_LOG(gBrowserFocusLog, mozilla::LogLevel::Debug, args)
+
+/* static */
+BrowserParent* BrowserParent::sFocus = nullptr;
+/* static */
+BrowserParent* BrowserParent::sTopLevelWebFocus = nullptr;
+/* static */
+BrowserParent* BrowserParent::sLastMouseRemoteTarget = nullptr;
+
+// The flags passed by the webProgress notifications are 16 bits shifted
+// from the ones registered by webProgressListeners.
+#define NOTIFY_FLAG_SHIFT 16
+
+namespace mozilla {
+
+/**
+ * Store data of a keypress event which is requesting to handled it in a remote
+ * process or some remote processes.
+ */
+class RequestingAccessKeyEventData {
+ public:
+  RequestingAccessKeyEventData() = delete;
+
+  static void OnBrowserParentCreated() {
+    MOZ_ASSERT(sBrowserParentCount <= INT32_MAX);
+    sBrowserParentCount++;
+  }
+  static void OnBrowserParentDestroyed() {
+    MOZ_ASSERT(sBrowserParentCount > 0);
+    sBrowserParentCount--;
+    // To avoid memory leak, we need to reset sData when the last BrowserParent
+    // is destroyed.
+    if (!sBrowserParentCount) {
+      Clear();
+    }
+  }
+
+  static void Set(const WidgetKeyboardEvent& aKeyPressEvent) {
+    MOZ_ASSERT(aKeyPressEvent.mMessage == eKeyPress);
+    MOZ_ASSERT(sBrowserParentCount > 0);
+    sData =
+        Some(Data{aKeyPressEvent.mAlternativeCharCodes, aKeyPressEvent.mKeyCode,
+                  aKeyPressEvent.mCharCode, aKeyPressEvent.mKeyNameIndex,
+                  aKeyPressEvent.mCodeNameIndex, aKeyPressEvent.mKeyValue,
+                  aKeyPressEvent.mModifiers});
+  }
+
+  static void Clear() { sData.reset(); }
+
+  [[nodiscard]] static bool Equals(const WidgetKeyboardEvent& aKeyPressEvent) {
+    MOZ_ASSERT(sBrowserParentCount > 0);
+    return sData.isSome() && sData->Equals(aKeyPressEvent);
+  }
+
+  [[nodiscard]] static bool IsSet() {
+    MOZ_ASSERT(sBrowserParentCount > 0);
+    return sData.isSome();
+  }
+
+ private:
+  struct Data {
+    [[nodiscard]] bool Equals(const WidgetKeyboardEvent& aKeyPressEvent) {
+      return mKeyCode == aKeyPressEvent.mKeyCode &&
+             mCharCode == aKeyPressEvent.mCharCode &&
+             mKeyNameIndex == aKeyPressEvent.mKeyNameIndex &&
+             mCodeNameIndex == aKeyPressEvent.mCodeNameIndex &&
+             mKeyValue == aKeyPressEvent.mKeyValue &&
+             mModifiers == aKeyPressEvent.mModifiers &&
+             mAlternativeCharCodes == aKeyPressEvent.mAlternativeCharCodes;
+    }
+
+    CopyableTArray<AlternativeCharCode> mAlternativeCharCodes;
+    uint32_t mKeyCode;
+    uint32_t mCharCode;
+    KeyNameIndex mKeyNameIndex;
+    CodeNameIndex mCodeNameIndex;
+    nsString mKeyValue;
+    Modifiers mModifiers;
+  };
+  static Maybe<Data> sData;
+  static int32_t sBrowserParentCount;
+};
+int32_t RequestingAccessKeyEventData::sBrowserParentCount = 0;
+Maybe<RequestingAccessKeyEventData::Data> RequestingAccessKeyEventData::sData;
+
+namespace dom {
+
+BrowserParent::LayerToBrowserParentTable*
+    BrowserParent::sLayerToBrowserParentTable = nullptr;
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(BrowserParent)
+  NS_INTERFACE_MAP_ENTRY(nsIAuthPromptProvider)
+  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMEventListener)
+NS_INTERFACE_MAP_END
+NS_IMPL_CYCLE_COLLECTION_WEAK(BrowserParent, mFrameLoader, mBrowsingContext)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(BrowserParent)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(BrowserParent)
+
+BrowserParent::BrowserParent(ContentParent* aManager, const TabId& aTabId,
+                             const TabContext& aContext,
+                             CanonicalBrowsingContext* aBrowsingContext,
+                             uint32_t aChromeFlags)
+    : TabContext(aContext),
+      mTabId(aTabId),
+      mManager(aManager),
+      mBrowsingContext(aBrowsingContext),
+      mFrameElement(nullptr),
+      mBrowserDOMWindow(nullptr),
+      mFrameLoader(nullptr),
+      mChromeFlags(aChromeFlags),
+      mBrowserBridgeParent(nullptr),
+      mBrowserHost(nullptr),
+      mContentCache(*this),
+      mRemoteLayerTreeOwner{},
+      mLayerTreeEpoch{1},
+      mChildToParentConversionMatrix{},
+      mRect(0, 0, 0, 0),
+      mDimensions(0, 0),
+      mDPI(0),
+      mRounding(0),
+      mDefaultScale(0),
+      mUpdatedDimensions(false),
+      mSizeMode(nsSizeMode_Normal),
+      mClientOffset{},
+      mChromeOffset{},
+      mCreatingWindow(false),
+      mDelayedFrameScripts{},
+      mVsyncParent(nullptr),
+      mMarkedDestroying(false),
+      mIsDestroyed(false),
+      mRemoteTargetSetsCursor(false),
+      mIsPreservingLayers(false),
+      mRenderLayers(true),
+      mPriorityHint(false),
+      mHasLayers(false),
+      mHasPresented(false),
+      mIsReadyToHandleInputEvents(false),
+      mIsMouseEnterIntoWidgetEventSuppressed(false),
+      mLockedNativePointer(false),
+      mShowingTooltip(false) {
+  MOZ_ASSERT(aManager);
+
+  RequestingAccessKeyEventData::OnBrowserParentCreated();
+
+  // When the input event queue is disabled, we don't need to handle the case
+  // that some input events are dispatched before PBrowserConstructor.
+  mIsReadyToHandleInputEvents = !ContentParent::IsInputEventQueueSupported();
+
+  // Make sure to compute our process priority if needed before the block of
+  // code below. This makes sure the block below prioritizes our process if
+  // needed.
+  if (aBrowsingContext->IsTop()) {
+    RecomputeProcessPriority();
+  }
+
+  // If we're in a BC tree that is active with respect to the priority manager,
+  // ensure that this new BrowserParent is marked as active. This ensures that
+  // the process will be prioritized in a cross-site iframe navigation in an
+  // active tab, and also that the process is correctly prioritized if we got
+  // created for a browsing context which was already active.
+  if (aBrowsingContext->Top()->IsPriorityActive()) {
+    ProcessPriorityManager::BrowserPriorityChanged(this, true);
+  }
+}
+
+BrowserParent::~BrowserParent() {
+  RequestingAccessKeyEventData::OnBrowserParentDestroyed();
+}
+
+/* static */
+BrowserParent* BrowserParent::GetFocused() { return sFocus; }
+
+/* static */
+BrowserParent* BrowserParent::GetLastMouseRemoteTarget() {
+  return sLastMouseRemoteTarget;
+}
+
+/*static*/
+BrowserParent* BrowserParent::GetFrom(nsFrameLoader* aFrameLoader) {
+  if (!aFrameLoader) {
+    return nullptr;
+  }
+  return aFrameLoader->GetBrowserParent();
+}
+
+/*static*/
+BrowserParent* BrowserParent::GetFrom(PBrowserParent* aBrowserParent) {
+  return static_cast<BrowserParent*>(aBrowserParent);
+}
+
+/*static*/
+BrowserParent* BrowserParent::GetFrom(nsIContent* aContent) {
+  RefPtr<nsFrameLoaderOwner> loaderOwner = do_QueryObject(aContent);
+  if (!loaderOwner) {
+    return nullptr;
+  }
+  RefPtr<nsFrameLoader> frameLoader = loaderOwner->GetFrameLoader();
+  return GetFrom(frameLoader);
+}
+
+/* static */
+BrowserParent* BrowserParent::GetBrowserParentFromLayersId(
+    layers::LayersId aLayersId) {
+  if (!sLayerToBrowserParentTable) {
+    return nullptr;
+  }
+  return sLayerToBrowserParentTable->Get(uint64_t(aLayersId));
+}
+
+/*static*/
+TabId BrowserParent::GetTabIdFrom(nsIDocShell* docShell) {
+  nsCOMPtr<nsIBrowserChild> browserChild(BrowserChild::GetFrom(docShell));
+  if (browserChild) {
+    return static_cast<BrowserChild*>(browserChild.get())->GetTabId();
+  }
+  return TabId(0);
+}
+
+void BrowserParent::AddBrowserParentToTable(layers::LayersId aLayersId,
+                                            BrowserParent* aBrowserParent) {
+  if (!sLayerToBrowserParentTable) {
+    sLayerToBrowserParentTable = new LayerToBrowserParentTable();
+  }
+  sLayerToBrowserParentTable->InsertOrUpdate(uint64_t(aLayersId),
+                                             aBrowserParent);
+}
+
+void BrowserParent::RemoveBrowserParentFromTable(layers::LayersId aLayersId) {
+  if (!sLayerToBrowserParentTable) {
+    return;
+  }
+  sLayerToBrowserParentTable->Remove(uint64_t(aLayersId));
+  if (sLayerToBrowserParentTable->Count() == 0) {
+    delete sLayerToBrowserParentTable;
+    sLayerToBrowserParentTable = nullptr;
+  }
+}
+
+already_AddRefed<nsILoadContext> BrowserParent::GetLoadContext() {
+  return do_AddRef(mBrowsingContext);
+}
+
+/**
+ * Will return nullptr if there is no outer window available for the
+ * document hosting the owner element of this BrowserParent. Also will return
+ * nullptr if that outer window is in the process of closing.
+ */
+already_AddRefed<nsPIDOMWindowOuter> BrowserParent::GetParentWindowOuter() {
+  nsCOMPtr<nsIContent> frame = GetOwnerElement();
+  if (!frame) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> parent = frame->OwnerDoc()->GetWindow();
+  if (!parent || parent->Closed()) {
+    return nullptr;
+  }
+
+  return parent.forget();
+}
+
+already_AddRefed<nsIWidget> BrowserParent::GetTopLevelWidget() {
+  if (RefPtr<Element> element = mFrameElement) {
+    if (PresShell* presShell = element->OwnerDoc()->GetPresShell()) {
+      return do_AddRef(presShell->GetViewManager()->GetRootWidget());
+    }
+  }
+  return nullptr;
+}
+
+already_AddRefed<nsIWidget> BrowserParent::GetTextInputHandlingWidget() const {
+  if (!mFrameElement) {
+    return nullptr;
+  }
+  PresShell* presShell = mFrameElement->OwnerDoc()->GetPresShell();
+  if (!presShell) {
+    return nullptr;
+  }
+  nsPresContext* presContext = presShell->GetPresContext();
+  if (!presContext) {
+    return nullptr;
+  }
+  nsCOMPtr<nsIWidget> widget = presContext->GetTextInputHandlingWidget();
+  return widget.forget();
+}
+
+already_AddRefed<nsIWidget> BrowserParent::GetWidget() const {
+  if (!mFrameElement) {
+    return nullptr;
+  }
+  nsCOMPtr<nsIWidget> widget = nsContentUtils::WidgetForContent(mFrameElement);
+  if (!widget) {
+    widget = nsContentUtils::WidgetForDocument(mFrameElement->OwnerDoc());
+  }
+  return widget.forget();
+}
+
+already_AddRefed<nsIWidget> BrowserParent::GetDocWidget() const {
+  if (!mFrameElement) {
+    return nullptr;
+  }
+  return do_AddRef(
+      nsContentUtils::WidgetForDocument(mFrameElement->OwnerDoc()));
+}
+
+nsIXULBrowserWindow* BrowserParent::GetXULBrowserWindow() {
+  if (!mFrameElement) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsIDocShell> docShell = mFrameElement->OwnerDoc()->GetDocShell();
+  if (!docShell) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
+  docShell->GetTreeOwner(getter_AddRefs(treeOwner));
+  if (!treeOwner) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsIAppWindow> window = do_GetInterface(treeOwner);
+  if (!window) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsIXULBrowserWindow> xulBrowserWindow;
+  window->GetXULBrowserWindow(getter_AddRefs(xulBrowserWindow));
+  return xulBrowserWindow;
+}
+
+uint32_t BrowserParent::GetMaxTouchPoints(Element* aElement) {
+  if (!aElement) {
+    return 0;
+  }
+
+  if (StaticPrefs::dom_maxtouchpoints_testing_value() >= 0) {
+    return StaticPrefs::dom_maxtouchpoints_testing_value();
+  }
+
+  nsIWidget* widget = nsContentUtils::WidgetForDocument(aElement->OwnerDoc());
+  return widget ? widget->GetMaxTouchPoints() : 0;
+}
+
+a11y::DocAccessibleParent* BrowserParent::GetTopLevelDocAccessible() const {
+#ifdef ACCESSIBILITY
+  // XXX Consider managing non top level PDocAccessibles with their parent
+  // document accessible.
+  const ManagedContainer<PDocAccessibleParent>& docs =
+      ManagedPDocAccessibleParent();
+  for (auto* key : docs) {
+    auto* doc = static_cast<a11y::DocAccessibleParent*>(key);
+    // We want the document for this BrowserParent even if it's for an
+    // embedded out-of-process iframe. Therefore, we use
+    // IsTopLevelInContentProcess. In contrast, using IsToplevel would only
+    // include documents that aren't embedded; e.g. tab documents.
+    if (doc->IsTopLevelInContentProcess() && !doc->IsShutdown()) {
+      return doc;
+    }
+  }
+#endif
+  return nullptr;
+}
+
+LayersId BrowserParent::GetLayersId() const {
+  if (!mRemoteLayerTreeOwner.IsInitialized()) {
+    return LayersId{};
+  }
+  return mRemoteLayerTreeOwner.GetLayersId();
+}
+
+BrowserBridgeParent* BrowserParent::GetBrowserBridgeParent() const {
+  return mBrowserBridgeParent;
+}
+
+BrowserHost* BrowserParent::GetBrowserHost() const { return mBrowserHost; }
+
+ParentShowInfo BrowserParent::GetShowInfo() {
+  TryCacheDPIAndScale();
+  if (mFrameElement) {
+    nsAutoString name;
+    mFrameElement->GetAttr(nsGkAtoms::name, name);
+    bool isTransparent =
+        nsContentUtils::IsChromeDoc(mFrameElement->OwnerDoc()) &&
+        mFrameElement->HasAttr(nsGkAtoms::transparent);
+    return ParentShowInfo(name, false, isTransparent, mDPI, mRounding,
+                          mDefaultScale.scale);
+  }
+
+  return ParentShowInfo(u""_ns, false, false, mDPI, mRounding,
+                        mDefaultScale.scale);
+}
+
+already_AddRefed<nsIPrincipal> BrowserParent::GetContentPrincipal() const {
+  nsCOMPtr<nsIBrowser> browser =
+      mFrameElement ? mFrameElement->AsBrowser() : nullptr;
+  NS_ENSURE_TRUE(browser, nullptr);
+
+  RefPtr<nsIPrincipal> principal;
+
+  nsresult rv;
+  rv = browser->GetContentPrincipal(getter_AddRefs(principal));
+  NS_ENSURE_SUCCESS(rv, nullptr);
+
+  return principal.forget();
+}
+
+void BrowserParent::SetOwnerElement(Element* aElement) {
+  // If we held previous content then unregister for its events.
+  RemoveWindowListeners();
+
+  // If we change top-level documents then we need to change our
+  // registration with them.
+  RefPtr<nsPIWindowRoot> curTopLevelWin, newTopLevelWin;
+  if (mFrameElement) {
+    curTopLevelWin = nsContentUtils::GetWindowRoot(mFrameElement->OwnerDoc());
+  }
+  if (aElement) {
+    newTopLevelWin = nsContentUtils::GetWindowRoot(aElement->OwnerDoc());
+  }
+  bool isSameTopLevelWin = curTopLevelWin == newTopLevelWin;
+  if (mBrowserHost && curTopLevelWin && !isSameTopLevelWin) {
+    curTopLevelWin->RemoveBrowser(mBrowserHost);
+  }
+
+  // Update to the new content, and register to listen for events from it.
+  mFrameElement = aElement;
+
+  if (mBrowserHost && newTopLevelWin && !isSameTopLevelWin) {
+    newTopLevelWin->AddBrowser(mBrowserHost);
+  }
+
+#if defined(XP_WIN) && defined(ACCESSIBILITY)
+  if (!mIsDestroyed) {
+    uintptr_t newWindowHandle = 0;
+    if (nsCOMPtr<nsIWidget> widget = GetWidget()) {
+      newWindowHandle =
+          reinterpret_cast<uintptr_t>(widget->GetNativeData(NS_NATIVE_WINDOW));
+    }
+    Unused << SendUpdateNativeWindowHandle(newWindowHandle);
+    a11y::DocAccessibleParent* doc = GetTopLevelDocAccessible();
+    if (doc) {
+      HWND hWnd = reinterpret_cast<HWND>(doc->GetEmulatedWindowHandle());
+      if (hWnd) {
+        HWND parentHwnd = reinterpret_cast<HWND>(newWindowHandle);
+        if (parentHwnd != ::GetParent(hWnd)) {
+          ::SetParent(hWnd, parentHwnd);
+        }
+      }
+    }
+  }
+#endif
+
+  AddWindowListeners();
+
+  // The DPI depends on our frame element's widget, so invalidate now in case
+  // we've tried to cache it already.
+  mDPI = -1;
+  TryCacheDPIAndScale();
+
+  if (mRemoteLayerTreeOwner.IsInitialized()) {
+    mRemoteLayerTreeOwner.OwnerContentChanged();
+  }
+
+  // Set our BrowsingContext's embedder if we're not embedded within a
+  // BrowserBridgeParent.
+  if (!GetBrowserBridgeParent() && mBrowsingContext && mFrameElement) {
+    mBrowsingContext->SetEmbedderElement(mFrameElement);
+  }
+
+  UpdateVsyncParentVsyncDispatcher();
+
+  VisitChildren([aElement](BrowserBridgeParent* aBrowser) {
+    if (auto* browserParent = aBrowser->GetBrowserParent()) {
+      browserParent->SetOwnerElement(aElement);
+    }
+  });
+}
+
+void BrowserParent::CacheFrameLoader(nsFrameLoader* aFrameLoader) {
+  mFrameLoader = aFrameLoader;
+}
+
+void BrowserParent::AddWindowListeners() {
+  if (mFrameElement) {
+    if (nsCOMPtr<nsPIDOMWindowOuter> window =
+            mFrameElement->OwnerDoc()->GetWindow()) {
+      nsCOMPtr<EventTarget> eventTarget = window->GetTopWindowRoot();
+      if (eventTarget) {
+        eventTarget->AddEventListener(u"MozUpdateWindowPos"_ns, this, false,
+                                      false);
+        eventTarget->AddEventListener(u"fullscreenchange"_ns, this, false,
+                                      false);
+      }
+    }
+  }
+}
+
+void BrowserParent::RemoveWindowListeners() {
+  if (mFrameElement && mFrameElement->OwnerDoc()->GetWindow()) {
+    nsCOMPtr<nsPIDOMWindowOuter> window =
+        mFrameElement->OwnerDoc()->GetWindow();
+    nsCOMPtr<EventTarget> eventTarget = window->GetTopWindowRoot();
+    if (eventTarget) {
+      eventTarget->RemoveEventListener(u"MozUpdateWindowPos"_ns, this, false);
+      eventTarget->RemoveEventListener(u"fullscreenchange"_ns, this, false);
+    }
+  }
+}
+
+void BrowserParent::Deactivated() {
+  if (mShowingTooltip) {
+    // Reuse the normal tooltip hiding method.
+    mozilla::Unused << RecvHideTooltip();
+  }
+  UnlockNativePointer();
+  UnsetTopLevelWebFocus(this);
+  UnsetLastMouseRemoteTarget(this);
+  PointerLockManager::ReleaseLockedRemoteTarget(this);
+  PointerEventHandler::ReleasePointerCaptureRemoteTarget(this);
+  PresShell::ReleaseCapturingRemoteTarget(this);
+  ProcessPriorityManager::BrowserPriorityChanged(this, /* aPriority = */ false);
+}
+
+void BrowserParent::DestroyInternal() {
+  Deactivated();
+
+  RemoveWindowListeners();
+
+#ifdef ACCESSIBILITY
+  if (a11y::DocAccessibleParent* tabDoc = GetTopLevelDocAccessible()) {
+#  if defined(ANDROID)
+    MonitorAutoLock mal(nsAccessibilityService::GetAndroidMonitor());
+#  endif
+    tabDoc->Destroy();
+  }
+#endif
+
+  // If this fails, it's most likely due to a content-process crash,
+  // and auto-cleanup will kick in.  Otherwise, the child side will
+  // destroy itself and send back __delete__().
+  Unused << SendDestroy();
+}
+
+void BrowserParent::Destroy() {
+  // Aggressively release the window to avoid leaking the world in shutdown
+  // corner cases.
+  mBrowserDOMWindow = nullptr;
+
+  if (mIsDestroyed) {
+    return;
+  }
+
+  // If we are shutting down everything or we know to be the last
+  // BrowserParent, signal the impending shutdown early to the content process
+  // to avoid to run the SendDestroy before we know we are ExpectingShutdown.
+  Manager()->NotifyTabWillDestroy();
+
+  DestroyInternal();
+
+  mIsDestroyed = true;
+
+  Manager()->NotifyTabDestroying();
+
+  // This `AddKeepAlive` will be cleared if `mMarkedDestroying` is set in
+  // `ActorDestroy`. Out of caution, we don't add the `KeepAlive` if our IPC
+  // actor has somehow already been destroyed, as that would mean `ActorDestroy`
+  // won't be called.
+  if (CanRecv()) {
+    mBrowsingContext->Group()->AddKeepAlive();
+  }
+
+  mMarkedDestroying = true;
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvDidUnsuppressPainting() {
+  if (!mFrameElement) {
+    return IPC_OK();
+  }
+  nsSubDocumentFrame* subdocFrame =
+      do_QueryFrame(mFrameElement->GetPrimaryFrame());
+  if (subdocFrame && subdocFrame->HasRetainedPaintData()) {
+    subdocFrame->ClearRetainedPaintData();
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvEnsureLayersConnected(
+    CompositorOptions* aCompositorOptions) {
+  if (mRemoteLayerTreeOwner.IsInitialized()) {
+    mRemoteLayerTreeOwner.EnsureLayersConnected(aCompositorOptions);
+  }
+  return IPC_OK();
+}
+
+void BrowserParent::ActorDestroy(ActorDestroyReason why) {
+  Manager()->NotifyTabDestroyed(mTabId, mMarkedDestroying);
+
+  ContentProcessManager* cpm = ContentProcessManager::GetSingleton();
+  if (cpm) {
+    cpm->UnregisterRemoteFrame(mTabId);
+  }
+
+  if (mRemoteLayerTreeOwner.IsInitialized()) {
+    auto layersId = mRemoteLayerTreeOwner.GetLayersId();
+    if (mFrameElement) {
+      nsSubDocumentFrame* f = do_QueryFrame(mFrameElement->GetPrimaryFrame());
+      if (f && f->HasRetainedPaintData() &&
+          f->GetRemotePaintData().mLayersId == layersId) {
+        f->ClearRetainedPaintData();
+      }
+    }
+
+    // It's important to unmap layers after the remote browser has been
+    // destroyed, otherwise it may still send messages to the compositor which
+    // will reject them, causing assertions.
+    RemoveBrowserParentFromTable(layersId);
+    mRemoteLayerTreeOwner.Destroy();
+  }
+
+  // Even though BrowserParent::Destroy calls this, we need to do it here too in
+  // case of a crash.
+  Deactivated();
+
+  if (why == AbnormalShutdown) {
+    // dom_reporting_header must also be enabled for the report to be sent.
+    if (StaticPrefs::dom_reporting_crash_enabled()) {
+      nsCOMPtr<nsIPrincipal> principal = GetContentPrincipal();
+
+      if (principal) {
+        nsAutoCString crash_reason;
+        CrashReporter::GetAnnotation(OtherPid(),
+                                     CrashReporter::Annotation::MozCrashReason,
+                                     crash_reason);
+        // FIXME(arenevier): Find a less fragile way to identify that a crash
+        // was caused by OOM
+        bool is_oom = false;
+        if (crash_reason == "OOM" || crash_reason == "OOM!" ||
+            StringBeginsWith(crash_reason, "[unhandlable oom]"_ns) ||
+            StringBeginsWith(crash_reason, "Unhandlable OOM"_ns)) {
+          is_oom = true;
+        }
+
+        CrashReport::Deliver(principal, is_oom);
+      }
+    }
+  }
+
+  // If we were shutting down normally, we held a reference to our
+  // BrowsingContextGroup in `BrowserParent::Destroy`. Clear that reference
+  // here.
+  if (mMarkedDestroying) {
+    mBrowsingContext->Group()->RemoveKeepAlive();
+  }
+
+  // Tell our embedder that the tab is now going away unless we're an
+  // out-of-process iframe.
+  RefPtr<nsFrameLoader> frameLoader = GetFrameLoader(true);
+  if (frameLoader) {
+    ReceiveMessage(CHILD_PROCESS_SHUTDOWN_MESSAGE, false, nullptr);
+
+    if (mBrowsingContext->IsTop()) {
+      // If this is a top-level BrowsingContext, tell the frameloader it's time
+      // to go away. Otherwise, this is a subframe crash, and we can keep the
+      // frameloader around.
+      frameLoader->DestroyComplete();
+    }
+
+    // If this was a crash, tell our nsFrameLoader to fire crash events.
+    if (why == AbnormalShutdown) {
+      frameLoader->MaybeNotifyCrashed(mBrowsingContext, Manager()->ChildID(),
+                                      GetIPCChannel());
+    } else if (why == ManagedEndpointDropped) {
+      // If we instead failed due to a constructor error, don't include process
+      // information, as the process did not crash.
+      frameLoader->MaybeNotifyCrashed(mBrowsingContext, ContentParentId{},
+                                      nullptr);
+    }
+  }
+
+  mFrameLoader = nullptr;
+
+  // If we were destroyed due to our ManagedEndpoints being dropped, make a
+  // point of showing the subframe crashed UI. We don't fire the full
+  // `MaybeNotifyCrashed` codepath, as the entire process hasn't crashed on us,
+  // and it may confuse the frontend.
+  mBrowsingContext->BrowserParentDestroyed(
+      this, why == AbnormalShutdown || why == ManagedEndpointDropped);
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvMoveFocus(
+    const bool& aForward, const bool& aForDocumentNavigation) {
+  LOGBROWSERFOCUS(("RecvMoveFocus %p, aForward: %d, aForDocumentNavigation: %d",
+                   this, aForward, aForDocumentNavigation));
+  BrowserBridgeParent* bridgeParent = GetBrowserBridgeParent();
+  if (bridgeParent) {
+    mozilla::Unused << bridgeParent->SendMoveFocus(aForward,
+                                                   aForDocumentNavigation);
+    return IPC_OK();
+  }
+
+  RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager();
+  if (fm) {
+    RefPtr<Element> dummy;
+
+    uint32_t type =
+        aForward
+            ? (aForDocumentNavigation
+                   ? static_cast<uint32_t>(
+                         nsIFocusManager::MOVEFOCUS_FORWARDDOC)
+                   : static_cast<uint32_t>(nsIFocusManager::MOVEFOCUS_FORWARD))
+            : (aForDocumentNavigation
+                   ? static_cast<uint32_t>(
+                         nsIFocusManager::MOVEFOCUS_BACKWARDDOC)
+                   : static_cast<uint32_t>(
+                         nsIFocusManager::MOVEFOCUS_BACKWARD));
+    fm->MoveFocus(nullptr, mFrameElement, type, nsIFocusManager::FLAG_BYKEY,
+                  getter_AddRefs(dummy));
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvDropLinks(
+    nsTArray<nsString>&& aLinks) {
+  nsCOMPtr<nsIBrowser> browser =
+      mFrameElement ? mFrameElement->AsBrowser() : nullptr;
+  if (browser) {
+    // Verify that links have not been modified by the child. If links have
+    // not been modified then it's safe to load those links using the
+    // SystemPrincipal. If they have been modified by web content, then
+    // we use a NullPrincipal which still allows to load web links.
+    bool loadUsingSystemPrincipal = true;
+    if (aLinks.Length() != mVerifyDropLinks.Length()) {
+      loadUsingSystemPrincipal = false;
+    }
+    for (uint32_t i = 0; i < aLinks.Length(); i++) {
+      if (loadUsingSystemPrincipal) {
+        if (!aLinks[i].Equals(mVerifyDropLinks[i])) {
+          loadUsingSystemPrincipal = false;
+        }
+      }
+    }
+    mVerifyDropLinks.Clear();
+    nsCOMPtr<nsIPrincipal> triggeringPrincipal;
+    if (loadUsingSystemPrincipal) {
+      triggeringPrincipal = nsContentUtils::GetSystemPrincipal();
+    } else {
+      triggeringPrincipal = NullPrincipal::CreateWithoutOriginAttributes();
+    }
+    browser->DropLinks(aLinks, triggeringPrincipal);
+  }
+  return IPC_OK();
+}
+
+bool BrowserParent::SendLoadRemoteScript(const nsAString& aURL,
+                                         const bool& aRunInGlobalScope) {
+  if (mCreatingWindow) {
+    mDelayedFrameScripts.AppendElement(
+        FrameScriptInfo(nsString(aURL), aRunInGlobalScope));
+    return true;
+  }
+
+  MOZ_ASSERT(mDelayedFrameScripts.IsEmpty());
+  return PBrowserParent::SendLoadRemoteScript(aURL, aRunInGlobalScope);
+}
+
+void BrowserParent::LoadURL(nsDocShellLoadState* aLoadState) {
+  MOZ_ASSERT(aLoadState);
+  MOZ_ASSERT(aLoadState->URI());
+  if (mIsDestroyed) {
+    return;
+  }
+
+  if (mCreatingWindow) {
+    // Don't send the message if the child wants to load its own URL.
+    return;
+  }
+
+  Unused << SendLoadURL(WrapNotNull(aLoadState), GetShowInfo());
+}
+
+void BrowserParent::ResumeLoad(uint64_t aPendingSwitchID) {
+  MOZ_ASSERT(aPendingSwitchID != 0);
+
+  if (NS_WARN_IF(mIsDestroyed)) {
+    return;
+  }
+
+  Unused << SendResumeLoad(aPendingSwitchID, GetShowInfo());
+}
+
+void BrowserParent::InitRendering() {
+  if (mRemoteLayerTreeOwner.IsInitialized()) {
+    return;
+  }
+  mRemoteLayerTreeOwner.Initialize(this);
+
+  layers::LayersId layersId = mRemoteLayerTreeOwner.GetLayersId();
+  AddBrowserParentToTable(layersId, this);
+
+  RefPtr<nsFrameLoader> frameLoader = GetFrameLoader();
+  if (frameLoader) {
+    nsIFrame* frame = frameLoader->GetPrimaryFrameOfOwningContent();
+    if (frame) {
+      frame->InvalidateFrame();
+    }
+  }
+
+  TextureFactoryIdentifier textureFactoryIdentifier;
+  mRemoteLayerTreeOwner.GetTextureFactoryIdentifier(&textureFactoryIdentifier);
+  Unused << SendInitRendering(textureFactoryIdentifier, layersId,
+                              mRemoteLayerTreeOwner.GetCompositorOptions(),
+                              mRemoteLayerTreeOwner.IsLayersConnected());
+
+  RefPtr<nsIWidget> widget = GetTopLevelWidget();
+  if (widget) {
+    ScreenIntMargin safeAreaInsets = widget->GetSafeAreaInsets();
+    Unused << SendSafeAreaInsetsChanged(safeAreaInsets);
+  }
+
+#if defined(MOZ_WIDGET_ANDROID)
+  MOZ_ASSERT(widget);
+
+  if (GetBrowsingContext()->IsTopContent()) {
+    Unused << SendDynamicToolbarMaxHeightChanged(
+        widget->GetDynamicToolbarMaxHeight());
+  }
+#endif
+}
+
+bool BrowserParent::AttachWindowRenderer() {
+  return mRemoteLayerTreeOwner.AttachWindowRenderer();
+}
+
+void BrowserParent::MaybeShowFrame() {
+  RefPtr<nsFrameLoader> frameLoader = GetFrameLoader();
+  if (!frameLoader) {
+    return;
+  }
+  frameLoader->MaybeShowFrame();
+}
+
+bool BrowserParent::Show(const OwnerShowInfo& aOwnerInfo) {
+  mDimensions = aOwnerInfo.size();
+  if (mIsDestroyed) {
+    return false;
+  }
+
+  MOZ_ASSERT(mRemoteLayerTreeOwner.IsInitialized());
+  if (!mRemoteLayerTreeOwner.AttachWindowRenderer()) {
+    return false;
+  }
+
+  mSizeMode = aOwnerInfo.sizeMode();
+  Unused << SendShow(GetShowInfo(), aOwnerInfo);
+  return true;
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSetDimensions(
+    mozilla::DimensionRequest aRequest, const double& aScale) {
+  NS_ENSURE_TRUE(mFrameElement, IPC_OK());
+  nsCOMPtr<nsIDocShell> docShell = mFrameElement->OwnerDoc()->GetDocShell();
+  NS_ENSURE_TRUE(docShell, IPC_OK());
+  nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
+  docShell->GetTreeOwner(getter_AddRefs(treeOwner));
+  nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = do_QueryInterface(treeOwner);
+  NS_ENSURE_TRUE(treeOwnerAsWin, IPC_OK());
+
+  // `BrowserChild` only sends the values to actually be changed, see more
+  // details in `BrowserChild::SetDimensions()`.
+  // Note that `BrowserChild::SetDimensions()` may be called before receiving
+  // our `SendUIResolutionChanged()` call.  Therefore, if given each coordinate
+  // shouldn't be ignored, we need to recompute it if DPI has been changed.
+  // And also note that don't use `mDefaultScale.scale` here since it may be
+  // different from the result of `GetWidgetCSSToDeviceScale()`.
+  // NOTE(emilio): We use GetWidgetCSSToDeviceScale() because the old scale is a
+  // widget scale, and we only use the current scale to scale up/down the
+  // relevant values.
+
+  CSSToLayoutDeviceScale oldScale((float)aScale);
+  CSSToLayoutDeviceScale currentScale(
+      (float)treeOwnerAsWin->GetWidgetCSSToDeviceScale());
+
+  if (oldScale != currentScale) {
+    auto rescaleFunc = [&oldScale, &currentScale](LayoutDeviceIntCoord& aVal) {
+      aVal = (LayoutDeviceCoord(aVal) / oldScale * currentScale).Rounded();
+    };
+    aRequest.mX.apply(rescaleFunc);
+    aRequest.mY.apply(rescaleFunc);
+    aRequest.mWidth.apply(rescaleFunc);
+    aRequest.mHeight.apply(rescaleFunc);
+  }
+
+  // treeOwner is the chrome tree owner, but we wan't the content tree owner.
+  nsCOMPtr<nsIWebBrowserChrome> webBrowserChrome = do_GetInterface(treeOwner);
+  NS_ENSURE_TRUE(webBrowserChrome, IPC_OK());
+  webBrowserChrome->SetDimensions(std::move(aRequest));
+  return IPC_OK();
+}
+
+nsresult BrowserParent::UpdatePosition() {
+  RefPtr<nsFrameLoader> frameLoader = GetFrameLoader();
+  if (!frameLoader) {
+    return NS_OK;
+  }
+  nsIntRect windowDims;
+  NS_ENSURE_SUCCESS(frameLoader->GetWindowDimensions(windowDims),
+                    NS_ERROR_FAILURE);
+  // Avoid updating sizes here.
+  windowDims.SizeTo(mRect.Size());
+  UpdateDimensions(windowDims, mDimensions);
+  return NS_OK;
+}
+
+void BrowserParent::NotifyPositionUpdatedForContentsInPopup() {
+  if (CanonicalBrowsingContext* bc = GetBrowsingContext()) {
+    bc->PreOrderWalk([](BrowsingContext* aContext) {
+      if (WindowGlobalParent* windowGlobalParent =
+              aContext->Canonical()->GetCurrentWindowGlobal()) {
+        if (RefPtr<BrowserParent> browserParent =
+                windowGlobalParent->GetBrowserParent()) {
+          browserParent->UpdatePosition();
+        }
+      }
+    });
+  }
+}
+
+void BrowserParent::UpdateDimensions(const nsIntRect& rect,
+                                     const ScreenIntSize& size) {
+  if (mIsDestroyed) {
+    return;
+  }
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (!widget) {
+    NS_WARNING("No widget found in BrowserParent::UpdateDimensions");
+    return;
+  }
+
+  LayoutDeviceIntPoint clientOffset = GetClientOffset();
+  LayoutDeviceIntPoint chromeOffset = !GetBrowserBridgeParent()
+                                          ? -GetChildProcessOffset()
+                                          : LayoutDeviceIntPoint();
+
+  if (!mUpdatedDimensions || mDimensions != size || !mRect.IsEqualEdges(rect) ||
+      clientOffset != mClientOffset || chromeOffset != mChromeOffset) {
+    mUpdatedDimensions = true;
+    mRect = rect;
+    mDimensions = size;
+    mClientOffset = clientOffset;
+    mChromeOffset = chromeOffset;
+
+    Unused << SendUpdateDimensions(GetDimensionInfo());
+    UpdateNativePointerLockCenter(widget);
+  }
+}
+
+DimensionInfo BrowserParent::GetDimensionInfo() {
+  LayoutDeviceIntRect devicePixelRect = ViewAs<LayoutDevicePixel>(
+      mRect, PixelCastJustification::LayoutDeviceIsScreenForTabDims);
+  LayoutDeviceIntSize devicePixelSize = ViewAs<LayoutDevicePixel>(
+      mDimensions, PixelCastJustification::LayoutDeviceIsScreenForTabDims);
+
+  CSSRect unscaledRect = devicePixelRect / mDefaultScale;
+  CSSSize unscaledSize = devicePixelSize / mDefaultScale;
+  DimensionInfo di(unscaledRect, unscaledSize, mClientOffset, mChromeOffset);
+  return di;
+}
+
+void BrowserParent::UpdateNativePointerLockCenter(nsIWidget* aWidget) {
+  if (!mLockedNativePointer) {
+    return;
+  }
+  LayoutDeviceIntRect dims(
+      {0, 0},
+      ViewAs<LayoutDevicePixel>(
+          mDimensions, PixelCastJustification::LayoutDeviceIsScreenForTabDims));
+  aWidget->SetNativePointerLockCenter((dims + mChromeOffset).Center());
+}
+
+void BrowserParent::SizeModeChanged(const nsSizeMode& aSizeMode) {
+  if (!mIsDestroyed && aSizeMode != mSizeMode) {
+    mSizeMode = aSizeMode;
+    Unused << SendSizeModeChanged(aSizeMode);
+  }
+}
+
+#if defined(MOZ_WIDGET_ANDROID)
+void BrowserParent::DynamicToolbarMaxHeightChanged(ScreenIntCoord aHeight) {
+  if (!mIsDestroyed) {
+    Unused << SendDynamicToolbarMaxHeightChanged(aHeight);
+  }
+}
+
+void BrowserParent::DynamicToolbarOffsetChanged(ScreenIntCoord aOffset) {
+  if (!mIsDestroyed) {
+    Unused << SendDynamicToolbarOffsetChanged(aOffset);
+  }
+}
+#endif
+
+void BrowserParent::HandleAccessKey(const WidgetKeyboardEvent& aEvent,
+                                    nsTArray<uint32_t>& aCharCodes) {
+  if (!mIsDestroyed) {
+    // Note that we don't need to mark aEvent is posted to a remote process
+    // because the event may be dispatched to it as normal keyboard event.
+    // Therefore, we should use local copy to send it.
+    WidgetKeyboardEvent localEvent(aEvent);
+    RequestingAccessKeyEventData::Set(localEvent);
+    Unused << SendHandleAccessKey(localEvent, aCharCodes);
+  }
+}
+
+void BrowserParent::Activate(uint64_t aActionId) {
+  LOGBROWSERFOCUS(("Activate %p actionid: %" PRIu64, this, aActionId));
+  if (!mIsDestroyed) {
+    SetTopLevelWebFocus(this);  // Intentionally inside "if"
+    Unused << SendActivate(aActionId);
+  }
+}
+
+void BrowserParent::Deactivate(bool aWindowLowering, uint64_t aActionId) {
+  LOGBROWSERFOCUS(("Deactivate %p actionid: %" PRIu64, this, aActionId));
+  if (!aWindowLowering) {
+    UnsetTopLevelWebFocus(this);  // Intentionally outside the next "if"
+  }
+  if (!mIsDestroyed) {
+    Unused << SendDeactivate(aActionId);
+  }
+}
+
+#ifdef ACCESSIBILITY
+a11y::PDocAccessibleParent* BrowserParent::AllocPDocAccessibleParent(
+    PDocAccessibleParent* aParent, const uint64_t&,
+    const MaybeDiscardedBrowsingContext&) {
+  // Reference freed in DeallocPDocAccessibleParent.
+  return a11y::DocAccessibleParent::New().take();
+}
+
+bool BrowserParent::DeallocPDocAccessibleParent(PDocAccessibleParent* aParent) {
+  // Free reference from AllocPDocAccessibleParent.
+  static_cast<a11y::DocAccessibleParent*>(aParent)->Release();
+  return true;
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvPDocAccessibleConstructor(
+    PDocAccessibleParent* aDoc, PDocAccessibleParent* aParentDoc,
+    const uint64_t& aParentID,
+    const MaybeDiscardedBrowsingContext& aBrowsingContext) {
+#  if defined(ANDROID)
+  MonitorAutoLock mal(nsAccessibilityService::GetAndroidMonitor());
+#  endif
+  auto doc = static_cast<a11y::DocAccessibleParent*>(aDoc);
+
+  // If this tab is already shutting down just mark the new actor as shutdown
+  // and ignore it.  When the tab actor is destroyed it will be too.
+  if (mIsDestroyed) {
+    doc->MarkAsShutdown();
+    return IPC_OK();
+  }
+
+  if (aParentDoc) {
+    // Iframe document rendered in the same process as its embedder.
+    // A document should never directly be the parent of another document.
+    // There should always be an outer doc accessible child of the outer
+    // document containing the child.
+    MOZ_ASSERT(aParentID);
+    if (!aParentID) {
+      return IPC_FAIL_NO_REASON(this);
+    }
+
+    auto parentDoc = static_cast<a11y::DocAccessibleParent*>(aParentDoc);
+    if (parentDoc->IsShutdown()) {
+      // This can happen if parentDoc is an OOP iframe, but its embedder has
+      // been destroyed. (DocAccessibleParent::Destroy destroys any child
+      // documents.) The OOP iframe (and anything it embeds) will die soon
+      // anyway, so mark this document as shutdown and ignore it.
+      doc->MarkAsShutdown();
+      return IPC_OK();
+    }
+
+    if (aBrowsingContext) {
+      doc->SetBrowsingContext(aBrowsingContext.get_canonical());
+    }
+
+    mozilla::ipc::IPCResult added = parentDoc->AddChildDoc(doc, aParentID);
+    if (!added) {
+#  ifdef DEBUG
+      return added;
+#  else
+      return IPC_OK();
+#  endif
+    }
+
+#  ifdef XP_WIN
+    if (a11y::nsWinUtils::IsWindowEmulationStarted()) {
+      doc->SetEmulatedWindowHandle(parentDoc->GetEmulatedWindowHandle());
+    }
+#  endif
+
+    return IPC_OK();
+  }
+
+  if (aBrowsingContext) {
+    doc->SetBrowsingContext(aBrowsingContext.get_canonical());
+  }
+
+  if (auto* bridge = GetBrowserBridgeParent()) {
+    // Iframe document rendered in a different process to its embedder.
+    // In this case, we don't get aParentDoc and aParentID.
+    MOZ_ASSERT(!aParentDoc && !aParentID);
+    doc->SetTopLevelInContentProcess();
+    a11y::ProxyCreated(doc);
+    // It's possible the embedder accessible hasn't been set yet; e.g.
+    // a hidden iframe. In that case, embedderDoc will be null and this will
+    // be handled when the embedder is set.
+    if (a11y::DocAccessibleParent* embedderDoc =
+            bridge->GetEmbedderAccessibleDoc()) {
+      mozilla::ipc::IPCResult added = embedderDoc->AddChildDoc(bridge);
+      if (!added) {
+#  ifdef DEBUG
+        return added;
+#  else
+        return IPC_OK();
+#  endif
+      }
+    }
+    return IPC_OK();
+  } else {
+    // null aParentDoc means this document is at the top level in the child
+    // process.  That means it makes no sense to get an id for an accessible
+    // that is its parent.
+    MOZ_ASSERT(!aParentID);
+    if (aParentID) {
+      return IPC_FAIL_NO_REASON(this);
+    }
+
+    if (auto* prevTopLevel = GetTopLevelDocAccessible()) {
+      // Sometimes, we can get a new top level DocAccessibleParent before the
+      // old one gets destroyed. The old one will die pretty shortly anyway,
+      // so just destroy it now. If we don't do this, GetTopLevelDocAccessible()
+      // might return the wrong document for a short while.
+      prevTopLevel->Destroy();
+    }
+    doc->SetTopLevel();
+    a11y::DocManager::RemoteDocAdded(doc);
+#  ifdef XP_WIN
+    doc->MaybeInitWindowEmulation();
+#  endif
+  }
+  return IPC_OK();
+}
+#endif
+
+already_AddRefed<PFilePickerParent> BrowserParent::AllocPFilePickerParent(
+    const nsString& aTitle, const nsIFilePicker::Mode& aMode) {
+  return MakeAndAddRef<FilePickerParent>(aTitle, aMode);
+}
+
+already_AddRefed<PSessionStoreParent>
+BrowserParent::AllocPSessionStoreParent() {
+  RefPtr<BrowserSessionStore> sessionStore =
+      BrowserSessionStore::GetOrCreate(mBrowsingContext->Top());
+  if (!sessionStore) {
+    return nullptr;
+  }
+
+  return do_AddRef(new SessionStoreParent(mBrowsingContext, sessionStore));
+}
+
+IPCResult BrowserParent::RecvNewWindowGlobal(
+    ManagedEndpoint<PWindowGlobalParent>&& aEndpoint,
+    const WindowGlobalInit& aInit) {
+  RefPtr<CanonicalBrowsingContext> browsingContext =
+      CanonicalBrowsingContext::Get(aInit.context().mBrowsingContextId);
+  if (!browsingContext) {
+    return IPC_FAIL(this, "Cannot create for missing BrowsingContext");
+  }
+  if (!aInit.principal()) {
+    return IPC_FAIL(this, "Cannot create without valid principal");
+  }
+
+  // Ensure we never load a document with a content principal in
+  // the wrong type of webIsolated process
+  EnumSet<ContentParent::ValidatePrincipalOptions> validationOptions = {};
+  nsCOMPtr<nsIURI> docURI = aInit.documentURI();
+  if (docURI->SchemeIs("about") || docURI->SchemeIs("blob") ||
+      docURI->SchemeIs("chrome")) {
+    // XXXckerschb TODO - Do not use SystemPrincipal for:
+    // Bug 1700639: about:plugins
+    // Bug 1699385: Remove allowSystem for blobs
+    // Bug 1698087: chrome://devtools/content/shared/webextension-fallback.html
+    // chrome reftests, e.g.
+    //   * chrome://reftest/content/writing-mode/ua-style-sheet-button-1a-ref.html
+    //   * chrome://reftest/content/xul-document-load/test003.xhtml
+    //   * chrome://reftest/content/forms/input/text/centering-1.xhtml
+    validationOptions = {ContentParent::ValidatePrincipalOptions::AllowSystem};
+  }
+
+  if (!mManager->ValidatePrincipal(aInit.principal(), validationOptions)) {
+    ContentParent::LogAndAssertFailedPrincipalValidationInfo(aInit.principal(),
+                                                             __func__);
+  }
+
+  // Construct our new WindowGlobalParent, bind, and initialize it.
+  RefPtr<WindowGlobalParent> wgp =
+      WindowGlobalParent::CreateDisconnected(aInit);
+  BindPWindowGlobalEndpoint(std::move(aEndpoint), wgp);
+  wgp->Init();
+  return IPC_OK();
+}
+
+PVsyncParent* BrowserParent::AllocPVsyncParent() {
+  MOZ_ASSERT(!mVsyncParent);
+  mVsyncParent = new VsyncParent();
+  UpdateVsyncParentVsyncDispatcher();
+  return mVsyncParent.get();
+}
+
+bool BrowserParent::DeallocPVsyncParent(PVsyncParent* aActor) {
+  MOZ_ASSERT(aActor);
+  mVsyncParent = nullptr;
+  return true;
+}
+
+void BrowserParent::UpdateVsyncParentVsyncDispatcher() {
+  if (!mVsyncParent) {
+    return;
+  }
+
+  if (nsCOMPtr<nsIWidget> widget = GetWidget()) {
+    RefPtr<VsyncDispatcher> vsyncDispatcher = widget->GetVsyncDispatcher();
+    if (!vsyncDispatcher) {
+      vsyncDispatcher = gfxPlatform::GetPlatform()->GetGlobalVsyncDispatcher();
+    }
+    mVsyncParent->UpdateVsyncDispatcher(vsyncDispatcher);
+  }
+}
+
+void BrowserParent::MouseEnterIntoWidget() {
+  if (nsCOMPtr<nsIWidget> widget = GetWidget()) {
+    // When we mouseenter the remote target, the remote target's cursor should
+    // become the current cursor.  When we mouseexit, we stop.
+    mRemoteTargetSetsCursor = true;
+    widget->SetCursor(mCursor);
+  }
+
+  // Mark that we have missed a mouse enter event, so that
+  // the next mouse event will create a replacement mouse
+  // enter event and send it to the child.
+  mIsMouseEnterIntoWidgetEventSuppressed = true;
+}
+
+void BrowserParent::SendRealMouseEvent(WidgetMouseEvent& aEvent) {
+  if (mIsDestroyed) {
+    return;
+  }
+
+  // XXXedgar, if the synthesized mouse events could deliver to the correct
+  // process directly (see
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=1549355), we probably don't
+  // need to check mReason then.
+  if (aEvent.mReason == WidgetMouseEvent::eReal) {
+    if (aEvent.mMessage == eMouseExitFromWidget) {
+      // Since we are leaving this remote target, so don't need to update
+      // sLastMouseRemoteTarget, and if we are sLastMouseRemoteTarget, reset it
+      // to null.
+      BrowserParent::UnsetLastMouseRemoteTarget(this);
+    } else {
+      // Last remote target should not be changed without eMouseExitFromWidget.
+      MOZ_ASSERT_IF(sLastMouseRemoteTarget, sLastMouseRemoteTarget == this);
+      sLastMouseRemoteTarget = this;
+    }
+  }
+
+  aEvent.mRefPoint = TransformParentToChild(aEvent.mRefPoint);
+
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (widget) {
+    // When we mouseenter the remote target, the remote target's cursor should
+    // become the current cursor.  When we mouseexit, we stop.
+    if (eMouseEnterIntoWidget == aEvent.mMessage) {
+      mRemoteTargetSetsCursor = true;
+      widget->SetCursor(mCursor);
+    } else if (eMouseExitFromWidget == aEvent.mMessage) {
+      mRemoteTargetSetsCursor = false;
+    }
+  }
+  if (!mIsReadyToHandleInputEvents) {
+    if (eMouseEnterIntoWidget == aEvent.mMessage) {
+      mIsMouseEnterIntoWidgetEventSuppressed = true;
+    } else if (eMouseExitFromWidget == aEvent.mMessage) {
+      mIsMouseEnterIntoWidgetEventSuppressed = false;
+    }
+    return;
+  }
+
+  ScrollableLayerGuid guid;
+  uint64_t blockId;
+  ApzAwareEventRoutingToChild(&guid, &blockId, nullptr);
+
+  bool isInputPriorityEventEnabled = Manager()->IsInputPriorityEventEnabled();
+
+  if (mIsMouseEnterIntoWidgetEventSuppressed) {
+    // In the case that the BrowserParent suppressed the eMouseEnterWidget event
+    // due to its corresponding BrowserChild wasn't ready to handle it, we have
+    // to resend it when the BrowserChild is ready.
+    mIsMouseEnterIntoWidgetEventSuppressed = false;
+    WidgetMouseEvent localEvent(aEvent);
+    localEvent.mMessage = eMouseEnterIntoWidget;
+    DebugOnly<bool> ret =
+        isInputPriorityEventEnabled
+            ? SendRealMouseEnterExitWidgetEvent(localEvent, guid, blockId)
+            : SendNormalPriorityRealMouseEnterExitWidgetEvent(localEvent, guid,
+                                                              blockId);
+    NS_WARNING_ASSERTION(ret, "SendRealMouseEnterExitWidgetEvent() failed");
+    MOZ_ASSERT(!ret || localEvent.HasBeenPostedToRemoteProcess());
+  }
+
+  if (eMouseMove == aEvent.mMessage) {
+    if (aEvent.mReason == WidgetMouseEvent::eSynthesized) {
+      DebugOnly<bool> ret =
+          isInputPriorityEventEnabled
+              ? SendSynthMouseMoveEvent(aEvent, guid, blockId)
+              : SendNormalPrioritySynthMouseMoveEvent(aEvent, guid, blockId);
+      NS_WARNING_ASSERTION(ret, "SendSynthMouseMoveEvent() failed");
+      MOZ_ASSERT(!ret || aEvent.HasBeenPostedToRemoteProcess());
+      return;
+    }
+
+    if (!aEvent.mFlags.mIsSynthesizedForTests) {
+      DebugOnly<bool> ret =
+          isInputPriorityEventEnabled
+              ? SendRealMouseMoveEvent(aEvent, guid, blockId)
+              : SendNormalPriorityRealMouseMoveEvent(aEvent, guid, blockId);
+      NS_WARNING_ASSERTION(ret, "SendRealMouseMoveEvent() failed");
+      MOZ_ASSERT(!ret || aEvent.HasBeenPostedToRemoteProcess());
+      return;
+    }
+
+    DebugOnly<bool> ret =
+        isInputPriorityEventEnabled
+            ? SendRealMouseMoveEventForTests(aEvent, guid, blockId)
+            : SendNormalPriorityRealMouseMoveEventForTests(aEvent, guid,
+                                                           blockId);
+    NS_WARNING_ASSERTION(ret, "SendRealMouseMoveEventForTests() failed");
+    MOZ_ASSERT(!ret || aEvent.HasBeenPostedToRemoteProcess());
+    return;
+  }
+
+  if (eMouseEnterIntoWidget == aEvent.mMessage ||
+      eMouseExitFromWidget == aEvent.mMessage) {
+    DebugOnly<bool> ret =
+        isInputPriorityEventEnabled
+            ? SendRealMouseEnterExitWidgetEvent(aEvent, guid, blockId)
+            : SendNormalPriorityRealMouseEnterExitWidgetEvent(aEvent, guid,
+                                                              blockId);
+    NS_WARNING_ASSERTION(ret, "SendRealMouseEnterExitWidgetEvent() failed");
+    MOZ_ASSERT(!ret || aEvent.HasBeenPostedToRemoteProcess());
+    return;
+  }
+
+  DebugOnly<bool> ret =
+      isInputPriorityEventEnabled
+          ? SendRealMouseButtonEvent(aEvent, guid, blockId)
+          : SendNormalPriorityRealMouseButtonEvent(aEvent, guid, blockId);
+  NS_WARNING_ASSERTION(ret, "SendRealMouseButtonEvent() failed");
+  MOZ_ASSERT(!ret || aEvent.HasBeenPostedToRemoteProcess());
+}
+
+LayoutDeviceToCSSScale BrowserParent::GetLayoutDeviceToCSSScale() {
+  Document* doc = (mFrameElement ? mFrameElement->OwnerDoc() : nullptr);
+  nsPresContext* ctx = (doc ? doc->GetPresContext() : nullptr);
+  return LayoutDeviceToCSSScale(
+      ctx ? (float)ctx->AppUnitsPerDevPixel() / AppUnitsPerCSSPixel() : 0.0f);
+}
+
+bool BrowserParent::QueryDropLinksForVerification() {
+  // Before sending the dragEvent, we query the links being dragged and
+  // store them on the parent, to make sure the child can not modify links.
+  nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession();
+  if (!dragSession) {
+    NS_WARNING("No dragSession to query links for verification");
+    return false;
+  }
+
+  RefPtr<DataTransfer> initialDataTransfer = dragSession->GetDataTransfer();
+  if (!initialDataTransfer) {
+    NS_WARNING("No initialDataTransfer to query links for verification");
+    return false;
+  }
+
+  nsCOMPtr<nsIDroppedLinkHandler> dropHandler =
+      do_GetService("@mozilla.org/content/dropped-link-handler;1");
+  if (!dropHandler) {
+    NS_WARNING("No dropHandler to query links for verification");
+    return false;
+  }
+
+  // No more than one drop event can happen simultaneously; reset the link
+  // verification array and store all links that are being dragged.
+  mVerifyDropLinks.Clear();
+
+  nsTArray<RefPtr<nsIDroppedLinkItem>> droppedLinkItems;
+  dropHandler->QueryLinks(initialDataTransfer, droppedLinkItems);
+
+  // Since the entire event is cancelled if one of the links is invalid,
+  // we can store all links on the parent side without any prior
+  // validation checks.
+  nsresult rv = NS_OK;
+  for (nsIDroppedLinkItem* item : droppedLinkItems) {
+    nsString tmp;
+    rv = item->GetUrl(tmp);
+    if (NS_FAILED(rv)) {
+      NS_WARNING("Failed to query url for verification");
+      break;
+    }
+    mVerifyDropLinks.AppendElement(tmp);
+
+    rv = item->GetName(tmp);
+    if (NS_FAILED(rv)) {
+      NS_WARNING("Failed to query name for verification");
+      break;
+    }
+    mVerifyDropLinks.AppendElement(tmp);
+
+    rv = item->GetType(tmp);
+    if (NS_FAILED(rv)) {
+      NS_WARNING("Failed to query type for verification");
+      break;
+    }
+    mVerifyDropLinks.AppendElement(tmp);
+  }
+  if (NS_FAILED(rv)) {
+    mVerifyDropLinks.Clear();
+    return false;
+  }
+  return true;
+}
+
+void BrowserParent::SendRealDragEvent(WidgetDragEvent& aEvent,
+                                      uint32_t aDragAction,
+                                      uint32_t aDropEffect,
+                                      nsIPrincipal* aPrincipal,
+                                      nsIContentSecurityPolicy* aCsp) {
+  if (mIsDestroyed || !mIsReadyToHandleInputEvents) {
+    return;
+  }
+  MOZ_ASSERT(!Manager()->IsInputPriorityEventEnabled());
+  aEvent.mRefPoint = TransformParentToChild(aEvent.mRefPoint);
+  if (aEvent.mMessage == eDrop) {
+    if (!QueryDropLinksForVerification()) {
+      return;
+    }
+  }
+  DebugOnly<bool> ret = PBrowserParent::SendRealDragEvent(
+      aEvent, aDragAction, aDropEffect, aPrincipal, aCsp);
+  NS_WARNING_ASSERTION(ret, "PBrowserParent::SendRealDragEvent() failed");
+  MOZ_ASSERT(!ret || aEvent.HasBeenPostedToRemoteProcess());
+}
+
+void BrowserParent::SendMouseWheelEvent(WidgetWheelEvent& aEvent) {
+  if (mIsDestroyed || !mIsReadyToHandleInputEvents) {
+    return;
+  }
+
+  ScrollableLayerGuid guid;
+  uint64_t blockId;
+  ApzAwareEventRoutingToChild(&guid, &blockId, nullptr);
+  aEvent.mRefPoint = TransformParentToChild(aEvent.mRefPoint);
+  DebugOnly<bool> ret =
+      Manager()->IsInputPriorityEventEnabled()
+          ? PBrowserParent::SendMouseWheelEvent(aEvent, guid, blockId)
+          : PBrowserParent::SendNormalPriorityMouseWheelEvent(aEvent, guid,
+                                                              blockId);
+
+  NS_WARNING_ASSERTION(ret, "PBrowserParent::SendMouseWheelEvent() failed");
+  MOZ_ASSERT(!ret || aEvent.HasBeenPostedToRemoteProcess());
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvDispatchWheelEvent(
+    const mozilla::WidgetWheelEvent& aEvent) {
+  NS_ENSURE_TRUE(xpc::IsInAutomation(), IPC_FAIL(this, "Unexpected event"));
+
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (!widget) {
+    return IPC_OK();
+  }
+
+  WidgetWheelEvent localEvent(aEvent);
+  localEvent.mWidget = widget;
+  localEvent.mRefPoint = TransformChildToParent(localEvent.mRefPoint);
+
+  widget->DispatchInputEvent(&localEvent);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvDispatchMouseEvent(
+    const mozilla::WidgetMouseEvent& aEvent) {
+  NS_ENSURE_TRUE(xpc::IsInAutomation(), IPC_FAIL(this, "Unexpected event"));
+
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (!widget) {
+    return IPC_OK();
+  }
+
+  WidgetMouseEvent localEvent(aEvent);
+  localEvent.mWidget = widget;
+  localEvent.mRefPoint = TransformChildToParent(localEvent.mRefPoint);
+
+  widget->DispatchInputEvent(&localEvent);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvDispatchKeyboardEvent(
+    const mozilla::WidgetKeyboardEvent& aEvent) {
+  NS_ENSURE_TRUE(xpc::IsInAutomation(), IPC_FAIL(this, "Unexpected event"));
+
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (!widget) {
+    return IPC_OK();
+  }
+
+  WidgetKeyboardEvent localEvent(aEvent);
+  localEvent.mWidget = widget;
+  localEvent.mRefPoint = TransformChildToParent(localEvent.mRefPoint);
+
+  widget->DispatchInputEvent(&localEvent);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvDispatchTouchEvent(
+    const mozilla::WidgetTouchEvent& aEvent) {
+  NS_ENSURE_TRUE(xpc::IsInAutomation(), IPC_FAIL(this, "Unexpected event"));
+
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (!widget) {
+    return IPC_OK();
+  }
+
+  WidgetTouchEvent localEvent(aEvent);
+  localEvent.mWidget = widget;
+
+  for (uint32_t i = 0; i < localEvent.mTouches.Length(); i++) {
+    localEvent.mTouches[i]->mRefPoint =
+        TransformChildToParent(localEvent.mTouches[i]->mRefPoint);
+  }
+
+  widget->DispatchInputEvent(&localEvent);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvRequestNativeKeyBindings(
+    const uint32_t& aType, const WidgetKeyboardEvent& aEvent,
+    nsTArray<CommandInt>* aCommands) {
+  MOZ_ASSERT(aCommands);
+  MOZ_ASSERT(aCommands->IsEmpty());
+
+  NS_ENSURE_TRUE(xpc::IsInAutomation(), IPC_FAIL(this, "Unexpected event"));
+
+  NativeKeyBindingsType keyBindingsType =
+      static_cast<NativeKeyBindingsType>(aType);
+  switch (keyBindingsType) {
+    case NativeKeyBindingsType::SingleLineEditor:
+    case NativeKeyBindingsType::MultiLineEditor:
+    case NativeKeyBindingsType::RichTextEditor:
+      break;
+    default:
+      return IPC_FAIL(this, "Invalid aType value");
+  }
+
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (!widget) {
+    return IPC_OK();
+  }
+
+  WidgetKeyboardEvent localEvent(aEvent);
+  localEvent.mWidget = widget;
+
+  if (NS_FAILED(widget->AttachNativeKeyEvent(localEvent))) {
+    return IPC_OK();
+  }
+
+  Maybe<WritingMode> writingMode;
+  if (RefPtr<widget::TextEventDispatcher> dispatcher =
+          widget->GetTextEventDispatcher()) {
+    writingMode = dispatcher->MaybeQueryWritingModeAtSelection();
+  }
+  if (localEvent.InitEditCommandsFor(keyBindingsType, writingMode)) {
+    *aCommands = localEvent.EditCommandsConstRef(keyBindingsType).Clone();
+  }
+
+  return IPC_OK();
+}
+
+class SynthesizedEventObserver : public nsIObserver {
+  NS_DECL_ISUPPORTS
+
+ public:
+  SynthesizedEventObserver(BrowserParent* aBrowserParent,
+                           const uint64_t& aObserverId)
+      : mBrowserParent(aBrowserParent), mObserverId(aObserverId) {
+    MOZ_ASSERT(mBrowserParent);
+  }
+
+  NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic,
+                     const char16_t* aData) override {
+    if (!mBrowserParent || !mObserverId) {
+      // We already sent the notification, or we don't actually need to
+      // send any notification at all.
+      return NS_OK;
+    }
+
+    if (mBrowserParent->IsDestroyed()) {
+      // If this happens it's probably a bug in the test that's triggering this.
+      NS_WARNING(
+          "BrowserParent was unexpectedly destroyed during event "
+          "synthesization!");
+    } else if (!mBrowserParent->SendNativeSynthesisResponse(
+                   mObserverId, nsCString(aTopic))) {
+      NS_WARNING("Unable to send native event synthesization response!");
+    }
+    // Null out browserParent to indicate we already sent the response
+    mBrowserParent = nullptr;
+    return NS_OK;
+  }
+
+ private:
+  virtual ~SynthesizedEventObserver() = default;
+
+  RefPtr<BrowserParent> mBrowserParent;
+  uint64_t mObserverId;
+};
+
+NS_IMPL_ISUPPORTS(SynthesizedEventObserver, nsIObserver)
+
+class MOZ_STACK_CLASS AutoSynthesizedEventResponder {
+ public:
+  AutoSynthesizedEventResponder(BrowserParent* aBrowserParent,
+                                const uint64_t& aObserverId, const char* aTopic)
+      : mObserver(new SynthesizedEventObserver(aBrowserParent, aObserverId)),
+        mTopic(aTopic) {}
+
+  ~AutoSynthesizedEventResponder() {
+    // This may be a no-op if the observer already sent a response.
+    mObserver->Observe(nullptr, mTopic, nullptr);
+  }
+
+  nsIObserver* GetObserver() { return mObserver; }
+
+ private:
+  nsCOMPtr<nsIObserver> mObserver;
+  const char* mTopic;
+};
+
+mozilla::ipc::IPCResult BrowserParent::RecvSynthesizeNativeKeyEvent(
+    const int32_t& aNativeKeyboardLayout, const int32_t& aNativeKeyCode,
+    const uint32_t& aModifierFlags, const nsString& aCharacters,
+    const nsString& aUnmodifiedCharacters, const uint64_t& aObserverId) {
+  NS_ENSURE_TRUE(xpc::IsInAutomation(), IPC_FAIL(this, "Unexpected event"));
+
+  AutoSynthesizedEventResponder responder(this, aObserverId, "keyevent");
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (widget) {
+    widget->SynthesizeNativeKeyEvent(
+        aNativeKeyboardLayout, aNativeKeyCode, aModifierFlags, aCharacters,
+        aUnmodifiedCharacters, responder.GetObserver());
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSynthesizeNativeMouseEvent(
+    const LayoutDeviceIntPoint& aPoint, const uint32_t& aNativeMessage,
+    const int16_t& aButton, const uint32_t& aModifierFlags,
+    const uint64_t& aObserverId) {
+  NS_ENSURE_TRUE(xpc::IsInAutomation(), IPC_FAIL(this, "Unexpected event"));
+
+  const uint32_t last =
+      static_cast<uint32_t>(nsIWidget::NativeMouseMessage::LeaveWindow);
+  NS_ENSURE_TRUE(aNativeMessage <= last, IPC_FAIL(this, "Bogus message"));
+  AutoSynthesizedEventResponder responder(this, aObserverId, "mouseevent");
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (widget) {
+    widget->SynthesizeNativeMouseEvent(
+        aPoint, static_cast<nsIWidget::NativeMouseMessage>(aNativeMessage),
+        static_cast<mozilla::MouseButton>(aButton),
+        static_cast<nsIWidget::Modifiers>(aModifierFlags),
+        responder.GetObserver());
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSynthesizeNativeMouseMove(
+    const LayoutDeviceIntPoint& aPoint, const uint64_t& aObserverId) {
+  // This is used by pointer lock API.  So, even if it's not in the automation
+  // mode, we need to accept the request.
+  AutoSynthesizedEventResponder responder(this, aObserverId, "mousemove");
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (widget) {
+    widget->SynthesizeNativeMouseMove(aPoint, responder.GetObserver());
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSynthesizeNativeMouseScrollEvent(
+    const LayoutDeviceIntPoint& aPoint, const uint32_t& aNativeMessage,
+    const double& aDeltaX, const double& aDeltaY, const double& aDeltaZ,
+    const uint32_t& aModifierFlags, const uint32_t& aAdditionalFlags,
+    const uint64_t& aObserverId) {
+  NS_ENSURE_TRUE(xpc::IsInAutomation(), IPC_FAIL(this, "Unexpected event"));
+
+  AutoSynthesizedEventResponder responder(this, aObserverId,
+                                          "mousescrollevent");
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (widget) {
+    widget->SynthesizeNativeMouseScrollEvent(
+        aPoint, aNativeMessage, aDeltaX, aDeltaY, aDeltaZ, aModifierFlags,
+        aAdditionalFlags, responder.GetObserver());
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSynthesizeNativeTouchPoint(
+    const uint32_t& aPointerId, const TouchPointerState& aPointerState,
+    const LayoutDeviceIntPoint& aPoint, const double& aPointerPressure,
+    const uint32_t& aPointerOrientation, const uint64_t& aObserverId) {
+  // This is used by DevTools to emulate touch events from mouse events in the
+  // responsive design mode.  Therefore, we should accept the IPC messages even
+  // if it's not in the automation mode but the browsing context is in RDM pane.
+  // And the IPC message could be just delayed after closing the responsive
+  // design mode.  Therefore, we shouldn't return IPC_FAIL since doing it makes
+  // the tab crash.
+  if (!xpc::IsInAutomation()) {
+    NS_ENSURE_TRUE(mBrowsingContext, IPC_OK());
+    NS_ENSURE_TRUE(mBrowsingContext->Top()->GetInRDMPane(), IPC_OK());
+  }
+
+  AutoSynthesizedEventResponder responder(this, aObserverId, "touchpoint");
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (widget) {
+    widget->SynthesizeNativeTouchPoint(aPointerId, aPointerState, aPoint,
+                                       aPointerPressure, aPointerOrientation,
+                                       responder.GetObserver());
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSynthesizeNativeTouchPadPinch(
+    const TouchpadGesturePhase& aEventPhase, const float& aScale,
+    const LayoutDeviceIntPoint& aPoint, const int32_t& aModifierFlags) {
+  NS_ENSURE_TRUE(xpc::IsInAutomation(), IPC_FAIL(this, "Unexpected event"));
+
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (widget) {
+    widget->SynthesizeNativeTouchPadPinch(aEventPhase, aScale, aPoint,
+                                          aModifierFlags);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSynthesizeNativeTouchTap(
+    const LayoutDeviceIntPoint& aPoint, const bool& aLongTap,
+    const uint64_t& aObserverId) {
+  NS_ENSURE_TRUE(xpc::IsInAutomation(), IPC_FAIL(this, "Unexpected event"));
+
+  AutoSynthesizedEventResponder responder(this, aObserverId, "touchtap");
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (widget) {
+    widget->SynthesizeNativeTouchTap(aPoint, aLongTap, responder.GetObserver());
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvClearNativeTouchSequence(
+    const uint64_t& aObserverId) {
+  NS_ENSURE_TRUE(xpc::IsInAutomation(), IPC_FAIL(this, "Unexpected event"));
+
+  AutoSynthesizedEventResponder responder(this, aObserverId, "cleartouch");
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (widget) {
+    widget->ClearNativeTouchSequence(responder.GetObserver());
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSynthesizeNativePenInput(
+    const uint32_t& aPointerId, const TouchPointerState& aPointerState,
+    const LayoutDeviceIntPoint& aPoint, const double& aPressure,
+    const uint32_t& aRotation, const int32_t& aTiltX, const int32_t& aTiltY,
+    const int32_t& aButton, const uint64_t& aObserverId) {
+  NS_ENSURE_TRUE(xpc::IsInAutomation(), IPC_FAIL(this, "Unexpected event"));
+
+  AutoSynthesizedEventResponder responder(this, aObserverId, "peninput");
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (widget) {
+    widget->SynthesizeNativePenInput(aPointerId, aPointerState, aPoint,
+                                     aPressure, aRotation, aTiltX, aTiltY,
+                                     aButton, responder.GetObserver());
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSynthesizeNativeTouchpadDoubleTap(
+    const LayoutDeviceIntPoint& aPoint, const uint32_t& aModifierFlags) {
+  NS_ENSURE_TRUE(xpc::IsInAutomation(), IPC_FAIL(this, "Unexpected event"));
+
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (widget) {
+    widget->SynthesizeNativeTouchpadDoubleTap(aPoint, aModifierFlags);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSynthesizeNativeTouchpadPan(
+    const TouchpadGesturePhase& aEventPhase, const LayoutDeviceIntPoint& aPoint,
+    const double& aDeltaX, const double& aDeltaY, const int32_t& aModifierFlags,
+    const uint64_t& aObserverId) {
+  NS_ENSURE_TRUE(xpc::IsInAutomation(), IPC_FAIL(this, "Unexpected event"));
+
+  AutoSynthesizedEventResponder responder(this, aObserverId,
+                                          "touchpadpanevent");
+
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (widget) {
+    widget->SynthesizeNativeTouchpadPan(aEventPhase, aPoint, aDeltaX, aDeltaY,
+                                        aModifierFlags,
+                                        responder.GetObserver());
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvLockNativePointer() {
+  if (nsCOMPtr<nsIWidget> widget = GetWidget()) {
+    mLockedNativePointer = true;  // do before updating the center
+    UpdateNativePointerLockCenter(widget);
+    widget->LockNativePointer();
+  }
+  return IPC_OK();
+}
+
+void BrowserParent::UnlockNativePointer() {
+  if (!mLockedNativePointer) {
+    return;
+  }
+  if (nsCOMPtr<nsIWidget> widget = GetWidget()) {
+    widget->UnlockNativePointer();
+    mLockedNativePointer = false;
+  }
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvUnlockNativePointer() {
+  UnlockNativePointer();
+  return IPC_OK();
+}
+
+void BrowserParent::SendRealKeyEvent(WidgetKeyboardEvent& aEvent) {
+  if (mIsDestroyed || !mIsReadyToHandleInputEvents) {
+    return;
+  }
+  aEvent.mRefPoint = TransformParentToChild(aEvent.mRefPoint);
+
+  // NOTE: If you call `InitAllEditCommands()` for the other messages too,
+  //       you also need to update
+  //       TextEventDispatcher::DispatchKeyboardEventInternal().
+  if (aEvent.mMessage == eKeyPress) {
+    // If current input context is editable, the edit commands are initialized
+    // by TextEventDispatcher::DispatchKeyboardEventInternal().  Otherwise,
+    // we need to do it here (they are not necessary for the parent process,
+    // therefore, we need to do it here for saving the runtime cost).
+    if (!aEvent.AreAllEditCommandsInitialized()) {
+      // XXX Is it good thing that the keypress event will be handled in an
+      //     editor even though the user pressed the key combination before the
+      //     focus change has not been completed in the parent process yet or
+      //     focus change will happen?  If no, we can stop doing this.
+      Maybe<WritingMode> writingMode;
+      if (aEvent.mWidget) {
+        if (RefPtr<widget::TextEventDispatcher> dispatcher =
+                aEvent.mWidget->GetTextEventDispatcher()) {
+          writingMode = dispatcher->MaybeQueryWritingModeAtSelection();
+        }
+      }
+      aEvent.InitAllEditCommands(writingMode);
+    }
+  } else {
+    aEvent.PreventNativeKeyBindings();
+  }
+  SentKeyEventData sendKeyEventData{
+      aEvent.mKeyCode,      aEvent.mCharCode,      aEvent.mPseudoCharCode,
+      aEvent.mKeyNameIndex, aEvent.mCodeNameIndex, aEvent.mModifiers,
+      nsID::GenerateUUID()};
+  const bool ok =
+      Manager()->IsInputPriorityEventEnabled()
+          ? PBrowserParent::SendRealKeyEvent(aEvent, sendKeyEventData.mUUID)
+          : PBrowserParent::SendNormalPriorityRealKeyEvent(
+                aEvent, sendKeyEventData.mUUID);
+
+  NS_WARNING_ASSERTION(ok, "PBrowserParent::SendRealKeyEvent() failed");
+  MOZ_ASSERT(!ok || aEvent.HasBeenPostedToRemoteProcess());
+  if (ok && aEvent.IsWaitingReplyFromRemoteProcess()) {
+    mWaitingReplyKeyboardEvents.AppendElement(sendKeyEventData);
+  }
+}
+
+void BrowserParent::SendRealTouchEvent(WidgetTouchEvent& aEvent) {
+  if (mIsDestroyed || !mIsReadyToHandleInputEvents) {
+    return;
+  }
+
+  // PresShell::HandleEventInternal adds touches on touch end/cancel.  This
+  // confuses remote content and the panning and zooming logic into thinking
+  // that the added touches are part of the touchend/cancel, when actually
+  // they're not.
+  if (aEvent.mMessage == eTouchEnd || aEvent.mMessage == eTouchCancel) {
+    aEvent.mTouches.RemoveElementsBy(
+        [](const auto& touch) { return !touch->mChanged; });
+  }
+
+  APZData apzData;
+  ApzAwareEventRoutingToChild(&apzData.guid, &apzData.blockId,
+                              &apzData.apzResponse);
+
+  if (mIsDestroyed) {
+    return;
+  }
+
+  for (uint32_t i = 0; i < aEvent.mTouches.Length(); i++) {
+    aEvent.mTouches[i]->mRefPoint =
+        TransformParentToChild(aEvent.mTouches[i]->mRefPoint);
+  }
+
+  static uint32_t sConsecutiveTouchMoveCount = 0;
+  if (aEvent.mMessage == eTouchMove) {
+    ++sConsecutiveTouchMoveCount;
+    SendRealTouchMoveEvent(aEvent, apzData, sConsecutiveTouchMoveCount);
+    return;
+  }
+
+  sConsecutiveTouchMoveCount = 0;
+  DebugOnly<bool> ret =
+      Manager()->IsInputPriorityEventEnabled()
+          ? PBrowserParent::SendRealTouchEvent(
+                aEvent, apzData.guid, apzData.blockId, apzData.apzResponse)
+          : PBrowserParent::SendNormalPriorityRealTouchEvent(
+                aEvent, apzData.guid, apzData.blockId, apzData.apzResponse);
+
+  NS_WARNING_ASSERTION(ret, "PBrowserParent::SendRealTouchEvent() failed");
+  MOZ_ASSERT(!ret || aEvent.HasBeenPostedToRemoteProcess());
+}
+
+void BrowserParent::SendRealTouchMoveEvent(
+    WidgetTouchEvent& aEvent, APZData& aAPZData,
+    uint32_t aConsecutiveTouchMoveCount) {
+  // Touchmove handling is complicated, since IPC compression should be used
+  // only when there are consecutive touch objects for the same touch on the
+  // same BrowserParent. IPC compression can be disabled by switching to
+  // different IPC message.
+  static bool sIPCMessageType1 = true;
+  static TabId sLastTargetBrowserParent(0);
+  static Maybe<APZData> sPreviousAPZData;
+  // Artificially limit max touch points to 10. That should be in practise
+  // more than enough.
+  const uint32_t kMaxTouchMoveIdentifiers = 10;
+  static Maybe<int32_t> sLastTouchMoveIdentifiers[kMaxTouchMoveIdentifiers];
+
+  // Returns true if aIdentifiers contains all the touches in
+  // sLastTouchMoveIdentifiers.
+  auto LastTouchMoveIdentifiersContainedIn =
+      [&](const nsTArray<int32_t>& aIdentifiers) -> bool {
+    for (Maybe<int32_t>& entry : sLastTouchMoveIdentifiers) {
+      if (entry.isSome() && !aIdentifiers.Contains(entry.value())) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  // Cache touch identifiers in sLastTouchMoveIdentifiers array to be used
+  // when checking whether compression can be done for the next touchmove.
+  auto SetLastTouchMoveIdentifiers =
+      [&](const nsTArray<int32_t>& aIdentifiers) {
+        for (Maybe<int32_t>& entry : sLastTouchMoveIdentifiers) {
+          entry.reset();
+        }
+
+        MOZ_ASSERT(aIdentifiers.Length() <= kMaxTouchMoveIdentifiers);
+        for (uint32_t j = 0; j < aIdentifiers.Length(); ++j) {
+          sLastTouchMoveIdentifiers[j].emplace(aIdentifiers[j]);
+        }
+      };
+
+  AutoTArray<int32_t, kMaxTouchMoveIdentifiers> changedTouches;
+  bool preventCompression = !StaticPrefs::dom_events_compress_touchmove() ||
+                            // Ensure the very first touchmove isn't overridden
+                            // by the second one, so that web pages can get
+                            // accurate coordinates for the first touchmove.
+                            aConsecutiveTouchMoveCount < 3 ||
+                            sPreviousAPZData.isNothing() ||
+                            sPreviousAPZData.value() != aAPZData ||
+                            sLastTargetBrowserParent != GetTabId() ||
+                            aEvent.mTouches.Length() > kMaxTouchMoveIdentifiers;
+
+  if (!preventCompression) {
+    for (RefPtr<Touch>& touch : aEvent.mTouches) {
+      if (touch->mChanged) {
+        changedTouches.AppendElement(touch->mIdentifier);
+      }
+    }
+
+    // Prevent compression if the new event has fewer or different touches
+    // than the old one.
+    preventCompression = !LastTouchMoveIdentifiersContainedIn(changedTouches);
+  }
+
+  if (preventCompression) {
+    sIPCMessageType1 = !sIPCMessageType1;
+  }
+
+  // Update the last touch move identifiers always, so that when the next
+  // event comes in, the new identifiers can be compared to the old ones.
+  // If the pref is disabled, this just does a quick small loop.
+  SetLastTouchMoveIdentifiers(changedTouches);
+  sPreviousAPZData.reset();
+  sPreviousAPZData.emplace(aAPZData);
+  sLastTargetBrowserParent = GetTabId();
+
+  DebugOnly<bool> ret = true;
+  if (sIPCMessageType1) {
+    ret =
+        Manager()->IsInputPriorityEventEnabled()
+            ? PBrowserParent::SendRealTouchMoveEvent(
+                  aEvent, aAPZData.guid, aAPZData.blockId, aAPZData.apzResponse)
+            : PBrowserParent::SendNormalPriorityRealTouchMoveEvent(
+                  aEvent, aAPZData.guid, aAPZData.blockId,
+                  aAPZData.apzResponse);
+  } else {
+    ret =
+        Manager()->IsInputPriorityEventEnabled()
+            ? PBrowserParent::SendRealTouchMoveEvent2(
+                  aEvent, aAPZData.guid, aAPZData.blockId, aAPZData.apzResponse)
+            : PBrowserParent::SendNormalPriorityRealTouchMoveEvent2(
+                  aEvent, aAPZData.guid, aAPZData.blockId,
+                  aAPZData.apzResponse);
+  }
+
+  NS_WARNING_ASSERTION(ret, "PBrowserParent::SendRealTouchMoveEvent() failed");
+  MOZ_ASSERT(!ret || aEvent.HasBeenPostedToRemoteProcess());
+}
+
+bool BrowserParent::SendHandleTap(TapType aType,
+                                  const LayoutDevicePoint& aPoint,
+                                  Modifiers aModifiers,
+                                  const ScrollableLayerGuid& aGuid,
+                                  uint64_t aInputBlockId) {
+  if (mIsDestroyed || !mIsReadyToHandleInputEvents) {
+    return false;
+  }
+  if ((aType == TapType::eSingleTap || aType == TapType::eSecondTap)) {
+    if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
+      if (RefPtr<nsFrameLoader> frameLoader = GetFrameLoader()) {
+        if (RefPtr<Element> element = frameLoader->GetOwnerContent()) {
+          fm->SetFocus(element, nsIFocusManager::FLAG_BYMOUSE |
+                                    nsIFocusManager::FLAG_BYTOUCH |
+                                    nsIFocusManager::FLAG_NOSCROLL);
+        }
+      }
+    }
+  }
+  return Manager()->IsInputPriorityEventEnabled()
+             ? PBrowserParent::SendHandleTap(aType,
+                                             TransformParentToChild(aPoint),
+                                             aModifiers, aGuid, aInputBlockId)
+             : PBrowserParent::SendNormalPriorityHandleTap(
+                   aType, TransformParentToChild(aPoint), aModifiers, aGuid,
+                   aInputBlockId);
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSyncMessage(
+    const nsString& aMessage, const ClonedMessageData& aData,
+    nsTArray<StructuredCloneData>* aRetVal) {
+  AUTO_PROFILER_LABEL_DYNAMIC_LOSSY_NSSTRING("BrowserParent::RecvSyncMessage",
+                                             OTHER, aMessage);
+  MMPrinter::Print("BrowserParent::RecvSyncMessage", aMessage, aData);
+
+  StructuredCloneData data;
+  ipc::UnpackClonedMessageData(aData, data);
+
+  if (!ReceiveMessage(aMessage, true, &data, aRetVal)) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvAsyncMessage(
+    const nsString& aMessage, const ClonedMessageData& aData) {
+  AUTO_PROFILER_LABEL_DYNAMIC_LOSSY_NSSTRING("BrowserParent::RecvAsyncMessage",
+                                             OTHER, aMessage);
+  MMPrinter::Print("BrowserParent::RecvAsyncMessage", aMessage, aData);
+
+  StructuredCloneData data;
+  ipc::UnpackClonedMessageData(aData, data);
+
+  if (!ReceiveMessage(aMessage, false, &data, nullptr)) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSetCursor(
+    const nsCursor& aCursor, const bool& aHasCustomCursor,
+    Maybe<BigBuffer>&& aCursorData, const uint32_t& aWidth,
+    const uint32_t& aHeight, const float& aResolutionX,
+    const float& aResolutionY, const uint32_t& aStride,
+    const gfx::SurfaceFormat& aFormat, const uint32_t& aHotspotX,
+    const uint32_t& aHotspotY, const bool& aForce) {
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (!widget) {
+    return IPC_OK();
+  }
+
+  if (aForce) {
+    widget->ClearCachedCursor();
+  }
+
+  nsCOMPtr<imgIContainer> cursorImage;
+  if (aHasCustomCursor) {
+    const bool cursorDataValid = [&] {
+      if (!aCursorData) {
+        return false;
+      }
+      auto expectedSize = CheckedInt<uint32_t>(aHeight) * aStride;
+      if (!expectedSize.isValid() ||
+          expectedSize.value() != aCursorData->Size()) {
+        return false;
+      }
+      auto minStride =
+          CheckedInt<uint32_t>(aWidth) * gfx::BytesPerPixel(aFormat);
+      if (!minStride.isValid() || aStride < minStride.value()) {
+        return false;
+      }
+      return true;
+    }();
+    if (!cursorDataValid) {
+      return IPC_FAIL(this, "Invalid custom cursor data");
+    }
+    const gfx::IntSize size(aWidth, aHeight);
+    RefPtr<gfx::DataSourceSurface> customCursor =
+        gfx::CreateDataSourceSurfaceFromData(size, aFormat, aCursorData->Data(),
+                                             aStride);
+
+    RefPtr<gfxDrawable> drawable = new gfxSurfaceDrawable(customCursor, size);
+    cursorImage = image::ImageOps::CreateFromDrawable(drawable);
+  }
+
+  mCursor = nsIWidget::Cursor{aCursor,
+                              std::move(cursorImage),
+                              aHotspotX,
+                              aHotspotY,
+                              {aResolutionX, aResolutionY}};
+  if (!mRemoteTargetSetsCursor) {
+    return IPC_OK();
+  }
+
+  widget->SetCursor(mCursor);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSetLinkStatus(
+    const nsString& aStatus) {
+  nsCOMPtr<nsIXULBrowserWindow> xulBrowserWindow = GetXULBrowserWindow();
+  if (!xulBrowserWindow) {
+    return IPC_OK();
+  }
+
+  xulBrowserWindow->SetOverLink(aStatus);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvShowTooltip(
+    const uint32_t& aX, const uint32_t& aY, const nsString& aTooltip,
+    const nsString& aDirection) {
+  nsCOMPtr<nsIXULBrowserWindow> xulBrowserWindow = GetXULBrowserWindow();
+  if (!xulBrowserWindow) {
+    return IPC_OK();
+  }
+
+  // ShowTooltip will end up accessing XULElement properties in JS (specifically
+  // BoxObject). However, to get it to JS, we need to make sure we're a
+  // nsFrameLoaderOwner, which implies we're a XULFrameElement. We can then
+  // safely pass Element into JS.
+  RefPtr<nsFrameLoaderOwner> flo = do_QueryObject(mFrameElement);
+  if (!flo) return IPC_OK();
+
+  nsCOMPtr<Element> el = do_QueryInterface(flo);
+  if (!el) return IPC_OK();
+
+  if (NS_SUCCEEDED(
+          xulBrowserWindow->ShowTooltip(aX, aY, aTooltip, aDirection, el))) {
+    mShowingTooltip = true;
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvHideTooltip() {
+  mShowingTooltip = false;
+
+  nsCOMPtr<nsIXULBrowserWindow> xulBrowserWindow = GetXULBrowserWindow();
+  if (!xulBrowserWindow) {
+    return IPC_OK();
+  }
+
+  xulBrowserWindow->HideTooltip();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvNotifyIMEFocus(
+    const ContentCache& aContentCache, const IMENotification& aIMENotification,
+    NotifyIMEFocusResolver&& aResolve) {
+  if (mIsDestroyed) {
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIWidget> widget = GetTextInputHandlingWidget();
+  if (!widget) {
+    aResolve(IMENotificationRequests());
+    return IPC_OK();
+  }
+  if (NS_WARN_IF(!aContentCache.IsValid())) {
+    return IPC_FAIL(this, "Invalid content cache data");
+  }
+  mContentCache.AssignContent(aContentCache, widget, &aIMENotification);
+  IMEStateManager::NotifyIME(aIMENotification, widget, this);
+
+  IMENotificationRequests requests;
+  if (aIMENotification.mMessage == NOTIFY_IME_OF_FOCUS) {
+    requests = widget->IMENotificationRequestsRef();
+  }
+  aResolve(requests);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvNotifyIMETextChange(
+    const ContentCache& aContentCache,
+    const IMENotification& aIMENotification) {
+  nsCOMPtr<nsIWidget> widget = GetTextInputHandlingWidget();
+  if (!widget || !IMEStateManager::DoesBrowserParentHaveIMEFocus(this)) {
+    return IPC_OK();
+  }
+  if (NS_WARN_IF(!aContentCache.IsValid())) {
+    return IPC_FAIL(this, "Invalid content cache data");
+  }
+  mContentCache.AssignContent(aContentCache, widget, &aIMENotification);
+  mContentCache.MaybeNotifyIME(widget, aIMENotification);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvNotifyIMECompositionUpdate(
+    const ContentCache& aContentCache,
+    const IMENotification& aIMENotification) {
+  nsCOMPtr<nsIWidget> widget = GetTextInputHandlingWidget();
+  if (!widget || !IMEStateManager::DoesBrowserParentHaveIMEFocus(this)) {
+    return IPC_OK();
+  }
+  if (NS_WARN_IF(!aContentCache.IsValid())) {
+    return IPC_FAIL(this, "Invalid content cache data");
+  }
+  mContentCache.AssignContent(aContentCache, widget, &aIMENotification);
+  mContentCache.MaybeNotifyIME(widget, aIMENotification);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvNotifyIMESelection(
+    const ContentCache& aContentCache,
+    const IMENotification& aIMENotification) {
+  nsCOMPtr<nsIWidget> widget = GetTextInputHandlingWidget();
+  if (!widget || !IMEStateManager::DoesBrowserParentHaveIMEFocus(this)) {
+    return IPC_OK();
+  }
+  if (NS_WARN_IF(!aContentCache.IsValid())) {
+    return IPC_FAIL(this, "Invalid content cache data");
+  }
+  mContentCache.AssignContent(aContentCache, widget, &aIMENotification);
+  mContentCache.MaybeNotifyIME(widget, aIMENotification);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvUpdateContentCache(
+    const ContentCache& aContentCache) {
+  nsCOMPtr<nsIWidget> widget = GetTextInputHandlingWidget();
+  if (!widget || !IMEStateManager::DoesBrowserParentHaveIMEFocus(this)) {
+    return IPC_OK();
+  }
+  if (NS_WARN_IF(!aContentCache.IsValid())) {
+    return IPC_FAIL(this, "Invalid content cache data");
+  }
+  mContentCache.AssignContent(aContentCache, widget);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvNotifyIMEMouseButtonEvent(
+    const IMENotification& aIMENotification, bool* aConsumedByIME) {
+  nsCOMPtr<nsIWidget> widget = GetTextInputHandlingWidget();
+  if (!widget || !IMEStateManager::DoesBrowserParentHaveIMEFocus(this)) {
+    *aConsumedByIME = false;
+    return IPC_OK();
+  }
+  nsresult rv = IMEStateManager::NotifyIME(aIMENotification, widget, this);
+  *aConsumedByIME = rv == NS_SUCCESS_EVENT_CONSUMED;
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvNotifyIMEPositionChange(
+    const ContentCache& aContentCache,
+    const IMENotification& aIMENotification) {
+  nsCOMPtr<nsIWidget> widget = GetTextInputHandlingWidget();
+  if (!widget || !IMEStateManager::DoesBrowserParentHaveIMEFocus(this)) {
+    return IPC_OK();
+  }
+  if (NS_WARN_IF(!aContentCache.IsValid())) {
+    return IPC_FAIL(this, "Invalid content cache data");
+  }
+  mContentCache.AssignContent(aContentCache, widget, &aIMENotification);
+  mContentCache.MaybeNotifyIME(widget, aIMENotification);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvOnEventNeedingAckHandled(
+    const EventMessage& aMessage) {
+  // This is called when the child process receives WidgetCompositionEvent or
+  // WidgetSelectionEvent.
+  // FYI: Don't check if widget is nullptr here because it's more important to
+  //      notify mContentCahce of this than handling something in it.
+  nsCOMPtr<nsIWidget> widget = GetTextInputHandlingWidget();
+
+  // While calling OnEventNeedingAckHandled(), BrowserParent *might* be
+  // destroyed since it may send notifications to IME.
+  RefPtr<BrowserParent> kungFuDeathGrip(this);
+  mContentCache.OnEventNeedingAckHandled(widget, aMessage);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvRequestFocus(
+    const bool& aCanRaise, const CallerType aCallerType) {
+  LOGBROWSERFOCUS(("RecvRequestFocus %p, aCanRaise: %d", this, aCanRaise));
+  if (BrowserBridgeParent* bridgeParent = GetBrowserBridgeParent()) {
+    mozilla::Unused << bridgeParent->SendRequestFocus(aCanRaise, aCallerType);
+    return IPC_OK();
+  }
+
+  if (!mFrameElement) {
+    return IPC_OK();
+  }
+
+  nsContentUtils::RequestFrameFocus(*mFrameElement, aCanRaise, aCallerType);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvWheelZoomChange(bool aIncrease) {
+  RefPtr<BrowsingContext> bc = GetBrowsingContext();
+  if (!bc) {
+    return IPC_OK();
+  }
+
+  bc->Canonical()->DispatchWheelZoomChange(aIncrease);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvEnableDisableCommands(
+    const MaybeDiscarded<BrowsingContext>& aContext, const nsString& aAction,
+    nsTArray<nsCString>&& aEnabledCommands,
+    nsTArray<nsCString>&& aDisabledCommands) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIBrowserController> browserController = do_QueryActor(
+      "Controllers", aContext.get_canonical()->GetCurrentWindowGlobal());
+  if (browserController) {
+    browserController->EnableDisableCommands(aAction, aEnabledCommands,
+                                             aDisabledCommands);
+  }
+
+  return IPC_OK();
+}
+
+LayoutDeviceIntPoint BrowserParent::TransformPoint(
+    const LayoutDeviceIntPoint& aPoint,
+    const LayoutDeviceToLayoutDeviceMatrix4x4& aMatrix) {
+  LayoutDevicePoint floatPoint(aPoint);
+  LayoutDevicePoint floatTransformed = TransformPoint(floatPoint, aMatrix);
+  // The next line loses precision if an out-of-process iframe
+  // has been scaled or rotated.
+  return RoundedToInt(floatTransformed);
+}
+
+LayoutDevicePoint BrowserParent::TransformPoint(
+    const LayoutDevicePoint& aPoint,
+    const LayoutDeviceToLayoutDeviceMatrix4x4& aMatrix) {
+  return aMatrix.TransformPoint(aPoint);
+}
+
+LayoutDeviceIntPoint BrowserParent::TransformParentToChild(
+    const LayoutDeviceIntPoint& aPoint) {
+  LayoutDeviceToLayoutDeviceMatrix4x4 matrix =
+      GetChildToParentConversionMatrix();
+  if (!matrix.Invert()) {
+    return LayoutDeviceIntPoint();
+  }
+  auto transformed = UntransformBy(matrix, aPoint);
+  if (!transformed) {
+    return LayoutDeviceIntPoint();
+  }
+  return transformed.ref();
+}
+
+LayoutDevicePoint BrowserParent::TransformParentToChild(
+    const LayoutDevicePoint& aPoint) {
+  LayoutDeviceToLayoutDeviceMatrix4x4 matrix =
+      GetChildToParentConversionMatrix();
+  if (!matrix.Invert()) {
+    return LayoutDevicePoint();
+  }
+  auto transformed = UntransformBy(matrix, aPoint);
+  if (!transformed) {
+    return LayoutDeviceIntPoint();
+  }
+  return transformed.ref();
+}
+
+LayoutDeviceIntPoint BrowserParent::TransformChildToParent(
+    const LayoutDeviceIntPoint& aPoint) {
+  return TransformPoint(aPoint, GetChildToParentConversionMatrix());
+}
+
+LayoutDevicePoint BrowserParent::TransformChildToParent(
+    const LayoutDevicePoint& aPoint) {
+  return TransformPoint(aPoint, GetChildToParentConversionMatrix());
+}
+
+LayoutDeviceIntRect BrowserParent::TransformChildToParent(
+    const LayoutDeviceIntRect& aRect) {
+  LayoutDeviceToLayoutDeviceMatrix4x4 matrix =
+      GetChildToParentConversionMatrix();
+  LayoutDeviceRect floatRect(aRect);
+  // The outcome is not ideal if an out-of-process iframe has been rotated
+  LayoutDeviceRect floatTransformed = matrix.TransformBounds(floatRect);
+  // The next line loses precision if an out-of-process iframe
+  // has been scaled or rotated.
+  return RoundedToInt(floatTransformed);
+}
+
+LayoutDeviceToLayoutDeviceMatrix4x4
+BrowserParent::GetChildToParentConversionMatrix() {
+  if (mChildToParentConversionMatrix) {
+    return *mChildToParentConversionMatrix;
+  }
+  LayoutDevicePoint offset(-GetChildProcessOffset());
+  return LayoutDeviceToLayoutDeviceMatrix4x4::Translation(offset);
+}
+
+void BrowserParent::SetChildToParentConversionMatrix(
+    const Maybe<LayoutDeviceToLayoutDeviceMatrix4x4>& aMatrix,
+    const ScreenRect& aRemoteDocumentRect) {
+  if (mChildToParentConversionMatrix == aMatrix &&
+      mRemoteDocumentRect.isSome() &&
+      mRemoteDocumentRect.value() == aRemoteDocumentRect) {
+    return;
+  }
+
+  mChildToParentConversionMatrix = aMatrix;
+  mRemoteDocumentRect = Some(aRemoteDocumentRect);
+  if (mIsDestroyed) {
+    return;
+  }
+  mozilla::Unused << SendChildToParentMatrix(ToUnknownMatrix(aMatrix),
+                                             aRemoteDocumentRect);
+}
+
+LayoutDeviceIntPoint BrowserParent::GetChildProcessOffset() {
+  // The "toplevel widget" in child processes is always at position
+  // 0,0.  Map the event coordinates to match that.
+
+  LayoutDeviceIntPoint offset(0, 0);
+  RefPtr<nsFrameLoader> frameLoader = GetFrameLoader();
+  if (!frameLoader) {
+    return offset;
+  }
+  nsIFrame* targetFrame = frameLoader->GetPrimaryFrameOfOwningContent();
+  if (!targetFrame) {
+    return offset;
+  }
+
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (!widget) {
+    return offset;
+  }
+
+  nsPresContext* presContext = targetFrame->PresContext();
+  nsIFrame* rootFrame = presContext->PresShell()->GetRootFrame();
+  nsView* rootView = rootFrame ? rootFrame->GetView() : nullptr;
+  if (!rootView) {
+    return offset;
+  }
+
+  // Note that we don't want to take into account transforms here:
+#if 0
+  nsPoint pt(0, 0);
+  nsLayoutUtils::TransformPoint(targetFrame, rootFrame, pt);
+#endif
+  // In practice, when transforms are applied to this frameLoader, we currently
+  // get the wrong results whether we take transforms into account here or not.
+  // But applying transforms here gives us the wrong results in all
+  // circumstances when transforms are applied, unless they're purely
+  // translational. It also gives us the wrong results whenever CSS transitions
+  // are used to apply transforms, since the offeets aren't updated as the
+  // transition is animated.
+  //
+  // What we actually need to do is apply the transforms to the coordinates of
+  // any events we send to the child, and reverse them for any screen
+  // coordinates that we retrieve from the child.
+
+  // TODO: Once we take into account transforms here, set viewportType
+  // correctly. For now we use Visual as this means we don't apply
+  // the layout-to-visual transform in TranslateViewToWidget().
+  ViewportType viewportType = ViewportType::Visual;
+
+  nsPoint pt = targetFrame->GetOffsetTo(rootFrame);
+  return -nsLayoutUtils::TranslateViewToWidget(presContext, rootView, pt,
+                                               viewportType, widget);
+}
+
+LayoutDeviceIntPoint BrowserParent::GetClientOffset() {
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  nsCOMPtr<nsIWidget> docWidget = GetDocWidget();
+
+  if (widget == docWidget) {
+    return widget->GetClientOffset();
+  }
+
+  return (docWidget->GetClientOffset() +
+          nsLayoutUtils::WidgetToWidgetOffset(widget, docWidget));
+}
+
+void BrowserParent::StopIMEStateManagement() {
+  if (mIsDestroyed) {
+    return;
+  }
+  Unused << SendStopIMEStateManagement();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvReplyKeyEvent(
+    const WidgetKeyboardEvent& aEvent, const nsID& aUUID) {
+  NS_ENSURE_TRUE(mFrameElement, IPC_OK());
+
+  // First, verify aEvent is what we've sent to a remote process.
+  Maybe<size_t> index = [&]() -> Maybe<size_t> {
+    for (const size_t i : IntegerRange(mWaitingReplyKeyboardEvents.Length())) {
+      const SentKeyEventData& data = mWaitingReplyKeyboardEvents[i];
+      if (data.mUUID.Equals(aUUID)) {
+        if (NS_WARN_IF(data.mKeyCode != aEvent.mKeyCode) ||
+            NS_WARN_IF(data.mCharCode != aEvent.mCharCode) ||
+            NS_WARN_IF(data.mPseudoCharCode != aEvent.mPseudoCharCode) ||
+            NS_WARN_IF(data.mKeyNameIndex != aEvent.mKeyNameIndex) ||
+            NS_WARN_IF(data.mCodeNameIndex != aEvent.mCodeNameIndex) ||
+            NS_WARN_IF(data.mModifiers != aEvent.mModifiers)) {
+          // Got different event data from what we stored before dispatching an
+          // event with the ID.
+          return Nothing();
+        }
+        return Some(i);
+      }
+    }
+    // No entry found.
+    return Nothing();
+  }();
+  if (MOZ_UNLIKELY(index.isNothing())) {
+    return IPC_FAIL(this, "Bogus reply keyboard event");
+  }
+  // Don't discard the older keyboard events because the order may be changed if
+  // the remote process has a event listener which takes too long time and while
+  // the freezing, user may switch the tab, or if the remote process sends
+  // synchronous XMLHttpRequest.
+  mWaitingReplyKeyboardEvents.RemoveElementAt(*index);
+
+  // If the event propagation was stopped by the child, it means that the event
+  // was ignored in the child.  In the case, we should ignore it too because the
+  // focused web app didn't have a chance to prevent its default.
+  if (aEvent.PropagationStopped()) {
+    return IPC_OK();
+  }
+
+  WidgetKeyboardEvent localEvent(aEvent);
+  localEvent.MarkAsHandledInRemoteProcess();
+
+  // Here we convert the WidgetEvent that we received to an Event
+  // to be able to dispatch it to the <browser> element as the target element.
+  RefPtr<nsPresContext> presContext =
+      mFrameElement->OwnerDoc()->GetPresContext();
+  NS_ENSURE_TRUE(presContext, IPC_OK());
+
+  AutoHandlingUserInputStatePusher userInpStatePusher(localEvent.IsTrusted(),
+                                                      &localEvent);
+
+  nsEventStatus status = nsEventStatus_eIgnore;
+
+  // Handle access key in this process before dispatching reply event because
+  // ESM handles it before dispatching the event to the DOM tree.
+  if (localEvent.mMessage == eKeyPress &&
+      (localEvent.ModifiersMatchWithAccessKey(AccessKeyType::eChrome) ||
+       localEvent.ModifiersMatchWithAccessKey(AccessKeyType::eContent))) {
+    RefPtr<EventStateManager> esm = presContext->EventStateManager();
+    AutoTArray<uint32_t, 10> accessCharCodes;
+    localEvent.GetAccessKeyCandidates(accessCharCodes);
+    if (esm->HandleAccessKey(&localEvent, presContext, accessCharCodes)) {
+      status = nsEventStatus_eConsumeNoDefault;
+    }
+  }
+
+  RefPtr<Element> frameElement = mFrameElement;
+  EventDispatcher::Dispatch(frameElement, presContext, &localEvent, nullptr,
+                            &status);
+
+  if (!localEvent.DefaultPrevented() &&
+      !localEvent.mFlags.mIsSynthesizedForTests) {
+    nsCOMPtr<nsIWidget> widget = GetWidget();
+    if (widget) {
+      widget->PostHandleKeyEvent(&localEvent);
+      localEvent.StopPropagation();
+    }
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvAccessKeyNotHandled(
+    const WidgetKeyboardEvent& aEvent) {
+  NS_ENSURE_TRUE(mFrameElement, IPC_OK());
+
+  // This is called only when this process had focus and HandleAccessKey
+  // message was posted to all remote process and each remote process didn't
+  // execute any content access keys.
+
+  if (MOZ_UNLIKELY(aEvent.mMessage != eKeyPress || !aEvent.IsTrusted())) {
+    return IPC_FAIL(this, "Called with unexpected event");
+  }
+
+  // If there is no requesting event, the event may have already been handled
+  // when it's returned from another remote process.
+  if (MOZ_UNLIKELY(!RequestingAccessKeyEventData::IsSet())) {
+    return IPC_OK();
+  }
+
+  // If the event does not match with the one which we requested a remote
+  // process to handle access key of (that means that we has already requested
+  // for another key press), we should ignore this call because user focuses
+  // to the last key press.
+  if (MOZ_UNLIKELY(!RequestingAccessKeyEventData::Equals(aEvent))) {
+    return IPC_OK();
+  }
+
+  RequestingAccessKeyEventData::Clear();
+
+  WidgetKeyboardEvent localEvent(aEvent);
+  localEvent.MarkAsHandledInRemoteProcess();
+  localEvent.mMessage = eAccessKeyNotFound;
+
+  // Here we convert the WidgetEvent that we received to an Event
+  // to be able to dispatch it to the <browser> element as the target element.
+  Document* doc = mFrameElement->OwnerDoc();
+  PresShell* presShell = doc->GetPresShell();
+  NS_ENSURE_TRUE(presShell, IPC_OK());
+
+  if (presShell->CanDispatchEvent()) {
+    RefPtr<nsPresContext> presContext = presShell->GetPresContext();
+    NS_ENSURE_TRUE(presContext, IPC_OK());
+
+    RefPtr<Element> frameElement = mFrameElement;
+    EventDispatcher::Dispatch(frameElement, presContext, &localEvent);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvRegisterProtocolHandler(
+    const nsString& aScheme, nsIURI* aHandlerURI, const nsString& aTitle,
+    nsIURI* aDocURI) {
+  nsCOMPtr<nsIWebProtocolHandlerRegistrar> registrar =
+      do_GetService(NS_WEBPROTOCOLHANDLERREGISTRAR_CONTRACTID);
+  if (registrar) {
+    registrar->RegisterProtocolHandler(aScheme, aHandlerURI, aTitle, aDocURI,
+                                       mFrameElement);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvOnStateChange(
+    const WebProgressData& aWebProgressData, const RequestData& aRequestData,
+    const uint32_t aStateFlags, const nsresult aStatus,
+    const Maybe<WebProgressStateChangeData>& aStateChangeData) {
+  RefPtr<CanonicalBrowsingContext> browsingContext =
+      BrowsingContextForWebProgress(aWebProgressData);
+  if (!browsingContext) {
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIRequest> request;
+  if (aRequestData.requestURI()) {
+    request = MakeAndAddRef<RemoteWebProgressRequest>(
+        aRequestData.requestURI(), aRequestData.originalRequestURI(),
+        aRequestData.matchedList());
+  }
+
+  if (aStateChangeData.isSome()) {
+    if (!browsingContext->IsTopContent()) {
+      return IPC_FAIL(
+          this,
+          "Unexpected WebProgressStateChangeData for non toplevel webProgress");
+    }
+
+    if (nsCOMPtr<nsIBrowser> browser = GetBrowser()) {
+      Unused << browser->SetIsNavigating(aStateChangeData->isNavigating());
+      Unused << browser->SetMayEnableCharacterEncodingMenu(
+          aStateChangeData->mayEnableCharacterEncodingMenu());
+      Unused << browser->UpdateForStateChange(aStateChangeData->charset(),
+                                              aStateChangeData->documentURI(),
+                                              aStateChangeData->contentType());
+    }
+  }
+
+  if (auto* listener = browsingContext->GetWebProgress()) {
+    listener->OnStateChange(listener, request, aStateFlags, aStatus);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvOnProgressChange(
+    const int32_t aCurTotalProgress, const int32_t aMaxTotalProgress) {
+  // We only collect progress change notifications for the toplevel
+  // BrowserParent.
+  // FIXME: In the future, consider merging in progress change information from
+  // oop subframes.
+  if (!GetBrowsingContext()->IsTopContent() ||
+      !GetBrowsingContext()->GetWebProgress()) {
+    return IPC_OK();
+  }
+
+  GetBrowsingContext()->GetWebProgress()->OnProgressChange(
+      nullptr, nullptr, 0, 0, aCurTotalProgress, aMaxTotalProgress);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvOnLocationChange(
+    const WebProgressData& aWebProgressData, const RequestData& aRequestData,
+    nsIURI* aLocation, const uint32_t aFlags, const bool aCanGoBack,
+    const bool aCanGoForward,
+    const Maybe<WebProgressLocationChangeData>& aLocationChangeData) {
+  RefPtr<CanonicalBrowsingContext> browsingContext =
+      BrowsingContextForWebProgress(aWebProgressData);
+  if (!browsingContext) {
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIRequest> request;
+  if (aRequestData.requestURI()) {
+    request = MakeAndAddRef<RemoteWebProgressRequest>(
+        aRequestData.requestURI(), aRequestData.originalRequestURI(),
+        aRequestData.matchedList());
+  }
+
+  browsingContext->SetCurrentRemoteURI(aLocation);
+
+  nsCOMPtr<nsIBrowser> browser = GetBrowser();
+  if (!mozilla::SessionHistoryInParent() && browser) {
+    Unused << browser->UpdateWebNavigationForLocationChange(aCanGoBack,
+                                                            aCanGoForward);
+  }
+
+  if (aLocationChangeData.isSome()) {
+    if (!browsingContext->IsTopContent()) {
+      return IPC_FAIL(this,
+                      "Unexpected WebProgressLocationChangeData for non "
+                      "toplevel webProgress");
+    }
+
+    if (browser) {
+      Unused << browser->SetIsNavigating(aLocationChangeData->isNavigating());
+      Unused << browser->UpdateForLocationChange(
+          aLocation, aLocationChangeData->charset(),
+          aLocationChangeData->mayEnableCharacterEncodingMenu(),
+          aLocationChangeData->documentURI(), aLocationChangeData->title(),
+          aLocationChangeData->contentPrincipal(),
+          aLocationChangeData->contentPartitionedPrincipal(),
+          aLocationChangeData->csp(), aLocationChangeData->referrerInfo(),
+          aLocationChangeData->isSyntheticDocument(),
+          aLocationChangeData->requestContextID().isSome(),
+          aLocationChangeData->requestContextID().valueOr(0),
+          aLocationChangeData->contentType());
+    }
+  }
+
+  if (auto* listener = browsingContext->GetWebProgress()) {
+    listener->OnLocationChange(listener, request, aLocation, aFlags);
+  }
+
+  // Since we've now changed Documents, notify the BrowsingContext that we've
+  // changed. Ideally we'd just let the BrowsingContext do this when it changes
+  // the current window global, but that happens before this and we have a lot
+  // of tests that depend on the specific ordering of messages.
+  if (browsingContext->IsTopContent() &&
+      !(aFlags & nsIWebProgressListener::LOCATION_CHANGE_SAME_DOCUMENT)) {
+    browsingContext->UpdateSecurityState();
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvOnStatusChange(
+    const nsString& aMessage) {
+  // We only collect status change notifications for the toplevel
+  // BrowserParent.
+  // FIXME: In the future, consider merging in status change information from
+  // oop subframes.
+  if (!GetBrowsingContext()->IsTopContent() ||
+      !GetBrowsingContext()->GetWebProgress()) {
+    return IPC_OK();
+  }
+
+  GetBrowsingContext()->GetWebProgress()->OnStatusChange(nullptr, nullptr,
+                                                         NS_OK, aMessage.get());
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvNavigationFinished() {
+  nsCOMPtr<nsIBrowser> browser =
+      mFrameElement ? mFrameElement->AsBrowser() : nullptr;
+
+  if (browser) {
+    browser->SetIsNavigating(false);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvNotifyContentBlockingEvent(
+    const uint32_t& aEvent, const RequestData& aRequestData,
+    const bool aBlocked, const nsACString& aTrackingOrigin,
+    nsTArray<nsCString>&& aTrackingFullHashes,
+    const Maybe<
+        mozilla::ContentBlockingNotifier::StorageAccessPermissionGrantedReason>&
+        aReason) {
+  RefPtr<BrowsingContext> bc = GetBrowsingContext();
+
+  if (!bc || bc->IsDiscarded()) {
+    return IPC_OK();
+  }
+
+  // Get the top-level browsing context.
+  bc = bc->Top();
+  RefPtr<dom::WindowGlobalParent> wgp =
+      bc->Canonical()->GetCurrentWindowGlobal();
+
+  // The WindowGlobalParent would be null while running the test
+  // browser_339445.js. This is unexpected and we will address this in a
+  // following bug. For now, we first workaround this issue.
+  if (!wgp) {
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIRequest> request = MakeAndAddRef<RemoteWebProgressRequest>(
+      aRequestData.requestURI(), aRequestData.originalRequestURI(),
+      aRequestData.matchedList());
+
+  wgp->NotifyContentBlockingEvent(aEvent, request, aBlocked, aTrackingOrigin,
+                                  aTrackingFullHashes, aReason);
+
+  return IPC_OK();
+}
+
+already_AddRefed<nsIBrowser> BrowserParent::GetBrowser() {
+  nsCOMPtr<nsIBrowser> browser;
+  RefPtr<Element> currentElement = mFrameElement;
+
+  // In Responsive Design Mode, mFrameElement will be the <iframe mozbrowser>,
+  // but we want the <xul:browser> that it is embedded in.
+  while (currentElement) {
+    browser = currentElement->AsBrowser();
+    if (browser) {
+      break;
+    }
+
+    BrowsingContext* browsingContext =
+        currentElement->OwnerDoc()->GetBrowsingContext();
+    currentElement =
+        browsingContext ? browsingContext->GetEmbedderElement() : nullptr;
+  }
+
+  return browser.forget();
+}
+
+already_AddRefed<CanonicalBrowsingContext>
+BrowserParent::BrowsingContextForWebProgress(
+    const WebProgressData& aWebProgressData) {
+  // Look up the BrowsingContext which this notification was fired for.
+  if (aWebProgressData.browsingContext().IsNullOrDiscarded()) {
+    NS_WARNING("WebProgress Ignored: BrowsingContext is null or discarded");
+    return nullptr;
+  }
+  RefPtr<CanonicalBrowsingContext> browsingContext =
+      aWebProgressData.browsingContext().get_canonical();
+
+  // Double-check that we actually manage this BrowsingContext, and are not
+  // receiving a malformed or out-of-date request. browsingContext should either
+  // be the toplevel one managed by this BrowserParent, or embedded within a
+  // WindowGlobalParent managed by this BrowserParent.
+  if (browsingContext != mBrowsingContext) {
+    WindowGlobalParent* embedder = browsingContext->GetParentWindowContext();
+    if (!embedder || embedder->GetBrowserParent() != this) {
+      NS_WARNING("WebProgress Ignored: wrong embedder process");
+      return nullptr;
+    }
+  }
+
+  // The current process for this BrowsingContext may have changed since the
+  // notification was fired. Don't fire events for it anymore, as ownership of
+  // the BrowsingContext has been moved elsewhere.
+  if (RefPtr<WindowGlobalParent> current =
+          browsingContext->GetCurrentWindowGlobal();
+      current && current->GetBrowserParent() != this) {
+    NS_WARNING("WebProgress Ignored: no longer current window global");
+    return nullptr;
+  }
+
+  if (RefPtr<BrowsingContextWebProgress> progress =
+          browsingContext->GetWebProgress()) {
+    progress->SetLoadType(aWebProgressData.loadType());
+  }
+
+  return browsingContext.forget();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvIntrinsicSizeOrRatioChanged(
+    const Maybe<IntrinsicSize>& aIntrinsicSize,
+    const Maybe<AspectRatio>& aIntrinsicRatio) {
+  BrowserBridgeParent* bridge = GetBrowserBridgeParent();
+  if (!bridge || !bridge->CanSend()) {
+    return IPC_OK();
+  }
+
+  Unused << bridge->SendIntrinsicSizeOrRatioChanged(aIntrinsicSize,
+                                                    aIntrinsicRatio);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvImageLoadComplete(
+    const nsresult& aResult) {
+  BrowserBridgeParent* bridge = GetBrowserBridgeParent();
+  if (!bridge || !bridge->CanSend()) {
+    return IPC_OK();
+  }
+
+  Unused << bridge->SendImageLoadComplete(aResult);
+
+  return IPC_OK();
+}
+
+bool BrowserParent::HandleQueryContentEvent(WidgetQueryContentEvent& aEvent) {
+  nsCOMPtr<nsIWidget> textInputHandlingWidget = GetTextInputHandlingWidget();
+  if (!textInputHandlingWidget) {
+    return true;
+  }
+  if (!mContentCache.HandleQueryContentEvent(aEvent, textInputHandlingWidget) ||
+      NS_WARN_IF(aEvent.Failed())) {
+    return true;
+  }
+  switch (aEvent.mMessage) {
+    case eQueryTextRect:
+    case eQueryCaretRect:
+    case eQueryEditorRect: {
+      nsCOMPtr<nsIWidget> browserWidget = GetWidget();
+      if (browserWidget != textInputHandlingWidget) {
+        aEvent.mReply->mRect += nsLayoutUtils::WidgetToWidgetOffset(
+            browserWidget, textInputHandlingWidget);
+      }
+      aEvent.mReply->mRect = TransformChildToParent(aEvent.mReply->mRect);
+      break;
+    }
+    default:
+      break;
+  }
+  return true;
+}
+
+bool BrowserParent::SendCompositionEvent(WidgetCompositionEvent& aEvent) {
+  if (mIsDestroyed) {
+    return false;
+  }
+
+  if (!mContentCache.OnCompositionEvent(aEvent)) {
+    return true;
+  }
+
+  bool ret = Manager()->IsInputPriorityEventEnabled()
+                 ? PBrowserParent::SendCompositionEvent(aEvent)
+                 : PBrowserParent::SendNormalPriorityCompositionEvent(aEvent);
+  if (NS_WARN_IF(!ret)) {
+    return false;
+  }
+  MOZ_ASSERT(aEvent.HasBeenPostedToRemoteProcess());
+  return true;
+}
+
+bool BrowserParent::SendSelectionEvent(WidgetSelectionEvent& aEvent) {
+  if (mIsDestroyed) {
+    return false;
+  }
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (!widget) {
+    return true;
+  }
+  mContentCache.OnSelectionEvent(aEvent);
+  bool ret = Manager()->IsInputPriorityEventEnabled()
+                 ? PBrowserParent::SendSelectionEvent(aEvent)
+                 : PBrowserParent::SendNormalPrioritySelectionEvent(aEvent);
+  if (NS_WARN_IF(!ret)) {
+    return false;
+  }
+  MOZ_ASSERT(aEvent.HasBeenPostedToRemoteProcess());
+  aEvent.mSucceeded = true;
+  return true;
+}
+
+bool BrowserParent::SendInsertText(const nsString& aStringToInsert) {
+  if (mIsDestroyed) {
+    return false;
+  }
+  return Manager()->IsInputPriorityEventEnabled()
+             ? PBrowserParent::SendInsertText(aStringToInsert)
+             : PBrowserParent::SendNormalPriorityInsertText(aStringToInsert);
+}
+
+bool BrowserParent::SendPasteTransferable(
+    IPCTransferableData&& aTransferableData, const bool& aIsPrivateData,
+    nsIPrincipal* aRequestingPrincipal,
+    const nsContentPolicyType& aContentPolicyType) {
+  return PBrowserParent::SendPasteTransferable(
+      std::move(aTransferableData), aIsPrivateData, aRequestingPrincipal,
+      aContentPolicyType);
+}
+
+/* static */
+void BrowserParent::SetTopLevelWebFocus(BrowserParent* aBrowserParent) {
+  BrowserParent* old = GetFocused();
+  if (aBrowserParent && !aBrowserParent->GetBrowserBridgeParent()) {
+    // top-level Web content
+    sTopLevelWebFocus = aBrowserParent;
+    BrowserParent* bp = UpdateFocus();
+    if (old != bp) {
+      LOGBROWSERFOCUS(
+          ("SetTopLevelWebFocus updated focus; old: %p, new: %p", old, bp));
+      IMEStateManager::OnFocusMovedBetweenBrowsers(old, bp);
+    }
+  }
+}
+
+/* static */
+void BrowserParent::UnsetTopLevelWebFocus(BrowserParent* aBrowserParent) {
+  BrowserParent* old = GetFocused();
+  if (sTopLevelWebFocus == aBrowserParent) {
+    // top-level Web content
+    sTopLevelWebFocus = nullptr;
+    sFocus = nullptr;
+    if (old) {
+      LOGBROWSERFOCUS(
+          ("UnsetTopLevelWebFocus moved focus to chrome; old: %p", old));
+      IMEStateManager::OnFocusMovedBetweenBrowsers(old, nullptr);
+    }
+  }
+}
+
+/* static */
+void BrowserParent::UpdateFocusFromBrowsingContext() {
+  BrowserParent* old = GetFocused();
+  BrowserParent* bp = UpdateFocus();
+  if (old != bp) {
+    LOGBROWSERFOCUS(
+        ("UpdateFocusFromBrowsingContext updated focus; old: %p, new: %p", old,
+         bp));
+    IMEStateManager::OnFocusMovedBetweenBrowsers(old, bp);
+  }
+}
+
+/* static */
+BrowserParent* BrowserParent::UpdateFocus() {
+  if (!sTopLevelWebFocus) {
+    sFocus = nullptr;
+    return nullptr;
+  }
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (fm) {
+    BrowsingContext* bc = fm->GetFocusedBrowsingContextInChrome();
+    if (bc) {
+      BrowsingContext* top = bc->Top();
+      MOZ_ASSERT(top, "Should always have a top BrowsingContext.");
+      CanonicalBrowsingContext* canonicalTop = top->Canonical();
+      MOZ_ASSERT(canonicalTop,
+                 "Casting to canonical should always be possible in the parent "
+                 "process (top case).");
+      WindowGlobalParent* globalTop = canonicalTop->GetCurrentWindowGlobal();
+      if (globalTop) {
+        RefPtr<BrowserParent> globalTopParent = globalTop->GetBrowserParent();
+        if (sTopLevelWebFocus == globalTopParent) {
+          CanonicalBrowsingContext* canonical = bc->Canonical();
+          MOZ_ASSERT(
+              canonical,
+              "Casting to canonical should always be possible in the parent "
+              "process.");
+          WindowGlobalParent* global = canonical->GetCurrentWindowGlobal();
+          if (global) {
+            RefPtr<BrowserParent> parent = global->GetBrowserParent();
+            sFocus = parent;
+            return sFocus;
+          }
+          LOGBROWSERFOCUS(
+              ("Focused BrowsingContext did not have WindowGlobalParent."));
+        }
+      } else {
+        LOGBROWSERFOCUS(
+            ("Top-level BrowsingContext did not have WindowGlobalParent."));
+      }
+    }
+  }
+  sFocus = sTopLevelWebFocus;
+  return sFocus;
+}
+
+/* static */
+void BrowserParent::UnsetTopLevelWebFocusAll() {
+  if (sTopLevelWebFocus) {
+    UnsetTopLevelWebFocus(sTopLevelWebFocus);
+  }
+}
+
+/* static */
+void BrowserParent::UnsetLastMouseRemoteTarget(BrowserParent* aBrowserParent) {
+  if (sLastMouseRemoteTarget == aBrowserParent) {
+    sLastMouseRemoteTarget = nullptr;
+  }
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvRequestIMEToCommitComposition(
+    const bool& aCancel, bool* aIsCommitted, nsString* aCommittedString) {
+  nsCOMPtr<nsIWidget> widget = GetTextInputHandlingWidget();
+  if (!widget) {
+    *aIsCommitted = false;
+    return IPC_OK();
+  }
+
+  *aIsCommitted = mContentCache.RequestIMEToCommitComposition(
+      widget, aCancel, *aCommittedString);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvGetInputContext(
+    widget::IMEState* aState) {
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (!widget) {
+    *aState = widget::IMEState(IMEEnabled::Disabled,
+                               IMEState::OPEN_STATE_NOT_SUPPORTED);
+    return IPC_OK();
+  }
+
+  *aState = widget->GetInputContext().mIMEState;
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSetInputContext(
+    const InputContext& aContext, const InputContextAction& aAction) {
+  IMEStateManager::SetInputContextForChildProcess(this, aContext, aAction);
+  return IPC_OK();
+}
+
+bool BrowserParent::ReceiveMessage(const nsString& aMessage, bool aSync,
+                                   StructuredCloneData* aData,
+                                   nsTArray<StructuredCloneData>* aRetVal) {
+  // If we're for an oop iframe, don't deliver messages to the wrong place.
+  if (mBrowserBridgeParent) {
+    return true;
+  }
+
+  RefPtr<nsFrameLoader> frameLoader = GetFrameLoader(true);
+  if (frameLoader && frameLoader->GetFrameMessageManager()) {
+    RefPtr<nsFrameMessageManager> manager =
+        frameLoader->GetFrameMessageManager();
+
+    manager->ReceiveMessage(mFrameElement, frameLoader, aMessage, aSync, aData,
+                            aRetVal, IgnoreErrors());
+  }
+  return true;
+}
+
+// nsIAuthPromptProvider
+
+// This method is largely copied from nsDocShell::GetAuthPrompt
+NS_IMETHODIMP
+BrowserParent::GetAuthPrompt(uint32_t aPromptReason, const nsIID& iid,
+                             void** aResult) {
+  // we're either allowing auth, or it's a proxy request
+  nsresult rv;
+  nsCOMPtr<nsIPromptFactory> wwatch =
+      do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsPIDOMWindowOuter> window;
+  RefPtr<Element> frame = mFrameElement;
+  if (frame) window = frame->OwnerDoc()->GetWindow();
+
+  // Get an auth prompter for our window so that the parenting
+  // of the dialogs works as it should when using tabs.
+  nsCOMPtr<nsISupports> prompt;
+  rv = wwatch->GetPrompt(window, iid, getter_AddRefs(prompt));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsILoginManagerAuthPrompter> prompter = do_QueryInterface(prompt);
+  if (prompter) {
+    prompter->SetBrowser(mFrameElement);
+  }
+
+  *aResult = prompt.forget().take();
+  return NS_OK;
+}
+
+already_AddRefed<PColorPickerParent> BrowserParent::AllocPColorPickerParent(
+    const nsString& aTitle, const nsString& aInitialColor,
+    const nsTArray<nsString>& aDefaultColors) {
+  return MakeAndAddRef<ColorPickerParent>(aTitle, aInitialColor,
+                                          aDefaultColors);
+}
+
+already_AddRefed<nsFrameLoader> BrowserParent::GetFrameLoader(
+    bool aUseCachedFrameLoaderAfterDestroy) const {
+  if (mIsDestroyed && !aUseCachedFrameLoaderAfterDestroy) {
+    return nullptr;
+  }
+
+  if (mFrameLoader) {
+    RefPtr<nsFrameLoader> fl = mFrameLoader;
+    return fl.forget();
+  }
+  RefPtr<Element> frameElement(mFrameElement);
+  RefPtr<nsFrameLoaderOwner> frameLoaderOwner = do_QueryObject(frameElement);
+  return frameLoaderOwner ? frameLoaderOwner->GetFrameLoader() : nullptr;
+}
+
+void BrowserParent::TryCacheDPIAndScale() {
+  if (mDPI > 0) {
+    return;
+  }
+
+  const auto oldDefaultScale = mDefaultScale;
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  mDPI = widget ? widget->GetDPI() : nsIWidget::GetFallbackDPI();
+  mRounding = widget ? widget->RoundsWidgetCoordinatesTo() : 1;
+  mDefaultScale =
+      widget ? widget->GetDefaultScale() : nsIWidget::GetFallbackDefaultScale();
+
+  if (mDefaultScale != oldDefaultScale) {
+    // The change of the default scale factor will affect the child dimensions
+    // so we need to invalidate it.
+    mUpdatedDimensions = false;
+  }
+}
+
+void BrowserParent::ApzAwareEventRoutingToChild(
+    ScrollableLayerGuid* aOutTargetGuid, uint64_t* aOutInputBlockId,
+    nsEventStatus* aOutApzResponse) {
+  // Let the widget know that the event will be sent to the child process,
+  // which will (hopefully) send a confirmation notice back to APZ.
+  // Do this even if APZ is off since we need it for swipe gesture support on
+  // OS X without APZ.
+  InputAPZContext::SetRoutedToChildProcess();
+
+  if (AsyncPanZoomEnabled()) {
+    if (aOutTargetGuid) {
+      *aOutTargetGuid = InputAPZContext::GetTargetLayerGuid();
+
+      // There may be cases where the APZ hit-testing code came to a different
+      // conclusion than the main-thread hit-testing code as to where the event
+      // is destined. In such cases the layersId of the APZ result may not match
+      // the layersId of this RemoteLayerTreeOwner. In such cases the
+      // main-thread hit- testing code "wins" so we need to update the guid to
+      // reflect this.
+      if (mRemoteLayerTreeOwner.IsInitialized()) {
+        if (aOutTargetGuid->mLayersId != mRemoteLayerTreeOwner.GetLayersId()) {
+          *aOutTargetGuid =
+              ScrollableLayerGuid(mRemoteLayerTreeOwner.GetLayersId(), 0,
+                                  ScrollableLayerGuid::NULL_SCROLL_ID);
+        }
+      }
+    }
+    if (aOutInputBlockId) {
+      *aOutInputBlockId = InputAPZContext::GetInputBlockId();
+    }
+    if (aOutApzResponse) {
+      *aOutApzResponse = InputAPZContext::GetApzResponse();
+
+      // We can get here without there being an InputAPZContext on the stack
+      // if a non-native event synthesization function (such as
+      // nsIDOMWindowUtils.sendTouchEvent()) was used in the parent process to
+      // synthesize an event that's targeting a content process. Such events do
+      // not go through APZ. Without an InputAPZContext on the stack we pick up
+      // the default value "eSentinel" which cannot be sent over IPC, so replace
+      // it with "eIgnore" instead, which what APZ uses when it ignores an
+      // event. If a caller needs the ability to synthesize a event with a
+      // different APZ response, a native event synthesization function (such as
+      // sendNativeTouchPoint()) can be used.
+      if (*aOutApzResponse == nsEventStatus_eSentinel) {
+        *aOutApzResponse = nsEventStatus_eIgnore;
+      }
+    }
+  } else {
+    if (aOutInputBlockId) {
+      *aOutInputBlockId = 0;
+    }
+    if (aOutApzResponse) {
+      *aOutApzResponse = nsEventStatus_eIgnore;
+    }
+  }
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvRespondStartSwipeEvent(
+    const uint64_t& aInputBlockId, const bool& aStartSwipe) {
+  if (nsCOMPtr<nsIWidget> widget = GetWidget()) {
+    widget->ReportSwipeStarted(aInputBlockId, aStartSwipe);
+  }
+  return IPC_OK();
+}
+
+bool BrowserParent::GetDocShellIsActive() {
+  return mBrowsingContext && mBrowsingContext->IsActive();
+}
+
+bool BrowserParent::GetHasPresented() { return mHasPresented; }
+
+bool BrowserParent::GetHasLayers() { return mHasLayers; }
+
+bool BrowserParent::GetRenderLayers() { return mRenderLayers; }
+
+void BrowserParent::SetRenderLayers(bool aEnabled) {
+  if (aEnabled == mRenderLayers) {
+    if (aEnabled && mHasLayers && mIsPreservingLayers) {
+      // RenderLayers might be called when we've been preserving layers,
+      // and already had layers uploaded. In that case, the MozLayerTreeReady
+      // event will not naturally arrive, which can confuse the front-end
+      // layer. So we fire the event here.
+      RefPtr<BrowserParent> self = this;
+      LayersObserverEpoch epoch = mLayerTreeEpoch;
+      NS_DispatchToMainThread(NS_NewRunnableFunction(
+          "dom::BrowserParent::RenderLayers", [self, epoch]() {
+            MOZ_ASSERT(NS_IsMainThread());
+            self->LayerTreeUpdate(epoch, true);
+          }));
+    }
+
+    return;
+  }
+
+  // Preserve layers means that attempts to stop rendering layers
+  // will be ignored.
+  if (!aEnabled && mIsPreservingLayers) {
+    return;
+  }
+
+  mRenderLayers = aEnabled;
+
+  SetRenderLayersInternal(aEnabled);
+}
+
+void BrowserParent::SetRenderLayersInternal(bool aEnabled) {
+  // Increment the epoch so that layer tree updates from previous
+  // RenderLayers requests are ignored.
+  mLayerTreeEpoch = mLayerTreeEpoch.Next();
+
+  Unused << SendRenderLayers(aEnabled, mLayerTreeEpoch);
+
+  // Ask the child to repaint/unload layers using the PHangMonitor
+  // channel/thread (which may be less congested).
+  if (aEnabled) {
+    Manager()->PaintTabWhileInterruptingJS(this, mLayerTreeEpoch);
+  } else {
+    Manager()->UnloadLayersWhileInterruptingJS(this, mLayerTreeEpoch);
+  }
+}
+
+bool BrowserParent::GetPriorityHint() { return mPriorityHint; }
+
+void BrowserParent::SetPriorityHint(bool aPriorityHint) {
+  mPriorityHint = aPriorityHint;
+  RecomputeProcessPriority();
+}
+
+void BrowserParent::RecomputeProcessPriority() {
+  auto* bc = GetBrowsingContext();
+  ProcessPriorityManager::BrowserPriorityChanged(
+      bc, bc->IsActive() || mPriorityHint);
+}
+
+void BrowserParent::PreserveLayers(bool aPreserveLayers) {
+  if (mIsPreservingLayers == aPreserveLayers) {
+    return;
+  }
+  mIsPreservingLayers = aPreserveLayers;
+  Unused << SendPreserveLayers(aPreserveLayers);
+}
+
+void BrowserParent::NotifyResolutionChanged() {
+  if (mIsDestroyed) {
+    return;
+  }
+  // TryCacheDPIAndScale()'s cache is keyed off of
+  // mDPI being greater than 0, so this invalidates it.
+  mDPI = -1;
+  TryCacheDPIAndScale();
+  // If mDPI was set to -1 to invalidate it and then TryCacheDPIAndScale
+  // fails to cache the values, then mDefaultScale.scale might be invalid.
+  // We don't want to send that value to content. Just send -1 for it too in
+  // that case.
+  Unused << SendUIResolutionChanged(mDPI, mRounding,
+                                    mDPI < 0 ? -1.0 : mDefaultScale.scale);
+}
+
+bool BrowserParent::CanCancelContentJS(
+    nsIRemoteTab::NavigationType aNavigationType, int32_t aNavigationIndex,
+    nsIURI* aNavigationURI) const {
+  // Pre-checking if we can cancel content js in the parent is only
+  // supported when session history in the parent is enabled.
+  if (!mozilla::SessionHistoryInParent()) {
+    // If session history in the parent isn't enabled, this check will
+    // be fully done in BrowserChild::CanCancelContentJS
+    return true;
+  }
+
+  nsCOMPtr<nsISHistory> history = mBrowsingContext->GetSessionHistory();
+
+  if (!history) {
+    // If there is no history we can't possibly know if it's ok to
+    // cancel content js.
+    return false;
+  }
+
+  int32_t current;
+  NS_ENSURE_SUCCESS(history->GetIndex(&current), false);
+
+  if (current == -1) {
+    // This tab has no history! Just return.
+    return false;
+  }
+
+  nsCOMPtr<nsISHEntry> entry;
+  NS_ENSURE_SUCCESS(history->GetEntryAtIndex(current, getter_AddRefs(entry)),
+                    false);
+
+  nsCOMPtr<nsIURI> currentURI = entry->GetURI();
+  if (!currentURI->SchemeIs("http") && !currentURI->SchemeIs("https") &&
+      !currentURI->SchemeIs("file")) {
+    // Only cancel content JS for http(s) and file URIs. Other URIs are probably
+    // internal and we should just let them run to completion.
+    return false;
+  }
+
+  if (aNavigationType == nsIRemoteTab::NAVIGATE_BACK) {
+    aNavigationIndex = current - 1;
+  } else if (aNavigationType == nsIRemoteTab::NAVIGATE_FORWARD) {
+    aNavigationIndex = current + 1;
+  } else if (aNavigationType == nsIRemoteTab::NAVIGATE_URL) {
+    if (!aNavigationURI) {
+      return false;
+    }
+
+    if (aNavigationURI->SchemeIs("javascript")) {
+      // "javascript:" URIs don't (necessarily) trigger navigation to a
+      // different page, so don't allow the current page's JS to terminate.
+      return false;
+    }
+
+    // If navigating directly to a URL (e.g. via hitting Enter in the location
+    // bar), then we can cancel anytime the next URL is different from the
+    // current, *excluding* the ref ("#").
+    bool equals;
+    NS_ENSURE_SUCCESS(currentURI->EqualsExceptRef(aNavigationURI, &equals),
+                      false);
+    return !equals;
+  }
+  // Note: aNavigationType may also be NAVIGATE_INDEX, in which case we don't
+  // need to do anything special.
+
+  int32_t delta = aNavigationIndex > current ? 1 : -1;
+  for (int32_t i = current + delta; i != aNavigationIndex + delta; i += delta) {
+    nsCOMPtr<nsISHEntry> nextEntry;
+    // If `i` happens to be negative, this call will fail (which is what we
+    // would want to happen).
+    NS_ENSURE_SUCCESS(history->GetEntryAtIndex(i, getter_AddRefs(nextEntry)),
+                      false);
+
+    nsCOMPtr<nsISHEntry> laterEntry = delta == 1 ? nextEntry : entry;
+    nsCOMPtr<nsIURI> thisURI = entry->GetURI();
+    nsCOMPtr<nsIURI> nextURI = nextEntry->GetURI();
+
+    // If we changed origin and the load wasn't in a subframe, we know it was
+    // a full document load, so we can cancel the content JS safely.
+    if (!laterEntry->GetIsSubFrame()) {
+      nsAutoCString thisHost;
+      NS_ENSURE_SUCCESS(thisURI->GetPrePath(thisHost), false);
+
+      nsAutoCString nextHost;
+      NS_ENSURE_SUCCESS(nextURI->GetPrePath(nextHost), false);
+
+      if (!thisHost.Equals(nextHost)) {
+        return true;
+      }
+    }
+
+    entry = nextEntry;
+  }
+
+  return false;
+}
+
+void BrowserParent::SuppressDisplayport(bool aEnabled) {
+  if (IsDestroyed()) {
+    return;
+  }
+
+#ifdef DEBUG
+  if (aEnabled) {
+    mActiveSupressDisplayportCount++;
+  } else {
+    mActiveSupressDisplayportCount--;
+  }
+  MOZ_ASSERT(mActiveSupressDisplayportCount >= 0);
+#endif
+
+  Unused << SendSuppressDisplayport(aEnabled);
+}
+
+void BrowserParent::NavigateByKey(bool aForward, bool aForDocumentNavigation) {
+  Unused << SendNavigateByKey(aForward, aForDocumentNavigation);
+}
+
+void BrowserParent::LayerTreeUpdate(const LayersObserverEpoch& aEpoch,
+                                    bool aActive) {
+  // Ignore updates if we're an out-of-process iframe. For oop iframes, our
+  // |mFrameElement| is that of the top-level document, and so AsyncTabSwitcher
+  // will treat MozLayerTreeReady / MozLayerTreeCleared events as if they came
+  // from the top-level tab, which is wrong.
+  //
+  // XXX: Should we still be updating |mHasLayers|?
+  if (GetBrowserBridgeParent()) {
+    return;
+  }
+
+  // Ignore updates from old epochs. They might tell us that layers are
+  // available when we've already sent a message to clear them. We can't trust
+  // the update in that case since layers could disappear anytime after that.
+  if (aEpoch != mLayerTreeEpoch || mIsDestroyed) {
+    return;
+  }
+
+  RefPtr<Element> frameElement = mFrameElement;
+  if (!frameElement) {
+    NS_WARNING("Could not locate target for layer tree message.");
+    return;
+  }
+
+  mHasLayers = aActive;
+
+  RefPtr<Event> event = NS_NewDOMEvent(frameElement, nullptr, nullptr);
+  if (aActive) {
+    mHasPresented = true;
+    event->InitEvent(u"MozLayerTreeReady"_ns, true, false);
+  } else {
+    event->InitEvent(u"MozLayerTreeCleared"_ns, true, false);
+  }
+  event->SetTrusted(true);
+  event->WidgetEventPtr()->mFlags.mOnlyChromeDispatch = true;
+  frameElement->DispatchEvent(*event);
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvPaintWhileInterruptingJSNoOp(
+    const LayersObserverEpoch& aEpoch) {
+  // We sent a PaintWhileInterruptingJS message when layers were already
+  // visible. In this case, we should act as if an update occurred even though
+  // we already have the layers.
+  LayerTreeUpdate(aEpoch, true);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvRemoteIsReadyToHandleInputEvents() {
+  // When enabling input event prioritization, input events may preempt other
+  // normal priority IPC messages. To prevent the input events preempt
+  // PBrowserConstructor, we use an IPC 'RemoteIsReadyToHandleInputEvents' to
+  // notify the parent that BrowserChild is created and ready to handle input
+  // events.
+  SetReadyToHandleInputEvents();
+  return IPC_OK();
+}
+
+PPaymentRequestParent* BrowserParent::AllocPPaymentRequestParent() {
+  RefPtr<PaymentRequestParent> actor = new PaymentRequestParent();
+  return actor.forget().take();
+}
+
+bool BrowserParent::DeallocPPaymentRequestParent(
+    PPaymentRequestParent* aActor) {
+  RefPtr<PaymentRequestParent> actor =
+      dont_AddRef(static_cast<PaymentRequestParent*>(aActor));
+  return true;
+}
+
+nsresult BrowserParent::HandleEvent(Event* aEvent) {
+  if (mIsDestroyed) {
+    return NS_OK;
+  }
+
+  nsAutoString eventType;
+  aEvent->GetType(eventType);
+  if (eventType.EqualsLiteral("MozUpdateWindowPos") ||
+      eventType.EqualsLiteral("fullscreenchange")) {
+    // Events that signify the window moving are used to update the position
+    // and notify the BrowserChild.
+    return UpdatePosition();
+  }
+  return NS_OK;
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvInvokeDragSession(
+    nsTArray<IPCTransferableData>&& aTransferables, const uint32_t& aAction,
+    Maybe<BigBuffer>&& aVisualDnDData, const uint32_t& aStride,
+    const gfx::SurfaceFormat& aFormat, const LayoutDeviceIntRect& aDragRect,
+    nsIPrincipal* aPrincipal, nsIContentSecurityPolicy* aCsp,
+    const CookieJarSettingsArgs& aCookieJarSettingsArgs,
+    const MaybeDiscarded<WindowContext>& aSourceWindowContext,
+    const MaybeDiscarded<WindowContext>& aSourceTopWindowContext) {
+  PresShell* presShell = mFrameElement->OwnerDoc()->GetPresShell();
+  if (!presShell) {
+    Unused << Manager()->SendEndDragSession(
+        true, true, LayoutDeviceIntPoint(), 0,
+        nsIDragService::DRAGDROP_ACTION_NONE);
+    // Continue sending input events with input priority when stopping the dnd
+    // session.
+    Manager()->SetInputPriorityEventEnabled(true);
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsICookieJarSettings> cookieJarSettings;
+  net::CookieJarSettings::Deserialize(aCookieJarSettingsArgs,
+                                      getter_AddRefs(cookieJarSettings));
+
+  RefPtr<RemoteDragStartData> dragStartData = new RemoteDragStartData(
+      this, std::move(aTransferables), aDragRect, aPrincipal, aCsp,
+      cookieJarSettings, aSourceWindowContext.GetMaybeDiscarded(),
+      aSourceTopWindowContext.GetMaybeDiscarded());
+
+  if (aVisualDnDData) {
+    const auto checkedSize = CheckedInt<size_t>(aDragRect.height) * aStride;
+    if (checkedSize.isValid() &&
+        aVisualDnDData->Size() >= checkedSize.value()) {
+      dragStartData->SetVisualization(gfx::CreateDataSourceSurfaceFromData(
+          gfx::IntSize(aDragRect.width, aDragRect.height), aFormat,
+          aVisualDnDData->Data(), aStride));
+    }
+  }
+
+  nsCOMPtr<nsIDragService> dragService =
+      do_GetService("@mozilla.org/widget/dragservice;1");
+  if (dragService) {
+    dragService->MaybeAddChildProcess(Manager());
+  }
+
+  presShell->GetPresContext()
+      ->EventStateManager()
+      ->BeginTrackingRemoteDragGesture(mFrameElement, dragStartData);
+
+  return IPC_OK();
+}
+
+bool BrowserParent::AsyncPanZoomEnabled() const {
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  return widget && widget->AsyncPanZoomEnabled();
+}
+
+void BrowserParent::StartPersistence(
+    CanonicalBrowsingContext* aContext,
+    nsIWebBrowserPersistDocumentReceiver* aRecv, ErrorResult& aRv) {
+  auto* actor = new WebBrowserPersistDocumentParent();
+  actor->SetOnReady(aRecv);
+  bool ok = Manager()->SendPWebBrowserPersistDocumentConstructor(actor, this,
+                                                                 aContext);
+  if (!ok) {
+    aRv.Throw(NS_ERROR_FAILURE);
+  }
+  // (The actor will be destroyed on constructor failure.)
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvLookUpDictionary(
+    const nsString& aText, nsTArray<FontRange>&& aFontRangeArray,
+    const bool& aIsVertical, const LayoutDeviceIntPoint& aPoint) {
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (!widget) {
+    return IPC_OK();
+  }
+
+  widget->LookUpDictionary(aText, aFontRangeArray, aIsVertical,
+                           TransformChildToParent(aPoint));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvShowCanvasPermissionPrompt(
+    const nsCString& aOrigin, const bool& aHideDoorHanger) {
+  nsCOMPtr<nsIBrowser> browser =
+      mFrameElement ? mFrameElement->AsBrowser() : nullptr;
+  if (!browser) {
+    // If the tab is being closed, the browser may not be available.
+    // In this case we can ignore the request.
+    return IPC_OK();
+  }
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  if (!os) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  nsresult rv = os->NotifyObservers(
+      browser,
+      aHideDoorHanger ? "canvas-permissions-prompt-hide-doorhanger"
+                      : "canvas-permissions-prompt",
+      NS_ConvertUTF8toUTF16(aOrigin).get());
+  if (NS_FAILED(rv)) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvVisitURI(
+    nsIURI* aURI, nsIURI* aLastVisitedURI, const uint32_t& aFlags,
+    const uint64_t& aBrowserId) {
+  if (!aURI) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  RefPtr<nsIWidget> widget = GetWidget();
+  if (NS_WARN_IF(!widget)) {
+    return IPC_OK();
+  }
+  nsCOMPtr<IHistory> history = components::History::Service();
+  if (history) {
+    Unused << history->VisitURI(widget, aURI, aLastVisitedURI, aFlags,
+                                aBrowserId);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvQueryVisitedState(
+    nsTArray<RefPtr<nsIURI>>&& aURIs) {
+#ifdef MOZ_ANDROID_HISTORY
+  nsCOMPtr<IHistory> history = components::History::Service();
+  if (NS_WARN_IF(!history)) {
+    return IPC_OK();
+  }
+  RefPtr<nsIWidget> widget = GetWidget();
+  if (NS_WARN_IF(!widget)) {
+    return IPC_OK();
+  }
+
+  // FIXME(emilio): Is this check really needed?
+  for (nsIURI* uri : aURIs) {
+    if (!uri) {
+      return IPC_FAIL(this, "Received null URI");
+    }
+  }
+
+  auto* gvHistory = static_cast<GeckoViewHistory*>(history.get());
+  gvHistory->QueryVisitedState(widget, mManager, std::move(aURIs));
+  return IPC_OK();
+#else
+  return IPC_FAIL(this, "QueryVisitedState is Android-only");
+#endif
+}
+
+void BrowserParent::LiveResizeStarted() { SuppressDisplayport(true); }
+
+void BrowserParent::LiveResizeStopped() { SuppressDisplayport(false); }
+
+void BrowserParent::SetBrowserBridgeParent(BrowserBridgeParent* aBrowser) {
+  // We should either be clearing out our reference to a browser bridge, or not
+  // have either a browser bridge, browser host, or owner content yet.
+  MOZ_ASSERT(!aBrowser ||
+             (!mBrowserBridgeParent && !mBrowserHost && !mFrameElement));
+  mBrowserBridgeParent = aBrowser;
+}
+
+void BrowserParent::SetBrowserHost(BrowserHost* aBrowser) {
+  // We should either be clearing out our reference to a browser host, or not
+  // have either a browser bridge, browser host, or owner content yet.
+  MOZ_ASSERT(!aBrowser ||
+             (!mBrowserBridgeParent && !mBrowserHost && !mFrameElement));
+  mBrowserHost = aBrowser;
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvSetSystemFont(
+    const nsCString& aFontName) {
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (widget) {
+    widget->SetSystemFont(aFontName);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvGetSystemFont(nsCString* aFontName) {
+  nsCOMPtr<nsIWidget> widget = GetWidget();
+  if (widget) {
+    widget->GetSystemFont(*aFontName);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvMaybeFireEmbedderLoadEvents(
+    EmbedderElementEventType aFireEventAtEmbeddingElement) {
+  BrowserBridgeParent* bridge = GetBrowserBridgeParent();
+  if (!bridge) {
+    NS_WARNING("Received `load` event on unbridged BrowserParent!");
+    return IPC_OK();
+  }
+
+  Unused << bridge->SendMaybeFireEmbedderLoadEvents(
+      aFireEventAtEmbeddingElement);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvScrollRectIntoView(
+    const nsRect& aRect, const ScrollAxis& aVertical,
+    const ScrollAxis& aHorizontal, const ScrollFlags& aScrollFlags,
+    const int32_t& aAppUnitsPerDevPixel) {
+  BrowserBridgeParent* bridge = GetBrowserBridgeParent();
+  if (!bridge || !bridge->CanSend()) {
+    return IPC_OK();
+  }
+
+  Unused << bridge->SendScrollRectIntoView(aRect, aVertical, aHorizontal,
+                                           aScrollFlags, aAppUnitsPerDevPixel);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvIsWindowSupportingProtectedMedia(
+    const uint64_t& aOuterWindowID,
+    IsWindowSupportingProtectedMediaResolver&& aResolve) {
+#ifdef XP_WIN
+  bool isFxrWindow =
+      FxRWindowManager::GetInstance()->IsFxRWindow(aOuterWindowID);
+  aResolve(!isFxrWindow);
+#else
+#  ifdef FUZZING_SNAPSHOT
+  return IPC_FAIL(this, "Should only be called on Windows");
+#  endif
+  MOZ_CRASH("Should only be called on Windows");
+#endif
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvIsWindowSupportingWebVR(
+    const uint64_t& aOuterWindowID,
+    IsWindowSupportingWebVRResolver&& aResolve) {
+#ifdef XP_WIN
+  bool isFxrWindow =
+      FxRWindowManager::GetInstance()->IsFxRWindow(aOuterWindowID);
+  aResolve(!isFxrWindow);
+#else
+  aResolve(true);
+#endif
+
+  return IPC_OK();
+}
+
+static BrowserParent* GetTopLevelBrowserParent(BrowserParent* aBrowserParent) {
+  MOZ_ASSERT(aBrowserParent);
+  BrowserParent* parent = aBrowserParent;
+  while (BrowserBridgeParent* bridge = parent->GetBrowserBridgeParent()) {
+    parent = bridge->Manager();
+  }
+  return parent;
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvRequestPointerLock(
+    RequestPointerLockResolver&& aResolve) {
+  nsCString error;
+  if (sTopLevelWebFocus != GetTopLevelBrowserParent(this)) {
+    error = "PointerLockDeniedNotFocused";
+  } else if (!PointerLockManager::SetLockedRemoteTarget(this)) {
+    error = "PointerLockDeniedInUse";
+  } else {
+    PointerEventHandler::ReleaseAllPointerCaptureRemoteTarget();
+  }
+  aResolve(error);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvReleasePointerLock() {
+  MOZ_ASSERT_IF(PointerLockManager::GetLockedRemoteTarget(),
+                PointerLockManager::GetLockedRemoteTarget() == this);
+  PointerLockManager::ReleaseLockedRemoteTarget(this);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvRequestPointerCapture(
+    const uint32_t& aPointerId, RequestPointerCaptureResolver&& aResolve) {
+  aResolve(
+      PointerEventHandler::SetPointerCaptureRemoteTarget(aPointerId, this));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvReleasePointerCapture(
+    const uint32_t& aPointerId) {
+  PointerEventHandler::ReleasePointerCaptureRemoteTarget(aPointerId);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult BrowserParent::RecvShowDynamicToolbar() {
+#if defined(MOZ_WIDGET_ANDROID)
+  nsCOMPtr<nsIWidget> widget = GetTopLevelWidget();
+  if (!widget) {
+    return IPC_OK();
+  }
+
+  RefPtr<nsWindow> window = nsWindow::From(widget);
+  if (!window) {
+    return IPC_OK();
+  }
+
+  window->ShowDynamicToolbar();
+#endif  // defined(MOZ_WIDGET_ANDROID)
+  return IPC_OK();
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/ipc/BrowserParent.h b/dom/ipc/BrowserParent.h
new file mode 100644
index 0000000000..ce3f831abf
--- /dev/null
+++ b/dom/ipc/BrowserParent.h
@@ -0,0 +1,1015 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_BrowserParent_h
+#define mozilla_dom_BrowserParent_h
+
+#include <utility>
+
+#include "LiveResizeListener.h"
+#include "Units.h"
+#include "js/TypeDecls.h"
+#include "mozilla/AlreadyAddRefed.h"
+#include "mozilla/ContentCache.h"
+#include "mozilla/EventForwards.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/dom/BrowserBridgeParent.h"
+#include "mozilla/dom/PBrowserParent.h"
+#include "mozilla/dom/TabContext.h"
+#include "mozilla/dom/VsyncParent.h"
+#include "mozilla/dom/ipc/IdType.h"
+#include "mozilla/layout/RemoteLayerTreeOwner.h"
+#include "nsCOMPtr.h"
+#include "nsIAuthPromptProvider.h"
+#include "nsIBrowserDOMWindow.h"
+#include "nsIDOMEventListener.h"
+#include "nsIFilePicker.h"
+#include "nsIRemoteTab.h"
+#include "nsIWidget.h"
+#include "nsTArray.h"
+#include "nsWeakReference.h"
+
+class imgIContainer;
+class nsCycleCollectionTraversalCallback;
+class nsDocShellLoadState;
+class nsFrameLoader;
+class nsIBrowser;
+class nsIContent;
+class nsIContentSecurityPolicy;
+class nsIDocShell;
+class nsILoadContext;
+class nsIPrincipal;
+class nsIRequest;
+class nsIURI;
+class nsIWebBrowserPersistDocumentReceiver;
+class nsIWebProgress;
+class nsIXULBrowserWindow;
+class nsPIDOMWindowOuter;
+
+namespace mozilla {
+
+namespace a11y {
+class DocAccessibleParent;
+}
+
+namespace widget {
+struct IMENotification;
+}  // namespace widget
+
+namespace gfx {
+class SourceSurface;
+}  // namespace gfx
+
+namespace dom {
+
+class CanonicalBrowsingContext;
+class ClonedMessageData;
+class ContentParent;
+class Element;
+class DataTransfer;
+class BrowserHost;
+class BrowserBridgeParent;
+
+namespace ipc {
+class StructuredCloneData;
+}  // namespace ipc
+
+/**
+ * BrowserParent implements the parent actor part of the PBrowser protocol. See
+ * PBrowser for more information.
+ */
+class BrowserParent final : public PBrowserParent,
+                            public nsIDOMEventListener,
+                            public nsIAuthPromptProvider,
+                            public nsSupportsWeakReference,
+                            public TabContext,
+                            public LiveResizeListener {
+  typedef mozilla::dom::ClonedMessageData ClonedMessageData;
+  using TapType = GeckoContentController_TapType;
+
+  friend class PBrowserParent;
+
+  virtual ~BrowserParent();
+
+ public:
+  // Helper class for ContentParent::RecvCreateWindow.
+  struct AutoUseNewTab;
+
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_NSIAUTHPROMPTPROVIDER
+  // nsIDOMEventListener interfaces
+  NS_DECL_NSIDOMEVENTLISTENER
+
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(BrowserParent, nsIDOMEventListener)
+
+  BrowserParent(ContentParent* aManager, const TabId& aTabId,
+                const TabContext& aContext,
+                CanonicalBrowsingContext* aBrowsingContext,
+                uint32_t aChromeFlags);
+
+  /**
+   * Returns the focused BrowserParent or nullptr if chrome or another app
+   * is focused.
+   */
+  static BrowserParent* GetFocused();
+
+  static BrowserParent* GetLastMouseRemoteTarget();
+
+  static BrowserParent* GetFrom(nsFrameLoader* aFrameLoader);
+
+  static BrowserParent* GetFrom(PBrowserParent* aBrowserParent);
+
+  static BrowserParent* GetFrom(nsIContent* aContent);
+
+  static BrowserParent* GetBrowserParentFromLayersId(
+      layers::LayersId aLayersId);
+
+  static TabId GetTabIdFrom(nsIDocShell* docshell);
+
+  const TabId GetTabId() const { return mTabId; }
+
+  ContentParent* Manager() const { return mManager; }
+
+  CanonicalBrowsingContext* GetBrowsingContext() { return mBrowsingContext; }
+
+  void RecomputeProcessPriority();
+
+  already_AddRefed<nsILoadContext> GetLoadContext();
+
+  Element* GetOwnerElement() const { return mFrameElement; }
+
+  nsIBrowserDOMWindow* GetBrowserDOMWindow() const { return mBrowserDOMWindow; }
+
+  already_AddRefed<nsPIDOMWindowOuter> GetParentWindowOuter();
+
+  already_AddRefed<nsIWidget> GetTopLevelWidget();
+
+  // Returns the closest widget for our frameloader's content.
+  already_AddRefed<nsIWidget> GetWidget() const;
+
+  // Returns the top-level widget for our frameloader's document.
+  already_AddRefed<nsIWidget> GetDocWidget() const;
+
+  /**
+   * Returns the widget which may have native focus and handles text input
+   * like keyboard input, IME, etc.
+   */
+  already_AddRefed<nsIWidget> GetTextInputHandlingWidget() const;
+
+  nsIXULBrowserWindow* GetXULBrowserWindow();
+
+  static uint32_t GetMaxTouchPoints(Element* aElement);
+  uint32_t GetMaxTouchPoints() { return GetMaxTouchPoints(mFrameElement); }
+
+  /**
+   * Return the top level DocAccessibleParent for this BrowserParent.
+   * Note that in the case of an out-of-process iframe, the returned actor
+   * might not be at the top level of the DocAccessibleParent tree; i.e. it
+   * might have a parent. However, it will be at the top level in its content
+   * process. That is, doc->IsTopLevelInContentProcess() will always be true,
+   * but doc->IsTopLevel() might not.
+   */
+  a11y::DocAccessibleParent* GetTopLevelDocAccessible() const;
+
+  LayersId GetLayersId() const;
+
+  // Returns the BrowserBridgeParent if this BrowserParent is for an
+  // out-of-process iframe and nullptr otherwise.
+  BrowserBridgeParent* GetBrowserBridgeParent() const;
+
+  // Returns the BrowserHost if this BrowserParent is for a top-level browser
+  // and nullptr otherwise.
+  BrowserHost* GetBrowserHost() const;
+
+  ParentShowInfo GetShowInfo();
+
+  // Get the content principal from the owner element.
+  already_AddRefed<nsIPrincipal> GetContentPrincipal() const;
+
+  /**
+   * Let managees query if Destroy() is already called so they don't send out
+   * messages when the PBrowser actor is being destroyed.
+   */
+  bool IsDestroyed() const { return mIsDestroyed; }
+
+  /**
+   * Returns whether we're in the process of creating a new window (from
+   * window.open). If so, LoadURL calls are being skipped until everything is
+   * set up. For further details, see `mCreatingWindow` below.
+   */
+  bool CreatingWindow() const { return mCreatingWindow; }
+
+  /*
+   * Visit each BrowserParent in the tree formed by PBrowser and
+   * PBrowserBridge, including `this`.
+   */
+  template <typename Callback>
+  void VisitAll(Callback aCallback) {
+    aCallback(this);
+    VisitAllDescendants(aCallback);
+  }
+
+  /*
+   * Visit each BrowserParent in the tree formed by PBrowser and
+   * PBrowserBridge, excluding `this`.
+   */
+  template <typename Callback>
+  void VisitAllDescendants(Callback aCallback) {
+    const auto& browserBridges = ManagedPBrowserBridgeParent();
+    for (const auto& key : browserBridges) {
+      BrowserBridgeParent* browserBridge =
+          static_cast<BrowserBridgeParent*>(key);
+      BrowserParent* browserParent = browserBridge->GetBrowserParent();
+
+      aCallback(browserParent);
+      browserParent->VisitAllDescendants(aCallback);
+    }
+  }
+
+  /*
+   * Visit each BrowserBridgeParent that is a child of this BrowserParent.
+   */
+  template <typename Callback>
+  void VisitChildren(Callback aCallback) {
+    const auto& browserBridges = ManagedPBrowserBridgeParent();
+    for (const auto& key : browserBridges) {
+      BrowserBridgeParent* browserBridge =
+          static_cast<BrowserBridgeParent*>(key);
+      aCallback(browserBridge);
+    }
+  }
+
+  void SetOwnerElement(Element* aElement);
+
+  void SetBrowserDOMWindow(nsIBrowserDOMWindow* aBrowserDOMWindow) {
+    mBrowserDOMWindow = aBrowserDOMWindow;
+  }
+
+  void SwapFrameScriptsFrom(nsTArray<FrameScriptInfo>& aFrameScripts) {
+    aFrameScripts.SwapElements(mDelayedFrameScripts);
+  }
+
+  void CacheFrameLoader(nsFrameLoader* aFrameLoader);
+
+  void Destroy();
+
+  void RemoveWindowListeners();
+
+  void AddWindowListeners();
+
+  mozilla::ipc::IPCResult RecvDidUnsuppressPainting();
+  mozilla::ipc::IPCResult RecvDidUnsuppressPaintingNormalPriority() {
+    return RecvDidUnsuppressPainting();
+  }
+  mozilla::ipc::IPCResult RecvMoveFocus(const bool& aForward,
+                                        const bool& aForDocumentNavigation);
+
+  mozilla::ipc::IPCResult RecvDropLinks(nsTArray<nsString>&& aLinks);
+
+  // TODO: Use MOZ_CAN_RUN_SCRIPT when it gains IPDL support (bug 1539864)
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvReplyKeyEvent(
+      const WidgetKeyboardEvent& aEvent, const nsID& aUUID);
+
+  // TODO: Use MOZ_CAN_RUN_SCRIPT when it gains IPDL support (bug 1539864)
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvAccessKeyNotHandled(
+      const WidgetKeyboardEvent& aEvent);
+
+  mozilla::ipc::IPCResult RecvRegisterProtocolHandler(const nsString& aScheme,
+                                                      nsIURI* aHandlerURI,
+                                                      const nsString& aTitle,
+                                                      nsIURI* aDocURI);
+
+  mozilla::ipc::IPCResult RecvOnStateChange(
+      const WebProgressData& aWebProgressData, const RequestData& aRequestData,
+      const uint32_t aStateFlags, const nsresult aStatus,
+      const Maybe<WebProgressStateChangeData>& aStateChangeData);
+
+  mozilla::ipc::IPCResult RecvOnProgressChange(const int32_t aCurTotalProgres,
+                                               const int32_t aMaxTotalProgress);
+
+  mozilla::ipc::IPCResult RecvOnLocationChange(
+      const WebProgressData& aWebProgressData, const RequestData& aRequestData,
+      nsIURI* aLocation, const uint32_t aFlags, const bool aCanGoBack,
+      const bool aCanGoForward,
+      const Maybe<WebProgressLocationChangeData>& aLocationChangeData);
+
+  mozilla::ipc::IPCResult RecvOnStatusChange(const nsString& aMessage);
+
+  mozilla::ipc::IPCResult RecvNotifyContentBlockingEvent(
+      const uint32_t& aEvent, const RequestData& aRequestData,
+      const bool aBlocked, const nsACString& aTrackingOrigin,
+      nsTArray<nsCString>&& aTrackingFullHashes,
+      const Maybe<mozilla::ContentBlockingNotifier::
+                      StorageAccessPermissionGrantedReason>& aReason);
+
+  mozilla::ipc::IPCResult RecvNavigationFinished();
+
+  already_AddRefed<nsIBrowser> GetBrowser();
+
+  already_AddRefed<CanonicalBrowsingContext> BrowsingContextForWebProgress(
+      const WebProgressData& aWebProgressData);
+
+  mozilla::ipc::IPCResult RecvIntrinsicSizeOrRatioChanged(
+      const Maybe<IntrinsicSize>& aIntrinsicSize,
+      const Maybe<AspectRatio>& aIntrinsicRatio);
+
+  mozilla::ipc::IPCResult RecvImageLoadComplete(const nsresult& aResult);
+
+  mozilla::ipc::IPCResult RecvSyncMessage(
+      const nsString& aMessage, const ClonedMessageData& aData,
+      nsTArray<ipc::StructuredCloneData>* aRetVal);
+
+  mozilla::ipc::IPCResult RecvAsyncMessage(const nsString& aMessage,
+                                           const ClonedMessageData& aData);
+
+  mozilla::ipc::IPCResult RecvNotifyIMEFocus(
+      const ContentCache& aContentCache,
+      const widget::IMENotification& aEventMessage,
+      NotifyIMEFocusResolver&& aResolve);
+
+  mozilla::ipc::IPCResult RecvNotifyIMETextChange(
+      const ContentCache& aContentCache,
+      const widget::IMENotification& aEventMessage);
+
+  mozilla::ipc::IPCResult RecvNotifyIMECompositionUpdate(
+      const ContentCache& aContentCache,
+      const widget::IMENotification& aEventMessage);
+
+  mozilla::ipc::IPCResult RecvNotifyIMESelection(
+      const ContentCache& aContentCache,
+      const widget::IMENotification& aEventMessage);
+
+  mozilla::ipc::IPCResult RecvUpdateContentCache(
+      const ContentCache& aContentCache);
+
+  mozilla::ipc::IPCResult RecvNotifyIMEMouseButtonEvent(
+      const widget::IMENotification& aEventMessage, bool* aConsumedByIME);
+
+  mozilla::ipc::IPCResult RecvNotifyIMEPositionChange(
+      const ContentCache& aContentCache,
+      const widget::IMENotification& aEventMessage);
+
+  mozilla::ipc::IPCResult RecvOnEventNeedingAckHandled(
+      const EventMessage& aMessage);
+
+  mozilla::ipc::IPCResult RecvRequestIMEToCommitComposition(
+      const bool& aCancel, bool* aIsCommitted, nsString* aCommittedString);
+
+  mozilla::ipc::IPCResult RecvGetInputContext(widget::IMEState* aIMEState);
+
+  mozilla::ipc::IPCResult RecvSetInputContext(
+      const widget::InputContext& aContext,
+      const widget::InputContextAction& aAction);
+
+  mozilla::ipc::IPCResult RecvRequestFocus(const bool& aCanRaise,
+                                           const CallerType aCallerType);
+
+  mozilla::ipc::IPCResult RecvWheelZoomChange(bool aIncrease);
+
+  mozilla::ipc::IPCResult RecvLookUpDictionary(
+      const nsString& aText, nsTArray<mozilla::FontRange>&& aFontRangeArray,
+      const bool& aIsVertical, const LayoutDeviceIntPoint& aPoint);
+
+  mozilla::ipc::IPCResult RecvEnableDisableCommands(
+      const MaybeDiscarded<BrowsingContext>& aContext, const nsString& aAction,
+      nsTArray<nsCString>&& aEnabledCommands,
+      nsTArray<nsCString>&& aDisabledCommands);
+
+  mozilla::ipc::IPCResult RecvSetCursor(
+      const nsCursor& aValue, const bool& aHasCustomCursor,
+      Maybe<BigBuffer>&& aCursorData, const uint32_t& aWidth,
+      const uint32_t& aHeight, const float& aResolutionX,
+      const float& aResolutionY, const uint32_t& aStride,
+      const gfx::SurfaceFormat& aFormat, const uint32_t& aHotspotX,
+      const uint32_t& aHotspotY, const bool& aForce);
+
+  mozilla::ipc::IPCResult RecvSetLinkStatus(const nsString& aStatus);
+
+  mozilla::ipc::IPCResult RecvShowTooltip(const uint32_t& aX,
+                                          const uint32_t& aY,
+                                          const nsString& aTooltip,
+                                          const nsString& aDirection);
+
+  mozilla::ipc::IPCResult RecvHideTooltip();
+
+  mozilla::ipc::IPCResult RecvRespondStartSwipeEvent(
+      const uint64_t& aInputBlockId, const bool& aStartSwipe);
+
+  mozilla::ipc::IPCResult RecvDispatchWheelEvent(
+      const mozilla::WidgetWheelEvent& aEvent);
+
+  mozilla::ipc::IPCResult RecvDispatchMouseEvent(
+      const mozilla::WidgetMouseEvent& aEvent);
+
+  mozilla::ipc::IPCResult RecvDispatchKeyboardEvent(
+      const mozilla::WidgetKeyboardEvent& aEvent);
+
+  mozilla::ipc::IPCResult RecvDispatchTouchEvent(
+      const mozilla::WidgetTouchEvent& aEvent);
+
+  mozilla::ipc::IPCResult RecvScrollRectIntoView(
+      const nsRect& aRect, const ScrollAxis& aVertical,
+      const ScrollAxis& aHorizontal, const ScrollFlags& aScrollFlags,
+      const int32_t& aAppUnitsPerDevPixel);
+
+  already_AddRefed<PColorPickerParent> AllocPColorPickerParent(
+      const nsString& aTitle, const nsString& aInitialColor,
+      const nsTArray<nsString>& aDefaultColors);
+
+  PVsyncParent* AllocPVsyncParent();
+
+  bool DeallocPVsyncParent(PVsyncParent* aActor);
+
+#ifdef ACCESSIBILITY
+  PDocAccessibleParent* AllocPDocAccessibleParent(
+      PDocAccessibleParent*, const uint64_t&,
+      const MaybeDiscardedBrowsingContext&);
+  bool DeallocPDocAccessibleParent(PDocAccessibleParent*);
+  virtual mozilla::ipc::IPCResult RecvPDocAccessibleConstructor(
+      PDocAccessibleParent* aDoc, PDocAccessibleParent* aParentDoc,
+      const uint64_t& aParentID,
+      const MaybeDiscardedBrowsingContext& aBrowsingContext) override;
+#endif
+
+  already_AddRefed<PSessionStoreParent> AllocPSessionStoreParent();
+
+  mozilla::ipc::IPCResult RecvNewWindowGlobal(
+      ManagedEndpoint<PWindowGlobalParent>&& aEndpoint,
+      const WindowGlobalInit& aInit);
+
+  mozilla::ipc::IPCResult RecvIsWindowSupportingProtectedMedia(
+      const uint64_t& aOuterWindowID,
+      IsWindowSupportingProtectedMediaResolver&& aResolve);
+
+  mozilla::ipc::IPCResult RecvIsWindowSupportingWebVR(
+      const uint64_t& aOuterWindowID,
+      IsWindowSupportingWebVRResolver&& aResolve);
+
+  void LoadURL(nsDocShellLoadState* aLoadState);
+
+  void ResumeLoad(uint64_t aPendingSwitchID);
+
+  void InitRendering();
+  bool AttachWindowRenderer();
+  void MaybeShowFrame();
+
+  bool Show(const OwnerShowInfo&);
+
+  void UpdateDimensions(const nsIntRect& aRect, const ScreenIntSize& aSize);
+
+  DimensionInfo GetDimensionInfo();
+
+  nsresult UpdatePosition();
+
+  // Notify position update to all descendant documents in this browser parent.
+  // NOTE: This should use only for browsers in popup windows attached to the
+  // main browser window.
+  void NotifyPositionUpdatedForContentsInPopup();
+
+  void SizeModeChanged(const nsSizeMode& aSizeMode);
+
+  void HandleAccessKey(const WidgetKeyboardEvent& aEvent,
+                       nsTArray<uint32_t>& aCharCodes);
+
+#if defined(MOZ_WIDGET_ANDROID)
+  void DynamicToolbarMaxHeightChanged(ScreenIntCoord aHeight);
+  void DynamicToolbarOffsetChanged(ScreenIntCoord aOffset);
+#endif
+
+  void Activate(uint64_t aActionId);
+
+  void Deactivate(bool aWindowLowering, uint64_t aActionId);
+
+  void MouseEnterIntoWidget();
+
+  bool MapEventCoordinatesForChildProcess(mozilla::WidgetEvent* aEvent);
+
+  void MapEventCoordinatesForChildProcess(const LayoutDeviceIntPoint& aOffset,
+                                          mozilla::WidgetEvent* aEvent);
+
+  LayoutDeviceToCSSScale GetLayoutDeviceToCSSScale();
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult
+  RecvRequestNativeKeyBindings(const uint32_t& aType,
+                               const mozilla::WidgetKeyboardEvent& aEvent,
+                               nsTArray<mozilla::CommandInt>* aCommands);
+
+  mozilla::ipc::IPCResult RecvSynthesizeNativeKeyEvent(
+      const int32_t& aNativeKeyboardLayout, const int32_t& aNativeKeyCode,
+      const uint32_t& aModifierFlags, const nsString& aCharacters,
+      const nsString& aUnmodifiedCharacters, const uint64_t& aObserverId);
+
+  mozilla::ipc::IPCResult RecvSynthesizeNativeMouseEvent(
+      const LayoutDeviceIntPoint& aPoint, const uint32_t& aNativeMessage,
+      const int16_t& aButton, const uint32_t& aModifierFlags,
+      const uint64_t& aObserverId);
+
+  mozilla::ipc::IPCResult RecvSynthesizeNativeMouseMove(
+      const LayoutDeviceIntPoint& aPoint, const uint64_t& aObserverId);
+
+  mozilla::ipc::IPCResult RecvSynthesizeNativeMouseScrollEvent(
+      const LayoutDeviceIntPoint& aPoint, const uint32_t& aNativeMessage,
+      const double& aDeltaX, const double& aDeltaY, const double& aDeltaZ,
+      const uint32_t& aModifierFlags, const uint32_t& aAdditionalFlags,
+      const uint64_t& aObserverId);
+
+  mozilla::ipc::IPCResult RecvSynthesizeNativeTouchPoint(
+      const uint32_t& aPointerId, const TouchPointerState& aPointerState,
+      const LayoutDeviceIntPoint& aPoint, const double& aPointerPressure,
+      const uint32_t& aPointerOrientation, const uint64_t& aObserverId);
+
+  mozilla::ipc::IPCResult RecvSynthesizeNativeTouchPadPinch(
+      const TouchpadGesturePhase& aEventPhase, const float& aScale,
+      const LayoutDeviceIntPoint& aPoint, const int32_t& aModifierFlags);
+
+  mozilla::ipc::IPCResult RecvSynthesizeNativeTouchTap(
+      const LayoutDeviceIntPoint& aPoint, const bool& aLongTap,
+      const uint64_t& aObserverId);
+
+  mozilla::ipc::IPCResult RecvClearNativeTouchSequence(
+      const uint64_t& aObserverId);
+
+  mozilla::ipc::IPCResult RecvSynthesizeNativePenInput(
+      const uint32_t& aPointerId, const TouchPointerState& aPointerState,
+      const LayoutDeviceIntPoint& aPoint, const double& aPressure,
+      const uint32_t& aRotation, const int32_t& aTiltX, const int32_t& aTiltY,
+      const int32_t& aButton, const uint64_t& aObserverId);
+
+  mozilla::ipc::IPCResult RecvSynthesizeNativeTouchpadDoubleTap(
+      const LayoutDeviceIntPoint& aPoint, const uint32_t& aModifierFlags);
+
+  mozilla::ipc::IPCResult RecvSynthesizeNativeTouchpadPan(
+      const TouchpadGesturePhase& aEventPhase,
+      const LayoutDeviceIntPoint& aPoint, const double& aDeltaX,
+      const double& aDeltaY, const int32_t& aModifierFlags,
+      const uint64_t& aObserverId);
+
+  mozilla::ipc::IPCResult RecvLockNativePointer();
+
+  mozilla::ipc::IPCResult RecvUnlockNativePointer();
+
+  /**
+   * The following Send*Event() marks aEvent as posted to remote process if
+   * it succeeded.  So, you can check the result with
+   * aEvent.HasBeenPostedToRemoteProcess().
+   */
+  void SendRealMouseEvent(WidgetMouseEvent& aEvent);
+
+  void SendRealDragEvent(WidgetDragEvent& aEvent, uint32_t aDragAction,
+                         uint32_t aDropEffect, nsIPrincipal* aPrincipal,
+                         nsIContentSecurityPolicy* aCsp);
+
+  void SendMouseWheelEvent(WidgetWheelEvent& aEvent);
+
+  /**
+   * Only when the event is synthesized, retrieving writing mode may flush
+   * the layout.
+   */
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY void SendRealKeyEvent(
+      WidgetKeyboardEvent& aEvent);
+
+  void SendRealTouchEvent(WidgetTouchEvent& aEvent);
+
+  /**
+   * Different from above Send*Event(), these methods return true if the
+   * event has been posted to the remote process or failed to do that but
+   * shouldn't be handled by following event listeners.
+   * If you need to check if it's actually posted to the remote process,
+   * you can refer aEvent.HasBeenPostedToRemoteProcess().
+   */
+  bool SendCompositionEvent(mozilla::WidgetCompositionEvent& aEvent);
+
+  bool SendSelectionEvent(mozilla::WidgetSelectionEvent& aEvent);
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY bool SendHandleTap(
+      TapType aType, const LayoutDevicePoint& aPoint, Modifiers aModifiers,
+      const ScrollableLayerGuid& aGuid, uint64_t aInputBlockId);
+
+  already_AddRefed<PFilePickerParent> AllocPFilePickerParent(
+      const nsString& aTitle, const nsIFilePicker::Mode& aMode);
+
+  bool GetGlobalJSObject(JSContext* cx, JSObject** globalp);
+
+  void StartPersistence(CanonicalBrowsingContext* aContext,
+                        nsIWebBrowserPersistDocumentReceiver* aRecv,
+                        ErrorResult& aRv);
+
+  bool HandleQueryContentEvent(mozilla::WidgetQueryContentEvent& aEvent);
+
+  bool SendInsertText(const nsString& aStringToInsert);
+
+  bool SendPasteTransferable(IPCTransferableData&& aTransferableData,
+                             const bool& aIsPrivateData,
+                             nsIPrincipal* aRequestingPrincipal,
+                             const nsContentPolicyType& aContentPolicyType);
+
+  // Helper for transforming a point
+  LayoutDeviceIntPoint TransformPoint(
+      const LayoutDeviceIntPoint& aPoint,
+      const LayoutDeviceToLayoutDeviceMatrix4x4& aMatrix);
+  LayoutDevicePoint TransformPoint(
+      const LayoutDevicePoint& aPoint,
+      const LayoutDeviceToLayoutDeviceMatrix4x4& aMatrix);
+
+  // Transform a coordinate from the parent process coordinate space to the
+  // child process coordinate space.
+  LayoutDeviceIntPoint TransformParentToChild(
+      const LayoutDeviceIntPoint& aPoint);
+  LayoutDevicePoint TransformParentToChild(const LayoutDevicePoint& aPoint);
+
+  // Transform a coordinate from the child process coordinate space to the
+  // parent process coordinate space.
+  LayoutDeviceIntPoint TransformChildToParent(
+      const LayoutDeviceIntPoint& aPoint);
+  LayoutDevicePoint TransformChildToParent(const LayoutDevicePoint& aPoint);
+  LayoutDeviceIntRect TransformChildToParent(const LayoutDeviceIntRect& aRect);
+
+  // Returns the matrix that transforms event coordinates from the coordinate
+  // space of the child process to the coordinate space of the parent process.
+  LayoutDeviceToLayoutDeviceMatrix4x4 GetChildToParentConversionMatrix();
+
+  void SetChildToParentConversionMatrix(
+      const Maybe<LayoutDeviceToLayoutDeviceMatrix4x4>& aMatrix,
+      const ScreenRect& aRemoteDocumentRect);
+
+  // Returns the offset from the origin of our frameloader's nearest widget to
+  // the origin of its layout frame. This offset is used to translate event
+  // coordinates relative to the PuppetWidget origin in the child process.
+  //
+  // GOING AWAY. PLEASE AVOID ADDING CALLERS. Use the above tranformation
+  // methods instead.
+  LayoutDeviceIntPoint GetChildProcessOffset();
+
+  // Returns the offset from the on-screen origin of our top-level window's
+  // widget (including window decorations) to the origin of our frameloader's
+  // nearest widget. This offset is used to translate coordinates from the
+  // PuppetWidget's origin to absolute screen coordinates in the child.
+  LayoutDeviceIntPoint GetClientOffset();
+
+  void StopIMEStateManagement();
+
+  PPaymentRequestParent* AllocPPaymentRequestParent();
+
+  bool DeallocPPaymentRequestParent(PPaymentRequestParent* aActor);
+
+  bool SendLoadRemoteScript(const nsAString& aURL,
+                            const bool& aRunInGlobalScope);
+
+  void LayerTreeUpdate(const LayersObserverEpoch& aEpoch, bool aActive);
+
+  mozilla::ipc::IPCResult RecvInvokeDragSession(
+      nsTArray<IPCTransferableData>&& aTransferables, const uint32_t& aAction,
+      Maybe<BigBuffer>&& aVisualDnDData, const uint32_t& aStride,
+      const gfx::SurfaceFormat& aFormat, const LayoutDeviceIntRect& aDragRect,
+      nsIPrincipal* aPrincipal, nsIContentSecurityPolicy* aCsp,
+      const CookieJarSettingsArgs& aCookieJarSettingsArgs,
+      const MaybeDiscarded<WindowContext>& aSourceWindowContext,
+      const MaybeDiscarded<WindowContext>& aSourceTopWindowContext);
+
+  void AddInitialDnDDataTo(IPCTransferableData* aTransferableData,
+                           nsIPrincipal** aPrincipal);
+
+  bool TakeDragVisualization(RefPtr<mozilla::gfx::SourceSurface>& aSurface,
+                             LayoutDeviceIntRect* aDragRect);
+
+  mozilla::ipc::IPCResult RecvEnsureLayersConnected(
+      CompositorOptions* aCompositorOptions);
+
+  // LiveResizeListener implementation
+  void LiveResizeStarted() override;
+  void LiveResizeStopped() override;
+
+  void SetReadyToHandleInputEvents() { mIsReadyToHandleInputEvents = true; }
+  bool IsReadyToHandleInputEvents() { return mIsReadyToHandleInputEvents; }
+
+  void NavigateByKey(bool aForward, bool aForDocumentNavigation);
+
+  bool GetDocShellIsActive();
+  void SetDocShellIsActive(bool aDocShellIsActive);
+
+  bool GetHasPresented();
+  bool GetHasLayers();
+  bool GetRenderLayers();
+  void SetRenderLayers(bool aRenderLayers);
+  bool GetPriorityHint();
+  void SetPriorityHint(bool aPriorityHint);
+  void PreserveLayers(bool aPreserveLayers);
+  void NotifyResolutionChanged();
+
+  bool CanCancelContentJS(nsIRemoteTab::NavigationType aNavigationType,
+                          int32_t aNavigationIndex,
+                          nsIURI* aNavigationURI) const;
+
+  // Called when the BrowserParent is being destroyed or entering bfcache.
+  void Deactivated();
+
+ protected:
+  friend BrowserBridgeParent;
+  friend BrowserHost;
+
+  void SetBrowserBridgeParent(BrowserBridgeParent* aBrowser);
+  void SetBrowserHost(BrowserHost* aBrowser);
+
+  bool ReceiveMessage(
+      const nsString& aMessage, bool aSync, ipc::StructuredCloneData* aData,
+      nsTArray<ipc::StructuredCloneData>* aJSONRetVal = nullptr);
+
+  virtual void ActorDestroy(ActorDestroyReason why) override;
+
+  mozilla::ipc::IPCResult RecvRemoteIsReadyToHandleInputEvents();
+
+  mozilla::ipc::IPCResult RecvPaintWhileInterruptingJSNoOp(
+      const LayersObserverEpoch& aEpoch);
+
+  mozilla::ipc::IPCResult RecvSetDimensions(mozilla::DimensionRequest aRequest,
+                                            const double& aScale);
+
+  mozilla::ipc::IPCResult RecvShowCanvasPermissionPrompt(
+      const nsCString& aOrigin, const bool& aHideDoorHanger);
+
+  mozilla::ipc::IPCResult RecvSetSystemFont(const nsCString& aFontName);
+  mozilla::ipc::IPCResult RecvGetSystemFont(nsCString* aFontName);
+
+  mozilla::ipc::IPCResult RecvVisitURI(nsIURI* aURI, nsIURI* aLastVisitedURI,
+                                       const uint32_t& aFlags,
+                                       const uint64_t& aBrowserId);
+
+  mozilla::ipc::IPCResult RecvQueryVisitedState(
+      nsTArray<RefPtr<nsIURI>>&& aURIs);
+
+  mozilla::ipc::IPCResult RecvMaybeFireEmbedderLoadEvents(
+      EmbedderElementEventType aFireEventAtEmbeddingElement);
+
+  mozilla::ipc::IPCResult RecvRequestPointerLock(
+      RequestPointerLockResolver&& aResolve);
+  mozilla::ipc::IPCResult RecvReleasePointerLock();
+
+  mozilla::ipc::IPCResult RecvRequestPointerCapture(
+      const uint32_t& aPointerId, RequestPointerCaptureResolver&& aResolve);
+  mozilla::ipc::IPCResult RecvReleasePointerCapture(const uint32_t& aPointerId);
+
+  mozilla::ipc::IPCResult RecvShowDynamicToolbar();
+
+ private:
+  void SuppressDisplayport(bool aEnabled);
+
+  void DestroyInternal();
+
+  void SetRenderLayersInternal(bool aEnabled);
+
+  already_AddRefed<nsFrameLoader> GetFrameLoader(
+      bool aUseCachedFrameLoaderAfterDestroy = false) const;
+
+  void TryCacheDPIAndScale();
+
+  bool AsyncPanZoomEnabled() const;
+
+  // Update state prior to routing an APZ-aware event to the child process.
+  // |aOutTargetGuid| will contain the identifier
+  // of the APZC instance that handled the event. aOutTargetGuid may be null.
+  // |aOutInputBlockId| will contain the identifier of the input block
+  // that this event was added to, if there was one. aOutInputBlockId may be
+  // null. |aOutApzResponse| will contain the response that the APZ gave when
+  // processing the input block; this is used for generating appropriate
+  // pointercancel events.
+  void ApzAwareEventRoutingToChild(ScrollableLayerGuid* aOutTargetGuid,
+                                   uint64_t* aOutInputBlockId,
+                                   nsEventStatus* aOutApzResponse);
+
+  // When dropping links we perform a roundtrip from
+  // Parent (SendRealDragEvent) -> Child -> Parent (RecvDropLinks)
+  // and have to ensure that the child did not modify links to be loaded.
+  bool QueryDropLinksForVerification();
+
+  void UnlockNativePointer();
+
+  void UpdateNativePointerLockCenter(nsIWidget* aWidget);
+
+ private:
+  // This is used when APZ needs to find the BrowserParent associated with a
+  // layer to dispatch events.
+  typedef nsTHashMap<nsUint64HashKey, BrowserParent*> LayerToBrowserParentTable;
+  static LayerToBrowserParentTable* sLayerToBrowserParentTable;
+
+  static void AddBrowserParentToTable(layers::LayersId aLayersId,
+                                      BrowserParent* aBrowserParent);
+
+  static void RemoveBrowserParentFromTable(layers::LayersId aLayersId);
+
+  // Keeps track of which BrowserParent has keyboard focus.
+  // If nullptr, the parent process has focus.
+  // Use UpdateFocus() to manage.
+  static BrowserParent* sFocus;
+
+  // Keeps track of which top-level BrowserParent the keyboard focus is under.
+  // If nullptr, the parent process has focus.
+  // Use SetTopLevelWebFocus and UnsetTopLevelWebFocus to manage.
+  static BrowserParent* sTopLevelWebFocus;
+
+  // Setter for sTopLevelWebFocus
+  static void SetTopLevelWebFocus(BrowserParent* aBrowserParent);
+
+  // Unsetter for sTopLevelWebFocus; only unsets if argument matches
+  // current sTopLevelWebFocus. Use UnsetTopLevelWebFocusAll() to
+  // unset regardless of current value.
+  static void UnsetTopLevelWebFocus(BrowserParent* aBrowserParent);
+
+  // Recomputes sFocus and returns it.
+  static BrowserParent* UpdateFocus();
+
+  // Keeps track of which BrowserParent the real mouse event is sent to.
+  static BrowserParent* sLastMouseRemoteTarget;
+
+  // Unsetter for LastMouseRemoteTarget; only unsets if argument matches
+  // current sLastMouseRemoteTarget.
+  static void UnsetLastMouseRemoteTarget(BrowserParent* aBrowserParent);
+
+  struct APZData {
+    bool operator==(const APZData& aOther) const {
+      return aOther.guid == guid && aOther.blockId == blockId &&
+             aOther.apzResponse == apzResponse;
+    }
+
+    bool operator!=(const APZData& aOther) const { return !(*this == aOther); }
+
+    ScrollableLayerGuid guid;
+    uint64_t blockId;
+    nsEventStatus apzResponse;
+  };
+  void SendRealTouchMoveEvent(WidgetTouchEvent& aEvent, APZData& aAPZData,
+                              uint32_t aConsecutiveTouchMoveCount);
+
+  void UpdateVsyncParentVsyncDispatcher();
+
+ public:
+  // Unsets sTopLevelWebFocus regardless of its current value.
+  static void UnsetTopLevelWebFocusAll();
+
+  // Recomputes focus when the BrowsingContext tree changes in a
+  // way that potentially invalidates the sFocus.
+  static void UpdateFocusFromBrowsingContext();
+
+ private:
+  TabId mTabId;
+
+  RefPtr<ContentParent> mManager;
+  // The root browsing context loaded in this BrowserParent.
+  RefPtr<CanonicalBrowsingContext> mBrowsingContext;
+  nsCOMPtr<nsILoadContext> mLoadContext;
+  RefPtr<Element> mFrameElement;
+  nsCOMPtr<nsIBrowserDOMWindow> mBrowserDOMWindow;
+  // We keep a strong reference to the frameloader after we've sent the
+  // Destroy message and before we've received __delete__. This allows us to
+  // dispatch message manager messages during this time.
+  RefPtr<nsFrameLoader> mFrameLoader;
+  uint32_t mChromeFlags;
+
+  // Pointer back to BrowserBridgeParent if there is one associated with
+  // this BrowserParent. This is non-owning to avoid cycles and is managed
+  // by the BrowserBridgeParent instance, which has the strong reference
+  // to this BrowserParent.
+  BrowserBridgeParent* mBrowserBridgeParent;
+  // Pointer to the BrowserHost that owns us, if any. This is mutually
+  // exclusive with mBrowserBridgeParent, and one is guaranteed to be
+  // non-null.
+  BrowserHost* mBrowserHost;
+
+  ContentCacheInParent mContentCache;
+
+  layout::RemoteLayerTreeOwner mRemoteLayerTreeOwner;
+  LayersObserverEpoch mLayerTreeEpoch;
+
+  Maybe<LayoutDeviceToLayoutDeviceMatrix4x4> mChildToParentConversionMatrix;
+  Maybe<ScreenRect> mRemoteDocumentRect;
+
+  // mWaitingReplyKeyboardEvents stores keyboard events which are sent from
+  // SendRealKeyEvent and the event will be back as a reply event.  They are
+  // removed when RecvReplyKeyEvent receives corresponding event or newer event.
+  // Note that reply event will be used for handling non-reserved shortcut keys.
+  // Therefore, we need to store only important data for GlobalKeyHandler.
+  struct SentKeyEventData {
+    uint32_t mKeyCode;
+    uint32_t mCharCode;
+    uint32_t mPseudoCharCode;
+    KeyNameIndex mKeyNameIndex;
+    CodeNameIndex mCodeNameIndex;
+    Modifiers mModifiers;
+    nsID mUUID;
+  };
+  nsTArray<SentKeyEventData> mWaitingReplyKeyboardEvents;
+
+  nsIntRect mRect;
+  ScreenIntSize mDimensions;
+  float mDPI;
+  int32_t mRounding;
+  CSSToLayoutDeviceScale mDefaultScale;
+  bool mUpdatedDimensions;
+  nsSizeMode mSizeMode;
+  LayoutDeviceIntPoint mClientOffset;
+  LayoutDeviceIntPoint mChromeOffset;
+
+  // When loading a new tab or window via window.open, the child is
+  // responsible for loading the URL it wants into the new BrowserChild. When
+  // the parent receives the CreateWindow message, though, it sends a LoadURL
+  // message, usually for about:blank. It's important for the about:blank load
+  // to get processed because the Firefox frontend expects every new window to
+  // immediately start loading something (see bug 1123090). However, we want
+  // the child to process the LoadURL message before it returns from
+  // ProvideWindow so that the URL sent from the parent doesn't override the
+  // child's URL. This is not possible using our IPC mechanisms. To solve the
+  // problem, we skip sending the LoadURL message in the parent and instead
+  // return the URL as a result from CreateWindow. The child simulates
+  // receiving a LoadURL message before returning from ProvideWindow.
+  //
+  // The mCreatingWindow flag is set while dispatching CreateWindow. During
+  // that time, any LoadURL calls are skipped.
+  bool mCreatingWindow;
+
+  // When loading a new tab or window via window.open, we want to ensure that
+  // frame scripts for that tab are loaded before any scripts start to run in
+  // the window. We can't load the frame scripts the normal way, using
+  // separate IPC messages, since they won't be processed by the child until
+  // returning to the event loop, which is too late. Instead, we queue up
+  // frame scripts that we intend to load and send them as part of the
+  // CreateWindow response. Then BrowserChild loads them immediately.
+  nsTArray<FrameScriptInfo> mDelayedFrameScripts;
+
+  // Cached cursor setting from BrowserChild.  When the cursor is over the
+  // tab, it should take this appearance.
+  nsIWidget::Cursor mCursor;
+
+  nsTArray<nsString> mVerifyDropLinks;
+
+  RefPtr<VsyncParent> mVsyncParent;
+
+#ifdef DEBUG
+  int32_t mActiveSupressDisplayportCount = 0;
+#endif
+
+  // When true, we've initiated normal shutdown and notified our managing
+  // PContent.
+  bool mMarkedDestroying : 1;
+  // When true, the BrowserParent is invalid and we should not send IPC
+  // messages anymore.
+  bool mIsDestroyed : 1;
+  // True if the cursor changes from the BrowserChild should change the widget
+  // cursor.  This happens whenever the cursor is in the remote target's
+  // region.
+  bool mRemoteTargetSetsCursor : 1;
+
+  // If this flag is set, then the tab's layers will be preserved even when
+  // the tab's docshell is inactive.
+  bool mIsPreservingLayers : 1;
+
+  // Holds the most recent value passed to the RenderLayers function. This
+  // does not necessarily mean that the layers have finished rendering
+  // and have uploaded - for that, use mHasLayers.
+  bool mRenderLayers : 1;
+
+  // True if process should be set to a higher priority.
+  bool mPriorityHint : 1;
+
+  // True if the compositor has reported that the BrowserChild has uploaded
+  // layers.
+  bool mHasLayers : 1;
+
+  // True if this BrowserParent has had its layer tree sent to the compositor
+  // at least once.
+  bool mHasPresented : 1;
+
+  // True when the remote browser is created and ready to handle input events.
+  bool mIsReadyToHandleInputEvents : 1;
+
+  // True if we suppress the eMouseEnterIntoWidget event due to the
+  // BrowserChild was not ready to handle it. We will resend it when the next
+  // time we fire a mouse event and the BrowserChild is ready.
+  bool mIsMouseEnterIntoWidgetEventSuppressed : 1;
+
+  // True after RecvLockNativePointer has been called and until
+  // UnlockNativePointer has been called.
+  bool mLockedNativePointer : 1;
+
+  // True between ShowTooltip and HideTooltip messages.
+  bool mShowingTooltip : 1;
+};
+
+struct MOZ_STACK_CLASS BrowserParent::AutoUseNewTab final {
+ public:
+  explicit AutoUseNewTab(BrowserParent* aNewTab) : mNewTab(aNewTab) {
+    MOZ_ASSERT(!aNewTab->mCreatingWindow);
+    aNewTab->mCreatingWindow = true;
+  }
+
+  ~AutoUseNewTab() { mNewTab->mCreatingWindow = false; }
+
+ private:
+  RefPtr<BrowserParent> mNewTab;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_BrowserParent_h
diff --git a/dom/ipc/CSPMessageUtils.cpp b/dom/ipc/CSPMessageUtils.cpp
new file mode 100644
index 0000000000..b952d01b6f
--- /dev/null
+++ b/dom/ipc/CSPMessageUtils.cpp
@@ -0,0 +1,50 @@
+/* -*- 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 "mozilla/dom/CSPMessageUtils.h"
+#include "mozilla/ipc/PBackgroundSharedTypes.h"
+#include "nsSerializationHelper.h"
+#include "mozilla/ipc/BackgroundUtils.h"
+
+namespace IPC {
+
+using namespace mozilla::ipc;
+
+void ParamTraits<nsIContentSecurityPolicy*>::Write(
+    MessageWriter* aWriter, nsIContentSecurityPolicy* aParam) {
+  bool isNull = !aParam;
+  WriteParam(aWriter, isNull);
+  if (isNull) {
+    return;
+  }
+
+  CSPInfo csp;
+  mozilla::Unused << NS_WARN_IF(NS_FAILED(CSPToCSPInfo(aParam, &csp)));
+  WriteParam(aWriter, csp);
+}
+
+bool ParamTraits<nsIContentSecurityPolicy*>::Read(
+    MessageReader* aReader, RefPtr<nsIContentSecurityPolicy>* aResult) {
+  bool isNull;
+  if (!ReadParam(aReader, &isNull)) {
+    return false;
+  }
+
+  if (isNull) {
+    *aResult = nullptr;
+    return true;
+  }
+
+  CSPInfo csp;
+  if (!ReadParam(aReader, &csp)) {
+    return false;
+  }
+
+  *aResult = CSPInfoToCSP(csp, nullptr, nullptr);
+  return *aResult;
+}
+
+}  // namespace IPC
diff --git a/dom/ipc/CSPMessageUtils.h b/dom/ipc/CSPMessageUtils.h
new file mode 100644
index 0000000000..286a3a9778
--- /dev/null
+++ b/dom/ipc/CSPMessageUtils.h
@@ -0,0 +1,25 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_csp_message_utils_h__
+#define mozilla_dom_csp_message_utils_h__
+
+#include "ipc/IPCMessageUtils.h"
+#include "nsCOMPtr.h"
+#include "nsIContentSecurityPolicy.h"
+
+namespace IPC {
+
+template <>
+struct ParamTraits<nsIContentSecurityPolicy*> {
+  static void Write(MessageWriter* aWriter, nsIContentSecurityPolicy* aParam);
+  static bool Read(MessageReader* aReader,
+                   RefPtr<nsIContentSecurityPolicy>* aResult);
+};
+
+}  // namespace IPC
+
+#endif  // mozilla_dom_csp_message_utils_h__
diff --git a/dom/ipc/ClonedErrorHolder.cpp b/dom/ipc/ClonedErrorHolder.cpp
new file mode 100644
index 0000000000..af5e765fac
--- /dev/null
+++ b/dom/ipc/ClonedErrorHolder.cpp
@@ -0,0 +1,371 @@
+/* -*- 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 "mozilla/dom/ClonedErrorHolder.h"
+
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/ClonedErrorHolderBinding.h"
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/DOMExceptionBinding.h"
+#include "mozilla/dom/Exceptions.h"
+#include "mozilla/dom/StructuredCloneTags.h"
+#include "mozilla/dom/ToJSValue.h"
+#include "jsapi.h"
+#include "jsfriendapi.h"
+#include "js/StructuredClone.h"
+#include "nsReadableUtils.h"
+#include "xpcpublic.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+// static
+already_AddRefed<ClonedErrorHolder> ClonedErrorHolder::Constructor(
+    const GlobalObject& aGlobal, JS::Handle<JSObject*> aError,
+    ErrorResult& aRv) {
+  return Create(aGlobal.Context(), aError, aRv);
+}
+
+// static
+already_AddRefed<ClonedErrorHolder> ClonedErrorHolder::Create(
+    JSContext* aCx, JS::Handle<JSObject*> aError, ErrorResult& aRv) {
+  RefPtr<ClonedErrorHolder> ceh = new ClonedErrorHolder();
+  ceh->Init(aCx, aError, aRv);
+  if (aRv.Failed()) {
+    return nullptr;
+  }
+  return ceh.forget();
+}
+
+ClonedErrorHolder::ClonedErrorHolder()
+    : mName(VoidCString()),
+      mMessage(VoidCString()),
+      mFilename(VoidCString()),
+      mSourceLine(VoidCString()) {}
+
+void ClonedErrorHolder::Init(JSContext* aCx, JS::Handle<JSObject*> aError,
+                             ErrorResult& aRv) {
+  JS::Rooted<JSObject*> stack(aCx);
+
+  if (JSErrorReport* err = JS_ErrorFromException(aCx, aError)) {
+    mType = Type::JSError;
+    if (err->message()) {
+      mMessage = err->message().c_str();
+    }
+    if (err->filename) {
+      mFilename = err->filename;
+    }
+    if (err->linebuf()) {
+      AppendUTF16toUTF8(
+          nsDependentSubstring(err->linebuf(), err->linebufLength()),
+          mSourceLine);
+      mTokenOffset = err->tokenOffset();
+    }
+    mLineNumber = err->lineno;
+    mColumn = err->column;
+    mErrorNumber = err->errorNumber;
+    mExnType = JSExnType(err->exnType);
+
+    // Note: We don't save the souce ID here, since this object is cross-process
+    // clonable, and the source ID won't be valid in other processes.
+    // We don't store the source notes either, though for no other reason that
+    // it isn't clear that it's worth the complexity.
+
+    stack = JS::ExceptionStackOrNull(aError);
+  } else {
+    RefPtr<DOMException> domExn;
+    RefPtr<Exception> exn;
+    if (NS_SUCCEEDED(UNWRAP_OBJECT(DOMException, aError, domExn))) {
+      mType = Type::DOMException;
+      mCode = domExn->Code();
+      exn = std::move(domExn);
+    } else if (NS_SUCCEEDED(UNWRAP_OBJECT(Exception, aError, exn))) {
+      mType = Type::Exception;
+    } else {
+      aRv.ThrowNotSupportedError(
+          "We can only clone DOM Exceptions and native JS Error objects");
+      return;
+    }
+
+    nsAutoString str;
+
+    exn->GetName(str);
+    CopyUTF16toUTF8(str, mName);
+
+    exn->GetMessageMoz(str);
+    CopyUTF16toUTF8(str, mMessage);
+
+    // Note: In DOM exceptions, filename, line number, and column number come
+    // from the stack frame, and don't need to be stored separately. mFilename,
+    // mLineNumber, and mColumn are only used for JS exceptions.
+    //
+    // We also don't serialized Exception's mThrownJSVal or mData fields, since
+    // they generally won't be serializable.
+
+    mResult = nsresult(exn->Result());
+
+    if (nsCOMPtr<nsIStackFrame> frame = exn->GetLocation()) {
+      JS::Rooted<JS::Value> value(aCx);
+      frame->GetNativeSavedFrame(&value);
+      if (value.isObject()) {
+        stack = &value.toObject();
+      }
+    }
+  }
+
+  Maybe<JSAutoRealm> ar;
+  if (stack) {
+    ar.emplace(aCx, stack);
+  }
+  JS::Rooted<JS::Value> stackValue(aCx, JS::ObjectOrNullValue(stack));
+  mStack.Write(aCx, stackValue, aRv);
+}
+
+bool ClonedErrorHolder::WrapObject(JSContext* aCx,
+                                   JS::Handle<JSObject*> aGivenProto,
+                                   JS::MutableHandle<JSObject*> aReflector) {
+  return ClonedErrorHolder_Binding::Wrap(aCx, this, aGivenProto, aReflector);
+}
+
+static constexpr uint32_t kVoidStringLength = ~0;
+
+static bool WriteStringPair(JSStructuredCloneWriter* aWriter,
+                            const nsACString& aString1,
+                            const nsACString& aString2) {
+  auto StringLength = [](const nsACString& aStr) -> uint32_t {
+    auto length = uint32_t(aStr.Length());
+    MOZ_DIAGNOSTIC_ASSERT(length != kVoidStringLength,
+                          "We should not be serializing a 4GiB string");
+    if (aStr.IsVoid()) {
+      return kVoidStringLength;
+    }
+    return length;
+  };
+
+  return JS_WriteUint32Pair(aWriter, StringLength(aString1),
+                            StringLength(aString2)) &&
+         JS_WriteBytes(aWriter, aString1.BeginReading(), aString1.Length()) &&
+         JS_WriteBytes(aWriter, aString2.BeginReading(), aString2.Length());
+}
+
+static bool ReadStringPair(JSStructuredCloneReader* aReader,
+                           nsACString& aString1, nsACString& aString2) {
+  auto ReadString = [&](nsACString& aStr, uint32_t aLength) {
+    if (aLength == kVoidStringLength) {
+      aStr.SetIsVoid(true);
+      return true;
+    }
+    char* data = nullptr;
+    return aLength == 0 || (aStr.GetMutableData(&data, aLength, fallible) &&
+                            JS_ReadBytes(aReader, data, aLength));
+  };
+
+  aString1.Truncate(0);
+  aString2.Truncate(0);
+
+  uint32_t length1, length2;
+  return JS_ReadUint32Pair(aReader, &length1, &length2) &&
+         ReadString(aString1, length1) && ReadString(aString2, length2);
+}
+
+bool ClonedErrorHolder::WriteStructuredClone(JSContext* aCx,
+                                             JSStructuredCloneWriter* aWriter,
+                                             StructuredCloneHolder* aHolder) {
+  auto& data = mStack.BufferData();
+  return JS_WriteUint32Pair(aWriter, SCTAG_DOM_CLONED_ERROR_OBJECT, 0) &&
+         WriteStringPair(aWriter, mName, mMessage) &&
+         WriteStringPair(aWriter, mFilename, mSourceLine) &&
+         JS_WriteUint32Pair(aWriter, mLineNumber, mColumn) &&
+         JS_WriteUint32Pair(aWriter, mTokenOffset, mErrorNumber) &&
+         JS_WriteUint32Pair(aWriter, uint32_t(mType), uint32_t(mExnType)) &&
+         JS_WriteUint32Pair(aWriter, mCode, uint32_t(mResult)) &&
+         JS_WriteUint32Pair(aWriter, data.Size(),
+                            JS_STRUCTURED_CLONE_VERSION) &&
+         data.ForEachDataChunk([&](const char* aData, size_t aSize) {
+           return JS_WriteBytes(aWriter, aData, aSize);
+         });
+}
+
+bool ClonedErrorHolder::Init(JSContext* aCx, JSStructuredCloneReader* aReader) {
+  uint32_t type, exnType, result, code;
+  if (!(ReadStringPair(aReader, mName, mMessage) &&
+        ReadStringPair(aReader, mFilename, mSourceLine) &&
+        JS_ReadUint32Pair(aReader, &mLineNumber, &mColumn) &&
+        JS_ReadUint32Pair(aReader, &mTokenOffset, &mErrorNumber) &&
+        JS_ReadUint32Pair(aReader, &type, &exnType) &&
+        JS_ReadUint32Pair(aReader, &code, &result) &&
+        mStack.ReadStructuredCloneInternal(aCx, aReader))) {
+    return false;
+  }
+
+  if (type == uint32_t(Type::Uninitialized) || type >= uint32_t(Type::Max_) ||
+      exnType >= uint32_t(JSEXN_ERROR_LIMIT)) {
+    return false;
+  }
+
+  mType = Type(type);
+  mExnType = JSExnType(exnType);
+  mResult = nsresult(result);
+  mCode = code;
+
+  return true;
+}
+
+/* static */
+JSObject* ClonedErrorHolder::ReadStructuredClone(
+    JSContext* aCx, JSStructuredCloneReader* aReader,
+    StructuredCloneHolder* aHolder) {
+  // Keep the result object rooted across the call to ClonedErrorHolder::Release
+  // to avoid a potential rooting hazard.
+  JS::Rooted<JS::Value> errorVal(aCx);
+  {
+    RefPtr<ClonedErrorHolder> ceh = new ClonedErrorHolder();
+    if (!ceh->Init(aCx, aReader) || !ceh->ToErrorValue(aCx, &errorVal)) {
+      return nullptr;
+    }
+  }
+  return &errorVal.toObject();
+}
+
+static JS::UniqueTwoByteChars ToNullTerminatedJSStringBuffer(
+    JSContext* aCx, const nsString& aStr) {
+  // Since nsString is null terminated, we can simply copy + 1 characters.
+  size_t nbytes = (aStr.Length() + 1) * sizeof(char16_t);
+  JS::UniqueTwoByteChars buffer(static_cast<char16_t*>(JS_malloc(aCx, nbytes)));
+  if (buffer) {
+    memcpy(buffer.get(), aStr.get(), nbytes);
+  }
+  return buffer;
+}
+
+static bool ToJSString(JSContext* aCx, const nsACString& aStr,
+                       JS::MutableHandle<JSString*> aJSString) {
+  if (aStr.IsVoid()) {
+    aJSString.set(nullptr);
+    return true;
+  }
+  JS::Rooted<JS::Value> res(aCx);
+  if (xpc::NonVoidStringToJsval(aCx, NS_ConvertUTF8toUTF16(aStr), &res)) {
+    aJSString.set(res.toString());
+    return true;
+  }
+  return false;
+}
+
+bool ClonedErrorHolder::ToErrorValue(JSContext* aCx,
+                                     JS::MutableHandle<JS::Value> aResult) {
+  JS::Rooted<JS::Value> stackVal(aCx);
+  JS::Rooted<JSObject*> stack(aCx);
+
+  IgnoredErrorResult rv;
+  mStack.Read(xpc::CurrentNativeGlobal(aCx), aCx, &stackVal, rv);
+  // Note: We continue even if reading the stack fails, since we can still
+  // produce a useful error object even without a stack. That said, if decoding
+  // the stack fails, there's a pretty good chance that the rest of the message
+  // is corrupt, and there's no telling how useful the final result will
+  // actually be.
+  if (!rv.Failed() && stackVal.isObject()) {
+    stack = &stackVal.toObject();
+    // Make sure that this is really a saved frame. This mainly ensures that
+    // malicious code on the child side can't trigger a memory exploit by
+    // sending an incompatible data type, but also protects against potential
+    // issues like a cross-compartment wrapper being unexpectedly cut.
+    if (!js::IsSavedFrame(stack)) {
+      stack = nullptr;
+    }
+  }
+
+  if (mType == Type::JSError) {
+    JS::Rooted<JSString*> filename(aCx);
+    JS::Rooted<JSString*> message(aCx);
+
+    // For some unknown reason, we can end up with a void string in mFilename,
+    // which will cause filename to be null, which causes JS::CreateError() to
+    // crash. Make this code against robust against this by treating void
+    // strings as the empty string.
+    if (mFilename.IsVoid()) {
+      mFilename.Assign(""_ns);
+    }
+
+    // When fuzzing, we can also end up with the message to be null,
+    // so we should handle that case as well.
+    if (mMessage.IsVoid()) {
+      mMessage.Assign(""_ns);
+    }
+
+    if (!ToJSString(aCx, mFilename, &filename) ||
+        !ToJSString(aCx, mMessage, &message)) {
+      return false;
+    }
+    if (!JS::CreateError(aCx, mExnType, stack, filename, mLineNumber, mColumn,
+                         nullptr, message, JS::NothingHandleValue, aResult)) {
+      return false;
+    }
+
+    if (!mSourceLine.IsVoid()) {
+      JS::Rooted<JSObject*> errObj(aCx, &aResult.toObject());
+      if (JSErrorReport* err = JS_ErrorFromException(aCx, errObj)) {
+        NS_ConvertUTF8toUTF16 sourceLine(mSourceLine);
+        // Because this string ends up being consumed as an nsDependentString
+        // in nsXPCComponents_Utils::ReportError, this needs to be a null
+        // terminated string.
+        //
+        // See Bug 1699569.
+        if (mTokenOffset >= sourceLine.Length()) {
+          // Corrupt data, leave linebuf unset.
+        } else if (JS::UniqueTwoByteChars buffer =
+                       ToNullTerminatedJSStringBuffer(aCx, sourceLine)) {
+          err->initOwnedLinebuf(buffer.release(), sourceLine.Length(),
+                                mTokenOffset);
+        } else {
+          // Just ignore OOM and continue if the string copy failed.
+          JS_ClearPendingException(aCx);
+        }
+      }
+    }
+
+    return true;
+  }
+
+  nsCOMPtr<nsIStackFrame> frame(exceptions::CreateStack(aCx, stack));
+
+  RefPtr<Exception> exn;
+  if (mType == Type::Exception) {
+    exn = new Exception(mMessage, mResult, mName, frame, nullptr);
+  } else {
+    MOZ_ASSERT(mType == Type::DOMException);
+    exn = new DOMException(mResult, mMessage, mName, mCode, frame);
+  }
+
+  return ToJSValue(aCx, exn, aResult);
+}
+
+bool ClonedErrorHolder::Holder::ReadStructuredCloneInternal(
+    JSContext* aCx, JSStructuredCloneReader* aReader) {
+  uint32_t length;
+  uint32_t version;
+  if (!JS_ReadUint32Pair(aReader, &length, &version)) {
+    return false;
+  }
+  if (length % 8 != 0) {
+    return false;
+  }
+
+  JSStructuredCloneData data(mStructuredCloneScope);
+  while (length) {
+    size_t size;
+    char* buffer = data.AllocateBytes(length, &size);
+    if (!buffer || !JS_ReadBytes(aReader, buffer, size)) {
+      return false;
+    }
+    length -= size;
+  }
+
+  mBuffer = MakeUnique<JSAutoStructuredCloneBuffer>(
+      mStructuredCloneScope, &StructuredCloneHolder::sCallbacks, this);
+  mBuffer->adopt(std::move(data), version, &StructuredCloneHolder::sCallbacks);
+  return true;
+}
diff --git a/dom/ipc/ClonedErrorHolder.h b/dom/ipc/ClonedErrorHolder.h
new file mode 100644
index 0000000000..9d536398a2
--- /dev/null
+++ b/dom/ipc/ClonedErrorHolder.h
@@ -0,0 +1,104 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef mozilla_dom_ClonedErrorHolder_h
+#define mozilla_dom_ClonedErrorHolder_h
+
+#include "nsISupportsImpl.h"
+#include "js/ErrorReport.h"
+#include "js/TypeDecls.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/StructuredCloneHolder.h"
+#include "mozilla/Attributes.h"
+
+class nsIGlobalObject;
+class nsQueryActorChild;
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class ClonedErrorHolder final {
+  NS_INLINE_DECL_REFCOUNTING(ClonedErrorHolder)
+
+ public:
+  static already_AddRefed<ClonedErrorHolder> Constructor(
+      const GlobalObject& aGlobal, JS::Handle<JSObject*> aError,
+      ErrorResult& aRv);
+
+  static already_AddRefed<ClonedErrorHolder> Create(
+      JSContext* aCx, JS::Handle<JSObject*> aError, ErrorResult& aRv);
+
+  enum class Type : uint8_t {
+    Uninitialized,
+    JSError,
+    Exception,
+    DOMException,
+    Max_,
+  };
+
+  bool WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto,
+                  JS::MutableHandle<JSObject*> aReflector);
+
+  bool WriteStructuredClone(JSContext* aCx, JSStructuredCloneWriter* aWriter,
+                            StructuredCloneHolder* aHolder);
+
+  // Reads the structured clone data for the ClonedErrorHolder and returns the
+  // wrapped object (either a JS Error or an Exception/DOMException object)
+  // directly. Never returns an actual ClonedErrorHolder object.
+  static JSObject* ReadStructuredClone(JSContext* aCx,
+                                       JSStructuredCloneReader* aReader,
+                                       StructuredCloneHolder* aHolder);
+
+ private:
+  ClonedErrorHolder();
+  ~ClonedErrorHolder() = default;
+
+  void Init(JSContext* aCx, JS::Handle<JSObject*> aError, ErrorResult& aRv);
+
+  bool Init(JSContext* aCx, JSStructuredCloneReader* aReader);
+
+  // Creates a new JS Error or Exception/DOMException object based on the
+  // values stored in the holder. Returns false and sets an exception on aCx
+  // if it fails.
+  bool ToErrorValue(JSContext* aCx, JS::MutableHandle<JS::Value> aResult);
+
+  class Holder final : public StructuredCloneHolder {
+   public:
+    using StructuredCloneHolder::StructuredCloneHolder;
+
+    bool ReadStructuredCloneInternal(JSContext* aCx,
+                                     JSStructuredCloneReader* aReader);
+  };
+
+  // Only a subset of the following fields are used, depending on the mType of
+  // the error stored:
+  nsCString mName;        // Exception, DOMException
+  nsCString mMessage;     // JSError, Exception, DOMException
+  nsCString mFilename;    // JSError only
+  nsCString mSourceLine;  // JSError only
+
+  uint32_t mLineNumber = 0;   // JSError only
+  uint32_t mColumn = 0;       // JSError only
+  uint32_t mTokenOffset = 0;  // JSError only
+  uint32_t mErrorNumber = 0;  // JSError only
+
+  Type mType = Type::Uninitialized;
+
+  uint16_t mCode = 0;                 // DOMException only
+  JSExnType mExnType = JSExnType(0);  // JSError only
+  nsresult mResult = NS_OK;           // Exception, DOMException
+
+  // JSError, Exception, DOMException
+  Holder mStack{Holder::CloningSupported, Holder::TransferringNotSupported,
+                Holder::StructuredCloneScope::DifferentProcess};
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // !defined(mozilla_dom_ClonedErrorHolder_h)
diff --git a/dom/ipc/CoalescedInputData.cpp b/dom/ipc/CoalescedInputData.cpp
new file mode 100644
index 0000000000..6336f86928
--- /dev/null
+++ b/dom/ipc/CoalescedInputData.cpp
@@ -0,0 +1,47 @@
+/* -*- 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 "nsRefreshDriver.h"
+#include "BrowserChild.h"
+#include "CoalescedInputData.h"
+#include "mozilla/PresShell.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+void CoalescedInputFlusher::StartObserver() {
+  nsRefreshDriver* refreshDriver = GetRefreshDriver();
+  if (mRefreshDriver && mRefreshDriver == refreshDriver) {
+    // Nothing to do if we already added an observer and it's same refresh
+    // driver.
+    return;
+  }
+  RemoveObserver();
+  if (refreshDriver) {
+    mRefreshDriver = refreshDriver;
+    mRefreshDriver->AddRefreshObserver(this, FlushType::Event,
+                                       "Coalesced input move flusher");
+  }
+}
+
+CoalescedInputFlusher::CoalescedInputFlusher(BrowserChild* aBrowserChild)
+    : mBrowserChild(aBrowserChild) {}
+
+void CoalescedInputFlusher::RemoveObserver() {
+  if (mRefreshDriver) {
+    mRefreshDriver->RemoveRefreshObserver(this, FlushType::Event);
+    mRefreshDriver = nullptr;
+  }
+}
+
+CoalescedInputFlusher::~CoalescedInputFlusher() = default;
+
+nsRefreshDriver* CoalescedInputFlusher::GetRefreshDriver() {
+  if (PresShell* presShell = mBrowserChild->GetTopLevelPresShell()) {
+    return presShell->GetRefreshDriver();
+  }
+  return nullptr;
+}
diff --git a/dom/ipc/CoalescedInputData.h b/dom/ipc/CoalescedInputData.h
new file mode 100644
index 0000000000..aeac9d99a0
--- /dev/null
+++ b/dom/ipc/CoalescedInputData.h
@@ -0,0 +1,74 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_CoalescedInputData_h
+#define mozilla_dom_CoalescedInputData_h
+
+#include "mozilla/UniquePtr.h"
+#include "mozilla/layers/ScrollableLayerGuid.h"
+#include "nsRefreshObservers.h"
+
+class nsRefreshDriver;
+
+namespace mozilla::dom {
+
+class BrowserChild;
+
+template <class InputEventType>
+class CoalescedInputData {
+ protected:
+  using ScrollableLayerGuid = mozilla::layers::ScrollableLayerGuid;
+
+  UniquePtr<InputEventType> mCoalescedInputEvent;
+  ScrollableLayerGuid mGuid;
+  uint64_t mInputBlockId;
+
+ public:
+  CoalescedInputData() : mInputBlockId(0) {}
+
+  void RetrieveDataFrom(CoalescedInputData& aSource) {
+    mCoalescedInputEvent = std::move(aSource.mCoalescedInputEvent);
+    mGuid = aSource.mGuid;
+    mInputBlockId = aSource.mInputBlockId;
+  }
+
+  bool IsEmpty() { return !mCoalescedInputEvent; }
+
+  bool CanCoalesce(const InputEventType& aEvent,
+                   const ScrollableLayerGuid& aGuid,
+                   const uint64_t& aInputBlockId);
+
+  UniquePtr<InputEventType> TakeCoalescedEvent() {
+    return std::move(mCoalescedInputEvent);
+  }
+
+  ScrollableLayerGuid GetScrollableLayerGuid() { return mGuid; }
+
+  uint64_t GetInputBlockId() { return mInputBlockId; }
+};
+
+class CoalescedInputFlusher : public nsARefreshObserver {
+ public:
+  explicit CoalescedInputFlusher(BrowserChild* aBrowserChild);
+
+  virtual void WillRefresh(mozilla::TimeStamp aTime) override = 0;
+
+  NS_INLINE_DECL_REFCOUNTING(CoalescedInputFlusher, override)
+
+  void StartObserver();
+  void RemoveObserver();
+
+ protected:
+  virtual ~CoalescedInputFlusher();
+
+  nsRefreshDriver* GetRefreshDriver();
+
+  BrowserChild* mBrowserChild;
+  RefPtr<nsRefreshDriver> mRefreshDriver;
+};
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_CoalescedInputData_h
diff --git a/dom/ipc/CoalescedMouseData.cpp b/dom/ipc/CoalescedMouseData.cpp
new file mode 100644
index 0000000000..5aa445d2e0
--- /dev/null
+++ b/dom/ipc/CoalescedMouseData.cpp
@@ -0,0 +1,83 @@
+/* -*- 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 "base/basictypes.h"
+
+#include "CoalescedMouseData.h"
+#include "BrowserChild.h"
+
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "nsRefreshDriver.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+void CoalescedMouseData::Coalesce(const WidgetMouseEvent& aEvent,
+                                  const ScrollableLayerGuid& aGuid,
+                                  const uint64_t& aInputBlockId) {
+  if (IsEmpty()) {
+    mCoalescedInputEvent = MakeUnique<WidgetMouseEvent>(aEvent);
+    mGuid = aGuid;
+    mInputBlockId = aInputBlockId;
+    MOZ_ASSERT(!mCoalescedInputEvent->mCoalescedWidgetEvents);
+  } else {
+    MOZ_ASSERT(mGuid == aGuid);
+    MOZ_ASSERT(mInputBlockId == aInputBlockId);
+    MOZ_ASSERT(mCoalescedInputEvent->mModifiers == aEvent.mModifiers);
+    MOZ_ASSERT(mCoalescedInputEvent->mReason == aEvent.mReason);
+    MOZ_ASSERT(mCoalescedInputEvent->mInputSource == aEvent.mInputSource);
+    MOZ_ASSERT(mCoalescedInputEvent->mButton == aEvent.mButton);
+    MOZ_ASSERT(mCoalescedInputEvent->mButtons == aEvent.mButtons);
+    mCoalescedInputEvent->mTimeStamp = aEvent.mTimeStamp;
+    mCoalescedInputEvent->mRefPoint = aEvent.mRefPoint;
+    mCoalescedInputEvent->mPressure = aEvent.mPressure;
+    mCoalescedInputEvent->AssignPointerHelperData(aEvent);
+  }
+
+  if (aEvent.mMessage == eMouseMove) {
+    // PointerEvent::getCoalescedEvents is only applied to pointermove events.
+    if (!mCoalescedInputEvent->mCoalescedWidgetEvents) {
+      mCoalescedInputEvent->mCoalescedWidgetEvents =
+          new WidgetPointerEventHolder();
+    }
+    // Append current event in mCoalescedWidgetEvents. We use them to generate
+    // DOM events when content calls PointerEvent::getCoalescedEvents.
+    WidgetPointerEvent* event =
+        mCoalescedInputEvent->mCoalescedWidgetEvents->mEvents.AppendElement(
+            aEvent);
+
+    event->mMessage = ePointerMove;
+    event->mFlags.mBubbles = false;
+    event->mFlags.mCancelable = false;
+  }
+}
+
+bool CoalescedMouseData::CanCoalesce(const WidgetMouseEvent& aEvent,
+                                     const ScrollableLayerGuid& aGuid,
+                                     const uint64_t& aInputBlockId) {
+  MOZ_ASSERT(aEvent.mMessage == eMouseMove);
+  return !mCoalescedInputEvent ||
+         (!mCoalescedInputEvent->mFlags.mIsSynthesizedForTests &&
+          !aEvent.mFlags.mIsSynthesizedForTests &&
+          mCoalescedInputEvent->mModifiers == aEvent.mModifiers &&
+          mCoalescedInputEvent->mInputSource == aEvent.mInputSource &&
+          mCoalescedInputEvent->pointerId == aEvent.pointerId &&
+          mCoalescedInputEvent->mButton == aEvent.mButton &&
+          mCoalescedInputEvent->mButtons == aEvent.mButtons && mGuid == aGuid &&
+          mInputBlockId == aInputBlockId);
+}
+
+CoalescedMouseMoveFlusher::CoalescedMouseMoveFlusher(
+    BrowserChild* aBrowserChild)
+    : CoalescedInputFlusher(aBrowserChild) {}
+
+void CoalescedMouseMoveFlusher::WillRefresh(mozilla::TimeStamp aTime) {
+  MOZ_ASSERT(mRefreshDriver);
+  mBrowserChild->FlushAllCoalescedMouseData();
+  mBrowserChild->ProcessPendingCoalescedMouseDataAndDispatchEvents();
+}
+
+CoalescedMouseMoveFlusher::~CoalescedMouseMoveFlusher() { RemoveObserver(); }
diff --git a/dom/ipc/CoalescedMouseData.h b/dom/ipc/CoalescedMouseData.h
new file mode 100644
index 0000000000..4d09783ec4
--- /dev/null
+++ b/dom/ipc/CoalescedMouseData.h
@@ -0,0 +1,45 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_CoalescedMouseData_h
+#define mozilla_dom_CoalescedMouseData_h
+
+#include "CoalescedInputData.h"
+#include "mozilla/MouseEvents.h"
+#include "nsRefreshObservers.h"
+
+class nsRefreshDriver;
+
+namespace mozilla::dom {
+
+class CoalescedMouseData final : public CoalescedInputData<WidgetMouseEvent> {
+ public:
+  CoalescedMouseData() { MOZ_COUNT_CTOR(mozilla::dom::CoalescedMouseData); }
+
+  ~CoalescedMouseData() { MOZ_COUNT_DTOR(mozilla::dom::CoalescedMouseData); }
+
+  void Coalesce(const WidgetMouseEvent& aEvent,
+                const ScrollableLayerGuid& aGuid,
+                const uint64_t& aInputBlockId);
+
+  bool CanCoalesce(const WidgetMouseEvent& aEvent,
+                   const ScrollableLayerGuid& aGuid,
+                   const uint64_t& aInputBlockId);
+};
+
+class CoalescedMouseMoveFlusher final : public CoalescedInputFlusher {
+ public:
+  explicit CoalescedMouseMoveFlusher(BrowserChild* aBrowserChild);
+
+  void WillRefresh(mozilla::TimeStamp aTime) override;
+
+ private:
+  ~CoalescedMouseMoveFlusher() override;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_CoalescedMouseData_h
diff --git a/dom/ipc/CoalescedTouchData.cpp b/dom/ipc/CoalescedTouchData.cpp
new file mode 100644
index 0000000000..3c3bc71a0c
--- /dev/null
+++ b/dom/ipc/CoalescedTouchData.cpp
@@ -0,0 +1,132 @@
+/* -*- 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 "CoalescedTouchData.h"
+#include "BrowserChild.h"
+#include "mozilla/dom/PointerEventHandler.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+static const uint32_t sMaxTouchMoveIdentifiers = 10;
+
+void CoalescedTouchData::CreateCoalescedTouchEvent(
+    const WidgetTouchEvent& aEvent) {
+  MOZ_ASSERT(IsEmpty());
+  mCoalescedInputEvent = MakeUnique<WidgetTouchEvent>(aEvent);
+  for (size_t i = 0; i < mCoalescedInputEvent->mTouches.Length(); i++) {
+    const RefPtr<Touch>& touch = mCoalescedInputEvent->mTouches[i];
+    touch->mCoalescedWidgetEvents = MakeAndAddRef<WidgetPointerEventHolder>();
+    // Add an initial event into coalesced events, so
+    // the relevant pointer event would at least contain one coalesced event.
+    WidgetPointerEvent* event =
+        touch->mCoalescedWidgetEvents->mEvents.AppendElement(WidgetPointerEvent(
+            aEvent.IsTrusted(), ePointerMove, aEvent.mWidget));
+    PointerEventHandler::InitPointerEventFromTouch(*event, aEvent, *touch,
+                                                   i == 0);
+    event->mFlags.mBubbles = false;
+    event->mFlags.mCancelable = false;
+  }
+}
+
+void CoalescedTouchData::Coalesce(const WidgetTouchEvent& aEvent,
+                                  const ScrollableLayerGuid& aGuid,
+                                  const uint64_t& aInputBlockId,
+                                  const nsEventStatus& aApzResponse) {
+  MOZ_ASSERT(aEvent.mMessage == eTouchMove);
+  if (IsEmpty()) {
+    CreateCoalescedTouchEvent(aEvent);
+    mGuid = aGuid;
+    mInputBlockId = aInputBlockId;
+    mApzResponse = aApzResponse;
+  } else {
+    MOZ_ASSERT(mGuid == aGuid);
+    MOZ_ASSERT(mInputBlockId == aInputBlockId);
+    MOZ_ASSERT(mCoalescedInputEvent->mModifiers == aEvent.mModifiers);
+    MOZ_ASSERT(mCoalescedInputEvent->mInputSource == aEvent.mInputSource);
+
+    for (size_t i = 0; i < aEvent.mTouches.Length(); i++) {
+      const RefPtr<Touch>& touch = aEvent.mTouches[i];
+      // Get the same touch in the original event
+      RefPtr<Touch> sameTouch = GetTouch(touch->Identifier());
+      // The checks in CoalescedTouchData::CanCoalesce ensure it should never
+      // be null.
+      MOZ_ASSERT(sameTouch);
+      MOZ_ASSERT(sameTouch->mCoalescedWidgetEvents);
+      MOZ_ASSERT(!sameTouch->mCoalescedWidgetEvents->mEvents.IsEmpty());
+      if (!sameTouch->Equals(touch)) {
+        sameTouch->SetSameAs(touch);
+        WidgetPointerEvent* event =
+            sameTouch->mCoalescedWidgetEvents->mEvents.AppendElement(
+                WidgetPointerEvent(aEvent.IsTrusted(), ePointerMove,
+                                   aEvent.mWidget));
+        PointerEventHandler::InitPointerEventFromTouch(*event, aEvent, *touch,
+                                                       i == 0);
+        event->mFlags.mBubbles = false;
+        event->mFlags.mCancelable = false;
+      }
+    }
+
+    mCoalescedInputEvent->mTimeStamp = aEvent.mTimeStamp;
+  }
+}
+
+bool CoalescedTouchData::CanCoalesce(const WidgetTouchEvent& aEvent,
+                                     const ScrollableLayerGuid& aGuid,
+                                     const uint64_t& aInputBlockId,
+                                     const nsEventStatus& aApzResponse) {
+  MOZ_ASSERT(!IsEmpty());
+  if (mGuid != aGuid || mInputBlockId != aInputBlockId ||
+      mCoalescedInputEvent->mModifiers != aEvent.mModifiers ||
+      mCoalescedInputEvent->mInputSource != aEvent.mInputSource ||
+      aEvent.mTouches.Length() > sMaxTouchMoveIdentifiers) {
+    return false;
+  }
+
+  // Ensures both touchmove events have the same touches
+  if (aEvent.mTouches.Length() != mCoalescedInputEvent->mTouches.Length()) {
+    return false;
+  }
+  for (const RefPtr<Touch>& touch : aEvent.mTouches) {
+    if (!GetTouch(touch->Identifier())) {
+      return false;
+    }
+  }
+
+  // If one of them is eIgnore and the other one is eConsumeDoDefault,
+  // we always coalesce them to eConsumeDoDefault.
+  if (mApzResponse != aApzResponse) {
+    if (mApzResponse == nsEventStatus::nsEventStatus_eIgnore &&
+        aApzResponse == nsEventStatus::nsEventStatus_eConsumeDoDefault) {
+      mApzResponse = aApzResponse;
+    } else if (mApzResponse != nsEventStatus::nsEventStatus_eConsumeDoDefault ||
+               aApzResponse != nsEventStatus::nsEventStatus_eIgnore) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+Touch* CoalescedTouchData::GetTouch(int32_t aIdentifier) {
+  for (const RefPtr<Touch>& touch : mCoalescedInputEvent->mTouches) {
+    if (touch->Identifier() == aIdentifier) {
+      return touch;
+    }
+  }
+  return nullptr;
+}
+
+void CoalescedTouchMoveFlusher::WillRefresh(mozilla::TimeStamp aTime) {
+  MOZ_ASSERT(mRefreshDriver);
+  mBrowserChild->ProcessPendingCoalescedTouchData();
+}
+
+CoalescedTouchMoveFlusher::CoalescedTouchMoveFlusher(
+    BrowserChild* aBrowserChild)
+    : CoalescedInputFlusher(aBrowserChild) {}
+
+CoalescedTouchMoveFlusher::~CoalescedTouchMoveFlusher() { RemoveObserver(); }
diff --git a/dom/ipc/CoalescedTouchData.h b/dom/ipc/CoalescedTouchData.h
new file mode 100644
index 0000000000..1fc0efa262
--- /dev/null
+++ b/dom/ipc/CoalescedTouchData.h
@@ -0,0 +1,46 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom__CoalescedTouchData_h
+#define mozilla_dom__CoalescedTouchData_h
+
+#include "CoalescedInputData.h"
+#include "mozilla/TouchEvents.h"
+
+namespace mozilla::dom {
+
+class CoalescedTouchData final : public CoalescedInputData<WidgetTouchEvent> {
+ public:
+  void CreateCoalescedTouchEvent(const WidgetTouchEvent& aEvent);
+
+  void Coalesce(const WidgetTouchEvent& aEvent,
+                const ScrollableLayerGuid& aGuid, const uint64_t& aInputBlockId,
+                const nsEventStatus& aApzResponse);
+
+  bool CanCoalesce(const WidgetTouchEvent& aEvent,
+                   const ScrollableLayerGuid& aGuid,
+                   const uint64_t& aInputBlockId,
+                   const nsEventStatus& aApzResponse);
+
+  nsEventStatus GetApzResponse() { return mApzResponse; }
+
+ private:
+  Touch* GetTouch(int32_t aIdentifier);
+
+  nsEventStatus mApzResponse = nsEventStatus_eIgnore;
+};
+
+class CoalescedTouchMoveFlusher final : public CoalescedInputFlusher {
+ public:
+  explicit CoalescedTouchMoveFlusher(BrowserChild* aBrowserChild);
+  void WillRefresh(mozilla::TimeStamp aTime) override;
+
+ private:
+  ~CoalescedTouchMoveFlusher() override;
+};
+};  // namespace mozilla::dom
+
+#endif  // mozilla_dom_CoalescedTouchData_h
diff --git a/dom/ipc/CoalescedWheelData.cpp b/dom/ipc/CoalescedWheelData.cpp
new file mode 100644
index 0000000000..c8e23ac86d
--- /dev/null
+++ b/dom/ipc/CoalescedWheelData.cpp
@@ -0,0 +1,46 @@
+/* -*- 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 "base/basictypes.h"
+
+#include "CoalescedWheelData.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+void CoalescedWheelData::Coalesce(const WidgetWheelEvent& aEvent,
+                                  const ScrollableLayerGuid& aGuid,
+                                  const uint64_t& aInputBlockId) {
+  if (IsEmpty()) {
+    mCoalescedInputEvent = MakeUnique<WidgetWheelEvent>(aEvent);
+    mGuid = aGuid;
+    mInputBlockId = aInputBlockId;
+  } else {
+    MOZ_ASSERT(mGuid == aGuid);
+    MOZ_ASSERT(mInputBlockId == aInputBlockId);
+    MOZ_ASSERT(mCoalescedInputEvent->mModifiers == aEvent.mModifiers);
+    MOZ_ASSERT(mCoalescedInputEvent->mDeltaMode == aEvent.mDeltaMode);
+    MOZ_ASSERT(mCoalescedInputEvent->mCanTriggerSwipe ==
+               aEvent.mCanTriggerSwipe);
+    mCoalescedInputEvent->mDeltaX += aEvent.mDeltaX;
+    mCoalescedInputEvent->mDeltaY += aEvent.mDeltaY;
+    mCoalescedInputEvent->mDeltaZ += aEvent.mDeltaZ;
+    mCoalescedInputEvent->mLineOrPageDeltaX += aEvent.mLineOrPageDeltaX;
+    mCoalescedInputEvent->mLineOrPageDeltaY += aEvent.mLineOrPageDeltaY;
+    mCoalescedInputEvent->mTimeStamp = aEvent.mTimeStamp;
+  }
+}
+
+bool CoalescedWheelData::CanCoalesce(const WidgetWheelEvent& aEvent,
+                                     const ScrollableLayerGuid& aGuid,
+                                     const uint64_t& aInputBlockId) {
+  MOZ_ASSERT(!IsEmpty());
+  return !mCoalescedInputEvent ||
+         (mCoalescedInputEvent->mRefPoint == aEvent.mRefPoint &&
+          mCoalescedInputEvent->mModifiers == aEvent.mModifiers &&
+          mCoalescedInputEvent->mDeltaMode == aEvent.mDeltaMode &&
+          mCoalescedInputEvent->mCanTriggerSwipe == aEvent.mCanTriggerSwipe &&
+          mGuid == aGuid && mInputBlockId == aInputBlockId);
+}
diff --git a/dom/ipc/CoalescedWheelData.h b/dom/ipc/CoalescedWheelData.h
new file mode 100644
index 0000000000..cd322d8874
--- /dev/null
+++ b/dom/ipc/CoalescedWheelData.h
@@ -0,0 +1,28 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_CoalescedWheelData_h
+#define mozilla_dom_CoalescedWheelData_h
+
+#include "CoalescedInputData.h"
+#include "mozilla/MouseEvents.h"
+
+namespace mozilla::dom {
+
+class CoalescedWheelData final : public CoalescedInputData<WidgetWheelEvent> {
+ public:
+  void Coalesce(const WidgetWheelEvent& aEvent,
+                const ScrollableLayerGuid& aGuid,
+                const uint64_t& aInputBlockId);
+
+  bool CanCoalesce(const WidgetWheelEvent& aEvent,
+                   const ScrollableLayerGuid& aGuid,
+                   const uint64_t& aInputBlockId);
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_CoalescedWheelData_h
diff --git a/dom/ipc/ColorPickerParent.cpp b/dom/ipc/ColorPickerParent.cpp
new file mode 100644
index 0000000000..18cf197330
--- /dev/null
+++ b/dom/ipc/ColorPickerParent.cpp
@@ -0,0 +1,77 @@
+/* -*- 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 "ColorPickerParent.h"
+#include "nsComponentManagerUtils.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/Unused.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/BrowserParent.h"
+
+using mozilla::Unused;
+using namespace mozilla::dom;
+
+NS_IMPL_ISUPPORTS(ColorPickerParent::ColorPickerShownCallback,
+                  nsIColorPickerShownCallback);
+
+NS_IMETHODIMP
+ColorPickerParent::ColorPickerShownCallback::Update(const nsAString& aColor) {
+  if (mColorPickerParent) {
+    Unused << mColorPickerParent->SendUpdate(aColor);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ColorPickerParent::ColorPickerShownCallback::Done(const nsAString& aColor) {
+  if (mColorPickerParent) {
+    Unused << ColorPickerParent::Send__delete__(mColorPickerParent, aColor);
+  }
+  return NS_OK;
+}
+
+void ColorPickerParent::ColorPickerShownCallback::Destroy() {
+  mColorPickerParent = nullptr;
+}
+
+bool ColorPickerParent::CreateColorPicker() {
+  mPicker = do_CreateInstance("@mozilla.org/colorpicker;1");
+  if (!mPicker) {
+    return false;
+  }
+
+  Element* ownerElement = BrowserParent::GetFrom(Manager())->GetOwnerElement();
+  if (!ownerElement) {
+    return false;
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = ownerElement->OwnerDoc()->GetWindow();
+  if (!window) {
+    return false;
+  }
+
+  return NS_SUCCEEDED(
+      mPicker->Init(window, mTitle, mInitialColor, mDefaultColors));
+}
+
+mozilla::ipc::IPCResult ColorPickerParent::RecvOpen() {
+  if (!CreateColorPicker()) {
+    Unused << Send__delete__(this, mInitialColor);
+    return IPC_OK();
+  }
+
+  MOZ_ASSERT(!mCallback);
+  mCallback = new ColorPickerShownCallback(this);
+
+  mPicker->Open(mCallback);
+  return IPC_OK();
+};
+
+void ColorPickerParent::ActorDestroy(ActorDestroyReason aWhy) {
+  if (mCallback) {
+    mCallback->Destroy();
+  }
+}
diff --git a/dom/ipc/ColorPickerParent.h b/dom/ipc/ColorPickerParent.h
new file mode 100644
index 0000000000..00b0828034
--- /dev/null
+++ b/dom/ipc/ColorPickerParent.h
@@ -0,0 +1,58 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_ColorPickerParent_h
+#define mozilla_dom_ColorPickerParent_h
+
+#include "mozilla/dom/PColorPickerParent.h"
+#include "nsIColorPicker.h"
+
+namespace mozilla::dom {
+
+class ColorPickerParent : public PColorPickerParent {
+ public:
+  ColorPickerParent(const nsString& aTitle, const nsString& aInitialColor,
+                    const nsTArray<nsString>& aDefaultColors)
+      : mTitle(aTitle),
+        mInitialColor(aInitialColor),
+        mDefaultColors(aDefaultColors.Clone()) {}
+
+  NS_INLINE_DECL_REFCOUNTING(ColorPickerParent, final)
+
+  virtual mozilla::ipc::IPCResult RecvOpen() override;
+  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  class ColorPickerShownCallback final : public nsIColorPickerShownCallback {
+   public:
+    explicit ColorPickerShownCallback(ColorPickerParent* aColorPickerParnet)
+        : mColorPickerParent(aColorPickerParnet) {}
+
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSICOLORPICKERSHOWNCALLBACK
+
+    void Destroy();
+
+   private:
+    ~ColorPickerShownCallback() = default;
+    RefPtr<ColorPickerParent> mColorPickerParent;
+  };
+
+ private:
+  virtual ~ColorPickerParent() = default;
+
+  bool CreateColorPicker();
+
+  RefPtr<ColorPickerShownCallback> mCallback;
+  nsCOMPtr<nsIColorPicker> mPicker;
+
+  nsString mTitle;
+  nsString mInitialColor;
+  nsTArray<nsString> mDefaultColors;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_ColorPickerParent_h
diff --git a/dom/ipc/ContentChild.cpp b/dom/ipc/ContentChild.cpp
new file mode 100644
index 0000000000..5254f5f1ea
--- /dev/null
+++ b/dom/ipc/ContentChild.cpp
@@ -0,0 +1,5036 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=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/. */
+
+#ifdef MOZ_WIDGET_ANDROID
+#  include "AndroidDecoderModule.h"
+#endif
+
+#include "BrowserChild.h"
+#include "nsNSSComponent.h"
+#include "ContentChild.h"
+#include "GeckoProfiler.h"
+#include "HandlerServiceChild.h"
+#include "nsXPLookAndFeel.h"
+#include "mozilla/AppShutdown.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/BackgroundHangMonitor.h"
+#include "mozilla/BenchmarkStorageChild.h"
+#include "mozilla/FOGIPC.h"
+#include "GMPServiceChild.h"
+#include "Geolocation.h"
+#include "imgLoader.h"
+#include "ScrollingMetrics.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/Components.h"
+#include "mozilla/HangDetails.h"
+#include "mozilla/LoadInfo.h"
+#include "mozilla/Logging.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/MemoryTelemetry.h"
+#include "mozilla/NullPrincipal.h"
+#include "mozilla/PerfStats.h"
+#include "mozilla/PerformanceMetricsCollector.h"
+#include "mozilla/PerformanceUtils.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/ProcessHangMonitorIPC.h"
+#include "mozilla/RemoteDecoderManagerChild.h"
+#include "mozilla/RemoteLazyInputStreamChild.h"
+#include "mozilla/SchedulerGroup.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/SharedStyleSheetCache.h"
+#include "mozilla/SimpleEnumerator.h"
+#include "mozilla/SpinEventLoopUntil.h"
+#include "mozilla/StaticPrefs_browser.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/StaticPrefs_fission.h"
+#include "mozilla/StaticPrefs_javascript.h"
+#include "mozilla/StaticPrefs_media.h"
+#include "mozilla/StaticPrefs_threads.h"
+#include "mozilla/StorageAccessAPIHelper.h"
+#include "mozilla/TelemetryIPC.h"
+#include "mozilla/Unused.h"
+#include "mozilla/WebBrowserPersistDocumentChild.h"
+#include "mozilla/devtools/HeapSnapshotTempFileHelperChild.h"
+#include "mozilla/dom/AutoSuppressEventHandlingAndSuspend.h"
+#include "mozilla/dom/BlobImpl.h"
+#include "mozilla/dom/BrowserBridgeHost.h"
+#include "mozilla/dom/BrowsingContext.h"
+#include "mozilla/dom/BrowsingContextGroup.h"
+#include "mozilla/dom/ChildProcessChannelListener.h"
+#include "mozilla/dom/ChildProcessMessageManager.h"
+#include "mozilla/dom/ClientManager.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/ContentProcessManager.h"
+#include "mozilla/dom/ContentPlaybackController.h"
+#include "mozilla/dom/ContentProcessMessageManager.h"
+#include "mozilla/dom/DataTransfer.h"
+#include "mozilla/dom/DocGroup.h"
+#include "mozilla/dom/ExternalHelperAppChild.h"
+#include "mozilla/dom/GetFilesHelper.h"
+#include "mozilla/dom/IPCBlobUtils.h"
+#include "mozilla/dom/InProcessChild.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"
+#include "mozilla/dom/PSessionStorageObserverChild.h"
+#include "mozilla/dom/PostMessageEvent.h"
+#include "mozilla/dom/PushNotifier.h"
+#include "mozilla/dom/RemoteWorkerService.h"
+#include "mozilla/dom/ScreenOrientation.h"
+#include "mozilla/dom/ServiceWorkerManager.h"
+#include "mozilla/dom/SessionStorageManager.h"
+#include "mozilla/dom/URLClassifierChild.h"
+#include "mozilla/dom/WindowGlobalChild.h"
+#include "mozilla/dom/WorkerDebugger.h"
+#include "mozilla/dom/WorkerDebuggerManager.h"
+#include "mozilla/dom/ipc/SharedMap.h"
+#include "mozilla/extensions/ExtensionsChild.h"
+#include "mozilla/extensions/StreamFilterParent.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/hal_sandbox/PHalChild.h"
+#include "mozilla/intl/L10nRegistry.h"
+#include "mozilla/intl/LocaleService.h"
+#include "mozilla/ipc/BackgroundChild.h"
+#include "mozilla/ipc/Endpoint.h"
+#include "mozilla/ipc/FileDescriptorUtils.h"
+#include "mozilla/ipc/GeckoChildProcessHost.h"
+#include "mozilla/ipc/ProcessChild.h"
+#include "mozilla/ipc/TestShellChild.h"
+#include "mozilla/layers/APZChild.h"
+#include "mozilla/layers/CompositorManagerChild.h"
+#include "mozilla/layers/ContentProcessController.h"
+#include "mozilla/layers/ImageBridgeChild.h"
+#ifdef NS_PRINTING
+#  include "mozilla/layout/RemotePrintJobChild.h"
+#endif
+#include "mozilla/loader/ScriptCacheActors.h"
+#include "mozilla/media/MediaChild.h"
+#include "mozilla/net/CaptivePortalService.h"
+#include "mozilla/net/ChildDNSService.h"
+#include "mozilla/net/CookieServiceChild.h"
+#include "mozilla/net/DocumentChannelChild.h"
+#include "mozilla/net/HttpChannelChild.h"
+#include "mozilla/widget/RemoteLookAndFeel.h"
+#include "mozilla/widget/ScreenManager.h"
+#include "mozilla/widget/WidgetMessageUtils.h"
+#include "nsBaseDragService.h"
+#include "nsDocShellLoadTypes.h"
+#include "nsFocusManager.h"
+#include "nsHttpHandler.h"
+#include "nsIConsoleService.h"
+#include "nsIInputStreamChannel.h"
+#include "nsILayoutHistoryState.h"
+#include "nsILoadGroup.h"
+#include "nsIOpenWindowInfo.h"
+#include "nsISimpleEnumerator.h"
+#include "nsIStringBundle.h"
+#include "nsIURIMutator.h"
+#include "nsQueryObject.h"
+#include "nsSandboxFlags.h"
+#include "mozmemory.h"
+
+#include "ChildProfilerController.h"
+
+#if defined(MOZ_SANDBOX)
+#  include "mozilla/SandboxSettings.h"
+#  if defined(XP_WIN)
+#    include "mozilla/sandboxTarget.h"
+#  elif defined(XP_LINUX)
+#    include "CubebUtils.h"
+#    include "mozilla/Sandbox.h"
+#    include "mozilla/SandboxInfo.h"
+#  elif defined(XP_MACOSX)
+#    include "mozilla/Sandbox.h"
+#    include "mozilla/gfx/QuartzSupport.h"
+#  elif defined(__OpenBSD__)
+#    include <err.h>
+#    include <sys/stat.h>
+#    include <unistd.h>
+
+#    include <fstream>
+
+#    include "BinaryPath.h"
+#    include "SpecialSystemDirectory.h"
+#    include "nsILineInputStream.h"
+#    include "mozilla/ipc/UtilityProcessSandboxing.h"
+#  endif
+#  if defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
+#    include "mozilla/SandboxTestingChild.h"
+#  endif
+#endif
+
+#include "SandboxHal.h"
+#include "mozInlineSpellChecker.h"
+#include "mozilla/GlobalStyleSheetCache.h"
+#include "nsAnonymousTemporaryFile.h"
+#include "nsCategoryManagerUtils.h"
+#include "nsClipboardProxy.h"
+#include "nsContentPermissionHelper.h"
+#include "nsDebugImpl.h"
+#include "nsDirectoryService.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsDirectoryServiceUtils.h"
+#include "nsDocShell.h"
+#include "nsDocShellLoadState.h"
+#include "nsHashPropertyBag.h"
+#include "nsIConsoleListener.h"
+#include "nsIContentViewer.h"
+#include "nsICycleCollectorListener.h"
+#include "nsIDocShellTreeOwner.h"
+#include "nsIDragService.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIMemoryInfoDumper.h"
+#include "nsIMemoryReporter.h"
+#include "nsIObserverService.h"
+#include "nsIOService.h"
+#include "nsIScriptError.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsJSEnvironment.h"
+#include "nsJSUtils.h"
+#include "nsMemoryInfoDumper.h"
+#include "nsPluginHost.h"
+#include "nsServiceManagerUtils.h"
+#include "nsStyleSheetService.h"
+#include "nsThreadManager.h"
+#include "nsVariant.h"
+#include "nsXULAppAPI.h"
+#include "IHistory.h"
+#include "ReferrerInfo.h"
+#include "base/message_loop.h"
+#include "base/process_util.h"
+#include "base/task.h"
+#include "mozilla/dom/BlobURLProtocolHandler.h"
+#include "mozilla/dom/PCycleCollectWithLogsChild.h"
+#include "mozilla/dom/PerformanceStorage.h"
+#include "nsChromeRegistryContent.h"
+#include "nsFrameMessageManager.h"
+#include "nsNetUtil.h"
+#include "nsWindowMemoryReporter.h"
+
+#ifdef MOZ_WEBRTC
+#  include "jsapi/WebrtcGlobalChild.h"
+#endif
+
+#include "PermissionMessageUtils.h"
+#include "mozilla/Permission.h"
+#include "mozilla/PermissionManager.h"
+
+#if defined(MOZ_WIDGET_ANDROID)
+#  include "APKOpen.h"
+#endif
+
+#ifdef XP_WIN
+#  include <process.h>
+#  define getpid _getpid
+#  include "mozilla/WinDllServices.h"
+#endif
+
+#if defined(XP_MACOSX)
+#  include "nsMacUtilsImpl.h"
+#  include <sys/qos.h>
+#endif /* XP_MACOSX */
+
+#ifdef MOZ_X11
+#  include "mozilla/X11Util.h"
+#endif
+
+#ifdef ACCESSIBILITY
+#  include "nsAccessibilityService.h"
+#  ifdef XP_WIN
+#    include "mozilla/a11y/AccessibleWrap.h"
+#  endif
+#  include "mozilla/a11y/DocAccessible.h"
+#  include "mozilla/a11y/DocManager.h"
+#  include "mozilla/a11y/OuterDocAccessible.h"
+#endif
+
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/MediaControllerBinding.h"
+
+#ifdef MOZ_WEBSPEECH
+#  include "mozilla/dom/PSpeechSynthesisChild.h"
+#endif
+
+#include "ClearOnShutdown.h"
+#include "DomainPolicy.h"
+#include "GfxInfoBase.h"
+#include "MMPrinter.h"
+#include "mozilla/ipc/ProcessUtils.h"
+#include "mozilla/ipc/URIUtils.h"
+#include "VRManagerChild.h"
+#include "gfxPlatform.h"
+#include "gfxPlatformFontList.h"
+#include "mozilla/RemoteSpellCheckEngineChild.h"
+#include "mozilla/dom/TabContext.h"
+#include "mozilla/dom/ipc/StructuredCloneData.h"
+#include "mozilla/ipc/CrashReporterClient.h"
+#include "mozilla/net/NeckoMessageUtils.h"
+#include "mozilla/widget/PuppetBidiKeyboard.h"
+#include "nsContentUtils.h"
+#include "nsIPrincipal.h"
+#include "nsString.h"
+#include "nscore.h"  // for NS_FREE_PERMANENT_DATA
+#include "private/pprio.h"
+
+#ifdef MOZ_WIDGET_GTK
+#  include "mozilla/WidgetUtilsGtk.h"
+#  include "nsAppRunner.h"
+#  include <gtk/gtk.h>
+#endif
+
+#ifdef MOZ_CODE_COVERAGE
+#  include "mozilla/CodeCoverageHandler.h"
+#endif
+
+extern mozilla::LazyLogModule gSHIPBFCacheLog;
+
+using namespace mozilla;
+using namespace mozilla::dom::ipc;
+using namespace mozilla::media;
+using namespace mozilla::embedding;
+using namespace mozilla::gmp;
+using namespace mozilla::hal_sandbox;
+using namespace mozilla::ipc;
+using namespace mozilla::intl;
+using namespace mozilla::layers;
+using namespace mozilla::layout;
+using namespace mozilla::net;
+using namespace mozilla::widget;
+using mozilla::loader::PScriptCacheChild;
+
+namespace geckoprofiler::markers {
+struct ProcessPriorityChange {
+  static constexpr Span<const char> MarkerTypeName() {
+    return MakeStringSpan("ProcessPriorityChange");
+  }
+  static void StreamJSONMarkerData(baseprofiler::SpliceableJSONWriter& aWriter,
+                                   const ProfilerString8View& aPreviousPriority,
+                                   const ProfilerString8View& aNewPriority) {
+    aWriter.StringProperty("Before", aPreviousPriority);
+    aWriter.StringProperty("After", aNewPriority);
+  }
+  static MarkerSchema MarkerTypeDisplay() {
+    using MS = MarkerSchema;
+    MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable};
+    schema.AddKeyFormat("Before", MS::Format::String);
+    schema.AddKeyFormat("After", MS::Format::String);
+    schema.AddStaticLabelValue("Note",
+                               "This is a notification of the priority change "
+                               "that was done by the parent process");
+    schema.SetAllLabels(
+        "priority: {marker.data.Before} -> {marker.data.After}");
+    return schema;
+  }
+};
+
+struct ProcessPriority {
+  static constexpr Span<const char> MarkerTypeName() {
+    return MakeStringSpan("ProcessPriority");
+  }
+  static void StreamJSONMarkerData(baseprofiler::SpliceableJSONWriter& aWriter,
+                                   const ProfilerString8View& aPriority,
+                                   const ProfilingState& aProfilingState) {
+    aWriter.StringProperty("Priority", aPriority);
+    aWriter.StringProperty("Marker cause",
+                           ProfilerString8View::WrapNullTerminatedString(
+                               ProfilingStateToString(aProfilingState)));
+  }
+  static MarkerSchema MarkerTypeDisplay() {
+    using MS = MarkerSchema;
+    MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable};
+    schema.AddKeyFormat("Priority", MS::Format::String);
+    schema.AddKeyFormat("Marker cause", MS::Format::String);
+    schema.SetAllLabels("priority: {marker.data.Priority}");
+    return schema;
+  }
+};
+}  // namespace geckoprofiler::markers
+
+namespace mozilla {
+namespace dom {
+
+// IPC sender for remote GC/CC logging.
+class CycleCollectWithLogsChild final : public PCycleCollectWithLogsChild {
+ public:
+  NS_INLINE_DECL_REFCOUNTING(CycleCollectWithLogsChild)
+
+  class Sink final : public nsICycleCollectorLogSink {
+    NS_DECL_ISUPPORTS
+
+    Sink(CycleCollectWithLogsChild* aActor, const FileDescriptor& aGCLog,
+         const FileDescriptor& aCCLog) {
+      mActor = aActor;
+      mGCLog = FileDescriptorToFILE(aGCLog, "w");
+      mCCLog = FileDescriptorToFILE(aCCLog, "w");
+    }
+
+    NS_IMETHOD Open(FILE** aGCLog, FILE** aCCLog) override {
+      if (NS_WARN_IF(!mGCLog) || NS_WARN_IF(!mCCLog)) {
+        return NS_ERROR_FAILURE;
+      }
+      *aGCLog = mGCLog;
+      *aCCLog = mCCLog;
+      return NS_OK;
+    }
+
+    NS_IMETHOD CloseGCLog() override {
+      MOZ_ASSERT(mGCLog);
+      fclose(mGCLog);
+      mGCLog = nullptr;
+      mActor->SendCloseGCLog();
+      return NS_OK;
+    }
+
+    NS_IMETHOD CloseCCLog() override {
+      MOZ_ASSERT(mCCLog);
+      fclose(mCCLog);
+      mCCLog = nullptr;
+      mActor->SendCloseCCLog();
+      return NS_OK;
+    }
+
+    NS_IMETHOD GetFilenameIdentifier(nsAString& aIdentifier) override {
+      return UnimplementedProperty();
+    }
+
+    NS_IMETHOD SetFilenameIdentifier(const nsAString& aIdentifier) override {
+      return UnimplementedProperty();
+    }
+
+    NS_IMETHOD GetProcessIdentifier(int32_t* aIdentifier) override {
+      return UnimplementedProperty();
+    }
+
+    NS_IMETHOD SetProcessIdentifier(int32_t aIdentifier) override {
+      return UnimplementedProperty();
+    }
+
+    NS_IMETHOD GetGcLog(nsIFile** aPath) override {
+      return UnimplementedProperty();
+    }
+
+    NS_IMETHOD GetCcLog(nsIFile** aPath) override {
+      return UnimplementedProperty();
+    }
+
+   private:
+    ~Sink() {
+      if (mGCLog) {
+        fclose(mGCLog);
+        mGCLog = nullptr;
+      }
+      if (mCCLog) {
+        fclose(mCCLog);
+        mCCLog = nullptr;
+      }
+      // The XPCOM refcount drives the IPC lifecycle;
+      Unused << mActor->Send__delete__(mActor);
+    }
+
+    nsresult UnimplementedProperty() {
+      MOZ_ASSERT(false,
+                 "This object is a remote GC/CC logger;"
+                 " this property isn't meaningful.");
+      return NS_ERROR_UNEXPECTED;
+    }
+
+    RefPtr<CycleCollectWithLogsChild> mActor;
+    FILE* mGCLog;
+    FILE* mCCLog;
+  };
+
+ private:
+  ~CycleCollectWithLogsChild() = default;
+};
+
+NS_IMPL_ISUPPORTS(CycleCollectWithLogsChild::Sink, nsICycleCollectorLogSink);
+
+class AlertObserver {
+ public:
+  AlertObserver(nsIObserver* aObserver, const nsString& aData)
+      : mObserver(aObserver), mData(aData) {}
+
+  ~AlertObserver() = default;
+
+  nsCOMPtr<nsIObserver> mObserver;
+  nsString mData;
+};
+
+class ConsoleListener final : public nsIConsoleListener {
+ public:
+  explicit ConsoleListener(ContentChild* aChild) : mChild(aChild) {}
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSICONSOLELISTENER
+
+ private:
+  ~ConsoleListener() = default;
+
+  ContentChild* mChild;
+  friend class ContentChild;
+};
+
+NS_IMPL_ISUPPORTS(ConsoleListener, nsIConsoleListener)
+
+// Before we send the error to the parent process (which
+// involves copying the memory), truncate any long lines.  CSS
+// errors in particular share the memory for long lines with
+// repeated errors, but the IPC communication we're about to do
+// will break that sharing, so we better truncate now.
+static void TruncateString(nsAString& aString) {
+  if (aString.Length() > 1000) {
+    aString.Truncate(1000);
+  }
+}
+
+NS_IMETHODIMP
+ConsoleListener::Observe(nsIConsoleMessage* aMessage) {
+  if (!mChild) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIScriptError> scriptError = do_QueryInterface(aMessage);
+  if (scriptError) {
+    nsAutoString msg, sourceName, sourceLine;
+    nsCString category;
+    uint32_t lineNum, colNum, flags;
+    bool fromPrivateWindow, fromChromeContext;
+
+    nsresult rv = scriptError->GetErrorMessage(msg);
+    NS_ENSURE_SUCCESS(rv, rv);
+    TruncateString(msg);
+    rv = scriptError->GetSourceName(sourceName);
+    NS_ENSURE_SUCCESS(rv, rv);
+    TruncateString(sourceName);
+    rv = scriptError->GetSourceLine(sourceLine);
+    NS_ENSURE_SUCCESS(rv, rv);
+    TruncateString(sourceLine);
+
+    rv = scriptError->GetCategory(getter_Copies(category));
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = scriptError->GetLineNumber(&lineNum);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = scriptError->GetColumnNumber(&colNum);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = scriptError->GetFlags(&flags);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = scriptError->GetIsFromPrivateWindow(&fromPrivateWindow);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = scriptError->GetIsFromChromeContext(&fromChromeContext);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    {
+      AutoJSAPI jsapi;
+      jsapi.Init();
+      JSContext* cx = jsapi.cx();
+
+      JS::Rooted<JS::Value> stack(cx);
+      rv = scriptError->GetStack(&stack);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      if (stack.isObject()) {
+        // Because |stack| might be a cross-compartment wrapper, we can't use it
+        // with JSAutoRealm. Use the stackGlobal for that.
+        JS::Rooted<JS::Value> stackGlobal(cx);
+        rv = scriptError->GetStackGlobal(&stackGlobal);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        JSAutoRealm ar(cx, &stackGlobal.toObject());
+
+        StructuredCloneData data;
+        ErrorResult err;
+        data.Write(cx, stack, err);
+        if (err.Failed()) {
+          return err.StealNSResult();
+        }
+
+        ClonedMessageData cloned;
+        if (!data.BuildClonedMessageData(cloned)) {
+          return NS_ERROR_FAILURE;
+        }
+
+        mChild->SendScriptErrorWithStack(
+            msg, sourceName, sourceLine, lineNum, colNum, flags, category,
+            fromPrivateWindow, fromChromeContext, cloned);
+        return NS_OK;
+      }
+    }
+
+    mChild->SendScriptError(msg, sourceName, sourceLine, lineNum, colNum, flags,
+                            category, fromPrivateWindow, 0, fromChromeContext);
+    return NS_OK;
+  }
+
+  nsString msg;
+  nsresult rv = aMessage->GetMessageMoz(msg);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mChild->SendConsoleMessage(msg);
+  return NS_OK;
+}
+
+#ifdef NIGHTLY_BUILD
+/**
+ * The singleton of this class is registered with the BackgroundHangMonitor as
+ * an annotator, so that the hang monitor can record whether or not there were
+ * pending input events when the thread hung.
+ */
+class PendingInputEventHangAnnotator final : public BackgroundHangAnnotator {
+ public:
+  virtual void AnnotateHang(BackgroundHangAnnotations& aAnnotations) override {
+    int32_t pending = ContentChild::GetSingleton()->GetPendingInputEvents();
+    if (pending > 0) {
+      aAnnotations.AddAnnotation(u"PendingInput"_ns, pending);
+    }
+  }
+
+  static PendingInputEventHangAnnotator sSingleton;
+};
+PendingInputEventHangAnnotator PendingInputEventHangAnnotator::sSingleton;
+#endif
+
+class ContentChild::ShutdownCanary final {};
+
+ContentChild* ContentChild::sSingleton;
+StaticAutoPtr<ContentChild::ShutdownCanary> ContentChild::sShutdownCanary;
+
+ContentChild::ContentChild()
+    : mID(uint64_t(-1)),
+      mIsForBrowser(false),
+      mIsAlive(true),
+      mShuttingDown(false) {
+  // This process is a content process, so it's clearly running in
+  // multiprocess mode!
+  nsDebugImpl::SetMultiprocessMode("Child");
+
+  // Our static analysis doesn't allow capturing ref-counted pointers in
+  // lambdas, so we need to hide it in a uintptr_t. This is safe because this
+  // lambda will be destroyed in ~ContentChild().
+  uintptr_t self = reinterpret_cast<uintptr_t>(this);
+  profiler_add_state_change_callback(
+      AllProfilingStates(),
+      [self](ProfilingState aProfilingState) {
+        const ContentChild* selfPtr =
+            reinterpret_cast<const ContentChild*>(self);
+        PROFILER_MARKER("Process Priority", OTHER,
+                        mozilla::MarkerThreadId::MainThread(), ProcessPriority,
+                        ProfilerString8View::WrapNullTerminatedString(
+                            ProcessPriorityToString(selfPtr->mProcessPriority)),
+                        aProfilingState);
+      },
+      self);
+
+  // When ContentChild is created, the observer service does not even exist.
+  // When ContentChild::RecvSetXPCOMProcessAttributes is called (the first
+  // IPDL call made on this object), shutdown may have already happened. Thus
+  // we create a canary here that relies upon getting cleared if shutdown
+  // happens without requiring the observer service at this time.
+  if (!sShutdownCanary) {
+    sShutdownCanary = new ShutdownCanary();
+    ClearOnShutdown(&sShutdownCanary, ShutdownPhase::XPCOMShutdown);
+  }
+}
+
+#ifdef _MSC_VER
+#  pragma warning(push)
+#  pragma warning(                                                      \
+          disable : 4722) /* Silence "destructor never returns" warning \
+                           */
+#endif
+
+ContentChild::~ContentChild() {
+  profiler_remove_state_change_callback(reinterpret_cast<uintptr_t>(this));
+
+#ifndef NS_FREE_PERMANENT_DATA
+  MOZ_CRASH("Content Child shouldn't be destroyed.");
+#endif
+}
+
+#ifdef _MSC_VER
+#  pragma warning(pop)
+#endif
+
+NS_INTERFACE_MAP_BEGIN(ContentChild)
+  NS_INTERFACE_MAP_ENTRY(nsIDOMProcessChild)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMProcessChild)
+NS_INTERFACE_MAP_END
+
+mozilla::ipc::IPCResult ContentChild::RecvSetXPCOMProcessAttributes(
+    XPCOMInitData&& aXPCOMInit, const StructuredCloneData& aInitialData,
+    FullLookAndFeel&& aLookAndFeelData, dom::SystemFontList&& aFontList,
+    Maybe<SharedMemoryHandle>&& aSharedUASheetHandle,
+    const uintptr_t& aSharedUASheetAddress,
+    nsTArray<SharedMemoryHandle>&& aSharedFontListBlocks,
+    const bool& aIsReadyForBackgroundProcessing) {
+  if (!sShutdownCanary) {
+    return IPC_OK();
+  }
+
+  mLookAndFeelData = std::move(aLookAndFeelData);
+  mFontList = std::move(aFontList);
+  mSharedFontListBlocks = std::move(aSharedFontListBlocks);
+
+  gfx::gfxVars::SetValuesForInitialize(aXPCOMInit.gfxNonDefaultVarUpdates());
+  PerfStats::SetCollectionMask(aXPCOMInit.perfStatsMask());
+  InitSharedUASheets(std::move(aSharedUASheetHandle), aSharedUASheetAddress);
+  InitXPCOM(std::move(aXPCOMInit), aInitialData,
+            aIsReadyForBackgroundProcessing);
+  InitGraphicsDeviceData(aXPCOMInit.contentDeviceData());
+  RefPtr<net::ChildDNSService> dnsServiceChild =
+      dont_AddRef(net::ChildDNSService::GetSingleton());
+  if (dnsServiceChild) {
+    dnsServiceChild->SetTRRDomain(aXPCOMInit.trrDomain());
+    dnsServiceChild->SetTRRModeInChild(aXPCOMInit.trrMode(),
+                                       aXPCOMInit.trrModeFromPref());
+  }
+  return IPC_OK();
+}
+
+class nsGtkNativeInitRunnable : public Runnable {
+ public:
+  nsGtkNativeInitRunnable() : Runnable("nsGtkNativeInitRunnable") {}
+
+  NS_IMETHOD Run() override {
+    LookAndFeel::NativeInit();
+    return NS_OK;
+  }
+};
+
+void ContentChild::Init(mozilla::ipc::UntypedEndpoint&& aEndpoint,
+                        const char* aParentBuildID, uint64_t aChildID,
+                        bool aIsForBrowser) {
+#ifdef MOZ_WIDGET_GTK
+  // When running X11 only build we need to pass a display down
+  // to gtk_init because it's not going to use the one from the environment
+  // on its own when deciding which backend to use, and when starting under
+  // XWayland, it may choose to start with the wayland backend
+  // instead of the x11 backend.
+  // The DISPLAY environment variable is normally set by the parent process.
+  // The MOZ_GDK_DISPLAY environment variable is set from nsAppRunner.cpp
+  // when --display is set by the command line.
+  if (!gfxPlatform::IsHeadless()) {
+    const char* display_name = PR_GetEnv("MOZ_GDK_DISPLAY");
+    if (!display_name) {
+      bool waylandEnabled = false;
+#  ifdef MOZ_WAYLAND
+      waylandEnabled = IsWaylandEnabled();
+#  endif
+      if (!waylandEnabled) {
+        display_name = PR_GetEnv("DISPLAY");
+      }
+    }
+    if (display_name) {
+      int argc = 3;
+      char option_name[] = "--display";
+      char* argv[] = {
+          // argv0 is unused because g_set_prgname() was called in
+          // XRE_InitChildProcess().
+          nullptr, option_name, const_cast<char*>(display_name), nullptr};
+      char** argvp = argv;
+      gtk_init(&argc, &argvp);
+    } else {
+      gtk_init(nullptr, nullptr);
+    }
+  }
+#endif
+
+#ifdef MOZ_X11
+  if (!gfxPlatform::IsHeadless()) {
+    // Do this after initializing GDK, or GDK will install its own handler.
+    XRE_InstallX11ErrorHandler();
+  }
+#endif
+
+  MOZ_ASSERT(!sSingleton, "only one ContentChild per child");
+
+  // Once we start sending IPC messages, we need the thread manager to be
+  // initialized so we can deal with the responses. Do that here before we
+  // try to construct the crash reporter.
+  nsresult rv = nsThreadManager::get().Init();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    MOZ_CRASH("Failed to initialize the thread manager in ContentChild::Init");
+  }
+
+  if (!aEndpoint.Bind(this)) {
+    MOZ_CRASH("Bind failed in ContentChild::Init");
+  }
+  sSingleton = this;
+
+  // If communications with the parent have broken down, take the process
+  // down so it's not hanging around.
+  GetIPCChannel()->SetAbortOnError(true);
+
+  // This must be checked before any IPDL message, which may hit sentinel
+  // errors due to parent and content processes having different
+  // versions.
+  MessageChannel* channel = GetIPCChannel();
+  if (channel && !channel->SendBuildIDsMatchMessage(aParentBuildID)) {
+    // We need to quit this process if the buildID doesn't match the parent's.
+    // This can occur when an update occurred in the background.
+    ProcessChild::QuickExit();
+  }
+
+#if defined(__OpenBSD__) && defined(MOZ_SANDBOX)
+  StartOpenBSDSandbox(GeckoProcessType_Content);
+#endif
+
+#ifdef MOZ_X11
+#  ifdef MOZ_WIDGET_GTK
+  if (GdkIsX11Display() && !gfxPlatform::IsHeadless()) {
+    // Send the parent our X socket to act as a proxy reference for our X
+    // resources.
+    int xSocketFd = ConnectionNumber(DefaultXDisplay());
+    SendBackUpXResources(FileDescriptor(xSocketFd));
+  }
+#  endif
+#endif
+
+  CrashReporterClient::InitSingleton(this);
+
+  mID = aChildID;
+  mIsForBrowser = aIsForBrowser;
+
+  SetProcessName("Web Content"_ns);
+
+#ifdef NIGHTLY_BUILD
+  // NOTE: We have to register the annotator on the main thread, as annotators
+  // only affect a single thread.
+  SchedulerGroup::Dispatch(
+      TaskCategory::Other,
+      NS_NewRunnableFunction("RegisterPendingInputEventHangAnnotator", [] {
+        BackgroundHangMonitor::RegisterAnnotator(
+            PendingInputEventHangAnnotator::sSingleton);
+      }));
+#endif
+}
+
+void ContentChild::AddProfileToProcessName(const nsACString& aProfile) {
+  nsCOMPtr<nsIPrincipal> isolationPrincipal =
+      ContentParent::CreateRemoteTypeIsolationPrincipal(mRemoteType);
+  if (isolationPrincipal) {
+    // DEFAULT_PRIVATE_BROWSING_ID is the value when it's not private
+    if (isolationPrincipal->OriginAttributesRef().mPrivateBrowsingId !=
+        nsIScriptSecurityManager::DEFAULT_PRIVATE_BROWSING_ID) {
+      return;
+    }
+  }
+
+  mProcessName = aProfile + ":"_ns + mProcessName;  //<profile_name>:example.com
+}
+
+void ContentChild::SetProcessName(const nsACString& aName,
+                                  const nsACString* aSite,
+                                  const nsACString* aCurrentProfile) {
+  char* name;
+  if ((name = PR_GetEnv("MOZ_DEBUG_APP_PROCESS")) && aName.EqualsASCII(name)) {
+#ifdef OS_POSIX
+    printf_stderr("\n\nCHILDCHILDCHILDCHILD\n  [%s] debug me @%d\n\n", name,
+                  getpid());
+    sleep(30);
+#elif defined(OS_WIN)
+    // Windows has a decent JIT debugging story, so NS_DebugBreak does the
+    // right thing.
+    NS_DebugBreak(NS_DEBUG_BREAK,
+                  "Invoking NS_DebugBreak() to debug child process", nullptr,
+                  __FILE__, __LINE__);
+#endif
+  }
+
+  if (aSite) {
+    profiler_set_process_name(aName, aSite);
+  } else {
+    profiler_set_process_name(aName);
+  }
+
+  mProcessName = aName;
+
+  // Requires pref flip
+  if (aSite && StaticPrefs::fission_processSiteNames()) {
+    nsCOMPtr<nsIPrincipal> isolationPrincipal =
+        ContentParent::CreateRemoteTypeIsolationPrincipal(mRemoteType);
+    if (isolationPrincipal) {
+      // DEFAULT_PRIVATE_BROWSING_ID is the value when it's not private
+      MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+              ("private = %d, pref = %d",
+               isolationPrincipal->OriginAttributesRef().mPrivateBrowsingId !=
+                   nsIScriptSecurityManager::DEFAULT_PRIVATE_BROWSING_ID,
+               StaticPrefs::fission_processPrivateWindowSiteNames()));
+      if (isolationPrincipal->OriginAttributesRef().mPrivateBrowsingId ==
+              nsIScriptSecurityManager::DEFAULT_PRIVATE_BROWSING_ID
+#ifdef NIGHTLY_BUILD
+          // Nightly can show site names for private windows, with a second pref
+          || StaticPrefs::fission_processPrivateWindowSiteNames()
+#endif
+      ) {
+#if !defined(XP_MACOSX)
+        // Mac doesn't have the 15-character limit Linux does
+        // Sets profiler process name
+        if (isolationPrincipal->SchemeIs("https")) {
+          nsAutoCString schemeless;
+          isolationPrincipal->GetHostPort(schemeless);
+          nsAutoCString originSuffix;
+          isolationPrincipal->GetOriginSuffix(originSuffix);
+          schemeless.Append(originSuffix);
+          mProcessName = schemeless;
+        } else
+#endif
+        {
+          mProcessName = *aSite;
+        }
+      }
+    }
+  }
+
+  if (StaticPrefs::fission_processProfileName() && aCurrentProfile &&
+      !aCurrentProfile->IsEmpty()) {
+    AddProfileToProcessName(*aCurrentProfile);
+  }
+
+  // else private window, don't change process name, or the pref isn't set
+  // mProcessName is always flat (mProcessName == aName)
+
+  mozilla::ipc::SetThisProcessName(mProcessName.get());
+
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+          ("Changed name of process %d to %s", getpid(),
+           PromiseFlatCString(mProcessName).get()));
+}
+
+static nsresult GetCreateWindowParams(nsIOpenWindowInfo* aOpenWindowInfo,
+                                      nsDocShellLoadState* aLoadState,
+                                      bool aForceNoReferrer,
+                                      nsIReferrerInfo** aReferrerInfo,
+                                      nsIPrincipal** aTriggeringPrincipal,
+                                      nsIContentSecurityPolicy** aCsp) {
+  if (!aTriggeringPrincipal || !aCsp) {
+    NS_ERROR("aTriggeringPrincipal || aCsp is null");
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!aReferrerInfo) {
+    NS_ERROR("aReferrerInfo is null");
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIReferrerInfo> referrerInfo;
+  if (aForceNoReferrer) {
+    referrerInfo = new ReferrerInfo(nullptr, ReferrerPolicy::_empty, false);
+  }
+  if (aLoadState && !referrerInfo) {
+    referrerInfo = aLoadState->GetReferrerInfo();
+  }
+
+  RefPtr<BrowsingContext> parent = aOpenWindowInfo->GetParent();
+  nsCOMPtr<nsPIDOMWindowOuter> opener =
+      parent ? parent->GetDOMWindow() : nullptr;
+  if (!opener) {
+    nsCOMPtr<nsIPrincipal> nullPrincipal =
+        NullPrincipal::Create(aOpenWindowInfo->GetOriginAttributes());
+    if (!referrerInfo) {
+      referrerInfo = new ReferrerInfo(nullptr, ReferrerPolicy::_empty);
+    }
+
+    referrerInfo.swap(*aReferrerInfo);
+    NS_ADDREF(*aTriggeringPrincipal = nullPrincipal);
+    return NS_OK;
+  }
+
+  nsCOMPtr<Document> doc = opener->GetDoc();
+  NS_ADDREF(*aTriggeringPrincipal = doc->NodePrincipal());
+
+  nsCOMPtr<nsIContentSecurityPolicy> csp = doc->GetCsp();
+  if (csp) {
+    csp.forget(aCsp);
+  }
+
+  nsCOMPtr<nsIURI> baseURI = doc->GetDocBaseURI();
+  if (!baseURI) {
+    NS_ERROR("Document didn't return a base URI");
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!referrerInfo) {
+    referrerInfo = new ReferrerInfo(*doc);
+  }
+
+  referrerInfo.swap(*aReferrerInfo);
+  return NS_OK;
+}
+
+nsresult ContentChild::ProvideWindowCommon(
+    NotNull<BrowserChild*> aTabOpener, nsIOpenWindowInfo* aOpenWindowInfo,
+    uint32_t aChromeFlags, bool aCalledFromJS, nsIURI* aURI,
+    const nsAString& aName, const nsACString& aFeatures, bool aForceNoOpener,
+    bool aForceNoReferrer, bool aIsPopupRequested,
+    nsDocShellLoadState* aLoadState, bool* aWindowIsNew,
+    BrowsingContext** aReturn) {
+  *aReturn = nullptr;
+
+  nsAutoCString features(aFeatures);
+  nsAutoString name(aName);
+
+  nsresult rv;
+
+  RefPtr<BrowsingContext> parent = aOpenWindowInfo->GetParent();
+  MOZ_DIAGNOSTIC_ASSERT(parent, "We must have a parent BC");
+
+  // Block the attempt to open a new window if the opening BrowsingContext is
+  // not marked to use remote tabs. This ensures that the newly opened window is
+  // correctly remote.
+  if (NS_WARN_IF(!parent->UseRemoteTabs())) {
+    return NS_ERROR_ABORT;
+  }
+
+  bool useRemoteSubframes =
+      aChromeFlags & nsIWebBrowserChrome::CHROME_FISSION_WINDOW;
+
+  uint32_t parentSandboxFlags = parent->SandboxFlags();
+  if (Document* doc = parent->GetDocument()) {
+    parentSandboxFlags = doc->GetSandboxFlags();
+  }
+
+  // Certain conditions complicate the process of creating the new
+  // BrowsingContext, and prevent us from using the
+  // "CreateWindowInDifferentProcess" codepath.
+  //  * With Fission enabled, process selection will happen during the load, so
+  //    switching processes eagerly will not provide a benefit.
+  //  * Windows created for printing must be created within the current process
+  //    so that a static clone of the source document can be created.
+  //  * Sandboxed popups require the full window creation codepath.
+  //  * Loads with form or POST data require the full window creation codepath.
+  bool cannotLoadInDifferentProcess =
+      useRemoteSubframes || aOpenWindowInfo->GetIsForPrinting() ||
+      (parentSandboxFlags &
+       SANDBOX_PROPAGATES_TO_AUXILIARY_BROWSING_CONTEXTS) ||
+      (aLoadState &&
+       (aLoadState->IsFormSubmission() || aLoadState->PostDataStream()));
+  if (!cannotLoadInDifferentProcess) {
+    // If we're in a content process and we have noopener set, there's no reason
+    // to load in our process, so let's load it elsewhere!
+    bool loadInDifferentProcess =
+        aForceNoOpener && StaticPrefs::dom_noopener_newprocess_enabled();
+    if (loadInDifferentProcess) {
+      nsCOMPtr<nsIPrincipal> triggeringPrincipal;
+      nsCOMPtr<nsIContentSecurityPolicy> csp;
+      nsCOMPtr<nsIReferrerInfo> referrerInfo;
+      rv = GetCreateWindowParams(aOpenWindowInfo, aLoadState, aForceNoReferrer,
+                                 getter_AddRefs(referrerInfo),
+                                 getter_AddRefs(triggeringPrincipal),
+                                 getter_AddRefs(csp));
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+
+      if (name.LowerCaseEqualsLiteral("_blank")) {
+        name.Truncate();
+      }
+
+      MOZ_DIAGNOSTIC_ASSERT(!nsContentUtils::IsSpecialName(name));
+
+      Unused << SendCreateWindowInDifferentProcess(
+          aTabOpener, parent, aChromeFlags, aCalledFromJS, aURI, features, name,
+          triggeringPrincipal, csp, referrerInfo,
+          aOpenWindowInfo->GetOriginAttributes());
+
+      // We return NS_ERROR_ABORT, so that the caller knows that we've abandoned
+      // the window open as far as it is concerned.
+      return NS_ERROR_ABORT;
+    }
+  }
+
+  TabId tabId(nsContentUtils::GenerateTabId());
+
+  // We need to assign a TabGroup to the PBrowser actor before we send it to the
+  // parent. Otherwise, the parent could send messages to us before we have a
+  // proper TabGroup for that actor.
+  RefPtr<BrowsingContext> openerBC;
+  if (!aForceNoOpener) {
+    openerBC = parent;
+  }
+
+  RefPtr<BrowsingContext> browsingContext = BrowsingContext::CreateDetached(
+      nullptr, openerBC, nullptr, aName, BrowsingContext::Type::Content,
+      aIsPopupRequested);
+  MOZ_ALWAYS_SUCCEEDS(browsingContext->SetRemoteTabs(true));
+  MOZ_ALWAYS_SUCCEEDS(browsingContext->SetRemoteSubframes(useRemoteSubframes));
+  MOZ_ALWAYS_SUCCEEDS(browsingContext->SetOriginAttributes(
+      aOpenWindowInfo->GetOriginAttributes()));
+
+  browsingContext->InitPendingInitialization(true);
+  auto unsetPending = MakeScopeExit([browsingContext]() {
+    Unused << browsingContext->SetPendingInitialization(false);
+  });
+
+  browsingContext->EnsureAttached();
+
+  // The initial about:blank document we generate within the nsDocShell will
+  // almost certainly be replaced at some point. Unfortunately, getting the
+  // principal right here causes bugs due to frame scripts not getting events
+  // they expect, due to the real initial about:blank not being created yet.
+  //
+  // For this reason, we intentionally mispredict the initial principal here, so
+  // that we can act the same as we did before when not predicting a result
+  // principal. This `PWindowGlobal` will almost immediately be destroyed.
+  nsCOMPtr<nsIPrincipal> initialPrincipal =
+      NullPrincipal::Create(browsingContext->OriginAttributesRef());
+  WindowGlobalInit windowInit = WindowGlobalActor::AboutBlankInitializer(
+      browsingContext, initialPrincipal);
+
+  RefPtr<WindowGlobalChild> windowChild =
+      WindowGlobalChild::CreateDisconnected(windowInit);
+  if (NS_WARN_IF(!windowChild)) {
+    return NS_ERROR_ABORT;
+  }
+
+  auto newChild = MakeNotNull<RefPtr<BrowserChild>>(
+      this, tabId, *aTabOpener, browsingContext, aChromeFlags,
+      /* aIsTopLevel */ true);
+
+  if (IsShuttingDown()) {
+    return NS_ERROR_ABORT;
+  }
+
+  // Open a remote endpoint for our PBrowser actor.
+  ManagedEndpoint<PBrowserParent> parentEp = OpenPBrowserEndpoint(newChild);
+  if (NS_WARN_IF(!parentEp.IsValid())) {
+    return NS_ERROR_ABORT;
+  }
+
+  // Open a remote endpoint for our PWindowGlobal actor.
+  ManagedEndpoint<PWindowGlobalParent> windowParentEp =
+      newChild->OpenPWindowGlobalEndpoint(windowChild);
+  if (NS_WARN_IF(!windowParentEp.IsValid())) {
+    return NS_ERROR_ABORT;
+  }
+
+  // Tell the parent process to set up its PBrowserParent.
+  PopupIPCTabContext ipcContext(aTabOpener, 0);
+  if (NS_WARN_IF(!SendConstructPopupBrowser(
+          std::move(parentEp), std::move(windowParentEp), tabId, ipcContext,
+          windowInit, aChromeFlags))) {
+    return NS_ERROR_ABORT;
+  }
+
+  windowChild->Init();
+  auto guardNullWindowGlobal = MakeScopeExit([&] {
+    if (!windowChild->GetWindowGlobal()) {
+      windowChild->Destroy();
+    }
+  });
+
+  // Now that |newChild| has had its IPC link established, call |Init| to set it
+  // up.
+  // XXX: This MOZ_KnownLive is only necessary because the static analysis can't
+  // tell that NotNull<RefPtr<BrowserChild>> is a strong pointer.
+  RefPtr<nsPIDOMWindowOuter> parentWindow =
+      parent ? parent->GetDOMWindow() : nullptr;
+  if (NS_FAILED(MOZ_KnownLive(newChild)->Init(parentWindow, windowChild))) {
+    return NS_ERROR_ABORT;
+  }
+
+  // Set to true when we're ready to return from this function.
+  bool ready = false;
+
+  // NOTE: Capturing by reference here is safe, as this function won't return
+  // until one of these callbacks is called.
+  auto resolve = [&](CreatedWindowInfo&& info) {
+    MOZ_RELEASE_ASSERT(NS_IsMainThread());
+    rv = info.rv();
+    *aWindowIsNew = info.windowOpened();
+    nsTArray<FrameScriptInfo> frameScripts(std::move(info.frameScripts()));
+    uint32_t maxTouchPoints = info.maxTouchPoints();
+    DimensionInfo dimensionInfo = std::move(info.dimensions());
+
+    // Once this function exits, we should try to exit the nested event loop.
+    ready = true;
+
+    // NOTE: We have to handle this immediately in the resolve callback in order
+    // to make sure that we don't process any more IPC messages before returning
+    // from ProvideWindowCommon.
+
+    // Handle the error which we got back from the parent process, if we got
+    // one.
+    if (NS_FAILED(rv)) {
+      return;
+    }
+
+    if (!*aWindowIsNew) {
+      rv = NS_ERROR_ABORT;
+      return;
+    }
+
+    // If the BrowserChild has been torn down, we don't need to do this anymore.
+    if (NS_WARN_IF(!newChild->IPCOpen() || newChild->IsDestroyed())) {
+      rv = NS_ERROR_ABORT;
+      return;
+    }
+
+    ParentShowInfo showInfo(u""_ns, /* fakeShowInfo = */ true,
+                            /* isTransparent = */ false,
+                            newChild->WebWidget()->GetDPI(),
+                            newChild->WebWidget()->RoundsWidgetCoordinatesTo(),
+                            newChild->WebWidget()->GetDefaultScale().scale);
+
+    newChild->SetMaxTouchPoints(maxTouchPoints);
+
+    if (aForceNoOpener || !parent) {
+      MOZ_DIAGNOSTIC_ASSERT(!browsingContext->HadOriginalOpener());
+      MOZ_DIAGNOSTIC_ASSERT(browsingContext->GetOpenerId() == 0);
+    } else {
+      MOZ_DIAGNOSTIC_ASSERT(browsingContext->HadOriginalOpener());
+      MOZ_DIAGNOSTIC_ASSERT(browsingContext->GetOpenerId() == parent->Id());
+    }
+
+    // Unfortunately we don't get a window unless we've shown the frame.  That's
+    // pretty bogus; see bug 763602.
+    newChild->DoFakeShow(showInfo);
+
+    newChild->RecvUpdateDimensions(dimensionInfo);
+
+    for (size_t i = 0; i < frameScripts.Length(); i++) {
+      FrameScriptInfo& info = frameScripts[i];
+      if (!newChild->RecvLoadRemoteScript(info.url(),
+                                          info.runInGlobalScope())) {
+        MOZ_CRASH();
+      }
+    }
+
+    if (xpc::IsInAutomation()) {
+      if (nsCOMPtr<nsPIDOMWindowOuter> outer =
+              do_GetInterface(newChild->WebNavigation())) {
+        nsCOMPtr<nsIObserverService> obs(services::GetObserverService());
+        obs->NotifyObservers(
+            outer, "dangerous:test-only:new-browser-child-ready", nullptr);
+      }
+    }
+
+    browsingContext.forget(aReturn);
+  };
+
+  // NOTE: Capturing by reference here is safe, as this function won't return
+  // until one of these callbacks is called.
+  auto reject = [&](ResponseRejectReason) {
+    MOZ_RELEASE_ASSERT(NS_IsMainThread());
+    NS_WARNING("windowCreated promise rejected");
+    rv = NS_ERROR_NOT_AVAILABLE;
+    ready = true;
+  };
+
+  // Send down the request to open the window.
+  nsCOMPtr<nsIPrincipal> triggeringPrincipal;
+  nsCOMPtr<nsIContentSecurityPolicy> csp;
+  nsCOMPtr<nsIReferrerInfo> referrerInfo;
+  rv = GetCreateWindowParams(aOpenWindowInfo, aLoadState, aForceNoReferrer,
+                             getter_AddRefs(referrerInfo),
+                             getter_AddRefs(triggeringPrincipal),
+                             getter_AddRefs(csp));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  SendCreateWindow(aTabOpener, parent, newChild, aChromeFlags, aCalledFromJS,
+                   aOpenWindowInfo->GetIsForPrinting(),
+                   aOpenWindowInfo->GetIsForWindowDotPrint(), aURI, features,
+                   triggeringPrincipal, csp, referrerInfo,
+                   aOpenWindowInfo->GetOriginAttributes(), std::move(resolve),
+                   std::move(reject));
+
+  // =======================
+  // Begin Nested Event Loop
+  // =======================
+
+  // We have to wait for a response from SendCreateWindow or with information
+  // we're going to need to return from this function, So we spin a nested event
+  // loop until they get back to us.
+
+  {
+    // Suppress event handling for all contexts in our BrowsingContextGroup so
+    // that event handlers cannot target our new window while it's still being
+    // opened. Note that pending events that were suppressed while our blocker
+    // was active will be dispatched asynchronously from a runnable dispatched
+    // to the main event loop after this function returns, not immediately when
+    // we leave this scope.
+    AutoSuppressEventHandlingAndSuspend seh(browsingContext->Group());
+
+    AutoNoJSAPI nojsapi;
+
+    // Spin the event loop until we get a response. Callers of this function
+    // already have to guard against an inner event loop spinning in the
+    // non-e10s case because of the need to spin one to create a new chrome
+    // window.
+    SpinEventLoopUntil("ContentChild::ProvideWindowCommon"_ns,
+                       [&]() { return ready; });
+    MOZ_RELEASE_ASSERT(ready,
+                       "We are on the main thread, so we should not exit this "
+                       "loop without ready being true.");
+  }
+
+  // =====================
+  // End Nested Event Loop
+  // =====================
+
+  // It's possible for our new BrowsingContext to become discarded during the
+  // nested event loop, in which case we shouldn't return it, since our callers
+  // will generally not be prepared to deal with that.
+  if (*aReturn && (*aReturn)->IsDiscarded()) {
+    NS_RELEASE(*aReturn);
+    return NS_ERROR_ABORT;
+  }
+
+  // We should have the results already set by the callbacks.
+  MOZ_ASSERT_IF(NS_SUCCEEDED(rv), *aReturn);
+  return rv;
+}
+
+bool ContentChild::IsAlive() const { return mIsAlive; }
+
+bool ContentChild::IsShuttingDown() const { return mShuttingDown; }
+
+void ContentChild::GetProcessName(nsACString& aName) const {
+  aName = mProcessName;
+}
+
+/* static */
+void ContentChild::AppendProcessId(nsACString& aName) {
+  if (!aName.IsEmpty()) {
+    aName.Append(' ');
+  }
+  unsigned pid = getpid();
+  aName.Append(nsPrintfCString("(pid %u)", pid));
+}
+
+void ContentChild::InitGraphicsDeviceData(const ContentDeviceData& aData) {
+  gfxPlatform::InitChild(aData);
+}
+
+void ContentChild::InitSharedUASheets(Maybe<SharedMemoryHandle>&& aHandle,
+                                      uintptr_t aAddress) {
+  MOZ_ASSERT_IF(!aHandle, !aAddress);
+
+  if (!aAddress) {
+    return;
+  }
+
+  // Map the shared memory storing the user agent style sheets.  Do this as
+  // early as possible to maximize the chance of being able to map at the
+  // address we want.
+  GlobalStyleSheetCache::SetSharedMemory(std::move(*aHandle), aAddress);
+}
+
+void ContentChild::InitXPCOM(
+    XPCOMInitData&& aXPCOMInit,
+    const mozilla::dom::ipc::StructuredCloneData& aInitialData,
+    bool aIsReadyForBackgroundProcessing) {
+#ifdef MOZ_WIDGET_GTK
+  // LookAndFeel::NativeInit takes a long time to run on Linux, here we schedule
+  // it as soon as possible after BackgroundChild::Startup to give
+  // it chance to run ahead of ConstructBrowser
+  nsCOMPtr<nsIRunnable> event = new nsGtkNativeInitRunnable();
+  NS_DispatchToMainThreadQueue(event.forget(), EventQueuePriority::Idle);
+#endif
+
+#if defined(XP_WIN)
+  // DLL services untrusted modules processing depends on
+  // BackgroundChild::Startup having been called
+  RefPtr<DllServices> dllSvc(DllServices::Get());
+  dllSvc->StartUntrustedModulesProcessor(aIsReadyForBackgroundProcessing);
+#endif  // defined(XP_WIN)
+
+  PBackgroundChild* actorChild = BackgroundChild::GetOrCreateForCurrentThread();
+  if (NS_WARN_IF(!actorChild)) {
+    MOZ_ASSERT_UNREACHABLE("PBackground init can't fail at this point");
+    return;
+  }
+
+  ClientManager::Startup();
+
+  // RemoteWorkerService will be initialized in RecvRemoteType, to avoid to
+  // register it to the RemoteWorkerManager while it is still a prealloc
+  // remoteType and defer it to the point the child process is assigned a.
+  // actual remoteType.
+
+  nsCOMPtr<nsIConsoleService> svc(do_GetService(NS_CONSOLESERVICE_CONTRACTID));
+  if (!svc) {
+    NS_WARNING("Couldn't acquire console service");
+    return;
+  }
+
+  mConsoleListener = new ConsoleListener(this);
+  if (NS_FAILED(svc->RegisterListener(mConsoleListener)))
+    NS_WARNING("Couldn't register console listener for child process");
+
+  mAvailableDictionaries = std::move(aXPCOMInit.dictionaries());
+
+  RecvSetOffline(aXPCOMInit.isOffline());
+  RecvSetConnectivity(aXPCOMInit.isConnected());
+
+  LocaleService::GetInstance()->AssignAppLocales(aXPCOMInit.appLocales());
+  LocaleService::GetInstance()->AssignRequestedLocales(
+      aXPCOMInit.requestedLocales());
+
+  L10nRegistry::RegisterFileSourcesFromParentProcess(
+      aXPCOMInit.l10nFileSources());
+
+  RecvSetCaptivePortalState(aXPCOMInit.captivePortalState());
+  RecvBidiKeyboardNotify(aXPCOMInit.isLangRTL(),
+                         aXPCOMInit.haveBidiKeyboards());
+
+  if (aXPCOMInit.domainPolicy().active()) {
+    nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
+    MOZ_ASSERT(ssm);
+    ssm->ActivateDomainPolicyInternal(getter_AddRefs(mPolicy));
+    if (!mPolicy) {
+      MOZ_CRASH("Failed to activate domain policy.");
+    }
+    mPolicy->ApplyClone(&aXPCOMInit.domainPolicy());
+  }
+
+  nsCOMPtr<nsIClipboard> clipboard(
+      do_GetService("@mozilla.org/widget/clipboard;1"));
+  if (nsCOMPtr<nsIClipboardProxy> clipboardProxy =
+          do_QueryInterface(clipboard)) {
+    clipboardProxy->SetCapabilities(aXPCOMInit.clipboardCaps());
+  }
+
+  {
+    AutoJSAPI jsapi;
+    if (NS_WARN_IF(!jsapi.Init(xpc::PrivilegedJunkScope()))) {
+      MOZ_CRASH();
+    }
+    ErrorResult rv;
+    JS::Rooted<JS::Value> data(jsapi.cx());
+    mozilla::dom::ipc::StructuredCloneData id;
+    id.Copy(aInitialData);
+    id.Read(jsapi.cx(), &data, rv);
+    if (NS_WARN_IF(rv.Failed())) {
+      MOZ_CRASH();
+    }
+    auto* global = ContentProcessMessageManager::Get();
+    global->SetInitialProcessData(data);
+  }
+
+  // The stylesheet cache is not ready yet. Store this URL for future use.
+  nsCOMPtr<nsIURI> ucsURL = std::move(aXPCOMInit.userContentSheetURL());
+  GlobalStyleSheetCache::SetUserContentCSSURL(ucsURL);
+
+  GfxInfoBase::SetFeatureStatus(std::move(aXPCOMInit.gfxFeatureStatus()));
+
+  // Initialize the RemoteDecoderManager thread and its associated PBackground
+  // channel.
+  RemoteDecoderManagerChild::Init();
+
+  Preferences::RegisterCallbackAndCall(&OnFissionBlocklistPrefChange,
+                                       kFissionEnforceBlockList);
+  Preferences::RegisterCallbackAndCall(&OnFissionBlocklistPrefChange,
+                                       kFissionOmitBlockListValues);
+
+  // Set the dynamic scalar definitions for this process.
+  TelemetryIPC::AddDynamicScalarDefinitions(aXPCOMInit.dynamicScalarDefs());
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvRequestMemoryReport(
+    const uint32_t& aGeneration, const bool& aAnonymize,
+    const bool& aMinimizeMemoryUsage,
+    const Maybe<mozilla::ipc::FileDescriptor>& aDMDFile,
+    const RequestMemoryReportResolver& aResolver) {
+  nsCString process;
+  if (aAnonymize || mRemoteType.IsEmpty()) {
+    GetProcessName(process);
+  } else {
+    process = mRemoteType;
+  }
+  AppendProcessId(process);
+  MOZ_ASSERT(!process.IsEmpty());
+
+  MemoryReportRequestClient::Start(
+      aGeneration, aAnonymize, aMinimizeMemoryUsage, aDMDFile, process,
+      [&](const MemoryReport& aReport) {
+        Unused << GetSingleton()->SendAddMemoryReport(aReport);
+      },
+      aResolver);
+  return IPC_OK();
+}
+
+#if defined(XP_WIN)
+mozilla::ipc::IPCResult ContentChild::RecvGetUntrustedModulesData(
+    GetUntrustedModulesDataResolver&& aResolver) {
+  RefPtr<DllServices> dllSvc(DllServices::Get());
+  dllSvc->GetUntrustedModulesData()->Then(
+      GetMainThreadSerialEventTarget(), __func__,
+      [aResolver](Maybe<UntrustedModulesData>&& aData) {
+        aResolver(std::move(aData));
+      },
+      [aResolver](nsresult aReason) { aResolver(Nothing()); });
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvUnblockUntrustedModulesThread() {
+  if (nsCOMPtr<nsIObserverService> obs =
+          mozilla::services::GetObserverService()) {
+    obs->NotifyObservers(nullptr, "unblock-untrusted-modules-thread", nullptr);
+  }
+  return IPC_OK();
+}
+#endif  // defined(XP_WIN)
+
+PCycleCollectWithLogsChild* ContentChild::AllocPCycleCollectWithLogsChild(
+    const bool& aDumpAllTraces, const FileDescriptor& aGCLog,
+    const FileDescriptor& aCCLog) {
+  return do_AddRef(new CycleCollectWithLogsChild()).take();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvPCycleCollectWithLogsConstructor(
+    PCycleCollectWithLogsChild* aActor, const bool& aDumpAllTraces,
+    const FileDescriptor& aGCLog, const FileDescriptor& aCCLog) {
+  // The sink's destructor is called when the last reference goes away, which
+  // will cause the actor to be closed down.
+  auto* actor = static_cast<CycleCollectWithLogsChild*>(aActor);
+  RefPtr<CycleCollectWithLogsChild::Sink> sink =
+      new CycleCollectWithLogsChild::Sink(actor, aGCLog, aCCLog);
+
+  // Invoke the dumper, which will take a reference to the sink.
+  nsCOMPtr<nsIMemoryInfoDumper> dumper =
+      do_GetService("@mozilla.org/memory-info-dumper;1");
+  dumper->DumpGCAndCCLogsToSink(aDumpAllTraces, sink);
+  return IPC_OK();
+}
+
+bool ContentChild::DeallocPCycleCollectWithLogsChild(
+    PCycleCollectWithLogsChild* aActor) {
+  RefPtr<CycleCollectWithLogsChild> actor =
+      dont_AddRef(static_cast<CycleCollectWithLogsChild*>(aActor));
+  return true;
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvInitGMPService(
+    Endpoint<PGMPServiceChild>&& aGMPService) {
+  if (!GMPServiceChild::Create(std::move(aGMPService))) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvInitProfiler(
+    Endpoint<PProfilerChild>&& aEndpoint) {
+  mProfilerController = ChildProfilerController::Create(std::move(aEndpoint));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvGMPsChanged(
+    nsTArray<GMPCapabilityData>&& capabilities) {
+  GeckoMediaPluginServiceChild::UpdateGMPCapabilities(std::move(capabilities));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvInitProcessHangMonitor(
+    Endpoint<PProcessHangMonitorChild>&& aHangMonitor) {
+  CreateHangMonitorChild(std::move(aHangMonitor));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::GetResultForRenderingInitFailure(
+    base::ProcessId aOtherPid) {
+  if (aOtherPid == base::GetCurrentProcId() || aOtherPid == OtherPid()) {
+    // If we are talking to ourselves, or the UI process, then that is a fatal
+    // protocol error.
+    return IPC_FAIL_NO_REASON(this);
+  }
+
+  // If we are talking to the GPU process, then we should recover from this on
+  // the next ContentChild::RecvReinitRendering call.
+  gfxCriticalNote << "Could not initialize rendering with GPU process";
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvRequestPerformanceMetrics(
+    const nsID& aID) {
+  RefPtr<ContentChild> self = this;
+  RefPtr<AbstractThread> mainThread = AbstractThread::MainThread();
+  nsTArray<RefPtr<PerformanceInfoPromise>> promises = CollectPerformanceInfo();
+
+  PerformanceInfoPromise::All(mainThread, promises)
+      ->Then(
+          mainThread, __func__,
+          [self, aID](const nsTArray<mozilla::dom::PerformanceInfo>& aResult) {
+            self->SendAddPerformanceMetrics(aID, aResult);
+          },
+          []() { /* silently fails -- the parent times out
+                    and proceeds when the data is not coming back */
+          });
+
+  return IPC_OK();
+}
+
+#if defined(XP_MACOSX)
+extern "C" {
+void CGSShutdownServerConnections();
+};
+#endif
+
+mozilla::ipc::IPCResult ContentChild::RecvInitRendering(
+    Endpoint<PCompositorManagerChild>&& aCompositor,
+    Endpoint<PImageBridgeChild>&& aImageBridge,
+    Endpoint<PVRManagerChild>&& aVRBridge,
+    Endpoint<PRemoteDecoderManagerChild>&& aVideoManager,
+    nsTArray<uint32_t>&& namespaces) {
+  MOZ_ASSERT(namespaces.Length() == 3);
+
+  // Note that for all of the methods below, if it can fail, it should only
+  // return false if the failure is an IPDL error. In such situations,
+  // ContentChild can reason about whether or not to wait for
+  // RecvReinitRendering (because we surmised the GPU process crashed), or if it
+  // should crash itself (because we are actually talking to the UI process). If
+  // there are localized failures (e.g. failed to spawn a thread), then it
+  // should MOZ_RELEASE_ASSERT or MOZ_CRASH as necessary instead.
+  if (!CompositorManagerChild::Init(std::move(aCompositor), namespaces[0])) {
+    return GetResultForRenderingInitFailure(aCompositor.OtherPid());
+  }
+  if (!CompositorManagerChild::CreateContentCompositorBridge(namespaces[1])) {
+    return GetResultForRenderingInitFailure(aCompositor.OtherPid());
+  }
+  if (!ImageBridgeChild::InitForContent(std::move(aImageBridge),
+                                        namespaces[2])) {
+    return GetResultForRenderingInitFailure(aImageBridge.OtherPid());
+  }
+  if (!gfx::VRManagerChild::InitForContent(std::move(aVRBridge))) {
+    return GetResultForRenderingInitFailure(aVRBridge.OtherPid());
+  }
+  RemoteDecoderManagerChild::InitForGPUProcess(std::move(aVideoManager));
+
+#if defined(XP_MACOSX) && !defined(MOZ_SANDBOX)
+  // Close all current connections to the WindowServer. This ensures that the
+  // Activity Monitor will not label the content process as "Not responding"
+  // because it's not running a native event loop. See bug 1384336. When the
+  // build is configured with sandbox support, this is called during sandbox
+  // setup.
+  CGSShutdownServerConnections();
+#endif
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvReinitRendering(
+    Endpoint<PCompositorManagerChild>&& aCompositor,
+    Endpoint<PImageBridgeChild>&& aImageBridge,
+    Endpoint<PVRManagerChild>&& aVRBridge,
+    Endpoint<PRemoteDecoderManagerChild>&& aVideoManager,
+    nsTArray<uint32_t>&& namespaces) {
+  MOZ_ASSERT(namespaces.Length() == 3);
+  nsTArray<RefPtr<BrowserChild>> tabs = BrowserChild::GetAll();
+
+  // Re-establish singleton bridges to the compositor.
+  if (!CompositorManagerChild::Init(std::move(aCompositor), namespaces[0])) {
+    return GetResultForRenderingInitFailure(aCompositor.OtherPid());
+  }
+  if (!CompositorManagerChild::CreateContentCompositorBridge(namespaces[1])) {
+    return GetResultForRenderingInitFailure(aCompositor.OtherPid());
+  }
+  if (!ImageBridgeChild::ReinitForContent(std::move(aImageBridge),
+                                          namespaces[2])) {
+    return GetResultForRenderingInitFailure(aImageBridge.OtherPid());
+  }
+  if (!gfx::VRManagerChild::InitForContent(std::move(aVRBridge))) {
+    return GetResultForRenderingInitFailure(aVRBridge.OtherPid());
+  }
+  gfxPlatform::GetPlatform()->CompositorUpdated();
+
+  // Establish new PLayerTransactions.
+  for (const auto& browserChild : tabs) {
+    if (browserChild->GetLayersId().IsValid()) {
+      browserChild->ReinitRendering();
+    }
+  }
+
+  // Notify any observers that the compositor has been reinitialized,
+  // eg the ZoomConstraintsClients for documents in this process.
+  // This must occur after the ReinitRendering call above so that the
+  // APZCTreeManagers have been connected.
+  nsCOMPtr<nsIObserverService> observerService = services::GetObserverService();
+  if (observerService) {
+    observerService->NotifyObservers(nullptr, "compositor-reinitialized",
+                                     nullptr);
+  }
+
+  RemoteDecoderManagerChild::InitForGPUProcess(std::move(aVideoManager));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvReinitRenderingForDeviceReset() {
+  gfxPlatform::GetPlatform()->CompositorUpdated();
+
+  nsTArray<RefPtr<BrowserChild>> tabs = BrowserChild::GetAll();
+  for (const auto& browserChild : tabs) {
+    if (browserChild->GetLayersId().IsValid()) {
+      browserChild->ReinitRenderingForDeviceReset();
+    }
+  }
+  return IPC_OK();
+}
+
+#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
+extern "C" {
+CGError CGSSetDenyWindowServerConnections(bool);
+};
+
+static void DisconnectWindowServer(bool aIsSandboxEnabled) {
+  // Close all current connections to the WindowServer. This ensures that the
+  // Activity Monitor will not label the content process as "Not responding"
+  // because it's not running a native event loop. See bug 1384336.
+  // This is required with or without the sandbox enabled. Until the
+  // window server is blocked as the policy level, this should be called
+  // just before CGSSetDenyWindowServerConnections() so there are no
+  // windowserver connections active when CGSSetDenyWindowServerConnections()
+  // is called.
+  CGSShutdownServerConnections();
+
+  // Actual security benefits are only achieved when we additionally deny
+  // future connections using the sandbox policy. WebGL must be remoted if
+  // the windowserver connections are blocked. WebGL remoting is disabled
+  // for some tests.
+  if (aIsSandboxEnabled &&
+      Preferences::GetBool(
+          "security.sandbox.content.mac.disconnect-windowserver") &&
+      Preferences::GetBool("webgl.out-of-process")) {
+    CGError result = CGSSetDenyWindowServerConnections(true);
+    MOZ_DIAGNOSTIC_ASSERT(result == kCGErrorSuccess);
+#  if !MOZ_DIAGNOSTIC_ASSERT_ENABLED
+    Unused << result;
+#  endif
+  }
+}
+#endif
+
+mozilla::ipc::IPCResult ContentChild::RecvSetProcessSandbox(
+    const Maybe<mozilla::ipc::FileDescriptor>& aBroker) {
+  // We may want to move the sandbox initialization somewhere else
+  // at some point; see bug 880808.
+#if defined(MOZ_SANDBOX)
+
+  bool sandboxEnabled = true;
+#  if defined(XP_LINUX)
+  // On Linux, we have to support systems that can't use any sandboxing.
+  sandboxEnabled = SandboxInfo::Get().CanSandboxContent();
+
+  if (sandboxEnabled && !StaticPrefs::media_cubeb_sandbox()) {
+    // Pre-start audio before sandboxing; see bug 1443612.
+    Unused << CubebUtils::GetCubebContext();
+  }
+
+  if (sandboxEnabled) {
+    sandboxEnabled = SetContentProcessSandbox(
+        ContentProcessSandboxParams::ForThisProcess(aBroker));
+  }
+#  elif defined(XP_WIN)
+  mozilla::SandboxTarget::Instance()->StartSandbox();
+#  elif defined(XP_MACOSX)
+  sandboxEnabled = (GetEffectiveContentSandboxLevel() >= 1);
+  DisconnectWindowServer(sandboxEnabled);
+#  endif
+
+  CrashReporter::AnnotateCrashReport(
+      CrashReporter::Annotation::ContentSandboxEnabled, sandboxEnabled);
+#  if defined(XP_LINUX) && !defined(OS_ANDROID)
+  CrashReporter::AnnotateCrashReport(
+      CrashReporter::Annotation::ContentSandboxCapabilities,
+      static_cast<int>(SandboxInfo::Get().AsInteger()));
+#  endif /* XP_LINUX && !OS_ANDROID */
+#endif   /* MOZ_SANDBOX */
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvBidiKeyboardNotify(
+    const bool& aIsLangRTL, const bool& aHaveBidiKeyboards) {
+  // bidi is always of type PuppetBidiKeyboard* (because in the child, the only
+  // possible implementation of nsIBidiKeyboard is PuppetBidiKeyboard).
+  PuppetBidiKeyboard* bidi =
+      static_cast<PuppetBidiKeyboard*>(nsContentUtils::GetBidiKeyboard());
+  if (bidi) {
+    bidi->SetBidiKeyboardInfo(aIsLangRTL, aHaveBidiKeyboards);
+  }
+  return IPC_OK();
+}
+
+static StaticRefPtr<CancelableRunnable> gFirstIdleTask;
+
+static void FirstIdle(void) {
+  MOZ_ASSERT(gFirstIdleTask);
+  gFirstIdleTask = nullptr;
+
+  ContentChild::GetSingleton()->SendFirstIdle();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvConstructBrowser(
+    ManagedEndpoint<PBrowserChild>&& aBrowserEp,
+    ManagedEndpoint<PWindowGlobalChild>&& aWindowEp, const TabId& aTabId,
+    const IPCTabContext& aContext, const WindowGlobalInit& aWindowInit,
+    const uint32_t& aChromeFlags, const ContentParentId& aCpID,
+    const bool& aIsForBrowser, const bool& aIsTopLevel) {
+  MOZ_DIAGNOSTIC_ASSERT(!IsShuttingDown());
+
+  static bool hasRunOnce = false;
+  if (!hasRunOnce) {
+    hasRunOnce = true;
+    MOZ_ASSERT(!gFirstIdleTask);
+    RefPtr<CancelableRunnable> firstIdleTask =
+        NewCancelableRunnableFunction("FirstIdleRunnable", FirstIdle);
+    gFirstIdleTask = firstIdleTask;
+    if (NS_FAILED(NS_DispatchToCurrentThreadQueue(firstIdleTask.forget(),
+                                                  EventQueuePriority::Idle))) {
+      gFirstIdleTask = nullptr;
+      hasRunOnce = false;
+    }
+  }
+
+  RefPtr<BrowsingContext> browsingContext =
+      BrowsingContext::Get(aWindowInit.context().mBrowsingContextId);
+  if (!browsingContext || browsingContext->IsDiscarded()) {
+    nsPrintfCString reason("%s initial %s BrowsingContext",
+                           browsingContext ? "discarded" : "missing",
+                           aIsTopLevel ? "top" : "frame");
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Warning, ("%s", reason.get()));
+    if (!aIsTopLevel) {
+      // Recover if the BrowsingContext is missing for a new subframe. The
+      // `ManagedEndpoint` instances will be automatically destroyed.
+      NS_WARNING(reason.get());
+      return IPC_OK();
+    }
+    return IPC_FAIL(this, reason.get());
+  }
+
+  if (xpc::IsInAutomation() &&
+      StaticPrefs::
+          browser_tabs_remote_testOnly_failPBrowserCreation_enabled()) {
+    nsAutoCString idString;
+    if (NS_SUCCEEDED(Preferences::GetCString(
+            "browser.tabs.remote.testOnly.failPBrowserCreation.browsingContext",
+            idString))) {
+      nsresult rv = NS_OK;
+      uint64_t bcid = idString.ToInteger64(&rv);
+      if (NS_SUCCEEDED(rv) && bcid == browsingContext->Id()) {
+        NS_WARNING("Injecting artificial PBrowser creation failure");
+        return IPC_OK();
+      }
+    }
+  }
+
+  if (!aWindowInit.isInitialDocument() ||
+      !NS_IsAboutBlank(aWindowInit.documentURI())) {
+    return IPC_FAIL(this,
+                    "Logic in CreateContentViewerForActor currently requires "
+                    "actors to be initial about:blank documents");
+  }
+
+  // We'll happily accept any kind of IPCTabContext here; we don't need to
+  // check that it's of a certain type for security purposes, because we
+  // believe whatever the parent process tells us.
+  MaybeInvalidTabContext tc(aContext);
+  if (!tc.IsValid()) {
+    NS_ERROR(nsPrintfCString("Received an invalid TabContext from "
+                             "the parent process. (%s)  Crashing...",
+                             tc.GetInvalidReason())
+                 .get());
+    MOZ_CRASH("Invalid TabContext received from the parent process.");
+  }
+
+  RefPtr<WindowGlobalChild> windowChild =
+      WindowGlobalChild::CreateDisconnected(aWindowInit);
+  if (!windowChild) {
+    return IPC_FAIL(this, "Failed to create initial WindowGlobalChild");
+  }
+
+  RefPtr<BrowserChild> browserChild =
+      BrowserChild::Create(this, aTabId, tc.GetTabContext(), browsingContext,
+                           aChromeFlags, aIsTopLevel);
+
+  // Bind the created BrowserChild to IPC to actually link the actor.
+  if (NS_WARN_IF(!BindPBrowserEndpoint(std::move(aBrowserEp), browserChild))) {
+    return IPC_FAIL(this, "BindPBrowserEndpoint failed");
+  }
+
+  if (NS_WARN_IF(!browserChild->BindPWindowGlobalEndpoint(std::move(aWindowEp),
+                                                          windowChild))) {
+    return IPC_FAIL(this, "BindPWindowGlobalEndpoint failed");
+  }
+  windowChild->Init();
+  auto guardNullWindowGlobal = MakeScopeExit([&] {
+    if (!windowChild->GetWindowGlobal()) {
+      windowChild->Destroy();
+    }
+  });
+
+  // Ensure that a BrowsingContext is set for our BrowserChild before
+  // running `Init`.
+  MOZ_RELEASE_ASSERT(browserChild->mBrowsingContext->Id() ==
+                     aWindowInit.context().mBrowsingContextId);
+
+  if (NS_WARN_IF(
+          NS_FAILED(browserChild->Init(/* aOpener */ nullptr, windowChild)))) {
+    return IPC_FAIL(browserChild, "BrowserChild::Init failed");
+  }
+
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  if (os) {
+    os->NotifyObservers(static_cast<nsIBrowserChild*>(browserChild),
+                        "tab-child-created", nullptr);
+  }
+  // Notify parent that we are ready to handle input events.
+  browserChild->SendRemoteIsReadyToHandleInputEvents();
+  return IPC_OK();
+}
+
+void ContentChild::GetAvailableDictionaries(
+    nsTArray<nsCString>& aDictionaries) {
+  aDictionaries = mAvailableDictionaries.Clone();
+}
+
+mozilla::PRemoteSpellcheckEngineChild*
+ContentChild::AllocPRemoteSpellcheckEngineChild() {
+  MOZ_CRASH(
+      "Default Constructor for PRemoteSpellcheckEngineChild should never be "
+      "called");
+  return nullptr;
+}
+
+bool ContentChild::DeallocPRemoteSpellcheckEngineChild(
+    PRemoteSpellcheckEngineChild* child) {
+  delete child;
+  return true;
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvNotifyEmptyHTTPCache() {
+  MOZ_ASSERT(NS_IsMainThread());
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  obs->NotifyObservers(nullptr, "cacheservice:empty-cache", nullptr);
+  return IPC_OK();
+}
+
+PHalChild* ContentChild::AllocPHalChild() { return CreateHalChild(); }
+
+bool ContentChild::DeallocPHalChild(PHalChild* aHal) {
+  delete aHal;
+  return true;
+}
+
+devtools::PHeapSnapshotTempFileHelperChild*
+ContentChild::AllocPHeapSnapshotTempFileHelperChild() {
+  return devtools::HeapSnapshotTempFileHelperChild::Create();
+}
+
+bool ContentChild::DeallocPHeapSnapshotTempFileHelperChild(
+    devtools::PHeapSnapshotTempFileHelperChild* aHeapSnapshotHelper) {
+  delete aHeapSnapshotHelper;
+  return true;
+}
+
+PTestShellChild* ContentChild::AllocPTestShellChild() {
+  return new TestShellChild();
+}
+
+bool ContentChild::DeallocPTestShellChild(PTestShellChild* shell) {
+  delete shell;
+  return true;
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvPTestShellConstructor(
+    PTestShellChild* actor) {
+  return IPC_OK();
+}
+
+void ContentChild::UpdateCookieStatus(nsIChannel* aChannel) {
+  RefPtr<CookieServiceChild> csChild = CookieServiceChild::GetSingleton();
+  NS_ASSERTION(csChild, "Couldn't get CookieServiceChild");
+
+  csChild->TrackCookieLoad(aChannel);
+}
+
+PScriptCacheChild* ContentChild::AllocPScriptCacheChild(
+    const FileDescOrError& cacheFile, const bool& wantCacheData) {
+  return new loader::ScriptCacheChild();
+}
+
+bool ContentChild::DeallocPScriptCacheChild(PScriptCacheChild* cache) {
+  delete static_cast<loader::ScriptCacheChild*>(cache);
+  return true;
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvPScriptCacheConstructor(
+    PScriptCacheChild* actor, const FileDescOrError& cacheFile,
+    const bool& wantCacheData) {
+  Maybe<FileDescriptor> fd;
+  if (cacheFile.type() == cacheFile.TFileDescriptor) {
+    fd.emplace(cacheFile.get_FileDescriptor());
+  }
+
+  static_cast<loader::ScriptCacheChild*>(actor)->Init(fd, wantCacheData);
+
+  // Some scripts listen for "app-startup" to start. However, in the content
+  // process, this category runs before the ScriptPreloader is initialized so
+  // these scripts wouldn't be added to the cache. Instead, if a script needs to
+  // run on start up in the content process, it should listen for this category.
+  NS_CreateServicesFromCategory("content-process-ready-for-script", nullptr,
+                                "content-process-ready-for-script", nullptr);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvNetworkLinkTypeChange(
+    const uint32_t& aType) {
+  mNetworkLinkType = aType;
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->NotifyObservers(nullptr, "contentchild:network-link-type-changed",
+                         nullptr);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvSocketProcessCrashed() {
+  nsIOService::IncreaseSocketProcessCrashCount();
+  return IPC_OK();
+}
+
+PRemotePrintJobChild* ContentChild::AllocPRemotePrintJobChild() {
+#ifdef NS_PRINTING
+  return new RemotePrintJobChild();
+#else
+  return nullptr;
+#endif
+}
+
+media::PMediaChild* ContentChild::AllocPMediaChild() {
+  return media::AllocPMediaChild();
+}
+
+bool ContentChild::DeallocPMediaChild(media::PMediaChild* aActor) {
+  return media::DeallocPMediaChild(aActor);
+}
+
+PBenchmarkStorageChild* ContentChild::AllocPBenchmarkStorageChild() {
+  return BenchmarkStorageChild::Instance();
+}
+
+bool ContentChild::DeallocPBenchmarkStorageChild(
+    PBenchmarkStorageChild* aActor) {
+  delete aActor;
+  return true;
+}
+
+#ifdef MOZ_WEBSPEECH
+PSpeechSynthesisChild* ContentChild::AllocPSpeechSynthesisChild() {
+  MOZ_CRASH("No one should be allocating PSpeechSynthesisChild actors");
+}
+
+bool ContentChild::DeallocPSpeechSynthesisChild(PSpeechSynthesisChild* aActor) {
+  delete aActor;
+  return true;
+}
+#endif
+
+#ifdef MOZ_WEBRTC
+PWebrtcGlobalChild* ContentChild::AllocPWebrtcGlobalChild() {
+  auto* child = new WebrtcGlobalChild();
+  return child;
+}
+
+bool ContentChild::DeallocPWebrtcGlobalChild(PWebrtcGlobalChild* aActor) {
+  delete static_cast<WebrtcGlobalChild*>(aActor);
+  return true;
+}
+#endif
+
+mozilla::ipc::IPCResult ContentChild::RecvRegisterChrome(
+    nsTArray<ChromePackage>&& packages,
+    nsTArray<SubstitutionMapping>&& resources,
+    nsTArray<OverrideMapping>&& overrides, const nsCString& locale,
+    const bool& reset) {
+  nsCOMPtr<nsIChromeRegistry> registrySvc = nsChromeRegistry::GetService();
+  nsChromeRegistryContent* chromeRegistry =
+      static_cast<nsChromeRegistryContent*>(registrySvc.get());
+  if (!chromeRegistry) {
+    return IPC_FAIL(this, "ChromeRegistryContent is null!");
+  }
+  chromeRegistry->RegisterRemoteChrome(packages, resources, overrides, locale,
+                                       reset);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvRegisterChromeItem(
+    const ChromeRegistryItem& item) {
+  nsCOMPtr<nsIChromeRegistry> registrySvc = nsChromeRegistry::GetService();
+  nsChromeRegistryContent* chromeRegistry =
+      static_cast<nsChromeRegistryContent*>(registrySvc.get());
+  if (!chromeRegistry) {
+    return IPC_FAIL(this, "ChromeRegistryContent is null!");
+  }
+  switch (item.type()) {
+    case ChromeRegistryItem::TChromePackage:
+      chromeRegistry->RegisterPackage(item.get_ChromePackage());
+      break;
+
+    case ChromeRegistryItem::TOverrideMapping:
+      chromeRegistry->RegisterOverride(item.get_OverrideMapping());
+      break;
+
+    case ChromeRegistryItem::TSubstitutionMapping:
+      chromeRegistry->RegisterSubstitution(item.get_SubstitutionMapping());
+      break;
+
+    default:
+      MOZ_ASSERT(false, "bad chrome item");
+      return IPC_FAIL_NO_REASON(this);
+  }
+
+  return IPC_OK();
+}
+mozilla::ipc::IPCResult ContentChild::RecvClearStyleSheetCache(
+    const Maybe<RefPtr<nsIPrincipal>>& aForPrincipal,
+    const Maybe<nsCString>& aBaseDomain) {
+  nsIPrincipal* principal =
+      aForPrincipal ? aForPrincipal.value().get() : nullptr;
+  const nsCString* baseDomain = aBaseDomain ? aBaseDomain.ptr() : nullptr;
+  SharedStyleSheetCache::Clear(principal, baseDomain);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvClearImageCacheFromPrincipal(
+    nsIPrincipal* aPrincipal) {
+  imgLoader* loader;
+  if (aPrincipal->OriginAttributesRef().mPrivateBrowsingId ==
+      nsIScriptSecurityManager::DEFAULT_PRIVATE_BROWSING_ID) {
+    loader = imgLoader::NormalLoader();
+  } else {
+    loader = imgLoader::PrivateBrowsingLoader();
+  }
+
+  loader->RemoveEntriesInternal(aPrincipal, nullptr);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvClearImageCacheFromBaseDomain(
+    const nsCString& aBaseDomain) {
+  imgLoader::NormalLoader()->RemoveEntriesInternal(nullptr, &aBaseDomain);
+  imgLoader::PrivateBrowsingLoader()->RemoveEntriesInternal(nullptr,
+                                                            &aBaseDomain);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvClearImageCache(
+    const bool& privateLoader, const bool& chrome) {
+  imgLoader* loader = privateLoader ? imgLoader::PrivateBrowsingLoader()
+                                    : imgLoader::NormalLoader();
+
+  loader->ClearCache(chrome);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvSetOffline(const bool& offline) {
+  nsCOMPtr<nsIIOService> io(do_GetIOService());
+  NS_ASSERTION(io, "IO Service can not be null");
+
+  io->SetOffline(offline);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvSetConnectivity(
+    const bool& connectivity) {
+  nsCOMPtr<nsIIOService> io(do_GetIOService());
+  nsCOMPtr<nsIIOServiceInternal> ioInternal(do_QueryInterface(io));
+  NS_ASSERTION(ioInternal, "IO Service can not be null");
+
+  ioInternal->SetConnectivity(connectivity);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvSetCaptivePortalState(
+    const int32_t& aState) {
+  nsCOMPtr<nsICaptivePortalService> cps = do_GetService(NS_CAPTIVEPORTAL_CID);
+  if (!cps) {
+    return IPC_OK();
+  }
+
+  mozilla::net::CaptivePortalService* portal =
+      static_cast<mozilla::net::CaptivePortalService*>(cps.get());
+  portal->SetStateInChild(aState);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvSetTRRMode(
+    const nsIDNSService::ResolverMode& mode,
+    const nsIDNSService::ResolverMode& modeFromPref) {
+  RefPtr<net::ChildDNSService> dnsServiceChild =
+      dont_AddRef(net::ChildDNSService::GetSingleton());
+  if (dnsServiceChild) {
+    dnsServiceChild->SetTRRModeInChild(mode, modeFromPref);
+  }
+  return IPC_OK();
+}
+
+void ContentChild::ActorDestroy(ActorDestroyReason why) {
+  if (mForceKillTimer) {
+    mForceKillTimer->Cancel();
+    mForceKillTimer = nullptr;
+  }
+
+  if (AbnormalShutdown == why) {
+    NS_WARNING("shutting down early because of crash!");
+    ProcessChild::QuickExit();
+  }
+
+#ifndef NS_FREE_PERMANENT_DATA
+  // In release builds, there's no point in the content process
+  // going through the full XPCOM shutdown path, because it doesn't
+  // keep persistent state.
+  ProcessChild::QuickExit();
+#else
+  // Destroy our JSProcessActors, and reject any pending queries.
+  JSActorDidDestroy();
+
+#  if defined(XP_WIN)
+  RefPtr<DllServices> dllSvc(DllServices::Get());
+  dllSvc->DisableFull();
+#  endif  // defined(XP_WIN)
+
+  if (gFirstIdleTask) {
+    gFirstIdleTask->Cancel();
+    gFirstIdleTask = nullptr;
+  }
+
+  BlobURLProtocolHandler::RemoveDataEntries();
+
+  mSharedData = nullptr;
+
+  mAlertObservers.Clear();
+
+  mIdleObservers.Clear();
+
+  if (mConsoleListener) {
+    nsCOMPtr<nsIConsoleService> svc(
+        do_GetService(NS_CONSOLESERVICE_CONTRACTID));
+    if (svc) {
+      svc->UnregisterListener(mConsoleListener);
+      mConsoleListener->mChild = nullptr;
+    }
+  }
+  mIsAlive = false;
+
+  CrashReporterClient::DestroySingleton();
+
+  XRE_ShutdownChildProcess();
+#endif    // NS_FREE_PERMANENT_DATA
+}
+
+void ContentChild::ProcessingError(Result aCode, const char* aReason) {
+  switch (aCode) {
+    case MsgDropped:
+      NS_WARNING("MsgDropped in ContentChild");
+      return;
+
+    case MsgNotKnown:
+    case MsgNotAllowed:
+    case MsgPayloadError:
+    case MsgProcessingError:
+    case MsgRouteError:
+    case MsgValueError:
+      break;
+
+    default:
+      MOZ_CRASH("not reached");
+  }
+
+  nsDependentCString reason(aReason);
+  CrashReporter::AnnotateCrashReport(
+      CrashReporter::Annotation::ipc_channel_error, reason);
+
+  MOZ_CRASH("Content child abort due to IPC error");
+}
+
+nsresult ContentChild::AddRemoteAlertObserver(const nsString& aData,
+                                              nsIObserver* aObserver) {
+  NS_ASSERTION(aObserver, "Adding a null observer?");
+  mAlertObservers.AppendElement(new AlertObserver(aObserver, aData));
+  return NS_OK;
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvPreferenceUpdate(const Pref& aPref) {
+  Preferences::SetPreference(aPref);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvVarUpdate(const GfxVarUpdate& aVar) {
+  gfx::gfxVars::ApplyUpdate(aVar);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvUpdatePerfStatsCollectionMask(
+    const uint64_t& aMask) {
+  PerfStats::SetCollectionMask(static_cast<PerfStats::MetricMask>(aMask));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvCollectPerfStatsJSON(
+    CollectPerfStatsJSONResolver&& aResolver) {
+  aResolver(PerfStats::CollectLocalPerfStatsJSON());
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvCollectScrollingMetrics(
+    CollectScrollingMetricsResolver&& aResolver) {
+  auto metrics = ScrollingMetrics::CollectLocalScrollingMetrics();
+  using ResolverArgs = std::tuple<const uint32_t&, const uint32_t&>;
+  aResolver(ResolverArgs(std::get<0>(metrics), std::get<1>(metrics)));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvNotifyAlertsObserver(
+    const nsCString& aType, const nsString& aData) {
+  nsTArray<nsCOMPtr<nsIObserver>> observersToNotify;
+
+  mAlertObservers.RemoveElementsBy([&](UniquePtr<AlertObserver>& observer) {
+    if (!observer->mData.Equals(aData)) {
+      return false;
+    }
+
+    // aType == alertfinished, this alert is done and we can remove the
+    // observer.
+    observersToNotify.AppendElement(observer->mObserver);
+    return aType.EqualsLiteral("alertfinished");
+  });
+
+  for (auto& observer : observersToNotify) {
+    observer->Observe(nullptr, aType.get(), aData.get());
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvNotifyVisited(
+    nsTArray<VisitedQueryResult>&& aURIs) {
+  nsCOMPtr<IHistory> history = components::History::Service();
+  if (!history) {
+    return IPC_OK();
+  }
+  for (const VisitedQueryResult& result : aURIs) {
+    nsCOMPtr<nsIURI> newURI = result.uri();
+    if (!newURI) {
+      return IPC_FAIL_NO_REASON(this);
+    }
+    auto status = result.visited() ? IHistory::VisitedStatus::Visited
+                                   : IHistory::VisitedStatus::Unvisited;
+    history->NotifyVisited(newURI, status);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvThemeChanged(
+    FullLookAndFeel&& aLookAndFeelData, widget::ThemeChangeKind aKind) {
+  LookAndFeel::SetData(std::move(aLookAndFeelData));
+  LookAndFeel::NotifyChangedAllWindows(aKind);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvLoadProcessScript(
+    const nsString& aURL) {
+  auto* global = ContentProcessMessageManager::Get();
+  global->LoadScript(aURL);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvAsyncMessage(
+    const nsString& aMsg, const ClonedMessageData& aData) {
+  AUTO_PROFILER_LABEL_DYNAMIC_LOSSY_NSSTRING("ContentChild::RecvAsyncMessage",
+                                             OTHER, aMsg);
+  MMPrinter::Print("ContentChild::RecvAsyncMessage", aMsg, aData);
+
+  RefPtr<nsFrameMessageManager> cpm =
+      nsFrameMessageManager::GetChildProcessManager();
+  if (cpm) {
+    StructuredCloneData data;
+    ipc::UnpackClonedMessageData(aData, data);
+    cpm->ReceiveMessage(cpm, nullptr, aMsg, false, &data, nullptr,
+                        IgnoreErrors());
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvRegisterStringBundles(
+    nsTArray<mozilla::dom::StringBundleDescriptor>&& aDescriptors) {
+  nsCOMPtr<nsIStringBundleService> stringBundleService =
+      components::StringBundle::Service();
+
+  for (auto& descriptor : aDescriptors) {
+    stringBundleService->RegisterContentBundle(
+        descriptor.bundleURL(), descriptor.mapFile(), descriptor.mapSize());
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvUpdateL10nFileSources(
+    nsTArray<mozilla::dom::L10nFileSourceDescriptor>&& aDescriptors) {
+  L10nRegistry::RegisterFileSourcesFromParentProcess(aDescriptors);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvUpdateSharedData(
+    const FileDescriptor& aMapFile, const uint32_t& aMapSize,
+    nsTArray<IPCBlob>&& aBlobs, nsTArray<nsCString>&& aChangedKeys) {
+  nsTArray<RefPtr<BlobImpl>> blobImpls(aBlobs.Length());
+  for (auto& ipcBlob : aBlobs) {
+    blobImpls.AppendElement(IPCBlobUtils::Deserialize(ipcBlob));
+  }
+
+  if (mSharedData) {
+    mSharedData->Update(aMapFile, aMapSize, std::move(blobImpls),
+                        std::move(aChangedKeys));
+  } else {
+    mSharedData =
+        new SharedMap(ContentProcessMessageManager::Get()->GetParentObject(),
+                      aMapFile, aMapSize, std::move(blobImpls));
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvFontListChanged() {
+  gfxPlatformFontList::PlatformFontList()->FontListChanged();
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvForceGlobalReflow(
+    bool aNeedsReframe) {
+  gfxPlatform::ForceGlobalReflow(aNeedsReframe ? gfxPlatform::NeedsReframe::Yes
+                                               : gfxPlatform::NeedsReframe::No);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvGeolocationUpdate(
+    nsIDOMGeoPosition* aPosition) {
+  RefPtr<nsGeolocationService> gs =
+      nsGeolocationService::GetGeolocationService();
+  if (!gs) {
+    return IPC_OK();
+  }
+  gs->Update(aPosition);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvGeolocationError(
+    const uint16_t& errorCode) {
+  RefPtr<nsGeolocationService> gs =
+      nsGeolocationService::GetGeolocationService();
+  if (!gs) {
+    return IPC_OK();
+  }
+  gs->NotifyError(errorCode);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvUpdateDictionaryList(
+    nsTArray<nsCString>&& aDictionaries) {
+  mAvailableDictionaries = std::move(aDictionaries);
+  mozInlineSpellChecker::UpdateCanEnableInlineSpellChecking();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvUpdateFontList(
+    dom::SystemFontList&& aFontList) {
+  mFontList = std::move(aFontList);
+  if (gfxPlatform::Initialized()) {
+    gfxPlatform::GetPlatform()->UpdateFontList(true);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvRebuildFontList(
+    const bool& aFullRebuild) {
+  if (gfxPlatform::Initialized()) {
+    gfxPlatform::GetPlatform()->UpdateFontList(aFullRebuild);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvFontListShmBlockAdded(
+    const uint32_t& aGeneration, const uint32_t& aIndex,
+    base::SharedMemoryHandle&& aHandle) {
+  if (gfxPlatform::Initialized()) {
+    gfxPlatformFontList::PlatformFontList()->ShmBlockAdded(aGeneration, aIndex,
+                                                           std::move(aHandle));
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvUpdateAppLocales(
+    nsTArray<nsCString>&& aAppLocales) {
+  LocaleService::GetInstance()->AssignAppLocales(aAppLocales);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvUpdateRequestedLocales(
+    nsTArray<nsCString>&& aRequestedLocales) {
+  LocaleService::GetInstance()->AssignRequestedLocales(aRequestedLocales);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvSystemTimezoneChanged() {
+  nsJSUtils::ResetTimeZone();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvAddPermission(
+    const IPC::Permission& permission) {
+  nsCOMPtr<nsIPermissionManager> permissionManagerIface =
+      components::PermissionManager::Service();
+  PermissionManager* permissionManager =
+      static_cast<PermissionManager*>(permissionManagerIface.get());
+  MOZ_ASSERT(permissionManager,
+             "We have no permissionManager in the Content process !");
+
+  // note we do not need to force mUserContextId to the default here because
+  // the permission manager does that internally.
+  nsAutoCString originNoSuffix;
+  OriginAttributes attrs;
+  bool success = attrs.PopulateFromOrigin(permission.origin, originNoSuffix);
+  NS_ENSURE_TRUE(success, IPC_FAIL_NO_REASON(this));
+
+  nsCOMPtr<nsIURI> uri;
+  nsresult rv = NS_NewURI(getter_AddRefs(uri), originNoSuffix);
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+
+  nsCOMPtr<nsIPrincipal> principal =
+      mozilla::BasePrincipal::CreateContentPrincipal(uri, attrs);
+
+  // child processes don't care about modification time.
+  int64_t modificationTime = 0;
+
+  permissionManager->AddInternal(
+      principal, nsCString(permission.type), permission.capability, 0,
+      permission.expireType, permission.expireTime, modificationTime,
+      PermissionManager::eNotify, PermissionManager::eNoDBOperation);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvRemoveAllPermissions() {
+  nsCOMPtr<nsIPermissionManager> permissionManagerIface =
+      components::PermissionManager::Service();
+  PermissionManager* permissionManager =
+      static_cast<PermissionManager*>(permissionManagerIface.get());
+  MOZ_ASSERT(permissionManager,
+             "We have no permissionManager in the Content process !");
+
+  permissionManager->RemoveAllFromIPC();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvFlushMemory(const nsString& reason) {
+  nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
+  if (!mShuttingDown && os) {
+    os->NotifyObservers(nullptr, "memory-pressure", reason.get());
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvActivateA11y() {
+#ifdef ACCESSIBILITY
+  // Start accessibility in content process if it's running in chrome
+  // process.
+  GetOrCreateAccService(nsAccessibilityService::eMainProcess);
+#endif  // ACCESSIBILITY
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvShutdownA11y() {
+#ifdef ACCESSIBILITY
+  // Try to shutdown accessibility in content process if it's shutting down in
+  // chrome process.
+  MaybeShutdownAccService(nsAccessibilityService::eMainProcess);
+#endif
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvApplicationForeground() {
+  // Rebroadcast the "application-foreground"
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->NotifyObservers(nullptr, "application-foreground", nullptr);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvApplicationBackground() {
+  // Rebroadcast the "application-background"
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->NotifyObservers(nullptr, "application-background", nullptr);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvGarbageCollect() {
+  // Rebroadcast the "child-gc-request" so that workers will GC.
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->NotifyObservers(nullptr, "child-gc-request", nullptr);
+  }
+  nsJSContext::GarbageCollectNow(JS::GCReason::DOM_IPC);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvCycleCollect() {
+  // Rebroadcast the "child-cc-request" so that workers will CC.
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->NotifyObservers(nullptr, "child-cc-request", nullptr);
+  }
+  nsJSContext::CycleCollectNow(CCReason::IPC_MESSAGE);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvUnlinkGhosts() {
+#ifdef DEBUG
+  nsWindowMemoryReporter::UnlinkGhostWindows();
+#endif
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvAppInfo(
+    const nsCString& version, const nsCString& buildID, const nsCString& name,
+    const nsCString& UAName, const nsCString& ID, const nsCString& vendor,
+    const nsCString& sourceURL, const nsCString& updateURL) {
+  mAppInfo.version.Assign(version);
+  mAppInfo.buildID.Assign(buildID);
+  mAppInfo.name.Assign(name);
+  mAppInfo.UAName.Assign(UAName);
+  mAppInfo.ID.Assign(ID);
+  mAppInfo.vendor.Assign(vendor);
+  mAppInfo.sourceURL.Assign(sourceURL);
+  mAppInfo.updateURL.Assign(updateURL);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvRemoteType(
+    const nsCString& aRemoteType, const nsCString& aProfile) {
+  if (aRemoteType == mRemoteType) {
+    // Allocation of preallocated processes that are still launching can
+    // cause this
+    return IPC_OK();
+  }
+
+  if (!mRemoteType.IsVoid()) {
+    // Preallocated processes are type PREALLOC_REMOTE_TYPE; they may not
+    // become a File: process, or Privileged About Content Process
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+            ("Changing remoteType of process %d from %s to %s", getpid(),
+             mRemoteType.get(), aRemoteType.get()));
+    // prealloc->anything (but file) or web->web allowed, and no-change
+    MOZ_RELEASE_ASSERT(mRemoteType == PREALLOC_REMOTE_TYPE &&
+                       aRemoteType != FILE_REMOTE_TYPE &&
+                       aRemoteType != PRIVILEGEDABOUT_REMOTE_TYPE);
+  } else {
+    // Initial setting of remote type.  Either to 'prealloc' or the actual
+    // final type (if we didn't use a preallocated process)
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+            ("Setting remoteType of process %d to %s", getpid(),
+             aRemoteType.get()));
+
+    if (aRemoteType == PREALLOC_REMOTE_TYPE) {
+      PreallocInit();
+    }
+  }
+
+  auto remoteTypePrefix = RemoteTypePrefix(aRemoteType);
+
+  // Must do before SetProcessName
+  mRemoteType.Assign(aRemoteType);
+
+  // Update the process name so about:memory's process names are more obvious.
+  if (aRemoteType == FILE_REMOTE_TYPE) {
+    SetProcessName("file:// Content"_ns, nullptr, &aProfile);
+  } else if (aRemoteType == EXTENSION_REMOTE_TYPE) {
+    SetProcessName("WebExtensions"_ns, nullptr, &aProfile);
+  } else if (aRemoteType == PRIVILEGEDABOUT_REMOTE_TYPE) {
+    SetProcessName("Privileged Content"_ns, nullptr, &aProfile);
+  } else if (aRemoteType == PRIVILEGEDMOZILLA_REMOTE_TYPE) {
+    SetProcessName("Privileged Mozilla"_ns, nullptr, &aProfile);
+  } else if (remoteTypePrefix == WITH_COOP_COEP_REMOTE_TYPE) {
+#ifdef NIGHTLY_BUILD
+    SetProcessName("WebCOOP+COEP Content"_ns, nullptr, &aProfile);
+#else
+    SetProcessName("Isolated Web Content"_ns, nullptr,
+                   &aProfile);  // to avoid confusing people
+#endif
+  } else if (remoteTypePrefix == FISSION_WEB_REMOTE_TYPE) {
+    // The profiler can sanitize out the eTLD+1
+    nsDependentCSubstring etld =
+        Substring(aRemoteType, FISSION_WEB_REMOTE_TYPE.Length() + 1);
+    SetProcessName("Isolated Web Content"_ns, &etld, &aProfile);
+  } else if (remoteTypePrefix == SERVICEWORKER_REMOTE_TYPE) {
+    // The profiler can sanitize out the eTLD+1
+    nsDependentCSubstring etld =
+        Substring(aRemoteType, SERVICEWORKER_REMOTE_TYPE.Length() + 1);
+    SetProcessName("Isolated Service Worker"_ns, &etld, &aProfile);
+  } else {
+    // else "prealloc" or "web" type -> "Web Content"
+    SetProcessName("Web Content"_ns, nullptr, &aProfile);
+  }
+
+  // Turn off Spectre mitigations in isolated web content processes.
+  if (StaticPrefs::javascript_options_spectre_disable_for_isolated_content() &&
+      (remoteTypePrefix == FISSION_WEB_REMOTE_TYPE ||
+       remoteTypePrefix == SERVICEWORKER_REMOTE_TYPE ||
+       remoteTypePrefix == WITH_COOP_COEP_REMOTE_TYPE ||
+       aRemoteType == PRIVILEGEDABOUT_REMOTE_TYPE ||
+       aRemoteType == PRIVILEGEDMOZILLA_REMOTE_TYPE)) {
+    JS::DisableSpectreMitigationsAfterInit();
+  }
+
+  // Use the prefix to avoid URIs from Fission isolated processes.
+  CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::RemoteType,
+                                     remoteTypePrefix);
+
+  // Defer RemoteWorkerService initialization until the child process does
+  // receive its specific remoteType and can become actionable for the
+  // RemoteWorkerManager in the parent process.
+  if (mRemoteType != PREALLOC_REMOTE_TYPE) {
+    RemoteWorkerService::Initialize();
+  }
+
+  return IPC_OK();
+}
+
+// A method to initialize anything we need during the preallocation phase
+void ContentChild::PreallocInit() {
+  EnsureNSSInitializedChromeOrContent();
+
+  // SetAcceptLanguages() needs to read localized strings (file access),
+  // which is slow, so do this in prealloc
+  nsHttpHandler::PresetAcceptLanguages();
+}
+
+// Call RemoteTypePrefix() on the result to remove URIs if you want to use this
+// for telemetry.
+const nsACString& ContentChild::GetRemoteType() const { return mRemoteType; }
+
+mozilla::ipc::IPCResult ContentChild::RecvInitBlobURLs(
+    nsTArray<BlobURLRegistrationData>&& aRegistrations) {
+  for (uint32_t i = 0; i < aRegistrations.Length(); ++i) {
+    BlobURLRegistrationData& registration = aRegistrations[i];
+    RefPtr<BlobImpl> blobImpl = IPCBlobUtils::Deserialize(registration.blob());
+    MOZ_ASSERT(blobImpl);
+
+    BlobURLProtocolHandler::AddDataEntry(
+        registration.url(), registration.principal(),
+        registration.agentClusterId(), blobImpl);
+    // If we have received an already-revoked blobURL, we have to keep it alive
+    // for a while (see BlobURLProtocolHandler) in order to support pending
+    // operations such as navigation, download and so on.
+    if (registration.revoked()) {
+      BlobURLProtocolHandler::RemoveDataEntry(registration.url(), false);
+    }
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvInitJSActorInfos(
+    nsTArray<JSProcessActorInfo>&& aContentInfos,
+    nsTArray<JSWindowActorInfo>&& aWindowInfos) {
+  RefPtr<JSActorService> actSvc = JSActorService::GetSingleton();
+  actSvc->LoadJSActorInfos(aContentInfos, aWindowInfos);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvUnregisterJSWindowActor(
+    const nsCString& aName) {
+  RefPtr<JSActorService> actSvc = JSActorService::GetSingleton();
+  actSvc->UnregisterWindowActor(aName);
+  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);
+  return IPC_OK();
+}
+
+// Method used for setting QoS levels on background main threads.
+#ifdef XP_MACOSX
+static bool PriorityUsesLowPowerMainThread(
+    const hal::ProcessPriority& aPriority) {
+  return aPriority == hal::PROCESS_PRIORITY_BACKGROUND ||
+         aPriority == hal::PROCESS_PRIORITY_PREALLOC;
+}
+#endif
+
+mozilla::ipc::IPCResult ContentChild::RecvNotifyProcessPriorityChanged(
+    const hal::ProcessPriority& aPriority) {
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  NS_ENSURE_TRUE(os, IPC_OK());
+
+  RefPtr<nsHashPropertyBag> props = new nsHashPropertyBag();
+  props->SetPropertyAsInt32(u"priority"_ns, static_cast<int32_t>(aPriority));
+
+  PROFILER_MARKER("Process Priority", OTHER,
+                  mozilla::MarkerThreadId::MainThread(), ProcessPriorityChange,
+                  ProfilerString8View::WrapNullTerminatedString(
+                      ProcessPriorityToString(mProcessPriority)),
+                  ProfilerString8View::WrapNullTerminatedString(
+                      ProcessPriorityToString(aPriority)));
+
+  // Record FOG data before the priority change.
+  // Ignore the change if it's the first time we set the process priority.
+  if (mProcessPriority != hal::PROCESS_PRIORITY_UNKNOWN) {
+    glean::RecordPowerMetrics();
+  }
+
+#ifdef XP_MACOSX
+  // In cases where we have low-power threads enabled (such as on MacOS) we can
+  // go ahead and put the main thread in the background here. If the new
+  // priority is the background priority, we can tell the OS to put the main
+  // thread on low-power cores. Alternately, if we are changing from the
+  // background to a higher priority, we change the main thread back to the
+  // |user-interactive| state, defined in MacOS's QoS documentation as reserved
+  // for main threads.
+  if (StaticPrefs::threads_use_low_power_enabled() &&
+      StaticPrefs::threads_lower_mainthread_priority_in_background_enabled()) {
+    if (PriorityUsesLowPowerMainThread(aPriority)) {
+      pthread_set_qos_class_self_np(QOS_CLASS_UTILITY, 0);
+    } else if (PriorityUsesLowPowerMainThread(mProcessPriority)) {
+      pthread_set_qos_class_self_np(QOS_CLASS_USER_INTERACTIVE, 0);
+    }
+  }
+#endif
+
+  mProcessPriority = aPriority;
+
+  os->NotifyObservers(static_cast<nsIPropertyBag2*>(props),
+                      "ipc:process-priority-changed", nullptr);
+  if (StaticPrefs::
+          dom_memory_foreground_content_processes_have_larger_page_cache()) {
+    if (mProcessPriority >= hal::PROCESS_PRIORITY_FOREGROUND) {
+      // Note: keep this in sync with the JS shell (js/src/shell/js.cpp).
+      moz_set_max_dirty_page_modifier(4);
+    } else if (mProcessPriority == hal::PROCESS_PRIORITY_BACKGROUND) {
+      moz_set_max_dirty_page_modifier(-2);
+    } else {
+      moz_set_max_dirty_page_modifier(0);
+    }
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvMinimizeMemoryUsage() {
+  nsCOMPtr<nsIMemoryReporterManager> mgr =
+      do_GetService("@mozilla.org/memory-reporter-manager;1");
+  NS_ENSURE_TRUE(mgr, IPC_OK());
+
+  Unused << mgr->MinimizeMemoryUsage(/* callback = */ nullptr);
+  return IPC_OK();
+}
+
+void ContentChild::AddIdleObserver(nsIObserver* aObserver,
+                                   uint32_t aIdleTimeInS) {
+  MOZ_ASSERT(aObserver, "null idle observer");
+  // Make sure aObserver isn't released while we wait for the parent
+  aObserver->AddRef();
+  SendAddIdleObserver(reinterpret_cast<uint64_t>(aObserver), aIdleTimeInS);
+  mIdleObservers.Insert(aObserver);
+}
+
+void ContentChild::RemoveIdleObserver(nsIObserver* aObserver,
+                                      uint32_t aIdleTimeInS) {
+  MOZ_ASSERT(aObserver, "null idle observer");
+  SendRemoveIdleObserver(reinterpret_cast<uint64_t>(aObserver), aIdleTimeInS);
+  aObserver->Release();
+  mIdleObservers.Remove(aObserver);
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvNotifyIdleObserver(
+    const uint64_t& aObserver, const nsCString& aTopic,
+    const nsString& aTimeStr) {
+  nsIObserver* observer = reinterpret_cast<nsIObserver*>(aObserver);
+  if (mIdleObservers.Contains(observer)) {
+    observer->Observe(nullptr, aTopic.get(), aTimeStr.get());
+  } else {
+    NS_WARNING("Received notification for an idle observer that was removed.");
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvLoadAndRegisterSheet(
+    nsIURI* aURI, const uint32_t& aType) {
+  if (!aURI) {
+    return IPC_OK();
+  }
+
+  nsStyleSheetService* sheetService = nsStyleSheetService::GetInstance();
+  if (sheetService) {
+    sheetService->LoadAndRegisterSheet(aURI, aType);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvUnregisterSheet(
+    nsIURI* aURI, const uint32_t& aType) {
+  if (!aURI) {
+    return IPC_OK();
+  }
+
+  nsStyleSheetService* sheetService = nsStyleSheetService::GetInstance();
+  if (sheetService) {
+    sheetService->UnregisterSheet(aURI, aType);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvDomainSetChanged(
+    const uint32_t& aSetType, const uint32_t& aChangeType, nsIURI* aDomain) {
+  if (aChangeType == ACTIVATE_POLICY) {
+    if (mPolicy) {
+      return IPC_OK();
+    }
+    nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
+    MOZ_ASSERT(ssm);
+    ssm->ActivateDomainPolicyInternal(getter_AddRefs(mPolicy));
+    if (!mPolicy) {
+      return IPC_FAIL_NO_REASON(this);
+    }
+    return IPC_OK();
+  }
+  if (!mPolicy) {
+    MOZ_ASSERT_UNREACHABLE(
+        "If the domain policy is not active yet,"
+        " the first message should be ACTIVATE_POLICY");
+    return IPC_FAIL_NO_REASON(this);
+  }
+
+  NS_ENSURE_TRUE(mPolicy, IPC_FAIL_NO_REASON(this));
+
+  if (aChangeType == DEACTIVATE_POLICY) {
+    mPolicy->Deactivate();
+    mPolicy = nullptr;
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIDomainSet> set;
+  switch (aSetType) {
+    case BLOCKLIST:
+      mPolicy->GetBlocklist(getter_AddRefs(set));
+      break;
+    case SUPER_BLOCKLIST:
+      mPolicy->GetSuperBlocklist(getter_AddRefs(set));
+      break;
+    case ALLOWLIST:
+      mPolicy->GetAllowlist(getter_AddRefs(set));
+      break;
+    case SUPER_ALLOWLIST:
+      mPolicy->GetSuperAllowlist(getter_AddRefs(set));
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Unexpected setType");
+      return IPC_FAIL_NO_REASON(this);
+  }
+
+  MOZ_ASSERT(set);
+
+  switch (aChangeType) {
+    case ADD_DOMAIN:
+      NS_ENSURE_TRUE(aDomain, IPC_FAIL_NO_REASON(this));
+      set->Add(aDomain);
+      break;
+    case REMOVE_DOMAIN:
+      NS_ENSURE_TRUE(aDomain, IPC_FAIL_NO_REASON(this));
+      set->Remove(aDomain);
+      break;
+    case CLEAR_DOMAINS:
+      set->Clear();
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Unexpected changeType");
+      return IPC_FAIL_NO_REASON(this);
+  }
+
+  return IPC_OK();
+}
+
+void ContentChild::StartForceKillTimer() {
+  if (mForceKillTimer) {
+    return;
+  }
+
+  int32_t timeoutSecs = StaticPrefs::dom_ipc_tabs_shutdownTimeoutSecs();
+  if (timeoutSecs > 0) {
+    NS_NewTimerWithFuncCallback(getter_AddRefs(mForceKillTimer),
+                                ContentChild::ForceKillTimerCallback, this,
+                                timeoutSecs * 1000, nsITimer::TYPE_ONE_SHOT,
+                                "dom::ContentChild::StartForceKillTimer");
+    MOZ_ASSERT(mForceKillTimer);
+  }
+}
+
+/* static */
+void ContentChild::ForceKillTimerCallback(nsITimer* aTimer, void* aClosure) {
+  ProcessChild::QuickExit();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvShutdownConfirmedHP() {
+  CrashReporter::AppendToCrashReportAnnotation(
+      CrashReporter::Annotation::IPCShutdownState,
+      "RecvShutdownConfirmedHP entry"_ns);
+
+  // Bug 1755376: If we see "RecvShutdownConfirmedHP entry" often in
+  // bug IPCError_ShutDownKill we might want to anticipate
+  // ShutdownPhase::AppShutdownConfirmed to start here.
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvShutdown() {
+  CrashReporter::AppendToCrashReportAnnotation(
+      CrashReporter::Annotation::IPCShutdownState, "RecvShutdown entry"_ns);
+
+  // Signal the ongoing shutdown to AppShutdown, this
+  // will make abort nested SpinEventLoopUntilOrQuit loops
+  AppShutdown::AdvanceShutdownPhaseWithoutNotify(
+      ShutdownPhase::AppShutdownConfirmed);
+
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  if (os) {
+    CrashReporter::AppendToCrashReportAnnotation(
+        CrashReporter::Annotation::IPCShutdownState,
+        "content-child-will-shutdown started"_ns);
+
+    os->NotifyObservers(ToSupports(this), "content-child-will-shutdown",
+                        nullptr);
+  }
+
+  ShutdownInternal();
+  return IPC_OK();
+}
+
+void ContentChild::ShutdownInternal() {
+  CrashReporter::AppendToCrashReportAnnotation(
+      CrashReporter::Annotation::IPCShutdownState, "ShutdownInternal entry"_ns);
+
+  // If we receive the shutdown message from within a nested event loop, we want
+  // to wait for that event loop to finish. Otherwise we could prematurely
+  // terminate an "unload" or "pagehide" event handler (which might be doing a
+  // sync XHR, for example).
+
+  MOZ_ASSERT(NS_IsMainThread());
+  RefPtr<nsThread> mainThread = nsThreadManager::get().GetCurrentThread();
+  // Note that we only have to check the recursion count for the current
+  // cooperative thread. Since the Shutdown message is not labeled with a
+  // SchedulerGroup, there can be no other cooperative threads doing work while
+  // we're running.
+  if (mainThread && mainThread->RecursionDepth() > 1) {
+    // We're in a nested event loop. Let's delay for an arbitrary period of
+    // time (100ms) in the hopes that the event loop will have finished by
+    // then.
+    GetCurrentSerialEventTarget()->DelayedDispatch(
+        NewRunnableMethod("dom::ContentChild::RecvShutdown", this,
+                          &ContentChild::ShutdownInternal),
+        100);
+    return;
+  }
+
+  mShuttingDown = true;
+
+#ifdef NIGHTLY_BUILD
+  BackgroundHangMonitor::UnregisterAnnotator(
+      PendingInputEventHangAnnotator::sSingleton);
+#endif
+
+  if (mPolicy) {
+    mPolicy->Deactivate();
+    mPolicy = nullptr;
+  }
+
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  if (os) {
+    CrashReporter::AppendToCrashReportAnnotation(
+        CrashReporter::Annotation::IPCShutdownState,
+        "content-child-shutdown started"_ns);
+    os->NotifyObservers(ToSupports(this), "content-child-shutdown", nullptr);
+  }
+
+  GetIPCChannel()->SetAbortOnError(false);
+
+  if (mProfilerController) {
+    const bool isProfiling = profiler_is_active();
+    CrashReporter::AnnotateCrashReport(
+        CrashReporter::Annotation::ProfilerChildShutdownPhase,
+        isProfiling ? "Profiling - GrabShutdownProfileAndShutdown"_ns
+                    : "Not profiling - GrabShutdownProfileAndShutdown"_ns);
+    ProfileAndAdditionalInformation shutdownProfileAndAdditionalInformation =
+        mProfilerController->GrabShutdownProfileAndShutdown();
+    CrashReporter::AnnotateCrashReport(
+        CrashReporter::Annotation::ProfilerChildShutdownPhase,
+        isProfiling ? "Profiling - Destroying ChildProfilerController"_ns
+                    : "Not profiling - Destroying ChildProfilerController"_ns);
+    mProfilerController = nullptr;
+    CrashReporter::AnnotateCrashReport(
+        CrashReporter::Annotation::ProfilerChildShutdownPhase,
+        isProfiling ? "Profiling - SendShutdownProfile (sending)"_ns
+                    : "Not profiling - SendShutdownProfile (sending)"_ns);
+    if (const size_t len = shutdownProfileAndAdditionalInformation.SizeOf();
+        len >= size_t(IPC::Channel::kMaximumMessageSize)) {
+      shutdownProfileAndAdditionalInformation.mProfile = nsPrintfCString(
+          "*Profile from pid %u bigger (%zu) than IPC max (%zu)",
+          unsigned(profiler_current_process_id().ToNumber()), len,
+          size_t(IPC::Channel::kMaximumMessageSize));
+    }
+    // Send the shutdown profile to the parent process through our own
+    // message channel, which we know will survive for long enough.
+    bool sent =
+        SendShutdownProfile(shutdownProfileAndAdditionalInformation.mProfile);
+    CrashReporter::AnnotateCrashReport(
+        CrashReporter::Annotation::ProfilerChildShutdownPhase,
+        sent ? (isProfiling ? "Profiling - SendShutdownProfile (sent)"_ns
+                            : "Not profiling - SendShutdownProfile (sent)"_ns)
+             : (isProfiling
+                    ? "Profiling - SendShutdownProfile (failed)"_ns
+                    : "Not profiling - SendShutdownProfile (failed)"_ns));
+  }
+
+  if (PerfStats::GetCollectionMask() != 0) {
+    SendShutdownPerfStats(PerfStats::CollectLocalPerfStatsJSON());
+  }
+
+  // Start a timer that will ensure we quickly exit after a reasonable period
+  // of time. Prevents shutdown hangs after our connection to the parent
+  // closes or when the parent is too busy to ever kill us.
+  CrashReporter::AppendToCrashReportAnnotation(
+      CrashReporter::Annotation::IPCShutdownState, "StartForceKillTimer"_ns);
+  StartForceKillTimer();
+
+  CrashReporter::AppendToCrashReportAnnotation(
+      CrashReporter::Annotation::IPCShutdownState,
+      "SendFinishShutdown (sending)"_ns);
+
+  // Notify the parent that we are done with shutdown. This is sent with high
+  // priority and will just flag we are done.
+  Unused << SendNotifyShutdownSuccess();
+
+  // Now tell the parent to actually destroy our channel which will make end
+  // our process. This is expected to be the last event the parent will
+  // ever process for this ContentChild.
+  bool sent = SendFinishShutdown();
+
+  CrashReporter::AppendToCrashReportAnnotation(
+      CrashReporter::Annotation::IPCShutdownState,
+      sent ? "SendFinishShutdown (sent)"_ns : "SendFinishShutdown (failed)"_ns);
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvUpdateWindow(
+    const uintptr_t& aChildId) {
+  MOZ_ASSERT(
+      false,
+      "ContentChild::RecvUpdateWindow calls unexpected on this platform.");
+  return IPC_FAIL_NO_REASON(this);
+}
+
+PContentPermissionRequestChild*
+ContentChild::AllocPContentPermissionRequestChild(
+    Span<const PermissionRequest> aRequests, nsIPrincipal* aPrincipal,
+    nsIPrincipal* aTopLevelPrincipal, const bool& aIsHandlingUserInput,
+    const bool& aMaybeUnsafePermissionDelegate, const TabId& aTabId) {
+  MOZ_CRASH("unused");
+  return nullptr;
+}
+
+bool ContentChild::DeallocPContentPermissionRequestChild(
+    PContentPermissionRequestChild* actor) {
+  nsContentPermissionUtils::NotifyRemoveContentPermissionRequestChild(actor);
+  auto child = static_cast<RemotePermissionRequest*>(actor);
+  child->IPDLRelease();
+  return true;
+}
+
+PWebBrowserPersistDocumentChild*
+ContentChild::AllocPWebBrowserPersistDocumentChild(
+    PBrowserChild* aBrowser, const MaybeDiscarded<BrowsingContext>& aContext) {
+  return new WebBrowserPersistDocumentChild();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvPWebBrowserPersistDocumentConstructor(
+    PWebBrowserPersistDocumentChild* aActor, PBrowserChild* aBrowser,
+    const MaybeDiscarded<BrowsingContext>& aContext) {
+  if (NS_WARN_IF(!aBrowser)) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+
+  if (aContext.IsNullOrDiscarded()) {
+    aActor->SendInitFailure(NS_ERROR_NO_CONTENT);
+    return IPC_OK();
+  }
+
+  nsCOMPtr<Document> foundDoc = aContext.get()->GetDocument();
+
+  if (!foundDoc) {
+    aActor->SendInitFailure(NS_ERROR_NO_CONTENT);
+  } else {
+    static_cast<WebBrowserPersistDocumentChild*>(aActor)->Start(foundDoc);
+  }
+  return IPC_OK();
+}
+
+bool ContentChild::DeallocPWebBrowserPersistDocumentChild(
+    PWebBrowserPersistDocumentChild* aActor) {
+  delete aActor;
+  return true;
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvInvokeDragSession(
+    const MaybeDiscarded<WindowContext>& aSourceWindowContext,
+    const MaybeDiscarded<WindowContext>& aSourceTopWindowContext,
+    nsTArray<IPCTransferableData>&& aTransferables, const uint32_t& aAction) {
+  nsCOMPtr<nsIDragService> dragService =
+      do_GetService("@mozilla.org/widget/dragservice;1");
+  if (dragService) {
+    dragService->StartDragSession();
+    nsCOMPtr<nsIDragSession> session;
+    dragService->GetCurrentSession(getter_AddRefs(session));
+    if (session) {
+      session->SetSourceWindowContext(aSourceWindowContext.GetMaybeDiscarded());
+      session->SetSourceTopWindowContext(
+          aSourceTopWindowContext.GetMaybeDiscarded());
+      session->SetDragAction(aAction);
+      // Check if we are receiving any file objects. If we are we will want
+      // to hide any of the other objects coming in from content.
+      bool hasFiles = false;
+      for (uint32_t i = 0; i < aTransferables.Length() && !hasFiles; ++i) {
+        auto& items = aTransferables[i].items();
+        for (uint32_t j = 0; j < items.Length() && !hasFiles; ++j) {
+          if (items[j].data().type() ==
+              IPCTransferableDataType::TIPCTransferableDataBlob) {
+            hasFiles = true;
+          }
+        }
+      }
+
+      // Add the entries from the IPC to the new DataTransfer
+      nsCOMPtr<DataTransfer> dataTransfer =
+          new DataTransfer(nullptr, eDragStart, false, -1);
+      for (uint32_t i = 0; i < aTransferables.Length(); ++i) {
+        auto& items = aTransferables[i].items();
+        for (uint32_t j = 0; j < items.Length(); ++j) {
+          const IPCTransferableDataItem& item = items[j];
+          RefPtr<nsVariantCC> variant = new nsVariantCC();
+          nsresult rv =
+              nsContentUtils::IPCTransferableDataItemToVariant(item, variant);
+          if (NS_FAILED(rv)) {
+            continue;
+          }
+
+          // We should hide this data from content if we have a file, and we
+          // aren't a file.
+          bool hidden =
+              hasFiles && item.data().type() !=
+                              IPCTransferableDataType::TIPCTransferableDataBlob;
+          dataTransfer->SetDataWithPrincipalFromOtherProcess(
+              NS_ConvertUTF8toUTF16(item.flavor()), variant, i,
+              nsContentUtils::GetSystemPrincipal(), hidden);
+        }
+      }
+      session->SetDataTransfer(dataTransfer);
+    }
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvEndDragSession(
+    const bool& aDoneDrag, const bool& aUserCancelled,
+    const LayoutDeviceIntPoint& aDragEndPoint, const uint32_t& aKeyModifiers,
+    const uint32_t& aDropEffect) {
+  nsCOMPtr<nsIDragService> dragService =
+      do_GetService("@mozilla.org/widget/dragservice;1");
+  if (dragService) {
+    nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession();
+    if (dragSession) {
+      if (aUserCancelled) {
+        dragSession->UserCancelled();
+      }
+
+      RefPtr<DataTransfer> dataTransfer = dragSession->GetDataTransfer();
+      if (dataTransfer) {
+        dataTransfer->SetDropEffectInt(aDropEffect);
+      }
+    }
+
+    static_cast<nsBaseDragService*>(dragService.get())
+        ->SetDragEndPoint(aDragEndPoint);
+    dragService->EndDragSession(aDoneDrag, aKeyModifiers);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvPush(const nsCString& aScope,
+                                               nsIPrincipal* aPrincipal,
+                                               const nsString& aMessageId) {
+  PushMessageDispatcher dispatcher(aScope, aPrincipal, aMessageId, Nothing());
+  Unused << NS_WARN_IF(NS_FAILED(dispatcher.NotifyObserversAndWorkers()));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvPushWithData(
+    const nsCString& aScope, nsIPrincipal* aPrincipal,
+    const nsString& aMessageId, nsTArray<uint8_t>&& aData) {
+  PushMessageDispatcher dispatcher(aScope, aPrincipal, aMessageId,
+                                   Some(std::move(aData)));
+  Unused << NS_WARN_IF(NS_FAILED(dispatcher.NotifyObserversAndWorkers()));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvPushSubscriptionChange(
+    const nsCString& aScope, nsIPrincipal* aPrincipal) {
+  PushSubscriptionChangeDispatcher dispatcher(aScope, aPrincipal);
+  Unused << NS_WARN_IF(NS_FAILED(dispatcher.NotifyObserversAndWorkers()));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvPushError(const nsCString& aScope,
+                                                    nsIPrincipal* aPrincipal,
+                                                    const nsString& aMessage,
+                                                    const uint32_t& aFlags) {
+  PushErrorDispatcher dispatcher(aScope, aPrincipal, aMessage, aFlags);
+  Unused << NS_WARN_IF(NS_FAILED(dispatcher.NotifyObserversAndWorkers()));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+ContentChild::RecvNotifyPushSubscriptionModifiedObservers(
+    const nsCString& aScope, nsIPrincipal* aPrincipal) {
+  PushSubscriptionModifiedDispatcher dispatcher(aScope, aPrincipal);
+  Unused << NS_WARN_IF(NS_FAILED(dispatcher.NotifyObservers()));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvBlobURLRegistration(
+    const nsCString& aURI, const IPCBlob& aBlob, nsIPrincipal* aPrincipal,
+    const Maybe<nsID>& aAgentClusterId) {
+  RefPtr<BlobImpl> blobImpl = IPCBlobUtils::Deserialize(aBlob);
+  MOZ_ASSERT(blobImpl);
+
+  BlobURLProtocolHandler::AddDataEntry(aURI, aPrincipal, aAgentClusterId,
+                                       blobImpl);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvBlobURLUnregistration(
+    const nsCString& aURI) {
+  BlobURLProtocolHandler::RemoveDataEntry(
+      aURI,
+      /* aBroadcastToOtherProcesses = */ false);
+  return IPC_OK();
+}
+
+void ContentChild::CreateGetFilesRequest(const nsAString& aDirectoryPath,
+                                         bool aRecursiveFlag, nsID& aUUID,
+                                         GetFilesHelperChild* aChild) {
+  MOZ_ASSERT(aChild);
+  MOZ_ASSERT(!mGetFilesPendingRequests.Contains(aUUID));
+
+  Unused << SendGetFilesRequest(aUUID, aDirectoryPath, aRecursiveFlag);
+  mGetFilesPendingRequests.InsertOrUpdate(aUUID, RefPtr{aChild});
+}
+
+void ContentChild::DeleteGetFilesRequest(nsID& aUUID,
+                                         GetFilesHelperChild* aChild) {
+  MOZ_ASSERT(aChild);
+  MOZ_ASSERT(mGetFilesPendingRequests.Contains(aUUID));
+
+  Unused << SendDeleteGetFilesRequest(aUUID);
+  mGetFilesPendingRequests.Remove(aUUID);
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvGetFilesResponse(
+    const nsID& aUUID, const GetFilesResponseResult& aResult) {
+  RefPtr<GetFilesHelperChild> child;
+
+  // This object can already been deleted in case DeleteGetFilesRequest has
+  // been called when the response was sending by the parent.
+  if (!mGetFilesPendingRequests.Remove(aUUID, getter_AddRefs(child))) {
+    return IPC_OK();
+  }
+
+  if (aResult.type() == GetFilesResponseResult::TGetFilesResponseFailure) {
+    child->Finished(aResult.get_GetFilesResponseFailure().errorCode());
+  } else {
+    MOZ_ASSERT(aResult.type() ==
+               GetFilesResponseResult::TGetFilesResponseSuccess);
+
+    const nsTArray<IPCBlob>& ipcBlobs =
+        aResult.get_GetFilesResponseSuccess().blobs();
+
+    bool succeeded = true;
+    for (uint32_t i = 0; succeeded && i < ipcBlobs.Length(); ++i) {
+      RefPtr<BlobImpl> impl = IPCBlobUtils::Deserialize(ipcBlobs[i]);
+      succeeded = child->AppendBlobImpl(impl);
+    }
+
+    child->Finished(succeeded ? NS_OK : NS_ERROR_OUT_OF_MEMORY);
+  }
+  return IPC_OK();
+}
+
+/* static */
+void ContentChild::FatalErrorIfNotUsingGPUProcess(const char* const aErrorMsg,
+                                                  base::ProcessId aOtherPid) {
+  // If we're communicating with the same process or the UI process then we
+  // want to crash normally. Otherwise we want to just warn as the other end
+  // must be the GPU process and it crashing shouldn't be fatal for us.
+  if (aOtherPid == base::GetCurrentProcId() ||
+      (GetSingleton() && GetSingleton()->OtherPid() == aOtherPid)) {
+    mozilla::ipc::FatalError(aErrorMsg, false);
+  } else {
+    nsAutoCString formattedMessage("IPDL error: \"");
+    formattedMessage.AppendASCII(aErrorMsg);
+    formattedMessage.AppendLiteral(R"(".)");
+    NS_WARNING(formattedMessage.get());
+  }
+}
+
+PURLClassifierChild* ContentChild::AllocPURLClassifierChild(
+    nsIPrincipal* aPrincipal, bool* aSuccess) {
+  *aSuccess = true;
+  return new URLClassifierChild();
+}
+
+bool ContentChild::DeallocPURLClassifierChild(PURLClassifierChild* aActor) {
+  MOZ_ASSERT(aActor);
+  delete aActor;
+  return true;
+}
+
+PURLClassifierLocalChild* ContentChild::AllocPURLClassifierLocalChild(
+    nsIURI* aUri, Span<const IPCURLClassifierFeature> aFeatures) {
+  return new URLClassifierLocalChild();
+}
+
+bool ContentChild::DeallocPURLClassifierLocalChild(
+    PURLClassifierLocalChild* aActor) {
+  MOZ_ASSERT(aActor);
+  delete aActor;
+  return true;
+}
+
+PLoginReputationChild* ContentChild::AllocPLoginReputationChild(nsIURI* aUri) {
+  return new PLoginReputationChild();
+}
+
+bool ContentChild::DeallocPLoginReputationChild(PLoginReputationChild* aActor) {
+  MOZ_ASSERT(aActor);
+  delete aActor;
+  return true;
+}
+
+PSessionStorageObserverChild*
+ContentChild::AllocPSessionStorageObserverChild() {
+  MOZ_CRASH(
+      "PSessionStorageObserverChild actors should be manually constructed!");
+}
+
+bool ContentChild::DeallocPSessionStorageObserverChild(
+    PSessionStorageObserverChild* aActor) {
+  MOZ_ASSERT(aActor);
+
+  delete aActor;
+  return true;
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvProvideAnonymousTemporaryFile(
+    const uint64_t& aID, const FileDescOrError& aFDOrError) {
+  mozilla::UniquePtr<AnonymousTemporaryFileCallback> callback;
+  mPendingAnonymousTemporaryFiles.Remove(aID, &callback);
+  MOZ_ASSERT(callback);
+
+  PRFileDesc* prfile = nullptr;
+  if (aFDOrError.type() == FileDescOrError::Tnsresult) {
+    DebugOnly<nsresult> rv = aFDOrError.get_nsresult();
+    MOZ_ASSERT(NS_FAILED(rv));
+  } else {
+    auto rawFD = aFDOrError.get_FileDescriptor().ClonePlatformHandle();
+    prfile = PR_ImportFile(PROsfd(rawFD.release()));
+  }
+  (*callback)(prfile);
+  return IPC_OK();
+}
+
+nsresult ContentChild::AsyncOpenAnonymousTemporaryFile(
+    const AnonymousTemporaryFileCallback& aCallback) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  static uint64_t id = 0;
+  auto newID = id++;
+  if (!SendRequestAnonymousTemporaryFile(newID)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Remember the association with the callback.
+  MOZ_ASSERT(!mPendingAnonymousTemporaryFiles.Get(newID));
+  mPendingAnonymousTemporaryFiles.GetOrInsertNew(newID, aCallback);
+  return NS_OK;
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvSetPermissionsWithKey(
+    const nsCString& aPermissionKey, nsTArray<IPC::Permission>&& aPerms) {
+  RefPtr<PermissionManager> permManager = PermissionManager::GetInstance();
+  if (permManager) {
+    permManager->SetPermissionsWithKey(aPermissionKey, aPerms);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvRefreshScreens(
+    nsTArray<ScreenDetails>&& aScreens) {
+  ScreenManager& screenManager = ScreenManager::GetSingleton();
+  screenManager.Refresh(std::move(aScreens));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvShareCodeCoverageMutex(
+    CrossProcessMutexHandle aHandle) {
+#ifdef MOZ_CODE_COVERAGE
+  CodeCoverageHandler::Init(std::move(aHandle));
+  return IPC_OK();
+#else
+  MOZ_CRASH("Shouldn't receive this message in non-code coverage builds!");
+#endif
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvFlushCodeCoverageCounters(
+    FlushCodeCoverageCountersResolver&& aResolver) {
+#ifdef MOZ_CODE_COVERAGE
+  CodeCoverageHandler::FlushCounters();
+  aResolver(/* unused */ true);
+  return IPC_OK();
+#else
+  MOZ_CRASH("Shouldn't receive this message in non-code coverage builds!");
+#endif
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvSetInputEventQueueEnabled() {
+  nsThreadManager::get().EnableMainThreadEventPrioritization();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvFlushInputEventQueue() {
+  nsThreadManager::get().FlushInputEventPrioritization();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvSuspendInputEventQueue() {
+  nsThreadManager::get().SuspendInputEventPrioritization();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvResumeInputEventQueue() {
+  nsThreadManager::get().ResumeInputEventPrioritization();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvAddDynamicScalars(
+    nsTArray<DynamicScalarDefinition>&& aDefs) {
+  TelemetryIPC::AddDynamicScalarDefinitions(aDefs);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvCrossProcessRedirect(
+    RedirectToRealChannelArgs&& aArgs,
+    nsTArray<Endpoint<extensions::PStreamFilterParent>>&& aEndpoints,
+    CrossProcessRedirectResolver&& aResolve) {
+  nsCOMPtr<nsILoadInfo> loadInfo;
+  nsresult rv = mozilla::ipc::LoadInfoArgsToLoadInfo(
+      aArgs.loadInfo(), NOT_REMOTE_TYPE, getter_AddRefs(loadInfo));
+  if (NS_FAILED(rv)) {
+    MOZ_DIAGNOSTIC_ASSERT(false, "LoadInfoArgsToLoadInfo failed");
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIChannel> newChannel;
+  MOZ_ASSERT((aArgs.loadStateInternalLoadFlags() &
+              nsDocShell::InternalLoad::INTERNAL_LOAD_FLAGS_IS_SRCDOC) ||
+             aArgs.srcdocData().IsVoid());
+  rv = nsDocShell::CreateRealChannelForDocument(
+      getter_AddRefs(newChannel), aArgs.uri(), loadInfo, nullptr,
+      aArgs.newLoadFlags(), aArgs.srcdocData(), aArgs.baseUri());
+
+  if (RefPtr<HttpBaseChannel> httpChannel = do_QueryObject(newChannel)) {
+    httpChannel->SetEarlyHints(std::move(aArgs.earlyHints()));
+    httpChannel->SetEarlyHintLinkType(aArgs.earlyHintLinkType());
+  }
+
+  // This is used to report any errors back to the parent by calling
+  // CrossProcessRedirectFinished.
+  RefPtr<HttpChannelChild> httpChild = do_QueryObject(newChannel);
+  auto resolve = [=](const nsresult& aRv) {
+    nsresult rv = aRv;
+    if (httpChild) {
+      rv = httpChild->CrossProcessRedirectFinished(rv);
+    }
+    aResolve(rv);
+  };
+  auto scopeExit = MakeScopeExit([&]() { resolve(rv); });
+
+  if (NS_FAILED(rv)) {
+    return IPC_OK();
+  }
+
+  if (nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(newChannel)) {
+    rv = httpChannel->SetChannelId(aArgs.channelId());
+  }
+  if (NS_FAILED(rv)) {
+    return IPC_OK();
+  }
+
+  rv = newChannel->SetOriginalURI(aArgs.originalURI());
+  if (NS_FAILED(rv)) {
+    return IPC_OK();
+  }
+
+  if (nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal =
+          do_QueryInterface(newChannel)) {
+    rv = httpChannelInternal->SetRedirectMode(aArgs.redirectMode());
+  }
+  if (NS_FAILED(rv)) {
+    return IPC_OK();
+  }
+
+  if (aArgs.init()) {
+    HttpBaseChannel::ReplacementChannelConfig config(std::move(*aArgs.init()));
+    HttpBaseChannel::ConfigureReplacementChannel(
+        newChannel, config,
+        HttpBaseChannel::ReplacementReason::DocumentChannel);
+  }
+
+  if (aArgs.contentDisposition()) {
+    newChannel->SetContentDisposition(*aArgs.contentDisposition());
+  }
+
+  if (aArgs.contentDispositionFilename()) {
+    newChannel->SetContentDispositionFilename(
+        *aArgs.contentDispositionFilename());
+  }
+
+  if (nsCOMPtr<nsIChildChannel> childChannel = do_QueryInterface(newChannel)) {
+    // Connect to the parent if this is a remote channel. If it's entirely
+    // handled locally, then we'll call AsyncOpen from the docshell when
+    // we complete the setup
+    rv = childChannel->ConnectParent(
+        aArgs.registrarId());  // creates parent channel
+    if (NS_FAILED(rv)) {
+      return IPC_OK();
+    }
+  }
+
+  // We need to copy the property bag before signaling that the channel
+  // is ready so that the nsDocShell can retrieve the history data when called.
+  if (nsCOMPtr<nsIWritablePropertyBag> bag = do_QueryInterface(newChannel)) {
+    nsHashPropertyBag::CopyFrom(bag, aArgs.properties());
+  }
+
+  RefPtr<nsDocShellLoadState> loadState;
+  rv = nsDocShellLoadState::CreateFromPendingChannel(
+      newChannel, aArgs.loadIdentifier(), aArgs.registrarId(),
+      getter_AddRefs(loadState));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return IPC_OK();
+  }
+  loadState->SetLoadFlags(aArgs.loadStateExternalLoadFlags());
+  loadState->SetInternalLoadFlags(aArgs.loadStateInternalLoadFlags());
+  if (IsValidLoadType(aArgs.loadStateLoadType())) {
+    loadState->SetLoadType(aArgs.loadStateLoadType());
+  }
+
+  if (aArgs.loadingSessionHistoryInfo().isSome()) {
+    loadState->SetLoadingSessionHistoryInfo(
+        aArgs.loadingSessionHistoryInfo().ref());
+  }
+  if (aArgs.originalUriString().isSome()) {
+    loadState->SetOriginalURIString(aArgs.originalUriString().ref());
+  }
+
+  RefPtr<ChildProcessChannelListener> processListener =
+      ChildProcessChannelListener::GetSingleton();
+  // The listener will call completeRedirectSetup or asyncOpen on the channel.
+  processListener->OnChannelReady(loadState, aArgs.loadIdentifier(),
+                                  std::move(aEndpoints), aArgs.timing(),
+                                  std::move(resolve));
+  scopeExit.release();
+
+  // scopeExit will call CrossProcessRedirectFinished(rv) here
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvStartDelayedAutoplayMediaComponents(
+    const MaybeDiscarded<BrowsingContext>& aContext) {
+  if (NS_WARN_IF(aContext.IsNullOrDiscarded())) {
+    return IPC_OK();
+  }
+
+  aContext.get()->StartDelayedAutoplayMediaComponents();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvUpdateMediaControlAction(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const MediaControlAction& aAction) {
+  if (NS_WARN_IF(aContext.IsNullOrDiscarded())) {
+    return IPC_OK();
+  }
+
+  ContentMediaControlKeyHandler::HandleMediaControlAction(aContext.get(),
+                                                          aAction);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvOnAllowAccessFor(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const nsCString& aTrackingOrigin, uint32_t aCookieBehavior,
+    const ContentBlockingNotifier::StorageAccessPermissionGrantedReason&
+        aReason) {
+  MOZ_ASSERT(!aContext.IsNull(), "Browsing context cannot be null");
+
+  StorageAccessAPIHelper::OnAllowAccessFor(
+      aContext.GetMaybeDiscarded(), aTrackingOrigin, aCookieBehavior, aReason);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvOnContentBlockingDecision(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const ContentBlockingNotifier::BlockingDecision& aDecision,
+    uint32_t aRejectedReason) {
+  MOZ_ASSERT(!aContext.IsNull(), "Browsing context cannot be null");
+
+  nsCOMPtr<nsPIDOMWindowOuter> outer = aContext.get()->GetDOMWindow();
+  if (!outer) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to a context without a outer "
+             "window"));
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsPIDOMWindowInner> inner = outer->GetCurrentInnerWindow();
+  if (!inner) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to a context without a inner "
+             "window"));
+    return IPC_OK();
+  }
+
+  ContentBlockingNotifier::OnDecision(inner, aDecision, aRejectedReason);
+  return IPC_OK();
+}
+
+#ifdef NIGHTLY_BUILD
+void ContentChild::OnChannelReceivedMessage(const Message& aMsg) {
+  if (nsContentUtils::IsMessageInputEvent(aMsg)) {
+    mPendingInputEvents++;
+  }
+}
+
+PContentChild::Result ContentChild::OnMessageReceived(const Message& aMsg) {
+  if (nsContentUtils::IsMessageInputEvent(aMsg)) {
+    DebugOnly<uint32_t> prevEvts = mPendingInputEvents--;
+    MOZ_ASSERT(prevEvts > 0);
+  }
+
+  return PContentChild::OnMessageReceived(aMsg);
+}
+
+PContentChild::Result ContentChild::OnMessageReceived(
+    const Message& aMsg, UniquePtr<Message>& aReply) {
+  return PContentChild::OnMessageReceived(aMsg, aReply);
+}
+#endif
+
+mozilla::ipc::IPCResult ContentChild::RecvCreateBrowsingContext(
+    uint64_t aGroupId, BrowsingContext::IPCInitializer&& aInit) {
+  // We can't already have a BrowsingContext with this ID.
+  if (RefPtr<BrowsingContext> existing = BrowsingContext::Get(aInit.mId)) {
+    return IPC_FAIL(this, "Browsing context already exists");
+  }
+
+  RefPtr<WindowContext> parent = WindowContext::GetById(aInit.mParentId);
+  if (!parent && aInit.mParentId != 0) {
+    // Handle this case by ignoring the request, as parent must be in the
+    // process of being discarded.
+    // In the future it would be nice to avoid sending this message to the child
+    // at all.
+    NS_WARNING("Attempt to attach BrowsingContext to discarded parent");
+    return IPC_OK();
+  }
+
+  RefPtr<BrowsingContextGroup> group =
+      BrowsingContextGroup::GetOrCreate(aGroupId);
+  return BrowsingContext::CreateFromIPC(std::move(aInit), group, nullptr);
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvDiscardBrowsingContext(
+    const MaybeDiscarded<BrowsingContext>& aContext, bool aDoDiscard,
+    DiscardBrowsingContextResolver&& aResolve) {
+  if (BrowsingContext* context = aContext.GetMaybeDiscarded()) {
+    if (aDoDiscard && !context->IsDiscarded()) {
+      context->Detach(/* aFromIPC */ true);
+    }
+    context->AddDiscardListener(aResolve);
+    return IPC_OK();
+  }
+
+  // Immediately resolve the promise, as we've received the message. This will
+  // allow the parent process to discard references to this BC.
+  aResolve(true);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvRegisterBrowsingContextGroup(
+    uint64_t aGroupId, nsTArray<SyncedContextInitializer>&& aInits) {
+  RefPtr<BrowsingContextGroup> group =
+      BrowsingContextGroup::GetOrCreate(aGroupId);
+
+  // Each of the initializers in aInits is sorted in pre-order, so our parent
+  // should always be available before the element itself.
+  for (auto& initUnion : aInits) {
+    switch (initUnion.type()) {
+      case SyncedContextInitializer::TBrowsingContextInitializer: {
+        auto& init = initUnion.get_BrowsingContextInitializer();
+#ifdef DEBUG
+        RefPtr<BrowsingContext> existing = BrowsingContext::Get(init.mId);
+        MOZ_ASSERT(!existing, "BrowsingContext must not exist yet!");
+
+        RefPtr<WindowContext> parent = init.GetParent();
+        MOZ_ASSERT_IF(parent, parent->Group() == group);
+#endif
+
+        BrowsingContext::CreateFromIPC(std::move(init), group, nullptr);
+        break;
+      }
+      case SyncedContextInitializer::TWindowContextInitializer: {
+        auto& init = initUnion.get_WindowContextInitializer();
+#ifdef DEBUG
+        RefPtr<WindowContext> existing =
+            WindowContext::GetById(init.mInnerWindowId);
+        MOZ_ASSERT(!existing, "WindowContext must not exist yet!");
+        RefPtr<BrowsingContext> parent =
+            BrowsingContext::Get(init.mBrowsingContextId);
+        MOZ_ASSERT(parent && parent->Group() == group);
+#endif
+
+        WindowContext::CreateFromIPC(std::move(init));
+        break;
+      };
+      default:
+        MOZ_ASSERT_UNREACHABLE();
+    }
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvDestroyBrowsingContextGroup(
+    uint64_t aGroupId) {
+  if (RefPtr<BrowsingContextGroup> group =
+          BrowsingContextGroup::GetExisting(aGroupId)) {
+    group->ChildDestroy();
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvWindowClose(
+    const MaybeDiscarded<BrowsingContext>& aContext, bool aTrustedCaller) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
+  if (!window) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ChildIPC: Trying to send a message to a context without a window"));
+    return IPC_OK();
+  }
+
+  // Call `GetDocument()` to force the document and its inner window to be
+  // created, as it would be forced to be created if this call was being
+  // performed in-process.
+  if (NS_WARN_IF(!aContext.get()->GetDocument())) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to a context but document "
+             "creation failed"));
+    return IPC_OK();
+  }
+
+  nsGlobalWindowOuter::Cast(window)->CloseOuter(aTrustedCaller);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvWindowFocus(
+    const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
+    uint64_t aActionId) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
+  if (!window) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ChildIPC: Trying to send a message to a context without a window"));
+    return IPC_OK();
+  }
+
+  // Call `GetDocument()` to force the document and its inner window to be
+  // created, as it would be forced to be created if this call was being
+  // performed in-process.
+  if (NS_WARN_IF(!aContext.get()->GetDocument())) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to a context but document "
+             "creation failed"));
+    return IPC_OK();
+  }
+
+  nsGlobalWindowOuter::Cast(window)->FocusOuter(
+      aCallerType, /* aFromOtherProcess */ true, aActionId);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvWindowBlur(
+    const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
+  if (!window) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ChildIPC: Trying to send a message to a context without a window"));
+    return IPC_OK();
+  }
+
+  // Call `GetDocument()` to force the document and its inner window to be
+  // created, as it would be forced to be created if this call was being
+  // performed in-process.
+  if (NS_WARN_IF(!aContext.get()->GetDocument())) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to a context but document "
+             "creation failed"));
+    return IPC_OK();
+  }
+
+  nsGlobalWindowOuter::Cast(window)->BlurOuter(aCallerType);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvRaiseWindow(
+    const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
+    uint64_t aActionId) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
+  if (!window) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ChildIPC: Trying to send a message to a context without a window"));
+    return IPC_OK();
+  }
+
+  if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
+    fm->RaiseWindow(window, aCallerType, aActionId);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvAdjustWindowFocus(
+    const MaybeDiscarded<BrowsingContext>& aContext, bool aIsVisible,
+    uint64_t aActionId) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
+    RefPtr<BrowsingContext> bc = aContext.get();
+    fm->AdjustInProcessWindowFocus(bc, false, aIsVisible, aActionId);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvClearFocus(
+    const MaybeDiscarded<BrowsingContext>& aContext) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
+  if (!window) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ChildIPC: Trying to send a message to a context without a window"));
+    return IPC_OK();
+  }
+
+  if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
+    fm->ClearFocus(window);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvSetFocusedBrowsingContext(
+    const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (fm) {
+    fm->SetFocusedBrowsingContextFromOtherProcess(aContext.get(), aActionId);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvSetActiveBrowsingContext(
+    const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (fm) {
+    fm->SetActiveBrowsingContextFromOtherProcess(aContext.get(), aActionId);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvAbortOrientationPendingPromises(
+    const MaybeDiscarded<BrowsingContext>& aContext) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  dom::ScreenOrientation::AbortInProcessOrientationPromises(aContext.get());
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvUnsetActiveBrowsingContext(
+    const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (fm) {
+    fm->UnsetActiveBrowsingContextFromOtherProcess(aContext.get(), aActionId);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvSetFocusedElement(
+    const MaybeDiscarded<BrowsingContext>& aContext, bool aNeedsFocus) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = aContext.get()->GetDOMWindow();
+  if (!window) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ChildIPC: Trying to send a message to a context without a window"));
+    return IPC_OK();
+  }
+
+  window->SetFocusedElement(nullptr, 0, aNeedsFocus);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvFinalizeFocusOuter(
+    const MaybeDiscarded<BrowsingContext>& aContext, bool aCanFocus,
+    CallerType aCallerType) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  if (Element* frame = aContext.get()->GetEmbedderElement()) {
+    nsContentUtils::RequestFrameFocus(*frame, aCanFocus, aCallerType);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvBlurToChild(
+    const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
+    const MaybeDiscarded<BrowsingContext>& aBrowsingContextToClear,
+    const MaybeDiscarded<BrowsingContext>& aAncestorBrowsingContextToFocus,
+    bool aIsLeavingDocument, bool aAdjustWidget, uint64_t aActionId) {
+  if (aFocusedBrowsingContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager();
+  if (MOZ_UNLIKELY(!fm)) {
+    return IPC_OK();
+  }
+
+  RefPtr<BrowsingContext> toClear = aBrowsingContextToClear.IsDiscarded()
+                                        ? nullptr
+                                        : aBrowsingContextToClear.get();
+  RefPtr<BrowsingContext> toFocus =
+      aAncestorBrowsingContextToFocus.IsDiscarded()
+          ? nullptr
+          : aAncestorBrowsingContextToFocus.get();
+
+  RefPtr<BrowsingContext> focusedBrowsingContext =
+      aFocusedBrowsingContext.get();
+
+  fm->BlurFromOtherProcess(focusedBrowsingContext, toClear, toFocus,
+                           aIsLeavingDocument, aAdjustWidget, aActionId);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvSetupFocusedAndActive(
+    const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
+    uint64_t aActionIdForFocused,
+    const MaybeDiscarded<BrowsingContext>& aActiveBrowsingContext,
+    uint64_t aActionIdForActive) {
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (fm) {
+    if (!aActiveBrowsingContext.IsNullOrDiscarded()) {
+      fm->SetActiveBrowsingContextFromOtherProcess(aActiveBrowsingContext.get(),
+                                                   aActionIdForActive);
+    }
+    if (!aFocusedBrowsingContext.IsNullOrDiscarded()) {
+      fm->SetFocusedBrowsingContextFromOtherProcess(
+          aFocusedBrowsingContext.get(), aActionIdForFocused);
+    }
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvReviseActiveBrowsingContext(
+    uint64_t aOldActionId,
+    const MaybeDiscarded<BrowsingContext>& aActiveBrowsingContext,
+    uint64_t aNewActionId) {
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (fm && !aActiveBrowsingContext.IsNullOrDiscarded()) {
+    fm->ReviseActiveBrowsingContext(aOldActionId, aActiveBrowsingContext.get(),
+                                    aNewActionId);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvReviseFocusedBrowsingContext(
+    uint64_t aOldActionId,
+    const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
+    uint64_t aNewActionId) {
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (fm && !aFocusedBrowsingContext.IsNullOrDiscarded()) {
+    fm->ReviseFocusedBrowsingContext(
+        aOldActionId, aFocusedBrowsingContext.get(), aNewActionId);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvMaybeExitFullscreen(
+    const MaybeDiscarded<BrowsingContext>& aContext) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  nsIDocShell* shell = aContext.get()->GetDocShell();
+  if (!shell) {
+    return IPC_OK();
+  }
+
+  Document* doc = shell->GetDocument();
+  if (doc && doc->GetFullscreenElement()) {
+    Document::AsyncExitFullscreen(doc);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvWindowPostMessage(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const ClonedOrErrorMessageData& aMessage, const PostMessageData& aData) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  RefPtr<nsGlobalWindowOuter> window =
+      nsGlobalWindowOuter::Cast(aContext.get()->GetDOMWindow());
+  if (!window) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ChildIPC: Trying to send a message to a context without a window"));
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIPrincipal> providedPrincipal;
+  if (!window->GetPrincipalForPostMessage(
+          aData.targetOrigin(), aData.targetOriginURI(),
+          aData.callerPrincipal(), *aData.subjectPrincipal(),
+          getter_AddRefs(providedPrincipal))) {
+    return IPC_OK();
+  }
+
+  // Call `GetDocument()` to force the document and its inner window to be
+  // created, as it would be forced to be created if this call was being
+  // performed in-process.
+  if (NS_WARN_IF(!aContext.get()->GetDocument())) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ChildIPC: Trying to send a message to a context but document "
+             "creation failed"));
+    return IPC_OK();
+  }
+
+  // It's OK if `sourceBc` has already been discarded, so long as we can
+  // continue to wrap it.
+  RefPtr<BrowsingContext> sourceBc = aData.source().GetMaybeDiscarded();
+
+  // Create and asynchronously dispatch a runnable which will handle actual DOM
+  // event creation and dispatch.
+  RefPtr<PostMessageEvent> event =
+      new PostMessageEvent(sourceBc, aData.origin(), window, providedPrincipal,
+                           aData.innerWindowId(), aData.callerURI(),
+                           aData.scriptLocation(), aData.isFromPrivateWindow());
+  event->UnpackFrom(aMessage);
+
+  event->DispatchToTargetThread(IgnoredErrorResult());
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvCommitBrowsingContextTransaction(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    BrowsingContext::BaseTransaction&& aTransaction, uint64_t aEpoch) {
+  return aTransaction.CommitFromIPC(aContext, aEpoch, this);
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvCommitWindowContextTransaction(
+    const MaybeDiscarded<WindowContext>& aContext,
+    WindowContext::BaseTransaction&& aTransaction, uint64_t aEpoch) {
+  return aTransaction.CommitFromIPC(aContext, aEpoch, this);
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvCreateWindowContext(
+    WindowContext::IPCInitializer&& aInit) {
+  RefPtr<BrowsingContext> bc = BrowsingContext::Get(aInit.mBrowsingContextId);
+  if (!bc) {
+    // Handle this case by ignoring the request, as bc must be in the process of
+    // being discarded.
+    // In the future it would be nice to avoid sending this message to the child
+    // at all.
+    NS_WARNING("Attempt to attach WindowContext to discarded parent");
+    return IPC_OK();
+  }
+
+  WindowContext::CreateFromIPC(std::move(aInit));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvDiscardWindowContext(
+    uint64_t aContextId, DiscardWindowContextResolver&& aResolve) {
+  // Resolve immediately to acknowledge call
+  aResolve(true);
+
+  RefPtr<WindowContext> window = WindowContext::GetById(aContextId);
+  if (NS_WARN_IF(!window) || NS_WARN_IF(window->IsDiscarded())) {
+    return IPC_OK();
+  }
+
+  window->Discard();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvScriptError(
+    const nsString& aMessage, const nsString& aSourceName,
+    const nsString& aSourceLine, const uint32_t& aLineNumber,
+    const uint32_t& aColNumber, const uint32_t& aFlags,
+    const nsCString& aCategory, const bool& aFromPrivateWindow,
+    const uint64_t& aInnerWindowId, const bool& aFromChromeContext) {
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIConsoleService> consoleService =
+      do_GetService(NS_CONSOLESERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, IPC_FAIL(this, "Failed to get console service"));
+
+  nsCOMPtr<nsIScriptError> scriptError(
+      do_CreateInstance(NS_SCRIPTERROR_CONTRACTID));
+  NS_ENSURE_TRUE(scriptError,
+                 IPC_FAIL(this, "Failed to construct nsIScriptError"));
+
+  scriptError->InitWithWindowID(aMessage, aSourceName, aSourceLine, aLineNumber,
+                                aColNumber, aFlags, aCategory, aInnerWindowId,
+                                aFromChromeContext);
+  rv = consoleService->LogMessage(scriptError);
+  NS_ENSURE_SUCCESS(rv, IPC_FAIL(this, "Failed to log script error"));
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvReportFrameTimingData(
+    const mozilla::Maybe<LoadInfoArgs>& loadInfoArgs, const nsString& entryName,
+    const nsString& initiatorType, UniquePtr<PerformanceTimingData>&& aData) {
+  if (!aData) {
+    return IPC_FAIL(this, "aData should not be null");
+  }
+
+  if (loadInfoArgs.isNothing()) {
+    return IPC_FAIL(this, "loadInfoArgs should not be null");
+  }
+
+  nsCOMPtr<nsILoadInfo> loadInfo;
+  nsresult rv = mozilla::ipc::LoadInfoArgsToLoadInfo(
+      loadInfoArgs, NOT_REMOTE_TYPE, getter_AddRefs(loadInfo));
+  if (NS_FAILED(rv)) {
+    MOZ_DIAGNOSTIC_ASSERT(false, "LoadInfoArgsToLoadInfo failed");
+    return IPC_OK();
+  }
+
+  // It is important to call LoadInfo::GetPerformanceStorage instead of simply
+  // getting the performance object via the innerWindowID in order to perform
+  // necessary cross origin checks.
+  if (PerformanceStorage* storage = loadInfo->GetPerformanceStorage()) {
+    storage->AddEntry(entryName, initiatorType, std::move(aData));
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvLoadURI(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    nsDocShellLoadState* aLoadState, bool aSetNavigating,
+    LoadURIResolver&& aResolve) {
+  auto resolveOnExit = MakeScopeExit([&] { aResolve(true); });
+
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  RefPtr<BrowsingContext> context = aContext.get();
+  if (!context->IsInProcess()) {
+    // The DocShell has been torn down or the BrowsingContext has changed
+    // process in the middle of the load request. There's not much we can do at
+    // this point, so just give up.
+    return IPC_OK();
+  }
+
+  context->LoadURI(aLoadState, aSetNavigating);
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = context->GetDOMWindow();
+  BrowserChild* bc = BrowserChild::GetFrom(window);
+  if (bc) {
+    bc->NotifyNavigationFinished();
+  }
+
+#ifdef MOZ_CRASHREPORTER
+  if (CrashReporter::GetEnabled()) {
+    nsCOMPtr<nsIURI> annotationURI;
+
+    nsresult rv = NS_MutateURI(aLoadState->URI())
+                      .SetUserPass(""_ns)
+                      .Finalize(annotationURI);
+
+    if (NS_FAILED(rv)) {
+      // Ignore failures on about: URIs.
+      annotationURI = aLoadState->URI();
+    }
+
+    CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::URL,
+                                       annotationURI->GetSpecOrDefault());
+  }
+#endif
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvInternalLoad(
+    nsDocShellLoadState* aLoadState) {
+  if (!aLoadState->Target().IsEmpty() ||
+      aLoadState->TargetBrowsingContext().IsNull()) {
+    return IPC_FAIL(this, "must already be retargeted");
+  }
+  if (aLoadState->TargetBrowsingContext().IsDiscarded()) {
+    return IPC_OK();
+  }
+  RefPtr<BrowsingContext> context = aLoadState->TargetBrowsingContext().get();
+
+  context->InternalLoad(aLoadState);
+
+#ifdef MOZ_CRASHREPORTER
+  if (CrashReporter::GetEnabled()) {
+    nsCOMPtr<nsIURI> annotationURI;
+
+    nsresult rv = NS_MutateURI(aLoadState->URI())
+                      .SetUserPass(""_ns)
+                      .Finalize(annotationURI);
+
+    if (NS_FAILED(rv)) {
+      // Ignore failures on about: URIs.
+      annotationURI = aLoadState->URI();
+    }
+
+    CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::URL,
+                                       annotationURI->GetSpecOrDefault());
+  }
+#endif
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvDisplayLoadError(
+    const MaybeDiscarded<BrowsingContext>& aContext, const nsAString& aURI) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  RefPtr<BrowsingContext> context = aContext.get();
+
+  context->DisplayLoadError(aURI);
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = context->GetDOMWindow();
+  BrowserChild* bc = BrowserChild::GetFrom(window);
+  if (bc) {
+    bc->NotifyNavigationFinished();
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvHistoryCommitIndexAndLength(
+    const MaybeDiscarded<BrowsingContext>& aContext, const uint32_t& aIndex,
+    const uint32_t& aLength, const nsID& aChangeID) {
+  if (!aContext.IsNullOrDiscarded()) {
+    ChildSHistory* shistory = aContext.get()->GetChildSessionHistory();
+    if (shistory) {
+      shistory->SetIndexAndLength(aIndex, aLength, aChangeID);
+    }
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvGetLayoutHistoryState(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    GetLayoutHistoryStateResolver&& aResolver) {
+  nsCOMPtr<nsILayoutHistoryState> state;
+  nsIDocShell* docShell;
+  mozilla::Maybe<mozilla::dom::Wireframe> wireframe;
+  if (!aContext.IsNullOrDiscarded() &&
+      (docShell = aContext.get()->GetDocShell())) {
+    docShell->PersistLayoutHistoryState();
+    docShell->GetLayoutHistoryState(getter_AddRefs(state));
+    wireframe = static_cast<nsDocShell*>(docShell)->GetWireframe();
+  }
+  aResolver(
+      std::tuple<nsILayoutHistoryState*, const mozilla::Maybe<Wireframe>&>(
+          state, wireframe));
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvDispatchLocationChangeEvent(
+    const MaybeDiscarded<BrowsingContext>& aContext) {
+  if (!aContext.IsNullOrDiscarded() && aContext.get()->GetDocShell()) {
+    aContext.get()->GetDocShell()->DispatchLocationChangeEvent();
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvDispatchBeforeUnloadToSubtree(
+    const MaybeDiscarded<BrowsingContext>& aStartingAt,
+    DispatchBeforeUnloadToSubtreeResolver&& aResolver) {
+  if (aStartingAt.IsNullOrDiscarded()) {
+    aResolver(nsIContentViewer::eAllowNavigation);
+  } else {
+    DispatchBeforeUnloadToSubtree(aStartingAt.get(), std::move(aResolver));
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvDecoderSupportedMimeTypes(
+    nsTArray<nsCString>&& aSupportedTypes) {
+#ifdef MOZ_WIDGET_ANDROID
+  AndroidDecoderModule::SetSupportedMimeTypes(std::move(aSupportedTypes));
+#endif
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvInitNextGenLocalStorageEnabled(
+    const bool& aEnabled) {
+  mozilla::dom::RecvInitNextGenLocalStorageEnabled(aEnabled);
+
+  return IPC_OK();
+}
+
+/* static */ void ContentChild::DispatchBeforeUnloadToSubtree(
+    BrowsingContext* aStartingAt,
+    const DispatchBeforeUnloadToSubtreeResolver& aResolver) {
+  bool resolved = false;
+
+  aStartingAt->PreOrderWalk([&](dom::BrowsingContext* aBC) {
+    if (aBC->GetDocShell()) {
+      nsCOMPtr<nsIContentViewer> contentViewer;
+      aBC->GetDocShell()->GetContentViewer(getter_AddRefs(contentViewer));
+      if (contentViewer &&
+          contentViewer->DispatchBeforeUnload() ==
+              nsIContentViewer::eRequestBlockNavigation &&
+          !resolved) {
+        // Send our response as soon as we find any blocker, so that we can show
+        // the permit unload prompt as soon as possible, without giving
+        // subsequent handlers a chance to delay it.
+        aResolver(nsIContentViewer::eRequestBlockNavigation);
+        resolved = true;
+      }
+    }
+  });
+
+  if (!resolved) {
+    aResolver(nsIContentViewer::eAllowNavigation);
+  }
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvGoBack(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const Maybe<int32_t>& aCancelContentJSEpoch, bool aRequireUserInteraction,
+    bool aUserActivation) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  BrowsingContext* bc = aContext.get();
+
+  if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
+    if (aCancelContentJSEpoch) {
+      docShell->SetCancelContentJSEpoch(*aCancelContentJSEpoch);
+    }
+    docShell->GoBack(aRequireUserInteraction, aUserActivation);
+
+    if (BrowserChild* browserChild = BrowserChild::GetFrom(docShell)) {
+      browserChild->NotifyNavigationFinished();
+    }
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvGoForward(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const Maybe<int32_t>& aCancelContentJSEpoch, bool aRequireUserInteraction,
+    bool aUserActivation) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  BrowsingContext* bc = aContext.get();
+
+  if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
+    if (aCancelContentJSEpoch) {
+      docShell->SetCancelContentJSEpoch(*aCancelContentJSEpoch);
+    }
+    docShell->GoForward(aRequireUserInteraction, aUserActivation);
+
+    if (BrowserChild* browserChild = BrowserChild::GetFrom(docShell)) {
+      browserChild->NotifyNavigationFinished();
+    }
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvGoToIndex(
+    const MaybeDiscarded<BrowsingContext>& aContext, const int32_t& aIndex,
+    const Maybe<int32_t>& aCancelContentJSEpoch, bool aUserActivation) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  BrowsingContext* bc = aContext.get();
+
+  if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
+    if (aCancelContentJSEpoch) {
+      docShell->SetCancelContentJSEpoch(*aCancelContentJSEpoch);
+    }
+    docShell->GotoIndex(aIndex, aUserActivation);
+
+    if (BrowserChild* browserChild = BrowserChild::GetFrom(docShell)) {
+      browserChild->NotifyNavigationFinished();
+    }
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvReload(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const uint32_t aReloadFlags) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  BrowsingContext* bc = aContext.get();
+
+  if (RefPtr<nsDocShell> docShell = nsDocShell::Cast(bc->GetDocShell())) {
+    docShell->Reload(aReloadFlags);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentChild::RecvStopLoad(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const uint32_t aStopFlags) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  BrowsingContext* bc = aContext.get();
+
+  if (auto* docShell = nsDocShell::Cast(bc->GetDocShell())) {
+    docShell->Stop(aStopFlags);
+  }
+
+  return IPC_OK();
+}
+
+#if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
+mozilla::ipc::IPCResult ContentChild::RecvInitSandboxTesting(
+    Endpoint<PSandboxTestingChild>&& aEndpoint) {
+  if (!SandboxTestingChild::Initialize(std::move(aEndpoint))) {
+    return IPC_FAIL(
+        this, "InitSandboxTesting failed to initialise the child process.");
+  }
+  return IPC_OK();
+}
+#endif
+
+NS_IMETHODIMP ContentChild::GetChildID(uint64_t* aOut) {
+  *aOut = mID;
+  return NS_OK;
+}
+
+NS_IMETHODIMP ContentChild::GetActor(const nsACString& aName, JSContext* aCx,
+                                     JSProcessActorChild** retval) {
+  ErrorResult error;
+  RefPtr<JSProcessActorChild> actor =
+      JSActorManager::GetActor(aCx, aName, error)
+          .downcast<JSProcessActorChild>();
+  if (error.MaybeSetPendingException(aCx)) {
+    return NS_ERROR_FAILURE;
+  }
+  actor.forget(retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP ContentChild::GetExistingActor(const nsACString& aName,
+                                             JSProcessActorChild** retval) {
+  RefPtr<JSProcessActorChild> actor =
+      JSActorManager::GetExistingActor(aName).downcast<JSProcessActorChild>();
+  actor.forget(retval);
+  return NS_OK;
+}
+
+already_AddRefed<JSActor> ContentChild::InitJSActor(
+    JS::Handle<JSObject*> aMaybeActor, const nsACString& aName,
+    ErrorResult& aRv) {
+  RefPtr<JSProcessActorChild> actor;
+  if (aMaybeActor.get()) {
+    aRv = UNWRAP_OBJECT(JSProcessActorChild, aMaybeActor.get(), actor);
+    if (aRv.Failed()) {
+      return nullptr;
+    }
+  } else {
+    actor = new JSProcessActorChild();
+  }
+
+  MOZ_RELEASE_ASSERT(!actor->Manager(),
+                     "mManager was already initialized once!");
+  actor->Init(aName, this);
+  return actor.forget();
+}
+
+IPCResult ContentChild::RecvRawMessage(const JSActorMessageMeta& aMeta,
+                                       const Maybe<ClonedMessageData>& aData,
+                                       const Maybe<ClonedMessageData>& aStack) {
+  Maybe<StructuredCloneData> data;
+  if (aData) {
+    data.emplace();
+    data->BorrowFromClonedMessageData(*aData);
+  }
+  Maybe<StructuredCloneData> stack;
+  if (aStack) {
+    stack.emplace();
+    stack->BorrowFromClonedMessageData(*aStack);
+  }
+  ReceiveRawMessage(aMeta, std::move(data), std::move(stack));
+  return IPC_OK();
+}
+
+NS_IMETHODIMP ContentChild::GetCanSend(bool* aCanSend) {
+  *aCanSend = CanSend();
+  return NS_OK;
+}
+
+ContentChild* ContentChild::AsContentChild() { return this; }
+
+JSActorManager* ContentChild::AsJSActorManager() { return this; }
+
+IPCResult ContentChild::RecvFlushFOGData(FlushFOGDataResolver&& aResolver) {
+  glean::FlushFOGData(std::move(aResolver));
+  return IPC_OK();
+}
+
+IPCResult ContentChild::RecvUpdateMediaCodecsSupported(
+    RemoteDecodeIn aLocation, const media::MediaCodecsSupported& aSupported) {
+  RemoteDecoderManagerChild::SetSupported(aLocation, aSupported);
+
+  return IPC_OK();
+}
+
+}  // namespace dom
+
+#if defined(__OpenBSD__) && defined(MOZ_SANDBOX)
+
+static LazyLogModule sPledgeLog("OpenBSDSandbox");
+
+NS_IMETHODIMP
+OpenBSDFindPledgeUnveilFilePath(const char* file, nsACString& result) {
+  struct stat st;
+
+  // Allow overriding files in /etc/$MOZ_APP_NAME
+  result.Assign(nsPrintfCString("/etc/%s/%s", MOZ_APP_NAME, file));
+  if (stat(PromiseFlatCString(result).get(), &st) == 0) {
+    return NS_OK;
+  }
+
+  // Or look in the system default directory
+  result.Assign(nsPrintfCString(
+      "/usr/local/lib/%s/browser/defaults/preferences/%s", MOZ_APP_NAME, file));
+  if (stat(PromiseFlatCString(result).get(), &st) == 0) {
+    return NS_OK;
+  }
+
+  errx(1, "can't locate %s", file);
+}
+
+NS_IMETHODIMP
+OpenBSDPledgePromises(const nsACString& aPath) {
+  // Using NS_LOCAL_FILE_CONTRACTID/NS_LOCALFILEINPUTSTREAM_CONTRACTID requires
+  // a lot of setup before they are supported and we want to pledge early on
+  // before all of that, so read the file directly
+  std::ifstream input(PromiseFlatCString(aPath).get());
+
+  // Build up one line of pledge promises without comments
+  nsAutoCString promises;
+  bool disabled = false;
+  int linenum = 0;
+  for (std::string tLine; std::getline(input, tLine);) {
+    nsAutoCString line(tLine.c_str());
+    linenum++;
+
+    // Cut off any comments at the end of the line, also catches lines
+    // that are entirely a comment
+    int32_t hash = line.FindChar('#');
+    if (hash >= 0) {
+      line = Substring(line, 0, hash);
+    }
+    line.CompressWhitespace(true, true);
+    if (line.IsEmpty()) {
+      continue;
+    }
+
+    if (linenum == 1 && line.EqualsLiteral("disable")) {
+      disabled = true;
+      break;
+    }
+
+    if (!promises.IsEmpty()) {
+      promises.Append(" ");
+    }
+    promises.Append(line);
+  }
+  input.close();
+
+  if (disabled) {
+    warnx("%s: disabled", PromiseFlatCString(aPath).get());
+  } else {
+    MOZ_LOG(
+        sPledgeLog, LogLevel::Debug,
+        ("%s: pledge(%s)\n", PromiseFlatCString(aPath).get(), promises.get()));
+    if (pledge(promises.get(), nullptr) != 0) {
+      err(1, "%s: pledge(%s) failed", PromiseFlatCString(aPath).get(),
+          promises.get());
+    }
+  }
+
+  return NS_OK;
+}
+
+void ExpandUnveilPath(nsAutoCString& path) {
+  // Expand $XDG_RUNTIME_DIR to the environment variable, or ~/.cache
+  nsCString xdgRuntimeDir(PR_GetEnv("XDG_RUNTIME_DIR"));
+  if (xdgRuntimeDir.IsEmpty()) {
+    xdgRuntimeDir = "~/.cache";
+  }
+  path.ReplaceSubstring("$XDG_RUNTIME_DIR", xdgRuntimeDir.get());
+
+  // Expand $XDG_CONFIG_HOME to the environment variable, or ~/.config
+  nsCString xdgConfigHome(PR_GetEnv("XDG_CONFIG_HOME"));
+  if (xdgConfigHome.IsEmpty()) {
+    xdgConfigHome = "~/.config";
+  }
+  path.ReplaceSubstring("$XDG_CONFIG_HOME", xdgConfigHome.get());
+
+  // Expand $XDG_CACHE_HOME to the environment variable, or ~/.cache
+  nsCString xdgCacheHome(PR_GetEnv("XDG_CACHE_HOME"));
+  if (xdgCacheHome.IsEmpty()) {
+    xdgCacheHome = "~/.cache";
+  }
+  path.ReplaceSubstring("$XDG_CACHE_HOME", xdgCacheHome.get());
+
+  // Expand $XDG_DATA_HOME to the environment variable, or ~/.local/share
+  nsCString xdgDataHome(PR_GetEnv("XDG_DATA_HOME"));
+  if (xdgDataHome.IsEmpty()) {
+    xdgDataHome = "~/.local/share";
+  }
+  path.ReplaceSubstring("$XDG_DATA_HOME", xdgDataHome.get());
+
+  // Expand leading ~ to the user's home directory
+  nsCOMPtr<nsIFile> homeDir;
+  nsresult rv =
+      GetSpecialSystemDirectory(Unix_HomeDirectory, getter_AddRefs(homeDir));
+  if (NS_FAILED(rv)) {
+    errx(1, "failed getting home directory");
+  }
+  if (path.FindChar('~') == 0) {
+    nsCString tHome(homeDir->NativePath());
+    tHome.Append(Substring(path, 1, path.Length() - 1));
+    path = tHome.get();
+  }
+}
+
+void MkdirP(nsAutoCString& path) {
+  // nsLocalFile::CreateAllAncestors would be nice to use
+
+  nsAutoCString tPath("");
+  for (const nsACString& dir : path.Split('/')) {
+    struct stat st;
+
+    if (dir.IsEmpty()) {
+      continue;
+    }
+
+    tPath.Append("/");
+    tPath.Append(dir);
+
+    if (stat(tPath.get(), &st) == -1) {
+      if (mkdir(tPath.get(), 0700) == -1) {
+        err(1, "failed mkdir(%s) while MkdirP(%s)",
+            PromiseFlatCString(tPath).get(), PromiseFlatCString(path).get());
+      }
+    }
+  }
+}
+
+NS_IMETHODIMP
+OpenBSDUnveilPaths(const nsACString& uPath, const nsACString& pledgePath) {
+  // Using NS_LOCAL_FILE_CONTRACTID/NS_LOCALFILEINPUTSTREAM_CONTRACTID requires
+  // a lot of setup before they are allowed/supported and we want to pledge and
+  // unveil early on before all of that is setup
+  std::ifstream input(PromiseFlatCString(uPath).get());
+
+  bool disabled = false;
+  int linenum = 0;
+  for (std::string tLine; std::getline(input, tLine);) {
+    nsAutoCString line(tLine.c_str());
+    linenum++;
+
+    // Cut off any comments at the end of the line, also catches lines
+    // that are entirely a comment
+    int32_t hash = line.FindChar('#');
+    if (hash >= 0) {
+      line = Substring(line, 0, hash);
+    }
+    line.CompressWhitespace(true, true);
+    if (line.IsEmpty()) {
+      continue;
+    }
+
+    if (linenum == 1 && line.EqualsLiteral("disable")) {
+      disabled = true;
+      break;
+    }
+
+    int32_t space = line.FindChar(' ');
+    if (space <= 0) {
+      errx(1, "%s: line %d: invalid format", PromiseFlatCString(uPath).get(),
+           linenum);
+    }
+
+    nsAutoCString uPath(Substring(line, 0, space));
+    ExpandUnveilPath(uPath);
+
+    nsAutoCString perms(Substring(line, space + 1, line.Length() - space - 1));
+
+    MOZ_LOG(sPledgeLog, LogLevel::Debug,
+            ("%s: unveil(%s, %s)\n", PromiseFlatCString(uPath).get(),
+             uPath.get(), perms.get()));
+    if (unveil(uPath.get(), perms.get()) == -1 && errno != ENOENT) {
+      err(1, "%s: unveil(%s, %s) failed", PromiseFlatCString(uPath).get(),
+          uPath.get(), perms.get());
+    }
+  }
+  input.close();
+
+  if (disabled) {
+    warnx("%s: disabled", PromiseFlatCString(uPath).get());
+  } else {
+    struct stat st;
+
+    // Only unveil the pledgePath file if it's not already unveiled, otherwise
+    // some containing directory will lose visibility.
+    if (stat(PromiseFlatCString(pledgePath).get(), &st) == -1) {
+      if (errno == ENOENT) {
+        if (unveil(PromiseFlatCString(pledgePath).get(), "r") == -1) {
+          err(1, "unveil(%s, r) failed", PromiseFlatCString(pledgePath).get());
+        }
+      } else {
+        err(1, "stat(%s)", PromiseFlatCString(pledgePath).get());
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+bool StartOpenBSDSandbox(GeckoProcessType type, ipc::SandboxingKind kind) {
+  nsAutoCString pledgeFile;
+  nsAutoCString unveilFile;
+  char binaryPath[MAXPATHLEN];
+
+  switch (type) {
+    case GeckoProcessType_Default: {
+      OpenBSDFindPledgeUnveilFilePath("pledge.main", pledgeFile);
+      OpenBSDFindPledgeUnveilFilePath("unveil.main", unveilFile);
+
+      // Ensure dconf dir exists before we veil the filesystem
+      nsAutoCString dConf("$XDG_RUNTIME_DIR/dconf");
+      ExpandUnveilPath(dConf);
+      MkdirP(dConf);
+      break;
+    }
+
+    case GeckoProcessType_Content:
+      OpenBSDFindPledgeUnveilFilePath("pledge.content", pledgeFile);
+      OpenBSDFindPledgeUnveilFilePath("unveil.content", unveilFile);
+      break;
+
+    case GeckoProcessType_GPU:
+      OpenBSDFindPledgeUnveilFilePath("pledge.gpu", pledgeFile);
+      OpenBSDFindPledgeUnveilFilePath("unveil.gpu", unveilFile);
+      break;
+
+    case GeckoProcessType_Socket:
+      OpenBSDFindPledgeUnveilFilePath("pledge.socket", pledgeFile);
+      OpenBSDFindPledgeUnveilFilePath("unveil.socket", unveilFile);
+      break;
+
+    case GeckoProcessType_RDD:
+      OpenBSDFindPledgeUnveilFilePath("pledge.rdd", pledgeFile);
+      OpenBSDFindPledgeUnveilFilePath("unveil.rdd", unveilFile);
+      break;
+
+    case GeckoProcessType_Utility: {
+      MOZ_RELEASE_ASSERT(kind <= SandboxingKind::COUNT,
+                         "Should define a sandbox");
+      switch (kind) {
+        case ipc::SandboxingKind::GENERIC_UTILITY:
+        default:
+          OpenBSDFindPledgeUnveilFilePath("pledge.utility", pledgeFile);
+          OpenBSDFindPledgeUnveilFilePath("unveil.utility", unveilFile);
+          break;
+      }
+    } break;
+
+    default:
+      MOZ_ASSERT(false, "unknown process type");
+      return false;
+  }
+
+  nsresult rv = mozilla::BinaryPath::Get(binaryPath);
+  if (NS_FAILED(rv)) {
+    errx(1, "failed to cache binary path ?");
+  }
+
+  if (NS_WARN_IF(NS_FAILED(OpenBSDUnveilPaths(unveilFile, pledgeFile)))) {
+    errx(1, "failed reading/parsing %s", unveilFile.get());
+  }
+
+  if (NS_WARN_IF(NS_FAILED(OpenBSDPledgePromises(pledgeFile)))) {
+    errx(1, "failed reading/parsing %s", pledgeFile.get());
+  }
+
+  // Don't overwrite an existing session dbus address, but ensure it is set
+  if (!PR_GetEnv("DBUS_SESSION_BUS_ADDRESS")) {
+    PR_SetEnv("DBUS_SESSION_BUS_ADDRESS=");
+  }
+
+  return true;
+}
+#endif
+
+}  // namespace mozilla
+
+/* static */
+nsIDOMProcessChild* nsIDOMProcessChild::GetSingleton() {
+  if (XRE_IsContentProcess()) {
+    return mozilla::dom::ContentChild::GetSingleton();
+  }
+  return mozilla::dom::InProcessChild::Singleton();
+}
diff --git a/dom/ipc/ContentChild.h b/dom/ipc/ContentChild.h
new file mode 100644
index 0000000000..0d41ad0af7
--- /dev/null
+++ b/dom/ipc/ContentChild.h
@@ -0,0 +1,894 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=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/. */
+
+#ifndef mozilla_dom_ContentChild_h
+#define mozilla_dom_ContentChild_h
+
+#include "mozilla/Atomics.h"
+#include "mozilla/dom/BlobImpl.h"
+#include "mozilla/dom/GetFilesHelper.h"
+#include "mozilla/dom/PContentChild.h"
+#include "mozilla/dom/ProcessActor.h"
+#include "mozilla/dom/RemoteType.h"
+#include "mozilla/ipc/InputStreamUtils.h"
+#include "mozilla/ipc/ProtocolUtils.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/UniquePtr.h"
+#include "nsClassHashtable.h"
+#include "nscore.h"
+#include "nsHashKeys.h"
+#include "nsIDOMProcessChild.h"
+#include "nsRefPtrHashtable.h"
+#include "nsString.h"
+#include "nsTArrayForwardDeclare.h"
+#include "nsTHashSet.h"
+
+#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
+#  include "nsIFile.h"
+#endif
+
+struct ChromePackage;
+class nsIObserver;
+struct SubstitutionMapping;
+struct OverrideMapping;
+class nsIDomainPolicy;
+class nsIURIClassifierCallback;
+class nsDocShellLoadState;
+class nsFrameLoader;
+class nsIOpenWindowInfo;
+
+namespace mozilla {
+class RemoteSpellcheckEngineChild;
+class ChildProfilerController;
+class BenchmarkStorageChild;
+
+namespace ipc {
+class UntypedEndpoint;
+}
+
+namespace loader {
+class PScriptCacheChild;
+}
+
+namespace widget {
+enum class ThemeChangeKind : uint8_t;
+}
+namespace dom {
+
+namespace ipc {
+class SharedMap;
+}
+
+class AlertObserver;
+class ConsoleListener;
+class ClonedMessageData;
+class BrowserChild;
+class TabContext;
+enum class CallerType : uint32_t;
+
+class ContentChild final : public PContentChild,
+                           public nsIDOMProcessChild,
+                           public mozilla::ipc::IShmemAllocator,
+                           public ProcessActor {
+  using ClonedMessageData = mozilla::dom::ClonedMessageData;
+  using FileDescriptor = mozilla::ipc::FileDescriptor;
+
+  friend class PContentChild;
+
+ public:
+  NS_DECL_NSIDOMPROCESSCHILD
+
+  ContentChild();
+  virtual ~ContentChild();
+  NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr) override;
+  NS_IMETHOD_(MozExternalRefCountType) AddRef(void) override { return 1; }
+  NS_IMETHOD_(MozExternalRefCountType) Release(void) override { return 1; }
+
+  struct AppInfo {
+    nsCString version;
+    nsCString buildID;
+    nsCString name;
+    nsCString UAName;
+    nsCString ID;
+    nsCString vendor;
+    nsCString sourceURL;
+    nsCString updateURL;
+  };
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY nsresult ProvideWindowCommon(
+      NotNull<BrowserChild*> aTabOpener, nsIOpenWindowInfo* aOpenWindowInfo,
+      uint32_t aChromeFlags, bool aCalledFromJS, nsIURI* aURI,
+      const nsAString& aName, const nsACString& aFeatures, bool aForceNoOpener,
+      bool aForceNoReferrer, bool aIsPopupRequested,
+      nsDocShellLoadState* aLoadState, bool* aWindowIsNew,
+      BrowsingContext** aReturn);
+
+  void Init(mozilla::ipc::UntypedEndpoint&& aEndpoint,
+            const char* aParentBuildID, uint64_t aChildID, bool aIsForBrowser);
+
+  void InitXPCOM(XPCOMInitData&& aXPCOMInit,
+                 const mozilla::dom::ipc::StructuredCloneData& aInitialData,
+                 bool aIsReadyForBackgroundProcessing);
+
+  void InitSharedUASheets(Maybe<base::SharedMemoryHandle>&& aHandle,
+                          uintptr_t aAddress);
+
+  void InitGraphicsDeviceData(const ContentDeviceData& aData);
+
+  static ContentChild* GetSingleton() { return sSingleton; }
+
+  const AppInfo& GetAppInfo() { return mAppInfo; }
+
+  void SetProcessName(const nsACString& aName,
+                      const nsACString* aETLDplus1 = nullptr,
+                      const nsACString* aCurrentProfile = nullptr);
+
+  void GetProcessName(nsACString& aName) const;
+
+#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
+  void GetProfileDir(nsIFile** aProfileDir) const {
+    *aProfileDir = mProfileDir;
+    NS_IF_ADDREF(*aProfileDir);
+  }
+
+  void SetProfileDir(nsIFile* aProfileDir) { mProfileDir = aProfileDir; }
+#endif
+
+  bool IsAlive() const;
+
+  bool IsShuttingDown() const;
+
+  ipc::SharedMap* SharedData() { return mSharedData; };
+
+  static void AppendProcessId(nsACString& aName);
+
+  static void UpdateCookieStatus(nsIChannel* aChannel);
+
+  mozilla::ipc::IPCResult RecvInitGMPService(
+      Endpoint<PGMPServiceChild>&& aGMPService);
+
+  mozilla::ipc::IPCResult RecvInitProfiler(
+      Endpoint<PProfilerChild>&& aEndpoint);
+
+  mozilla::ipc::IPCResult RecvGMPsChanged(
+      nsTArray<GMPCapabilityData>&& capabilities);
+
+  mozilla::ipc::IPCResult RecvInitProcessHangMonitor(
+      Endpoint<PProcessHangMonitorChild>&& aHangMonitor);
+
+  mozilla::ipc::IPCResult RecvInitRendering(
+      Endpoint<PCompositorManagerChild>&& aCompositor,
+      Endpoint<PImageBridgeChild>&& aImageBridge,
+      Endpoint<PVRManagerChild>&& aVRBridge,
+      Endpoint<PRemoteDecoderManagerChild>&& aVideoManager,
+      nsTArray<uint32_t>&& namespaces);
+
+  mozilla::ipc::IPCResult RecvRequestPerformanceMetrics(const nsID& aID);
+
+  mozilla::ipc::IPCResult RecvReinitRendering(
+      Endpoint<PCompositorManagerChild>&& aCompositor,
+      Endpoint<PImageBridgeChild>&& aImageBridge,
+      Endpoint<PVRManagerChild>&& aVRBridge,
+      Endpoint<PRemoteDecoderManagerChild>&& aVideoManager,
+      nsTArray<uint32_t>&& namespaces);
+
+  mozilla::ipc::IPCResult RecvReinitRenderingForDeviceReset();
+
+  mozilla::ipc::IPCResult RecvSetProcessSandbox(
+      const Maybe<FileDescriptor>& aBroker);
+
+  PHalChild* AllocPHalChild();
+  bool DeallocPHalChild(PHalChild*);
+
+  PHeapSnapshotTempFileHelperChild* AllocPHeapSnapshotTempFileHelperChild();
+
+  bool DeallocPHeapSnapshotTempFileHelperChild(
+      PHeapSnapshotTempFileHelperChild*);
+
+  PCycleCollectWithLogsChild* AllocPCycleCollectWithLogsChild(
+      const bool& aDumpAllTraces, const FileDescriptor& aGCLog,
+      const FileDescriptor& aCCLog);
+
+  bool DeallocPCycleCollectWithLogsChild(PCycleCollectWithLogsChild* aActor);
+
+  virtual mozilla::ipc::IPCResult RecvPCycleCollectWithLogsConstructor(
+      PCycleCollectWithLogsChild* aChild, const bool& aDumpAllTraces,
+      const FileDescriptor& aGCLog, const FileDescriptor& aCCLog) override;
+
+  PWebBrowserPersistDocumentChild* AllocPWebBrowserPersistDocumentChild(
+      PBrowserChild* aBrowser, const MaybeDiscarded<BrowsingContext>& aContext);
+
+  virtual mozilla::ipc::IPCResult RecvPWebBrowserPersistDocumentConstructor(
+      PWebBrowserPersistDocumentChild* aActor, PBrowserChild* aBrowser,
+      const MaybeDiscarded<BrowsingContext>& aContext) override;
+
+  bool DeallocPWebBrowserPersistDocumentChild(
+      PWebBrowserPersistDocumentChild* aActor);
+
+  PTestShellChild* AllocPTestShellChild();
+
+  bool DeallocPTestShellChild(PTestShellChild*);
+
+  virtual mozilla::ipc::IPCResult RecvPTestShellConstructor(
+      PTestShellChild*) override;
+
+  PScriptCacheChild* AllocPScriptCacheChild(const FileDescOrError& cacheFile,
+                                            const bool& wantCacheData);
+
+  bool DeallocPScriptCacheChild(PScriptCacheChild*);
+
+  virtual mozilla::ipc::IPCResult RecvPScriptCacheConstructor(
+      PScriptCacheChild*, const FileDescOrError& cacheFile,
+      const bool& wantCacheData) override;
+
+  PRemotePrintJobChild* AllocPRemotePrintJobChild();
+
+  PMediaChild* AllocPMediaChild();
+
+  bool DeallocPMediaChild(PMediaChild* aActor);
+
+  PBenchmarkStorageChild* AllocPBenchmarkStorageChild();
+
+  bool DeallocPBenchmarkStorageChild(PBenchmarkStorageChild* aActor);
+
+  mozilla::ipc::IPCResult RecvNotifyEmptyHTTPCache();
+
+#ifdef MOZ_WEBSPEECH
+  PSpeechSynthesisChild* AllocPSpeechSynthesisChild();
+  bool DeallocPSpeechSynthesisChild(PSpeechSynthesisChild* aActor);
+#endif
+
+  mozilla::ipc::IPCResult RecvRegisterChrome(
+      nsTArray<ChromePackage>&& packages,
+      nsTArray<SubstitutionMapping>&& resources,
+      nsTArray<OverrideMapping>&& overrides, const nsCString& locale,
+      const bool& reset);
+  mozilla::ipc::IPCResult RecvRegisterChromeItem(
+      const ChromeRegistryItem& item);
+
+  mozilla::ipc::IPCResult RecvClearStyleSheetCache(
+      const Maybe<RefPtr<nsIPrincipal>>& aForPrincipal,
+      const Maybe<nsCString>& aBaseDomain);
+
+  mozilla::ipc::IPCResult RecvClearImageCacheFromPrincipal(
+      nsIPrincipal* aPrincipal);
+  mozilla::ipc::IPCResult RecvClearImageCacheFromBaseDomain(
+      const nsCString& aBaseDomain);
+  mozilla::ipc::IPCResult RecvClearImageCache(const bool& privateLoader,
+                                              const bool& chrome);
+
+  PRemoteSpellcheckEngineChild* AllocPRemoteSpellcheckEngineChild();
+
+  bool DeallocPRemoteSpellcheckEngineChild(PRemoteSpellcheckEngineChild*);
+
+  mozilla::ipc::IPCResult RecvSetOffline(const bool& offline);
+
+  mozilla::ipc::IPCResult RecvSetConnectivity(const bool& connectivity);
+  mozilla::ipc::IPCResult RecvSetCaptivePortalState(const int32_t& state);
+  mozilla::ipc::IPCResult RecvSetTRRMode(
+      const nsIDNSService::ResolverMode& mode,
+      const nsIDNSService::ResolverMode& modeFromPref);
+
+  mozilla::ipc::IPCResult RecvBidiKeyboardNotify(const bool& isLangRTL,
+                                                 const bool& haveBidiKeyboards);
+
+  mozilla::ipc::IPCResult RecvNotifyVisited(nsTArray<VisitedQueryResult>&&);
+
+  mozilla::ipc::IPCResult RecvThemeChanged(FullLookAndFeel&&,
+                                           widget::ThemeChangeKind);
+
+  // auto remove when alertfinished is received.
+  nsresult AddRemoteAlertObserver(const nsString& aData,
+                                  nsIObserver* aObserver);
+
+  mozilla::ipc::IPCResult RecvPreferenceUpdate(const Pref& aPref);
+  mozilla::ipc::IPCResult RecvVarUpdate(const GfxVarUpdate& pref);
+
+  mozilla::ipc::IPCResult RecvUpdatePerfStatsCollectionMask(
+      const uint64_t& aMask);
+
+  mozilla::ipc::IPCResult RecvCollectPerfStatsJSON(
+      CollectPerfStatsJSONResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvCollectScrollingMetrics(
+      CollectScrollingMetricsResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvNotifyAlertsObserver(const nsCString& aType,
+                                                   const nsString& aData);
+
+  mozilla::ipc::IPCResult RecvLoadProcessScript(const nsString& aURL);
+
+  mozilla::ipc::IPCResult RecvAsyncMessage(const nsString& aMsg,
+                                           const ClonedMessageData& aData);
+
+  mozilla::ipc::IPCResult RecvRegisterStringBundles(
+      nsTArray<StringBundleDescriptor>&& stringBundles);
+
+  mozilla::ipc::IPCResult RecvUpdateL10nFileSources(
+      nsTArray<L10nFileSourceDescriptor>&& aDescriptors);
+
+  mozilla::ipc::IPCResult RecvUpdateSharedData(
+      const FileDescriptor& aMapFile, const uint32_t& aMapSize,
+      nsTArray<IPCBlob>&& aBlobs, nsTArray<nsCString>&& aChangedKeys);
+
+  mozilla::ipc::IPCResult RecvFontListChanged();
+  mozilla::ipc::IPCResult RecvForceGlobalReflow(bool aNeedsReframe);
+
+  mozilla::ipc::IPCResult RecvGeolocationUpdate(nsIDOMGeoPosition* aPosition);
+
+  // MOZ_CAN_RUN_SCRIPT_BOUNDARY because we don't have MOZ_CAN_RUN_SCRIPT bits
+  // in IPC code yet.
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  mozilla::ipc::IPCResult RecvGeolocationError(const uint16_t& errorCode);
+
+  mozilla::ipc::IPCResult RecvUpdateDictionaryList(
+      nsTArray<nsCString>&& aDictionaries);
+
+  mozilla::ipc::IPCResult RecvUpdateFontList(SystemFontList&&);
+  mozilla::ipc::IPCResult RecvRebuildFontList(const bool& aFullRebuild);
+  mozilla::ipc::IPCResult RecvFontListShmBlockAdded(
+      const uint32_t& aGeneration, const uint32_t& aIndex,
+      base::SharedMemoryHandle&& aHandle);
+
+  mozilla::ipc::IPCResult RecvUpdateAppLocales(
+      nsTArray<nsCString>&& aAppLocales);
+  mozilla::ipc::IPCResult RecvUpdateRequestedLocales(
+      nsTArray<nsCString>&& aRequestedLocales);
+
+  mozilla::ipc::IPCResult RecvSystemTimezoneChanged();
+
+  mozilla::ipc::IPCResult RecvAddPermission(const IPC::Permission& permission);
+
+  mozilla::ipc::IPCResult RecvRemoveAllPermissions();
+
+  mozilla::ipc::IPCResult RecvFlushMemory(const nsString& reason);
+
+  mozilla::ipc::IPCResult RecvActivateA11y();
+  mozilla::ipc::IPCResult RecvShutdownA11y();
+
+  mozilla::ipc::IPCResult RecvApplicationForeground();
+  mozilla::ipc::IPCResult RecvApplicationBackground();
+  mozilla::ipc::IPCResult RecvGarbageCollect();
+  mozilla::ipc::IPCResult RecvCycleCollect();
+  mozilla::ipc::IPCResult RecvUnlinkGhosts();
+
+  mozilla::ipc::IPCResult RecvAppInfo(
+      const nsCString& version, const nsCString& buildID, const nsCString& name,
+      const nsCString& UAName, const nsCString& ID, const nsCString& vendor,
+      const nsCString& sourceURL, const nsCString& updateURL);
+
+  mozilla::ipc::IPCResult RecvRemoteType(const nsCString& aRemoteType,
+                                         const nsCString& aProfile);
+
+  void PreallocInit();
+
+  // Call RemoteTypePrefix() on the result to remove URIs if you want to use
+  // this for telemetry.
+  const nsACString& GetRemoteType() const override;
+
+  mozilla::ipc::IPCResult RecvInitBlobURLs(
+      nsTArray<BlobURLRegistrationData>&& aRegistations);
+
+  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(
+      const hal::ProcessPriority& aPriority);
+
+  mozilla::ipc::IPCResult RecvMinimizeMemoryUsage();
+
+  mozilla::ipc::IPCResult RecvLoadAndRegisterSheet(nsIURI* aURI,
+                                                   const uint32_t& aType);
+
+  mozilla::ipc::IPCResult RecvUnregisterSheet(nsIURI* aURI,
+                                              const uint32_t& aType);
+
+  void AddIdleObserver(nsIObserver* aObserver, uint32_t aIdleTimeInS);
+
+  void RemoveIdleObserver(nsIObserver* aObserver, uint32_t aIdleTimeInS);
+
+  mozilla::ipc::IPCResult RecvNotifyIdleObserver(const uint64_t& aObserver,
+                                                 const nsCString& aTopic,
+                                                 const nsString& aData);
+
+  mozilla::ipc::IPCResult RecvUpdateWindow(const uintptr_t& aChildId);
+
+  mozilla::ipc::IPCResult RecvDomainSetChanged(const uint32_t& aSetType,
+                                               const uint32_t& aChangeType,
+                                               nsIURI* aDomain);
+
+  mozilla::ipc::IPCResult RecvShutdownConfirmedHP();
+
+  mozilla::ipc::IPCResult RecvShutdown();
+
+  mozilla::ipc::IPCResult RecvInvokeDragSession(
+      const MaybeDiscarded<WindowContext>& aSourceWindowContext,
+      const MaybeDiscarded<WindowContext>& aSourceTopWindowContext,
+      nsTArray<IPCTransferableData>&& aTransferables, const uint32_t& aAction);
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  mozilla::ipc::IPCResult RecvEndDragSession(
+      const bool& aDoneDrag, const bool& aUserCancelled,
+      const mozilla::LayoutDeviceIntPoint& aEndDragPoint,
+      const uint32_t& aKeyModifiers, const uint32_t& aDropEffect);
+
+  mozilla::ipc::IPCResult RecvPush(const nsCString& aScope,
+                                   nsIPrincipal* aPrincipal,
+                                   const nsString& aMessageId);
+
+  mozilla::ipc::IPCResult RecvPushWithData(const nsCString& aScope,
+                                           nsIPrincipal* aPrincipal,
+                                           const nsString& aMessageId,
+                                           nsTArray<uint8_t>&& aData);
+
+  mozilla::ipc::IPCResult RecvPushSubscriptionChange(const nsCString& aScope,
+                                                     nsIPrincipal* aPrincipal);
+
+  mozilla::ipc::IPCResult RecvPushError(const nsCString& aScope,
+                                        nsIPrincipal* aPrincipal,
+                                        const nsString& aMessage,
+                                        const uint32_t& aFlags);
+
+  mozilla::ipc::IPCResult RecvNotifyPushSubscriptionModifiedObservers(
+      const nsCString& aScope, nsIPrincipal* aPrincipal);
+
+  mozilla::ipc::IPCResult RecvRefreshScreens(
+      nsTArray<ScreenDetails>&& aScreens);
+
+  mozilla::ipc::IPCResult RecvNetworkLinkTypeChange(const uint32_t& aType);
+  uint32_t NetworkLinkType() const { return mNetworkLinkType; }
+
+  mozilla::ipc::IPCResult RecvSocketProcessCrashed();
+
+  // Get the directory for IndexedDB files. We query the parent for this and
+  // cache the value
+  nsString& GetIndexedDBPath();
+
+  ContentParentId GetID() const { return mID; }
+
+  bool IsForBrowser() const { return mIsForBrowser; }
+
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvConstructBrowser(
+      ManagedEndpoint<PBrowserChild>&& aBrowserEp,
+      ManagedEndpoint<PWindowGlobalChild>&& aWindowEp, const TabId& aTabId,
+      const IPCTabContext& aContext, const WindowGlobalInit& aWindowInit,
+      const uint32_t& aChromeFlags, const ContentParentId& aCpID,
+      const bool& aIsForBrowser, const bool& aIsTopLevel);
+
+  FORWARD_SHMEM_ALLOCATOR_TO(PContentChild)
+
+  void GetAvailableDictionaries(nsTArray<nsCString>& aDictionaries);
+
+#ifdef MOZ_WEBRTC
+  PWebrtcGlobalChild* AllocPWebrtcGlobalChild();
+  bool DeallocPWebrtcGlobalChild(PWebrtcGlobalChild* aActor);
+#endif
+
+  PContentPermissionRequestChild* AllocPContentPermissionRequestChild(
+      Span<const PermissionRequest> aRequests, nsIPrincipal* aPrincipal,
+      nsIPrincipal* aTopLevelPrincipal, const bool& aIsHandlingUserInput,
+      const bool& aMaybeUnsafePermissionDelegate, const TabId& aTabId);
+  bool DeallocPContentPermissionRequestChild(
+      PContentPermissionRequestChild* actor);
+
+  // GetFiles for WebKit/Blink FileSystem API and Directory API must run on the
+  // parent process.
+  void CreateGetFilesRequest(const nsAString& aDirectoryPath,
+                             bool aRecursiveFlag, nsID& aUUID,
+                             GetFilesHelperChild* aChild);
+
+  void DeleteGetFilesRequest(nsID& aUUID, GetFilesHelperChild* aChild);
+
+  mozilla::ipc::IPCResult RecvGetFilesResponse(
+      const nsID& aUUID, const GetFilesResponseResult& aResult);
+
+  mozilla::ipc::IPCResult RecvBlobURLRegistration(
+      const nsCString& aURI, const IPCBlob& aBlob, nsIPrincipal* aPrincipal,
+      const Maybe<nsID>& aAgentClusterId);
+
+  mozilla::ipc::IPCResult RecvBlobURLUnregistration(const nsCString& aURI);
+
+  mozilla::ipc::IPCResult RecvRequestMemoryReport(
+      const uint32_t& generation, const bool& anonymize,
+      const bool& minimizeMemoryUsage, const Maybe<FileDescriptor>& DMDFile,
+      const RequestMemoryReportResolver& aResolver);
+
+#if defined(XP_WIN)
+  mozilla::ipc::IPCResult RecvGetUntrustedModulesData(
+      GetUntrustedModulesDataResolver&& aResolver);
+  mozilla::ipc::IPCResult RecvUnblockUntrustedModulesThread();
+#endif  // defined(XP_WIN)
+
+  mozilla::ipc::IPCResult RecvSetXPCOMProcessAttributes(
+      XPCOMInitData&& aXPCOMInit, const StructuredCloneData& aInitialData,
+      FullLookAndFeel&& aLookAndFeelData, SystemFontList&& aFontList,
+      Maybe<base::SharedMemoryHandle>&& aSharedUASheetHandle,
+      const uintptr_t& aSharedUASheetAddress,
+      nsTArray<base::SharedMemoryHandle>&& aSharedFontListBlocks,
+      const bool& aIsReadyForBackgroundProcessing);
+
+  mozilla::ipc::IPCResult RecvProvideAnonymousTemporaryFile(
+      const uint64_t& aID, const FileDescOrError& aFD);
+
+  mozilla::ipc::IPCResult RecvSetPermissionsWithKey(
+      const nsCString& aPermissionKey, nsTArray<IPC::Permission>&& aPerms);
+
+  mozilla::ipc::IPCResult RecvShareCodeCoverageMutex(
+      CrossProcessMutexHandle aHandle);
+
+  mozilla::ipc::IPCResult RecvFlushCodeCoverageCounters(
+      FlushCodeCoverageCountersResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvSetInputEventQueueEnabled();
+
+  mozilla::ipc::IPCResult RecvFlushInputEventQueue();
+
+  mozilla::ipc::IPCResult RecvSuspendInputEventQueue();
+
+  mozilla::ipc::IPCResult RecvResumeInputEventQueue();
+
+  mozilla::ipc::IPCResult RecvAddDynamicScalars(
+      nsTArray<DynamicScalarDefinition>&& aDefs);
+
+  // Get a reference to the font list passed from the chrome process,
+  // for use during gfx initialization.
+  SystemFontList& SystemFontList() { return mFontList; }
+
+  nsTArray<base::SharedMemoryHandle>& SharedFontListBlocks() {
+    return mSharedFontListBlocks;
+  }
+
+  // PURLClassifierChild
+  PURLClassifierChild* AllocPURLClassifierChild(nsIPrincipal* aPrincipal,
+                                                bool* aSuccess);
+  bool DeallocPURLClassifierChild(PURLClassifierChild* aActor);
+
+  // PURLClassifierLocalChild
+  PURLClassifierLocalChild* AllocPURLClassifierLocalChild(
+      nsIURI* aUri, Span<const IPCURLClassifierFeature> aFeatures);
+  bool DeallocPURLClassifierLocalChild(PURLClassifierLocalChild* aActor);
+
+  PLoginReputationChild* AllocPLoginReputationChild(nsIURI* aUri);
+
+  bool DeallocPLoginReputationChild(PLoginReputationChild* aActor);
+
+  PSessionStorageObserverChild* AllocPSessionStorageObserverChild();
+
+  bool DeallocPSessionStorageObserverChild(
+      PSessionStorageObserverChild* aActor);
+
+  FullLookAndFeel& BorrowLookAndFeelData() { return mLookAndFeelData; }
+
+  /**
+   * Helper function for protocols that use the GPU process when available.
+   * Overrides FatalError to just be a warning when communicating with the
+   * GPU process since we don't want to crash the content process when the
+   * GPU process crashes.
+   */
+  static void FatalErrorIfNotUsingGPUProcess(const char* const aErrorMsg,
+                                             base::ProcessId aOtherPid);
+
+  using AnonymousTemporaryFileCallback = std::function<void(PRFileDesc*)>;
+  nsresult AsyncOpenAnonymousTemporaryFile(
+      const AnonymousTemporaryFileCallback& aCallback);
+
+  mozilla::ipc::IPCResult RecvSaveRecording(const FileDescriptor& aFile);
+
+  mozilla::ipc::IPCResult RecvCrossProcessRedirect(
+      RedirectToRealChannelArgs&& aArgs,
+      nsTArray<Endpoint<extensions::PStreamFilterParent>>&& aEndpoints,
+      CrossProcessRedirectResolver&& aResolve);
+
+  mozilla::ipc::IPCResult RecvStartDelayedAutoplayMediaComponents(
+      const MaybeDiscarded<BrowsingContext>& aContext);
+
+  mozilla::ipc::IPCResult RecvUpdateMediaControlAction(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const MediaControlAction& aAction);
+
+  // See `BrowsingContext::mEpochs` for an explanation of this field.
+  uint64_t GetBrowsingContextFieldEpoch() const {
+    return mBrowsingContextFieldEpoch;
+  }
+  uint64_t NextBrowsingContextFieldEpoch() {
+    mBrowsingContextFieldEpoch++;
+    return mBrowsingContextFieldEpoch;
+  }
+
+  mozilla::ipc::IPCResult RecvOnAllowAccessFor(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const nsCString& aTrackingOrigin, uint32_t aCookieBehavior,
+      const ContentBlockingNotifier::StorageAccessPermissionGrantedReason&
+          aReason);
+
+  mozilla::ipc::IPCResult RecvOnContentBlockingDecision(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const ContentBlockingNotifier::BlockingDecision& aDecision,
+      uint32_t aRejectedReason);
+
+#ifdef NIGHTLY_BUILD
+  // Fetch the current number of pending input events.
+  //
+  // NOTE: This method performs an atomic read, and is safe to call from all
+  // threads.
+  uint32_t GetPendingInputEvents() { return mPendingInputEvents; }
+#endif
+
+#if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
+  mozilla::ipc::IPCResult RecvInitSandboxTesting(
+      Endpoint<PSandboxTestingChild>&& aEndpoint);
+#endif
+
+ private:
+  static void ForceKillTimerCallback(nsITimer* aTimer, void* aClosure);
+  void StartForceKillTimer();
+
+  void ShutdownInternal();
+
+  mozilla::ipc::IPCResult GetResultForRenderingInitFailure(
+      base::ProcessId aOtherPid);
+
+  virtual void ActorDestroy(ActorDestroyReason why) override;
+
+  virtual void ProcessingError(Result aCode, const char* aReason) override;
+
+  mozilla::ipc::IPCResult RecvCreateBrowsingContext(
+      uint64_t aGroupId, BrowsingContext::IPCInitializer&& aInit);
+
+  mozilla::ipc::IPCResult RecvDiscardBrowsingContext(
+      const MaybeDiscarded<BrowsingContext>& aContext, bool aDoDiscard,
+      DiscardBrowsingContextResolver&& aResolve);
+
+  mozilla::ipc::IPCResult RecvRegisterBrowsingContextGroup(
+      uint64_t aGroupId, nsTArray<SyncedContextInitializer>&& aInits);
+  mozilla::ipc::IPCResult RecvDestroyBrowsingContextGroup(uint64_t aGroupId);
+
+  mozilla::ipc::IPCResult RecvWindowClose(
+      const MaybeDiscarded<BrowsingContext>& aContext, bool aTrustedCaller);
+  mozilla::ipc::IPCResult RecvWindowFocus(
+      const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
+      uint64_t aActionId);
+  mozilla::ipc::IPCResult RecvWindowBlur(
+      const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType);
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvRaiseWindow(
+      const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
+      uint64_t aActionId);
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvAdjustWindowFocus(
+      const MaybeDiscarded<BrowsingContext>& aContext, bool aIsVisible,
+      uint64_t aActionId);
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvClearFocus(
+      const MaybeDiscarded<BrowsingContext>& aContext);
+  mozilla::ipc::IPCResult RecvSetFocusedBrowsingContext(
+      const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId);
+  mozilla::ipc::IPCResult RecvSetActiveBrowsingContext(
+      const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId);
+  mozilla::ipc::IPCResult RecvAbortOrientationPendingPromises(
+      const MaybeDiscarded<BrowsingContext>& aContext);
+  mozilla::ipc::IPCResult RecvUnsetActiveBrowsingContext(
+      const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId);
+  mozilla::ipc::IPCResult RecvSetFocusedElement(
+      const MaybeDiscarded<BrowsingContext>& aContext, bool aNeedsFocus);
+  mozilla::ipc::IPCResult RecvFinalizeFocusOuter(
+      const MaybeDiscarded<BrowsingContext>& aContext, bool aCanFocus,
+      CallerType aCallerType);
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvBlurToChild(
+      const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
+      const MaybeDiscarded<BrowsingContext>& aBrowsingContextToClear,
+      const MaybeDiscarded<BrowsingContext>& aAncestorBrowsingContextToFocus,
+      bool aIsLeavingDocument, bool aAdjustWidget, uint64_t aActionId);
+  mozilla::ipc::IPCResult RecvSetupFocusedAndActive(
+      const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
+      uint64_t aActionIdForFocused,
+      const MaybeDiscarded<BrowsingContext>& aActiveBrowsingContext,
+      uint64_t aActionIdForActive);
+  mozilla::ipc::IPCResult RecvReviseActiveBrowsingContext(
+      uint64_t aOldActionId,
+      const MaybeDiscarded<BrowsingContext>& aActiveBrowsingContext,
+      uint64_t aNewActionId);
+  mozilla::ipc::IPCResult RecvReviseFocusedBrowsingContext(
+      uint64_t aOldActionId,
+      const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
+      uint64_t aNewActionId);
+  mozilla::ipc::IPCResult RecvMaybeExitFullscreen(
+      const MaybeDiscarded<BrowsingContext>& aContext);
+
+  mozilla::ipc::IPCResult RecvWindowPostMessage(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const ClonedOrErrorMessageData& aMessage, const PostMessageData& aData);
+
+  mozilla::ipc::IPCResult RecvCommitBrowsingContextTransaction(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      BrowsingContext::BaseTransaction&& aTransaction, uint64_t aEpoch);
+
+  mozilla::ipc::IPCResult RecvCommitWindowContextTransaction(
+      const MaybeDiscarded<WindowContext>& aContext,
+      WindowContext::BaseTransaction&& aTransaction, uint64_t aEpoch);
+
+  mozilla::ipc::IPCResult RecvCreateWindowContext(
+      WindowContext::IPCInitializer&& aInit);
+  mozilla::ipc::IPCResult RecvDiscardWindowContext(
+      uint64_t aContextId, DiscardWindowContextResolver&& aResolve);
+
+  mozilla::ipc::IPCResult RecvScriptError(
+      const nsString& aMessage, const nsString& aSourceName,
+      const nsString& aSourceLine, const uint32_t& aLineNumber,
+      const uint32_t& aColNumber, const uint32_t& aFlags,
+      const nsCString& aCategory, const bool& aFromPrivateWindow,
+      const uint64_t& aInnerWindowId, const bool& aFromChromeContext);
+
+  mozilla::ipc::IPCResult RecvReportFrameTimingData(
+      const mozilla::Maybe<LoadInfoArgs>& loadInfoArgs,
+      const nsString& entryName, const nsString& initiatorType,
+      UniquePtr<PerformanceTimingData>&& aData);
+
+  mozilla::ipc::IPCResult RecvLoadURI(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      nsDocShellLoadState* aLoadState, bool aSetNavigating,
+      LoadURIResolver&& aResolve);
+
+  mozilla::ipc::IPCResult RecvInternalLoad(nsDocShellLoadState* aLoadState);
+
+  mozilla::ipc::IPCResult RecvDisplayLoadError(
+      const MaybeDiscarded<BrowsingContext>& aContext, const nsAString& aURI);
+
+  mozilla::ipc::IPCResult RecvGoBack(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const Maybe<int32_t>& aCancelContentJSEpoch, bool aRequireUserInteraction,
+      bool aUserActivation);
+  mozilla::ipc::IPCResult RecvGoForward(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const Maybe<int32_t>& aCancelContentJSEpoch, bool aRequireUserInteraction,
+      bool aUserActivation);
+  mozilla::ipc::IPCResult RecvGoToIndex(
+      const MaybeDiscarded<BrowsingContext>& aContext, const int32_t& aIndex,
+      const Maybe<int32_t>& aCancelContentJSEpoch, bool aUserActivation);
+  mozilla::ipc::IPCResult RecvReload(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const uint32_t aReloadFlags);
+  mozilla::ipc::IPCResult RecvStopLoad(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const uint32_t aStopFlags);
+
+  mozilla::ipc::IPCResult RecvRawMessage(
+      const JSActorMessageMeta& aMeta, const Maybe<ClonedMessageData>& aData,
+      const Maybe<ClonedMessageData>& aStack);
+
+  already_AddRefed<JSActor> InitJSActor(JS::Handle<JSObject*> aMaybeActor,
+                                        const nsACString& aName,
+                                        ErrorResult& aRv) override;
+  mozilla::ipc::IProtocol* AsNativeActor() override { return this; }
+
+  mozilla::ipc::IPCResult RecvHistoryCommitIndexAndLength(
+      const MaybeDiscarded<BrowsingContext>& aContext, const uint32_t& aIndex,
+      const uint32_t& aLength, const nsID& aChangeID);
+
+  mozilla::ipc::IPCResult RecvGetLayoutHistoryState(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      GetLayoutHistoryStateResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvDispatchLocationChangeEvent(
+      const MaybeDiscarded<BrowsingContext>& aContext);
+
+  mozilla::ipc::IPCResult RecvDispatchBeforeUnloadToSubtree(
+      const MaybeDiscarded<BrowsingContext>& aStartingAt,
+      DispatchBeforeUnloadToSubtreeResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvDecoderSupportedMimeTypes(
+      nsTArray<nsCString>&& aSupportedTypes);
+
+  mozilla::ipc::IPCResult RecvInitNextGenLocalStorageEnabled(
+      const bool& aEnabled);
+
+ public:
+  static void DispatchBeforeUnloadToSubtree(
+      BrowsingContext* aStartingAt,
+      const DispatchBeforeUnloadToSubtreeResolver& aResolver);
+
+  hal::ProcessPriority GetProcessPriority() const { return mProcessPriority; }
+
+ private:
+  void AddProfileToProcessName(const nsACString& aProfile);
+  mozilla::ipc::IPCResult RecvFlushFOGData(FlushFOGDataResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvUpdateMediaCodecsSupported(
+      RemoteDecodeIn aLocation, const media::MediaCodecsSupported& aSupported);
+
+#ifdef NIGHTLY_BUILD
+  virtual void OnChannelReceivedMessage(const Message& aMsg) override;
+
+  virtual PContentChild::Result OnMessageReceived(const Message& aMsg) override;
+
+  virtual PContentChild::Result OnMessageReceived(
+      const Message& aMsg, UniquePtr<Message>& aReply) override;
+#endif
+
+  nsTArray<mozilla::UniquePtr<AlertObserver>> mAlertObservers;
+  RefPtr<ConsoleListener> mConsoleListener;
+
+  nsTHashSet<nsIObserver*> mIdleObservers;
+
+  nsTArray<nsCString> mAvailableDictionaries;
+
+  // Temporary storage for a list of available fonts, passed from the
+  // parent process and used to initialize gfx in the child. Currently used
+  // only on MacOSX and Linux.
+  dom::SystemFontList mFontList;
+  // Temporary storage for look and feel data.
+  FullLookAndFeel mLookAndFeelData;
+  // Temporary storage for list of shared-fontlist memory blocks.
+  nsTArray<base::SharedMemoryHandle> mSharedFontListBlocks;
+
+  /**
+   * An ID unique to the process containing our corresponding
+   * content parent.
+   *
+   * We expect our content parent to set this ID immediately after opening a
+   * channel to us.
+   */
+  ContentParentId mID;
+
+  AppInfo mAppInfo;
+
+  bool mIsForBrowser;
+  nsCString mRemoteType = NOT_REMOTE_TYPE;
+  bool mIsAlive;
+  nsCString mProcessName;
+
+  static ContentChild* sSingleton;
+
+  class ShutdownCanary;
+  static StaticAutoPtr<ShutdownCanary> sShutdownCanary;
+
+  nsCOMPtr<nsIDomainPolicy> mPolicy;
+  nsCOMPtr<nsITimer> mForceKillTimer;
+
+  RefPtr<ipc::SharedMap> mSharedData;
+
+  RefPtr<ChildProfilerController> mProfilerController;
+
+#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
+  nsCOMPtr<nsIFile> mProfileDir;
+#endif
+
+  // Hashtable to keep track of the pending GetFilesHelper objects.
+  // This GetFilesHelperChild objects are removed when RecvGetFilesResponse is
+  // received.
+  nsRefPtrHashtable<nsIDHashKey, GetFilesHelperChild> mGetFilesPendingRequests;
+
+  nsClassHashtable<nsUint64HashKey, AnonymousTemporaryFileCallback>
+      mPendingAnonymousTemporaryFiles;
+
+  mozilla::Atomic<bool> mShuttingDown;
+
+#ifdef NIGHTLY_BUILD
+  // NOTE: This member is atomic because it can be accessed from
+  // off-main-thread.
+  mozilla::Atomic<uint32_t> mPendingInputEvents;
+#endif
+
+  uint32_t mNetworkLinkType = 0;
+
+  // See `BrowsingContext::mEpochs` for an explanation of this field.
+  uint64_t mBrowsingContextFieldEpoch = 0;
+
+  hal::ProcessPriority mProcessPriority = hal::PROCESS_PRIORITY_UNKNOWN;
+};
+
+inline nsISupports* ToSupports(mozilla::dom::ContentChild* aContentChild) {
+  return static_cast<nsIDOMProcessChild*>(aContentChild);
+}
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_ContentChild_h
diff --git a/dom/ipc/ContentParent.cpp b/dom/ipc/ContentParent.cpp
new file mode 100644
index 0000000000..a6e95d04bf
--- /dev/null
+++ b/dom/ipc/ContentParent.cpp
@@ -0,0 +1,8227 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=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/. */
+
+#ifdef MOZ_WIDGET_ANDROID
+#  include "AndroidDecoderModule.h"
+#endif
+
+#include "mozilla/AppShutdown.h"
+#include "mozilla/DebugOnly.h"
+
+#include "base/basictypes.h"
+#include "base/shared_memory.h"
+
+#include "ContentParent.h"
+#include "mozilla/ipc/ProcessUtils.h"
+#include "mozilla/CmdLineAndEnvUtils.h"
+#include "BrowserParent.h"
+
+#include "chrome/common/process_watcher.h"
+#include "mozilla/Result.h"
+#include "mozilla/XREAppData.h"
+#include "nsComponentManagerUtils.h"
+#include "nsIBrowserDOMWindow.h"
+
+#include "GMPServiceParent.h"
+#include "HandlerServiceParent.h"
+#include "IHistory.h"
+#if defined(XP_WIN) && defined(ACCESSIBILITY)
+#  include "mozilla/a11y/AccessibleWrap.h"
+#  include "mozilla/a11y/Compatibility.h"
+#endif
+#include <map>
+#include <utility>
+
+#include "ContentProcessManager.h"
+#include "GeckoProfiler.h"
+#include "Geolocation.h"
+#include "GfxInfoBase.h"
+#include "MMPrinter.h"
+#include "PreallocatedProcessManager.h"
+#include "ProcessPriorityManager.h"
+#include "ProfilerParent.h"
+#include "SandboxHal.h"
+#include "SourceSurfaceRawData.h"
+#include "mozilla/ipc/URIUtils.h"
+#include "gfxPlatform.h"
+#include "gfxPlatformFontList.h"
+#include "nsDNSService2.h"
+#include "nsPIDNSService.h"
+#include "mozilla/AntiTrackingUtils.h"
+#include "mozilla/AppShutdown.h"
+#include "mozilla/AutoRestore.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/BenchmarkStorageParent.h"
+#include "mozilla/Casting.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/ClipboardWriteRequestParent.h"
+#include "mozilla/ContentBlockingUserInteraction.h"
+#include "mozilla/FOGIPC.h"
+#include "mozilla/GlobalStyleSheetCache.h"
+#include "mozilla/GeckoArgs.h"
+#include "mozilla/HangDetails.h"
+#include "mozilla/LoginReputationIPC.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/NullPrincipal.h"
+#include "mozilla/PerformanceMetricsCollector.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/ProcessHangMonitor.h"
+#include "mozilla/ProcessHangMonitorIPC.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/ProfilerMarkers.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/ScriptPreloader.h"
+#include "mozilla/Components.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/StaticPrefs_fission.h"
+#include "mozilla/StaticPrefs_media.h"
+#include "mozilla/StaticPrefs_network.h"
+#include "mozilla/StaticPrefs_widget.h"
+#include "mozilla/StorageAccessAPIHelper.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
+#include "mozilla/TaskController.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/TelemetryIPC.h"
+#include "mozilla/Unused.h"
+#include "mozilla/WebBrowserPersistDocumentParent.h"
+#include "mozilla/devtools/HeapSnapshotTempFileHelperParent.h"
+#include "mozilla/dom/BlobURLProtocolHandler.h"
+#include "mozilla/dom/BrowserHost.h"
+#include "mozilla/dom/BrowsingContext.h"
+#include "mozilla/dom/BrowsingContextGroup.h"
+#include "mozilla/dom/CancelContentJSOptionsBinding.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/dom/ClientManager.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/DataTransfer.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/ExternalHelperAppParent.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/FileSystemSecurity.h"
+#include "mozilla/dom/GeolocationBinding.h"
+#include "mozilla/dom/GeolocationPositionError.h"
+#include "mozilla/dom/GetFilesHelper.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"
+#include "mozilla/dom/MediaStatusManager.h"
+#include "mozilla/dom/Notification.h"
+#include "mozilla/dom/PContentPermissionRequestParent.h"
+#include "mozilla/dom/PCycleCollectWithLogsParent.h"
+#include "mozilla/dom/ParentProcessMessageManager.h"
+#include "mozilla/dom/Permissions.h"
+#include "mozilla/dom/ProcessMessageManager.h"
+#include "mozilla/dom/PushNotifier.h"
+#include "mozilla/dom/ServiceWorkerManager.h"
+#include "mozilla/dom/ServiceWorkerRegistrar.h"
+#include "mozilla/dom/ServiceWorkerUtils.h"
+#include "mozilla/dom/SessionHistoryEntry.h"
+#include "mozilla/dom/SessionStorageManager.h"
+#include "mozilla/dom/StorageIPC.h"
+#include "mozilla/dom/URLClassifierParent.h"
+#include "mozilla/dom/WindowGlobalParent.h"
+#include "mozilla/dom/ipc/SharedMap.h"
+#include "mozilla/dom/ipc/StructuredCloneData.h"
+#include "mozilla/dom/nsMixedContentBlocker.h"
+#include "mozilla/dom/power/PowerManagerService.h"
+#include "mozilla/dom/quota/QuotaManagerService.h"
+#include "mozilla/extensions/ExtensionsParent.h"
+#include "mozilla/extensions/StreamFilterParent.h"
+#include "mozilla/gfx/GPUProcessManager.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/glean/GleanPings.h"
+#include "mozilla/hal_sandbox/PHalParent.h"
+#include "mozilla/intl/L10nRegistry.h"
+#include "mozilla/intl/LocaleService.h"
+#include "mozilla/ipc/BackgroundChild.h"
+#include "mozilla/ipc/BackgroundParent.h"
+#include "mozilla/ipc/ByteBuf.h"
+#include "mozilla/ipc/CrashReporterHost.h"
+#include "mozilla/ipc/Endpoint.h"
+#include "mozilla/ipc/FileDescriptorUtils.h"
+#include "mozilla/ipc/IPCStreamUtils.h"
+#include "mozilla/ipc/TestShellParent.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/layers/ImageBridgeParent.h"
+#include "mozilla/layers/LayerTreeOwnerTracker.h"
+#include "mozilla/layers/PAPZParent.h"
+#include "mozilla/loader/ScriptCacheActors.h"
+#include "mozilla/media/MediaParent.h"
+#include "mozilla/mozSpellChecker.h"
+#include "mozilla/net/CookieServiceParent.h"
+#include "mozilla/net/NeckoMessageUtils.h"
+#include "mozilla/net/NeckoParent.h"
+#include "mozilla/net/PCookieServiceParent.h"
+#include "mozilla/net/CookieKey.h"
+#include "mozilla/net/TRRService.h"
+#include "mozilla/TelemetryComms.h"
+#include "mozilla/TelemetryEventEnums.h"
+#include "mozilla/RemoteLazyInputStreamParent.h"
+#include "mozilla/widget/RemoteLookAndFeel.h"
+#include "mozilla/widget/ScreenManager.h"
+#include "mozilla/widget/TextRecognition.h"
+#include "nsAnonymousTemporaryFile.h"
+#include "nsAppRunner.h"
+#include "nsCExternalHandlerService.h"
+#include "nsCOMPtr.h"
+#include "nsChromeRegistryChrome.h"
+#include "nsConsoleMessage.h"
+#include "nsConsoleService.h"
+#include "nsContentPermissionHelper.h"
+#include "nsContentUtils.h"
+#include "nsCRT.h"
+#include "nsDebugImpl.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsDocShell.h"
+#include "nsEmbedCID.h"
+#include "nsFocusManager.h"
+#include "nsFrameLoader.h"
+#include "nsFrameMessageManager.h"
+#include "nsHashPropertyBag.h"
+#include "nsHyphenationManager.h"
+#include "nsIAlertsService.h"
+#include "nsIAppShell.h"
+#include "nsIAppWindow.h"
+#include "nsIAsyncInputStream.h"
+#include "nsIBidiKeyboard.h"
+#include "nsICaptivePortalService.h"
+#include "nsICertOverrideService.h"
+#include "nsIClipboard.h"
+#include "nsIContentProcess.h"
+#include "nsIContentSecurityPolicy.h"
+#include "nsICookie.h"
+#include "nsICrashService.h"
+#include "nsICycleCollectorListener.h"
+#include "nsIDOMChromeWindow.h"
+#include "nsIDocShell.h"
+#include "nsIDocShellTreeOwner.h"
+#include "nsIDragService.h"
+#include "nsIExternalProtocolService.h"
+#include "nsIGfxInfo.h"
+#include "nsIUserIdleService.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsILocalStorageManager.h"
+#include "nsIMemoryInfoDumper.h"
+#include "nsIMemoryReporter.h"
+#include "nsIMozBrowserFrame.h"
+#include "nsINetworkLinkService.h"
+#include "nsIObserverService.h"
+#include "nsIParentChannel.h"
+#include "nsIScriptError.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsIServiceWorkerManager.h"
+#include "nsISiteSecurityService.h"
+#include "nsISound.h"
+#include "nsIStringBundle.h"
+#include "nsITimer.h"
+#include "nsIURL.h"
+#include "nsIWebBrowserChrome.h"
+#include "nsIX509Cert.h"
+#include "nsIXULRuntime.h"
+#if defined(MOZ_WIDGET_GTK) || defined(XP_WIN)
+#  include "nsIconChannel.h"
+#endif
+#include "nsMemoryInfoDumper.h"
+#include "nsMemoryReporterManager.h"
+#include "nsOpenURIInFrameParams.h"
+#include "nsPIWindowWatcher.h"
+#include "nsPluginHost.h"
+#include "nsPluginTags.h"
+#include "nsQueryObject.h"
+#include "nsReadableUtils.h"
+#include "nsSHistory.h"
+#include "nsScriptError.h"
+#include "nsServiceManagerUtils.h"
+#include "nsStreamUtils.h"
+#include "nsStyleSheetService.h"
+#include "nsThread.h"
+#include "nsThreadUtils.h"
+#include "nsWidgetsCID.h"
+#include "nsWindowWatcher.h"
+#include "prio.h"
+#include "private/pprio.h"
+#include "xpcpublic.h"
+#include "nsOpenWindowInfo.h"
+#include "nsFrameLoaderOwner.h"
+
+#ifdef MOZ_WEBRTC
+#  include "jsapi/WebrtcGlobalParent.h"
+#endif
+
+#if defined(XP_MACOSX)
+#  include "nsMacUtilsImpl.h"
+#  include "mozilla/AvailableMemoryWatcher.h"
+#endif
+
+#if defined(ANDROID) || defined(LINUX)
+#  include "nsSystemInfo.h"
+#endif
+
+#if defined(XP_LINUX)
+#  include "mozilla/Hal.h"
+#endif
+
+#ifdef ANDROID
+#  include "gfxAndroidPlatform.h"
+#endif
+
+#include "mozilla/PermissionManager.h"
+
+#ifdef MOZ_WIDGET_ANDROID
+#  include "AndroidBridge.h"
+#  include "mozilla/java/GeckoProcessManagerWrappers.h"
+#  include "mozilla/java/GeckoProcessTypeWrappers.h"
+#endif
+
+#ifdef MOZ_WIDGET_GTK
+#  include <gdk/gdk.h>
+#  include "mozilla/WidgetUtilsGtk.h"
+#endif
+
+#include "mozilla/RemoteSpellCheckEngineParent.h"
+
+#include "Crypto.h"
+
+#ifdef MOZ_WEBSPEECH
+#  include "mozilla/dom/SpeechSynthesisParent.h"
+#endif
+
+#if defined(MOZ_SANDBOX)
+#  include "mozilla/SandboxSettings.h"
+#  if defined(XP_LINUX)
+#    include "mozilla/SandboxInfo.h"
+#    include "mozilla/SandboxBroker.h"
+#    include "mozilla/SandboxBrokerPolicyFactory.h"
+#  endif
+#  if defined(XP_MACOSX)
+#    include "mozilla/Sandbox.h"
+#  endif
+#endif
+
+#ifdef XP_WIN
+#  include "mozilla/widget/AudioSession.h"
+#  include "mozilla/WinDllServices.h"
+#endif
+
+#ifdef MOZ_CODE_COVERAGE
+#  include "mozilla/CodeCoverageHandler.h"
+#endif
+
+#ifdef FUZZING_SNAPSHOT
+#  include "mozilla/fuzzing/IPCFuzzController.h"
+#endif
+
+// For VP9Benchmark::sBenchmarkFpsPref
+#include "Benchmark.h"
+
+#include "nsIToolkitProfileService.h"
+#include "nsIToolkitProfile.h"
+
+static NS_DEFINE_CID(kCClipboardCID, NS_CLIPBOARD_CID);
+
+using base::KillProcess;
+
+using namespace CrashReporter;
+using namespace mozilla::dom::power;
+using namespace mozilla::media;
+using namespace mozilla::embedding;
+using namespace mozilla::gfx;
+using namespace mozilla::gmp;
+using namespace mozilla::hal;
+using namespace mozilla::ipc;
+using namespace mozilla::intl;
+using namespace mozilla::layers;
+using namespace mozilla::layout;
+using namespace mozilla::net;
+using namespace mozilla::psm;
+using namespace mozilla::widget;
+using namespace mozilla::Telemetry;
+using mozilla::loader::PScriptCacheParent;
+using mozilla::Telemetry::ProcessID;
+
+extern mozilla::LazyLogModule gFocusLog;
+
+#define LOGFOCUS(args) MOZ_LOG(gFocusLog, mozilla::LogLevel::Debug, args)
+
+namespace mozilla {
+namespace CubebUtils {
+extern FileDescriptor CreateAudioIPCConnection();
+}
+
+namespace dom {
+
+LazyLogModule gProcessLog("Process");
+
+static std::map<RemoteDecodeIn, media::MediaCodecsSupported> sCodecsSupported;
+
+/* static */
+uint32_t ContentParent::sMaxContentProcesses = 0;
+
+/* static */
+LogModule* ContentParent::GetLog() { return gProcessLog; }
+
+/* static */
+uint32_t ContentParent::sPageLoadEventCounter = 0;
+
+#define NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC "ipc:network:set-offline"
+#define NS_IPC_IOSERVICE_SET_CONNECTIVITY_TOPIC "ipc:network:set-connectivity"
+
+// IPC receiver for remote GC/CC logging.
+class CycleCollectWithLogsParent final : public PCycleCollectWithLogsParent {
+ public:
+  MOZ_COUNTED_DTOR(CycleCollectWithLogsParent)
+
+  static bool AllocAndSendConstructor(ContentParent* aManager,
+                                      bool aDumpAllTraces,
+                                      nsICycleCollectorLogSink* aSink,
+                                      nsIDumpGCAndCCLogsCallback* aCallback) {
+    CycleCollectWithLogsParent* actor;
+    FILE* gcLog;
+    FILE* ccLog;
+    nsresult rv;
+
+    actor = new CycleCollectWithLogsParent(aSink, aCallback);
+    rv = actor->mSink->Open(&gcLog, &ccLog);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      delete actor;
+      return false;
+    }
+
+    return aManager->SendPCycleCollectWithLogsConstructor(
+        actor, aDumpAllTraces, FILEToFileDescriptor(gcLog),
+        FILEToFileDescriptor(ccLog));
+  }
+
+ private:
+  virtual mozilla::ipc::IPCResult RecvCloseGCLog() override {
+    Unused << mSink->CloseGCLog();
+    return IPC_OK();
+  }
+
+  virtual mozilla::ipc::IPCResult RecvCloseCCLog() override {
+    Unused << mSink->CloseCCLog();
+    return IPC_OK();
+  }
+
+  virtual mozilla::ipc::IPCResult Recv__delete__() override {
+    // Report completion to mCallback only on successful
+    // completion of the protocol.
+    nsCOMPtr<nsIFile> gcLog, ccLog;
+    mSink->GetGcLog(getter_AddRefs(gcLog));
+    mSink->GetCcLog(getter_AddRefs(ccLog));
+    Unused << mCallback->OnDump(gcLog, ccLog, /* parent = */ false);
+    return IPC_OK();
+  }
+
+  virtual void ActorDestroy(ActorDestroyReason aReason) override {
+    // If the actor is unexpectedly destroyed, we deliberately
+    // don't call Close[GC]CLog on the sink, because the logs may
+    // be incomplete.  See also the nsCycleCollectorLogSinkToFile
+    // implementaiton of those methods, and its destructor.
+  }
+
+  CycleCollectWithLogsParent(nsICycleCollectorLogSink* aSink,
+                             nsIDumpGCAndCCLogsCallback* aCallback)
+      : mSink(aSink), mCallback(aCallback) {
+    MOZ_COUNT_CTOR(CycleCollectWithLogsParent);
+  }
+
+  nsCOMPtr<nsICycleCollectorLogSink> mSink;
+  nsCOMPtr<nsIDumpGCAndCCLogsCallback> mCallback;
+};
+
+// A memory reporter for ContentParent objects themselves.
+class ContentParentsMemoryReporter final : public nsIMemoryReporter {
+  ~ContentParentsMemoryReporter() = default;
+
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMEMORYREPORTER
+};
+
+NS_IMPL_ISUPPORTS(ContentParentsMemoryReporter, nsIMemoryReporter)
+
+NS_IMETHODIMP
+ContentParentsMemoryReporter::CollectReports(
+    nsIHandleReportCallback* aHandleReport, nsISupports* aData,
+    bool aAnonymize) {
+  AutoTArray<ContentParent*, 16> cps;
+  ContentParent::GetAllEvenIfDead(cps);
+
+  for (uint32_t i = 0; i < cps.Length(); i++) {
+    ContentParent* cp = cps[i];
+    MessageChannel* channel = cp->GetIPCChannel();
+
+    nsString friendlyName;
+    cp->FriendlyName(friendlyName, aAnonymize);
+
+    cp->AddRef();
+    nsrefcnt refcnt = cp->Release();
+
+    const char* channelStr = "no channel";
+    uint32_t numQueuedMessages = 0;
+    if (channel) {
+      if (channel->IsClosed()) {
+        channelStr = "closed channel";
+      } else {
+        channelStr = "open channel";
+      }
+      numQueuedMessages =
+          0;  // XXX was channel->Unsound_NumQueuedMessages(); Bug 1754876
+    }
+
+    nsPrintfCString path(
+        "queued-ipc-messages/content-parent"
+        "(%s, pid=%d, %s, 0x%p, refcnt=%" PRIuPTR ")",
+        NS_ConvertUTF16toUTF8(friendlyName).get(), cp->Pid(), channelStr,
+        static_cast<nsIObserver*>(cp), refcnt);
+
+    constexpr auto desc =
+        "The number of unset IPC messages held in this ContentParent's "
+        "channel.  A large value here might indicate that we're leaking "
+        "messages.  Similarly, a ContentParent object for a process that's no "
+        "longer running could indicate that we're leaking ContentParents."_ns;
+
+    aHandleReport->Callback(/* process */ ""_ns, path, KIND_OTHER, UNITS_COUNT,
+                            numQueuedMessages, desc, aData);
+  }
+
+  return NS_OK;
+}
+
+// A hashtable (by type) of processes/ContentParents.  This includes
+// processes that are in the Preallocator cache (which would be type
+// 'prealloc'), and recycled processes ('web' and in the future
+// eTLD+1-locked) processes).
+nsClassHashtable<nsCStringHashKey, nsTArray<ContentParent*>>*
+    ContentParent::sBrowserContentParents;
+
+namespace {
+
+uint64_t ComputeLoadedOriginHash(nsIPrincipal* aPrincipal) {
+  uint32_t originNoSuffix =
+      BasePrincipal::Cast(aPrincipal)->GetOriginNoSuffixHash();
+  uint32_t originSuffix =
+      BasePrincipal::Cast(aPrincipal)->GetOriginSuffixHash();
+
+  return ((uint64_t)originNoSuffix) << 32 | originSuffix;
+}
+
+class ScriptableCPInfo final : public nsIContentProcessInfo {
+ public:
+  explicit ScriptableCPInfo(ContentParent* aParent) : mContentParent(aParent) {
+    MOZ_ASSERT(mContentParent);
+  }
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSICONTENTPROCESSINFO
+
+  void ProcessDied() { mContentParent = nullptr; }
+
+ private:
+  ~ScriptableCPInfo() { MOZ_ASSERT(!mContentParent, "must call ProcessDied"); }
+
+  ContentParent* mContentParent;
+};
+
+NS_IMPL_ISUPPORTS(ScriptableCPInfo, nsIContentProcessInfo)
+
+NS_IMETHODIMP
+ScriptableCPInfo::GetIsAlive(bool* aIsAlive) {
+  *aIsAlive = mContentParent != nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ScriptableCPInfo::GetProcessId(int32_t* aPID) {
+  if (!mContentParent) {
+    *aPID = -1;
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  *aPID = mContentParent->Pid();
+  if (*aPID == -1) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ScriptableCPInfo::GetTabCount(int32_t* aTabCount) {
+  if (!mContentParent) {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  ContentProcessManager* cpm = ContentProcessManager::GetSingleton();
+  *aTabCount = cpm->GetBrowserParentCountByProcessId(mContentParent->ChildID());
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ScriptableCPInfo::GetMessageManager(nsISupports** aMessenger) {
+  *aMessenger = nullptr;
+  if (!mContentParent) {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  RefPtr<ProcessMessageManager> manager = mContentParent->GetMessageManager();
+  manager.forget(aMessenger);
+  return NS_OK;
+}
+
+ProcessID GetTelemetryProcessID(const nsACString& remoteType) {
+  // OOP WebExtensions run in a content process.
+  // For Telemetry though we want to break out collected data from the
+  // WebExtensions process into a separate bucket, to make sure we can analyze
+  // it separately and avoid skewing normal content process metrics.
+  return remoteType == EXTENSION_REMOTE_TYPE ? ProcessID::Extension
+                                             : ProcessID::Content;
+}
+
+}  // anonymous namespace
+
+StaticAutoPtr<nsTHashMap<nsUint32HashKey, ContentParent*>>
+    ContentParent::sJSPluginContentParents;
+StaticAutoPtr<LinkedList<ContentParent>> ContentParent::sContentParents;
+StaticRefPtr<ContentParent> ContentParent::sRecycledE10SProcess;
+#if defined(XP_LINUX) && defined(MOZ_SANDBOX)
+StaticAutoPtr<SandboxBrokerPolicyFactory>
+    ContentParent::sSandboxBrokerPolicyFactory;
+#endif
+#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
+StaticAutoPtr<std::vector<std::string>> ContentParent::sMacSandboxParams;
+#endif
+
+// Set to true when the first content process gets created.
+static bool sCreatedFirstContentProcess = false;
+
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+// True when we're running the process selection code, and do not expect to
+// enter code paths where processes may die.
+static bool sInProcessSelector = false;
+#endif
+
+// The first content child has ID 1, so the chrome process can have ID 0.
+static uint64_t gContentChildID = 1;
+
+static const char* sObserverTopics[] = {
+    NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC,
+    NS_IPC_IOSERVICE_SET_CONNECTIVITY_TOPIC,
+    NS_IPC_CAPTIVE_PORTAL_SET_STATE,
+    "application-background",
+    "application-foreground",
+    "memory-pressure",
+    "child-gc-request",
+    "child-cc-request",
+    "child-mmu-request",
+    "child-ghost-request",
+    "last-pb-context-exited",
+    "file-watcher-update",
+#ifdef ACCESSIBILITY
+    "a11y-init-or-shutdown",
+#endif
+    "cacheservice:empty-cache",
+    "intl:app-locales-changed",
+    "intl:requested-locales-changed",
+    "cookie-changed",
+    "private-cookie-changed",
+    NS_NETWORK_LINK_TYPE_TOPIC,
+    NS_NETWORK_TRR_MODE_CHANGED_TOPIC,
+    "network:socket-process-crashed",
+    DEFAULT_TIMEZONE_CHANGED_OBSERVER_TOPIC,
+};
+
+// PreallocateProcess is called by the PreallocatedProcessManager.
+// ContentParent then takes this process back within GetNewOrUsedBrowserProcess.
+/*static*/ already_AddRefed<ContentParent>
+ContentParent::MakePreallocProcess() {
+  RefPtr<ContentParent> process = new ContentParent(PREALLOC_REMOTE_TYPE);
+  return process.forget();
+}
+
+/*static*/
+void ContentParent::StartUp() {
+  // FIXME Bug 1023701 - Stop using ContentParent static methods in
+  // child process
+  if (!XRE_IsParentProcess()) {
+    return;
+  }
+
+  // From this point on, NS_WARNING, NS_ASSERTION, etc. should print out the
+  // PID along with the warning.
+  nsDebugImpl::SetMultiprocessMode("Parent");
+
+  // Note: This reporter measures all ContentParents.
+  RegisterStrongMemoryReporter(new ContentParentsMemoryReporter());
+
+  BackgroundChild::Startup();
+  ClientManager::Startup();
+
+  Preferences::RegisterCallbackAndCall(&OnFissionBlocklistPrefChange,
+                                       kFissionEnforceBlockList);
+  Preferences::RegisterCallbackAndCall(&OnFissionBlocklistPrefChange,
+                                       kFissionOmitBlockListValues);
+
+#if defined(XP_LINUX) && defined(MOZ_SANDBOX)
+  sSandboxBrokerPolicyFactory = new SandboxBrokerPolicyFactory();
+#endif
+
+#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
+  sMacSandboxParams = new std::vector<std::string>();
+#endif
+}
+
+/*static*/
+void ContentParent::ShutDown() {
+  // For the most, we rely on normal process shutdown and
+  // ClearOnShutdown() to clean up our state.
+
+#if defined(XP_LINUX) && defined(MOZ_SANDBOX)
+  sSandboxBrokerPolicyFactory = nullptr;
+#endif
+
+#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
+  sMacSandboxParams = nullptr;
+#endif
+}
+
+/*static*/
+uint32_t ContentParent::GetPoolSize(const nsACString& aContentProcessType) {
+  if (!sBrowserContentParents) {
+    return 0;
+  }
+
+  nsTArray<ContentParent*>* parents =
+      sBrowserContentParents->Get(aContentProcessType);
+
+  return parents ? parents->Length() : 0;
+}
+
+/*static*/ nsTArray<ContentParent*>& ContentParent::GetOrCreatePool(
+    const nsACString& aContentProcessType) {
+  if (!sBrowserContentParents) {
+    sBrowserContentParents =
+        new nsClassHashtable<nsCStringHashKey, nsTArray<ContentParent*>>;
+  }
+
+  return *sBrowserContentParents->GetOrInsertNew(aContentProcessType);
+}
+
+const nsDependentCSubstring RemoteTypePrefix(
+    const nsACString& aContentProcessType) {
+  // The suffix after a `=` in a remoteType is dynamic, and used to control the
+  // process pool to use.
+  int32_t equalIdx = aContentProcessType.FindChar(L'=');
+  if (equalIdx == kNotFound) {
+    equalIdx = aContentProcessType.Length();
+  }
+  return StringHead(aContentProcessType, equalIdx);
+}
+
+bool IsWebRemoteType(const nsACString& aContentProcessType) {
+  // Note: matches webIsolated, web, and webCOOP+COEP types.
+  return StringBeginsWith(aContentProcessType, DEFAULT_REMOTE_TYPE);
+}
+
+bool IsWebCoopCoepRemoteType(const nsACString& aContentProcessType) {
+  return StringBeginsWith(aContentProcessType,
+                          WITH_COOP_COEP_REMOTE_TYPE_PREFIX);
+}
+
+bool IsPrivilegedMozillaRemoteType(const nsACString& aContentProcessType) {
+  return aContentProcessType == PRIVILEGEDMOZILLA_REMOTE_TYPE;
+}
+
+bool IsExtensionRemoteType(const nsACString& aContentProcessType) {
+  return aContentProcessType == EXTENSION_REMOTE_TYPE;
+}
+
+/*static*/
+uint32_t ContentParent::GetMaxProcessCount(
+    const nsACString& aContentProcessType) {
+  // Max process count is based only on the prefix.
+  const nsDependentCSubstring processTypePrefix =
+      RemoteTypePrefix(aContentProcessType);
+
+  // Check for the default remote type of "web", as it uses different prefs.
+  if (processTypePrefix == DEFAULT_REMOTE_TYPE) {
+    return GetMaxWebProcessCount();
+  }
+
+  // Read the pref controling this remote type. `dom.ipc.processCount` is not
+  // used as a fallback, as it is intended to control the number of "web"
+  // content processes, checked in `mozilla::GetMaxWebProcessCount()`.
+  nsAutoCString processCountPref("dom.ipc.processCount.");
+  processCountPref.Append(processTypePrefix);
+
+  int32_t maxContentParents = Preferences::GetInt(processCountPref.get(), 1);
+  if (maxContentParents < 1) {
+    maxContentParents = 1;
+  }
+
+  return static_cast<uint32_t>(maxContentParents);
+}
+
+/*static*/
+bool ContentParent::IsMaxProcessCountReached(
+    const nsACString& aContentProcessType) {
+  return GetPoolSize(aContentProcessType) >=
+         GetMaxProcessCount(aContentProcessType);
+}
+
+// Really more ReleaseUnneededProcesses()
+/*static*/
+void ContentParent::ReleaseCachedProcesses() {
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+          ("ReleaseCachedProcesses:"));
+  if (!sBrowserContentParents) {
+    return;
+  }
+
+#ifdef DEBUG
+  for (const auto& cps : *sBrowserContentParents) {
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+            ("%s: %zu processes", PromiseFlatCString(cps.GetKey()).get(),
+             cps.GetData()->Length()));
+  }
+#endif
+  // We process the toRelease array outside of the iteration to avoid modifying
+  // the list (via RemoveFromList()) while we're iterating it.
+  nsTArray<ContentParent*> toRelease;
+  for (const auto& contentParents : sBrowserContentParents->Values()) {
+    // Shutting down these processes will change the array so let's use another
+    // array for the removal.
+    for (auto* cp : *contentParents) {
+      if (cp->ManagedPBrowserParent().Count() == 0 &&
+          !cp->HasActiveWorkerOrJSPlugin() &&
+          cp->mRemoteType == DEFAULT_REMOTE_TYPE) {
+        toRelease.AppendElement(cp);
+      } else {
+        MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+                ("  Skipping %p (%s), count %d, HasActiveWorkerOrJSPlugin %d",
+                 cp, cp->mRemoteType.get(), cp->ManagedPBrowserParent().Count(),
+                 cp->HasActiveWorkerOrJSPlugin()));
+      }
+    }
+  }
+
+  for (auto* cp : toRelease) {
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+            ("  Shutdown %p (%s)", cp, cp->mRemoteType.get()));
+    PreallocatedProcessManager::Erase(cp);
+    // Start a soft shutdown.
+    cp->ShutDownProcess(SEND_SHUTDOWN_MESSAGE);
+    // Make sure we don't select this process for new tabs.
+    cp->MarkAsDead();
+    // Make sure that this process is no longer accessible from JS by its
+    // message manager.
+    cp->ShutDownMessageManager();
+  }
+}
+
+/*static*/
+already_AddRefed<ContentParent> ContentParent::MinTabSelect(
+    const nsTArray<ContentParent*>& aContentParents,
+    int32_t aMaxContentParents) {
+  uint32_t maxSelectable =
+      std::min(static_cast<uint32_t>(aContentParents.Length()),
+               static_cast<uint32_t>(aMaxContentParents));
+  uint32_t min = INT_MAX;
+  RefPtr<ContentParent> candidate;
+  ContentProcessManager* cpm = ContentProcessManager::GetSingleton();
+
+  for (uint32_t i = 0; i < maxSelectable; i++) {
+    ContentParent* p = aContentParents[i];
+    MOZ_DIAGNOSTIC_ASSERT(!p->IsDead());
+
+    // Ignore processes that were slated for removal but not yet removed from
+    // the pool (see also GetUsedBrowserProcess and BlockShutdown).
+    if (!p->IsShuttingDown()) {
+      uint32_t tabCount = cpm->GetBrowserParentCountByProcessId(p->ChildID());
+      if (tabCount < min) {
+        candidate = p;
+        min = tabCount;
+      }
+    }
+  }
+
+  // If all current processes have at least one tab and we have not yet reached
+  // the maximum, use a new process.
+  if (min > 0 &&
+      aContentParents.Length() < static_cast<uint32_t>(aMaxContentParents)) {
+    return nullptr;
+  }
+
+  // Otherwise we return candidate.
+  return candidate.forget();
+}
+
+/* static */
+already_AddRefed<nsIPrincipal>
+ContentParent::CreateRemoteTypeIsolationPrincipal(
+    const nsACString& aRemoteType) {
+  if ((RemoteTypePrefix(aRemoteType) != FISSION_WEB_REMOTE_TYPE) &&
+      !StringBeginsWith(aRemoteType, WITH_COOP_COEP_REMOTE_TYPE_PREFIX)) {
+    return nullptr;
+  }
+
+  int32_t offset = aRemoteType.FindChar('=') + 1;
+  MOZ_ASSERT(offset > 1, "can not extract origin from that remote type");
+  nsAutoCString origin(
+      Substring(aRemoteType, offset, aRemoteType.Length() - offset));
+
+  nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
+  nsCOMPtr<nsIPrincipal> principal;
+  ssm->CreateContentPrincipalFromOrigin(origin, getter_AddRefs(principal));
+  return principal.forget();
+}
+
+/*static*/
+already_AddRefed<ContentParent> ContentParent::GetUsedBrowserProcess(
+    const nsACString& aRemoteType, nsTArray<ContentParent*>& aContentParents,
+    uint32_t aMaxContentParents, bool aPreferUsed, ProcessPriority aPriority) {
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+  AutoRestore ar(sInProcessSelector);
+  sInProcessSelector = true;
+#endif
+
+  uint32_t numberOfParents = aContentParents.Length();
+  nsTArray<RefPtr<nsIContentProcessInfo>> infos(numberOfParents);
+  for (auto* cp : aContentParents) {
+    infos.AppendElement(cp->mScriptableHelper);
+  }
+
+  if (aPreferUsed && numberOfParents) {
+    // If we prefer re-using existing content processes, we don't want to create
+    // a new process, and instead re-use an existing one, so pretend the process
+    // limit is at the current number of processes.
+    aMaxContentParents = numberOfParents;
+  }
+
+  nsCOMPtr<nsIContentProcessProvider> cpp =
+      do_GetService("@mozilla.org/ipc/processselector;1");
+  int32_t index;
+  if (cpp && NS_SUCCEEDED(cpp->ProvideProcess(aRemoteType, infos,
+                                              aMaxContentParents, &index))) {
+    // If the provider returned an existing ContentParent, use that one.
+    if (0 <= index && static_cast<uint32_t>(index) <= aMaxContentParents) {
+      RefPtr<ContentParent> retval = aContentParents[index];
+      // Ignore processes that were slated for removal but not yet removed from
+      // the pool.
+      if (!retval->IsShuttingDown()) {
+        if (profiler_thread_is_being_profiled_for_markers()) {
+          nsPrintfCString marker("Reused process %u",
+                                 (unsigned int)retval->ChildID());
+          PROFILER_MARKER_TEXT("Process", DOM, {}, marker);
+        }
+        MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+                ("GetUsedProcess: Reused process %p (%u) for %s", retval.get(),
+                 (unsigned int)retval->ChildID(),
+                 PromiseFlatCString(aRemoteType).get()));
+        retval->AssertAlive();
+        retval->StopRecyclingE10SOnly(true);
+        return retval.forget();
+      }
+    }
+  } else {
+    // If there was a problem with the JS chooser, fall back to a random
+    // selection.
+    NS_WARNING("nsIContentProcessProvider failed to return a process");
+    RefPtr<ContentParent> random;
+    if ((random = MinTabSelect(aContentParents, aMaxContentParents))) {
+      MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+              ("GetUsedProcess: Reused random process %p (%d) for %s",
+               random.get(), (unsigned int)random->ChildID(),
+               PromiseFlatCString(aRemoteType).get()));
+      random->AssertAlive();
+      random->StopRecyclingE10SOnly(true);
+      return random.forget();
+    }
+  }
+
+  // If we are loading into the "web" remote type, are choosing to launch a new
+  // tab, and have a recycled E10S process, we should launch into that process.
+  if (aRemoteType == DEFAULT_REMOTE_TYPE && sRecycledE10SProcess) {
+    RefPtr<ContentParent> recycled = sRecycledE10SProcess;
+    MOZ_DIAGNOSTIC_ASSERT(recycled->GetRemoteType() == DEFAULT_REMOTE_TYPE);
+    recycled->AssertAlive();
+    recycled->StopRecyclingE10SOnly(true);
+    if (profiler_thread_is_being_profiled_for_markers()) {
+      nsPrintfCString marker("Recycled process %u (%p)",
+                             (unsigned int)recycled->ChildID(), recycled.get());
+      PROFILER_MARKER_TEXT("Process", DOM, {}, marker);
+    }
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+            ("Recycled process %p", recycled.get()));
+
+    return recycled.forget();
+  }
+
+  // Try to take a preallocated process except for certain remote types.
+  // Note: this process may not have finished launching yet
+  RefPtr<ContentParent> preallocated;
+  if (aRemoteType != FILE_REMOTE_TYPE &&
+      aRemoteType != PRIVILEGEDABOUT_REMOTE_TYPE &&
+      aRemoteType != EXTENSION_REMOTE_TYPE &&  // Bug 1638119
+      (preallocated = PreallocatedProcessManager::Take(aRemoteType))) {
+    MOZ_DIAGNOSTIC_ASSERT(preallocated->GetRemoteType() ==
+                          PREALLOC_REMOTE_TYPE);
+    MOZ_DIAGNOSTIC_ASSERT(sRecycledE10SProcess != preallocated);
+    preallocated->AssertAlive();
+
+    if (profiler_thread_is_being_profiled_for_markers()) {
+      nsPrintfCString marker(
+          "Assigned preallocated process %u%s",
+          (unsigned int)preallocated->ChildID(),
+          preallocated->IsLaunching() ? " (still launching)" : "");
+      PROFILER_MARKER_TEXT("Process", DOM, {}, marker);
+    }
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+            ("Adopted preallocated process %p for type %s%s",
+             preallocated.get(), PromiseFlatCString(aRemoteType).get(),
+             preallocated->IsLaunching() ? " (still launching)" : ""));
+
+    // This ensures that the preallocator won't shut down the process once
+    // it finishes starting
+    preallocated->mRemoteType.Assign(aRemoteType);
+    {
+      MutexAutoLock lock(preallocated->mThreadsafeHandle->mMutex);
+      preallocated->mThreadsafeHandle->mRemoteType = preallocated->mRemoteType;
+    }
+    preallocated->mRemoteTypeIsolationPrincipal =
+        CreateRemoteTypeIsolationPrincipal(aRemoteType);
+    preallocated->mActivateTS = TimeStamp::Now();
+    preallocated->AddToPool(aContentParents);
+
+    // rare, but will happen
+    if (!preallocated->IsLaunching()) {
+      // Specialize this process for the appropriate remote type, and activate
+      // it.
+
+      Unused << preallocated->SendRemoteType(preallocated->mRemoteType,
+                                             preallocated->mProfile);
+
+      nsCOMPtr<nsIObserverService> obs =
+          mozilla::services::GetObserverService();
+      if (obs) {
+        nsAutoString cpId;
+        cpId.AppendInt(static_cast<uint64_t>(preallocated->ChildID()));
+        obs->NotifyObservers(static_cast<nsIObserver*>(preallocated),
+                             "process-type-set", cpId.get());
+        preallocated->AssertAlive();
+      }
+    }
+    return preallocated.forget();
+  }
+
+  return nullptr;
+}
+
+/*static*/
+already_AddRefed<ContentParent>
+ContentParent::GetNewOrUsedLaunchingBrowserProcess(
+    const nsACString& aRemoteType, BrowsingContextGroup* aGroup,
+    ProcessPriority aPriority, bool aPreferUsed) {
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+          ("GetNewOrUsedProcess for type %s",
+           PromiseFlatCString(aRemoteType).get()));
+
+  // Fallback check (we really want our callers to avoid this).
+  if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
+    MOZ_DIAGNOSTIC_ASSERT(
+        false, "Late attempt to GetNewOrUsedLaunchingBrowserProcess!");
+    return nullptr;
+  }
+
+  // If we have an existing host process attached to this BrowsingContextGroup,
+  // always return it, as we can never have multiple host processes within a
+  // single BrowsingContextGroup.
+  RefPtr<ContentParent> contentParent;
+  if (aGroup) {
+    contentParent = aGroup->GetHostProcess(aRemoteType);
+    Unused << NS_WARN_IF(contentParent && contentParent->IsShuttingDown());
+    if (contentParent && !contentParent->IsShuttingDown()) {
+      MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+              ("GetNewOrUsedProcess: Existing host process %p (launching %d)",
+               contentParent.get(), contentParent->IsLaunching()));
+      contentParent->AssertAlive();
+      contentParent->StopRecyclingE10SOnly(true);
+      return contentParent.forget();
+    }
+  }
+
+  nsTArray<ContentParent*>& contentParents = GetOrCreatePool(aRemoteType);
+  uint32_t maxContentParents = GetMaxProcessCount(aRemoteType);
+
+  // Let's try and reuse an existing process.
+  contentParent = GetUsedBrowserProcess(
+      aRemoteType, contentParents, maxContentParents, aPreferUsed, aPriority);
+
+  if (!contentParent) {
+    // No reusable process. Let's create and launch one.
+    // The life cycle will be set to `LifecycleState::LAUNCHING`.
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+            ("Launching new process immediately for type %s",
+             PromiseFlatCString(aRemoteType).get()));
+
+    contentParent = new ContentParent(aRemoteType);
+    if (NS_WARN_IF(!contentParent->BeginSubprocessLaunch(aPriority))) {
+      // Launch aborted because of shutdown. Bailout.
+      contentParent->LaunchSubprocessReject();
+      return nullptr;
+    }
+    // Until the new process is ready let's not allow to start up any
+    // preallocated processes. The blocker will be removed once we receive
+    // the first idle message.
+    contentParent->mIsAPreallocBlocker = true;
+    PreallocatedProcessManager::AddBlocker(aRemoteType, contentParent);
+
+    // Store this process for future reuse.
+    contentParent->AddToPool(contentParents);
+
+    MOZ_LOG(
+        ContentParent::GetLog(), LogLevel::Debug,
+        ("GetNewOrUsedProcess: new immediate process %p", contentParent.get()));
+  }
+  // else we have an existing or preallocated process (which may be
+  // still launching)
+
+  contentParent->AssertAlive();
+  contentParent->StopRecyclingE10SOnly(true);
+  if (aGroup) {
+    aGroup->EnsureHostProcess(contentParent);
+  }
+  return contentParent.forget();
+}
+
+/*static*/
+RefPtr<ContentParent::LaunchPromise>
+ContentParent::GetNewOrUsedBrowserProcessAsync(const nsACString& aRemoteType,
+                                               BrowsingContextGroup* aGroup,
+                                               ProcessPriority aPriority,
+                                               bool aPreferUsed) {
+  // Obtain a `ContentParent` launched asynchronously.
+  RefPtr<ContentParent> contentParent = GetNewOrUsedLaunchingBrowserProcess(
+      aRemoteType, aGroup, aPriority, aPreferUsed);
+  if (!contentParent) {
+    // In case of launch error, stop here.
+    return LaunchPromise::CreateAndReject(NS_ERROR_ILLEGAL_DURING_SHUTDOWN,
+                                          __func__);
+  }
+  return contentParent->WaitForLaunchAsync(aPriority);
+}
+
+/*static*/
+already_AddRefed<ContentParent> ContentParent::GetNewOrUsedBrowserProcess(
+    const nsACString& aRemoteType, BrowsingContextGroup* aGroup,
+    ProcessPriority aPriority, bool aPreferUsed) {
+  RefPtr<ContentParent> contentParent = GetNewOrUsedLaunchingBrowserProcess(
+      aRemoteType, aGroup, aPriority, aPreferUsed);
+  if (!contentParent || !contentParent->WaitForLaunchSync(aPriority)) {
+    // In case of launch error, stop here.
+    return nullptr;
+  }
+  return contentParent.forget();
+}
+
+RefPtr<ContentParent::LaunchPromise> ContentParent::WaitForLaunchAsync(
+    ProcessPriority aPriority) {
+  MOZ_DIAGNOSTIC_ASSERT(!IsDead());
+  if (!IsLaunching()) {
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+            ("WaitForLaunchAsync: launched"));
+    return LaunchPromise::CreateAndResolve(this, __func__);
+  }
+
+  // We've started an async content process launch.
+  Telemetry::Accumulate(Telemetry::CONTENT_PROCESS_LAUNCH_IS_SYNC, 0);
+
+  // We have located a process that hasn't finished initializing, then attempt
+  // to finish initializing. Both `LaunchSubprocessResolve` and
+  // `LaunchSubprocessReject` are safe to call multiple times if we race with
+  // other `WaitForLaunchAsync` callbacks.
+  return mSubprocess->WhenProcessHandleReady()->Then(
+      GetCurrentSerialEventTarget(), __func__,
+      [self = RefPtr{this}, aPriority]() {
+        if (self->LaunchSubprocessResolve(/* aIsSync = */ false, aPriority)) {
+          MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+                  ("WaitForLaunchAsync: async, now launched"));
+          self->mActivateTS = TimeStamp::Now();
+          return LaunchPromise::CreateAndResolve(self, __func__);
+        }
+
+        self->LaunchSubprocessReject();
+        return LaunchPromise::CreateAndReject(NS_ERROR_INVALID_ARG, __func__);
+      },
+      [self = RefPtr{this}]() {
+        MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+                ("WaitForLaunchAsync: async, rejected"));
+        self->LaunchSubprocessReject();
+        return LaunchPromise::CreateAndReject(NS_ERROR_FAILURE, __func__);
+      });
+}
+
+bool ContentParent::WaitForLaunchSync(ProcessPriority aPriority) {
+  MOZ_DIAGNOSTIC_ASSERT(!IsDead());
+  if (!IsLaunching()) {
+    return true;
+  }
+
+  // We've started a sync content process launch.
+  Telemetry::Accumulate(Telemetry::CONTENT_PROCESS_LAUNCH_IS_SYNC, 1);
+
+  // We're a process which hasn't finished initializing. We may be racing
+  // against whoever launched it (and whoever else is already racing). Since
+  // we're sync, we win the race and finish the initialization.
+  bool launchSuccess = mSubprocess->WaitForProcessHandle();
+  if (launchSuccess &&
+      LaunchSubprocessResolve(/* aIsSync = */ true, aPriority)) {
+    mActivateTS = TimeStamp::Now();
+    return true;
+  }
+  // In case of failure.
+  LaunchSubprocessReject();
+  return false;
+}
+
+/*static*/
+already_AddRefed<ContentParent> ContentParent::GetNewOrUsedJSPluginProcess(
+    uint32_t aPluginID, const hal::ProcessPriority& aPriority) {
+  RefPtr<ContentParent> p;
+  if (sJSPluginContentParents) {
+    p = sJSPluginContentParents->Get(aPluginID);
+  } else {
+    sJSPluginContentParents = new nsTHashMap<nsUint32HashKey, ContentParent*>();
+  }
+
+  if (p) {
+    return p.forget();
+  }
+
+  p = new ContentParent(aPluginID);
+
+  if (!p->LaunchSubprocessSync(aPriority)) {
+    return nullptr;
+  }
+
+  sJSPluginContentParents->InsertOrUpdate(aPluginID, p);
+
+  return p.forget();
+}
+
+static nsIDocShell* GetOpenerDocShellHelper(Element* aFrameElement) {
+  // Propagate the private-browsing status of the element's parent
+  // docshell to the remote docshell, via the chrome flags.
+  MOZ_ASSERT(aFrameElement);
+  nsPIDOMWindowOuter* win = aFrameElement->OwnerDoc()->GetWindow();
+  if (!win) {
+    NS_WARNING("Remote frame has no window");
+    return nullptr;
+  }
+  nsIDocShell* docShell = win->GetDocShell();
+  if (!docShell) {
+    NS_WARNING("Remote frame has no docshell");
+    return nullptr;
+  }
+
+  return docShell;
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvCreateGMPService() {
+  Endpoint<PGMPServiceParent> parent;
+  Endpoint<PGMPServiceChild> child;
+
+  if (mGMPCreated) {
+    return IPC_FAIL(this, "GMP Service already created");
+  }
+
+  nsresult rv;
+  rv = PGMPService::CreateEndpoints(base::GetCurrentProcId(), OtherPid(),
+                                    &parent, &child);
+  if (NS_FAILED(rv)) {
+    return IPC_FAIL(this, "CreateEndpoints failed");
+  }
+
+  if (!GMPServiceParent::Create(std::move(parent))) {
+    return IPC_FAIL(this, "GMPServiceParent::Create failed");
+  }
+
+  if (!SendInitGMPService(std::move(child))) {
+    return IPC_FAIL(this, "SendInitGMPService failed");
+  }
+
+  mGMPCreated = true;
+
+  return IPC_OK();
+}
+
+Atomic<bool, mozilla::Relaxed> sContentParentTelemetryEventEnabled(false);
+
+/*static*/
+void ContentParent::LogAndAssertFailedPrincipalValidationInfo(
+    nsIPrincipal* aPrincipal, const char* aMethod) {
+  // nsContentSecurityManager may also enable this same event, but that's okay
+  if (!sContentParentTelemetryEventEnabled.exchange(true)) {
+    sContentParentTelemetryEventEnabled = true;
+    Telemetry::SetEventRecordingEnabled("security"_ns, true);
+  }
+
+  // Send Telemetry
+  nsAutoCString principalScheme, principalType, spec;
+  CopyableTArray<EventExtraEntry> extra(2);
+
+  if (!aPrincipal) {
+    principalType.AssignLiteral("NullPtr");
+  } else if (aPrincipal->IsSystemPrincipal()) {
+    principalType.AssignLiteral("SystemPrincipal");
+  } else if (aPrincipal->GetIsExpandedPrincipal()) {
+    principalType.AssignLiteral("ExpandedPrincipal");
+  } else if (aPrincipal->GetIsContentPrincipal()) {
+    principalType.AssignLiteral("ContentPrincipal");
+    aPrincipal->GetSpec(spec);
+    aPrincipal->GetScheme(principalScheme);
+
+    extra.AppendElement(EventExtraEntry{"scheme"_ns, principalScheme});
+  } else {
+    principalType.AssignLiteral("Unknown");
+  }
+
+  extra.AppendElement(EventExtraEntry{"principalType"_ns, principalType});
+
+  // Do not send telemetry when chrome-debugging is enabled
+  bool isChromeDebuggingEnabled =
+      Preferences::GetBool("devtools.chrome.enabled", false);
+  if (!isChromeDebuggingEnabled) {
+    Telemetry::EventID eventType =
+        Telemetry::EventID::Security_Fissionprincipals_Contentparent;
+    Telemetry::RecordEvent(eventType, mozilla::Some(aMethod),
+                           mozilla::Some(extra));
+  }
+
+  // And log it
+  MOZ_LOG(
+      ContentParent::GetLog(), LogLevel::Error,
+      ("  Receiving unexpected Principal (%s) within %s",
+       aPrincipal && aPrincipal->GetIsContentPrincipal() ? spec.get()
+                                                         : principalType.get(),
+       aMethod));
+
+#ifdef DEBUG
+  // Not only log but also ensure we do not receive an unexpected
+  // principal when running in debug mode.
+  MOZ_ASSERT(false, "Receiving unexpected Principal");
+#endif
+}
+
+bool ContentParent::ValidatePrincipal(
+    nsIPrincipal* aPrincipal,
+    const EnumSet<ValidatePrincipalOptions>& aOptions) {
+  // If the pref says we should not validate, then there is nothing to do
+  if (!StaticPrefs::dom_security_enforceIPCBasedPrincipalVetting()) {
+    return true;
+  }
+
+  // If there is no principal, then there is nothing to validate!
+  if (!aPrincipal) {
+    return aOptions.contains(ValidatePrincipalOptions::AllowNullPtr);
+  }
+
+  // We currently do not track relationships between specific null principals
+  // and content processes, so we can not validate much here - just allow all
+  // null principals we see because they are generally safe anyway!
+  if (aPrincipal->GetIsNullPrincipal()) {
+    return true;
+  }
+
+  // Only allow the system principal if the passed in options flags
+  // request permitting the system principal.
+  if (aPrincipal->IsSystemPrincipal()) {
+    return aOptions.contains(ValidatePrincipalOptions::AllowSystem);
+  }
+
+  // XXXckerschb: we should eliminate the resource carve-out here and always
+  // validate the Principal, see Bug 1686200: Investigate Principal for pdf.js
+  if (aPrincipal->SchemeIs("resource")) {
+    return true;
+  }
+
+  // Validate each inner principal individually, allowing us to catch expanded
+  // principals containing the system principal, etc.
+  if (aPrincipal->GetIsExpandedPrincipal()) {
+    if (!aOptions.contains(ValidatePrincipalOptions::AllowExpanded)) {
+      return false;
+    }
+    // FIXME: There are more constraints on expanded principals in-practice,
+    // such as the structure of extension expanded principals. This may need
+    // to be investigated more in the future.
+    nsCOMPtr<nsIExpandedPrincipal> expandedPrincipal =
+        do_QueryInterface(aPrincipal);
+    const auto& allowList = expandedPrincipal->AllowList();
+    for (const auto& innerPrincipal : allowList) {
+      if (!ValidatePrincipal(innerPrincipal, aOptions)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // A URI with a file:// scheme can never load in a non-file content process
+  // due to sandboxing.
+  if (aPrincipal->SchemeIs("file")) {
+    // If we don't support a separate 'file' process, then we can return here.
+    if (!StaticPrefs::browser_tabs_remote_separateFileUriProcess()) {
+      return true;
+    }
+    return mRemoteType == FILE_REMOTE_TYPE;
+  }
+
+  if (aPrincipal->SchemeIs("about")) {
+    uint32_t flags = 0;
+    if (NS_FAILED(aPrincipal->GetAboutModuleFlags(&flags))) {
+      return false;
+    }
+
+    // Block principals for about: URIs which can't load in this process.
+    if (!(flags & (nsIAboutModule::URI_CAN_LOAD_IN_CHILD |
+                   nsIAboutModule::URI_MUST_LOAD_IN_CHILD))) {
+      return false;
+    }
+    if (flags & nsIAboutModule::URI_MUST_LOAD_IN_EXTENSION_PROCESS) {
+      return mRemoteType == EXTENSION_REMOTE_TYPE;
+    }
+    return true;
+  }
+
+  if (!mRemoteTypeIsolationPrincipal ||
+      RemoteTypePrefix(mRemoteType) != FISSION_WEB_REMOTE_TYPE) {
+    return true;
+  }
+
+  // Web content can contain extension content frames, so a content process may
+  // send us an extension's principal.
+  auto* addonPolicy = BasePrincipal::Cast(aPrincipal)->AddonPolicy();
+  if (addonPolicy) {
+    return true;
+  }
+
+  // Ensure that the expected site-origin matches the one specified by our
+  // mRemoteTypeIsolationPrincipal.
+  nsAutoCString siteOriginNoSuffix;
+  if (NS_FAILED(aPrincipal->GetSiteOriginNoSuffix(siteOriginNoSuffix))) {
+    return false;
+  }
+  nsAutoCString remoteTypeSiteOriginNoSuffix;
+  if (NS_FAILED(mRemoteTypeIsolationPrincipal->GetSiteOriginNoSuffix(
+          remoteTypeSiteOriginNoSuffix))) {
+    return false;
+  }
+
+  return remoteTypeSiteOriginNoSuffix.Equals(siteOriginNoSuffix);
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvRemovePermission(
+    nsIPrincipal* aPrincipal, const nsACString& aPermissionType,
+    nsresult* aRv) {
+  if (!aPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  if (!ValidatePrincipal(aPrincipal)) {
+    LogAndAssertFailedPrincipalValidationInfo(aPrincipal, __func__);
+  }
+  *aRv = Permissions::RemovePermission(aPrincipal, aPermissionType);
+  return IPC_OK();
+}
+
+/*static*/
+already_AddRefed<RemoteBrowser> ContentParent::CreateBrowser(
+    const TabContext& aContext, Element* aFrameElement,
+    const nsACString& aRemoteType, BrowsingContext* aBrowsingContext,
+    ContentParent* aOpenerContentParent) {
+  AUTO_PROFILER_LABEL("ContentParent::CreateBrowser", OTHER);
+
+  MOZ_DIAGNOSTIC_ASSERT(
+      !aBrowsingContext->Canonical()->GetBrowserParent(),
+      "BrowsingContext must not have BrowserParent, or have previous "
+      "BrowserParent cleared");
+
+  nsAutoCString remoteType(aRemoteType);
+  if (remoteType.IsEmpty()) {
+    remoteType = DEFAULT_REMOTE_TYPE;
+  }
+
+  TabId tabId(nsContentUtils::GenerateTabId());
+
+  nsIDocShell* docShell = GetOpenerDocShellHelper(aFrameElement);
+  TabId openerTabId;
+  if (docShell) {
+    openerTabId = BrowserParent::GetTabIdFrom(docShell);
+  }
+
+  RefPtr<ContentParent> constructorSender;
+  MOZ_RELEASE_ASSERT(XRE_IsParentProcess(),
+                     "Cannot allocate BrowserParent in content process");
+  if (aOpenerContentParent && !aOpenerContentParent->IsShuttingDown()) {
+    constructorSender = aOpenerContentParent;
+  } else {
+    if (aContext.IsJSPlugin()) {
+      constructorSender = GetNewOrUsedJSPluginProcess(
+          aContext.JSPluginId(), PROCESS_PRIORITY_FOREGROUND);
+    } else {
+      constructorSender = GetNewOrUsedBrowserProcess(
+          remoteType, aBrowsingContext->Group(), PROCESS_PRIORITY_FOREGROUND);
+    }
+    if (!constructorSender) {
+      return nullptr;
+    }
+  }
+
+  aBrowsingContext->SetEmbedderElement(aFrameElement);
+
+  // Ensure that the process which we're using to launch is set as the host
+  // process for this BrowsingContextGroup.
+  aBrowsingContext->Group()->EnsureHostProcess(constructorSender);
+
+  nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
+  docShell->GetTreeOwner(getter_AddRefs(treeOwner));
+  if (!treeOwner) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsIWebBrowserChrome> wbc = do_GetInterface(treeOwner);
+  if (!wbc) {
+    return nullptr;
+  }
+  uint32_t chromeFlags = 0;
+  wbc->GetChromeFlags(&chromeFlags);
+
+  nsCOMPtr<nsILoadContext> loadContext = do_QueryInterface(docShell);
+  if (loadContext && loadContext->UsePrivateBrowsing()) {
+    chromeFlags |= nsIWebBrowserChrome::CHROME_PRIVATE_WINDOW;
+  }
+  if (loadContext && loadContext->UseRemoteTabs()) {
+    chromeFlags |= nsIWebBrowserChrome::CHROME_REMOTE_WINDOW;
+  }
+  if (loadContext && loadContext->UseRemoteSubframes()) {
+    chromeFlags |= nsIWebBrowserChrome::CHROME_FISSION_WINDOW;
+  }
+
+  if (tabId == 0) {
+    return nullptr;
+  }
+
+  aBrowsingContext->Canonical()->SetOwnerProcessId(
+      constructorSender->ChildID());
+
+  RefPtr<BrowserParent> browserParent =
+      new BrowserParent(constructorSender, tabId, aContext,
+                        aBrowsingContext->Canonical(), chromeFlags);
+
+  // Open a remote endpoint for our PBrowser actor.
+  ManagedEndpoint<PBrowserChild> childEp =
+      constructorSender->OpenPBrowserEndpoint(browserParent);
+  if (NS_WARN_IF(!childEp.IsValid())) {
+    return nullptr;
+  }
+
+  ContentProcessManager* cpm = ContentProcessManager::GetSingleton();
+  if (NS_WARN_IF(!cpm)) {
+    return nullptr;
+  }
+  cpm->RegisterRemoteFrame(browserParent);
+
+  nsCOMPtr<nsIPrincipal> initialPrincipal =
+      NullPrincipal::Create(aBrowsingContext->OriginAttributesRef());
+  WindowGlobalInit windowInit = WindowGlobalActor::AboutBlankInitializer(
+      aBrowsingContext, initialPrincipal);
+
+  RefPtr<WindowGlobalParent> windowParent =
+      WindowGlobalParent::CreateDisconnected(windowInit);
+  if (NS_WARN_IF(!windowParent)) {
+    return nullptr;
+  }
+
+  // Open a remote endpoint for the initial PWindowGlobal actor.
+  ManagedEndpoint<PWindowGlobalChild> windowEp =
+      browserParent->OpenPWindowGlobalEndpoint(windowParent);
+  if (NS_WARN_IF(!windowEp.IsValid())) {
+    return nullptr;
+  }
+
+  // Tell the content process to set up its PBrowserChild.
+  bool ok = constructorSender->SendConstructBrowser(
+      std::move(childEp), std::move(windowEp), tabId,
+      aContext.AsIPCTabContext(), windowInit, chromeFlags,
+      constructorSender->ChildID(), constructorSender->IsForBrowser(),
+      /* aIsTopLevel */ true);
+  if (NS_WARN_IF(!ok)) {
+    return nullptr;
+  }
+
+  // Ensure that we're marked as the current BrowserParent on our
+  // CanonicalBrowsingContext.
+  aBrowsingContext->Canonical()->SetCurrentBrowserParent(browserParent);
+
+  windowParent->Init();
+
+  RefPtr<BrowserHost> browserHost = new BrowserHost(browserParent);
+  browserParent->SetOwnerElement(aFrameElement);
+  return browserHost.forget();
+}
+
+void ContentParent::GetAll(nsTArray<ContentParent*>& aArray) {
+  aArray.Clear();
+
+  for (auto* cp : AllProcesses(eLive)) {
+    aArray.AppendElement(cp);
+  }
+}
+
+void ContentParent::GetAllEvenIfDead(nsTArray<ContentParent*>& aArray) {
+  aArray.Clear();
+
+  for (auto* cp : AllProcesses(eAll)) {
+    aArray.AppendElement(cp);
+  }
+}
+
+void ContentParent::BroadcastStringBundle(
+    const StringBundleDescriptor& aBundle) {
+  AutoTArray<StringBundleDescriptor, 1> array;
+  array.AppendElement(aBundle);
+
+  for (auto* cp : AllProcesses(eLive)) {
+    Unused << cp->SendRegisterStringBundles(array);
+  }
+}
+
+void ContentParent::BroadcastFontListChanged() {
+  for (auto* cp : AllProcesses(eLive)) {
+    Unused << cp->SendFontListChanged();
+  }
+}
+
+void ContentParent::BroadcastShmBlockAdded(uint32_t aGeneration,
+                                           uint32_t aIndex) {
+  auto* pfl = gfxPlatformFontList::PlatformFontList();
+  for (auto* cp : AllProcesses(eLive)) {
+    base::SharedMemoryHandle handle =
+        pfl->ShareShmBlockToProcess(aIndex, cp->Pid());
+    if (handle == base::SharedMemory::NULLHandle()) {
+      // If something went wrong here, we just skip it; the child will need to
+      // request the block as needed, at some performance cost.
+      continue;
+    }
+    Unused << cp->SendFontListShmBlockAdded(aGeneration, aIndex,
+                                            std::move(handle));
+  }
+}
+
+void ContentParent::BroadcastThemeUpdate(widget::ThemeChangeKind aKind) {
+  const FullLookAndFeel& lnf = *RemoteLookAndFeel::ExtractData();
+  for (auto* cp : AllProcesses(eLive)) {
+    Unused << cp->SendThemeChanged(lnf, aKind);
+  }
+}
+
+/*static */
+void ContentParent::BroadcastMediaCodecsSupportedUpdate(
+    RemoteDecodeIn aLocation, const media::MediaCodecsSupported& aSupported) {
+  // Merge incoming codec support with existing support list
+  media::MCSInfo::AddSupport(aSupported);
+  auto support = media::MCSInfo::GetSupport();
+
+  // Update processes
+  sCodecsSupported[aLocation] = support;
+  for (auto* cp : AllProcesses(eAll)) {
+    Unused << cp->SendUpdateMediaCodecsSupported(aLocation, support);
+  }
+
+  // Generate + save support string for display in about:support
+  nsCString supportString;
+  media::MCSInfo::GetMediaCodecsSupportedString(supportString, support);
+  gfx::gfxVars::SetCodecSupportInfo(supportString);
+}
+
+const nsACString& ContentParent::GetRemoteType() const { return mRemoteType; }
+
+static StaticRefPtr<nsIAsyncShutdownClient> sXPCOMShutdownClient;
+static StaticRefPtr<nsIAsyncShutdownClient> sProfileBeforeChangeClient;
+static StaticRefPtr<nsIAsyncShutdownClient> sQuitApplicationGrantedClient;
+
+void ContentParent::Init() {
+  MOZ_ASSERT(sXPCOMShutdownClient);
+
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    size_t length = ArrayLength(sObserverTopics);
+    for (size_t i = 0; i < length; ++i) {
+      obs->AddObserver(this, sObserverTopics[i], false);
+    }
+  }
+
+  if (obs) {
+    nsAutoString cpId;
+    cpId.AppendInt(static_cast<uint64_t>(this->ChildID()));
+    obs->NotifyObservers(static_cast<nsIObserver*>(this), "ipc:content-created",
+                         cpId.get());
+  }
+
+#ifdef ACCESSIBILITY
+  // If accessibility is running in chrome process then start it in content
+  // process.
+  if (GetAccService()) {
+#  if defined(XP_WIN)
+    // Don't init content a11y if we detect an incompat version of JAWS in use.
+    if (!mozilla::a11y::Compatibility::IsOldJAWS()) {
+      Unused << SendActivateA11y();
+    }
+#  else
+    Unused << SendActivateA11y();
+#  endif
+  }
+#endif  // #ifdef ACCESSIBILITY
+
+  Unused << SendInitProfiler(ProfilerParent::CreateForProcess(OtherPid()));
+
+  RefPtr<GeckoMediaPluginServiceParent> gmps(
+      GeckoMediaPluginServiceParent::GetSingleton());
+  if (gmps) {
+    gmps->UpdateContentProcessGMPCapabilities(this);
+  }
+
+  // Flush any pref updates that happened during launch and weren't
+  // included in the blobs set up in BeginSubprocessLaunch.
+  for (const Pref& pref : mQueuedPrefs) {
+    Unused << NS_WARN_IF(!SendPreferenceUpdate(pref));
+  }
+  mQueuedPrefs.Clear();
+
+  Unused << SendInitNextGenLocalStorageEnabled(NextGenLocalStorageEnabled());
+}
+
+// Note that for E10S we can get a false here that will be overruled by
+// TryToRecycleE10SOnly as late as MaybeBeginShutdown. We cannot really
+// foresee its result here.
+bool ContentParent::CheckTabDestroyWillKeepAlive(
+    uint32_t aExpectedBrowserCount) {
+  return ManagedPBrowserParent().Count() != aExpectedBrowserCount ||
+         ShouldKeepProcessAlive();
+}
+
+void ContentParent::NotifyTabWillDestroy() {
+  if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)
+#if !defined(MOZ_WIDGET_ANDROID)
+      /* on Android we keep processes alive more agressively, see
+         NotifyTabDestroying where we omit MaybeBeginShutdown */
+      || (/* we cannot trust CheckTabDestroyWillKeepAlive in E10S mode */
+          mozilla::FissionAutostart() &&
+          !CheckTabDestroyWillKeepAlive(mNumDestroyingTabs + 1))
+#endif
+  ) {
+    // Once we notify the impending shutdown, the content process will stop
+    // to process content JS on interrupt (among other things), so we need to
+    // be sure that the process will not be re-used after this point.
+    // The inverse is harmless, that is if we decide later to shut it down
+    // but did not notify here, it will be just notified later (but in rare
+    // cases too late to avoid a hang).
+    NotifyImpendingShutdown();
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+    mNotifiedImpendingShutdownOnTabWillDestroy = true;
+#endif
+  }
+}
+
+void ContentParent::MaybeBeginShutDown(uint32_t aExpectedBrowserCount,
+                                       bool aSendShutDown) {
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Verbose,
+          ("MaybeBeginShutdown %p, %u vs %u", this,
+           ManagedPBrowserParent().Count(), aExpectedBrowserCount));
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // Both CheckTabDestroyWillKeepAlive and TryToRecycleE10SOnly will return
+  // false if IsInOrBeyond(AppShutdownConfirmed), so if the parent shuts
+  // down we will always shutdown the child.
+  if (CheckTabDestroyWillKeepAlive(aExpectedBrowserCount) ||
+      TryToRecycleE10SOnly()) {
+    return;
+  }
+
+  MOZ_LOG(
+      ContentParent::GetLog(), LogLevel::Debug,
+      ("Beginning ContentParent Shutdown %p (%s)", this, mRemoteType.get()));
+
+  // We're dying now, prevent anything from re-using this process.
+  MarkAsDead();
+  SignalImpendingShutdownToContentJS();
+  StartForceKillTimer();
+
+  if (aSendShutDown) {
+    MaybeAsyncSendShutDownMessage();
+  }
+}
+
+void ContentParent::MaybeAsyncSendShutDownMessage() {
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Verbose,
+          ("MaybeAsyncSendShutDownMessage %p", this));
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(sRecycledE10SProcess != this);
+
+#ifdef DEBUG
+  // Calling this below while the lock is acquired will deadlock.
+  bool shouldKeepProcessAlive = ShouldKeepProcessAlive();
+#endif
+
+  {
+    MutexAutoLock lock(mThreadsafeHandle->mMutex);
+    MOZ_ASSERT_IF(!mThreadsafeHandle->mRemoteWorkerActorCount,
+                  !shouldKeepProcessAlive);
+
+    if (mThreadsafeHandle->mRemoteWorkerActorCount) {
+      return;
+    }
+
+    MOZ_ASSERT(!mThreadsafeHandle->mShutdownStarted);
+    mThreadsafeHandle->mShutdownStarted = true;
+  }
+
+  // In the case of normal shutdown, send a shutdown message to child to
+  // allow it to perform shutdown tasks.
+  GetCurrentSerialEventTarget()->Dispatch(NewRunnableMethod<ShutDownMethod>(
+      "dom::ContentParent::ShutDownProcess", this,
+      &ContentParent::ShutDownProcess, SEND_SHUTDOWN_MESSAGE));
+}
+
+void MaybeLogBlockShutdownDiagnostics(ContentParent* aSelf, const char* aMsg,
+                                      const char* aFile, int32_t aLine) {
+#if defined(MOZ_DIAGNOSTIC_ASSERT_ENABLED)
+  if (aSelf->IsBlockingShutdown()) {
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Info,
+            ("ContentParent: id=%p pid=%d - %s at %s(%d)", aSelf, aSelf->Pid(),
+             aMsg, aFile, aLine));
+  }
+#else
+  Unused << aSelf;
+  Unused << aMsg;
+  Unused << aFile;
+  Unused << aLine;
+#endif
+}
+
+bool ContentParent::ShutDownProcess(ShutDownMethod aMethod) {
+  bool result = false;
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+          ("ShutDownProcess: %p", this));
+  // NB: must MarkAsDead() here so that this isn't accidentally
+  // returned from Get*() while in the midst of shutdown.
+  MarkAsDead();
+
+  // Shutting down by sending a shutdown message works differently than the
+  // other methods. We first call Shutdown() in the child. After the child is
+  // ready, it calls FinishShutdown() on us. Then we close the channel.
+  if (aMethod == SEND_SHUTDOWN_MESSAGE) {
+    if (!mShutdownPending) {
+      if (CanSend()) {
+        // Stop sending input events with input priority when shutting down.
+        SetInputPriorityEventEnabled(false);
+        // Send a high priority announcement first. If this fails, SendShutdown
+        // will also fail.
+        Unused << SendShutdownConfirmedHP();
+        // Send the definite message with normal priority.
+        if (SendShutdown()) {
+          MaybeLogBlockShutdownDiagnostics(
+              this, "ShutDownProcess: Sent shutdown message.", __FILE__,
+              __LINE__);
+          mShutdownPending = true;
+          // Start the force-kill timer if we haven't already.
+          // This can happen if we shutdown a process while launching or
+          // because it is removed from the cached processes pool.
+          if (!mForceKillTimer) {
+            SignalImpendingShutdownToContentJS();
+            StartForceKillTimer();
+          }
+          result = true;
+        } else {
+          MaybeLogBlockShutdownDiagnostics(
+              this, "ShutDownProcess: !!! Send shutdown message failed! !!!",
+              __FILE__, __LINE__);
+        }
+      } else {
+        MaybeLogBlockShutdownDiagnostics(
+            this, "ShutDownProcess: !!! !CanSend !!!", __FILE__, __LINE__);
+      }
+    } else {
+      MaybeLogBlockShutdownDiagnostics(
+          this, "ShutDownProcess: Shutdown already pending.", __FILE__,
+          __LINE__);
+
+      result = true;
+    }
+    // If call was not successful, the channel must have been broken
+    // somehow, and we will clean up the error in ActorDestroy.
+    return result;
+  }
+
+  using mozilla::dom::quota::QuotaManagerService;
+
+  if (QuotaManagerService* qms = QuotaManagerService::GetOrCreate()) {
+    qms->AbortOperationsForProcess(mChildID);
+  }
+
+  if (aMethod == CLOSE_CHANNEL || aMethod == CLOSE_CHANNEL_WITH_ERROR) {
+    if (!mCalledClose) {
+      MaybeLogBlockShutdownDiagnostics(
+          this, "ShutDownProcess: Closing channel.", __FILE__, __LINE__);
+      // Close()/CloseWithError() can only be called once: They kick off the
+      // destruction sequence.
+      mCalledClose = true;
+      if (aMethod == CLOSE_CHANNEL_WITH_ERROR) {
+        CloseWithError();
+      } else {
+        Close();
+      }
+    }
+    result = true;
+  }
+
+  // A ContentParent object might not get freed until after XPCOM shutdown has
+  // shut down the cycle collector.  But by then it's too late to release any
+  // CC'ed objects, so we need to null them out here, while we still can.  See
+  // bug 899761.
+  ShutDownMessageManager();
+  return result;
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvNotifyShutdownSuccess() {
+  if (!mShutdownPending) {
+    return IPC_FAIL(this, "RecvNotifyShutdownSuccess without mShutdownPending");
+  }
+
+  mIsNotifiedShutdownSuccess = true;
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvFinishShutdown() {
+  if (!mShutdownPending) {
+    return IPC_FAIL(this, "RecvFinishShutdown without mShutdownPending");
+  }
+
+  // At this point, we already called ShutDownProcess once with
+  // SEND_SHUTDOWN_MESSAGE. To actually close the channel, we call
+  // ShutDownProcess again with CLOSE_CHANNEL.
+  if (mCalledClose) {
+    MaybeLogBlockShutdownDiagnostics(
+        this, "RecvFinishShutdown: Channel already closed.", __FILE__,
+        __LINE__);
+  }
+
+  ShutDownProcess(CLOSE_CHANNEL);
+  return IPC_OK();
+}
+
+void ContentParent::ShutDownMessageManager() {
+  if (!mMessageManager) {
+    return;
+  }
+
+  mMessageManager->ReceiveMessage(mMessageManager, nullptr,
+                                  CHILD_PROCESS_SHUTDOWN_MESSAGE, false,
+                                  nullptr, nullptr, IgnoreErrors());
+
+  mMessageManager->SetOsPid(-1);
+  mMessageManager->Disconnect();
+  mMessageManager = nullptr;
+}
+
+void ContentParent::AddToPool(nsTArray<ContentParent*>& aPool) {
+  MOZ_DIAGNOSTIC_ASSERT(!mIsInPool);
+  AssertAlive();
+  MOZ_DIAGNOSTIC_ASSERT(!mCalledKillHard);
+  aPool.AppendElement(this);
+  mIsInPool = true;
+}
+
+void ContentParent::RemoveFromPool(nsTArray<ContentParent*>& aPool) {
+  MOZ_DIAGNOSTIC_ASSERT(mIsInPool);
+  aPool.RemoveElement(this);
+  mIsInPool = false;
+}
+
+void ContentParent::AssertNotInPool() {
+  MOZ_RELEASE_ASSERT(!mIsInPool);
+
+  MOZ_RELEASE_ASSERT(sRecycledE10SProcess != this);
+  if (IsForJSPlugin()) {
+    MOZ_RELEASE_ASSERT(!sJSPluginContentParents ||
+                       !sJSPluginContentParents->Get(mJSPluginID));
+  } else {
+    MOZ_RELEASE_ASSERT(
+        !sBrowserContentParents ||
+        !sBrowserContentParents->Contains(mRemoteType) ||
+        !sBrowserContentParents->Get(mRemoteType)->Contains(this));
+
+    for (const auto& group : mGroups) {
+      MOZ_RELEASE_ASSERT(group->GetHostProcess(mRemoteType) != this,
+                         "still a host process for one of our groups?");
+    }
+  }
+}
+
+void ContentParent::AssertAlive() {
+  MOZ_DIAGNOSTIC_ASSERT(!mNotifiedImpendingShutdownOnTabWillDestroy);
+  MOZ_DIAGNOSTIC_ASSERT(!mIsSignaledImpendingShutdown);
+  MOZ_DIAGNOSTIC_ASSERT(!IsDead());
+}
+
+void ContentParent::RemoveFromList() {
+  if (IsForJSPlugin()) {
+    if (sJSPluginContentParents) {
+      sJSPluginContentParents->Remove(mJSPluginID);
+      if (!sJSPluginContentParents->Count()) {
+        sJSPluginContentParents = nullptr;
+      }
+    }
+    return;
+  }
+
+  if (!mIsInPool) {
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+    AssertNotInPool();
+#endif
+    return;
+  }
+
+  // Ensure that this BrowsingContextGroup is no longer used to host new
+  // documents from any associated BrowsingContextGroups. It may become a host
+  // again in the future, if it is restored to the pool.
+  for (const auto& group : mGroups) {
+    group->RemoveHostProcess(this);
+  }
+
+  StopRecyclingE10SOnly(/* aForeground */ false);
+
+  if (sBrowserContentParents) {
+    if (auto entry = sBrowserContentParents->Lookup(mRemoteType)) {
+      const auto& contentParents = entry.Data();
+      RemoveFromPool(*contentParents);
+      if (contentParents->IsEmpty()) {
+        entry.Remove();
+      }
+    }
+    if (sBrowserContentParents->IsEmpty()) {
+      delete sBrowserContentParents;
+      sBrowserContentParents = nullptr;
+    }
+  }
+}
+
+void ContentParent::MarkAsDead() {
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Verbose,
+          ("Marking ContentProcess %p as dead", this));
+  MOZ_DIAGNOSTIC_ASSERT(!sInProcessSelector);
+  RemoveFromList();
+
+  // Prevent this process from being re-used.
+  PreallocatedProcessManager::Erase(this);
+  StopRecyclingE10SOnly(false);
+
+#ifdef MOZ_WIDGET_ANDROID
+  if (IsAlive()) {
+    // We're intentionally killing the content process at this point to ensure
+    // that we never have a "dead" content process sitting around and occupying
+    // an Android Service.
+    nsCOMPtr<nsIEventTarget> launcherThread(GetIPCLauncher());
+    MOZ_ASSERT(launcherThread);
+
+    auto procType = java::GeckoProcessType::CONTENT();
+    auto selector =
+        java::GeckoProcessManager::Selector::New(procType, OtherPid());
+
+    launcherThread->Dispatch(NS_NewRunnableFunction(
+        "ContentParent::MarkAsDead",
+        [selector =
+             java::GeckoProcessManager::Selector::GlobalRef(selector)]() {
+          java::GeckoProcessManager::ShutdownProcess(selector);
+        }));
+  }
+#endif
+
+  if (mScriptableHelper) {
+    static_cast<ScriptableCPInfo*>(mScriptableHelper.get())->ProcessDied();
+    mScriptableHelper = nullptr;
+  }
+
+  mLifecycleState = LifecycleState::DEAD;
+}
+
+void ContentParent::OnChannelError() {
+  RefPtr<ContentParent> kungFuDeathGrip(this);
+  PContentParent::OnChannelError();
+}
+
+void ContentParent::ProcessingError(Result aCode, const char* aReason) {
+  if (MsgDropped == aCode) {
+    return;
+  }
+  // Other errors are big deals.
+#ifndef FUZZING
+  KillHard(aReason);
+#endif
+  ShutDownProcess(CLOSE_CHANNEL_WITH_ERROR);
+}
+
+void ContentParent::ActorDestroy(ActorDestroyReason why) {
+  if (mForceKillTimer) {
+    mForceKillTimer->Cancel();
+    mForceKillTimer = nullptr;
+  }
+
+  // Signal shutdown completion regardless of error state, so we can
+  // finish waiting in the xpcom-shutdown/profile-before-change observer.
+  RemoveShutdownBlockers();
+
+  if (mHangMonitorActor) {
+    ProcessHangMonitor::RemoveProcess(mHangMonitorActor);
+    mHangMonitorActor = nullptr;
+  }
+
+  RefPtr<FileSystemSecurity> fss = FileSystemSecurity::Get();
+  if (fss) {
+    fss->Forget(ChildID());
+  }
+
+  if (why == NormalShutdown && !mCalledClose) {
+    // If we shut down normally but haven't called Close, assume somebody
+    // else called Close on us. In that case, we still need to call
+    // ShutDownProcess below to perform other necessary clean up.
+    mCalledClose = true;
+  }
+
+  // Make sure we always clean up.
+  ShutDownProcess(why == NormalShutdown ? CLOSE_CHANNEL
+                                        : CLOSE_CHANNEL_WITH_ERROR);
+
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    size_t length = ArrayLength(sObserverTopics);
+    for (size_t i = 0; i < length; ++i) {
+      obs->RemoveObserver(static_cast<nsIObserver*>(this), sObserverTopics[i]);
+    }
+  }
+
+  // remove the global remote preferences observers
+  Preferences::RemoveObserver(this, "");
+  gfxVars::RemoveReceiver(this);
+
+  if (GPUProcessManager* gpu = GPUProcessManager::Get()) {
+    // Note: the manager could have shutdown already.
+    gpu->RemoveListener(this);
+  }
+
+  RecvRemoveGeolocationListener();
+
+  // Destroy our JSProcessActors, and reject any pending queries.
+  JSActorDidDestroy();
+
+  if (obs) {
+    RefPtr<nsHashPropertyBag> props = new nsHashPropertyBag();
+
+    props->SetPropertyAsUint64(u"childID"_ns, mChildID);
+
+    if (AbnormalShutdown == why) {
+      Telemetry::Accumulate(Telemetry::SUBPROCESS_ABNORMAL_ABORT, "content"_ns,
+                            1);
+
+      props->SetPropertyAsBool(u"abnormal"_ns, true);
+
+      nsAutoString dumpID;
+      // There's a window in which child processes can crash
+      // after IPC is established, but before a crash reporter
+      // is created.
+      if (mCrashReporter) {
+        // if mCreatedPairedMinidumps is true, we've already generated
+        // parent/child dumps for desktop crashes.
+        if (!mCreatedPairedMinidumps) {
+#if defined(XP_MACOSX)
+          RefPtr<nsAvailableMemoryWatcherBase> memWatcher;
+          memWatcher = nsAvailableMemoryWatcherBase::GetSingleton();
+          memWatcher->AddChildAnnotations(mCrashReporter);
+#endif
+
+          mCrashReporter->GenerateCrashReport(OtherPid());
+        }
+
+        if (mCrashReporter->HasMinidump()) {
+          dumpID = mCrashReporter->MinidumpID();
+        }
+      } else {
+        HandleOrphanedMinidump(&dumpID);
+      }
+
+      if (!dumpID.IsEmpty()) {
+        props->SetPropertyAsAString(u"dumpID"_ns, dumpID);
+      }
+    }
+    nsAutoString cpId;
+    cpId.AppendInt(static_cast<uint64_t>(this->ChildID()));
+    obs->NotifyObservers((nsIPropertyBag2*)props, "ipc:content-shutdown",
+                         cpId.get());
+  }
+
+  // Remove any and all idle listeners.
+  if (mIdleListeners.Length() > 0) {
+    nsCOMPtr<nsIUserIdleService> idleService =
+        do_GetService("@mozilla.org/widget/useridleservice;1");
+    if (idleService) {
+      RefPtr<ParentIdleListener> listener;
+      for (const auto& lentry : mIdleListeners) {
+        listener = static_cast<ParentIdleListener*>(lentry.get());
+        idleService->RemoveIdleObserver(listener, listener->mTime);
+      }
+    }
+    mIdleListeners.Clear();
+  }
+
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Verbose,
+          ("destroying Subprocess in ActorDestroy: ContentParent %p "
+           "mSubprocess %p handle %" PRIuPTR,
+           this, mSubprocess,
+           mSubprocess ? (uintptr_t)mSubprocess->GetChildProcessHandle() : -1));
+  // FIXME (bug 1520997): does this really need an additional dispatch?
+  if (GetCurrentSerialEventTarget()) {
+    GetCurrentSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
+        "DelayedDeleteSubprocessRunnable", [subprocess = mSubprocess] {
+          MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+                  ("destroyed Subprocess in ActorDestroy: Subprocess %p handle "
+                   "%" PRIuPTR,
+                   subprocess,
+                   subprocess ? (uintptr_t)subprocess->GetChildProcessHandle()
+                              : -1));
+          subprocess->Destroy();
+        }));
+  }
+  mSubprocess = nullptr;
+
+  ContentProcessManager* cpm = ContentProcessManager::GetSingleton();
+  if (cpm) {
+    cpm->RemoveContentProcess(this->ChildID());
+  }
+
+  if (mDriverCrashGuard) {
+    mDriverCrashGuard->NotifyCrashed();
+  }
+
+  // Unregister all the BlobURLs registered by the ContentChild.
+  for (uint32_t i = 0; i < mBlobURLs.Length(); ++i) {
+    BlobURLProtocolHandler::RemoveDataEntry(mBlobURLs[i]);
+  }
+
+  mBlobURLs.Clear();
+
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+  AssertNotInPool();
+#endif
+
+  // As this process is going away, ensure that every BrowsingContext hosted by
+  // it has been detached, and every BrowsingContextGroup has been fully
+  // unsubscribed.
+  BrowsingContext::DiscardFromContentParent(this);
+
+  const nsTHashSet<RefPtr<BrowsingContextGroup>> groups = std::move(mGroups);
+  for (const auto& group : groups) {
+    group->Unsubscribe(this);
+  }
+  MOZ_DIAGNOSTIC_ASSERT(mGroups.IsEmpty());
+
+  mPendingLoadStates.Clear();
+}
+
+bool ContentParent::TryToRecycleE10SOnly() {
+  // Only try to recycle "web" content processes, as other remote types are
+  // generally more unique, and cannot be effectively re-used. This is disabled
+  // with Fission, as "web" content processes are no longer frequently used.
+  //
+  // Disabling the process pre-allocator will also disable process recycling,
+  // allowing for more consistent process counts under testing.
+  if (mRemoteType != DEFAULT_REMOTE_TYPE || mozilla::FissionAutostart() ||
+      !PreallocatedProcessManager::Enabled()) {
+    return false;
+  }
+
+  // This life time check should be replaced by a memory health check (memory
+  // usage + fragmentation).
+
+  // Note that this is specifically to help with edge cases that rapidly
+  // create-and-destroy processes
+  const double kMaxLifeSpan = 5;
+  MOZ_LOG(
+      ContentParent::GetLog(), LogLevel::Debug,
+      ("TryToRecycle ContentProcess %p (%u) with lifespan %f seconds", this,
+       (unsigned int)ChildID(), (TimeStamp::Now() - mActivateTS).ToSeconds()));
+
+  if (mCalledKillHard || !IsAlive() ||
+      (TimeStamp::Now() - mActivateTS).ToSeconds() > kMaxLifeSpan) {
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+            ("TryToRecycle did not recycle %p", this));
+
+    // It's possible that the process was already cached, and we're being called
+    // from a different path, and we're now past kMaxLifeSpan (or some other).
+    // Ensure that if we're going to kill this process we don't recycle it.
+    StopRecyclingE10SOnly(/* aForeground */ false);
+    return false;
+  }
+
+  if (!sRecycledE10SProcess) {
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+            ("TryToRecycle began recycling %p", this));
+    sRecycledE10SProcess = this;
+
+    ProcessPriorityManager::SetProcessPriority(this,
+                                               PROCESS_PRIORITY_BACKGROUND);
+    return true;
+  }
+
+  if (sRecycledE10SProcess == this) {
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+            ("TryToRecycle continue recycling %p", this));
+    return true;
+  }
+
+  // Some other process is already being recycled, just shut this one down.
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+          ("TryToRecycle did not recycle %p (already recycling %p)", this,
+           sRecycledE10SProcess.get()));
+  return false;
+}
+
+void ContentParent::StopRecyclingE10SOnly(bool aForeground) {
+  if (sRecycledE10SProcess != this) {
+    return;
+  }
+
+  sRecycledE10SProcess = nullptr;
+  if (aForeground) {
+    ProcessPriorityManager::SetProcessPriority(this,
+                                               PROCESS_PRIORITY_FOREGROUND);
+  }
+}
+
+bool ContentParent::HasActiveWorkerOrJSPlugin() {
+  if (IsForJSPlugin()) {
+    return true;
+  }
+
+  // If we have active workers, we need to stay alive.
+  {
+    MutexAutoLock lock(mThreadsafeHandle->mMutex);
+    if (mThreadsafeHandle->mRemoteWorkerActorCount) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool ContentParent::ShouldKeepProcessAlive() {
+  if (HasActiveWorkerOrJSPlugin()) {
+    return true;
+  }
+
+  if (mNumKeepaliveCalls > 0) {
+    return true;
+  }
+
+  if (IsLaunching()) {
+    return true;
+  }
+
+  // If we have already been marked as dead, don't prevent shutdown.
+  if (IsDead()) {
+    return false;
+  }
+
+  // If everything is going down, there is no need to keep us alive, neither.
+  if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
+    return false;
+  }
+
+  if (!sBrowserContentParents) {
+    return false;
+  }
+
+  auto contentParents = sBrowserContentParents->Get(mRemoteType);
+  if (!contentParents) {
+    return false;
+  }
+
+  // We might want to keep some content processes alive for performance reasons.
+  // e.g. test runs and privileged content process for some about: pages.
+  // We don't want to alter behavior if the pref is not set, so default to 0.
+  int32_t processesToKeepAlive = 0;
+
+  nsAutoCString keepAlivePref("dom.ipc.keepProcessesAlive.");
+
+  if (StringBeginsWith(mRemoteType, FISSION_WEB_REMOTE_TYPE) &&
+      xpc::IsInAutomation()) {
+    keepAlivePref.Append(FISSION_WEB_REMOTE_TYPE);
+    keepAlivePref.AppendLiteral(".perOrigin");
+  } else {
+    keepAlivePref.Append(mRemoteType);
+  }
+  if (NS_FAILED(
+          Preferences::GetInt(keepAlivePref.get(), &processesToKeepAlive))) {
+    return false;
+  }
+
+  int32_t numberOfAliveProcesses = contentParents->Length();
+
+  return numberOfAliveProcesses <= processesToKeepAlive;
+}
+
+void ContentParent::NotifyTabDestroying() {
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+          ("NotifyTabDestroying %p:", this));
+  // There can be more than one PBrowser for a given app process
+  // because of popup windows.  PBrowsers can also destroy
+  // concurrently.  When all the PBrowsers are destroying, kick off
+  // another task to ensure the child process *really* shuts down,
+  // even if the PBrowsers themselves never finish destroying.
+  ++mNumDestroyingTabs;
+
+  /**
+   * We intentionally skip this code on Android:
+   * 1. Android has a fixed upper bound on the number of content processes, so
+   *    we prefer to re-use them whenever possible (as opposed to letting an
+   *    old process wind down while we launch a new one).
+   * 2. GeckoView always hard-kills content processes (and if it does not,
+   *    Android itself will), so we don't concern ourselves with the ForceKill
+   *    timer either.
+   */
+#if !defined(MOZ_WIDGET_ANDROID)
+  MaybeBeginShutDown(/* aExpectedBrowserCount */ mNumDestroyingTabs,
+                     /* aSendShutDown */ false);
+#endif  // !defined(MOZ_WIDGET_ANDROID)
+}
+
+void ContentParent::AddKeepAlive() {
+  AssertAlive();
+  // Something wants to keep this content process alive.
+  ++mNumKeepaliveCalls;
+}
+
+void ContentParent::RemoveKeepAlive() {
+  MOZ_DIAGNOSTIC_ASSERT(mNumKeepaliveCalls > 0);
+  --mNumKeepaliveCalls;
+
+  MaybeBeginShutDown();
+}
+
+void ContentParent::StartForceKillTimer() {
+  if (mForceKillTimer || !CanSend()) {
+    return;
+  }
+
+  int32_t timeoutSecs = StaticPrefs::dom_ipc_tabs_shutdownTimeoutSecs();
+  if (timeoutSecs > 0) {
+    NS_NewTimerWithFuncCallback(getter_AddRefs(mForceKillTimer),
+                                ContentParent::ForceKillTimerCallback, this,
+                                timeoutSecs * 1000, nsITimer::TYPE_ONE_SHOT,
+                                "dom::ContentParent::StartForceKillTimer");
+    MOZ_ASSERT(mForceKillTimer);
+  }
+}
+
+void ContentParent::NotifyTabDestroyed(const TabId& aTabId,
+                                       bool aNotifiedDestroying) {
+  if (aNotifiedDestroying) {
+    --mNumDestroyingTabs;
+  }
+
+  nsTArray<PContentPermissionRequestParent*> parentArray =
+      nsContentPermissionUtils::GetContentPermissionRequestParentById(aTabId);
+
+  // Need to close undeleted ContentPermissionRequestParents before tab is
+  // closed.
+  for (auto& permissionRequestParent : parentArray) {
+    Unused << PContentPermissionRequestParent::Send__delete__(
+        permissionRequestParent);
+  }
+
+  // There can be more than one PBrowser for a given app process
+  // because of popup windows.  When the last one closes, shut
+  // us down.
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Verbose,
+          ("NotifyTabDestroyed %p", this));
+
+  MaybeBeginShutDown(/* aExpectedBrowserCount */ 1);
+}
+
+TestShellParent* ContentParent::CreateTestShell() {
+  return static_cast<TestShellParent*>(SendPTestShellConstructor());
+}
+
+bool ContentParent::DestroyTestShell(TestShellParent* aTestShell) {
+  return PTestShellParent::Send__delete__(aTestShell);
+}
+
+TestShellParent* ContentParent::GetTestShellSingleton() {
+  PTestShellParent* p = LoneManagedOrNullAsserts(ManagedPTestShellParent());
+  return static_cast<TestShellParent*>(p);
+}
+
+#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
+// Append the sandbox command line parameters that are not static. i.e.,
+// parameters that can be different for different child processes.
+void ContentParent::AppendDynamicSandboxParams(
+    std::vector<std::string>& aArgs) {
+  // For file content processes
+  if (GetRemoteType() == FILE_REMOTE_TYPE) {
+    MacSandboxInfo::AppendFileAccessParam(aArgs, true);
+  }
+}
+
+// Generate the static sandbox command line parameters and store
+// them in the provided params vector to be used each time a new
+// content process is launched.
+static void CacheSandboxParams(std::vector<std::string>& aCachedParams) {
+  // This must only be called once and we should
+  // be starting with an empty list of parameters.
+  MOZ_ASSERT(aCachedParams.empty());
+
+  MacSandboxInfo info;
+  info.type = MacSandboxType_Content;
+  info.level = GetEffectiveContentSandboxLevel();
+
+  // Sandbox logging
+  if (Preferences::GetBool("security.sandbox.logging.enabled") ||
+      PR_GetEnv("MOZ_SANDBOX_LOGGING")) {
+    info.shouldLog = true;
+  }
+
+  // Audio access
+  if (!StaticPrefs::media_cubeb_sandbox()) {
+    info.hasAudio = true;
+  }
+
+  // Window server access. If the disconnect-windowserver pref is not
+  // "true" or out-of-process WebGL is not enabled, allow window server
+  // access in the sandbox policy.
+  if (!Preferences::GetBool(
+          "security.sandbox.content.mac.disconnect-windowserver") ||
+      !Preferences::GetBool("webgl.out-of-process")) {
+    info.hasWindowServer = true;
+  }
+
+  // .app path (normalized)
+  nsAutoCString appPath;
+  if (!nsMacUtilsImpl::GetAppPath(appPath)) {
+    MOZ_CRASH("Failed to get app dir paths");
+  }
+  info.appPath = appPath.get();
+
+  // TESTING_READ_PATH1
+  nsAutoCString testingReadPath1;
+  Preferences::GetCString("security.sandbox.content.mac.testing_read_path1",
+                          testingReadPath1);
+  if (!testingReadPath1.IsEmpty()) {
+    info.testingReadPath1 = testingReadPath1.get();
+  }
+
+  // TESTING_READ_PATH2
+  nsAutoCString testingReadPath2;
+  Preferences::GetCString("security.sandbox.content.mac.testing_read_path2",
+                          testingReadPath2);
+  if (!testingReadPath2.IsEmpty()) {
+    info.testingReadPath2 = testingReadPath2.get();
+  }
+
+  // TESTING_READ_PATH3, TESTING_READ_PATH4. In non-packaged builds,
+  // these are used to whitelist the repo dir and object dir respectively.
+  nsresult rv;
+  if (!mozilla::IsPackagedBuild()) {
+    // Repo dir
+    nsCOMPtr<nsIFile> repoDir;
+    rv = nsMacUtilsImpl::GetRepoDir(getter_AddRefs(repoDir));
+    if (NS_FAILED(rv)) {
+      MOZ_CRASH("Failed to get path to repo dir");
+    }
+    nsCString repoDirPath;
+    Unused << repoDir->GetNativePath(repoDirPath);
+    info.testingReadPath3 = repoDirPath.get();
+
+    // Object dir
+    nsCOMPtr<nsIFile> objDir;
+    rv = nsMacUtilsImpl::GetObjDir(getter_AddRefs(objDir));
+    if (NS_FAILED(rv)) {
+      MOZ_CRASH("Failed to get path to build object dir");
+    }
+    nsCString objDirPath;
+    Unused << objDir->GetNativePath(objDirPath);
+    info.testingReadPath4 = objDirPath.get();
+  }
+
+  // DEBUG_WRITE_DIR
+#  ifdef DEBUG
+  // For bloat/leak logging or when a content process dies intentionally
+  // (|NoteIntentionalCrash|) for tests, it wants to log that it did this.
+  // Allow writing to this location.
+  nsAutoCString bloatLogDirPath;
+  if (NS_SUCCEEDED(nsMacUtilsImpl::GetBloatLogDir(bloatLogDirPath))) {
+    info.debugWriteDir = bloatLogDirPath.get();
+  }
+#  endif  // DEBUG
+
+  info.AppendAsParams(aCachedParams);
+}
+
+// Append sandboxing command line parameters.
+void ContentParent::AppendSandboxParams(std::vector<std::string>& aArgs) {
+  MOZ_ASSERT(sMacSandboxParams != nullptr);
+
+  // An empty sMacSandboxParams indicates this is the
+  // first invocation and we don't have cached params yet.
+  if (sMacSandboxParams->empty()) {
+    CacheSandboxParams(*sMacSandboxParams);
+    MOZ_ASSERT(!sMacSandboxParams->empty());
+  }
+
+  // Append cached arguments.
+  aArgs.insert(aArgs.end(), sMacSandboxParams->begin(),
+               sMacSandboxParams->end());
+
+  // Append remaining arguments.
+  AppendDynamicSandboxParams(aArgs);
+}
+#endif  // XP_MACOSX && MOZ_SANDBOX
+
+bool ContentParent::BeginSubprocessLaunch(ProcessPriority aPriority) {
+  AUTO_PROFILER_LABEL("ContentParent::LaunchSubprocess", OTHER);
+
+  // Ensure we will not rush through our shutdown phases while launching.
+  // LaunchSubprocessReject will remove them in case of failure,
+  // otherwise ActorDestroy will take care.
+  AddShutdownBlockers();
+
+  if (!ContentProcessManager::GetSingleton()) {
+    MOZ_ASSERT(false, "Unable to acquire ContentProcessManager singleton!");
+    return false;
+  }
+
+  std::vector<std::string> extraArgs;
+  geckoargs::sChildID.Put(mChildID, extraArgs);
+  geckoargs::sIsForBrowser.Put(IsForBrowser(), extraArgs);
+  geckoargs::sNotForBrowser.Put(!IsForBrowser(), extraArgs);
+
+  // Prefs information is passed via anonymous shared memory to avoid bloating
+  // the command line.
+
+  // Instantiate the pref serializer. It will be cleaned up in
+  // `LaunchSubprocessReject`/`LaunchSubprocessResolve`.
+  mPrefSerializer = MakeUnique<mozilla::ipc::SharedPreferenceSerializer>();
+  if (!mPrefSerializer->SerializeToSharedMemory(GeckoProcessType_Content,
+                                                GetRemoteType())) {
+    NS_WARNING("SharedPreferenceSerializer::SerializeToSharedMemory failed");
+    MarkAsDead();
+    return false;
+  }
+  mPrefSerializer->AddSharedPrefCmdLineArgs(*mSubprocess, extraArgs);
+
+  // The JS engine does some computation during the initialization which can be
+  // shared across processes. We add command line arguments to pass a file
+  // handle and its content length, to minimize the startup time of content
+  // processes.
+  ::mozilla::ipc::ExportSharedJSInit(*mSubprocess, extraArgs);
+
+  // Register ContentParent as an observer for changes to any pref
+  // whose prefix matches the empty string, i.e. all of them.  The
+  // observation starts here in order to capture pref updates that
+  // happen during async launch.
+  Preferences::AddStrongObserver(this, "");
+
+  if (gSafeMode) {
+    geckoargs::sSafeMode.Put(extraArgs);
+  }
+
+#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
+  if (IsContentSandboxEnabled()) {
+    AppendSandboxParams(extraArgs);
+    mSubprocess->DisableOSActivityMode();
+  }
+#endif
+
+  nsCString parentBuildID(mozilla::PlatformBuildID());
+  geckoargs::sParentBuildID.Put(parentBuildID.get(), extraArgs);
+
+#ifdef MOZ_WIDGET_GTK
+  // This is X11-only pending a solution for WebGL in Wayland mode.
+  if (StaticPrefs::dom_ipc_avoid_gtk() &&
+      StaticPrefs::widget_non_native_theme_enabled() &&
+      widget::GdkIsX11Display()) {
+    mSubprocess->SetEnv("MOZ_HEADLESS", "1");
+  }
+#endif
+
+  mLaunchYieldTS = TimeStamp::Now();
+  return mSubprocess->AsyncLaunch(std::move(extraArgs));
+}
+
+void ContentParent::LaunchSubprocessReject() {
+  NS_WARNING("failed to launch child in the parent");
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Verbose,
+          ("failed to launch child in the parent"));
+  // Now that communication with the child is complete, we can cleanup
+  // the preference serializer.
+  mPrefSerializer = nullptr;
+  if (mIsAPreallocBlocker) {
+    PreallocatedProcessManager::RemoveBlocker(mRemoteType, this);
+    mIsAPreallocBlocker = false;
+  }
+  MarkAsDead();
+  RemoveShutdownBlockers();
+}
+
+bool ContentParent::LaunchSubprocessResolve(bool aIsSync,
+                                            ProcessPriority aPriority) {
+  AUTO_PROFILER_LABEL("ContentParent::LaunchSubprocess::resolve", OTHER);
+
+  if (mLaunchResolved) {
+    // We've already been called, return.
+    MOZ_ASSERT(sCreatedFirstContentProcess);
+    MOZ_ASSERT(!mPrefSerializer);
+    MOZ_ASSERT(mLifecycleState != LifecycleState::LAUNCHING);
+    return mLaunchResolvedOk;
+  }
+  mLaunchResolved = true;
+
+  // Now that communication with the child is complete, we can cleanup
+  // the preference serializer.
+  mPrefSerializer = nullptr;
+
+  const auto launchResumeTS = TimeStamp::Now();
+  if (profiler_thread_is_being_profiled_for_markers()) {
+    nsPrintfCString marker("Process start%s for %u",
+                           mIsAPreallocBlocker ? " (immediate)" : "",
+                           (unsigned int)ChildID());
+    PROFILER_MARKER_TEXT(
+        mIsAPreallocBlocker ? ProfilerString8View("Process Immediate Launch")
+                            : ProfilerString8View("Process Launch"),
+        DOM, MarkerTiming::Interval(mLaunchTS, launchResumeTS), marker);
+  }
+
+  if (!sCreatedFirstContentProcess) {
+    nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+    obs->NotifyObservers(nullptr, "ipc:first-content-process-created", nullptr);
+    sCreatedFirstContentProcess = true;
+  }
+
+  mSubprocess->TakeInitialEndpoint().Bind(this);
+
+  ContentProcessManager* cpm = ContentProcessManager::GetSingleton();
+  if (!cpm) {
+    NS_WARNING("immediately shutting-down caused by our shutdown");
+    ShutDownProcess(SEND_SHUTDOWN_MESSAGE);
+    return false;
+  }
+  cpm->AddContentProcess(this);
+
+#ifdef MOZ_CODE_COVERAGE
+  Unused << SendShareCodeCoverageMutex(
+      CodeCoverageHandler::Get()->GetMutexHandle());
+#endif
+
+  // We must be in the LAUNCHING state still. If we've somehow already been
+  // marked as DEAD, fail the process launch, and immediately begin tearing down
+  // the content process.
+  if (IsDead()) {
+    NS_WARNING("immediately shutting-down already-dead process");
+    ShutDownProcess(SEND_SHUTDOWN_MESSAGE);
+    return false;
+  }
+  MOZ_ASSERT(mLifecycleState == LifecycleState::LAUNCHING);
+  mLifecycleState = LifecycleState::ALIVE;
+
+  if (!InitInternal(aPriority)) {
+    NS_WARNING("failed to initialize child in the parent");
+    // We've already called Open() by this point, so we need to close the
+    // channel to avoid leaking the process.
+    ShutDownProcess(SEND_SHUTDOWN_MESSAGE);
+    return false;
+  }
+
+  mHangMonitorActor = ProcessHangMonitor::AddProcess(this);
+
+  // Set a reply timeout for CPOWs.
+  SetReplyTimeoutMs(StaticPrefs::dom_ipc_cpow_timeout());
+
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    nsAutoString cpId;
+    cpId.AppendInt(static_cast<uint64_t>(this->ChildID()));
+    obs->NotifyObservers(static_cast<nsIObserver*>(this),
+                         "ipc:content-initializing", cpId.get());
+  }
+
+  Init();
+
+  mLifecycleState = LifecycleState::INITIALIZED;
+
+  if (aIsSync) {
+    Telemetry::AccumulateTimeDelta(Telemetry::CONTENT_PROCESS_SYNC_LAUNCH_MS,
+                                   mLaunchTS);
+  } else {
+    Telemetry::AccumulateTimeDelta(Telemetry::CONTENT_PROCESS_LAUNCH_TOTAL_MS,
+                                   mLaunchTS);
+
+    Telemetry::Accumulate(
+        Telemetry::CONTENT_PROCESS_LAUNCH_MAINTHREAD_MS,
+        static_cast<uint32_t>(
+            ((mLaunchYieldTS - mLaunchTS) + (TimeStamp::Now() - launchResumeTS))
+                .ToMilliseconds()));
+  }
+
+  mLaunchResolvedOk = true;
+  return true;
+}
+
+bool ContentParent::LaunchSubprocessSync(
+    hal::ProcessPriority aInitialPriority) {
+  // We've started a sync content process launch.
+  Telemetry::Accumulate(Telemetry::CONTENT_PROCESS_LAUNCH_IS_SYNC, 1);
+
+  if (BeginSubprocessLaunch(aInitialPriority)) {
+    const bool ok = mSubprocess->WaitForProcessHandle();
+    if (ok && LaunchSubprocessResolve(/* aIsSync = */ true, aInitialPriority)) {
+      return true;
+    }
+  }
+  LaunchSubprocessReject();
+  return false;
+}
+
+RefPtr<ContentParent::LaunchPromise> ContentParent::LaunchSubprocessAsync(
+    hal::ProcessPriority aInitialPriority) {
+  // We've started an async content process launch.
+  Telemetry::Accumulate(Telemetry::CONTENT_PROCESS_LAUNCH_IS_SYNC, 0);
+
+  if (!BeginSubprocessLaunch(aInitialPriority)) {
+    // Launch aborted because of shutdown. Bailout.
+    LaunchSubprocessReject();
+    return LaunchPromise::CreateAndReject(NS_ERROR_ILLEGAL_DURING_SHUTDOWN,
+                                          __func__);
+  }
+
+  // Otherwise, wait until the process is ready.
+  RefPtr<ProcessHandlePromise> ready = mSubprocess->WhenProcessHandleReady();
+  RefPtr<ContentParent> self = this;
+  mLaunchYieldTS = TimeStamp::Now();
+
+  return ready->Then(
+      GetCurrentSerialEventTarget(), __func__,
+      [self, aInitialPriority](
+          const ProcessHandlePromise::ResolveOrRejectValue& aValue) {
+        if (aValue.IsResolve() &&
+            self->LaunchSubprocessResolve(/* aIsSync = */ false,
+                                          aInitialPriority)) {
+          return LaunchPromise::CreateAndResolve(self, __func__);
+        }
+        self->LaunchSubprocessReject();
+        return LaunchPromise::CreateAndReject(NS_ERROR_FAILURE, __func__);
+      });
+}
+
+ContentParent::ContentParent(const nsACString& aRemoteType, int32_t aJSPluginID)
+    : mSubprocess(nullptr),
+      mLaunchTS(TimeStamp::Now()),
+      mLaunchYieldTS(mLaunchTS),
+      mActivateTS(mLaunchTS),
+      mIsAPreallocBlocker(false),
+      mRemoteType(aRemoteType),
+      mChildID(gContentChildID++),
+      mGeolocationWatchID(-1),
+      mJSPluginID(aJSPluginID),
+      mThreadsafeHandle(
+          new ThreadsafeContentParentHandle(this, mChildID, mRemoteType)),
+      mNumDestroyingTabs(0),
+      mNumKeepaliveCalls(0),
+      mLifecycleState(LifecycleState::LAUNCHING),
+      mIsForBrowser(!mRemoteType.IsEmpty()),
+      mCalledClose(false),
+      mCalledKillHard(false),
+      mCreatedPairedMinidumps(false),
+      mShutdownPending(false),
+      mLaunchResolved(false),
+      mLaunchResolvedOk(false),
+      mIsRemoteInputEventQueueEnabled(false),
+      mIsInputPriorityEventEnabled(false),
+      mIsInPool(false),
+      mGMPCreated(false),
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+      mBlockShutdownCalled(false),
+#endif
+      mHangMonitorActor(nullptr) {
+  MOZ_DIAGNOSTIC_ASSERT(!IsForJSPlugin(),
+                        "XXX(nika): How are we creating a JSPlugin?");
+
+  mRemoteTypeIsolationPrincipal =
+      CreateRemoteTypeIsolationPrincipal(aRemoteType);
+
+  // Insert ourselves into the global linked list of ContentParent objects.
+  if (!sContentParents) {
+    sContentParents = new LinkedList<ContentParent>();
+  }
+  sContentParents->insertBack(this);
+
+  mMessageManager = nsFrameMessageManager::NewProcessMessageManager(true);
+
+#if defined(XP_WIN)
+  // Request Windows message deferral behavior on our side of the PContent
+  // channel. Generally only applies to the situation where we get caught in
+  // a deadlock with the plugin process when sending CPOWs.
+  GetIPCChannel()->SetChannelFlags(
+      MessageChannel::REQUIRE_DEFERRED_MESSAGE_PROTECTION);
+#endif
+
+  NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
+  bool isFile = mRemoteType == FILE_REMOTE_TYPE;
+  mSubprocess = new GeckoChildProcessHost(GeckoProcessType_Content, isFile);
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Verbose,
+          ("CreateSubprocess: ContentParent %p mSubprocess %p handle %" PRIuPTR,
+           this, mSubprocess,
+           mSubprocess ? (uintptr_t)mSubprocess->GetChildProcessHandle() : -1));
+
+  // This is safe to do in the constructor, as it doesn't take a strong
+  // reference.
+  mScriptableHelper = new ScriptableCPInfo(this);
+}
+
+ContentParent::~ContentParent() {
+  if (mForceKillTimer) {
+    mForceKillTimer->Cancel();
+  }
+
+  AssertIsOnMainThread();
+
+  // Clear the weak reference from the threadsafe handle back to this actor.
+  mThreadsafeHandle->mWeakActor = nullptr;
+
+  if (mIsAPreallocBlocker) {
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+            ("Removing blocker on ContentProcess destruction"));
+    PreallocatedProcessManager::RemoveBlocker(mRemoteType, this);
+    mIsAPreallocBlocker = false;
+  }
+
+  // We should be removed from all these lists in ActorDestroy.
+  AssertNotInPool();
+
+  // Normally mSubprocess is destroyed in ActorDestroy, but that won't
+  // happen if the process wasn't launched or if it failed to launch.
+  if (mSubprocess) {
+    MOZ_LOG(
+        ContentParent::GetLog(), LogLevel::Verbose,
+        ("DestroySubprocess: ContentParent %p mSubprocess %p handle %" PRIuPTR,
+         this, mSubprocess,
+         mSubprocess ? (uintptr_t)mSubprocess->GetChildProcessHandle() : -1));
+    mSubprocess->Destroy();
+  }
+
+  // Make sure to clear the connection from `mScriptableHelper` if it hasn't
+  // been cleared yet.
+  if (mScriptableHelper) {
+    static_cast<ScriptableCPInfo*>(mScriptableHelper.get())->ProcessDied();
+    mScriptableHelper = nullptr;
+  }
+}
+
+bool ContentParent::InitInternal(ProcessPriority aInitialPriority) {
+  // We can't access the locale service after shutdown has started. Since we
+  // can't init the process without it, and since we're going to be canceling
+  // whatever load attempt that initiated this process creation anyway, just
+  // bail out now if shutdown has already started.
+  if (PastShutdownPhase(ShutdownPhase::XPCOMShutdown)) {
+    return false;
+  }
+
+  XPCOMInitData xpcomInit;
+
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+          ("ContentParent::InitInternal: %p", (void*)this));
+  nsCOMPtr<nsIIOService> io(do_GetIOService());
+  MOZ_ASSERT(io, "No IO service?");
+  DebugOnly<nsresult> rv = io->GetOffline(&xpcomInit.isOffline());
+  MOZ_ASSERT(NS_SUCCEEDED(rv), "Failed getting offline?");
+
+  rv = io->GetConnectivity(&xpcomInit.isConnected());
+  MOZ_ASSERT(NS_SUCCEEDED(rv), "Failed getting connectivity?");
+
+  xpcomInit.captivePortalState() = nsICaptivePortalService::UNKNOWN;
+  nsCOMPtr<nsICaptivePortalService> cps =
+      do_GetService(NS_CAPTIVEPORTAL_CONTRACTID);
+  if (cps) {
+    cps->GetState(&xpcomInit.captivePortalState());
+  }
+
+  if (StaticPrefs::fission_processProfileName()) {
+    nsCOMPtr<nsIToolkitProfileService> profileSvc =
+        do_GetService(NS_PROFILESERVICE_CONTRACTID);
+    if (profileSvc) {
+      nsCOMPtr<nsIToolkitProfile> currentProfile;
+      nsresult rv =
+          profileSvc->GetCurrentProfile(getter_AddRefs(currentProfile));
+      if (NS_SUCCEEDED(rv) && currentProfile) {
+        currentProfile->GetName(mProfile);
+      }
+    }
+  }
+
+  nsIBidiKeyboard* bidi = nsContentUtils::GetBidiKeyboard();
+
+  xpcomInit.isLangRTL() = false;
+  xpcomInit.haveBidiKeyboards() = false;
+  if (bidi) {
+    bidi->IsLangRTL(&xpcomInit.isLangRTL());
+    bidi->GetHaveBidiKeyboards(&xpcomInit.haveBidiKeyboards());
+  }
+
+  RefPtr<mozSpellChecker> spellChecker(mozSpellChecker::Create());
+  MOZ_ASSERT(spellChecker, "No spell checker?");
+
+  spellChecker->GetDictionaryList(&xpcomInit.dictionaries());
+
+  LocaleService::GetInstance()->GetAppLocalesAsBCP47(xpcomInit.appLocales());
+  LocaleService::GetInstance()->GetRequestedLocales(
+      xpcomInit.requestedLocales());
+
+  L10nRegistry::GetParentProcessFileSourceDescriptors(
+      xpcomInit.l10nFileSources());
+
+  nsCOMPtr<nsIClipboard> clipboard(
+      do_GetService("@mozilla.org/widget/clipboard;1"));
+  MOZ_ASSERT(clipboard, "No clipboard?");
+  MOZ_ASSERT(
+      clipboard->IsClipboardTypeSupported(nsIClipboard::kGlobalClipboard),
+      "We should always support the global clipboard.");
+
+  xpcomInit.clipboardCaps().supportsSelectionClipboard() =
+      clipboard->IsClipboardTypeSupported(nsIClipboard::kSelectionClipboard);
+
+  xpcomInit.clipboardCaps().supportsFindClipboard() =
+      clipboard->IsClipboardTypeSupported(nsIClipboard::kFindClipboard);
+
+  xpcomInit.clipboardCaps().supportsSelectionCache() =
+      clipboard->IsClipboardTypeSupported(nsIClipboard::kSelectionCache);
+
+  // Let's copy the domain policy from the parent to the child (if it's active).
+  StructuredCloneData initialData;
+  nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
+  if (ssm) {
+    ssm->CloneDomainPolicy(&xpcomInit.domainPolicy());
+
+    if (ParentProcessMessageManager* mm =
+            nsFrameMessageManager::sParentProcessManager) {
+      AutoJSAPI jsapi;
+      if (NS_WARN_IF(!jsapi.Init(xpc::PrivilegedJunkScope()))) {
+        MOZ_CRASH();
+      }
+      JS::Rooted<JS::Value> init(jsapi.cx());
+      // We'll crash on failure, so use a IgnoredErrorResult (which also
+      // auto-suppresses exceptions).
+      IgnoredErrorResult rv;
+      mm->GetInitialProcessData(jsapi.cx(), &init, rv);
+      if (NS_WARN_IF(rv.Failed())) {
+        MOZ_CRASH();
+      }
+
+      initialData.Write(jsapi.cx(), init, rv);
+      if (NS_WARN_IF(rv.Failed())) {
+        MOZ_CRASH();
+      }
+    }
+  }
+  // This is only implemented (returns a non-empty list) by MacOSX and Linux
+  // at present.
+  SystemFontList fontList;
+  gfxPlatform::GetPlatform()->ReadSystemFontList(&fontList);
+
+  const FullLookAndFeel& lnf = *RemoteLookAndFeel::ExtractData();
+
+  // If the shared fontlist is in use, collect its shmem block handles to pass
+  // to the child.
+  nsTArray<SharedMemoryHandle> sharedFontListBlocks;
+  gfxPlatformFontList::PlatformFontList()->ShareFontListToProcess(
+      &sharedFontListBlocks, OtherPid());
+
+  // Content processes have no permission to access profile directory, so we
+  // send the file URL instead.
+  auto* sheetCache = GlobalStyleSheetCache::Singleton();
+  if (StyleSheet* ucs = sheetCache->GetUserContentSheet()) {
+    xpcomInit.userContentSheetURL() = ucs->GetSheetURI();
+  } else {
+    xpcomInit.userContentSheetURL() = nullptr;
+  }
+
+  // 1. Build ContentDeviceData first, as it may affect some gfxVars.
+  gfxPlatform::GetPlatform()->BuildContentDeviceData(
+      &xpcomInit.contentDeviceData());
+  // 2. Gather non-default gfxVars.
+  xpcomInit.gfxNonDefaultVarUpdates() = gfxVars::FetchNonDefaultVars();
+  // 3. Start listening for gfxVars updates, to notify content process later on.
+  gfxVars::AddReceiver(this);
+
+  nsCOMPtr<nsIGfxInfo> gfxInfo = components::GfxInfo::Service();
+  if (gfxInfo) {
+    GfxInfoBase* gfxInfoRaw = static_cast<GfxInfoBase*>(gfxInfo.get());
+    xpcomInit.gfxFeatureStatus() = gfxInfoRaw->GetAllFeatures();
+  }
+
+  // Send the dynamic scalar definitions to the new process.
+  TelemetryIPC::GetDynamicScalarDefinitions(xpcomInit.dynamicScalarDefs());
+
+  for (auto const& [location, supported] : sCodecsSupported) {
+    Unused << SendUpdateMediaCodecsSupported(location, supported);
+  }
+
+#ifdef MOZ_WIDGET_ANDROID
+  if (!(StaticPrefs::media_utility_process_enabled() &&
+        StaticPrefs::media_utility_android_media_codec_enabled())) {
+    Unused << SendDecoderSupportedMimeTypes(
+        AndroidDecoderModule::GetSupportedMimeTypes());
+  }
+#endif
+
+  // Must send screen info before send initialData
+  ScreenManager& screenManager = ScreenManager::GetSingleton();
+  screenManager.CopyScreensToRemote(this);
+
+  // Send the UA sheet shared memory buffer and the address it is mapped at.
+  Maybe<SharedMemoryHandle> sharedUASheetHandle;
+  uintptr_t sharedUASheetAddress = sheetCache->GetSharedMemoryAddress();
+
+  if (SharedMemoryHandle handle = sheetCache->CloneHandle()) {
+    sharedUASheetHandle.emplace(std::move(handle));
+  } else {
+    sharedUASheetAddress = 0;
+  }
+
+  bool isReadyForBackgroundProcessing = false;
+#if defined(XP_WIN)
+  RefPtr<DllServices> dllSvc(DllServices::Get());
+  isReadyForBackgroundProcessing = dllSvc->IsReadyForBackgroundProcessing();
+#endif
+
+  xpcomInit.perfStatsMask() = PerfStats::GetCollectionMask();
+
+  nsCOMPtr<nsIDNSService> dns = do_GetService(NS_DNSSERVICE_CONTRACTID);
+  dns->GetTrrDomain(xpcomInit.trrDomain());
+
+  nsIDNSService::ResolverMode mode;
+  dns->GetCurrentTrrMode(&mode);
+  xpcomInit.trrMode() = mode;
+  xpcomInit.trrModeFromPref() =
+      static_cast<nsIDNSService::ResolverMode>(StaticPrefs::network_trr_mode());
+
+  Unused << SendSetXPCOMProcessAttributes(
+      xpcomInit, initialData, lnf, fontList, std::move(sharedUASheetHandle),
+      sharedUASheetAddress, std::move(sharedFontListBlocks),
+      isReadyForBackgroundProcessing);
+
+  ipc::WritableSharedMap* sharedData =
+      nsFrameMessageManager::sParentProcessManager->SharedData();
+  sharedData->Flush();
+  sharedData->SendTo(this);
+
+  nsCOMPtr<nsIChromeRegistry> registrySvc = nsChromeRegistry::GetService();
+  nsChromeRegistryChrome* chromeRegistry =
+      static_cast<nsChromeRegistryChrome*>(registrySvc.get());
+  chromeRegistry->SendRegisteredChrome(this);
+
+  nsCOMPtr<nsIStringBundleService> stringBundleService =
+      components::StringBundle::Service();
+  stringBundleService->SendContentBundles(this);
+
+  if (gAppData) {
+    nsCString version(gAppData->version);
+    nsCString buildID(gAppData->buildID);
+    nsCString name(gAppData->name);
+    nsCString UAName(gAppData->UAName);
+    nsCString ID(gAppData->ID);
+    nsCString vendor(gAppData->vendor);
+    nsCString sourceURL(gAppData->sourceURL);
+    nsCString updateURL(gAppData->updateURL);
+
+    // Sending all information to content process.
+    Unused << SendAppInfo(version, buildID, name, UAName, ID, vendor, sourceURL,
+                          updateURL);
+  }
+
+  // Send the child its remote type. On Mac, this needs to be sent prior
+  // to the message we send to enable the Sandbox (SendStartProcessSandbox)
+  // because different remote types require different sandbox privileges.
+
+  Unused << SendRemoteType(mRemoteType, mProfile);
+
+  ScriptPreloader::InitContentChild(*this);
+
+  // Initialize the message manager (and load delayed scripts) now that we
+  // have established communications with the child.
+  mMessageManager->InitWithCallback(this);
+  mMessageManager->SetOsPid(Pid());
+
+  // Set the subprocess's priority.  We do this early on because we're likely
+  // /lowering/ the process's CPU and memory priority, which it has inherited
+  // from this process.
+  //
+  // This call can cause us to send IPC messages to the child process, so it
+  // must come after the Open() call above.
+  ProcessPriorityManager::SetProcessPriority(this, aInitialPriority);
+
+  // NB: internally, this will send an IPC message to the child
+  // process to get it to create the CompositorBridgeChild.  This
+  // message goes through the regular IPC queue for this
+  // channel, so delivery will happen-before any other messages
+  // we send.  The CompositorBridgeChild must be created before any
+  // PBrowsers are created, because they rely on the Compositor
+  // already being around.  (Creation is async, so can't happen
+  // on demand.)
+  GPUProcessManager* gpm = GPUProcessManager::Get();
+
+  Endpoint<PCompositorManagerChild> compositor;
+  Endpoint<PImageBridgeChild> imageBridge;
+  Endpoint<PVRManagerChild> vrBridge;
+  Endpoint<PRemoteDecoderManagerChild> videoManager;
+  AutoTArray<uint32_t, 3> namespaces;
+
+  if (!gpm->CreateContentBridges(OtherPid(), &compositor, &imageBridge,
+                                 &vrBridge, &videoManager, mChildID,
+                                 &namespaces)) {
+    // This can fail if we've already started shutting down the compositor
+    // thread. See Bug 1562763 comment 8.
+    MOZ_ASSERT(AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdown));
+    return false;
+  }
+
+  Unused << SendInitRendering(std::move(compositor), std::move(imageBridge),
+                              std::move(vrBridge), std::move(videoManager),
+                              namespaces);
+
+  gpm->AddListener(this);
+
+  nsStyleSheetService* sheetService = nsStyleSheetService::GetInstance();
+  if (sheetService) {
+    // This looks like a lot of work, but in a normal browser session we just
+    // send two loads.
+    //
+    // The URIs of the Gecko and Servo sheets should be the same, so it
+    // shouldn't matter which we look at.
+
+    for (StyleSheet* sheet : *sheetService->AgentStyleSheets()) {
+      Unused << SendLoadAndRegisterSheet(sheet->GetSheetURI(),
+                                         nsIStyleSheetService::AGENT_SHEET);
+    }
+
+    for (StyleSheet* sheet : *sheetService->UserStyleSheets()) {
+      Unused << SendLoadAndRegisterSheet(sheet->GetSheetURI(),
+                                         nsIStyleSheetService::USER_SHEET);
+    }
+
+    for (StyleSheet* sheet : *sheetService->AuthorStyleSheets()) {
+      Unused << SendLoadAndRegisterSheet(sheet->GetSheetURI(),
+                                         nsIStyleSheetService::AUTHOR_SHEET);
+    }
+  }
+
+#ifdef MOZ_SANDBOX
+  bool shouldSandbox = true;
+  Maybe<FileDescriptor> brokerFd;
+  // XXX: Checking the pref here makes it possible to enable/disable sandboxing
+  // during an active session. Currently the pref is only used for testing
+  // purpose. If the decision is made to permanently rely on the pref, this
+  // should be changed so that it is required to restart firefox for the change
+  // of value to take effect. Always send SetProcessSandbox message on macOS.
+#  if !defined(XP_MACOSX)
+  shouldSandbox = IsContentSandboxEnabled();
+#  endif
+
+#  ifdef XP_LINUX
+  if (shouldSandbox) {
+    MOZ_ASSERT(!mSandboxBroker);
+    bool isFileProcess = mRemoteType == FILE_REMOTE_TYPE;
+    UniquePtr<SandboxBroker::Policy> policy =
+        sSandboxBrokerPolicyFactory->GetContentPolicy(Pid(), isFileProcess);
+    if (policy) {
+      brokerFd = Some(FileDescriptor());
+      mSandboxBroker =
+          SandboxBroker::Create(std::move(policy), Pid(), brokerFd.ref());
+      if (!mSandboxBroker) {
+        KillHard("SandboxBroker::Create failed");
+        return false;
+      }
+      MOZ_ASSERT(brokerFd.ref().IsValid());
+    }
+  }
+#  endif
+  if (shouldSandbox && !SendSetProcessSandbox(brokerFd)) {
+    KillHard("SandboxInitFailed");
+  }
+#endif
+
+  // Ensure that the default set of permissions are avaliable in the content
+  // process before we try to load any URIs in it.
+  //
+  // NOTE: All default permissions has to be transmitted to the child process
+  // before the blob urls in the for loop below (See Bug 1738713 comment 12).
+  EnsurePermissionsByKey(""_ns, ""_ns);
+
+  {
+    nsTArray<BlobURLRegistrationData> registrations;
+    BlobURLProtocolHandler::ForEachBlobURL(
+        [&](BlobImpl* aBlobImpl, nsIPrincipal* aPrincipal,
+            const Maybe<nsID>& aAgentClusterId, const nsACString& aURI,
+            bool aRevoked) {
+          // We send all moz-extension Blob URL's to all content processes
+          // because content scripts mean that a moz-extension can live in any
+          // process. Same thing for system principal Blob URLs. Content Blob
+          // URL's are sent for content principals on-demand by
+          // AboutToLoadHttpFtpDocumentForChild and RemoteWorkerManager.
+          if (!BlobURLProtocolHandler::IsBlobURLBroadcastPrincipal(
+                  aPrincipal)) {
+            return true;
+          }
+
+          IPCBlob ipcBlob;
+          nsresult rv = IPCBlobUtils::Serialize(aBlobImpl, ipcBlob);
+          if (NS_WARN_IF(NS_FAILED(rv))) {
+            return false;
+          }
+
+          registrations.AppendElement(BlobURLRegistrationData(
+              nsCString(aURI), ipcBlob, aPrincipal, aAgentClusterId, aRevoked));
+
+          rv = TransmitPermissionsForPrincipal(aPrincipal);
+          Unused << NS_WARN_IF(NS_FAILED(rv));
+          return true;
+        });
+
+    if (!registrations.IsEmpty()) {
+      Unused << SendInitBlobURLs(registrations);
+    }
+  }
+
+  // Send down { Parent, Window }ActorOptions at startup to content process.
+  RefPtr<JSActorService> actorSvc = JSActorService::GetSingleton();
+  if (actorSvc) {
+    nsTArray<JSProcessActorInfo> contentInfos;
+    actorSvc->GetJSProcessActorInfos(contentInfos);
+
+    nsTArray<JSWindowActorInfo> windowInfos;
+    actorSvc->GetJSWindowActorInfos(windowInfos);
+
+    Unused << SendInitJSActorInfos(contentInfos, windowInfos);
+  }
+
+  // Begin subscribing to any BrowsingContextGroups which were hosted by this
+  // process before it finished launching.
+  for (const auto& group : mGroups) {
+    group->Subscribe(this);
+  }
+
+  MaybeEnableRemoteInputEventQueue();
+
+  return true;
+}
+
+bool ContentParent::IsAlive() const {
+  return mLifecycleState == LifecycleState::ALIVE ||
+         mLifecycleState == LifecycleState::INITIALIZED;
+}
+
+bool ContentParent::IsInitialized() const {
+  return mLifecycleState == LifecycleState::INITIALIZED;
+}
+
+int32_t ContentParent::Pid() const {
+  if (!mSubprocess) {
+    return -1;
+  }
+  auto pid = mSubprocess->GetChildProcessId();
+  if (pid == 0) {
+    return -1;
+  }
+  return ReleaseAssertedCast<int32_t>(pid);
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvGetGfxVars(
+    nsTArray<GfxVarUpdate>* aVars) {
+  // Ensure gfxVars is initialized (for xpcshell tests).
+  gfxVars::Initialize();
+
+  *aVars = gfxVars::FetchNonDefaultVars();
+
+  // Now that content has initialized gfxVars, we can start listening for
+  // updates.
+  gfxVars::AddReceiver(this);
+  return IPC_OK();
+}
+
+void ContentParent::OnCompositorUnexpectedShutdown() {
+  GPUProcessManager* gpm = GPUProcessManager::Get();
+
+  Endpoint<PCompositorManagerChild> compositor;
+  Endpoint<PImageBridgeChild> imageBridge;
+  Endpoint<PVRManagerChild> vrBridge;
+  Endpoint<PRemoteDecoderManagerChild> videoManager;
+  AutoTArray<uint32_t, 3> namespaces;
+
+  if (!gpm->CreateContentBridges(OtherPid(), &compositor, &imageBridge,
+                                 &vrBridge, &videoManager, mChildID,
+                                 &namespaces)) {
+    MOZ_ASSERT(AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdown));
+    return;
+  }
+
+  Unused << SendReinitRendering(std::move(compositor), std::move(imageBridge),
+                                std::move(vrBridge), std::move(videoManager),
+                                namespaces);
+}
+
+void ContentParent::OnCompositorDeviceReset() {
+  Unused << SendReinitRenderingForDeviceReset();
+}
+
+void ContentParent::MaybeEnableRemoteInputEventQueue() {
+  MOZ_ASSERT(!mIsRemoteInputEventQueueEnabled);
+  if (!IsInputEventQueueSupported()) {
+    return;
+  }
+  mIsRemoteInputEventQueueEnabled = true;
+  Unused << SendSetInputEventQueueEnabled();
+  SetInputPriorityEventEnabled(true);
+}
+
+void ContentParent::SetInputPriorityEventEnabled(bool aEnabled) {
+  if (!IsInputEventQueueSupported() || !mIsRemoteInputEventQueueEnabled ||
+      mIsInputPriorityEventEnabled == aEnabled) {
+    return;
+  }
+  mIsInputPriorityEventEnabled = aEnabled;
+  // Send IPC messages to flush the pending events in the input event queue and
+  // the normal event queue. See PContent.ipdl for more details.
+  Unused << SendSuspendInputEventQueue();
+  Unused << SendFlushInputEventQueue();
+  Unused << SendResumeInputEventQueue();
+}
+
+/*static*/
+bool ContentParent::IsInputEventQueueSupported() {
+  static bool sSupported = false;
+  static bool sInitialized = false;
+  if (!sInitialized) {
+    MOZ_ASSERT(Preferences::IsServiceAvailable());
+    sSupported = Preferences::GetBool("input_event_queue.supported", false);
+    sInitialized = true;
+  }
+  return sSupported;
+}
+
+void ContentParent::OnVarChanged(const GfxVarUpdate& aVar) {
+  if (!CanSend()) {
+    return;
+  }
+  Unused << SendVarUpdate(aVar);
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSetClipboard(
+    const IPCTransferable& aTransferable, const int32_t& aWhichClipboard) {
+  // aRequestingPrincipal is allowed to be nullptr here.
+
+  if (!ValidatePrincipal(aTransferable.requestingPrincipal(),
+                         {ValidatePrincipalOptions::AllowNullPtr})) {
+    LogAndAssertFailedPrincipalValidationInfo(
+        aTransferable.requestingPrincipal(), __func__);
+  }
+
+  nsresult rv;
+  nsCOMPtr<nsIClipboard> clipboard(do_GetService(kCClipboardCID, &rv));
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+
+  nsCOMPtr<nsITransferable> trans =
+      do_CreateInstance("@mozilla.org/widget/transferable;1", &rv);
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+  trans->Init(nullptr);
+
+  rv = nsContentUtils::IPCTransferableToTransferable(
+      aTransferable, true /* aAddDataFlavor */, trans,
+      true /* aFilterUnknownFlavors */);
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+
+  clipboard->SetData(trans, nullptr, aWhichClipboard);
+  return IPC_OK();
+}
+
+namespace {
+
+static Result<nsCOMPtr<nsITransferable>, nsresult> CreateTransferable(
+    const nsTArray<nsCString>& aTypes) {
+  nsresult rv;
+  nsCOMPtr<nsITransferable> trans =
+      do_CreateInstance("@mozilla.org/widget/transferable;1", &rv);
+  if (NS_FAILED(rv)) {
+    return Err(rv);
+  }
+
+  MOZ_TRY(trans->Init(nullptr));
+  // The private flag is only used to prevent the data from being cached to the
+  // disk. The flag is not exported to the IPCDataTransfer object.
+  // The flag is set because we are not sure whether the clipboard data is used
+  // in a private browsing context. The transferable is only used in this scope,
+  // so the cache would not reduce memory consumption anyway.
+  trans->SetIsPrivateData(true);
+  // Fill out flavors for transferable
+  for (uint32_t t = 0; t < aTypes.Length(); t++) {
+    MOZ_TRY(trans->AddDataFlavor(aTypes[t].get()));
+  }
+
+  return std::move(trans);
+}
+
+}  // anonymous namespace
+
+mozilla::ipc::IPCResult ContentParent::RecvGetClipboard(
+    nsTArray<nsCString>&& aTypes, const int32_t& aWhichClipboard,
+    IPCTransferableData* aTransferableData) {
+  nsresult rv;
+  // Retrieve clipboard
+  nsCOMPtr<nsIClipboard> clipboard(do_GetService(kCClipboardCID, &rv));
+  if (NS_FAILED(rv)) {
+    return IPC_OK();
+  }
+
+  // Create transferable
+  auto result = CreateTransferable(aTypes);
+  if (result.isErr()) {
+    return IPC_OK();
+  }
+
+  // Get data from clipboard
+  nsCOMPtr<nsITransferable> trans = result.unwrap();
+  clipboard->GetData(trans, aWhichClipboard);
+
+  nsContentUtils::TransferableToIPCTransferableData(
+      trans, aTransferableData, true /* aInSyncMessage */, this);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvEmptyClipboard(
+    const int32_t& aWhichClipboard) {
+  nsresult rv;
+  nsCOMPtr<nsIClipboard> clipboard(do_GetService(kCClipboardCID, &rv));
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+
+  clipboard->EmptyClipboard(aWhichClipboard);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvClipboardHasType(
+    nsTArray<nsCString>&& aTypes, const int32_t& aWhichClipboard,
+    bool* aHasType) {
+  nsresult rv;
+  nsCOMPtr<nsIClipboard> clipboard(do_GetService(kCClipboardCID, &rv));
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+
+  clipboard->HasDataMatchingFlavors(aTypes, aWhichClipboard, aHasType);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvClipboardHasTypesAsync(
+    nsTArray<nsCString>&& aTypes, const int32_t& aWhichClipboard,
+    ClipboardHasTypesAsyncResolver&& aResolver) {
+  nsresult rv;
+  nsCOMPtr<nsIClipboard> clipboard(do_GetService(kCClipboardCID, &rv));
+  if (NS_FAILED(rv)) {
+    return IPC_FAIL(this, "RecvGetClipboardTypes failed.");
+  }
+
+  clipboard->AsyncHasDataMatchingFlavors(aTypes, aWhichClipboard)
+      ->Then(
+          GetMainThreadSerialEventTarget(), __func__,
+          /* resolve */
+          [aResolver](nsTArray<nsCString> types) { aResolver(types); },
+          /* reject */
+          [aResolver](nsresult rv) { aResolver(nsTArray<nsCString>{}); });
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvGetExternalClipboardFormats(
+    const int32_t& aWhichClipboard, const bool& aPlainTextOnly,
+    nsTArray<nsCString>* aTypes) {
+  MOZ_ASSERT(aTypes);
+  DataTransfer::GetExternalClipboardFormats(aWhichClipboard, aPlainTextOnly,
+                                            aTypes);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvGetClipboardAsync(
+    nsTArray<nsCString>&& aTypes, const int32_t& aWhichClipboard,
+    GetClipboardAsyncResolver&& aResolver) {
+  nsresult rv;
+  // Retrieve clipboard
+  nsCOMPtr<nsIClipboard> clipboard(do_GetService(kCClipboardCID, &rv));
+  if (NS_FAILED(rv)) {
+    aResolver(rv);
+    return IPC_OK();
+  }
+
+  // Create transferable
+  auto result = CreateTransferable(aTypes);
+  if (result.isErr()) {
+    aResolver(result.unwrapErr());
+    return IPC_OK();
+  }
+
+  // Get data from clipboard
+  nsCOMPtr<nsITransferable> trans = result.unwrap();
+  clipboard->AsyncGetData(trans, nsIClipboard::kGlobalClipboard)
+      ->Then(
+          GetMainThreadSerialEventTarget(), __func__,
+          [trans, aResolver,
+           self = RefPtr{this}](GenericPromise::ResolveOrRejectValue&& aValue) {
+            IPCTransferableData ipcTransferableData;
+            nsContentUtils::TransferableToIPCTransferableData(
+                trans, &ipcTransferableData, false /* aInSyncMessage */, self);
+            aResolver(std::move(ipcTransferableData));
+          });
+  return IPC_OK();
+}
+
+already_AddRefed<PClipboardWriteRequestParent>
+ContentParent::AllocPClipboardWriteRequestParent(
+    const int32_t& aClipboardType) {
+  RefPtr<ClipboardWriteRequestParent> request =
+      MakeAndAddRef<ClipboardWriteRequestParent>(this);
+  request->Init(aClipboardType);
+  return request.forget();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvPlaySound(nsIURI* aURI) {
+  // If the check here fails, it can only mean that this message was spoofed.
+  if (!aURI || !aURI->SchemeIs("chrome")) {
+    // PlaySound only accepts a valid chrome URI.
+    return IPC_FAIL(this, "Invalid aURI passed.");
+  }
+  nsCOMPtr<nsIURL> soundURL(do_QueryInterface(aURI));
+  if (!soundURL) {
+    return IPC_OK();
+  }
+
+  nsresult rv;
+  nsCOMPtr<nsISound> sound(do_GetService(NS_SOUND_CID, &rv));
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+
+  sound->Play(soundURL);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvBeep() {
+  nsresult rv;
+  nsCOMPtr<nsISound> sound(do_GetService(NS_SOUND_CID, &rv));
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+
+  sound->Beep();
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvPlayEventSound(
+    const uint32_t& aEventId) {
+  nsresult rv;
+  nsCOMPtr<nsISound> sound(do_GetService(NS_SOUND_CID, &rv));
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+
+  sound->PlayEventSound(aEventId);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvGetIconForExtension(
+    const nsACString& aFileExt, const uint32_t& aIconSize,
+    nsTArray<uint8_t>* bits) {
+#ifdef MOZ_WIDGET_ANDROID
+  NS_ASSERTION(AndroidBridge::Bridge() != nullptr,
+               "AndroidBridge is not available");
+  if (AndroidBridge::Bridge() == nullptr) {
+    // Do not fail - just no icon will be shown
+    return IPC_OK();
+  }
+
+  bits->AppendElements(aIconSize * aIconSize * 4);
+
+  AndroidBridge::Bridge()->GetIconForExtension(aFileExt, aIconSize,
+                                               bits->Elements());
+#endif
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvFirstIdle() {
+  // When the ContentChild goes idle, it sends us a FirstIdle message
+  // which we use as a good time to signal the PreallocatedProcessManager
+  // that it can start allocating processes from now on.
+  if (mIsAPreallocBlocker) {
+    MOZ_LOG(
+        ContentParent::GetLog(), LogLevel::Verbose,
+        ("RecvFirstIdle %p: Removing Blocker for %s", this, mRemoteType.get()));
+    PreallocatedProcessManager::RemoveBlocker(mRemoteType, this);
+    mIsAPreallocBlocker = false;
+  }
+  return IPC_OK();
+}
+
+already_AddRefed<nsDocShellLoadState> ContentParent::TakePendingLoadStateForId(
+    uint64_t aLoadIdentifier) {
+  return mPendingLoadStates.Extract(aLoadIdentifier).valueOr(nullptr).forget();
+}
+
+void ContentParent::StorePendingLoadState(nsDocShellLoadState* aLoadState) {
+  MOZ_DIAGNOSTIC_ASSERT(
+      !mPendingLoadStates.Contains(aLoadState->GetLoadIdentifier()),
+      "The same nsDocShellLoadState was sent to the same content process "
+      "twice? This will mess with cross-process tracking of loads");
+  mPendingLoadStates.InsertOrUpdate(aLoadState->GetLoadIdentifier(),
+                                    aLoadState);
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvCleanupPendingLoadState(
+    uint64_t aLoadIdentifier) {
+  mPendingLoadStates.Remove(aLoadIdentifier);
+  return IPC_OK();
+}
+
+// We want ContentParent to show up in CC logs for debugging purposes, but we
+// don't actually cycle collect it.
+NS_IMPL_CYCLE_COLLECTION_0(ContentParent)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(ContentParent)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(ContentParent)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ContentParent)
+  NS_INTERFACE_MAP_ENTRY_CONCRETE(ContentParent)
+  NS_INTERFACE_MAP_ENTRY(nsIDOMProcessParent)
+  NS_INTERFACE_MAP_ENTRY(nsIObserver)
+  NS_INTERFACE_MAP_ENTRY(nsIDOMGeoPositionCallback)
+  NS_INTERFACE_MAP_ENTRY(nsIDOMGeoPositionErrorCallback)
+  NS_INTERFACE_MAP_ENTRY(nsIAsyncShutdownBlocker)
+  NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMProcessParent)
+NS_INTERFACE_MAP_END
+
+class RequestContentJSInterruptRunnable final : public Runnable {
+ public:
+  explicit RequestContentJSInterruptRunnable(PProcessHangMonitorParent* aActor)
+      : Runnable("dom::RequestContentJSInterruptRunnable"),
+        mHangMonitorActor(aActor) {}
+
+  NS_IMETHOD Run() override {
+    MOZ_ASSERT(mHangMonitorActor);
+    Unused << mHangMonitorActor->SendRequestContentJSInterrupt();
+
+    return NS_OK;
+  }
+
+ private:
+  // The end-of-life of ContentParent::mHangMonitorActor is bound to
+  // ContentParent::ActorDestroy and then HangMonitorParent::Shutdown
+  // dispatches a shutdown runnable to this queue and waits for it to be
+  // executed. So the runnable needs not to care about keeping it alive,
+  // as it is surely dispatched earlier than the
+  // HangMonitorParent::ShutdownOnThread.
+  RefPtr<PProcessHangMonitorParent> mHangMonitorActor;
+};
+
+void ContentParent::SignalImpendingShutdownToContentJS() {
+  if (!mIsSignaledImpendingShutdown &&
+      !AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdown)) {
+    MaybeLogBlockShutdownDiagnostics(
+        this, "BlockShutdown: NotifyImpendingShutdown.", __FILE__, __LINE__);
+    NotifyImpendingShutdown();
+    mIsSignaledImpendingShutdown = true;
+    if (mHangMonitorActor &&
+        StaticPrefs::dom_abort_script_on_child_shutdown()) {
+      MaybeLogBlockShutdownDiagnostics(
+          this, "BlockShutdown: RequestContentJSInterrupt.", __FILE__,
+          __LINE__);
+      RefPtr<RequestContentJSInterruptRunnable> r =
+          new RequestContentJSInterruptRunnable(mHangMonitorActor);
+      ProcessHangMonitor::Get()->Dispatch(r.forget());
+    }
+  }
+}
+
+// Async shutdown blocker
+NS_IMETHODIMP
+ContentParent::BlockShutdown(nsIAsyncShutdownClient* aClient) {
+  if (!AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdown)) {
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+    mBlockShutdownCalled = true;
+#endif
+    // Our real shutdown has not yet started. Just notify the impending
+    // shutdown and eventually cancel content JS.
+    SignalImpendingShutdownToContentJS();
+    // This will make our process unusable for normal content, so we need to
+    // ensure we won't get re-used by GetUsedBrowserProcess as we have not yet
+    // done MarkAsDead.
+    PreallocatedProcessManager::Erase(this);
+    StopRecyclingE10SOnly(false);
+
+    if (sQuitApplicationGrantedClient) {
+      Unused << sQuitApplicationGrantedClient->RemoveBlocker(this);
+    }
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+    mBlockShutdownCalled = false;
+#endif
+    return NS_OK;
+  }
+
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+  // We register two final shutdown blockers and both would call us, but if
+  // things go well we will unregister both as (delayed) reaction to the first
+  // call we get and thus never receive a second call. Thus we believe that we
+  // will get called only once except for quit-application-granted, which is
+  // handled above.
+  MOZ_ASSERT(!mBlockShutdownCalled);
+  mBlockShutdownCalled = true;
+#endif
+
+  if (CanSend()) {
+    MaybeLogBlockShutdownDiagnostics(this, "BlockShutdown: CanSend.", __FILE__,
+                                     __LINE__);
+
+    // Make sure that our process will get scheduled.
+    ProcessPriorityManager::SetProcessPriority(this,
+                                               PROCESS_PRIORITY_FOREGROUND);
+    // The normal shutdown sequence is to send a shutdown message
+    // to the child and then just wait for ActorDestroy which will
+    // cleanup everything and remove our blockers.
+    if (!ShutDownProcess(SEND_SHUTDOWN_MESSAGE)) {
+      KillHard("Failed to send Shutdown message. Destroying the process...");
+      return NS_OK;
+    }
+  } else if (IsLaunching()) {
+    MaybeLogBlockShutdownDiagnostics(
+        this, "BlockShutdown: !CanSend && IsLaunching.", __FILE__, __LINE__);
+
+    // If we get here while we are launching, we must wait for the child to
+    // be able to react on our commands. Mark this process as dead. This
+    // will make bail out LaunchSubprocessResolve and kick off the normal
+    // shutdown sequence.
+    MarkAsDead();
+  } else {
+    MOZ_ASSERT(IsDead());
+    if (!IsDead()) {
+      MaybeLogBlockShutdownDiagnostics(
+          this, "BlockShutdown: !!! !CanSend && !IsLaunching && !IsDead !!!",
+          __FILE__, __LINE__);
+    } else {
+      MaybeLogBlockShutdownDiagnostics(
+          this, "BlockShutdown: !CanSend && !IsLaunching && IsDead.", __FILE__,
+          __LINE__);
+    }
+    // Nothing left we can do. We must assume that we race with an ongoing
+    // process shutdown, such that we can expect our shutdown blockers to be
+    // removed normally.
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ContentParent::GetName(nsAString& aName) {
+  aName.AssignLiteral("ContentParent:");
+  aName.AppendPrintf(" id=%p", this);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ContentParent::GetState(nsIPropertyBag** aResult) {
+  auto props = MakeRefPtr<nsHashPropertyBag>();
+  props->SetPropertyAsACString(u"remoteTypePrefix"_ns,
+                               RemoteTypePrefix(mRemoteType));
+  *aResult = props.forget().downcast<nsIWritablePropertyBag>().take();
+  return NS_OK;
+}
+
+static void InitShutdownClients() {
+  if (!sXPCOMShutdownClient) {
+    nsresult rv;
+    nsCOMPtr<nsIAsyncShutdownService> svc = services::GetAsyncShutdownService();
+    if (!svc) {
+      return;
+    }
+
+    nsCOMPtr<nsIAsyncShutdownClient> client;
+    // TODO: It seems as if getPhase from AsyncShutdown.sys.mjs does not check
+    // if we are beyond our phase already. See bug 1762840.
+    if (!AppShutdown::IsInOrBeyond(ShutdownPhase::XPCOMWillShutdown)) {
+      rv = svc->GetXpcomWillShutdown(getter_AddRefs(client));
+      if (NS_SUCCEEDED(rv)) {
+        sXPCOMShutdownClient = client.forget();
+        ClearOnShutdown(&sXPCOMShutdownClient);
+      }
+    }
+    if (!AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdown)) {
+      rv = svc->GetProfileBeforeChange(getter_AddRefs(client));
+      if (NS_SUCCEEDED(rv)) {
+        sProfileBeforeChangeClient = client.forget();
+        ClearOnShutdown(&sProfileBeforeChangeClient);
+      }
+    }
+    // TODO: ShutdownPhase::AppShutdownConfirmed is not mapping to
+    // QuitApplicationGranted, see bug 1762840 comment 4.
+    if (!AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
+      rv = svc->GetQuitApplicationGranted(getter_AddRefs(client));
+      if (NS_SUCCEEDED(rv)) {
+        sQuitApplicationGrantedClient = client.forget();
+        ClearOnShutdown(&sQuitApplicationGrantedClient);
+      }
+    }
+  }
+}
+
+void ContentParent::AddShutdownBlockers() {
+  InitShutdownClients();
+  MOZ_ASSERT(sXPCOMShutdownClient);
+  MOZ_ASSERT(sProfileBeforeChangeClient);
+
+  if (sXPCOMShutdownClient) {
+    sXPCOMShutdownClient->AddBlocker(
+        this, NS_LITERAL_STRING_FROM_CSTRING(__FILE__), __LINE__, u""_ns);
+  }
+  if (sProfileBeforeChangeClient) {
+    sProfileBeforeChangeClient->AddBlocker(
+        this, NS_LITERAL_STRING_FROM_CSTRING(__FILE__), __LINE__, u""_ns);
+  }
+  if (sQuitApplicationGrantedClient) {
+    sQuitApplicationGrantedClient->AddBlocker(
+        this, NS_LITERAL_STRING_FROM_CSTRING(__FILE__), __LINE__, u""_ns);
+  }
+}
+
+void ContentParent::RemoveShutdownBlockers() {
+  MOZ_ASSERT(sXPCOMShutdownClient);
+  MOZ_ASSERT(sProfileBeforeChangeClient);
+
+  MaybeLogBlockShutdownDiagnostics(this, "RemoveShutdownBlockers", __FILE__,
+                                   __LINE__);
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+  mBlockShutdownCalled = false;
+#endif
+
+  if (sXPCOMShutdownClient) {
+    Unused << sXPCOMShutdownClient->RemoveBlocker(this);
+  }
+  if (sProfileBeforeChangeClient) {
+    Unused << sProfileBeforeChangeClient->RemoveBlocker(this);
+  }
+  if (sQuitApplicationGrantedClient) {
+    Unused << sQuitApplicationGrantedClient->RemoveBlocker(this);
+  }
+}
+
+NS_IMETHODIMP
+ContentParent::Observe(nsISupports* aSubject, const char* aTopic,
+                       const char16_t* aData) {
+  if (IsDead() || !mSubprocess) {
+    return NS_OK;
+  }
+
+  if (!strcmp(aTopic, "nsPref:changed")) {
+    // We know prefs are ASCII here.
+    NS_LossyConvertUTF16toASCII strData(aData);
+
+    Pref pref(strData, /* isLocked */ false,
+              /* isSanitized */ false, Nothing(), Nothing());
+
+    Preferences::GetPreference(&pref, GeckoProcessType_Content,
+                               GetRemoteType());
+
+    // This check is a bit of a hack.  We want to avoid sending excessive
+    // preference updates to subprocesses for performance reasons, but we
+    // currently don't have a great mechanism for doing so. (See Bug 1819714)
+    // We're going to hijack the sanitization mechanism to accomplish our goal
+    // but it imposes the following complications:
+    // 1) It doesn't avoid sending anything to other (non-web-content)
+    //    subprocesses so we're not getting any perf gains there
+    // 2) It confuses the subprocesses w.r.t. sanitization.  The point of
+    //    sending a preference update of a sanitized preference is so that
+    //    content process knows when it's asked to resolve a sanitized
+    //    preference, and it can send telemetry and/or crash.  With this
+    //    change, a sanitized pref that is created during the browser session
+    //    will not be sent to the content process, and therefore the content
+    //    process won't know it should telemetry/crash on access - it'll just
+    //    silently fail to resolve it.  After browser restart, the sanitized
+    //    pref will be populated into the content process via the shared pref
+    //    map and _then_ if it is accessed, the content process will crash.
+    //    We're seeing good telemetry/crash rates right now, so we're okay with
+    //    this limitation.
+    if (pref.isSanitized()) {
+      return NS_OK;
+    }
+
+    if (IsInitialized()) {
+      MOZ_ASSERT(mQueuedPrefs.IsEmpty());
+      if (!SendPreferenceUpdate(pref)) {
+        return NS_ERROR_NOT_AVAILABLE;
+      }
+    } else {
+      MOZ_ASSERT(!IsDead());
+      mQueuedPrefs.AppendElement(pref);
+    }
+
+    return NS_OK;
+  }
+
+  if (!IsAlive()) {
+    return NS_OK;
+  }
+
+  // listening for memory pressure event
+  if (!strcmp(aTopic, "memory-pressure")) {
+    Unused << SendFlushMemory(nsDependentString(aData));
+  } else if (!strcmp(aTopic, "application-background")) {
+    Unused << SendApplicationBackground();
+  } else if (!strcmp(aTopic, "application-foreground")) {
+    Unused << SendApplicationForeground();
+  } else if (!strcmp(aTopic, NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC)) {
+    NS_ConvertUTF16toUTF8 dataStr(aData);
+    const char* offline = dataStr.get();
+    if (!SendSetOffline(!strcmp(offline, "true"))) {
+      return NS_ERROR_NOT_AVAILABLE;
+    }
+  } else if (!strcmp(aTopic, NS_IPC_IOSERVICE_SET_CONNECTIVITY_TOPIC)) {
+    if (!SendSetConnectivity(u"true"_ns.Equals(aData))) {
+      return NS_ERROR_NOT_AVAILABLE;
+    }
+  } else if (!strcmp(aTopic, NS_IPC_CAPTIVE_PORTAL_SET_STATE)) {
+    nsCOMPtr<nsICaptivePortalService> cps = do_QueryInterface(aSubject);
+    MOZ_ASSERT(cps, "Should QI to a captive portal service");
+    if (!cps) {
+      return NS_ERROR_FAILURE;
+    }
+    int32_t state;
+    cps->GetState(&state);
+    if (!SendSetCaptivePortalState(state)) {
+      return NS_ERROR_NOT_AVAILABLE;
+    }
+  }
+  // listening for alert notifications
+  else if (!strcmp(aTopic, "alertfinished") ||
+           !strcmp(aTopic, "alertclickcallback") ||
+           !strcmp(aTopic, "alertshow") ||
+           !strcmp(aTopic, "alertdisablecallback") ||
+           !strcmp(aTopic, "alertsettingscallback")) {
+    if (!SendNotifyAlertsObserver(nsDependentCString(aTopic),
+                                  nsDependentString(aData)))
+      return NS_ERROR_NOT_AVAILABLE;
+  } else if (!strcmp(aTopic, "child-gc-request")) {
+    Unused << SendGarbageCollect();
+  } else if (!strcmp(aTopic, "child-cc-request")) {
+    Unused << SendCycleCollect();
+  } else if (!strcmp(aTopic, "child-mmu-request")) {
+    Unused << SendMinimizeMemoryUsage();
+  } else if (!strcmp(aTopic, "child-ghost-request")) {
+    Unused << SendUnlinkGhosts();
+  } else if (!strcmp(aTopic, "last-pb-context-exited")) {
+    Unused << SendLastPrivateDocShellDestroyed();
+  }
+#ifdef ACCESSIBILITY
+  else if (aData && !strcmp(aTopic, "a11y-init-or-shutdown")) {
+    if (*aData == '1') {
+      // Make sure accessibility is running in content process when
+      // accessibility gets initiated in chrome process.
+#  if defined(XP_WIN)
+      // Don't init content a11y if we detect an incompat version of JAWS in
+      // use.
+      if (!mozilla::a11y::Compatibility::IsOldJAWS()) {
+        Unused << SendActivateA11y();
+      }
+#  else
+      Unused << SendActivateA11y();
+#  endif
+    } else {
+      // If possible, shut down accessibility in content process when
+      // accessibility gets shutdown in chrome process.
+      Unused << SendShutdownA11y();
+    }
+  }
+#endif
+  else if (!strcmp(aTopic, "cacheservice:empty-cache")) {
+    Unused << SendNotifyEmptyHTTPCache();
+  } else if (!strcmp(aTopic, "intl:app-locales-changed")) {
+    nsTArray<nsCString> appLocales;
+    LocaleService::GetInstance()->GetAppLocalesAsBCP47(appLocales);
+    Unused << SendUpdateAppLocales(appLocales);
+  } else if (!strcmp(aTopic, "intl:requested-locales-changed")) {
+    nsTArray<nsCString> requestedLocales;
+    LocaleService::GetInstance()->GetRequestedLocales(requestedLocales);
+    Unused << SendUpdateRequestedLocales(requestedLocales);
+  } else if (!strcmp(aTopic, "cookie-changed") ||
+             !strcmp(aTopic, "private-cookie-changed")) {
+    if (!aData) {
+      return NS_ERROR_UNEXPECTED;
+    }
+    PNeckoParent* neckoParent = LoneManagedOrNullAsserts(ManagedPNeckoParent());
+    if (!neckoParent) {
+      return NS_OK;
+    }
+    PCookieServiceParent* csParent =
+        LoneManagedOrNullAsserts(neckoParent->ManagedPCookieServiceParent());
+    if (!csParent) {
+      return NS_OK;
+    }
+    auto* cs = static_cast<CookieServiceParent*>(csParent);
+    if (!nsCRT::strcmp(aData, u"batch-deleted")) {
+      nsCOMPtr<nsIArray> cookieList = do_QueryInterface(aSubject);
+      NS_ASSERTION(cookieList, "couldn't get cookie list");
+      cs->RemoveBatchDeletedCookies(cookieList);
+      return NS_OK;
+    }
+
+    if (!nsCRT::strcmp(aData, u"cleared")) {
+      cs->RemoveAll();
+      return NS_OK;
+    }
+
+    // Do not push these cookie updates to the same process they originated
+    // from.
+    if (cs->ProcessingCookie()) {
+      return NS_OK;
+    }
+
+    nsCOMPtr<nsICookie> xpcCookie = do_QueryInterface(aSubject);
+    NS_ASSERTION(xpcCookie, "couldn't get cookie");
+
+    // only broadcast the cookie change to content processes that need it
+    const Cookie& cookie = xpcCookie->AsCookie();
+
+    // do not send cookie if content process does not have similar cookie
+    if (!cs->ContentProcessHasCookie(cookie)) {
+      return NS_OK;
+    }
+
+    if (!nsCRT::strcmp(aData, u"deleted")) {
+      cs->RemoveCookie(cookie);
+    } else if ((!nsCRT::strcmp(aData, u"added")) ||
+               (!nsCRT::strcmp(aData, u"changed"))) {
+      cs->AddCookie(cookie);
+    }
+  } else if (!strcmp(aTopic, NS_NETWORK_LINK_TYPE_TOPIC)) {
+    UpdateNetworkLinkType();
+  } else if (!strcmp(aTopic, "network:socket-process-crashed")) {
+    Unused << SendSocketProcessCrashed();
+  } else if (!strcmp(aTopic, DEFAULT_TIMEZONE_CHANGED_OBSERVER_TOPIC)) {
+    Unused << SendSystemTimezoneChanged();
+  } else if (!strcmp(aTopic, NS_NETWORK_TRR_MODE_CHANGED_TOPIC)) {
+    nsCOMPtr<nsIDNSService> dns = do_GetService(NS_DNSSERVICE_CONTRACTID);
+    nsIDNSService::ResolverMode mode;
+    dns->GetCurrentTrrMode(&mode);
+    Unused << SendSetTRRMode(mode, static_cast<nsIDNSService::ResolverMode>(
+                                       StaticPrefs::network_trr_mode()));
+  }
+
+  return NS_OK;
+}
+
+void ContentParent::UpdateNetworkLinkType() {
+  nsresult rv;
+  nsCOMPtr<nsINetworkLinkService> nls =
+      do_GetService(NS_NETWORK_LINK_SERVICE_CONTRACTID, &rv);
+  if (NS_FAILED(rv)) {
+    return;
+  }
+
+  uint32_t linkType = nsINetworkLinkService::LINK_TYPE_UNKNOWN;
+  rv = nls->GetLinkType(&linkType);
+  if (NS_FAILED(rv)) {
+    return;
+  }
+
+  Unused << SendNetworkLinkTypeChange(linkType);
+}
+
+NS_IMETHODIMP
+ContentParent::GetInterface(const nsIID& aIID, void** aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  if (aIID.Equals(NS_GET_IID(nsIMessageSender))) {
+    nsCOMPtr<nsIMessageSender> mm = GetMessageManager();
+    mm.forget(aResult);
+    return NS_OK;
+  }
+
+  return NS_NOINTERFACE;
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvInitBackground(
+    Endpoint<PBackgroundStarterParent>&& aEndpoint) {
+  if (!BackgroundParent::AllocStarter(this, std::move(aEndpoint))) {
+    NS_WARNING("BackgroundParent::Alloc failed");
+  }
+
+  return IPC_OK();
+}
+
+bool ContentParent::CanOpenBrowser(const IPCTabContext& aContext) {
+  // (PopupIPCTabContext lets the child process prove that it has access to
+  // the app it's trying to open.)
+  // On e10s we also allow UnsafeTabContext to allow service workers to open
+  // windows. This is enforced in MaybeInvalidTabContext.
+  if (aContext.type() != IPCTabContext::TPopupIPCTabContext) {
+    MOZ_CRASH_UNLESS_FUZZING(
+        "Unexpected IPCTabContext type.  Aborting AllocPBrowserParent.");
+    return false;
+  }
+
+  if (aContext.type() == IPCTabContext::TPopupIPCTabContext) {
+    const PopupIPCTabContext& popupContext = aContext.get_PopupIPCTabContext();
+
+    auto opener = BrowserParent::GetFrom(popupContext.opener().AsParent());
+    if (!opener) {
+      MOZ_CRASH_UNLESS_FUZZING(
+          "Got null opener from child; aborting AllocPBrowserParent.");
+      return false;
+    }
+  }
+
+  MaybeInvalidTabContext tc(aContext);
+  if (!tc.IsValid()) {
+    NS_ERROR(nsPrintfCString("Child passed us an invalid TabContext.  (%s)  "
+                             "Aborting AllocPBrowserParent.",
+                             tc.GetInvalidReason())
+                 .get());
+    return false;
+  }
+
+  return true;
+}
+
+static bool CloneIsLegal(ContentParent* aCp, CanonicalBrowsingContext& aSource,
+                         CanonicalBrowsingContext& aTarget) {
+  // Source and target must be in the same BCG
+  if (NS_WARN_IF(aSource.Group() != aTarget.Group())) {
+    return false;
+  }
+  // The source and target must be in different toplevel <browser>s
+  if (NS_WARN_IF(aSource.Top() == aTarget.Top())) {
+    return false;
+  }
+
+  // Neither source nor target must be toplevel.
+  if (NS_WARN_IF(aSource.IsTop()) || NS_WARN_IF(aTarget.IsTop())) {
+    return false;
+  }
+
+  // Both should be embedded by the same process.
+  auto* sourceEmbedder = aSource.GetParentWindowContext();
+  if (NS_WARN_IF(!sourceEmbedder) ||
+      NS_WARN_IF(sourceEmbedder->GetContentParent() != aCp)) {
+    return false;
+  }
+
+  auto* targetEmbedder = aTarget.GetParentWindowContext();
+  if (NS_WARN_IF(!targetEmbedder) ||
+      NS_WARN_IF(targetEmbedder->GetContentParent() != aCp)) {
+    return false;
+  }
+
+  // All seems sane.
+  return true;
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvCloneDocumentTreeInto(
+    const MaybeDiscarded<BrowsingContext>& aSource,
+    const MaybeDiscarded<BrowsingContext>& aTarget, PrintData&& aPrintData) {
+  if (aSource.IsNullOrDiscarded() || aTarget.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
+    // All existing processes have potentially been slated for removal already,
+    // such that any subsequent call to GetNewOrUsedLaunchingBrowserProcess
+    // (normally supposed to find an existing process here) will try to create
+    // a new process (but fail) that nobody would ever really use. Let's avoid
+    // this together with the expensive CloneDocumentTreeInto operation.
+    return IPC_OK();
+  }
+
+  auto* source = aSource.get_canonical();
+  auto* target = aTarget.get_canonical();
+
+  if (!CloneIsLegal(this, *source, *target)) {
+    return IPC_FAIL(this, "Illegal subframe clone");
+  }
+
+  ContentParent* cp = source->GetContentParent();
+  if (NS_WARN_IF(!cp)) {
+    return IPC_OK();
+  }
+
+  if (NS_WARN_IF(cp->GetRemoteType() == GetRemoteType())) {
+    // Wanted to switch to a target browsing context that's already local again.
+    // See bug 1676996 for how this can happen.
+    //
+    // Dropping the switch on the floor seems fine for this case, though we
+    // could also try to clone the local document.
+    //
+    // If the remote type matches & it's in the same group (which was confirmed
+    // by CloneIsLegal), it must be the exact same process.
+    MOZ_DIAGNOSTIC_ASSERT(cp == this);
+    return IPC_OK();
+  }
+
+  target->CloneDocumentTreeInto(source, cp->GetRemoteType(),
+                                std::move(aPrintData));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvUpdateRemotePrintSettings(
+    const MaybeDiscarded<BrowsingContext>& aTarget, PrintData&& aPrintData) {
+  if (aTarget.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  auto* target = aTarget.get_canonical();
+  auto* bp = target->GetBrowserParent();
+  if (NS_WARN_IF(!bp)) {
+    return IPC_OK();
+  }
+
+  Unused << bp->SendUpdateRemotePrintSettings(std::move(aPrintData));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvConstructPopupBrowser(
+    ManagedEndpoint<PBrowserParent>&& aBrowserEp,
+    ManagedEndpoint<PWindowGlobalParent>&& aWindowEp, const TabId& aTabId,
+    const IPCTabContext& aContext, const WindowGlobalInit& aInitialWindowInit,
+    const uint32_t& aChromeFlags) {
+  MOZ_ASSERT(XRE_IsParentProcess());
+
+  if (!CanOpenBrowser(aContext)) {
+    return IPC_FAIL(this, "CanOpenBrowser Failed");
+  }
+
+  RefPtr<CanonicalBrowsingContext> browsingContext =
+      CanonicalBrowsingContext::Get(
+          aInitialWindowInit.context().mBrowsingContextId);
+  if (!browsingContext || browsingContext->IsDiscarded()) {
+    return IPC_FAIL(this, "Null or discarded initial BrowsingContext");
+  }
+  if (!aInitialWindowInit.principal()) {
+    return IPC_FAIL(this, "Cannot create without valid initial principal");
+  }
+
+  if (!ValidatePrincipal(aInitialWindowInit.principal())) {
+    LogAndAssertFailedPrincipalValidationInfo(aInitialWindowInit.principal(),
+                                              __func__);
+  }
+
+  if (browsingContext->GetBrowserParent()) {
+    return IPC_FAIL(this, "BrowsingContext already has a BrowserParent");
+  }
+
+  uint32_t chromeFlags = aChromeFlags;
+  TabId openerTabId(0);
+  ContentParentId openerCpId(0);
+  if (aContext.type() == IPCTabContext::TPopupIPCTabContext) {
+    // CanOpenBrowser has ensured that the IPCTabContext is of
+    // type PopupIPCTabContext, and that the opener BrowserParent is
+    // reachable.
+    const PopupIPCTabContext& popupContext = aContext.get_PopupIPCTabContext();
+    auto opener = BrowserParent::GetFrom(popupContext.opener().AsParent());
+    openerTabId = opener->GetTabId();
+    openerCpId = opener->Manager()->ChildID();
+
+    // We must ensure that the private browsing and remoteness flags
+    // match those of the opener.
+    nsCOMPtr<nsILoadContext> loadContext = opener->GetLoadContext();
+    if (!loadContext) {
+      return IPC_FAIL(this, "Missing Opener LoadContext");
+    }
+    if (loadContext->UsePrivateBrowsing()) {
+      chromeFlags |= nsIWebBrowserChrome::CHROME_PRIVATE_WINDOW;
+    }
+    if (loadContext->UseRemoteSubframes()) {
+      chromeFlags |= nsIWebBrowserChrome::CHROME_FISSION_WINDOW;
+    }
+  }
+
+  // And because we're allocating a remote browser, of course the
+  // window is remote.
+  chromeFlags |= nsIWebBrowserChrome::CHROME_REMOTE_WINDOW;
+
+  if (NS_WARN_IF(!browsingContext->IsOwnedByProcess(ChildID()))) {
+    return IPC_FAIL(this, "BrowsingContext Owned by Incorrect Process!");
+  }
+
+  MaybeInvalidTabContext tc(aContext);
+  MOZ_ASSERT(tc.IsValid());
+
+  RefPtr<WindowGlobalParent> initialWindow =
+      WindowGlobalParent::CreateDisconnected(aInitialWindowInit);
+  if (!initialWindow) {
+    return IPC_FAIL(this, "Failed to create WindowGlobalParent");
+  }
+
+  auto parent = MakeRefPtr<BrowserParent>(this, aTabId, tc.GetTabContext(),
+                                          browsingContext, chromeFlags);
+
+  // Bind the created BrowserParent to IPC to actually link the actor.
+  if (NS_WARN_IF(!BindPBrowserEndpoint(std::move(aBrowserEp), parent))) {
+    return IPC_FAIL(this, "BindPBrowserEndpoint failed");
+  }
+
+  // XXX: Why are we checking these requirements? It seems we should register
+  // the created frame unconditionally?
+  if (openerTabId > 0) {
+    // The creation of PBrowser was triggered from content process through
+    // window.open().
+    // We need to register remote frame with the child generated tab id.
+    auto* cpm = ContentProcessManager::GetSingleton();
+    if (!cpm || !cpm->RegisterRemoteFrame(parent)) {
+      return IPC_FAIL(this, "RegisterRemoteFrame Failed");
+    }
+  }
+
+  if (NS_WARN_IF(!parent->BindPWindowGlobalEndpoint(std::move(aWindowEp),
+                                                    initialWindow))) {
+    return IPC_FAIL(this, "BindPWindowGlobalEndpoint failed");
+  }
+
+  browsingContext->SetCurrentBrowserParent(parent);
+
+  initialWindow->Init();
+
+  // When enabling input event prioritization, input events may preempt other
+  // normal priority IPC messages. To prevent the input events preempt
+  // PBrowserConstructor, we use an IPC 'RemoteIsReadyToHandleInputEvents' to
+  // notify parent that BrowserChild is created. In this case, PBrowser is
+  // initiated from content so that we can set BrowserParent as ready to handle
+  // input
+  parent->SetReadyToHandleInputEvents();
+  return IPC_OK();
+}
+
+mozilla::PRemoteSpellcheckEngineParent*
+ContentParent::AllocPRemoteSpellcheckEngineParent() {
+  mozilla::RemoteSpellcheckEngineParent* parent =
+      new mozilla::RemoteSpellcheckEngineParent();
+  return parent;
+}
+
+bool ContentParent::DeallocPRemoteSpellcheckEngineParent(
+    PRemoteSpellcheckEngineParent* parent) {
+  delete parent;
+  return true;
+}
+
+/* static */
+void ContentParent::ForceKillTimerCallback(nsITimer* aTimer, void* aClosure) {
+  // We don't want to time out the content process during XPCShell tests. This
+  // is the easiest way to ensure that.
+  if (PR_GetEnv("XPCSHELL_TEST_PROFILE_DIR")) {
+    return;
+  }
+
+  auto self = static_cast<ContentParent*>(aClosure);
+  self->KillHard("ShutDownKill");
+}
+
+void ContentParent::GeneratePairedMinidump(const char* aReason) {
+  // We're about to kill the child process associated with this content.
+  // Something has gone wrong to get us here, so we generate a minidump
+  // of the parent and child for submission to the crash server unless we're
+  // already shutting down.
+  if (mCrashReporter &&
+      !AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed) &&
+      StaticPrefs::dom_ipc_tabs_createKillHardCrashReports_AtStartup()) {
+    // GeneratePairedMinidump creates two minidumps for us - the main
+    // one is for the content process we're about to kill, and the other
+    // one is for the main browser process. That second one is the extra
+    // minidump tagging along, so we have to tell the crash reporter that
+    // it exists and is being appended.
+    nsAutoCString additionalDumps("browser");
+    mCrashReporter->AddAnnotation(
+        CrashReporter::Annotation::additional_minidumps, additionalDumps);
+    nsDependentCString reason(aReason);
+    mCrashReporter->AddAnnotation(CrashReporter::Annotation::ipc_channel_error,
+                                  reason);
+
+    // Generate the report and insert into the queue for submittal.
+    if (mCrashReporter->GenerateMinidumpAndPair(this, "browser"_ns)) {
+      mCrashReporter->FinalizeCrashReport();
+      mCreatedPairedMinidumps = true;
+    }
+  }
+}
+
+void ContentParent::HandleOrphanedMinidump(nsString* aDumpId) {
+  if (CrashReporter::FinalizeOrphanedMinidump(
+          OtherPid(), GeckoProcessType_Content, aDumpId)) {
+    CrashReporterHost::RecordCrash(GeckoProcessType_Content,
+                                   nsICrashService::CRASH_TYPE_CRASH, *aDumpId);
+  } else {
+    NS_WARNING(nsPrintfCString("content process pid = %" PRIPID
+                               " crashed without leaving a minidump behind",
+                               OtherPid())
+                   .get());
+  }
+}
+
+// WARNING: aReason appears in telemetry, so any new value passed in requires
+// data review.
+void ContentParent::KillHard(const char* aReason) {
+  AUTO_PROFILER_LABEL("ContentParent::KillHard", OTHER);
+
+  // On Windows, calling KillHard multiple times causes problems - the
+  // process handle becomes invalid on the first call, causing a second call
+  // to crash our process - more details in bug 890840.
+  if (mCalledKillHard) {
+    return;
+  }
+  mCalledKillHard = true;
+  mForceKillTimer = nullptr;
+
+  RemoveShutdownBlockers();
+  nsCString reason = nsDependentCString(aReason);
+
+  // If we find mIsNotifiedShutdownSuccess there is no reason to blame this
+  // content process, most probably our parent process is just slow in
+  // processing its own main thread queue.
+  if (!mIsNotifiedShutdownSuccess) {
+    GeneratePairedMinidump(aReason);
+  } else {
+    reason = nsDependentCString("KillHard after IsNotifiedShutdownSuccess.");
+  }
+  Telemetry::Accumulate(Telemetry::SUBPROCESS_KILL_HARD, reason, 1);
+
+  ProcessHandle otherProcessHandle;
+  if (!base::OpenProcessHandle(OtherPid(), &otherProcessHandle)) {
+    NS_ERROR("Failed to open child process when attempting kill.");
+    ShutDownProcess(CLOSE_CHANNEL_WITH_ERROR);
+    return;
+  }
+
+  if (!KillProcess(otherProcessHandle, base::PROCESS_END_KILLED_BY_USER)) {
+    if (mCrashReporter) {
+      mCrashReporter->DeleteCrashReport();
+    }
+    NS_WARNING("failed to kill subprocess!");
+  }
+
+  if (mSubprocess) {
+    MOZ_LOG(
+        ContentParent::GetLog(), LogLevel::Verbose,
+        ("KillHard Subprocess(%s): ContentParent %p mSubprocess %p handle "
+         "%" PRIuPTR,
+         aReason, this, mSubprocess,
+         mSubprocess ? (uintptr_t)mSubprocess->GetChildProcessHandle() : -1));
+    mSubprocess->SetAlreadyDead();
+  }
+
+  // After we've killed the remote process, also ensure we close the IPC channel
+  // with an error to immediately stop all IPC communication on this channel.
+  ShutDownProcess(CLOSE_CHANNEL_WITH_ERROR);
+
+  // EnsureProcessTerminated has responsibilty for closing otherProcessHandle.
+  XRE_GetIOMessageLoop()->PostTask(
+      NewRunnableFunction("EnsureProcessTerminatedRunnable",
+                          &ProcessWatcher::EnsureProcessTerminated,
+                          otherProcessHandle, /*force=*/true));
+}
+
+void ContentParent::FriendlyName(nsAString& aName, bool aAnonymize) {
+  aName.Truncate();
+  if (mIsForBrowser) {
+    aName.AssignLiteral("Browser");
+  } else if (aAnonymize) {
+    aName.AssignLiteral("<anonymized-name>");
+  } else {
+    aName.AssignLiteral("???");
+  }
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvInitCrashReporter(
+    const NativeThreadId& aThreadId) {
+  mCrashReporter =
+      MakeUnique<CrashReporterHost>(GeckoProcessType_Content, aThreadId);
+
+  return IPC_OK();
+}
+
+hal_sandbox::PHalParent* ContentParent::AllocPHalParent() {
+  return hal_sandbox::CreateHalParent();
+}
+
+bool ContentParent::DeallocPHalParent(hal_sandbox::PHalParent* aHal) {
+  delete aHal;
+  return true;
+}
+
+devtools::PHeapSnapshotTempFileHelperParent*
+ContentParent::AllocPHeapSnapshotTempFileHelperParent() {
+  return devtools::HeapSnapshotTempFileHelperParent::Create();
+}
+
+bool ContentParent::DeallocPHeapSnapshotTempFileHelperParent(
+    devtools::PHeapSnapshotTempFileHelperParent* aHeapSnapshotHelper) {
+  delete aHeapSnapshotHelper;
+  return true;
+}
+
+bool ContentParent::SendRequestMemoryReport(
+    const uint32_t& aGeneration, const bool& aAnonymize,
+    const bool& aMinimizeMemoryUsage, const Maybe<FileDescriptor>& aDMDFile) {
+  // This automatically cancels the previous request.
+  mMemoryReportRequest = MakeUnique<MemoryReportRequestHost>(aGeneration);
+  // If we run the callback in response to a reply, then by definition |this|
+  // is still alive, so the ref pointer is redundant, but it seems easier
+  // to hold a strong reference than to worry about that.
+  RefPtr<ContentParent> self(this);
+  PContentParent::SendRequestMemoryReport(
+      aGeneration, aAnonymize, aMinimizeMemoryUsage, aDMDFile,
+      [&, self](const uint32_t& aGeneration2) {
+        if (self->mMemoryReportRequest) {
+          self->mMemoryReportRequest->Finish(aGeneration2);
+          self->mMemoryReportRequest = nullptr;
+        }
+      },
+      [&, self](mozilla::ipc::ResponseRejectReason) {
+        self->mMemoryReportRequest = nullptr;
+      });
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvAddMemoryReport(
+    const MemoryReport& aReport) {
+  if (mMemoryReportRequest) {
+    mMemoryReportRequest->RecvReport(aReport);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvAddPerformanceMetrics(
+    const nsID& aID, nsTArray<PerformanceInfo>&& aMetrics) {
+  nsresult rv = PerformanceMetricsCollector::DataReceived(aID, aMetrics);
+  Unused << NS_WARN_IF(NS_FAILED(rv));
+  return IPC_OK();
+}
+
+PCycleCollectWithLogsParent* ContentParent::AllocPCycleCollectWithLogsParent(
+    const bool& aDumpAllTraces, const FileDescriptor& aGCLog,
+    const FileDescriptor& aCCLog) {
+  MOZ_CRASH("Don't call this; use ContentParent::CycleCollectWithLogs");
+}
+
+bool ContentParent::DeallocPCycleCollectWithLogsParent(
+    PCycleCollectWithLogsParent* aActor) {
+  delete aActor;
+  return true;
+}
+
+bool ContentParent::CycleCollectWithLogs(
+    bool aDumpAllTraces, nsICycleCollectorLogSink* aSink,
+    nsIDumpGCAndCCLogsCallback* aCallback) {
+  return CycleCollectWithLogsParent::AllocAndSendConstructor(
+      this, aDumpAllTraces, aSink, aCallback);
+}
+
+PTestShellParent* ContentParent::AllocPTestShellParent() {
+  return new TestShellParent();
+}
+
+bool ContentParent::DeallocPTestShellParent(PTestShellParent* shell) {
+  delete shell;
+  return true;
+}
+
+PScriptCacheParent* ContentParent::AllocPScriptCacheParent(
+    const FileDescOrError& cacheFile, const bool& wantCacheData) {
+  return new loader::ScriptCacheParent(wantCacheData);
+}
+
+bool ContentParent::DeallocPScriptCacheParent(PScriptCacheParent* cache) {
+  delete static_cast<loader::ScriptCacheParent*>(cache);
+  return true;
+}
+
+already_AddRefed<PNeckoParent> ContentParent::AllocPNeckoParent() {
+  RefPtr<NeckoParent> actor = new NeckoParent();
+  return actor.forget();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvInitStreamFilter(
+    const uint64_t& aChannelId, const nsAString& aAddonId,
+    InitStreamFilterResolver&& aResolver) {
+  extensions::StreamFilterParent::Create(this, aChannelId, aAddonId)
+      ->Then(
+          GetCurrentSerialEventTarget(), __func__,
+          [aResolver](mozilla::ipc::Endpoint<PStreamFilterChild>&& aEndpoint) {
+            aResolver(std::move(aEndpoint));
+          },
+          [aResolver](bool aDummy) {
+            aResolver(mozilla::ipc::Endpoint<PStreamFilterChild>());
+          });
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvAddSecurityState(
+    const MaybeDiscarded<WindowContext>& aContext, uint32_t aStateFlags) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  aContext.get()->AddSecurityState(aStateFlags);
+  return IPC_OK();
+}
+
+already_AddRefed<PExternalHelperAppParent>
+ContentParent::AllocPExternalHelperAppParent(
+    nsIURI* uri, const Maybe<mozilla::net::LoadInfoArgs>& aLoadInfoArgs,
+    const nsACString& aMimeContentType, const nsACString& aContentDisposition,
+    const uint32_t& aContentDispositionHint,
+    const nsAString& aContentDispositionFilename, const bool& aForceSave,
+    const int64_t& aContentLength, const bool& aWasFileChannel,
+    nsIURI* aReferrer, const MaybeDiscarded<BrowsingContext>& aContext,
+    const bool& aShouldCloseWindow) {
+  RefPtr<ExternalHelperAppParent> parent = new ExternalHelperAppParent(
+      uri, aContentLength, aWasFileChannel, aContentDisposition,
+      aContentDispositionHint, aContentDispositionFilename);
+  return parent.forget();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvPExternalHelperAppConstructor(
+    PExternalHelperAppParent* actor, nsIURI* uri,
+    const Maybe<LoadInfoArgs>& loadInfoArgs, const nsACString& aMimeContentType,
+    const nsACString& aContentDisposition,
+    const uint32_t& aContentDispositionHint,
+    const nsAString& aContentDispositionFilename, const bool& aForceSave,
+    const int64_t& aContentLength, const bool& aWasFileChannel,
+    nsIURI* aReferrer, const MaybeDiscarded<BrowsingContext>& aContext,
+    const bool& aShouldCloseWindow) {
+  BrowsingContext* context = aContext.IsDiscarded() ? nullptr : aContext.get();
+  if (!static_cast<ExternalHelperAppParent*>(actor)->Init(
+          loadInfoArgs, aMimeContentType, aForceSave, aReferrer, context,
+          aShouldCloseWindow)) {
+    return IPC_FAIL(this, "Init failed.");
+  }
+  return IPC_OK();
+}
+
+already_AddRefed<PHandlerServiceParent>
+ContentParent::AllocPHandlerServiceParent() {
+  RefPtr<HandlerServiceParent> actor = new HandlerServiceParent();
+  return actor.forget();
+}
+
+media::PMediaParent* ContentParent::AllocPMediaParent() {
+  return media::AllocPMediaParent();
+}
+
+bool ContentParent::DeallocPMediaParent(media::PMediaParent* aActor) {
+  return media::DeallocPMediaParent(aActor);
+}
+
+PBenchmarkStorageParent* ContentParent::AllocPBenchmarkStorageParent() {
+  return new BenchmarkStorageParent;
+}
+
+bool ContentParent::DeallocPBenchmarkStorageParent(
+    PBenchmarkStorageParent* aActor) {
+  delete aActor;
+  return true;
+}
+
+#ifdef MOZ_WEBSPEECH
+PSpeechSynthesisParent* ContentParent::AllocPSpeechSynthesisParent() {
+  if (!StaticPrefs::media_webspeech_synth_enabled()) {
+    return nullptr;
+  }
+  return new mozilla::dom::SpeechSynthesisParent();
+}
+
+bool ContentParent::DeallocPSpeechSynthesisParent(
+    PSpeechSynthesisParent* aActor) {
+  delete aActor;
+  return true;
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvPSpeechSynthesisConstructor(
+    PSpeechSynthesisParent* aActor) {
+  if (!static_cast<SpeechSynthesisParent*>(aActor)->SendInit()) {
+    return IPC_FAIL(this, "SpeechSynthesisParent::SendInit failed.");
+  }
+  return IPC_OK();
+}
+#endif
+
+mozilla::ipc::IPCResult ContentParent::RecvStartVisitedQueries(
+    const nsTArray<RefPtr<nsIURI>>& aUris) {
+  nsCOMPtr<IHistory> history = components::History::Service();
+  if (!history) {
+    return IPC_OK();
+  }
+  for (const auto& uri : aUris) {
+    if (NS_WARN_IF(!uri)) {
+      continue;
+    }
+    history->ScheduleVisitedQuery(uri, this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSetURITitle(nsIURI* uri,
+                                                       const nsAString& title) {
+  if (!uri) {
+    return IPC_FAIL(this, "uri must not be null.");
+  }
+  nsCOMPtr<IHistory> history = components::History::Service();
+  if (history) {
+    history->SetURITitle(uri, title);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvIsSecureURI(
+    nsIURI* aURI, const OriginAttributes& aOriginAttributes,
+    bool* aIsSecureURI) {
+  nsCOMPtr<nsISiteSecurityService> sss(do_GetService(NS_SSSERVICE_CONTRACTID));
+  if (!sss) {
+    return IPC_FAIL(this, "Failed to get nsISiteSecurityService.");
+  }
+  if (!aURI) {
+    return IPC_FAIL(this, "aURI must not be null.");
+  }
+  nsresult rv = sss->IsSecureURI(aURI, aOriginAttributes, aIsSecureURI);
+  if (NS_FAILED(rv)) {
+    return IPC_FAIL(this, "IsSecureURI failed.");
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvAccumulateMixedContentHSTS(
+    nsIURI* aURI, const bool& aActive,
+    const OriginAttributes& aOriginAttributes) {
+  if (!aURI) {
+    return IPC_FAIL(this, "aURI must not be null.");
+  }
+  nsMixedContentBlocker::AccumulateMixedContentHSTS(aURI, aActive,
+                                                    aOriginAttributes);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvLoadURIExternal(
+    nsIURI* uri, nsIPrincipal* aTriggeringPrincipal,
+    nsIPrincipal* aRedirectPrincipal,
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    bool aWasExternallyTriggered, bool aHasValidUserGestureActivation) {
+  if (aContext.IsDiscarded()) {
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIExternalProtocolService> extProtService(
+      do_GetService(NS_EXTERNALPROTOCOLSERVICE_CONTRACTID));
+  if (!extProtService) {
+    return IPC_OK();
+  }
+
+  if (!uri) {
+    return IPC_FAIL(this, "uri must not be null.");
+  }
+
+  BrowsingContext* bc = aContext.get();
+  extProtService->LoadURI(uri, aTriggeringPrincipal, aRedirectPrincipal, bc,
+                          aWasExternallyTriggered,
+                          aHasValidUserGestureActivation);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvExtProtocolChannelConnectParent(
+    const uint64_t& registrarId) {
+  nsresult rv;
+
+  // First get the real channel created before redirect on the parent.
+  nsCOMPtr<nsIChannel> channel;
+  rv = NS_LinkRedirectChannels(registrarId, nullptr, getter_AddRefs(channel));
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+
+  nsCOMPtr<nsIParentChannel> parent = do_QueryInterface(channel, &rv);
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+
+  // The channel itself is its own (faked) parent, link it.
+  rv = NS_LinkRedirectChannels(registrarId, parent, getter_AddRefs(channel));
+  NS_ENSURE_SUCCESS(rv, IPC_OK());
+
+  // Signal the parent channel that it's a redirect-to parent.  This will
+  // make AsyncOpen on it do nothing (what we want).
+  // Yes, this is a bit of a hack, but I don't think it's necessary to invent
+  // a new interface just to set this flag on the channel.
+  parent->SetParentListener(nullptr);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvShowAlert(
+    nsIAlertNotification* aAlert) {
+  if (!aAlert) {
+    return IPC_FAIL(this, "aAlert must not be null.");
+  }
+  nsCOMPtr<nsIAlertsService> sysAlerts(components::Alerts::Service());
+  if (sysAlerts) {
+    sysAlerts->ShowAlert(aAlert, this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvCloseAlert(const nsAString& aName,
+                                                      bool aContextClosed) {
+  nsCOMPtr<nsIAlertsService> sysAlerts(components::Alerts::Service());
+  if (sysAlerts) {
+    sysAlerts->CloseAlert(aName, aContextClosed);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvDisableNotifications(
+    nsIPrincipal* aPrincipal) {
+  if (!aPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  if (!ValidatePrincipal(aPrincipal)) {
+    LogAndAssertFailedPrincipalValidationInfo(aPrincipal, __func__);
+  }
+  Unused << Notification::RemovePermission(aPrincipal);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvOpenNotificationSettings(
+    nsIPrincipal* aPrincipal) {
+  if (!aPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  if (!ValidatePrincipal(aPrincipal)) {
+    LogAndAssertFailedPrincipalValidationInfo(aPrincipal, __func__);
+  }
+  Unused << Notification::OpenSettings(aPrincipal);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvNotificationEvent(
+    const nsAString& aType, const NotificationEventData& aData) {
+  nsCOMPtr<nsIServiceWorkerManager> swm =
+      mozilla::components::ServiceWorkerManager::Service();
+  if (NS_WARN_IF(!swm)) {
+    // Probably shouldn't happen, but no need to crash the child process.
+    return IPC_OK();
+  }
+
+  if (aType.EqualsLiteral("click")) {
+    nsresult rv = swm->SendNotificationClickEvent(
+        aData.originSuffix(), aData.scope(), aData.ID(), aData.title(),
+        aData.dir(), aData.lang(), aData.body(), aData.tag(), aData.icon(),
+        aData.data(), aData.behavior());
+    Unused << NS_WARN_IF(NS_FAILED(rv));
+  } else {
+    MOZ_ASSERT(aType.EqualsLiteral("close"));
+    nsresult rv = swm->SendNotificationCloseEvent(
+        aData.originSuffix(), aData.scope(), aData.ID(), aData.title(),
+        aData.dir(), aData.lang(), aData.body(), aData.tag(), aData.icon(),
+        aData.data(), aData.behavior());
+    Unused << NS_WARN_IF(NS_FAILED(rv));
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSyncMessage(
+    const nsAString& aMsg, const ClonedMessageData& aData,
+    nsTArray<StructuredCloneData>* aRetvals) {
+  AUTO_PROFILER_LABEL_DYNAMIC_LOSSY_NSSTRING("ContentParent::RecvSyncMessage",
+                                             OTHER, aMsg);
+  MMPrinter::Print("ContentParent::RecvSyncMessage", aMsg, aData);
+
+  RefPtr<nsFrameMessageManager> ppm = mMessageManager;
+  if (ppm) {
+    ipc::StructuredCloneData data;
+    ipc::UnpackClonedMessageData(aData, data);
+
+    ppm->ReceiveMessage(ppm, nullptr, aMsg, true, &data, aRetvals,
+                        IgnoreErrors());
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvAsyncMessage(
+    const nsAString& aMsg, const ClonedMessageData& aData) {
+  AUTO_PROFILER_LABEL_DYNAMIC_LOSSY_NSSTRING("ContentParent::RecvAsyncMessage",
+                                             OTHER, aMsg);
+  MMPrinter::Print("ContentParent::RecvAsyncMessage", aMsg, aData);
+
+  RefPtr<nsFrameMessageManager> ppm = mMessageManager;
+  if (ppm) {
+    ipc::StructuredCloneData data;
+    ipc::UnpackClonedMessageData(aData, data);
+
+    ppm->ReceiveMessage(ppm, nullptr, aMsg, false, &data, nullptr,
+                        IgnoreErrors());
+  }
+  return IPC_OK();
+}
+
+MOZ_CAN_RUN_SCRIPT
+static int32_t AddGeolocationListener(
+    nsIDOMGeoPositionCallback* watcher,
+    nsIDOMGeoPositionErrorCallback* errorCallBack, bool highAccuracy) {
+  RefPtr<Geolocation> geo = Geolocation::NonWindowSingleton();
+
+  UniquePtr<PositionOptions> options = MakeUnique<PositionOptions>();
+  options->mTimeout = 0;
+  options->mMaximumAge = 0;
+  options->mEnableHighAccuracy = highAccuracy;
+  return geo->WatchPosition(watcher, errorCallBack, std::move(options));
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvAddGeolocationListener(
+    const bool& aHighAccuracy) {
+  // To ensure no geolocation updates are skipped, we always force the
+  // creation of a new listener.
+  RecvRemoveGeolocationListener();
+  mGeolocationWatchID = AddGeolocationListener(this, this, aHighAccuracy);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvRemoveGeolocationListener() {
+  if (mGeolocationWatchID != -1) {
+    RefPtr<Geolocation> geo = Geolocation::NonWindowSingleton();
+    if (geo) {
+      geo->ClearWatch(mGeolocationWatchID);
+    }
+    mGeolocationWatchID = -1;
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSetGeolocationHigherAccuracy(
+    const bool& aEnable) {
+  // This should never be called without a listener already present,
+  // so this check allows us to forgo securing privileges.
+  if (mGeolocationWatchID != -1) {
+    RecvRemoveGeolocationListener();
+    mGeolocationWatchID = AddGeolocationListener(this, this, aEnable);
+  }
+  return IPC_OK();
+}
+
+NS_IMETHODIMP
+ContentParent::HandleEvent(nsIDOMGeoPosition* postion) {
+  Unused << SendGeolocationUpdate(postion);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ContentParent::HandleEvent(GeolocationPositionError* positionError) {
+  Unused << SendGeolocationError(positionError->Code());
+  return NS_OK;
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvConsoleMessage(
+    const nsAString& aMessage) {
+  nsresult rv;
+  nsCOMPtr<nsIConsoleService> consoleService =
+      do_GetService(NS_CONSOLESERVICE_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv)) {
+    RefPtr<nsConsoleMessage> msg(new nsConsoleMessage(aMessage));
+    msg->SetIsForwardedFromContentProcess(true);
+    consoleService->LogMessageWithMode(msg, nsIConsoleService::SuppressLog);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvReportFrameTimingData(
+    const mozilla::Maybe<LoadInfoArgs>& loadInfoArgs,
+    const nsAString& entryName, const nsAString& initiatorType,
+    UniquePtr<PerformanceTimingData>&& aData) {
+  if (!aData) {
+    return IPC_FAIL(this, "aData should not be null");
+  }
+
+  if (loadInfoArgs.isNothing()) {
+    return IPC_FAIL(this, "loadInfoArgs should not be null");
+  }
+
+  RefPtr<WindowGlobalParent> parent =
+      WindowGlobalParent::GetByInnerWindowId(loadInfoArgs->innerWindowID());
+  if (!parent || !parent->GetContentParent()) {
+    return IPC_OK();
+  }
+
+  MOZ_ASSERT(parent->GetContentParent() != this,
+             "No need to bounce around if in the same process");
+
+  Unused << parent->GetContentParent()->SendReportFrameTimingData(
+      loadInfoArgs, entryName, initiatorType, std::move(aData));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvScriptError(
+    const nsAString& aMessage, const nsAString& aSourceName,
+    const nsAString& aSourceLine, const uint32_t& aLineNumber,
+    const uint32_t& aColNumber, const uint32_t& aFlags,
+    const nsACString& aCategory, const bool& aFromPrivateWindow,
+    const uint64_t& aInnerWindowId, const bool& aFromChromeContext) {
+  return RecvScriptErrorInternal(aMessage, aSourceName, aSourceLine,
+                                 aLineNumber, aColNumber, aFlags, aCategory,
+                                 aFromPrivateWindow, aFromChromeContext);
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvScriptErrorWithStack(
+    const nsAString& aMessage, const nsAString& aSourceName,
+    const nsAString& aSourceLine, const uint32_t& aLineNumber,
+    const uint32_t& aColNumber, const uint32_t& aFlags,
+    const nsACString& aCategory, const bool& aFromPrivateWindow,
+    const bool& aFromChromeContext, const ClonedMessageData& aFrame) {
+  return RecvScriptErrorInternal(
+      aMessage, aSourceName, aSourceLine, aLineNumber, aColNumber, aFlags,
+      aCategory, aFromPrivateWindow, aFromChromeContext, &aFrame);
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvScriptErrorInternal(
+    const nsAString& aMessage, const nsAString& aSourceName,
+    const nsAString& aSourceLine, const uint32_t& aLineNumber,
+    const uint32_t& aColNumber, const uint32_t& aFlags,
+    const nsACString& aCategory, const bool& aFromPrivateWindow,
+    const bool& aFromChromeContext, const ClonedMessageData* aStack) {
+  nsresult rv;
+  nsCOMPtr<nsIConsoleService> consoleService =
+      do_GetService(NS_CONSOLESERVICE_CONTRACTID, &rv);
+  if (NS_FAILED(rv)) {
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIScriptError> msg;
+
+  if (aStack) {
+    StructuredCloneData data;
+    UnpackClonedMessageData(*aStack, data);
+
+    AutoJSAPI jsapi;
+    if (NS_WARN_IF(!jsapi.Init(xpc::PrivilegedJunkScope()))) {
+      MOZ_CRASH();
+    }
+    JSContext* cx = jsapi.cx();
+
+    JS::Rooted<JS::Value> stack(cx);
+    ErrorResult rv;
+    data.Read(cx, &stack, rv);
+    if (rv.Failed() || !stack.isObject()) {
+      rv.SuppressException();
+      return IPC_OK();
+    }
+
+    JS::Rooted<JSObject*> stackObj(cx, &stack.toObject());
+    MOZ_ASSERT(JS::IsUnwrappedSavedFrame(stackObj));
+
+    JS::Rooted<JSObject*> stackGlobal(cx, JS::GetNonCCWObjectGlobal(stackObj));
+    msg = new nsScriptErrorWithStack(JS::NothingHandleValue, stackObj,
+                                     stackGlobal);
+  } else {
+    msg = new nsScriptError();
+  }
+
+  rv = msg->Init(aMessage, aSourceName, aSourceLine, aLineNumber, aColNumber,
+                 aFlags, aCategory, aFromPrivateWindow, aFromChromeContext);
+  if (NS_FAILED(rv)) return IPC_OK();
+
+  msg->SetIsForwardedFromContentProcess(true);
+
+  consoleService->LogMessageWithMode(msg, nsIConsoleService::SuppressLog);
+  return IPC_OK();
+}
+
+bool ContentParent::DoLoadMessageManagerScript(const nsAString& aURL,
+                                               bool aRunInGlobalScope) {
+  MOZ_ASSERT(!aRunInGlobalScope);
+  return SendLoadProcessScript(aURL);
+}
+
+nsresult ContentParent::DoSendAsyncMessage(const nsAString& aMessage,
+                                           StructuredCloneData& aHelper) {
+  ClonedMessageData data;
+  if (!BuildClonedMessageData(aHelper, data)) {
+    return NS_ERROR_DOM_DATA_CLONE_ERR;
+  }
+  if (!SendAsyncMessage(aMessage, data)) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  return NS_OK;
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvCopyFavicon(
+    nsIURI* aOldURI, nsIURI* aNewURI, const bool& aInPrivateBrowsing) {
+  if (!aOldURI) {
+    return IPC_FAIL(this, "aOldURI should not be null");
+  }
+  if (!aNewURI) {
+    return IPC_FAIL(this, "aNewURI should not be null");
+  }
+
+  nsDocShell::CopyFavicon(aOldURI, aNewURI, aInPrivateBrowsing);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvFindImageText(
+    IPCImage&& aImage, nsTArray<nsCString>&& aLanguages,
+    FindImageTextResolver&& aResolver) {
+  RefPtr<DataSourceSurface> surf =
+      nsContentUtils::IPCImageToSurface(std::move(aImage));
+  if (!surf) {
+    aResolver(TextRecognitionResultOrError("Failed to read image"_ns));
+    return IPC_OK();
+  }
+  TextRecognition::FindText(*surf, aLanguages)
+      ->Then(
+          GetCurrentSerialEventTarget(), __func__,
+          [resolver = std::move(aResolver)](
+              TextRecognition::NativePromise::ResolveOrRejectValue&& aValue) {
+            if (aValue.IsResolve()) {
+              resolver(TextRecognitionResultOrError(aValue.ResolveValue()));
+            } else {
+              resolver(TextRecognitionResultOrError(aValue.RejectValue()));
+            }
+          });
+  return IPC_OK();
+}
+
+bool ContentParent::ShouldContinueFromReplyTimeout() {
+  RefPtr<ProcessHangMonitor> monitor = ProcessHangMonitor::Get();
+  return !monitor || !monitor->ShouldTimeOutCPOWs();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvRecordingDeviceEvents(
+    const nsAString& aRecordingStatus, const nsAString& aPageURL,
+    const bool& aIsAudio, const bool& aIsVideo) {
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    // recording-device-ipc-events needs to gather more information from content
+    // process
+    RefPtr<nsHashPropertyBag> props = new nsHashPropertyBag();
+    props->SetPropertyAsUint64(u"childID"_ns, ChildID());
+    props->SetPropertyAsBool(u"isAudio"_ns, aIsAudio);
+    props->SetPropertyAsBool(u"isVideo"_ns, aIsVideo);
+    props->SetPropertyAsAString(u"requestURL"_ns, aPageURL);
+
+    obs->NotifyObservers((nsIPropertyBag2*)props, "recording-device-ipc-events",
+                         PromiseFlatString(aRecordingStatus).get());
+  } else {
+    NS_WARNING(
+        "Could not get the Observer service for "
+        "ContentParent::RecvRecordingDeviceEvents.");
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvAddIdleObserver(
+    const uint64_t& aObserver, const uint32_t& aIdleTimeInS) {
+  nsresult rv;
+  nsCOMPtr<nsIUserIdleService> idleService =
+      do_GetService("@mozilla.org/widget/useridleservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, IPC_FAIL(this, "Failed to get UserIdleService."));
+
+  RefPtr<ParentIdleListener> listener =
+      new ParentIdleListener(this, aObserver, aIdleTimeInS);
+  rv = idleService->AddIdleObserver(listener, aIdleTimeInS);
+  NS_ENSURE_SUCCESS(rv, IPC_FAIL(this, "AddIdleObserver failed."));
+  mIdleListeners.AppendElement(listener);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvRemoveIdleObserver(
+    const uint64_t& aObserver, const uint32_t& aIdleTimeInS) {
+  RefPtr<ParentIdleListener> listener;
+  for (int32_t i = mIdleListeners.Length() - 1; i >= 0; --i) {
+    listener = static_cast<ParentIdleListener*>(mIdleListeners[i].get());
+    if (listener->mObserver == aObserver && listener->mTime == aIdleTimeInS) {
+      nsresult rv;
+      nsCOMPtr<nsIUserIdleService> idleService =
+          do_GetService("@mozilla.org/widget/useridleservice;1", &rv);
+      NS_ENSURE_SUCCESS(rv, IPC_FAIL(this, "Failed to get UserIdleService."));
+      idleService->RemoveIdleObserver(listener, aIdleTimeInS);
+      mIdleListeners.RemoveElementAt(i);
+      break;
+    }
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvBackUpXResources(
+    const FileDescriptor& aXSocketFd) {
+#ifndef MOZ_X11
+  MOZ_CRASH("This message only makes sense on X11 platforms");
+#else
+  MOZ_ASSERT(0 > mChildXSocketFdDup.get(), "Already backed up X resources??");
+  if (aXSocketFd.IsValid()) {
+    auto rawFD = aXSocketFd.ClonePlatformHandle();
+    mChildXSocketFdDup.reset(rawFD.release());
+  }
+#endif
+  return IPC_OK();
+}
+
+class AnonymousTemporaryFileRequestor final : public Runnable {
+ public:
+  AnonymousTemporaryFileRequestor(ContentParent* aCP, const uint64_t& aID)
+      : Runnable("dom::AnonymousTemporaryFileRequestor"),
+        mCP(aCP),
+        mID(aID),
+        mRv(NS_OK),
+        mPRFD(nullptr) {}
+
+  NS_IMETHOD Run() override {
+    if (NS_IsMainThread()) {
+      FileDescOrError result;
+      if (NS_WARN_IF(NS_FAILED(mRv))) {
+        // Returning false will kill the child process; instead
+        // propagate the error and let the child handle it.
+        result = mRv;
+      } else {
+        result = FileDescriptor(FileDescriptor::PlatformHandleType(
+            PR_FileDesc2NativeHandle(mPRFD)));
+        // The FileDescriptor object owns a duplicate of the file handle; we
+        // must close the original (and clean up the NSPR descriptor).
+        PR_Close(mPRFD);
+      }
+      Unused << mCP->SendProvideAnonymousTemporaryFile(mID, result);
+      // It's important to release this reference while wr're on the main
+      // thread!
+      mCP = nullptr;
+    } else {
+      mRv = NS_OpenAnonymousTemporaryFile(&mPRFD);
+      NS_DispatchToMainThread(this);
+    }
+    return NS_OK;
+  }
+
+ private:
+  RefPtr<ContentParent> mCP;
+  uint64_t mID;
+  nsresult mRv;
+  PRFileDesc* mPRFD;
+};
+
+mozilla::ipc::IPCResult ContentParent::RecvRequestAnonymousTemporaryFile(
+    const uint64_t& aID) {
+  // Make sure to send a callback to the child if we bail out early.
+  nsresult rv = NS_OK;
+  RefPtr<ContentParent> self(this);
+  auto autoNotifyChildOnError = MakeScopeExit([&, self]() {
+    if (NS_FAILED(rv)) {
+      FileDescOrError result(rv);
+      Unused << self->SendProvideAnonymousTemporaryFile(aID, result);
+    }
+  });
+
+  // We use a helper runnable to open the anonymous temporary file on the IO
+  // thread.  The same runnable will call us back on the main thread when the
+  // file has been opened.
+  nsCOMPtr<nsIEventTarget> target =
+      do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv);
+  if (!target) {
+    return IPC_OK();
+  }
+
+  rv = target->Dispatch(new AnonymousTemporaryFileRequestor(this, aID),
+                        NS_DISPATCH_NORMAL);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return IPC_OK();
+  }
+
+  rv = NS_OK;
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvCreateAudioIPCConnection(
+    CreateAudioIPCConnectionResolver&& aResolver) {
+  FileDescriptor fd = CubebUtils::CreateAudioIPCConnection();
+  FileDescOrError result;
+  if (fd.IsValid()) {
+    result = fd;
+  } else {
+    result = NS_ERROR_FAILURE;
+  }
+  aResolver(std::move(result));
+  return IPC_OK();
+}
+
+already_AddRefed<extensions::PExtensionsParent>
+ContentParent::AllocPExtensionsParent() {
+  return MakeAndAddRef<extensions::ExtensionsParent>();
+}
+
+void ContentParent::NotifyUpdatedDictionaries() {
+  RefPtr<mozSpellChecker> spellChecker(mozSpellChecker::Create());
+  MOZ_ASSERT(spellChecker, "No spell checker?");
+
+  nsTArray<nsCString> dictionaries;
+  spellChecker->GetDictionaryList(&dictionaries);
+
+  for (auto* cp : AllProcesses(eLive)) {
+    Unused << cp->SendUpdateDictionaryList(dictionaries);
+  }
+}
+
+void ContentParent::NotifyUpdatedFonts(bool aFullRebuild) {
+  if (gfxPlatformFontList::PlatformFontList()->SharedFontList()) {
+    for (auto* cp : AllProcesses(eLive)) {
+      Unused << cp->SendRebuildFontList(aFullRebuild);
+    }
+    return;
+  }
+
+  SystemFontList fontList;
+  gfxPlatform::GetPlatform()->ReadSystemFontList(&fontList);
+
+  for (auto* cp : AllProcesses(eLive)) {
+    Unused << cp->SendUpdateFontList(fontList);
+  }
+}
+
+#ifdef MOZ_WEBRTC
+PWebrtcGlobalParent* ContentParent::AllocPWebrtcGlobalParent() {
+  return WebrtcGlobalParent::Alloc();
+}
+
+bool ContentParent::DeallocPWebrtcGlobalParent(PWebrtcGlobalParent* aActor) {
+  WebrtcGlobalParent::Dealloc(static_cast<WebrtcGlobalParent*>(aActor));
+  return true;
+}
+#endif
+
+void ContentParent::MaybeInvokeDragSession(BrowserParent* aParent) {
+  // dnd uses IPCBlob to transfer data to the content process and the IPC
+  // message is sent as normal priority. When sending input events with input
+  // priority, the message may be preempted by the later dnd events. To make
+  // sure the input events and the blob message are processed in time order
+  // on the content process, we temporarily send the input events with normal
+  // priority when there is an active dnd session.
+  SetInputPriorityEventEnabled(false);
+
+  nsCOMPtr<nsIDragService> dragService =
+      do_GetService("@mozilla.org/widget/dragservice;1");
+  if (dragService && dragService->MaybeAddChildProcess(this)) {
+    // We need to send transferable data to child process.
+    nsCOMPtr<nsIDragSession> session;
+    dragService->GetCurrentSession(getter_AddRefs(session));
+    if (session) {
+      nsTArray<IPCTransferableData> ipcTransferables;
+      RefPtr<DataTransfer> transfer = session->GetDataTransfer();
+      if (!transfer) {
+        // Pass eDrop to get DataTransfer with external
+        // drag formats cached.
+        transfer = new DataTransfer(nullptr, eDrop, true, -1);
+        session->SetDataTransfer(transfer);
+      }
+      // Note, even though this fills the DataTransfer object with
+      // external data, the data is usually transfered over IPC lazily when
+      // needed.
+      transfer->FillAllExternalData();
+      nsCOMPtr<nsILoadContext> lc =
+          aParent ? aParent->GetLoadContext() : nullptr;
+      nsCOMPtr<nsIArray> transferables = transfer->GetTransferables(lc);
+      nsContentUtils::TransferablesToIPCTransferableDatas(
+          transferables, ipcTransferables, false, this);
+      uint32_t action;
+      session->GetDragAction(&action);
+
+      RefPtr<WindowContext> sourceWC;
+      session->GetSourceWindowContext(getter_AddRefs(sourceWC));
+      RefPtr<WindowContext> sourceTopWC;
+      session->GetSourceTopWindowContext(getter_AddRefs(sourceTopWC));
+      mozilla::Unused << SendInvokeDragSession(
+          sourceWC, sourceTopWC, std::move(ipcTransferables), action);
+    }
+  }
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvUpdateDropEffect(
+    const uint32_t& aDragAction, const uint32_t& aDropEffect) {
+  nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession();
+  if (dragSession) {
+    dragSession->SetDragAction(aDragAction);
+    RefPtr<DataTransfer> dt = dragSession->GetDataTransfer();
+    if (dt) {
+      dt->SetDropEffectInt(aDropEffect);
+    }
+    dragSession->UpdateDragEffect();
+  }
+  return IPC_OK();
+}
+
+PContentPermissionRequestParent*
+ContentParent::AllocPContentPermissionRequestParent(
+    const nsTArray<PermissionRequest>& aRequests, nsIPrincipal* aPrincipal,
+    nsIPrincipal* aTopLevelPrincipal, const bool& aIsHandlingUserInput,
+    const bool& aMaybeUnsafePermissionDelegate, const TabId& aTabId) {
+  RefPtr<BrowserParent> tp;
+  ContentProcessManager* cpm = ContentProcessManager::GetSingleton();
+  if (cpm) {
+    tp =
+        cpm->GetTopLevelBrowserParentByProcessAndTabId(this->ChildID(), aTabId);
+  }
+  if (!tp) {
+    return nullptr;
+  }
+
+  nsIPrincipal* topPrincipal = aTopLevelPrincipal;
+  if (!topPrincipal) {
+    nsCOMPtr<nsIPrincipal> principal = tp->GetContentPrincipal();
+    topPrincipal = principal;
+  }
+  return nsContentPermissionUtils::CreateContentPermissionRequestParent(
+      aRequests, tp->GetOwnerElement(), aPrincipal, topPrincipal,
+      aIsHandlingUserInput, aMaybeUnsafePermissionDelegate, aTabId);
+}
+
+bool ContentParent::DeallocPContentPermissionRequestParent(
+    PContentPermissionRequestParent* actor) {
+  nsContentPermissionUtils::NotifyRemoveContentPermissionRequestParent(actor);
+  delete actor;
+  return true;
+}
+
+PWebBrowserPersistDocumentParent*
+ContentParent::AllocPWebBrowserPersistDocumentParent(
+    PBrowserParent* aBrowser, const MaybeDiscarded<BrowsingContext>& aContext) {
+  return new WebBrowserPersistDocumentParent();
+}
+
+bool ContentParent::DeallocPWebBrowserPersistDocumentParent(
+    PWebBrowserPersistDocumentParent* aActor) {
+  delete aActor;
+  return true;
+}
+
+mozilla::ipc::IPCResult ContentParent::CommonCreateWindow(
+    PBrowserParent* aThisTab, BrowsingContext& aParent, bool aSetOpener,
+    const uint32_t& aChromeFlags, const bool& aCalledFromJS,
+    const bool& aForPrinting, const bool& aForWindowDotPrint,
+    nsIURI* aURIToLoad, const nsACString& aFeatures,
+    BrowserParent* aNextRemoteBrowser, const nsAString& aName,
+    nsresult& aResult, nsCOMPtr<nsIRemoteTab>& aNewRemoteTab,
+    bool* aWindowIsNew, int32_t& aOpenLocation,
+    nsIPrincipal* aTriggeringPrincipal, nsIReferrerInfo* aReferrerInfo,
+    bool aLoadURI, nsIContentSecurityPolicy* aCsp,
+    const OriginAttributes& aOriginAttributes) {
+  // The content process should never be in charge of computing whether or
+  // not a window should be private - the parent will do that.
+  const uint32_t badFlags = nsIWebBrowserChrome::CHROME_PRIVATE_WINDOW |
+                            nsIWebBrowserChrome::CHROME_NON_PRIVATE_WINDOW |
+                            nsIWebBrowserChrome::CHROME_PRIVATE_LIFETIME;
+  if (!!(aChromeFlags & badFlags)) {
+    return IPC_FAIL(this, "Forbidden aChromeFlags passed");
+  }
+
+  RefPtr<nsOpenWindowInfo> openInfo = new nsOpenWindowInfo();
+  openInfo->mForceNoOpener = !aSetOpener;
+  openInfo->mParent = &aParent;
+  openInfo->mIsRemote = true;
+  openInfo->mIsForPrinting = aForPrinting;
+  openInfo->mIsForWindowDotPrint = aForWindowDotPrint;
+  openInfo->mNextRemoteBrowser = aNextRemoteBrowser;
+  openInfo->mOriginAttributes = aOriginAttributes;
+
+  MOZ_ASSERT_IF(aForWindowDotPrint, aForPrinting);
+
+  RefPtr<BrowserParent> topParent = BrowserParent::GetFrom(aThisTab);
+  while (topParent && topParent->GetBrowserBridgeParent()) {
+    topParent = topParent->GetBrowserBridgeParent()->Manager();
+  }
+  RefPtr<BrowserHost> thisBrowserHost =
+      topParent ? topParent->GetBrowserHost() : nullptr;
+  MOZ_ASSERT_IF(topParent, thisBrowserHost);
+  RefPtr<BrowsingContext> topBC =
+      topParent ? topParent->GetBrowsingContext() : nullptr;
+  MOZ_ASSERT_IF(topParent, topBC);
+
+  // The content process should have set its remote and fission flags correctly.
+  if (topBC) {
+    if ((!!(aChromeFlags & nsIWebBrowserChrome::CHROME_REMOTE_WINDOW) !=
+         topBC->UseRemoteTabs()) ||
+        (!!(aChromeFlags & nsIWebBrowserChrome::CHROME_FISSION_WINDOW) !=
+         topBC->UseRemoteSubframes())) {
+      return IPC_FAIL(this, "Unexpected aChromeFlags passed");
+    }
+
+    if (!aOriginAttributes.EqualsIgnoringFPD(topBC->OriginAttributesRef())) {
+      return IPC_FAIL(this, "Passed-in OriginAttributes does not match opener");
+    }
+  }
+
+  nsCOMPtr<nsIContent> frame;
+  if (topParent) {
+    frame = topParent->GetOwnerElement();
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> outerWin;
+  if (frame) {
+    outerWin = frame->OwnerDoc()->GetWindow();
+
+    // If our chrome window is in the process of closing, don't try to open a
+    // new tab in it.
+    if (outerWin && outerWin->Closed()) {
+      outerWin = nullptr;
+    }
+  }
+
+  nsCOMPtr<nsIBrowserDOMWindow> browserDOMWin;
+  if (topParent) {
+    browserDOMWin = topParent->GetBrowserDOMWindow();
+  }
+
+  // If we haven't found a chrome window to open in, just use the most recently
+  // opened one.
+  if (!outerWin) {
+    outerWin = nsContentUtils::GetMostRecentNonPBWindow();
+    if (NS_WARN_IF(!outerWin)) {
+      aResult = NS_ERROR_FAILURE;
+      return IPC_OK();
+    }
+
+    nsCOMPtr<nsIDOMChromeWindow> rootChromeWin = do_QueryInterface(outerWin);
+    if (rootChromeWin) {
+      rootChromeWin->GetBrowserDOMWindow(getter_AddRefs(browserDOMWin));
+    }
+  }
+
+  aOpenLocation = nsWindowWatcher::GetWindowOpenLocation(
+      outerWin, aChromeFlags, aCalledFromJS, aForPrinting);
+
+  MOZ_ASSERT(aOpenLocation == nsIBrowserDOMWindow::OPEN_NEWTAB ||
+             aOpenLocation == nsIBrowserDOMWindow::OPEN_NEWWINDOW ||
+             aOpenLocation == nsIBrowserDOMWindow::OPEN_PRINT_BROWSER);
+
+  if (NS_WARN_IF(!browserDOMWin)) {
+    // Opening in the same window or headless requires an nsIBrowserDOMWindow.
+    aOpenLocation = nsIBrowserDOMWindow::OPEN_NEWWINDOW;
+  }
+
+  if (aOpenLocation == nsIBrowserDOMWindow::OPEN_NEWTAB ||
+      aOpenLocation == nsIBrowserDOMWindow::OPEN_PRINT_BROWSER) {
+    RefPtr<Element> openerElement = do_QueryObject(frame);
+
+    nsCOMPtr<nsIOpenURIInFrameParams> params =
+        new nsOpenURIInFrameParams(openInfo, openerElement);
+    params->SetReferrerInfo(aReferrerInfo);
+    MOZ_ASSERT(aTriggeringPrincipal, "need a valid triggeringPrincipal");
+    params->SetTriggeringPrincipal(aTriggeringPrincipal);
+    params->SetCsp(aCsp);
+
+    RefPtr<Element> el;
+
+    if (aLoadURI) {
+      aResult = browserDOMWin->OpenURIInFrame(aURIToLoad, params, aOpenLocation,
+                                              nsIBrowserDOMWindow::OPEN_NEW,
+                                              aName, getter_AddRefs(el));
+    } else {
+      aResult = browserDOMWin->CreateContentWindowInFrame(
+          aURIToLoad, params, aOpenLocation, nsIBrowserDOMWindow::OPEN_NEW,
+          aName, getter_AddRefs(el));
+    }
+    RefPtr<nsFrameLoaderOwner> frameLoaderOwner = do_QueryObject(el);
+    if (NS_SUCCEEDED(aResult) && frameLoaderOwner) {
+      RefPtr<nsFrameLoader> frameLoader = frameLoaderOwner->GetFrameLoader();
+      if (frameLoader) {
+        aNewRemoteTab = frameLoader->GetRemoteTab();
+        // At this point, it's possible the inserted frameloader hasn't gone
+        // through layout yet. To ensure that the dimensions that we send down
+        // when telling the frameloader to display will be correct (instead of
+        // falling back to a 10x10 default), we force layout if necessary to get
+        // the most up-to-date dimensions. See bug 1358712 for details.
+        frameLoader->ForceLayoutIfNecessary();
+      }
+    } else if (NS_SUCCEEDED(aResult) && !frameLoaderOwner) {
+      // Fall through to the normal window opening code path when there is no
+      // window which we can open a new tab in.
+      aOpenLocation = nsIBrowserDOMWindow::OPEN_NEWWINDOW;
+    } else {
+      *aWindowIsNew = false;
+    }
+
+    // If we didn't retarget our window open into a new window, we should return
+    // now.
+    if (aOpenLocation != nsIBrowserDOMWindow::OPEN_NEWWINDOW) {
+      return IPC_OK();
+    }
+  }
+
+  nsCOMPtr<nsPIWindowWatcher> pwwatch =
+      do_GetService(NS_WINDOWWATCHER_CONTRACTID, &aResult);
+  if (NS_WARN_IF(NS_FAILED(aResult))) {
+    return IPC_OK();
+  }
+
+  WindowFeatures features;
+  features.Tokenize(aFeatures);
+
+  aResult = pwwatch->OpenWindowWithRemoteTab(
+      thisBrowserHost, features, aCalledFromJS, aParent.FullZoom(), openInfo,
+      getter_AddRefs(aNewRemoteTab));
+  if (NS_WARN_IF(NS_FAILED(aResult))) {
+    return IPC_OK();
+  }
+
+  MOZ_ASSERT(aNewRemoteTab);
+  RefPtr<BrowserHost> newBrowserHost = BrowserHost::GetFrom(aNewRemoteTab);
+  RefPtr<BrowserParent> newBrowserParent = newBrowserHost->GetActor();
+
+  // At this point, it's possible the inserted frameloader hasn't gone through
+  // layout yet. To ensure that the dimensions that we send down when telling
+  // the frameloader to display will be correct (instead of falling back to a
+  // 10x10 default), we force layout if necessary to get the most up-to-date
+  // dimensions. See bug 1358712 for details.
+  nsCOMPtr<Element> frameElement = newBrowserHost->GetOwnerElement();
+  MOZ_ASSERT(frameElement);
+  if (nsWindowWatcher::HaveSpecifiedSize(features)) {
+    // We want to flush the layout anyway because of the resize to the specified
+    // size. (Bug 1793605).
+    RefPtr<Document> chromeDoc = frameElement->OwnerDoc();
+    MOZ_ASSERT(chromeDoc);
+    chromeDoc->FlushPendingNotifications(FlushType::Layout);
+  } else {
+    RefPtr<nsFrameLoaderOwner> frameLoaderOwner = do_QueryObject(frameElement);
+    MOZ_ASSERT(frameLoaderOwner);
+    RefPtr<nsFrameLoader> frameLoader = frameLoaderOwner->GetFrameLoader();
+    MOZ_ASSERT(frameLoader);
+    frameLoader->ForceLayoutIfNecessary();
+  }
+
+  // If we were passed a name for the window which would override the default,
+  // we should send it down to the new tab.
+  if (nsContentUtils::IsOverridingWindowName(aName)) {
+    MOZ_ALWAYS_SUCCEEDS(newBrowserHost->GetBrowsingContext()->SetName(aName));
+  }
+
+  MOZ_ASSERT(newBrowserHost->GetBrowsingContext()->OriginAttributesRef() ==
+             aOriginAttributes);
+
+  if (aURIToLoad && aLoadURI) {
+    nsCOMPtr<mozIDOMWindowProxy> openerWindow;
+    if (aSetOpener && topParent) {
+      openerWindow = topParent->GetParentWindowOuter();
+    }
+    nsCOMPtr<nsIBrowserDOMWindow> newBrowserDOMWin =
+        newBrowserParent->GetBrowserDOMWindow();
+    if (NS_WARN_IF(!newBrowserDOMWin)) {
+      aResult = NS_ERROR_ABORT;
+      return IPC_OK();
+    }
+    RefPtr<BrowsingContext> bc;
+    aResult = newBrowserDOMWin->OpenURI(
+        aURIToLoad, openInfo, nsIBrowserDOMWindow::OPEN_CURRENTWINDOW,
+        nsIBrowserDOMWindow::OPEN_NEW, aTriggeringPrincipal, aCsp,
+        getter_AddRefs(bc));
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvCreateWindow(
+    PBrowserParent* aThisTab, const MaybeDiscarded<BrowsingContext>& aParent,
+    PBrowserParent* aNewTab, const uint32_t& aChromeFlags,
+    const bool& aCalledFromJS, const bool& aForPrinting,
+    const bool& aForPrintPreview, nsIURI* aURIToLoad,
+    const nsACString& aFeatures, nsIPrincipal* aTriggeringPrincipal,
+    nsIContentSecurityPolicy* aCsp, nsIReferrerInfo* aReferrerInfo,
+    const OriginAttributes& aOriginAttributes,
+    CreateWindowResolver&& aResolve) {
+  if (!aTriggeringPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  if (!ValidatePrincipal(aTriggeringPrincipal)) {
+    LogAndAssertFailedPrincipalValidationInfo(aTriggeringPrincipal, __func__);
+  }
+
+  nsresult rv = NS_OK;
+  CreatedWindowInfo cwi;
+
+  // We always expect to open a new window here. If we don't, it's an error.
+  cwi.windowOpened() = true;
+  cwi.maxTouchPoints() = 0;
+
+  // Make sure to resolve the resolver when this function exits, even if we
+  // failed to generate a valid response.
+  auto resolveOnExit = MakeScopeExit([&] {
+    // Copy over the nsresult, and then resolve.
+    cwi.rv() = rv;
+    aResolve(cwi);
+  });
+
+  RefPtr<BrowserParent> thisTab = BrowserParent::GetFrom(aThisTab);
+  RefPtr<BrowserParent> newTab = BrowserParent::GetFrom(aNewTab);
+  MOZ_ASSERT(newTab);
+
+  auto destroyNewTabOnError = MakeScopeExit([&] {
+    // We always expect to open a new window here. If we don't, it's an error.
+    if (!cwi.windowOpened() || NS_FAILED(rv)) {
+      if (newTab) {
+        newTab->Destroy();
+      }
+    }
+  });
+
+  // Don't continue to try to create a new window if we've been fully discarded.
+  RefPtr<BrowsingContext> parent = aParent.GetMaybeDiscarded();
+  if (NS_WARN_IF(!parent)) {
+    rv = NS_ERROR_FAILURE;
+    return IPC_OK();
+  }
+
+  // Validate that our new BrowsingContext looks as we would expect it.
+  RefPtr<BrowsingContext> newBC = newTab->GetBrowsingContext();
+  if (!newBC) {
+    return IPC_FAIL(this, "Missing BrowsingContext for new tab");
+  }
+
+  uint64_t newBCOpenerId = newBC->GetOpenerId();
+  if (newBCOpenerId != 0 && parent->Id() != newBCOpenerId) {
+    return IPC_FAIL(this, "Invalid opener BrowsingContext for new tab");
+  }
+  if (newBC->GetParent() != nullptr) {
+    return IPC_FAIL(this,
+                    "Unexpected non-toplevel BrowsingContext for new tab");
+  }
+  if (!!(aChromeFlags & nsIWebBrowserChrome::CHROME_REMOTE_WINDOW) !=
+          newBC->UseRemoteTabs() ||
+      !!(aChromeFlags & nsIWebBrowserChrome::CHROME_FISSION_WINDOW) !=
+          newBC->UseRemoteSubframes()) {
+    return IPC_FAIL(this, "Unexpected aChromeFlags passed");
+  }
+  if (!aOriginAttributes.EqualsIgnoringFPD(newBC->OriginAttributesRef())) {
+    return IPC_FAIL(this, "Opened tab has mismatched OriginAttributes");
+  }
+
+  if (thisTab && BrowserParent::GetFrom(thisTab)->GetBrowsingContext()) {
+    BrowsingContext* thisTabBC = thisTab->GetBrowsingContext();
+    if (thisTabBC->UseRemoteTabs() != newBC->UseRemoteTabs() ||
+        thisTabBC->UseRemoteSubframes() != newBC->UseRemoteSubframes() ||
+        thisTabBC->UsePrivateBrowsing() != newBC->UsePrivateBrowsing()) {
+      return IPC_FAIL(this, "New BrowsingContext has mismatched LoadContext");
+    }
+  }
+  BrowserParent::AutoUseNewTab aunt(newTab);
+
+  nsCOMPtr<nsIRemoteTab> newRemoteTab;
+  int32_t openLocation = nsIBrowserDOMWindow::OPEN_NEWWINDOW;
+  mozilla::ipc::IPCResult ipcResult = CommonCreateWindow(
+      aThisTab, *parent, newBCOpenerId != 0, aChromeFlags, aCalledFromJS,
+      aForPrinting, aForPrintPreview, aURIToLoad, aFeatures, newTab,
+      VoidString(), rv, newRemoteTab, &cwi.windowOpened(), openLocation,
+      aTriggeringPrincipal, aReferrerInfo, /* aLoadUri = */ false, aCsp,
+      aOriginAttributes);
+  if (!ipcResult) {
+    return ipcResult;
+  }
+
+  if (NS_WARN_IF(NS_FAILED(rv)) || !newRemoteTab) {
+    return IPC_OK();
+  }
+
+  MOZ_ASSERT(BrowserHost::GetFrom(newRemoteTab.get()) ==
+             newTab->GetBrowserHost());
+
+  // This used to happen in the child - there may now be a better place to
+  // do this work.
+  MOZ_ALWAYS_SUCCEEDS(
+      newBC->SetHasSiblings(openLocation == nsIBrowserDOMWindow::OPEN_NEWTAB));
+
+  newTab->SwapFrameScriptsFrom(cwi.frameScripts());
+  newTab->MaybeShowFrame();
+
+  nsCOMPtr<nsIWidget> widget = newTab->GetWidget();
+  if (widget) {
+    cwi.dimensions() = newTab->GetDimensionInfo();
+  }
+
+  cwi.maxTouchPoints() = newTab->GetMaxTouchPoints();
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvCreateWindowInDifferentProcess(
+    PBrowserParent* aThisTab, const MaybeDiscarded<BrowsingContext>& aParent,
+    const uint32_t& aChromeFlags, const bool& aCalledFromJS, nsIURI* aURIToLoad,
+    const nsACString& aFeatures, const nsAString& aName,
+    nsIPrincipal* aTriggeringPrincipal, nsIContentSecurityPolicy* aCsp,
+    nsIReferrerInfo* aReferrerInfo, const OriginAttributes& aOriginAttributes) {
+  MOZ_DIAGNOSTIC_ASSERT(!nsContentUtils::IsSpecialName(aName));
+
+  // Don't continue to try to create a new window if we've been fully discarded.
+  RefPtr<BrowsingContext> parent = aParent.GetMaybeDiscarded();
+  if (NS_WARN_IF(!parent)) {
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsIRemoteTab> newRemoteTab;
+  bool windowIsNew;
+  int32_t openLocation = nsIBrowserDOMWindow::OPEN_NEWWINDOW;
+
+  // If we have enough data, check the schemes of the loader and loadee
+  // to make sure they make sense.
+  if (aURIToLoad && aURIToLoad->SchemeIs("file") &&
+      GetRemoteType() != FILE_REMOTE_TYPE &&
+      Preferences::GetBool("browser.tabs.remote.enforceRemoteTypeRestrictions",
+                           false)) {
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+#  ifdef DEBUG
+    nsAutoCString uriToLoadStr;
+    nsAutoCString triggeringUriStr;
+    aURIToLoad->GetAsciiSpec(uriToLoadStr);
+    aTriggeringPrincipal->GetAsciiSpec(triggeringUriStr);
+
+    NS_WARNING(nsPrintfCString(
+                   "RecvCreateWindowInDifferentProcess blocked loading file "
+                   "scheme from non-file remotetype: %s tried to load %s",
+                   triggeringUriStr.get(), uriToLoadStr.get())
+                   .get());
+#  endif
+    MOZ_CRASH(
+        "RecvCreateWindowInDifferentProcess blocked loading improper scheme");
+#endif
+    return IPC_OK();
+  }
+
+  nsresult rv;
+  mozilla::ipc::IPCResult ipcResult = CommonCreateWindow(
+      aThisTab, *parent, /* aSetOpener = */ false, aChromeFlags, aCalledFromJS,
+      /* aForPrinting = */ false,
+      /* aForPrintPreview = */ false, aURIToLoad, aFeatures,
+      /* aNextRemoteBrowser = */ nullptr, aName, rv, newRemoteTab, &windowIsNew,
+      openLocation, aTriggeringPrincipal, aReferrerInfo,
+      /* aLoadUri = */ true, aCsp, aOriginAttributes);
+  if (!ipcResult) {
+    return ipcResult;
+  }
+
+  if (NS_FAILED(rv)) {
+    NS_WARNING("Call to CommonCreateWindow failed.");
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvShutdownProfile(
+    const nsACString& aProfile) {
+  profiler_received_exit_profile(aProfile);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvShutdownPerfStats(
+    const nsACString& aPerfStats) {
+  PerfStats::StorePerfStats(this, aPerfStats);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvGetGraphicsDeviceInitData(
+    ContentDeviceData* aOut) {
+  gfxPlatform::GetPlatform()->BuildContentDeviceData(aOut);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvGetOutputColorProfileData(
+    nsTArray<uint8_t>* aOutputColorProfileData) {
+  (*aOutputColorProfileData) =
+      gfxPlatform::GetPlatform()->GetPlatformCMSOutputProfileData();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvGetFontListShmBlock(
+    const uint32_t& aGeneration, const uint32_t& aIndex,
+    base::SharedMemoryHandle* aOut) {
+  auto* fontList = gfxPlatformFontList::PlatformFontList();
+  MOZ_RELEASE_ASSERT(fontList, "gfxPlatformFontList not initialized?");
+  fontList->ShareFontListShmBlockToProcess(aGeneration, aIndex, Pid(), aOut);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvInitializeFamily(
+    const uint32_t& aGeneration, const uint32_t& aFamilyIndex,
+    const bool& aLoadCmaps) {
+  auto* fontList = gfxPlatformFontList::PlatformFontList();
+  MOZ_RELEASE_ASSERT(fontList, "gfxPlatformFontList not initialized?");
+  fontList->InitializeFamily(aGeneration, aFamilyIndex, aLoadCmaps);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSetCharacterMap(
+    const uint32_t& aGeneration, const mozilla::fontlist::Pointer& aFacePtr,
+    const gfxSparseBitSet& aMap) {
+  auto* fontList = gfxPlatformFontList::PlatformFontList();
+  MOZ_RELEASE_ASSERT(fontList, "gfxPlatformFontList not initialized?");
+  fontList->SetCharacterMap(aGeneration, aFacePtr, aMap);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvInitOtherFamilyNames(
+    const uint32_t& aGeneration, const bool& aDefer, bool* aLoaded) {
+  auto* fontList = gfxPlatformFontList::PlatformFontList();
+  MOZ_RELEASE_ASSERT(fontList, "gfxPlatformFontList not initialized?");
+  *aLoaded = fontList->InitOtherFamilyNames(aGeneration, aDefer);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSetupFamilyCharMap(
+    const uint32_t& aGeneration, const mozilla::fontlist::Pointer& aFamilyPtr) {
+  auto* fontList = gfxPlatformFontList::PlatformFontList();
+  MOZ_RELEASE_ASSERT(fontList, "gfxPlatformFontList not initialized?");
+  fontList->SetupFamilyCharMap(aGeneration, aFamilyPtr);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvStartCmapLoading(
+    const uint32_t& aGeneration, const uint32_t& aStartIndex) {
+  auto* fontList = gfxPlatformFontList::PlatformFontList();
+  MOZ_RELEASE_ASSERT(fontList, "gfxPlatformFontList not initialized?");
+  fontList->StartCmapLoading(aGeneration, aStartIndex);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvGetHyphDict(
+    nsIURI* aURI, base::SharedMemoryHandle* aOutHandle, uint32_t* aOutSize) {
+  if (!aURI) {
+    return IPC_FAIL(this, "aURI must not be null.");
+  }
+  nsHyphenationManager::Instance()->ShareHyphDictToProcess(
+      aURI, Pid(), aOutHandle, aOutSize);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvGraphicsError(
+    const nsACString& aError) {
+  if (gfx::LogForwarder* lf = gfx::Factory::GetLogForwarder()) {
+    std::stringstream message;
+    message << "CP+" << aError;
+    lf->UpdateStringsVector(message.str());
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvBeginDriverCrashGuard(
+    const uint32_t& aGuardType, bool* aOutCrashed) {
+  // Only one driver crash guard should be active at a time, per-process.
+  MOZ_ASSERT(!mDriverCrashGuard);
+
+  UniquePtr<gfx::DriverCrashGuard> guard;
+  switch (gfx::CrashGuardType(aGuardType)) {
+    case gfx::CrashGuardType::D3D11Layers:
+      guard = MakeUnique<gfx::D3D11LayersCrashGuard>(this);
+      break;
+    case gfx::CrashGuardType::GLContext:
+      guard = MakeUnique<gfx::GLContextCrashGuard>(this);
+      break;
+    case gfx::CrashGuardType::WMFVPXVideo:
+      guard = MakeUnique<gfx::WMFVPXVideoCrashGuard>(this);
+      break;
+    default:
+      return IPC_FAIL(this, "unknown crash guard type");
+  }
+
+  if (guard->Crashed()) {
+    *aOutCrashed = true;
+    return IPC_OK();
+  }
+
+  *aOutCrashed = false;
+  mDriverCrashGuard = std::move(guard);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvEndDriverCrashGuard(
+    const uint32_t& aGuardType) {
+  mDriverCrashGuard = nullptr;
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvNotifyBenchmarkResult(
+    const nsAString& aCodecName, const uint32_t& aDecodeFPS)
+
+{
+  if (aCodecName.EqualsLiteral("VP9")) {
+    Preferences::SetUint(VP9Benchmark::sBenchmarkFpsPref, aDecodeFPS);
+    Preferences::SetUint(VP9Benchmark::sBenchmarkFpsVersionCheck,
+                         VP9Benchmark::sBenchmarkVersionID);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvNotifyPushObservers(
+    const nsACString& aScope, nsIPrincipal* aPrincipal,
+    const nsAString& aMessageId) {
+  if (!aPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  if (!ValidatePrincipal(aPrincipal)) {
+    LogAndAssertFailedPrincipalValidationInfo(aPrincipal, __func__);
+  }
+  PushMessageDispatcher dispatcher(aScope, aPrincipal, aMessageId, Nothing());
+  Unused << NS_WARN_IF(NS_FAILED(dispatcher.NotifyObserversAndWorkers()));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvNotifyPushObserversWithData(
+    const nsACString& aScope, nsIPrincipal* aPrincipal,
+    const nsAString& aMessageId, nsTArray<uint8_t>&& aData) {
+  if (!aPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  if (!ValidatePrincipal(aPrincipal)) {
+    LogAndAssertFailedPrincipalValidationInfo(aPrincipal, __func__);
+  }
+  PushMessageDispatcher dispatcher(aScope, aPrincipal, aMessageId,
+                                   Some(std::move(aData)));
+  Unused << NS_WARN_IF(NS_FAILED(dispatcher.NotifyObserversAndWorkers()));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+ContentParent::RecvNotifyPushSubscriptionChangeObservers(
+    const nsACString& aScope, nsIPrincipal* aPrincipal) {
+  if (!aPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  if (!ValidatePrincipal(aPrincipal)) {
+    LogAndAssertFailedPrincipalValidationInfo(aPrincipal, __func__);
+  }
+  PushSubscriptionChangeDispatcher dispatcher(aScope, aPrincipal);
+  Unused << NS_WARN_IF(NS_FAILED(dispatcher.NotifyObserversAndWorkers()));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvPushError(const nsACString& aScope,
+                                                     nsIPrincipal* aPrincipal,
+                                                     const nsAString& aMessage,
+                                                     const uint32_t& aFlags) {
+  if (!aPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  if (!ValidatePrincipal(aPrincipal)) {
+    LogAndAssertFailedPrincipalValidationInfo(aPrincipal, __func__);
+  }
+  PushErrorDispatcher dispatcher(aScope, aPrincipal, aMessage, aFlags);
+  Unused << NS_WARN_IF(NS_FAILED(dispatcher.NotifyObserversAndWorkers()));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+ContentParent::RecvNotifyPushSubscriptionModifiedObservers(
+    const nsACString& aScope, nsIPrincipal* aPrincipal) {
+  if (!aPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  if (!ValidatePrincipal(aPrincipal)) {
+    LogAndAssertFailedPrincipalValidationInfo(aPrincipal, __func__);
+  }
+  PushSubscriptionModifiedDispatcher dispatcher(aScope, aPrincipal);
+  Unused << NS_WARN_IF(NS_FAILED(dispatcher.NotifyObservers()));
+  return IPC_OK();
+}
+
+/* static */
+void ContentParent::BroadcastBlobURLRegistration(
+    const nsACString& aURI, BlobImpl* aBlobImpl, nsIPrincipal* aPrincipal,
+    const Maybe<nsID>& aAgentClusterId, ContentParent* aIgnoreThisCP) {
+  uint64_t originHash = ComputeLoadedOriginHash(aPrincipal);
+
+  bool toBeSent =
+      BlobURLProtocolHandler::IsBlobURLBroadcastPrincipal(aPrincipal);
+
+  nsCString uri(aURI);
+
+  for (auto* cp : AllProcesses(eLive)) {
+    if (cp != aIgnoreThisCP) {
+      if (!toBeSent && !cp->mLoadedOriginHashes.Contains(originHash)) {
+        continue;
+      }
+
+      nsresult rv = cp->TransmitPermissionsForPrincipal(aPrincipal);
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        break;
+      }
+
+      IPCBlob ipcBlob;
+      rv = IPCBlobUtils::Serialize(aBlobImpl, ipcBlob);
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        break;
+      }
+
+      Unused << cp->SendBlobURLRegistration(uri, ipcBlob, aPrincipal,
+                                            aAgentClusterId);
+    }
+  }
+}
+
+/* static */
+void ContentParent::BroadcastBlobURLUnregistration(
+    const nsACString& aURI, nsIPrincipal* aPrincipal,
+    ContentParent* aIgnoreThisCP) {
+  uint64_t originHash = ComputeLoadedOriginHash(aPrincipal);
+
+  bool toBeSent =
+      BlobURLProtocolHandler::IsBlobURLBroadcastPrincipal(aPrincipal);
+
+  nsCString uri(aURI);
+
+  for (auto* cp : AllProcesses(eLive)) {
+    if (cp != aIgnoreThisCP &&
+        (toBeSent || cp->mLoadedOriginHashes.Contains(originHash))) {
+      Unused << cp->SendBlobURLUnregistration(uri);
+    }
+  }
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvStoreAndBroadcastBlobURLRegistration(
+    const nsACString& aURI, const IPCBlob& aBlob, nsIPrincipal* aPrincipal,
+    const Maybe<nsID>& aAgentClusterId) {
+  if (!aPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  if (!ValidatePrincipal(aPrincipal, {ValidatePrincipalOptions::AllowSystem})) {
+    LogAndAssertFailedPrincipalValidationInfo(aPrincipal, __func__);
+  }
+  RefPtr<BlobImpl> blobImpl = IPCBlobUtils::Deserialize(aBlob);
+  if (NS_WARN_IF(!blobImpl)) {
+    return IPC_FAIL(this, "Blob deserialization failed.");
+  }
+
+  BlobURLProtocolHandler::AddDataEntry(aURI, aPrincipal, aAgentClusterId,
+                                       blobImpl);
+  BroadcastBlobURLRegistration(aURI, blobImpl, aPrincipal, aAgentClusterId,
+                               this);
+
+  // We want to store this blobURL, so we can unregister it if the child
+  // crashes.
+  mBlobURLs.AppendElement(aURI);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+ContentParent::RecvUnstoreAndBroadcastBlobURLUnregistration(
+    const nsACString& aURI, nsIPrincipal* aPrincipal) {
+  if (!aPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  if (!ValidatePrincipal(aPrincipal, {ValidatePrincipalOptions::AllowSystem})) {
+    LogAndAssertFailedPrincipalValidationInfo(aPrincipal, __func__);
+  }
+  BlobURLProtocolHandler::RemoveDataEntry(aURI, false /* Don't broadcast */);
+  BroadcastBlobURLUnregistration(aURI, aPrincipal, this);
+  mBlobURLs.RemoveElement(aURI);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvGetFilesRequest(
+    const nsID& aUUID, const nsAString& aDirectoryPath,
+    const bool& aRecursiveFlag) {
+  MOZ_ASSERT(!mGetFilesPendingRequests.GetWeak(aUUID));
+
+  if (!mozilla::Preferences::GetBool("dom.filesystem.pathcheck.disabled",
+                                     false)) {
+    RefPtr<FileSystemSecurity> fss = FileSystemSecurity::Get();
+    if (!fss) {
+      return IPC_FAIL(this, "Failed to get FileSystemSecurity.");
+    }
+
+    if (!fss->ContentProcessHasAccessTo(ChildID(), aDirectoryPath)) {
+      return IPC_FAIL(this, "ContentProcessHasAccessTo failed.");
+    }
+  }
+
+  ErrorResult rv;
+  RefPtr<GetFilesHelper> helper = GetFilesHelperParent::Create(
+      aUUID, aDirectoryPath, aRecursiveFlag, this, rv);
+
+  if (NS_WARN_IF(rv.Failed())) {
+    if (!SendGetFilesResponse(aUUID,
+                              GetFilesResponseFailure(rv.StealNSResult()))) {
+      return IPC_FAIL(this, "SendGetFilesResponse failed.");
+    }
+    return IPC_OK();
+  }
+
+  mGetFilesPendingRequests.InsertOrUpdate(aUUID, std::move(helper));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvDeleteGetFilesRequest(
+    const nsID& aUUID) {
+  mGetFilesPendingRequests.Remove(aUUID);
+  return IPC_OK();
+}
+
+void ContentParent::SendGetFilesResponseAndForget(
+    const nsID& aUUID, const GetFilesResponseResult& aResult) {
+  if (mGetFilesPendingRequests.Remove(aUUID)) {
+    Unused << SendGetFilesResponse(aUUID, aResult);
+  }
+}
+
+void ContentParent::PaintTabWhileInterruptingJS(
+    BrowserParent* aBrowserParent, const layers::LayersObserverEpoch& aEpoch) {
+  if (!mHangMonitorActor) {
+    return;
+  }
+  ProcessHangMonitor::PaintWhileInterruptingJS(mHangMonitorActor,
+                                               aBrowserParent, aEpoch);
+}
+
+void ContentParent::UnloadLayersWhileInterruptingJS(
+    BrowserParent* aBrowserParent, const layers::LayersObserverEpoch& aEpoch) {
+  if (!mHangMonitorActor) {
+    return;
+  }
+  ProcessHangMonitor::UnloadLayersWhileInterruptingJS(mHangMonitorActor,
+                                                      aBrowserParent, aEpoch);
+}
+
+void ContentParent::CancelContentJSExecutionIfRunning(
+    BrowserParent* aBrowserParent, nsIRemoteTab::NavigationType aNavigationType,
+    const CancelContentJSOptions& aCancelContentJSOptions) {
+  if (!mHangMonitorActor) {
+    return;
+  }
+
+  ProcessHangMonitor::CancelContentJSExecutionIfRunning(
+      mHangMonitorActor, aBrowserParent, aNavigationType,
+      aCancelContentJSOptions);
+}
+
+void ContentParent::UpdateCookieStatus(nsIChannel* aChannel) {
+  PNeckoParent* neckoParent = LoneManagedOrNullAsserts(ManagedPNeckoParent());
+  PCookieServiceParent* csParent =
+      LoneManagedOrNullAsserts(neckoParent->ManagedPCookieServiceParent());
+  if (csParent) {
+    auto* cs = static_cast<CookieServiceParent*>(csParent);
+    cs->TrackCookieLoad(aChannel);
+  }
+}
+
+nsresult ContentParent::AboutToLoadHttpFtpDocumentForChild(
+    nsIChannel* aChannel, bool* aShouldWaitForPermissionCookieUpdate) {
+  MOZ_ASSERT(aChannel);
+
+  if (aShouldWaitForPermissionCookieUpdate) {
+    *aShouldWaitForPermissionCookieUpdate = false;
+  }
+
+  nsresult rv;
+  bool isDocument = aChannel->IsDocument();
+  if (!isDocument) {
+    // We may be looking at a nsIHttpChannel which has isMainDocumentChannel set
+    // (e.g. the internal http channel for a view-source: load.).
+    nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aChannel);
+    if (httpChannel) {
+      rv = httpChannel->GetIsMainDocumentChannel(&isDocument);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+  if (!isDocument) {
+    return NS_OK;
+  }
+
+  // Get the principal for the channel result, so that we can get the permission
+  // key for the document which will be created from this response.
+  nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
+  if (NS_WARN_IF(!ssm)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIPrincipal> principal;
+  nsCOMPtr<nsIPrincipal> partitionedPrincipal;
+  rv = ssm->GetChannelResultPrincipals(aChannel, getter_AddRefs(principal),
+                                       getter_AddRefs(partitionedPrincipal));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Let the caller know we're going to send main thread IPC for updating
+  // permisssions/cookies.
+  if (aShouldWaitForPermissionCookieUpdate) {
+    *aShouldWaitForPermissionCookieUpdate = true;
+  }
+
+  TransmitBlobURLsForPrincipal(principal);
+
+  // Tranmit permissions for both regular and partitioned principal so that the
+  // content process can get permissions for the partitioned principal. For
+  // example, the desk-notification permission for a partitioned service worker.
+  rv = TransmitPermissionsForPrincipal(principal);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = TransmitPermissionsForPrincipal(partitionedPrincipal);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsLoadFlags newLoadFlags;
+  aChannel->GetLoadFlags(&newLoadFlags);
+  if (newLoadFlags & nsIRequest::LOAD_DOCUMENT_NEEDS_COOKIE) {
+    UpdateCookieStatus(aChannel);
+  }
+
+  RefPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
+  RefPtr<BrowsingContext> browsingContext;
+  rv = loadInfo->GetTargetBrowsingContext(getter_AddRefs(browsingContext));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!NextGenLocalStorageEnabled()) {
+    return NS_OK;
+  }
+
+  if (principal->GetIsContentPrincipal()) {
+    nsCOMPtr<nsILocalStorageManager> lsm =
+        do_GetService("@mozilla.org/dom/localStorage-manager;1");
+    if (NS_WARN_IF(!lsm)) {
+      return NS_ERROR_FAILURE;
+    }
+
+    nsCOMPtr<nsIPrincipal> storagePrincipal;
+    rv = ssm->GetChannelResultStoragePrincipal(
+        aChannel, getter_AddRefs(storagePrincipal));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    RefPtr<Promise> dummy;
+    rv = lsm->Preload(storagePrincipal, nullptr, getter_AddRefs(dummy));
+    if (NS_FAILED(rv)) {
+      NS_WARNING("Failed to preload local storage!");
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult ContentParent::TransmitPermissionsForPrincipal(
+    nsIPrincipal* aPrincipal) {
+  // Create the key, and send it down to the content process.
+  nsTArray<std::pair<nsCString, nsCString>> pairs =
+      PermissionManager::GetAllKeysForPrincipal(aPrincipal);
+  MOZ_ASSERT(pairs.Length() >= 1);
+  for (auto& pair : pairs) {
+    EnsurePermissionsByKey(pair.first, pair.second);
+  }
+
+  return NS_OK;
+}
+
+void ContentParent::TransmitBlobURLsForPrincipal(nsIPrincipal* aPrincipal) {
+  // If we're already broadcasting BlobURLs with this principal, we don't need
+  // to send them here.
+  if (BlobURLProtocolHandler::IsBlobURLBroadcastPrincipal(aPrincipal)) {
+    return;
+  }
+
+  // We shouldn't have any Blob URLs with expanded principals, so transmit URLs
+  // for each principal in the AllowList instead.
+  if (nsCOMPtr<nsIExpandedPrincipal> ep = do_QueryInterface(aPrincipal)) {
+    for (const auto& prin : ep->AllowList()) {
+      TransmitBlobURLsForPrincipal(prin);
+    }
+    return;
+  }
+
+  uint64_t originHash = ComputeLoadedOriginHash(aPrincipal);
+
+  if (!mLoadedOriginHashes.Contains(originHash)) {
+    mLoadedOriginHashes.AppendElement(originHash);
+
+    nsTArray<BlobURLRegistrationData> registrations;
+    BlobURLProtocolHandler::ForEachBlobURL(
+        [&](BlobImpl* aBlobImpl, nsIPrincipal* aBlobPrincipal,
+            const Maybe<nsID>& aAgentClusterId, const nsACString& aURI,
+            bool aRevoked) {
+          // This check uses `ComputeLoadedOriginHash` to compare, rather than
+          // doing the more accurate `Equals` check, as it needs to match the
+          // behaviour of the logic to broadcast new registrations.
+          if (originHash != ComputeLoadedOriginHash(aBlobPrincipal)) {
+            return true;
+          }
+
+          IPCBlob ipcBlob;
+          nsresult rv = IPCBlobUtils::Serialize(aBlobImpl, ipcBlob);
+          if (NS_WARN_IF(NS_FAILED(rv))) {
+            return false;
+          }
+
+          registrations.AppendElement(
+              BlobURLRegistrationData(nsCString(aURI), ipcBlob, aBlobPrincipal,
+                                      aAgentClusterId, aRevoked));
+
+          rv = TransmitPermissionsForPrincipal(aBlobPrincipal);
+          Unused << NS_WARN_IF(NS_FAILED(rv));
+          return true;
+        });
+
+    if (!registrations.IsEmpty()) {
+      Unused << SendInitBlobURLs(registrations);
+    }
+  }
+}
+
+void ContentParent::TransmitBlobDataIfBlobURL(nsIURI* aURI) {
+  MOZ_ASSERT(aURI);
+
+  nsCOMPtr<nsIPrincipal> principal;
+  if (BlobURLProtocolHandler::GetBlobURLPrincipal(aURI,
+                                                  getter_AddRefs(principal))) {
+    TransmitBlobURLsForPrincipal(principal);
+  }
+}
+
+void ContentParent::EnsurePermissionsByKey(const nsACString& aKey,
+                                           const nsACString& aOrigin) {
+  // NOTE: Make sure to initialize the permission manager before updating the
+  // mActivePermissionKeys list. If the permission manager is being initialized
+  // by this call to GetPermissionManager, and we've added the key to
+  // mActivePermissionKeys, then the permission manager will send down a
+  // SendAddPermission before receiving the SendSetPermissionsWithKey message.
+  RefPtr<PermissionManager> permManager = PermissionManager::GetInstance();
+  if (!permManager) {
+    return;
+  }
+
+  if (!mActivePermissionKeys.EnsureInserted(aKey)) {
+    return;
+  }
+
+  nsTArray<IPC::Permission> perms;
+  if (permManager->GetPermissionsFromOriginOrKey(aOrigin, aKey, perms)) {
+    Unused << SendSetPermissionsWithKey(aKey, perms);
+  }
+}
+
+bool ContentParent::NeedsPermissionsUpdate(
+    const nsACString& aPermissionKey) const {
+  return mActivePermissionKeys.Contains(aPermissionKey);
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvAccumulateChildHistograms(
+    nsTArray<HistogramAccumulation>&& aAccumulations) {
+  TelemetryIPC::AccumulateChildHistograms(GetTelemetryProcessID(mRemoteType),
+                                          aAccumulations);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvAccumulateChildKeyedHistograms(
+    nsTArray<KeyedHistogramAccumulation>&& aAccumulations) {
+  TelemetryIPC::AccumulateChildKeyedHistograms(
+      GetTelemetryProcessID(mRemoteType), aAccumulations);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvUpdateChildScalars(
+    nsTArray<ScalarAction>&& aScalarActions) {
+  TelemetryIPC::UpdateChildScalars(GetTelemetryProcessID(mRemoteType),
+                                   aScalarActions);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvUpdateChildKeyedScalars(
+    nsTArray<KeyedScalarAction>&& aScalarActions) {
+  TelemetryIPC::UpdateChildKeyedScalars(GetTelemetryProcessID(mRemoteType),
+                                        aScalarActions);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvRecordChildEvents(
+    nsTArray<mozilla::Telemetry::ChildEventData>&& aEvents) {
+  TelemetryIPC::RecordChildEvents(GetTelemetryProcessID(mRemoteType), aEvents);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvRecordDiscardedData(
+    const mozilla::Telemetry::DiscardedData& aDiscardedData) {
+  TelemetryIPC::RecordDiscardedData(GetTelemetryProcessID(mRemoteType),
+                                    aDiscardedData);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvRecordPageLoadEvent(
+    const mozilla::glean::perf::PageLoadExtra& aPageLoadEventExtra) {
+  mozilla::glean::perf::page_load.Record(mozilla::Some(aPageLoadEventExtra));
+
+  // Send the PageLoadPing after every 30 page loads, or on startup.
+  if (++sPageLoadEventCounter >= 30) {
+    NS_SUCCEEDED(NS_DispatchToMainThreadQueue(
+        NS_NewRunnableFunction(
+            "PageLoadPingIdleTask",
+            [] { mozilla::glean_pings::Pageload.Submit("threshold"_ns); }),
+        EventQueuePriority::Idle));
+    sPageLoadEventCounter = 0;
+  }
+
+  return IPC_OK();
+}
+
+//////////////////////////////////////////////////////////////////
+// PURLClassifierParent
+
+PURLClassifierParent* ContentParent::AllocPURLClassifierParent(
+    nsIPrincipal* aPrincipal, bool* aSuccess) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  *aSuccess = true;
+  RefPtr<URLClassifierParent> actor = new URLClassifierParent();
+  return actor.forget().take();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvPURLClassifierConstructor(
+    PURLClassifierParent* aActor, nsIPrincipal* aPrincipal, bool* aSuccess) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aActor);
+  *aSuccess = false;
+
+  auto* actor = static_cast<URLClassifierParent*>(aActor);
+  nsCOMPtr<nsIPrincipal> principal(aPrincipal);
+  if (!principal) {
+    actor->ClassificationFailed();
+    return IPC_OK();
+  }
+  if (!ValidatePrincipal(aPrincipal)) {
+    LogAndAssertFailedPrincipalValidationInfo(aPrincipal, __func__);
+  }
+  return actor->StartClassify(principal, aSuccess);
+}
+
+bool ContentParent::DeallocPURLClassifierParent(PURLClassifierParent* aActor) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aActor);
+
+  RefPtr<URLClassifierParent> actor =
+      dont_AddRef(static_cast<URLClassifierParent*>(aActor));
+  return true;
+}
+
+//////////////////////////////////////////////////////////////////
+// PURLClassifierLocalParent
+
+PURLClassifierLocalParent* ContentParent::AllocPURLClassifierLocalParent(
+    nsIURI* aURI, const nsTArray<IPCURLClassifierFeature>& aFeatures) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  RefPtr<URLClassifierLocalParent> actor = new URLClassifierLocalParent();
+  return actor.forget().take();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvPURLClassifierLocalConstructor(
+    PURLClassifierLocalParent* aActor, nsIURI* aURI,
+    nsTArray<IPCURLClassifierFeature>&& aFeatures) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aActor);
+
+  nsTArray<IPCURLClassifierFeature> features = std::move(aFeatures);
+
+  if (!aURI) {
+    return IPC_FAIL(this, "aURI should not be null");
+  }
+
+  auto* actor = static_cast<URLClassifierLocalParent*>(aActor);
+  return actor->StartClassify(aURI, features);
+}
+
+bool ContentParent::DeallocPURLClassifierLocalParent(
+    PURLClassifierLocalParent* aActor) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aActor);
+
+  RefPtr<URLClassifierLocalParent> actor =
+      dont_AddRef(static_cast<URLClassifierLocalParent*>(aActor));
+  return true;
+}
+
+PLoginReputationParent* ContentParent::AllocPLoginReputationParent(
+    nsIURI* aURI) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  RefPtr<LoginReputationParent> actor = new LoginReputationParent();
+  return actor.forget().take();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvPLoginReputationConstructor(
+    PLoginReputationParent* aActor, nsIURI* aURI) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aActor);
+
+  if (!aURI) {
+    return IPC_FAIL(this, "aURI should not be null");
+  }
+
+  auto* actor = static_cast<LoginReputationParent*>(aActor);
+  return actor->QueryReputation(aURI);
+}
+
+bool ContentParent::DeallocPLoginReputationParent(
+    PLoginReputationParent* aActor) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aActor);
+
+  RefPtr<LoginReputationParent> actor =
+      dont_AddRef(static_cast<LoginReputationParent*>(aActor));
+  return true;
+}
+
+PSessionStorageObserverParent*
+ContentParent::AllocPSessionStorageObserverParent() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  return mozilla::dom::AllocPSessionStorageObserverParent();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvPSessionStorageObserverConstructor(
+    PSessionStorageObserverParent* aActor) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aActor);
+
+  if (!mozilla::dom::RecvPSessionStorageObserverConstructor(aActor)) {
+    return IPC_FAIL(this, "RecvPSessionStorageObserverConstructor failed.");
+  }
+  return IPC_OK();
+}
+
+bool ContentParent::DeallocPSessionStorageObserverParent(
+    PSessionStorageObserverParent* aActor) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aActor);
+
+  return mozilla::dom::DeallocPSessionStorageObserverParent(aActor);
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvBHRThreadHang(
+    const HangDetails& aDetails) {
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    // Copy the HangDetails recieved over the network into a nsIHangDetails, and
+    // then fire our own observer notification.
+    // XXX: We should be able to avoid this potentially expensive copy here by
+    // moving our deserialized argument.
+    nsCOMPtr<nsIHangDetails> hangDetails =
+        new nsHangDetails(HangDetails(aDetails), PersistedToDisk::No);
+    obs->NotifyObservers(hangDetails, "bhr-thread-hang", nullptr);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvAddCertException(
+    nsIX509Cert* aCert, const nsACString& aHostName, int32_t aPort,
+    const OriginAttributes& aOriginAttributes, bool aIsTemporary,
+    AddCertExceptionResolver&& aResolver) {
+  nsCOMPtr<nsICertOverrideService> overrideService =
+      do_GetService(NS_CERTOVERRIDE_CONTRACTID);
+  if (!overrideService) {
+    aResolver(NS_ERROR_FAILURE);
+    return IPC_OK();
+  }
+  nsresult rv = overrideService->RememberValidityOverride(
+      aHostName, aPort, aOriginAttributes, aCert, aIsTemporary);
+  aResolver(rv);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+ContentParent::RecvAutomaticStorageAccessPermissionCanBeGranted(
+    nsIPrincipal* aPrincipal,
+    AutomaticStorageAccessPermissionCanBeGrantedResolver&& aResolver) {
+  if (!aPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  if (!ValidatePrincipal(aPrincipal)) {
+    LogAndAssertFailedPrincipalValidationInfo(aPrincipal, __func__);
+  }
+  aResolver(Document::AutomaticStorageAccessPermissionCanBeGranted(aPrincipal));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+ContentParent::RecvStorageAccessPermissionGrantedForOrigin(
+    uint64_t aTopLevelWindowId,
+    const MaybeDiscarded<BrowsingContext>& aParentContext,
+    nsIPrincipal* aTrackingPrincipal, const nsACString& aTrackingOrigin,
+    const int& aAllowMode,
+    const Maybe<ContentBlockingNotifier::StorageAccessPermissionGrantedReason>&
+        aReason,
+    StorageAccessPermissionGrantedForOriginResolver&& aResolver) {
+  if (aParentContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  if (!aTrackingPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  // We only report here if we cannot report the console directly in the content
+  // process. In that case, the `aReason` would be given a value. Otherwise, it
+  // will be nothing.
+  if (aReason) {
+    ContentBlockingNotifier::ReportUnblockingToConsole(
+        aParentContext.get_canonical(), NS_ConvertUTF8toUTF16(aTrackingOrigin),
+        aReason.value());
+  }
+
+  StorageAccessAPIHelper::SaveAccessForOriginOnParentProcess(
+      aTopLevelWindowId, aParentContext.get_canonical(), aTrackingPrincipal,
+      aAllowMode)
+      ->Then(GetCurrentSerialEventTarget(), __func__,
+             [aResolver = std::move(aResolver)](
+                 StorageAccessAPIHelper::ParentAccessGrantPromise::
+                     ResolveOrRejectValue&& aValue) {
+               bool success =
+                   aValue.IsResolve() && NS_SUCCEEDED(aValue.ResolveValue());
+               aResolver(success);
+             });
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvCompleteAllowAccessFor(
+    const MaybeDiscarded<BrowsingContext>& aParentContext,
+    uint64_t aTopLevelWindowId, nsIPrincipal* aTrackingPrincipal,
+    const nsACString& aTrackingOrigin, uint32_t aCookieBehavior,
+    const ContentBlockingNotifier::StorageAccessPermissionGrantedReason&
+        aReason,
+    CompleteAllowAccessForResolver&& aResolver) {
+  if (aParentContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  StorageAccessAPIHelper::CompleteAllowAccessFor(
+      aParentContext.get_canonical(), aTopLevelWindowId, aTrackingPrincipal,
+      aTrackingOrigin, aCookieBehavior, aReason, nullptr)
+      ->Then(GetCurrentSerialEventTarget(), __func__,
+             [aResolver = std::move(aResolver)](
+                 StorageAccessAPIHelper::StorageAccessPermissionGrantPromise::
+                     ResolveOrRejectValue&& aValue) {
+               Maybe<StorageAccessPromptChoices> choice;
+               if (aValue.IsResolve()) {
+                 choice.emplace(static_cast<StorageAccessPromptChoices>(
+                     aValue.ResolveValue()));
+               }
+               aResolver(choice);
+             });
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSetAllowStorageAccessRequestFlag(
+    nsIPrincipal* aEmbeddedPrincipal, nsIURI* aEmbeddingOrigin,
+    SetAllowStorageAccessRequestFlagResolver&& aResolver) {
+  MOZ_ASSERT(aEmbeddedPrincipal);
+  MOZ_ASSERT(aEmbeddingOrigin);
+
+  if (!aEmbeddedPrincipal || !aEmbeddingOrigin) {
+    aResolver(false);
+    return IPC_OK();
+  }
+
+  // Get the permission manager and build the key.
+  RefPtr<PermissionManager> permManager = PermissionManager::GetInstance();
+  if (!permManager) {
+    aResolver(false);
+    return IPC_OK();
+  }
+  nsCOMPtr<nsIURI> embeddedURI = aEmbeddedPrincipal->GetURI();
+  nsCString permissionKey;
+  bool success = AntiTrackingUtils::CreateStorageRequestPermissionKey(
+      embeddedURI, permissionKey);
+  if (!success) {
+    aResolver(false);
+    return IPC_OK();
+  }
+
+  // Set the permission to ALLOW for a prefence specified amount of seconds.
+  // Time units are inconsistent, be careful
+  int64_t when = (PR_Now() / PR_USEC_PER_MSEC) +
+                 StaticPrefs::dom_storage_access_forward_declared_lifetime() *
+                     PR_MSEC_PER_SEC;
+  nsCOMPtr<nsIPrincipal> principal = BasePrincipal::CreateContentPrincipal(
+      aEmbeddingOrigin, aEmbeddedPrincipal->OriginAttributesRef());
+  nsresult rv = permManager->AddFromPrincipal(
+      principal, permissionKey, nsIPermissionManager::ALLOW_ACTION,
+      nsIPermissionManager::EXPIRE_TIME, when);
+  if (NS_FAILED(rv)) {
+    aResolver(false);
+    return IPC_OK();
+  }
+
+  // Resolve with success if we set the permission.
+  aResolver(true);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvTestAllowStorageAccessRequestFlag(
+    nsIPrincipal* aEmbeddingPrincipal, nsIURI* aEmbeddedOrigin,
+    TestAllowStorageAccessRequestFlagResolver&& aResolver) {
+  MOZ_ASSERT(aEmbeddingPrincipal);
+  MOZ_ASSERT(aEmbeddedOrigin);
+
+  // Get the permission manager and build the key.
+  RefPtr<PermissionManager> permManager = PermissionManager::GetInstance();
+  if (!permManager) {
+    aResolver(false);
+    return IPC_OK();
+  }
+  nsCString requestPermissionKey;
+  bool success = AntiTrackingUtils::CreateStorageRequestPermissionKey(
+      aEmbeddedOrigin, requestPermissionKey);
+  if (!success) {
+    aResolver(false);
+    return IPC_OK();
+  }
+
+  // Get the permission and resolve false if it is not set to ALLOW.
+  uint32_t access = nsIPermissionManager::UNKNOWN_ACTION;
+  nsresult rv = permManager->TestPermissionFromPrincipal(
+      aEmbeddingPrincipal, requestPermissionKey, &access);
+  if (NS_FAILED(rv)) {
+    aResolver(false);
+    return IPC_OK();
+  }
+  if (access != nsIPermissionManager::ALLOW_ACTION) {
+    aResolver(false);
+    return IPC_OK();
+  }
+
+  // Remove the permission, failing if the permission manager fails
+  rv = permManager->RemoveFromPrincipal(aEmbeddingPrincipal,
+                                        requestPermissionKey);
+  if (NS_FAILED(rv)) {
+    aResolver(false);
+    return IPC_OK();
+  }
+
+  // At this point, signal to our caller that the permission was set
+  aResolver(true);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvStoreUserInteractionAsPermission(
+    nsIPrincipal* aPrincipal) {
+  if (!aPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  if (!ValidatePrincipal(aPrincipal)) {
+    LogAndAssertFailedPrincipalValidationInfo(aPrincipal, __func__);
+  }
+  ContentBlockingUserInteraction::Observe(aPrincipal);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvTestCookiePermissionDecided(
+    const MaybeDiscarded<BrowsingContext>& aContext, nsIPrincipal* aPrincipal,
+    const TestCookiePermissionDecidedResolver&& aResolver) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  if (!aPrincipal) {
+    return IPC_FAIL(this, "No principal");
+  }
+
+  RefPtr<WindowGlobalParent> wgp =
+      aContext.get_canonical()->GetCurrentWindowGlobal();
+  nsCOMPtr<nsICookieJarSettings> cjs = wgp->CookieJarSettings();
+
+  Maybe<bool> result =
+      StorageAccessAPIHelper::CheckCookiesPermittedDecidesStorageAccessAPI(
+          cjs, aPrincipal);
+  aResolver(result);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvTestStorageAccessPermission(
+    nsIPrincipal* aEmbeddingPrincipal, const nsCString& aEmbeddedOrigin,
+    const TestStorageAccessPermissionResolver&& aResolver) {
+  // Get the permission manager and build the key.
+  RefPtr<PermissionManager> permManager = PermissionManager::GetInstance();
+  if (!permManager) {
+    aResolver(Nothing());
+    return IPC_OK();
+  }
+  nsCString requestPermissionKey;
+  AntiTrackingUtils::CreateStoragePermissionKey(aEmbeddedOrigin,
+                                                requestPermissionKey);
+
+  // Test the permission
+  uint32_t access = nsIPermissionManager::UNKNOWN_ACTION;
+  nsresult rv = permManager->TestPermissionFromPrincipal(
+      aEmbeddingPrincipal, requestPermissionKey, &access);
+  if (NS_FAILED(rv)) {
+    aResolver(Nothing());
+    return IPC_OK();
+  }
+  if (access == nsIPermissionManager::ALLOW_ACTION) {
+    aResolver(Some(true));
+  } else if (access == nsIPermissionManager::DENY_ACTION) {
+    aResolver(Some(false));
+  } else {
+    aResolver(Nothing());
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvNotifyMediaPlaybackChanged(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    MediaPlaybackState aState) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  if (RefPtr<IMediaInfoUpdater> updater =
+          aContext.get_canonical()->GetMediaController()) {
+    updater->NotifyMediaPlaybackChanged(aContext.ContextId(), aState);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvNotifyMediaAudibleChanged(
+    const MaybeDiscarded<BrowsingContext>& aContext, MediaAudibleState aState) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  if (RefPtr<IMediaInfoUpdater> updater =
+          aContext.get_canonical()->GetMediaController()) {
+    updater->NotifyMediaAudibleChanged(aContext.ContextId(), aState);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvNotifyPictureInPictureModeChanged(
+    const MaybeDiscarded<BrowsingContext>& aContext, bool aEnabled) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  if (RefPtr<MediaController> controller =
+          aContext.get_canonical()->GetMediaController()) {
+    controller->SetIsInPictureInPictureMode(aContext.ContextId(), aEnabled);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvAbortOtherOrientationPendingPromises(
+    const MaybeDiscarded<BrowsingContext>& aContext) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  CanonicalBrowsingContext* context = aContext.get_canonical();
+
+  context->Group()->EachOtherParent(this, [&](ContentParent* aParent) {
+    Unused << aParent->SendAbortOrientationPendingPromises(context);
+  });
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvNotifyMediaSessionUpdated(
+    const MaybeDiscarded<BrowsingContext>& aContext, bool aIsCreated) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  RefPtr<IMediaInfoUpdater> updater =
+      aContext.get_canonical()->GetMediaController();
+  if (!updater) {
+    return IPC_OK();
+  }
+  if (aIsCreated) {
+    updater->NotifySessionCreated(aContext->Id());
+  } else {
+    updater->NotifySessionDestroyed(aContext->Id());
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvNotifyUpdateMediaMetadata(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const Maybe<MediaMetadataBase>& aMetadata) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  if (RefPtr<IMediaInfoUpdater> updater =
+          aContext.get_canonical()->GetMediaController()) {
+    updater->UpdateMetadata(aContext.ContextId(), aMetadata);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+ContentParent::RecvNotifyMediaSessionPlaybackStateChanged(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    MediaSessionPlaybackState aPlaybackState) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  if (RefPtr<IMediaInfoUpdater> updater =
+          aContext.get_canonical()->GetMediaController()) {
+    updater->SetDeclaredPlaybackState(aContext.ContextId(), aPlaybackState);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+ContentParent::RecvNotifyMediaSessionSupportedActionChanged(
+    const MaybeDiscarded<BrowsingContext>& aContext, MediaSessionAction aAction,
+    bool aEnabled) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  RefPtr<IMediaInfoUpdater> updater =
+      aContext.get_canonical()->GetMediaController();
+  if (!updater) {
+    return IPC_OK();
+  }
+  if (aEnabled) {
+    updater->EnableAction(aContext.ContextId(), aAction);
+  } else {
+    updater->DisableAction(aContext.ContextId(), aAction);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvNotifyMediaFullScreenState(
+    const MaybeDiscarded<BrowsingContext>& aContext, bool aIsInFullScreen) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  if (RefPtr<IMediaInfoUpdater> updater =
+          aContext.get_canonical()->GetMediaController()) {
+    updater->NotifyMediaFullScreenState(aContext.ContextId(), aIsInFullScreen);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvNotifyPositionStateChanged(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const PositionState& aState) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  if (RefPtr<IMediaInfoUpdater> updater =
+          aContext.get_canonical()->GetMediaController()) {
+    updater->UpdatePositionState(aContext.ContextId(), aState);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvAddOrRemovePageAwakeRequest(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const bool& aShouldAddCount) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+  if (aShouldAddCount) {
+    aContext.get_canonical()->AddPageAwakeRequest();
+  } else {
+    aContext.get_canonical()->RemovePageAwakeRequest();
+  }
+  return IPC_OK();
+}
+
+#if defined(XP_WIN)
+mozilla::ipc::IPCResult ContentParent::RecvGetModulesTrust(
+    ModulePaths&& aModPaths, bool aRunAtNormalPriority,
+    GetModulesTrustResolver&& aResolver) {
+  RefPtr<DllServices> dllSvc(DllServices::Get());
+  dllSvc->GetModulesTrust(std::move(aModPaths), aRunAtNormalPriority)
+      ->Then(
+          GetMainThreadSerialEventTarget(), __func__,
+          [aResolver](ModulesMapResult&& aResult) {
+            aResolver(Some(ModulesMapResult(std::move(aResult))));
+          },
+          [aResolver](nsresult aRv) { aResolver(Nothing()); });
+  return IPC_OK();
+}
+#endif  // defined(XP_WIN)
+
+mozilla::ipc::IPCResult ContentParent::RecvCreateBrowsingContext(
+    uint64_t aGroupId, BrowsingContext::IPCInitializer&& aInit) {
+  RefPtr<WindowGlobalParent> parent;
+  if (aInit.mParentId != 0) {
+    parent = WindowGlobalParent::GetByInnerWindowId(aInit.mParentId);
+    if (!parent) {
+      return IPC_FAIL(this, "Parent doesn't exist in parent process");
+    }
+  }
+
+  if (parent && parent->GetContentParent() != this) {
+    // We're trying attach a child BrowsingContext to a parent
+    // WindowContext in another process. This is illegal since the
+    // only thing that could create that child BrowsingContext is the parent
+    // window's process.
+    return IPC_FAIL(this,
+                    "Must create BrowsingContext from the parent's process");
+  }
+
+  RefPtr<BrowsingContext> opener;
+  if (aInit.GetOpenerId() != 0) {
+    opener = BrowsingContext::Get(aInit.GetOpenerId());
+    if (!opener) {
+      return IPC_FAIL(this, "Opener doesn't exist in parent process");
+    }
+  }
+
+  RefPtr<BrowsingContext> child = BrowsingContext::Get(aInit.mId);
+  if (child) {
+    // This is highly suspicious. BrowsingContexts should only be created once,
+    // so finding one indicates that someone is doing something they shouldn't.
+    return IPC_FAIL(this, "A BrowsingContext with this ID already exists");
+  }
+
+  // Ensure that the passed-in BrowsingContextGroup is valid.
+  RefPtr<BrowsingContextGroup> group =
+      BrowsingContextGroup::GetOrCreate(aGroupId);
+  if (parent && parent->Group() != group) {
+    if (parent->Group()->Id() != aGroupId) {
+      return IPC_FAIL(this, "Parent has different group ID");
+    } else {
+      return IPC_FAIL(this, "Parent has different group object");
+    }
+  }
+  if (opener && opener->Group() != group) {
+    if (opener->Group()->Id() != aGroupId) {
+      return IPC_FAIL(this, "Opener has different group ID");
+    } else {
+      return IPC_FAIL(this, "Opener has different group object");
+    }
+  }
+  if (!parent && !opener && !group->Toplevels().IsEmpty()) {
+    return IPC_FAIL(this, "Unrelated context from child in stale group");
+  }
+
+  return BrowsingContext::CreateFromIPC(std::move(aInit), group, this);
+}
+
+bool ContentParent::CheckBrowsingContextEmbedder(CanonicalBrowsingContext* aBC,
+                                                 const char* aOperation) const {
+  if (!aBC->IsEmbeddedInProcess(ChildID())) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Warning,
+            ("ParentIPC: Trying to %s out of process context 0x%08" PRIx64,
+             aOperation, aBC->Id()));
+    return false;
+  }
+  return true;
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvDiscardBrowsingContext(
+    const MaybeDiscarded<BrowsingContext>& aContext, bool aDoDiscard,
+    DiscardBrowsingContextResolver&& aResolve) {
+  if (CanonicalBrowsingContext* context =
+          CanonicalBrowsingContext::Cast(aContext.GetMaybeDiscarded())) {
+    if (aDoDiscard && !context->IsDiscarded()) {
+      if (!CheckBrowsingContextEmbedder(context, "discard")) {
+        return IPC_FAIL(this, "Illegal Discard attempt");
+      }
+
+      context->Detach(/* aFromIPC */ true);
+    }
+    context->AddFinalDiscardListener(aResolve);
+    return IPC_OK();
+  }
+
+  // Resolve the promise, as we've received and handled the message. This will
+  // allow the content process to fully-discard references to this BC.
+  aResolve(true);
+  return IPC_OK();
+}
+
+void ContentParent::UnregisterRemoveWorkerActor() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  {
+    MutexAutoLock lock(mThreadsafeHandle->mMutex);
+    if (--mThreadsafeHandle->mRemoteWorkerActorCount) {
+      return;
+    }
+  }
+
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Verbose,
+          ("UnregisterRemoveWorkerActor %p", this));
+  MaybeBeginShutDown();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvWindowClose(
+    const MaybeDiscarded<BrowsingContext>& aContext, bool aTrustedCaller) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+  CanonicalBrowsingContext* context = aContext.get_canonical();
+
+  // FIXME Need to check that the sending process has access to the unit of
+  // related
+  //       browsing contexts of bc.
+
+  if (ContentParent* cp = context->GetContentParent()) {
+    Unused << cp->SendWindowClose(context, aTrustedCaller);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvWindowFocus(
+    const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
+    uint64_t aActionId) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+  LOGFOCUS(("ContentParent::RecvWindowFocus actionid: %" PRIu64, aActionId));
+  CanonicalBrowsingContext* context = aContext.get_canonical();
+
+  if (ContentParent* cp = context->GetContentParent()) {
+    Unused << cp->SendWindowFocus(context, aCallerType, aActionId);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvWindowBlur(
+    const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+  CanonicalBrowsingContext* context = aContext.get_canonical();
+
+  if (ContentParent* cp = context->GetContentParent()) {
+    Unused << cp->SendWindowBlur(context, aCallerType);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvRaiseWindow(
+    const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
+    uint64_t aActionId) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+  LOGFOCUS(("ContentParent::RecvRaiseWindow actionid: %" PRIu64, aActionId));
+
+  CanonicalBrowsingContext* context = aContext.get_canonical();
+
+  if (ContentParent* cp = context->GetContentParent()) {
+    Unused << cp->SendRaiseWindow(context, aCallerType, aActionId);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvAdjustWindowFocus(
+    const MaybeDiscarded<BrowsingContext>& aContext, bool aIsVisible,
+    uint64_t aActionId) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+  LOGFOCUS(
+      ("ContentParent::RecvAdjustWindowFocus isVisible %d actionid: %" PRIu64,
+       aIsVisible, aActionId));
+
+  nsTHashMap<nsPtrHashKey<ContentParent>, bool> processes(2);
+  processes.InsertOrUpdate(this, true);
+
+  ContentProcessManager* cpm = ContentProcessManager::GetSingleton();
+  if (cpm) {
+    CanonicalBrowsingContext* context = aContext.get_canonical();
+    while (context) {
+      BrowsingContext* parent = context->GetParent();
+      if (!parent) {
+        break;
+      }
+
+      CanonicalBrowsingContext* canonicalParent = parent->Canonical();
+      ContentParent* cp = cpm->GetContentProcessById(
+          ContentParentId(canonicalParent->OwnerProcessId()));
+      if (cp && !processes.Get(cp)) {
+        Unused << cp->SendAdjustWindowFocus(context, aIsVisible, aActionId);
+        processes.InsertOrUpdate(cp, true);
+      }
+      context = canonicalParent;
+    }
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvClearFocus(
+    const MaybeDiscarded<BrowsingContext>& aContext) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+  CanonicalBrowsingContext* context = aContext.get_canonical();
+
+  if (ContentParent* cp = context->GetContentParent()) {
+    Unused << cp->SendClearFocus(context);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSetFocusedBrowsingContext(
+    const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+  LOGFOCUS(("ContentParent::RecvSetFocusedBrowsingContext actionid: %" PRIu64,
+            aActionId));
+  CanonicalBrowsingContext* context = aContext.get_canonical();
+
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (!fm) {
+    return IPC_OK();
+  }
+
+  if (!fm->SetFocusedBrowsingContextInChrome(context, aActionId)) {
+    LOGFOCUS((
+        "Ignoring out-of-sequence attempt [%p] to set focused browsing context "
+        "in parent.",
+        context));
+    Unused << SendReviseFocusedBrowsingContext(
+        aActionId, fm->GetFocusedBrowsingContextInChrome(),
+        fm->GetActionIdForFocusedBrowsingContextInChrome());
+    return IPC_OK();
+  }
+
+  BrowserParent::UpdateFocusFromBrowsingContext();
+
+  context->Group()->EachOtherParent(this, [&](ContentParent* aParent) {
+    Unused << aParent->SendSetFocusedBrowsingContext(context, aActionId);
+  });
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSetActiveBrowsingContext(
+    const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+  LOGFOCUS(("ContentParent::RecvSetActiveBrowsingContext actionid: %" PRIu64,
+            aActionId));
+  CanonicalBrowsingContext* context = aContext.get_canonical();
+
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (!fm) {
+    return IPC_OK();
+  }
+
+  if (!fm->SetActiveBrowsingContextInChrome(context, aActionId)) {
+    LOGFOCUS(
+        ("Ignoring out-of-sequence attempt [%p] to set active browsing context "
+         "in parent.",
+         context));
+    Unused << SendReviseActiveBrowsingContext(
+        aActionId, fm->GetActiveBrowsingContextInChrome(),
+        fm->GetActionIdForActiveBrowsingContextInChrome());
+    return IPC_OK();
+  }
+
+  context->Group()->EachOtherParent(this, [&](ContentParent* aParent) {
+    Unused << aParent->SendSetActiveBrowsingContext(context, aActionId);
+  });
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvUnsetActiveBrowsingContext(
+    const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+  LOGFOCUS(("ContentParent::RecvUnsetActiveBrowsingContext actionid: %" PRIu64,
+            aActionId));
+  CanonicalBrowsingContext* context = aContext.get_canonical();
+
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (!fm) {
+    return IPC_OK();
+  }
+
+  if (!fm->SetActiveBrowsingContextInChrome(nullptr, aActionId)) {
+    LOGFOCUS(
+        ("Ignoring out-of-sequence attempt to unset active browsing context in "
+         "parent [%p].",
+         context));
+    Unused << SendReviseActiveBrowsingContext(
+        aActionId, fm->GetActiveBrowsingContextInChrome(),
+        fm->GetActionIdForActiveBrowsingContextInChrome());
+    return IPC_OK();
+  }
+
+  context->Group()->EachOtherParent(this, [&](ContentParent* aParent) {
+    Unused << aParent->SendUnsetActiveBrowsingContext(context, aActionId);
+  });
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSetFocusedElement(
+    const MaybeDiscarded<BrowsingContext>& aContext, bool aNeedsFocus) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+  LOGFOCUS(("ContentParent::RecvSetFocusedElement"));
+  CanonicalBrowsingContext* context = aContext.get_canonical();
+
+  if (ContentParent* cp = context->GetContentParent()) {
+    Unused << cp->SendSetFocusedElement(context, aNeedsFocus);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvFinalizeFocusOuter(
+    const MaybeDiscarded<BrowsingContext>& aContext, bool aCanFocus,
+    CallerType aCallerType) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+  LOGFOCUS(("ContentParent::RecvFinalizeFocusOuter"));
+  CanonicalBrowsingContext* context = aContext.get_canonical();
+  ContentProcessManager* cpm = ContentProcessManager::GetSingleton();
+  if (cpm) {
+    ContentParent* cp = cpm->GetContentProcessById(
+        ContentParentId(context->EmbedderProcessId()));
+    if (cp) {
+      Unused << cp->SendFinalizeFocusOuter(context, aCanFocus, aCallerType);
+    }
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvInsertNewFocusActionId(
+    uint64_t aActionId) {
+  LOGFOCUS(("ContentParent::RecvInsertNewFocusActionId actionid: %" PRIu64,
+            aActionId));
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (fm) {
+    fm->InsertNewFocusActionId(aActionId);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvBlurToParent(
+    const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
+    const MaybeDiscarded<BrowsingContext>& aBrowsingContextToClear,
+    const MaybeDiscarded<BrowsingContext>& aAncestorBrowsingContextToFocus,
+    bool aIsLeavingDocument, bool aAdjustWidget,
+    bool aBrowsingContextToClearHandled,
+    bool aAncestorBrowsingContextToFocusHandled, uint64_t aActionId) {
+  if (aFocusedBrowsingContext.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+
+  LOGFOCUS(
+      ("ContentParent::RecvBlurToParent isLeavingDocument %d adjustWidget %d "
+       "browsingContextToClearHandled %d ancestorBrowsingContextToFocusHandled "
+       "%d actionid: %" PRIu64,
+       aIsLeavingDocument, aAdjustWidget, aBrowsingContextToClearHandled,
+       aAncestorBrowsingContextToFocusHandled, aActionId));
+
+  CanonicalBrowsingContext* focusedBrowsingContext =
+      aFocusedBrowsingContext.get_canonical();
+
+  // If aBrowsingContextToClear and aAncestorBrowsingContextToFocusHandled
+  // didn't get handled in the process that sent this IPC message and they
+  // aren't in the same process as aFocusedBrowsingContext, we need to split
+  // off their handling here and use SendSetFocusedElement to send them
+  // elsewhere than the blurring itself.
+
+  bool ancestorDifferent =
+      (!aAncestorBrowsingContextToFocusHandled &&
+       !aAncestorBrowsingContextToFocus.IsNullOrDiscarded() &&
+       (focusedBrowsingContext->OwnerProcessId() !=
+        aAncestorBrowsingContextToFocus.get_canonical()->OwnerProcessId()));
+  if (!aBrowsingContextToClearHandled &&
+      !aBrowsingContextToClear.IsNullOrDiscarded() &&
+      (focusedBrowsingContext->OwnerProcessId() !=
+       aBrowsingContextToClear.get_canonical()->OwnerProcessId())) {
+    MOZ_RELEASE_ASSERT(!ancestorDifferent,
+                       "This combination is not supposed to happen.");
+    if (ContentParent* cp =
+            aBrowsingContextToClear.get_canonical()->GetContentParent()) {
+      Unused << cp->SendSetFocusedElement(aBrowsingContextToClear, false);
+    }
+  } else if (ancestorDifferent) {
+    if (ContentParent* cp = aAncestorBrowsingContextToFocus.get_canonical()
+                                ->GetContentParent()) {
+      Unused << cp->SendSetFocusedElement(aAncestorBrowsingContextToFocus,
+                                          true);
+    }
+  }
+
+  if (ContentParent* cp = focusedBrowsingContext->GetContentParent()) {
+    Unused << cp->SendBlurToChild(aFocusedBrowsingContext,
+                                  aBrowsingContextToClear,
+                                  aAncestorBrowsingContextToFocus,
+                                  aIsLeavingDocument, aAdjustWidget, aActionId);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvMaybeExitFullscreen(
+    const MaybeDiscarded<BrowsingContext>& aContext) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+  CanonicalBrowsingContext* context = aContext.get_canonical();
+
+  if (ContentParent* cp = context->GetContentParent()) {
+    Unused << cp->SendMaybeExitFullscreen(context);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvWindowPostMessage(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const ClonedOrErrorMessageData& aMessage, const PostMessageData& aData) {
+  if (aContext.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message to dead or detached context"));
+    return IPC_OK();
+  }
+  CanonicalBrowsingContext* context = aContext.get_canonical();
+
+  if (aData.source().IsDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message from dead or detached context"));
+    return IPC_OK();
+  }
+
+  RefPtr<ContentParent> cp = context->GetContentParent();
+  if (!cp) {
+    MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+            ("ParentIPC: Trying to send PostMessage to dead content process"));
+    return IPC_OK();
+  }
+
+  ClonedOrErrorMessageData message;
+  StructuredCloneData messageFromChild;
+  if (aMessage.type() == ClonedOrErrorMessageData::TClonedMessageData) {
+    UnpackClonedMessageData(aMessage, messageFromChild);
+
+    ClonedMessageData clonedMessageData;
+    if (BuildClonedMessageData(messageFromChild, clonedMessageData)) {
+      message = std::move(clonedMessageData);
+    } else {
+      // FIXME Logging?
+      message = ErrorMessageData();
+    }
+  } else {
+    MOZ_ASSERT(aMessage.type() == ClonedOrErrorMessageData::TErrorMessageData);
+    message = ErrorMessageData();
+  }
+
+  Unused << cp->SendWindowPostMessage(context, message, aData);
+  return IPC_OK();
+}
+
+void ContentParent::AddBrowsingContextGroup(BrowsingContextGroup* aGroup) {
+  MOZ_DIAGNOSTIC_ASSERT(aGroup);
+  // Ensure that the group has been inserted, and if we're not launching
+  // anymore, also begin subscribing. Launching processes will be subscribed if
+  // they finish launching in `LaunchSubprocessResolve`.
+  if (mGroups.EnsureInserted(aGroup) && !IsLaunching()) {
+    aGroup->Subscribe(this);
+  }
+}
+
+void ContentParent::RemoveBrowsingContextGroup(BrowsingContextGroup* aGroup) {
+  MOZ_DIAGNOSTIC_ASSERT(aGroup);
+  // Remove the group from our list. This is called from the
+  // BrowsingContextGroup when unsubscribing, so we don't need to do it here.
+  if (mGroups.EnsureRemoved(aGroup) && CanSend()) {
+    // If we're removing the entry for the first time, tell the content process
+    // to clean up the group.
+    Unused << SendDestroyBrowsingContextGroup(aGroup->Id());
+  }
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvCommitBrowsingContextTransaction(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    BrowsingContext::BaseTransaction&& aTransaction, uint64_t aEpoch) {
+  // Record the new BrowsingContextFieldEpoch associated with this transaction.
+  // This should be done unconditionally, so that we're always in-sync.
+  //
+  // The order the parent process receives transactions is considered the
+  // "canonical" ordering, so we don't need to worry about doing any
+  // epoch-related validation.
+  MOZ_ASSERT(aEpoch == mBrowsingContextFieldEpoch + 1,
+             "Child process skipped an epoch?");
+  mBrowsingContextFieldEpoch = aEpoch;
+
+  return aTransaction.CommitFromIPC(aContext, this);
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvBlobURLDataRequest(
+    const nsACString& aBlobURL, nsIPrincipal* aTriggeringPrincipal,
+    nsIPrincipal* aLoadingPrincipal, const OriginAttributes& aOriginAttributes,
+    uint64_t aInnerWindowId, const Maybe<nsID>& aAgentClusterId,
+    BlobURLDataRequestResolver&& aResolver) {
+  RefPtr<BlobImpl> blobImpl;
+
+  // Since revoked blobs are also retrieved, it is possible that the blob no
+  // longer exists (due to the 5 second timeout) when execution reaches here
+  if (!BlobURLProtocolHandler::GetDataEntry(
+          aBlobURL, getter_AddRefs(blobImpl), aLoadingPrincipal,
+          aTriggeringPrincipal, aOriginAttributes, aInnerWindowId,
+          aAgentClusterId, true /* AlsoIfRevoked */)) {
+    aResolver(NS_ERROR_DOM_BAD_URI);
+    return IPC_OK();
+  }
+
+  IPCBlob ipcBlob;
+  nsresult rv = IPCBlobUtils::Serialize(blobImpl, ipcBlob);
+
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    aResolver(rv);
+    return IPC_OK();
+  }
+
+  aResolver(ipcBlob);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvReportServiceWorkerShutdownProgress(
+    uint32_t aShutdownStateId, ServiceWorkerShutdownState::Progress aProgress) {
+  RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance();
+  MOZ_RELEASE_ASSERT(swm, "ServiceWorkers should shutdown before SWM.");
+
+  swm->ReportServiceWorkerShutdownProgress(aShutdownStateId, aProgress);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvNotifyOnHistoryReload(
+    const MaybeDiscarded<BrowsingContext>& aContext, const bool& aForceReload,
+    NotifyOnHistoryReloadResolver&& aResolver) {
+  bool canReload = false;
+  Maybe<NotNull<RefPtr<nsDocShellLoadState>>> loadState;
+  Maybe<bool> reloadActiveEntry;
+  if (!aContext.IsDiscarded()) {
+    aContext.get_canonical()->NotifyOnHistoryReload(
+        aForceReload, canReload, loadState, reloadActiveEntry);
+  }
+  aResolver(
+      std::tuple<const bool&,
+                 const Maybe<NotNull<RefPtr<nsDocShellLoadState>>>&,
+                 const Maybe<bool>&>(canReload, loadState, reloadActiveEntry));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvHistoryCommit(
+    const MaybeDiscarded<BrowsingContext>& aContext, const uint64_t& aLoadID,
+    const nsID& aChangeID, const uint32_t& aLoadType, const bool& aPersist,
+    const bool& aCloneEntryChildren, const bool& aChannelExpired,
+    const uint32_t& aCacheKey) {
+  if (!aContext.IsDiscarded()) {
+    CanonicalBrowsingContext* canonical = aContext.get_canonical();
+    if (!canonical) {
+      return IPC_FAIL(
+          this, "Could not get canonical. aContext.get_canonical() fails.");
+    }
+    canonical->SessionHistoryCommit(aLoadID, aChangeID, aLoadType, aPersist,
+                                    aCloneEntryChildren, aChannelExpired,
+                                    aCacheKey);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvHistoryGo(
+    const MaybeDiscarded<BrowsingContext>& aContext, int32_t aOffset,
+    uint64_t aHistoryEpoch, bool aRequireUserInteraction, bool aUserActivation,
+    HistoryGoResolver&& aResolveRequestedIndex) {
+  if (!aContext.IsDiscarded()) {
+    RefPtr<CanonicalBrowsingContext> canonical = aContext.get_canonical();
+    aResolveRequestedIndex(
+        canonical->HistoryGo(aOffset, aHistoryEpoch, aRequireUserInteraction,
+                             aUserActivation, Some(ChildID())));
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSynchronizeLayoutHistoryState(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    nsILayoutHistoryState* aState) {
+  if (aContext.IsNull()) {
+    return IPC_OK();
+  }
+
+  BrowsingContext* bc = aContext.GetMaybeDiscarded();
+  if (!bc) {
+    return IPC_OK();
+  }
+  SessionHistoryEntry* entry = bc->Canonical()->GetActiveSessionHistoryEntry();
+  if (entry) {
+    entry->SetLayoutHistoryState(aState);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSessionHistoryEntryTitle(
+    const MaybeDiscarded<BrowsingContext>& aContext, const nsAString& aTitle) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  SessionHistoryEntry* entry =
+      aContext.get_canonical()->GetActiveSessionHistoryEntry();
+  if (entry) {
+    entry->SetTitle(aTitle);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+ContentParent::RecvSessionHistoryEntryScrollRestorationIsManual(
+    const MaybeDiscarded<BrowsingContext>& aContext, const bool& aIsManual) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  SessionHistoryEntry* entry =
+      aContext.get_canonical()->GetActiveSessionHistoryEntry();
+  if (entry) {
+    entry->SetScrollRestorationIsManual(aIsManual);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSessionHistoryEntryScrollPosition(
+    const MaybeDiscarded<BrowsingContext>& aContext, const int32_t& aX,
+    const int32_t& aY) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  SessionHistoryEntry* entry =
+      aContext.get_canonical()->GetActiveSessionHistoryEntry();
+  if (entry) {
+    entry->SetScrollPosition(aX, aY);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+ContentParent::RecvSessionHistoryEntryStoreWindowNameInContiguousEntries(
+    const MaybeDiscarded<BrowsingContext>& aContext, const nsAString& aName) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  // Per https://html.spec.whatwg.org/#history-traversal 4.2.1, we need to set
+  // the name to all contiguous entries. This has to be called before
+  // CanonicalBrowsingContext::SessionHistoryCommit(), so the active entry is
+  // still the old entry that we want to set.
+
+  SessionHistoryEntry* entry =
+      aContext.get_canonical()->GetActiveSessionHistoryEntry();
+
+  if (entry) {
+    nsSHistory::WalkContiguousEntries(
+        entry, [&](nsISHEntry* aEntry) { aEntry->SetName(aName); });
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSessionHistoryEntryCacheKey(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const uint32_t& aCacheKey) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  SessionHistoryEntry* entry =
+      aContext.get_canonical()->GetActiveSessionHistoryEntry();
+  if (entry) {
+    entry->SetCacheKey(aCacheKey);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSessionHistoryEntryWireframe(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const Wireframe& aWireframe) {
+  if (aContext.IsNull()) {
+    return IPC_OK();
+  }
+
+  BrowsingContext* bc = aContext.GetMaybeDiscarded();
+  if (!bc) {
+    return IPC_OK();
+  }
+
+  SessionHistoryEntry* entry = bc->Canonical()->GetActiveSessionHistoryEntry();
+  if (entry) {
+    entry->SetWireframe(Some(aWireframe));
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+ContentParent::RecvGetLoadingSessionHistoryInfoFromParent(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    GetLoadingSessionHistoryInfoFromParentResolver&& aResolver) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  Maybe<LoadingSessionHistoryInfo> info;
+  aContext.get_canonical()->GetLoadingSessionHistoryInfoFromParent(info);
+  aResolver(info);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvRemoveFromBFCache(
+    const MaybeDiscarded<BrowsingContext>& aContext) {
+  if (aContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsFrameLoaderOwner> owner =
+      do_QueryInterface(aContext.get_canonical()->GetEmbedderElement());
+  if (!owner) {
+    return IPC_OK();
+  }
+
+  RefPtr<nsFrameLoader> frameLoader = owner->GetFrameLoader();
+  if (!frameLoader || !frameLoader->GetMaybePendingBrowsingContext()) {
+    return IPC_OK();
+  }
+
+  nsCOMPtr<nsISHistory> shistory = frameLoader->GetMaybePendingBrowsingContext()
+                                       ->Canonical()
+                                       ->GetSessionHistory();
+  if (!shistory) {
+    return IPC_OK();
+  }
+
+  uint32_t count = shistory->GetCount();
+  for (uint32_t i = 0; i < count; ++i) {
+    nsCOMPtr<nsISHEntry> entry;
+    shistory->GetEntryAtIndex(i, getter_AddRefs(entry));
+    nsCOMPtr<SessionHistoryEntry> she = do_QueryInterface(entry);
+    if (she) {
+      if (RefPtr<nsFrameLoader> frameLoader = she->GetFrameLoader()) {
+        if (frameLoader->GetMaybePendingBrowsingContext() == aContext.get()) {
+          she->SetFrameLoader(nullptr);
+          frameLoader->Destroy();
+          break;
+        }
+      }
+    }
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSetActiveSessionHistoryEntry(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const Maybe<nsPoint>& aPreviousScrollPos, SessionHistoryInfo&& aInfo,
+    uint32_t aLoadType, uint32_t aUpdatedCacheKey, const nsID& aChangeID) {
+  if (!aContext.IsDiscarded()) {
+    aContext.get_canonical()->SetActiveSessionHistoryEntry(
+        aPreviousScrollPos, &aInfo, aLoadType, aUpdatedCacheKey, aChangeID);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvReplaceActiveSessionHistoryEntry(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    SessionHistoryInfo&& aInfo) {
+  if (!aContext.IsDiscarded()) {
+    aContext.get_canonical()->ReplaceActiveSessionHistoryEntry(&aInfo);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+ContentParent::RecvRemoveDynEntriesFromActiveSessionHistoryEntry(
+    const MaybeDiscarded<BrowsingContext>& aContext) {
+  if (!aContext.IsDiscarded()) {
+    aContext.get_canonical()->RemoveDynEntriesFromActiveSessionHistoryEntry();
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvRemoveFromSessionHistory(
+    const MaybeDiscarded<BrowsingContext>& aContext, const nsID& aChangeID) {
+  if (!aContext.IsDiscarded()) {
+    aContext.get_canonical()->RemoveFromSessionHistory(aChangeID);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvHistoryReload(
+    const MaybeDiscarded<BrowsingContext>& aContext,
+    const uint32_t aReloadFlags) {
+  if (!aContext.IsDiscarded()) {
+    nsCOMPtr<nsISHistory> shistory =
+        aContext.get_canonical()->GetSessionHistory();
+    if (shistory) {
+      shistory->Reload(aReloadFlags);
+    }
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvCommitWindowContextTransaction(
+    const MaybeDiscarded<WindowContext>& aContext,
+    WindowContext::BaseTransaction&& aTransaction, uint64_t aEpoch) {
+  // Record the new BrowsingContextFieldEpoch associated with this transaction.
+  // This should be done unconditionally, so that we're always in-sync.
+  //
+  // The order the parent process receives transactions is considered the
+  // "canonical" ordering, so we don't need to worry about doing any
+  // epoch-related validation.
+  MOZ_ASSERT(aEpoch == mBrowsingContextFieldEpoch + 1,
+             "Child process skipped an epoch?");
+  mBrowsingContextFieldEpoch = aEpoch;
+
+  return aTransaction.CommitFromIPC(aContext, this);
+}
+
+NS_IMETHODIMP ContentParent::GetChildID(uint64_t* aOut) {
+  *aOut = this->ChildID();
+  return NS_OK;
+}
+
+NS_IMETHODIMP ContentParent::GetOsPid(int32_t* aOut) {
+  *aOut = Pid();
+  return NS_OK;
+}
+
+NS_IMETHODIMP ContentParent::GetRemoteType(nsACString& aRemoteType) {
+  aRemoteType = GetRemoteType();
+  return NS_OK;
+}
+
+IPCResult ContentParent::RecvRawMessage(
+    const JSActorMessageMeta& aMeta, const Maybe<ClonedMessageData>& aData,
+    const Maybe<ClonedMessageData>& aStack) {
+  Maybe<StructuredCloneData> data;
+  if (aData) {
+    data.emplace();
+    data->BorrowFromClonedMessageData(*aData);
+  }
+  Maybe<StructuredCloneData> stack;
+  if (aStack) {
+    stack.emplace();
+    stack->BorrowFromClonedMessageData(*aStack);
+  }
+  ReceiveRawMessage(aMeta, std::move(data), std::move(stack));
+  return IPC_OK();
+}
+
+NS_IMETHODIMP ContentParent::GetActor(const nsACString& aName, JSContext* aCx,
+                                      JSProcessActorParent** retval) {
+  ErrorResult error;
+  RefPtr<JSProcessActorParent> actor =
+      JSActorManager::GetActor(aCx, aName, error)
+          .downcast<JSProcessActorParent>();
+  if (error.MaybeSetPendingException(aCx)) {
+    return NS_ERROR_FAILURE;
+  }
+  actor.forget(retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP ContentParent::GetExistingActor(const nsACString& aName,
+                                              JSProcessActorParent** retval) {
+  RefPtr<JSProcessActorParent> actor =
+      JSActorManager::GetExistingActor(aName).downcast<JSProcessActorParent>();
+  actor.forget(retval);
+  return NS_OK;
+}
+
+already_AddRefed<JSActor> ContentParent::InitJSActor(
+    JS::Handle<JSObject*> aMaybeActor, const nsACString& aName,
+    ErrorResult& aRv) {
+  RefPtr<JSProcessActorParent> actor;
+  if (aMaybeActor.get()) {
+    aRv = UNWRAP_OBJECT(JSProcessActorParent, aMaybeActor.get(), actor);
+    if (aRv.Failed()) {
+      return nullptr;
+    }
+  } else {
+    actor = new JSProcessActorParent();
+  }
+
+  MOZ_RELEASE_ASSERT(!actor->Manager(),
+                     "mManager was already initialized once!");
+  actor->Init(aName, this);
+  return actor.forget();
+}
+
+IPCResult ContentParent::RecvFOGData(ByteBuf&& buf) {
+  glean::FOGData(std::move(buf));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult ContentParent::RecvSetContainerFeaturePolicy(
+    const MaybeDiscardedBrowsingContext& aContainerContext,
+    FeaturePolicy* aContainerFeaturePolicy) {
+  if (aContainerContext.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  auto* context = aContainerContext.get_canonical();
+  context->SetContainerFeaturePolicy(aContainerFeaturePolicy);
+
+  return IPC_OK();
+}
+
+NS_IMETHODIMP ContentParent::GetCanSend(bool* aCanSend) {
+  *aCanSend = CanSend();
+  return NS_OK;
+}
+
+ContentParent* ContentParent::AsContentParent() { return this; }
+
+JSActorManager* ContentParent::AsJSActorManager() { return this; }
+
+IPCResult ContentParent::RecvGetSystemIcon(nsIURI* aURI,
+                                           GetSystemIconResolver&& aResolver) {
+  using ResolverArgs = std::tuple<const nsresult&, mozilla::Maybe<ByteBuf>&&>;
+
+  if (!aURI) {
+    Maybe<ByteBuf> bytebuf = Nothing();
+    aResolver(ResolverArgs(NS_ERROR_NULL_POINTER, std::move(bytebuf)));
+    return IPC_OK();
+  }
+
+#if defined(MOZ_WIDGET_GTK)
+  Maybe<ByteBuf> bytebuf = Some(ByteBuf{});
+  nsresult rv = nsIconChannel::GetIcon(aURI, bytebuf.ptr());
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    bytebuf = Nothing();
+  }
+  aResolver(ResolverArgs(rv, std::move(bytebuf)));
+  return IPC_OK();
+#elif defined(XP_WIN)
+  nsIconChannel::GetIconAsync(aURI)->Then(
+      GetCurrentSerialEventTarget(), __func__,
+      [aResolver](ByteBuf&& aByteBuf) {
+        Maybe<ByteBuf> bytebuf = Some(std::move(aByteBuf));
+        aResolver(ResolverArgs(NS_OK, std::move(bytebuf)));
+      },
+      [aResolver](nsresult aErr) {
+        Maybe<ByteBuf> bytebuf = Nothing();
+        aResolver(ResolverArgs(aErr, std::move(bytebuf)));
+      });
+  return IPC_OK();
+#else
+  MOZ_CRASH(
+      "This message is currently implemented only on GTK and Windows "
+      "platforms");
+#endif
+}
+
+#ifdef FUZZING_SNAPSHOT
+IPCResult ContentParent::RecvSignalFuzzingReady() {
+  // No action needed here, we already observe this message directly
+  // on the channel and act accordingly.
+  return IPC_OK();
+}
+#endif
+
+nsCString ThreadsafeContentParentHandle::GetRemoteType() {
+  MutexAutoLock lock(mMutex);
+  return mRemoteType;
+}
+
+bool ThreadsafeContentParentHandle::MaybeRegisterRemoteWorkerActor(
+    MoveOnlyFunction<bool(uint32_t, bool)> aCallback) {
+  MutexAutoLock lock(mMutex);
+  if (aCallback(mRemoteWorkerActorCount, mShutdownStarted)) {
+    ++mRemoteWorkerActorCount;
+    return true;
+  }
+  return false;
+}
+
+}  // namespace dom
+}  // namespace mozilla
+
+NS_IMPL_ISUPPORTS(ParentIdleListener, nsIObserver)
+
+NS_IMETHODIMP
+ParentIdleListener::Observe(nsISupports*, const char* aTopic,
+                            const char16_t* aData) {
+  mozilla::Unused << mParent->SendNotifyIdleObserver(
+      mObserver, nsDependentCString(aTopic), nsDependentString(aData));
+  return NS_OK;
+}
diff --git a/dom/ipc/ContentParent.h b/dom/ipc/ContentParent.h
new file mode 100644
index 0000000000..b4c1f45b35
--- /dev/null
+++ b/dom/ipc/ContentParent.h
@@ -0,0 +1,1741 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_ContentParent_h
+#define mozilla_dom_ContentParent_h
+
+#include "mozilla/dom/PContentParent.h"
+#include "mozilla/dom/ipc/IdType.h"
+#include "mozilla/dom/MessageManagerCallback.h"
+#include "mozilla/dom/MediaSessionBinding.h"
+#include "mozilla/dom/RemoteBrowser.h"
+#include "mozilla/dom/RemoteType.h"
+#include "mozilla/dom/JSProcessActorParent.h"
+#include "mozilla/dom/ProcessActor.h"
+#include "mozilla/gfx/gfxVarReceiver.h"
+#include "mozilla/gfx/GPUProcessListener.h"
+#include "mozilla/ipc/BackgroundUtils.h"
+#include "mozilla/ipc/GeckoChildProcessHost.h"
+#include "mozilla/ipc/InputStreamUtils.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/DataMutex.h"
+#include "mozilla/FileUtils.h"
+#include "mozilla/HalTypes.h"
+#include "mozilla/LinkedList.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MemoryReportingProcess.h"
+#include "mozilla/MozPromise.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/UniquePtr.h"
+
+#include "MainThreadUtils.h"
+#include "nsClassHashtable.h"
+#include "nsTHashMap.h"
+#include "nsTHashSet.h"
+#include "nsPluginTags.h"
+#include "nsHashKeys.h"
+#include "nsIAsyncShutdown.h"
+#include "nsIDOMProcessParent.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIObserver.h"
+#include "nsIRemoteTab.h"
+#include "nsIDOMGeoPositionCallback.h"
+#include "nsIDOMGeoPositionErrorCallback.h"
+#include "nsRefPtrHashtable.h"
+#include "PermissionMessageUtils.h"
+#include "DriverCrashGuard.h"
+#include "nsIReferrerInfo.h"
+
+#define CHILD_PROCESS_SHUTDOWN_MESSAGE u"child-process-shutdown"_ns
+
+class nsConsoleService;
+class nsIContentProcessInfo;
+class nsICycleCollectorLogSink;
+class nsIDumpGCAndCCLogsCallback;
+class nsIRemoteTab;
+class nsITimer;
+class ParentIdleListener;
+class nsIWidget;
+class nsIX509Cert;
+
+namespace mozilla {
+class PClipboardWriteRequestParent;
+class PRemoteSpellcheckEngineParent;
+
+#if defined(XP_LINUX) && defined(MOZ_SANDBOX)
+class SandboxBroker;
+class SandboxBrokerPolicyFactory;
+#endif
+
+class PreallocatedProcessManagerImpl;
+class BenchmarkStorageParent;
+
+using mozilla::loader::PScriptCacheParent;
+
+namespace ipc {
+class CrashReporterHost;
+class TestShellParent;
+class SharedPreferenceSerializer;
+}  // namespace ipc
+
+namespace layers {
+struct TextureFactoryIdentifier;
+}  // namespace layers
+
+namespace dom {
+
+class BrowsingContextGroup;
+class Element;
+class BrowserParent;
+class ClonedMessageData;
+class MemoryReport;
+class TabContext;
+class GetFilesHelper;
+class MemoryReportRequestHost;
+class RemoteWorkerManager;
+class ThreadsafeContentParentHandle;
+struct CancelContentJSOptions;
+
+#define NS_CONTENTPARENT_IID                         \
+  {                                                  \
+    0xeeec9ebf, 0x8ecf, 0x4e38, {                    \
+      0x81, 0xda, 0xb7, 0x34, 0x13, 0x7e, 0xac, 0xf3 \
+    }                                                \
+  }
+
+class ContentParent final : public PContentParent,
+                            public nsIDOMProcessParent,
+                            public nsIObserver,
+                            public nsIDOMGeoPositionCallback,
+                            public nsIDOMGeoPositionErrorCallback,
+                            public nsIAsyncShutdownBlocker,
+                            public nsIInterfaceRequestor,
+                            public gfx::gfxVarReceiver,
+                            public mozilla::LinkedListElement<ContentParent>,
+                            public gfx::GPUProcessListener,
+                            public mozilla::MemoryReportingProcess,
+                            public mozilla::dom::ipc::MessageManagerCallback,
+                            public mozilla::ipc::IShmemAllocator,
+                            public ProcessActor {
+  typedef mozilla::ipc::GeckoChildProcessHost GeckoChildProcessHost;
+  typedef mozilla::ipc::TestShellParent TestShellParent;
+  typedef mozilla::ipc::PrincipalInfo PrincipalInfo;
+  typedef mozilla::dom::ClonedMessageData ClonedMessageData;
+  typedef mozilla::dom::BrowsingContextGroup BrowsingContextGroup;
+
+  friend class mozilla::PreallocatedProcessManagerImpl;
+  friend class PContentParent;
+  friend class mozilla::dom::RemoteWorkerManager;
+
+ public:
+  using LaunchPromise =
+      mozilla::MozPromise<RefPtr<ContentParent>, nsresult, false>;
+
+  NS_DECLARE_STATIC_IID_ACCESSOR(NS_CONTENTPARENT_IID)
+
+  static LogModule* GetLog();
+
+  static ContentParent* Cast(PContentParent* aActor) {
+    return static_cast<ContentParent*>(aActor);
+  }
+
+  /**
+   * Create a ContentParent suitable for use later as a content process.
+   */
+  static already_AddRefed<ContentParent> MakePreallocProcess();
+
+  /**
+   * Start up the content-process machinery.  This might include
+   * scheduling pre-launch tasks.
+   */
+  static void StartUp();
+
+  /** Shut down the content-process machinery. */
+  static void ShutDown();
+
+  static uint32_t GetPoolSize(const nsACString& aContentProcessType);
+
+  static uint32_t GetMaxProcessCount(const nsACString& aContentProcessType);
+
+  static bool IsMaxProcessCountReached(const nsACString& aContentProcessType);
+
+  static void ReleaseCachedProcesses();
+
+  static void LogAndAssertFailedPrincipalValidationInfo(
+      nsIPrincipal* aPrincipal, const char* aMethod);
+
+  /**
+   * Picks a random content parent from |aContentParents| respecting the index
+   * limit set by |aMaxContentParents|.
+   * Returns null if non available.
+   */
+  static already_AddRefed<ContentParent> MinTabSelect(
+      const nsTArray<ContentParent*>& aContentParents,
+      int32_t maxContentParents);
+
+  /**
+   * Get or create a content process for:
+   * 1. browser iframe
+   * 2. remote xul <browser>
+   * 3. normal iframe
+   */
+  static RefPtr<ContentParent::LaunchPromise> GetNewOrUsedBrowserProcessAsync(
+      const nsACString& aRemoteType, BrowsingContextGroup* aGroup = nullptr,
+      hal::ProcessPriority aPriority =
+          hal::ProcessPriority::PROCESS_PRIORITY_FOREGROUND,
+      bool aPreferUsed = false);
+  static already_AddRefed<ContentParent> GetNewOrUsedBrowserProcess(
+      const nsACString& aRemoteType, BrowsingContextGroup* aGroup = nullptr,
+      hal::ProcessPriority aPriority =
+          hal::ProcessPriority::PROCESS_PRIORITY_FOREGROUND,
+      bool aPreferUsed = false);
+
+  /**
+   * Get or create a content process, but without waiting for the process
+   * launch to have completed. The returned `ContentParent` may still be in the
+   * "Launching" state.
+   *
+   * Can return `nullptr` in the case of an error.
+   *
+   * Use the `WaitForLaunchAsync` or `WaitForLaunchSync` methods to wait for
+   * the process to be fully launched.
+   */
+  static already_AddRefed<ContentParent> GetNewOrUsedLaunchingBrowserProcess(
+      const nsACString& aRemoteType, BrowsingContextGroup* aGroup = nullptr,
+      hal::ProcessPriority aPriority =
+          hal::ProcessPriority::PROCESS_PRIORITY_FOREGROUND,
+      bool aPreferUsed = false);
+
+  RefPtr<ContentParent::LaunchPromise> WaitForLaunchAsync(
+      hal::ProcessPriority aPriority =
+          hal::ProcessPriority::PROCESS_PRIORITY_FOREGROUND);
+  bool WaitForLaunchSync(hal::ProcessPriority aPriority =
+                             hal::ProcessPriority::PROCESS_PRIORITY_FOREGROUND);
+
+  /**
+   * Get or create a content process for a JS plugin. aPluginID is the id of the
+   * JS plugin
+   * (@see nsFakePlugin::mId). There is a maximum of one process per JS plugin.
+   */
+  static already_AddRefed<ContentParent> GetNewOrUsedJSPluginProcess(
+      uint32_t aPluginID, const hal::ProcessPriority& aPriority);
+
+  /**
+   * Get or create a content process for the given TabContext.  aFrameElement
+   * should be the frame/iframe element with which this process will
+   * associated.
+   */
+  static already_AddRefed<RemoteBrowser> CreateBrowser(
+      const TabContext& aContext, Element* aFrameElement,
+      const nsACString& aRemoteType, BrowsingContext* aBrowsingContext,
+      ContentParent* aOpenerContentParent);
+
+  /**
+   * Get all content parents.
+   *
+   * # Lifetime
+   *
+   * These pointers are ONLY valid for synchronous use from the main thread.
+   *
+   * Do NOT attempt to use them after the main thread has had a chance to handle
+   * messages or you could end up with dangling pointers.
+   */
+  static void GetAll(nsTArray<ContentParent*>& aArray);
+
+  static void GetAllEvenIfDead(nsTArray<ContentParent*>& aArray);
+
+  static void BroadcastStringBundle(const StringBundleDescriptor&);
+
+  static void BroadcastFontListChanged();
+  static void BroadcastShmBlockAdded(uint32_t aGeneration, uint32_t aIndex);
+
+  static void BroadcastThemeUpdate(widget::ThemeChangeKind);
+
+  static void BroadcastMediaCodecsSupportedUpdate(
+      RemoteDecodeIn aLocation, const media::MediaCodecsSupported& aSupported);
+
+  const nsACString& GetRemoteType() const override;
+
+  virtual void DoGetRemoteType(nsACString& aRemoteType,
+                               ErrorResult& aError) const override {
+    aRemoteType = GetRemoteType();
+  }
+
+  enum CPIteratorPolicy { eLive, eAll };
+
+  class ContentParentIterator {
+   private:
+    ContentParent* mCurrent;
+    CPIteratorPolicy mPolicy;
+
+   public:
+    ContentParentIterator(CPIteratorPolicy aPolicy, ContentParent* aCurrent)
+        : mCurrent(aCurrent), mPolicy(aPolicy) {}
+
+    ContentParentIterator begin() {
+      // Move the cursor to the first element that matches the policy.
+      while (mPolicy != eAll && mCurrent && !mCurrent->IsAlive()) {
+        mCurrent = mCurrent->LinkedListElement<ContentParent>::getNext();
+      }
+
+      return *this;
+    }
+    ContentParentIterator end() {
+      return ContentParentIterator(mPolicy, nullptr);
+    }
+
+    const ContentParentIterator& operator++() {
+      MOZ_ASSERT(mCurrent);
+      do {
+        mCurrent = mCurrent->LinkedListElement<ContentParent>::getNext();
+      } while (mPolicy != eAll && mCurrent && !mCurrent->IsAlive());
+
+      return *this;
+    }
+
+    bool operator!=(const ContentParentIterator& aOther) const {
+      MOZ_ASSERT(mPolicy == aOther.mPolicy);
+      return mCurrent != aOther.mCurrent;
+    }
+
+    ContentParent* operator*() { return mCurrent; }
+  };
+
+  static ContentParentIterator AllProcesses(CPIteratorPolicy aPolicy) {
+    ContentParent* first =
+        sContentParents ? sContentParents->getFirst() : nullptr;
+    return ContentParentIterator(aPolicy, first);
+  }
+
+  static void NotifyUpdatedDictionaries();
+
+  // Tell content processes the font list has changed. If aFullRebuild is true,
+  // the shared list has been rebuilt and must be freshly mapped by child
+  // processes; if false, existing mappings are still valid but the data has
+  // been updated and so full reflows are in order.
+  static void NotifyUpdatedFonts(bool aFullRebuild);
+
+  mozilla::ipc::IPCResult RecvCreateGMPService();
+
+  mozilla::ipc::IPCResult RecvRemovePermission(
+      nsIPrincipal* aPrincipal, const nsACString& aPermissionType,
+      nsresult* aRv);
+
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(ContentParent, nsIObserver)
+
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_NSIDOMPROCESSPARENT
+  NS_DECL_NSIOBSERVER
+  NS_DECL_NSIDOMGEOPOSITIONCALLBACK
+  NS_DECL_NSIDOMGEOPOSITIONERRORCALLBACK
+  NS_DECL_NSIASYNCSHUTDOWNBLOCKER
+  NS_DECL_NSIINTERFACEREQUESTOR
+
+  /**
+   * MessageManagerCallback methods that we override.
+   */
+  virtual bool DoLoadMessageManagerScript(const nsAString& aURL,
+                                          bool aRunInGlobalScope) override;
+
+  virtual nsresult DoSendAsyncMessage(const nsAString& aMessage,
+                                      StructuredCloneData& aData) override;
+
+  /** Notify that a tab is about to send Destroy to its child. */
+  void NotifyTabWillDestroy();
+
+  /** Notify that a tab is beginning its destruction sequence. */
+  void NotifyTabDestroying();
+
+  /** Notify that a tab was destroyed during normal operation. */
+  void NotifyTabDestroyed(const TabId& aTabId, bool aNotifiedDestroying);
+
+  // Manage the set of `KeepAlive`s on this ContentParent which are preventing
+  // it from being destroyed.
+  void AddKeepAlive();
+  void RemoveKeepAlive();
+
+  TestShellParent* CreateTestShell();
+
+  bool DestroyTestShell(TestShellParent* aTestShell);
+
+  TestShellParent* GetTestShellSingleton();
+
+  // This method can be called on any thread.
+  void RegisterRemoteWorkerActor();
+
+  // This method _must_ be called on main-thread because it can start the
+  // shutting down of the content process.
+  void UnregisterRemoveWorkerActor();
+
+  void ReportChildAlreadyBlocked();
+
+  bool RequestRunToCompletion();
+
+  void UpdateCookieStatus(nsIChannel* aChannel);
+
+  bool IsLaunching() const {
+    return mLifecycleState == LifecycleState::LAUNCHING;
+  }
+  bool IsAlive() const override;
+  bool IsInitialized() const;
+  bool IsSignaledImpendingShutdown() const {
+    return mIsSignaledImpendingShutdown;
+  }
+  bool IsShuttingDown() const {
+    return IsDead() || IsSignaledImpendingShutdown();
+  }
+  bool IsDead() const { return mLifecycleState == LifecycleState::DEAD; }
+
+  bool IsForBrowser() const { return mIsForBrowser; }
+  bool IsForJSPlugin() const {
+    return mJSPluginID != nsFakePluginTag::NOT_JSPLUGIN;
+  }
+
+  GeckoChildProcessHost* Process() const { return mSubprocess; }
+
+  nsIContentProcessInfo* ScriptableHelper() const { return mScriptableHelper; }
+
+  mozilla::dom::ProcessMessageManager* GetMessageManager() const {
+    return mMessageManager;
+  }
+
+  bool NeedsPermissionsUpdate(const nsACString& aPermissionKey) const;
+
+  // Manage pending load states which have been sent to this process, and are
+  // expected to be used to start a load imminently.
+  already_AddRefed<nsDocShellLoadState> TakePendingLoadStateForId(
+      uint64_t aLoadIdentifier);
+  void StorePendingLoadState(nsDocShellLoadState* aLoadState);
+
+  /**
+   * Kill our subprocess and make sure it dies.  Should only be used
+   * in emergency situations since it bypasses the normal shutdown
+   * process.
+   *
+   * WARNING: aReason appears in telemetry, so any new value passed in requires
+   * data review.
+   */
+  void KillHard(const char* aWhy);
+
+  ContentParentId ChildID() const { return mChildID; }
+
+  /**
+   * Get a user-friendly name for this ContentParent.  We make no guarantees
+   * about this name: It might not be unique, apps can spoof special names,
+   * etc.  So please don't use this name to make any decisions about the
+   * ContentParent based on the value returned here.
+   */
+  void FriendlyName(nsAString& aName, bool aAnonymize = false);
+
+  virtual void OnChannelError() override;
+
+  mozilla::ipc::IPCResult RecvInitCrashReporter(
+      const NativeThreadId& aThreadId);
+
+  already_AddRefed<PNeckoParent> AllocPNeckoParent();
+
+  virtual mozilla::ipc::IPCResult RecvPNeckoConstructor(
+      PNeckoParent* aActor) override {
+    return PContentParent::RecvPNeckoConstructor(aActor);
+  }
+
+  mozilla::ipc::IPCResult RecvInitStreamFilter(
+      const uint64_t& aChannelId, const nsAString& aAddonId,
+      InitStreamFilterResolver&& aResolver);
+
+  PHalParent* AllocPHalParent();
+
+  virtual mozilla::ipc::IPCResult RecvPHalConstructor(
+      PHalParent* aActor) override {
+    return PContentParent::RecvPHalConstructor(aActor);
+  }
+
+  PHeapSnapshotTempFileHelperParent* AllocPHeapSnapshotTempFileHelperParent();
+
+  PRemoteSpellcheckEngineParent* AllocPRemoteSpellcheckEngineParent();
+
+  mozilla::ipc::IPCResult RecvRecordingDeviceEvents(
+      const nsAString& aRecordingStatus, const nsAString& aPageURL,
+      const bool& aIsAudio, const bool& aIsVideo);
+
+  bool CycleCollectWithLogs(bool aDumpAllTraces,
+                            nsICycleCollectorLogSink* aSink,
+                            nsIDumpGCAndCCLogsCallback* aCallback);
+
+  mozilla::ipc::IPCResult RecvNotifyTabDestroying(const TabId& aTabId,
+                                                  const ContentParentId& aCpId);
+
+  mozilla::ipc::IPCResult RecvFinishShutdown();
+
+  mozilla::ipc::IPCResult RecvNotifyShutdownSuccess();
+
+  void MaybeInvokeDragSession(BrowserParent* aParent);
+
+  PContentPermissionRequestParent* AllocPContentPermissionRequestParent(
+      const nsTArray<PermissionRequest>& aRequests, nsIPrincipal* aPrincipal,
+      nsIPrincipal* aTopLevelPrincipal, const bool& aIsHandlingUserInput,
+      const bool& aMaybeUnsafePermissionDelegate, const TabId& aTabId);
+
+  bool DeallocPContentPermissionRequestParent(
+      PContentPermissionRequestParent* actor);
+
+  void ForkNewProcess(bool aBlocking);
+
+  mozilla::ipc::IPCResult RecvCreateWindow(
+      PBrowserParent* aThisBrowserParent,
+      const MaybeDiscarded<BrowsingContext>& aParent, PBrowserParent* aNewTab,
+      const uint32_t& aChromeFlags, const bool& aCalledFromJS,
+      const bool& aForPrinting, const bool& aForWindowDotPrint,
+      nsIURI* aURIToLoad, const nsACString& aFeatures,
+      nsIPrincipal* aTriggeringPrincipal, nsIContentSecurityPolicy* aCsp,
+      nsIReferrerInfo* aReferrerInfo, const OriginAttributes& aOriginAttributes,
+      CreateWindowResolver&& aResolve);
+
+  mozilla::ipc::IPCResult RecvCreateWindowInDifferentProcess(
+      PBrowserParent* aThisTab, const MaybeDiscarded<BrowsingContext>& aParent,
+      const uint32_t& aChromeFlags, const bool& aCalledFromJS,
+      nsIURI* aURIToLoad, const nsACString& aFeatures, const nsAString& aName,
+      nsIPrincipal* aTriggeringPrincipal, nsIContentSecurityPolicy* aCsp,
+      nsIReferrerInfo* aReferrerInfo,
+      const OriginAttributes& aOriginAttributes);
+
+  static void BroadcastBlobURLRegistration(
+      const nsACString& aURI, BlobImpl* aBlobImpl, nsIPrincipal* aPrincipal,
+      const Maybe<nsID>& aAgentClusterId,
+      ContentParent* aIgnoreThisCP = nullptr);
+
+  static void BroadcastBlobURLUnregistration(
+      const nsACString& aURI, nsIPrincipal* aPrincipal,
+      ContentParent* aIgnoreThisCP = nullptr);
+
+  mozilla::ipc::IPCResult RecvStoreAndBroadcastBlobURLRegistration(
+      const nsACString& aURI, const IPCBlob& aBlob, nsIPrincipal* aPrincipal,
+      const Maybe<nsID>& aAgentCluster);
+
+  mozilla::ipc::IPCResult RecvUnstoreAndBroadcastBlobURLUnregistration(
+      const nsACString& aURI, nsIPrincipal* aPrincipal);
+
+  virtual int32_t Pid() const override;
+
+  // PURLClassifierParent.
+  PURLClassifierParent* AllocPURLClassifierParent(nsIPrincipal* aPrincipal,
+                                                  bool* aSuccess);
+  virtual mozilla::ipc::IPCResult RecvPURLClassifierConstructor(
+      PURLClassifierParent* aActor, nsIPrincipal* aPrincipal,
+      bool* aSuccess) override;
+
+  // PURLClassifierLocalParent.
+  PURLClassifierLocalParent* AllocPURLClassifierLocalParent(
+      nsIURI* aURI, const nsTArray<IPCURLClassifierFeature>& aFeatures);
+
+  virtual mozilla::ipc::IPCResult RecvPURLClassifierLocalConstructor(
+      PURLClassifierLocalParent* aActor, nsIURI* aURI,
+      nsTArray<IPCURLClassifierFeature>&& aFeatures) override;
+
+  PLoginReputationParent* AllocPLoginReputationParent(nsIURI* aURI);
+
+  virtual mozilla::ipc::IPCResult RecvPLoginReputationConstructor(
+      PLoginReputationParent* aActor, nsIURI* aURI) override;
+
+  bool DeallocPLoginReputationParent(PLoginReputationParent* aActor);
+
+  PSessionStorageObserverParent* AllocPSessionStorageObserverParent();
+
+  virtual mozilla::ipc::IPCResult RecvPSessionStorageObserverConstructor(
+      PSessionStorageObserverParent* aActor) override;
+
+  bool DeallocPSessionStorageObserverParent(
+      PSessionStorageObserverParent* aActor);
+
+  bool DeallocPURLClassifierLocalParent(PURLClassifierLocalParent* aActor);
+
+  bool DeallocPURLClassifierParent(PURLClassifierParent* aActor);
+
+  // Use the PHangMonitor channel to ask the child to repaint a tab.
+  void PaintTabWhileInterruptingJS(BrowserParent* aBrowserParent,
+                                   const layers::LayersObserverEpoch& aEpoch);
+
+  void UnloadLayersWhileInterruptingJS(
+      BrowserParent* aBrowserParent, const layers::LayersObserverEpoch& aEpoch);
+
+  void CancelContentJSExecutionIfRunning(
+      BrowserParent* aBrowserParent,
+      nsIRemoteTab::NavigationType aNavigationType,
+      const CancelContentJSOptions& aCancelContentJSOptions);
+
+  // This function is called when we are about to load a document from an
+  // HTTP(S) or FTP channel for a content process.  It is a useful place
+  // to start to kick off work as early as possible in response to such
+  // document loads.
+  // aShouldWaitForPermissionCookieUpdate is set to true if main thread IPCs for
+  // updating permissions/cookies are sent.
+  nsresult AboutToLoadHttpFtpDocumentForChild(
+      nsIChannel* aChannel,
+      bool* aShouldWaitForPermissionCookieUpdate = nullptr);
+
+  // Send Blob URLs for this aPrincipal if they are not already known to this
+  // content process and mark the process to receive any new/revoked Blob URLs
+  // to this content process forever.
+  void TransmitBlobURLsForPrincipal(nsIPrincipal* aPrincipal);
+
+  nsresult TransmitPermissionsForPrincipal(nsIPrincipal* aPrincipal);
+
+  // Whenever receiving a Principal we need to validate that Principal case
+  // by case, where we grant individual callsites to customize the checks!
+  enum class ValidatePrincipalOptions {
+    AllowNullPtr,  // Not a NullPrincipal but a nullptr as Principal.
+    AllowSystem,
+    AllowExpanded,
+  };
+  bool ValidatePrincipal(
+      nsIPrincipal* aPrincipal,
+      const EnumSet<ValidatePrincipalOptions>& aOptions = {});
+
+  // This function is called in BrowsingContext immediately before IPC call to
+  // load a URI. If aURI is a BlobURL, this method transmits all BlobURLs for
+  // aURI's principal that were previously not transmitted. This allows for
+  // opening a locally created BlobURL in a new tab.
+  //
+  // The reason all previously untransmitted Blobs are transmitted is that the
+  // current BlobURL could contain html code, referring to another untransmitted
+  // BlobURL.
+  //
+  // Should eventually be made obsolete by broader design changes that only
+  // store BlobURLs in the parent process.
+  void TransmitBlobDataIfBlobURL(nsIURI* aURI);
+
+  void OnCompositorDeviceReset() override;
+
+  // Control the priority of the IPC messages for input events.
+  void SetInputPriorityEventEnabled(bool aEnabled);
+  bool IsInputPriorityEventEnabled() { return mIsInputPriorityEventEnabled; }
+
+  static bool IsInputEventQueueSupported();
+
+  mozilla::ipc::IPCResult RecvCreateBrowsingContext(
+      uint64_t aGroupId, BrowsingContext::IPCInitializer&& aInit);
+
+  mozilla::ipc::IPCResult RecvDiscardBrowsingContext(
+      const MaybeDiscarded<BrowsingContext>& aContext, bool aDoDiscard,
+      DiscardBrowsingContextResolver&& aResolve);
+
+  mozilla::ipc::IPCResult RecvWindowClose(
+      const MaybeDiscarded<BrowsingContext>& aContext, bool aTrustedCaller);
+  mozilla::ipc::IPCResult RecvWindowFocus(
+      const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
+      uint64_t aActionId);
+  mozilla::ipc::IPCResult RecvWindowBlur(
+      const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType);
+  mozilla::ipc::IPCResult RecvRaiseWindow(
+      const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
+      uint64_t aActionId);
+  mozilla::ipc::IPCResult RecvAdjustWindowFocus(
+      const MaybeDiscarded<BrowsingContext>& aContext, bool aIsVisible,
+      uint64_t aActionId);
+  mozilla::ipc::IPCResult RecvClearFocus(
+      const MaybeDiscarded<BrowsingContext>& aContext);
+  mozilla::ipc::IPCResult RecvSetFocusedBrowsingContext(
+      const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId);
+  mozilla::ipc::IPCResult RecvSetActiveBrowsingContext(
+      const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId);
+  mozilla::ipc::IPCResult RecvUnsetActiveBrowsingContext(
+      const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId);
+  mozilla::ipc::IPCResult RecvSetFocusedElement(
+      const MaybeDiscarded<BrowsingContext>& aContext, bool aNeedsFocus);
+  mozilla::ipc::IPCResult RecvFinalizeFocusOuter(
+      const MaybeDiscarded<BrowsingContext>& aContext, bool aCanFocus,
+      CallerType aCallerType);
+  mozilla::ipc::IPCResult RecvInsertNewFocusActionId(uint64_t aActionId);
+  mozilla::ipc::IPCResult RecvBlurToParent(
+      const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
+      const MaybeDiscarded<BrowsingContext>& aBrowsingContextToClear,
+      const MaybeDiscarded<BrowsingContext>& aAncestorBrowsingContextToFocus,
+      bool aIsLeavingDocument, bool aAdjustWidget,
+      bool aBrowsingContextToClearHandled,
+      bool aAncestorBrowsingContextToFocusHandled, uint64_t aActionId);
+  mozilla::ipc::IPCResult RecvMaybeExitFullscreen(
+      const MaybeDiscarded<BrowsingContext>& aContext);
+
+  mozilla::ipc::IPCResult RecvWindowPostMessage(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const ClonedOrErrorMessageData& aMessage, const PostMessageData& aData);
+
+  FORWARD_SHMEM_ALLOCATOR_TO(PContentParent)
+
+  mozilla::ipc::IPCResult RecvBlobURLDataRequest(
+      const nsACString& aBlobURL, nsIPrincipal* pTriggeringPrincipal,
+      nsIPrincipal* pLoadingPrincipal,
+      const OriginAttributes& aOriginAttributes, uint64_t aInnerWindowId,
+      const Maybe<nsID>& aAgentClusterId,
+      BlobURLDataRequestResolver&& aResolver);
+
+ protected:
+  bool CheckBrowsingContextEmbedder(CanonicalBrowsingContext* aBC,
+                                    const char* aOperation) const;
+
+  void ActorDestroy(ActorDestroyReason why) override;
+
+  bool ShouldContinueFromReplyTimeout() override;
+
+  void OnVarChanged(const GfxVarUpdate& aVar) override;
+  void OnCompositorUnexpectedShutdown() override;
+
+ private:
+  /**
+   * A map of the remote content process type to a list of content parents
+   * currently available to host *new* tabs/frames of that type.
+   *
+   * If a content process is identified as troubled or dead, it will be
+   * removed from this list, but will still be in the sContentParents list for
+   * the GetAll/GetAllEvenIfDead APIs.
+   */
+  static nsClassHashtable<nsCStringHashKey, nsTArray<ContentParent*>>*
+      sBrowserContentParents;
+  static mozilla::StaticAutoPtr<nsTHashMap<nsUint32HashKey, ContentParent*>>
+      sJSPluginContentParents;
+  static mozilla::StaticAutoPtr<LinkedList<ContentParent>> sContentParents;
+
+  /**
+   * In order to avoid rapidly creating and destroying content processes when
+   * running under e10s, we may keep alive a single unused "web" content
+   * process if it previously had a very short lifetime.
+   *
+   * This process will be re-used during process selection, avoiding spawning a
+   * new process, if the "web" remote type is being requested.
+   */
+  static StaticRefPtr<ContentParent> sRecycledE10SProcess;
+
+  void AddShutdownBlockers();
+  void RemoveShutdownBlockers();
+
+#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
+  // Cached Mac sandbox params used when launching content processes.
+  static mozilla::StaticAutoPtr<std::vector<std::string>> sMacSandboxParams;
+#endif
+
+  // Set aLoadUri to true to load aURIToLoad and to false to only create the
+  // window. aURIToLoad should always be provided, if available, to ensure
+  // compatibility with GeckoView.
+  mozilla::ipc::IPCResult CommonCreateWindow(
+      PBrowserParent* aThisTab, BrowsingContext& aParent, bool aSetOpener,
+      const uint32_t& aChromeFlags, const bool& aCalledFromJS,
+      const bool& aForPrinting, const bool& aForWindowDotPrint,
+      nsIURI* aURIToLoad, const nsACString& aFeatures,
+      BrowserParent* aNextRemoteBrowser, const nsAString& aName,
+      nsresult& aResult, nsCOMPtr<nsIRemoteTab>& aNewRemoteTab,
+      bool* aWindowIsNew, int32_t& aOpenLocation,
+      nsIPrincipal* aTriggeringPrincipal, nsIReferrerInfo* aReferrerInfo,
+      bool aLoadUri, nsIContentSecurityPolicy* aCsp,
+      const OriginAttributes& aOriginAttributes);
+
+  explicit ContentParent(int32_t aPluginID) : ContentParent(""_ns, aPluginID) {}
+  explicit ContentParent(const nsACString& aRemoteType)
+      : ContentParent(aRemoteType, nsFakePluginTag::NOT_JSPLUGIN) {}
+
+  ContentParent(const nsACString& aRemoteType, int32_t aPluginID);
+
+  // Launch the subprocess and associated initialization.
+  // Returns false if the process fails to start.
+  // Deprecated in favor of LaunchSubprocessAsync.
+  bool LaunchSubprocessSync(hal::ProcessPriority aInitialPriority);
+
+  // Launch the subprocess and associated initialization;
+  // returns a promise and signals failure by rejecting.
+  // OS-level launching work is dispatched to another thread, but some
+  // initialization (creating IPDL actors, etc.; see Init()) is run on
+  // the main thread.
+  RefPtr<LaunchPromise> LaunchSubprocessAsync(
+      hal::ProcessPriority aInitialPriority);
+
+  // Common implementation of LaunchSubprocess{Sync,Async}.
+  // Return `true` in case of success, `false` if launch was
+  // aborted because of shutdown.
+  bool BeginSubprocessLaunch(ProcessPriority aPriority);
+  void LaunchSubprocessReject();
+  bool LaunchSubprocessResolve(bool aIsSync, ProcessPriority aPriority);
+
+  // Common initialization after sub process launch.
+  bool InitInternal(ProcessPriority aPriority);
+
+  // Generate a minidump for the child process and one for the main process
+  void GeneratePairedMinidump(const char* aReason);
+  void HandleOrphanedMinidump(nsString* aDumpId);
+
+  virtual ~ContentParent();
+
+  void Init();
+
+  // Some information could be sent to content very early, it
+  // should be send from this function. This function should only be
+  // called after the process has been transformed to browser.
+  void ForwardKnownInfo();
+
+  /**
+   * We might want to reuse barely used content processes if certain criteria
+   * are met.
+   *
+   * With Fission this is a no-op.
+   */
+  bool TryToRecycleE10SOnly();
+
+  /**
+   * If this process is currently being recycled, unmark it as the recycled
+   * content process.
+   * If `aForeground` is true, will also restore the process' foreground
+   * priority if it was previously the recycled content process.
+   *
+   * With Fission this is a no-op.
+   */
+  void StopRecyclingE10SOnly(bool aForeground);
+
+  /**
+   * Removing it from the static array so it won't be returned for new tabs in
+   * GetNewOrUsedBrowserProcess.
+   */
+  void RemoveFromList();
+
+  /**
+   * Return if the process has an active worker or JSPlugin
+   */
+  bool HasActiveWorkerOrJSPlugin();
+
+  /**
+   * Decide whether the process should be kept alive even when it would normally
+   * be shut down, for example when all its tabs are closed.
+   */
+  bool ShouldKeepProcessAlive();
+
+  /**
+   * Mark this ContentParent as dead for the purposes of Get*().
+   * This method is idempotent.
+   */
+  void MarkAsDead();
+
+  /**
+   * Let the process know we are about to send a shutdown through a
+   * non-mainthread side channel in order to bypass mainthread congestion.
+   * This potentially cancels mainthread content JS execution.
+   */
+  void SignalImpendingShutdownToContentJS();
+
+  bool CheckTabDestroyWillKeepAlive(uint32_t aExpectedBrowserCount);
+
+  /**
+   * Check if this process is ready to be shut down, and if it is, begin the
+   * shutdown process. Should be called whenever a change occurs which could
+   * cause the decisions made by `ShouldKeepProcessAlive` to change.
+   *
+   * @param aExpectedBrowserCount The number of PBrowser actors which should
+   *                              not block shutdown. This should usually be 0.
+   * @param aSendShutDown If true, will send the shutdown message in addition
+   *                      to marking the process as dead and starting the force
+   *                      kill timer.
+   */
+  void MaybeBeginShutDown(uint32_t aExpectedBrowserCount = 0,
+                          bool aSendShutDown = true);
+
+  /**
+   * How we will shut down this ContentParent and its subprocess.
+   */
+  enum ShutDownMethod {
+    // Send a shutdown message and wait for FinishShutdown call back.
+    SEND_SHUTDOWN_MESSAGE,
+    // Close the channel ourselves and let the subprocess clean up itself.
+    CLOSE_CHANNEL,
+    // Close the channel with error and let the subprocess clean up itself.
+    CLOSE_CHANNEL_WITH_ERROR,
+  };
+
+  void MaybeAsyncSendShutDownMessage();
+
+  /**
+   * Exit the subprocess and vamoose.  After this call IsAlive()
+   * will return false and this ContentParent will not be returned
+   * by the Get*() funtions.  However, the shutdown sequence itself
+   * may be asynchronous.
+   *
+   * If aMethod is CLOSE_CHANNEL_WITH_ERROR and this is the first call
+   * to ShutDownProcess, then we'll close our channel using CloseWithError()
+   * rather than vanilla Close().  CloseWithError() indicates to IPC that this
+   * is an abnormal shutdown (e.g. a crash).
+   */
+  bool ShutDownProcess(ShutDownMethod aMethod);
+
+  // Perform any steps necesssary to gracefully shtudown the message
+  // manager and null out mMessageManager.
+  void ShutDownMessageManager();
+
+  // Start the force-kill timer on shutdown.
+  void StartForceKillTimer();
+
+  // Ensure that the permissions for the giben Permission key are set in the
+  // content process.
+  //
+  // See nsIPermissionManager::GetPermissionsForKey for more information on
+  // these keys.
+  void EnsurePermissionsByKey(const nsACString& aKey,
+                              const nsACString& aOrigin);
+
+  static void ForceKillTimerCallback(nsITimer* aTimer, void* aClosure);
+
+  bool CanOpenBrowser(const IPCTabContext& aContext);
+
+  /**
+   * Get or create the corresponding content parent array to
+   * |aContentProcessType|.
+   */
+  static nsTArray<ContentParent*>& GetOrCreatePool(
+      const nsACString& aContentProcessType);
+
+  mozilla::ipc::IPCResult RecvInitBackground(
+      Endpoint<mozilla::ipc::PBackgroundStarterParent>&& aEndpoint);
+
+  mozilla::ipc::IPCResult RecvAddMemoryReport(const MemoryReport& aReport);
+  mozilla::ipc::IPCResult RecvAddPerformanceMetrics(
+      const nsID& aID, nsTArray<PerformanceInfo>&& aMetrics);
+
+  bool DeallocPRemoteSpellcheckEngineParent(PRemoteSpellcheckEngineParent*);
+
+  mozilla::ipc::IPCResult RecvCloneDocumentTreeInto(
+      const MaybeDiscarded<BrowsingContext>& aSource,
+      const MaybeDiscarded<BrowsingContext>& aTarget, PrintData&& aPrintData);
+
+  mozilla::ipc::IPCResult RecvUpdateRemotePrintSettings(
+      const MaybeDiscarded<BrowsingContext>& aTarget, PrintData&& aPrintData);
+
+  mozilla::ipc::IPCResult RecvConstructPopupBrowser(
+      ManagedEndpoint<PBrowserParent>&& actor,
+      ManagedEndpoint<PWindowGlobalParent>&& windowEp, const TabId& tabId,
+      const IPCTabContext& context, const WindowGlobalInit& initialWindowInit,
+      const uint32_t& chromeFlags);
+
+  mozilla::ipc::IPCResult RecvIsSecureURI(
+      nsIURI* aURI, const OriginAttributes& aOriginAttributes,
+      bool* aIsSecureURI);
+
+  mozilla::ipc::IPCResult RecvAccumulateMixedContentHSTS(
+      nsIURI* aURI, const bool& aActive,
+      const OriginAttributes& aOriginAttributes);
+
+  bool DeallocPHalParent(PHalParent*);
+
+  bool DeallocPHeapSnapshotTempFileHelperParent(
+      PHeapSnapshotTempFileHelperParent*);
+
+  PCycleCollectWithLogsParent* AllocPCycleCollectWithLogsParent(
+      const bool& aDumpAllTraces, const FileDescriptor& aGCLog,
+      const FileDescriptor& aCCLog);
+
+  bool DeallocPCycleCollectWithLogsParent(PCycleCollectWithLogsParent* aActor);
+
+  PTestShellParent* AllocPTestShellParent();
+
+  bool DeallocPTestShellParent(PTestShellParent* shell);
+
+  PScriptCacheParent* AllocPScriptCacheParent(const FileDescOrError& cacheFile,
+                                              const bool& wantCacheData);
+
+  bool DeallocPScriptCacheParent(PScriptCacheParent* shell);
+
+  already_AddRefed<PExternalHelperAppParent> AllocPExternalHelperAppParent(
+      nsIURI* aUri, const Maybe<mozilla::net::LoadInfoArgs>& aLoadInfoArgs,
+      const nsACString& aMimeContentType, const nsACString& aContentDisposition,
+      const uint32_t& aContentDispositionHint,
+      const nsAString& aContentDispositionFilename, const bool& aForceSave,
+      const int64_t& aContentLength, const bool& aWasFileChannel,
+      nsIURI* aReferrer, const MaybeDiscarded<BrowsingContext>& aContext,
+      const bool& aShouldCloseWindow);
+
+  mozilla::ipc::IPCResult RecvPExternalHelperAppConstructor(
+      PExternalHelperAppParent* actor, nsIURI* uri,
+      const Maybe<LoadInfoArgs>& loadInfoArgs,
+      const nsACString& aMimeContentType, const nsACString& aContentDisposition,
+      const uint32_t& aContentDispositionHint,
+      const nsAString& aContentDispositionFilename, const bool& aForceSave,
+      const int64_t& aContentLength, const bool& aWasFileChannel,
+      nsIURI* aReferrer, const MaybeDiscarded<BrowsingContext>& aContext,
+      const bool& aShouldCloseWindow) override;
+
+  already_AddRefed<PHandlerServiceParent> AllocPHandlerServiceParent();
+
+  PMediaParent* AllocPMediaParent();
+
+  bool DeallocPMediaParent(PMediaParent* aActor);
+
+  PBenchmarkStorageParent* AllocPBenchmarkStorageParent();
+
+  bool DeallocPBenchmarkStorageParent(PBenchmarkStorageParent* aActor);
+
+#ifdef MOZ_WEBSPEECH
+  PSpeechSynthesisParent* AllocPSpeechSynthesisParent();
+  bool DeallocPSpeechSynthesisParent(PSpeechSynthesisParent* aActor);
+
+  virtual mozilla::ipc::IPCResult RecvPSpeechSynthesisConstructor(
+      PSpeechSynthesisParent* aActor) override;
+#endif
+
+  PWebBrowserPersistDocumentParent* AllocPWebBrowserPersistDocumentParent(
+      PBrowserParent* aBrowser,
+      const MaybeDiscarded<BrowsingContext>& aContext);
+
+  bool DeallocPWebBrowserPersistDocumentParent(
+      PWebBrowserPersistDocumentParent* aActor);
+
+  mozilla::ipc::IPCResult RecvGetGfxVars(nsTArray<GfxVarUpdate>* aVars);
+
+  mozilla::ipc::IPCResult RecvSetClipboard(const IPCTransferable& aTransferable,
+                                           const int32_t& aWhichClipboard);
+
+  mozilla::ipc::IPCResult RecvGetClipboard(
+      nsTArray<nsCString>&& aTypes, const int32_t& aWhichClipboard,
+      IPCTransferableData* aTransferableData);
+
+  mozilla::ipc::IPCResult RecvEmptyClipboard(const int32_t& aWhichClipboard);
+
+  mozilla::ipc::IPCResult RecvClipboardHasType(nsTArray<nsCString>&& aTypes,
+                                               const int32_t& aWhichClipboard,
+                                               bool* aHasType);
+
+  mozilla::ipc::IPCResult RecvClipboardHasTypesAsync(
+      nsTArray<nsCString>&& aTypes, const int32_t& aWhichClipboard,
+      ClipboardHasTypesAsyncResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvGetExternalClipboardFormats(
+      const int32_t& aWhichClipboard, const bool& aPlainTextOnly,
+      nsTArray<nsCString>* aTypes);
+
+  mozilla::ipc::IPCResult RecvGetClipboardAsync(
+      nsTArray<nsCString>&& aTypes, const int32_t& aWhichClipboard,
+      GetClipboardAsyncResolver&& aResolver);
+
+  already_AddRefed<PClipboardWriteRequestParent>
+  AllocPClipboardWriteRequestParent(const int32_t& aClipboardType);
+
+  mozilla::ipc::IPCResult RecvPlaySound(nsIURI* aURI);
+  mozilla::ipc::IPCResult RecvBeep();
+  mozilla::ipc::IPCResult RecvPlayEventSound(const uint32_t& aEventId);
+
+  mozilla::ipc::IPCResult RecvGetIconForExtension(const nsACString& aFileExt,
+                                                  const uint32_t& aIconSize,
+                                                  nsTArray<uint8_t>* bits);
+
+  mozilla::ipc::IPCResult RecvStartVisitedQueries(
+      const nsTArray<RefPtr<nsIURI>>&);
+
+  mozilla::ipc::IPCResult RecvSetURITitle(nsIURI* uri, const nsAString& title);
+
+  mozilla::ipc::IPCResult RecvShowAlert(nsIAlertNotification* aAlert);
+
+  mozilla::ipc::IPCResult RecvCloseAlert(const nsAString& aName,
+                                         bool aContextClosed);
+
+  mozilla::ipc::IPCResult RecvDisableNotifications(nsIPrincipal* aPrincipal);
+
+  mozilla::ipc::IPCResult RecvOpenNotificationSettings(
+      nsIPrincipal* aPrincipal);
+
+  mozilla::ipc::IPCResult RecvNotificationEvent(
+      const nsAString& aType, const NotificationEventData& aData);
+
+  mozilla::ipc::IPCResult RecvLoadURIExternal(
+      nsIURI* uri, nsIPrincipal* triggeringPrincipal,
+      nsIPrincipal* redirectPrincipal,
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      bool aWasExternallyTriggered, bool aHasValidUserGestureActivation);
+  mozilla::ipc::IPCResult RecvExtProtocolChannelConnectParent(
+      const uint64_t& registrarId);
+
+  mozilla::ipc::IPCResult RecvSyncMessage(
+      const nsAString& aMsg, const ClonedMessageData& aData,
+      nsTArray<StructuredCloneData>* aRetvals);
+
+  mozilla::ipc::IPCResult RecvAsyncMessage(const nsAString& aMsg,
+                                           const ClonedMessageData& aData);
+
+  // MOZ_CAN_RUN_SCRIPT_BOUNDARY because we don't have MOZ_CAN_RUN_SCRIPT bits
+  // in IPC code yet.
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  mozilla::ipc::IPCResult RecvAddGeolocationListener(const bool& aHighAccuracy);
+  mozilla::ipc::IPCResult RecvRemoveGeolocationListener();
+
+  // MOZ_CAN_RUN_SCRIPT_BOUNDARY because we don't have MOZ_CAN_RUN_SCRIPT bits
+  // in IPC code yet.
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY
+  mozilla::ipc::IPCResult RecvSetGeolocationHigherAccuracy(const bool& aEnable);
+
+  mozilla::ipc::IPCResult RecvConsoleMessage(const nsAString& aMessage);
+
+  mozilla::ipc::IPCResult RecvScriptError(
+      const nsAString& aMessage, const nsAString& aSourceName,
+      const nsAString& aSourceLine, const uint32_t& aLineNumber,
+      const uint32_t& aColNumber, const uint32_t& aFlags,
+      const nsACString& aCategory, const bool& aIsFromPrivateWindow,
+      const uint64_t& aInnerWindowId, const bool& aIsFromChromeContext);
+
+  mozilla::ipc::IPCResult RecvReportFrameTimingData(
+      const mozilla::Maybe<LoadInfoArgs>& loadInfoArgs,
+      const nsAString& entryName, const nsAString& initiatorType,
+      UniquePtr<PerformanceTimingData>&& aData);
+
+  mozilla::ipc::IPCResult RecvScriptErrorWithStack(
+      const nsAString& aMessage, const nsAString& aSourceName,
+      const nsAString& aSourceLine, const uint32_t& aLineNumber,
+      const uint32_t& aColNumber, const uint32_t& aFlags,
+      const nsACString& aCategory, const bool& aIsFromPrivateWindow,
+      const bool& aIsFromChromeContext, const ClonedMessageData& aStack);
+
+ private:
+  mozilla::ipc::IPCResult RecvScriptErrorInternal(
+      const nsAString& aMessage, const nsAString& aSourceName,
+      const nsAString& aSourceLine, const uint32_t& aLineNumber,
+      const uint32_t& aColNumber, const uint32_t& aFlags,
+      const nsACString& aCategory, const bool& aIsFromPrivateWindow,
+      const bool& aIsFromChromeContext,
+      const ClonedMessageData* aStack = nullptr);
+
+ public:
+  mozilla::ipc::IPCResult RecvCommitBrowsingContextTransaction(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      BrowsingContext::BaseTransaction&& aTransaction, uint64_t aEpoch);
+
+  mozilla::ipc::IPCResult RecvCommitWindowContextTransaction(
+      const MaybeDiscarded<WindowContext>& aContext,
+      WindowContext::BaseTransaction&& aTransaction, uint64_t aEpoch);
+
+  mozilla::ipc::IPCResult RecvAddSecurityState(
+      const MaybeDiscarded<WindowContext>& aContext, uint32_t aStateFlags);
+
+  mozilla::ipc::IPCResult RecvFirstIdle();
+
+  mozilla::ipc::IPCResult RecvDeviceReset();
+
+  mozilla::ipc::IPCResult RecvCopyFavicon(nsIURI* aOldURI, nsIURI* aNewURI,
+                                          const bool& aInPrivateBrowsing);
+
+  mozilla::ipc::IPCResult RecvFindImageText(IPCImage&&, nsTArray<nsCString>&&,
+                                            FindImageTextResolver&&);
+
+  virtual void ProcessingError(Result aCode, const char* aMsgName) override;
+
+  mozilla::ipc::IPCResult RecvGraphicsError(const nsACString& aError);
+
+  mozilla::ipc::IPCResult RecvBeginDriverCrashGuard(const uint32_t& aGuardType,
+                                                    bool* aOutCrashed);
+
+  mozilla::ipc::IPCResult RecvEndDriverCrashGuard(const uint32_t& aGuardType);
+
+  mozilla::ipc::IPCResult RecvAddIdleObserver(const uint64_t& observerId,
+                                              const uint32_t& aIdleTimeInS);
+
+  mozilla::ipc::IPCResult RecvRemoveIdleObserver(const uint64_t& observerId,
+                                                 const uint32_t& aIdleTimeInS);
+
+  mozilla::ipc::IPCResult RecvBackUpXResources(
+      const FileDescriptor& aXSocketFd);
+
+  mozilla::ipc::IPCResult RecvRequestAnonymousTemporaryFile(
+      const uint64_t& aID);
+
+  mozilla::ipc::IPCResult RecvCreateAudioIPCConnection(
+      CreateAudioIPCConnectionResolver&& aResolver);
+
+  already_AddRefed<extensions::PExtensionsParent> AllocPExtensionsParent();
+
+#ifdef MOZ_WEBRTC
+  PWebrtcGlobalParent* AllocPWebrtcGlobalParent();
+  bool DeallocPWebrtcGlobalParent(PWebrtcGlobalParent* aActor);
+#endif
+
+  mozilla::ipc::IPCResult RecvUpdateDropEffect(const uint32_t& aDragAction,
+                                               const uint32_t& aDropEffect);
+
+  mozilla::ipc::IPCResult RecvShutdownProfile(const nsACString& aProfile);
+
+  mozilla::ipc::IPCResult RecvShutdownPerfStats(const nsACString& aPerfStats);
+
+  mozilla::ipc::IPCResult RecvGetGraphicsDeviceInitData(
+      ContentDeviceData* aOut);
+
+  mozilla::ipc::IPCResult RecvGetOutputColorProfileData(
+      nsTArray<uint8_t>* aOutputColorProfileData);
+
+  mozilla::ipc::IPCResult RecvGetFontListShmBlock(
+      const uint32_t& aGeneration, const uint32_t& aIndex,
+      base::SharedMemoryHandle* aOut);
+
+  mozilla::ipc::IPCResult RecvInitializeFamily(const uint32_t& aGeneration,
+                                               const uint32_t& aFamilyIndex,
+                                               const bool& aLoadCmaps);
+
+  mozilla::ipc::IPCResult RecvSetCharacterMap(
+      const uint32_t& aGeneration, const mozilla::fontlist::Pointer& aFacePtr,
+      const gfxSparseBitSet& aMap);
+
+  mozilla::ipc::IPCResult RecvInitOtherFamilyNames(const uint32_t& aGeneration,
+                                                   const bool& aDefer,
+                                                   bool* aLoaded);
+
+  mozilla::ipc::IPCResult RecvSetupFamilyCharMap(
+      const uint32_t& aGeneration,
+      const mozilla::fontlist::Pointer& aFamilyPtr);
+
+  mozilla::ipc::IPCResult RecvStartCmapLoading(const uint32_t& aGeneration,
+                                               const uint32_t& aStartIndex);
+
+  mozilla::ipc::IPCResult RecvGetHyphDict(nsIURI* aURIParams,
+                                          base::SharedMemoryHandle* aOutHandle,
+                                          uint32_t* aOutSize);
+
+  mozilla::ipc::IPCResult RecvNotifyBenchmarkResult(const nsAString& aCodecName,
+                                                    const uint32_t& aDecodeFPS);
+
+  mozilla::ipc::IPCResult RecvNotifyPushObservers(const nsACString& aScope,
+                                                  nsIPrincipal* aPrincipal,
+                                                  const nsAString& aMessageId);
+
+  mozilla::ipc::IPCResult RecvNotifyPushObserversWithData(
+      const nsACString& aScope, nsIPrincipal* aPrincipal,
+      const nsAString& aMessageId, nsTArray<uint8_t>&& aData);
+
+  mozilla::ipc::IPCResult RecvNotifyPushSubscriptionChangeObservers(
+      const nsACString& aScope, nsIPrincipal* aPrincipal);
+
+  mozilla::ipc::IPCResult RecvPushError(const nsACString& aScope,
+                                        nsIPrincipal* aPrincipal,
+                                        const nsAString& aMessage,
+                                        const uint32_t& aFlags);
+
+  mozilla::ipc::IPCResult RecvNotifyPushSubscriptionModifiedObservers(
+      const nsACString& aScope, nsIPrincipal* aPrincipal);
+
+  mozilla::ipc::IPCResult RecvGetFilesRequest(const nsID& aID,
+                                              const nsAString& aDirectoryPath,
+                                              const bool& aRecursiveFlag);
+
+  mozilla::ipc::IPCResult RecvDeleteGetFilesRequest(const nsID& aID);
+
+  mozilla::ipc::IPCResult RecvAccumulateChildHistograms(
+      nsTArray<HistogramAccumulation>&& aAccumulations);
+  mozilla::ipc::IPCResult RecvAccumulateChildKeyedHistograms(
+      nsTArray<KeyedHistogramAccumulation>&& aAccumulations);
+  mozilla::ipc::IPCResult RecvUpdateChildScalars(
+      nsTArray<ScalarAction>&& aScalarActions);
+  mozilla::ipc::IPCResult RecvUpdateChildKeyedScalars(
+      nsTArray<KeyedScalarAction>&& aScalarActions);
+  mozilla::ipc::IPCResult RecvRecordChildEvents(
+      nsTArray<ChildEventData>&& events);
+  mozilla::ipc::IPCResult RecvRecordDiscardedData(
+      const DiscardedData& aDiscardedData);
+  mozilla::ipc::IPCResult RecvRecordPageLoadEvent(
+      const mozilla::glean::perf::PageLoadExtra& aPageLoadEventExtra);
+  mozilla::ipc::IPCResult RecvRecordOrigin(const uint32_t& aMetricId,
+                                           const nsACString& aOrigin);
+  mozilla::ipc::IPCResult RecvReportContentBlockingLog(
+      const IPCStream& aIPCStream);
+
+  mozilla::ipc::IPCResult RecvBHRThreadHang(const HangDetails& aHangDetails);
+
+  mozilla::ipc::IPCResult RecvAddCertException(
+      nsIX509Cert* aCert, const nsACString& aHostName, int32_t aPort,
+      const OriginAttributes& aOriginAttributes, bool aIsTemporary,
+      AddCertExceptionResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvAutomaticStorageAccessPermissionCanBeGranted(
+      nsIPrincipal* aPrincipal,
+      AutomaticStorageAccessPermissionCanBeGrantedResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvStorageAccessPermissionGrantedForOrigin(
+      uint64_t aTopLevelWindowId,
+      const MaybeDiscarded<BrowsingContext>& aParentContext,
+      nsIPrincipal* aTrackingPrincipal, const nsACString& aTrackingOrigin,
+      const int& aAllowMode,
+      const Maybe<
+          ContentBlockingNotifier::StorageAccessPermissionGrantedReason>&
+          aReason,
+      StorageAccessPermissionGrantedForOriginResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvCompleteAllowAccessFor(
+      const MaybeDiscarded<BrowsingContext>& aParentContext,
+      uint64_t aTopLevelWindowId, nsIPrincipal* aTrackingPrincipal,
+      const nsACString& aTrackingOrigin, uint32_t aCookieBehavior,
+      const ContentBlockingNotifier::StorageAccessPermissionGrantedReason&
+          aReason,
+      CompleteAllowAccessForResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvSetAllowStorageAccessRequestFlag(
+      nsIPrincipal* aEmbeddedPrincipal, nsIURI* aEmbeddingOrigin,
+      SetAllowStorageAccessRequestFlagResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvTestAllowStorageAccessRequestFlag(
+      nsIPrincipal* aEmbeddingPrincipal, nsIURI* aEmbeddedOrigin,
+      TestAllowStorageAccessRequestFlagResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvStoreUserInteractionAsPermission(
+      nsIPrincipal* aPrincipal);
+
+  mozilla::ipc::IPCResult RecvTestCookiePermissionDecided(
+      const MaybeDiscarded<BrowsingContext>& aContext, nsIPrincipal* aPrincipal,
+      const TestCookiePermissionDecidedResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvTestStorageAccessPermission(
+      nsIPrincipal* aEmbeddingPrincipal, const nsCString& aEmbeddedOrigin,
+      const TestStorageAccessPermissionResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvNotifyMediaPlaybackChanged(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      MediaPlaybackState aState);
+
+  mozilla::ipc::IPCResult RecvNotifyMediaAudibleChanged(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      MediaAudibleState aState);
+
+  mozilla::ipc::IPCResult RecvNotifyPictureInPictureModeChanged(
+      const MaybeDiscarded<BrowsingContext>& aContext, bool aEnabled);
+
+  mozilla::ipc::IPCResult RecvNotifyMediaSessionUpdated(
+      const MaybeDiscarded<BrowsingContext>& aContext, bool aIsCreated);
+
+  mozilla::ipc::IPCResult RecvNotifyUpdateMediaMetadata(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const Maybe<MediaMetadataBase>& aMetadata);
+
+  mozilla::ipc::IPCResult RecvNotifyMediaSessionPlaybackStateChanged(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      MediaSessionPlaybackState aPlaybackState);
+
+  mozilla::ipc::IPCResult RecvNotifyMediaSessionSupportedActionChanged(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      MediaSessionAction aAction, bool aEnabled);
+
+  mozilla::ipc::IPCResult RecvNotifyMediaFullScreenState(
+      const MaybeDiscarded<BrowsingContext>& aContext, bool aIsInFullScreen);
+
+  mozilla::ipc::IPCResult RecvNotifyPositionStateChanged(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const PositionState& aState);
+
+  mozilla::ipc::IPCResult RecvAddOrRemovePageAwakeRequest(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const bool& aShouldAddCount);
+
+#if defined(XP_WIN)
+  mozilla::ipc::IPCResult RecvGetModulesTrust(
+      ModulePaths&& aModPaths, bool aRunAtNormalPriority,
+      GetModulesTrustResolver&& aResolver);
+#endif  // defined(XP_WIN)
+
+  mozilla::ipc::IPCResult RecvReportServiceWorkerShutdownProgress(
+      uint32_t aShutdownStateId,
+      ServiceWorkerShutdownState::Progress aProgress);
+
+  mozilla::ipc::IPCResult RecvRawMessage(
+      const JSActorMessageMeta& aMeta, const Maybe<ClonedMessageData>& aData,
+      const Maybe<ClonedMessageData>& aStack);
+
+  mozilla::ipc::IPCResult RecvAbortOtherOrientationPendingPromises(
+      const MaybeDiscarded<BrowsingContext>& aContext);
+
+  mozilla::ipc::IPCResult RecvNotifyOnHistoryReload(
+      const MaybeDiscarded<BrowsingContext>& aContext, const bool& aForceReload,
+      NotifyOnHistoryReloadResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvHistoryCommit(
+      const MaybeDiscarded<BrowsingContext>& aContext, const uint64_t& aLoadID,
+      const nsID& aChangeID, const uint32_t& aLoadType, const bool& aPersist,
+      const bool& aCloneEntryChildren, const bool& aChannelExpired,
+      const uint32_t& aCacheKey);
+
+  mozilla::ipc::IPCResult RecvHistoryGo(
+      const MaybeDiscarded<BrowsingContext>& aContext, int32_t aOffset,
+      uint64_t aHistoryEpoch, bool aRequireUserInteraction,
+      bool aUserActivation, HistoryGoResolver&& aResolveRequestedIndex);
+
+  mozilla::ipc::IPCResult RecvSynchronizeLayoutHistoryState(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      nsILayoutHistoryState* aState);
+
+  mozilla::ipc::IPCResult RecvSessionHistoryEntryTitle(
+      const MaybeDiscarded<BrowsingContext>& aContext, const nsAString& aTitle);
+
+  mozilla::ipc::IPCResult RecvSessionHistoryEntryScrollRestorationIsManual(
+      const MaybeDiscarded<BrowsingContext>& aContext, const bool& aIsManual);
+
+  mozilla::ipc::IPCResult RecvSessionHistoryEntryScrollPosition(
+      const MaybeDiscarded<BrowsingContext>& aContext, const int32_t& aX,
+      const int32_t& aY);
+
+  mozilla::ipc::IPCResult RecvSessionHistoryEntryCacheKey(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const uint32_t& aCacheKey);
+
+  mozilla::ipc::IPCResult RecvSessionHistoryEntryWireframe(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const Wireframe& aWireframe);
+
+  mozilla::ipc::IPCResult
+  RecvSessionHistoryEntryStoreWindowNameInContiguousEntries(
+      const MaybeDiscarded<BrowsingContext>& aContext, const nsAString& aName);
+
+  mozilla::ipc::IPCResult RecvGetLoadingSessionHistoryInfoFromParent(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      GetLoadingSessionHistoryInfoFromParentResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvRemoveFromBFCache(
+      const MaybeDiscarded<BrowsingContext>& aContext);
+
+  mozilla::ipc::IPCResult RecvSetActiveSessionHistoryEntry(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const Maybe<nsPoint>& aPreviousScrollPos, SessionHistoryInfo&& aInfo,
+      uint32_t aLoadType, uint32_t aUpdatedCacheKey, const nsID& aChangeID);
+
+  mozilla::ipc::IPCResult RecvReplaceActiveSessionHistoryEntry(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      SessionHistoryInfo&& aInfo);
+
+  mozilla::ipc::IPCResult RecvRemoveDynEntriesFromActiveSessionHistoryEntry(
+      const MaybeDiscarded<BrowsingContext>& aContext);
+
+  mozilla::ipc::IPCResult RecvRemoveFromSessionHistory(
+      const MaybeDiscarded<BrowsingContext>& aContext, const nsID& aChangeID);
+
+  mozilla::ipc::IPCResult RecvHistoryReload(
+      const MaybeDiscarded<BrowsingContext>& aContext,
+      const uint32_t aReloadFlags);
+
+  mozilla::ipc::IPCResult RecvCleanupPendingLoadState(uint64_t aLoadIdentifier);
+
+  // Notify the ContentChild to enable the input event prioritization when
+  // initializing.
+  void MaybeEnableRemoteInputEventQueue();
+
+#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
+  void AppendSandboxParams(std::vector<std::string>& aArgs);
+  void AppendDynamicSandboxParams(std::vector<std::string>& aArgs);
+#endif
+
+  mozilla::ipc::IPCResult RecvFOGData(ByteBuf&& buf);
+
+  mozilla::ipc::IPCResult RecvSetContainerFeaturePolicy(
+      const MaybeDiscardedBrowsingContext& aContainerContext,
+      FeaturePolicy* aContainerFeaturePolicy);
+
+  mozilla::ipc::IPCResult RecvGetSystemIcon(nsIURI* aURI,
+                                            GetSystemIconResolver&& aResolver);
+
+#ifdef FUZZING_SNAPSHOT
+  mozilla::ipc::IPCResult RecvSignalFuzzingReady();
+#endif
+
+ public:
+  void SendGetFilesResponseAndForget(const nsID& aID,
+                                     const GetFilesResponseResult& aResult);
+
+  bool SendRequestMemoryReport(const uint32_t& aGeneration,
+                               const bool& aAnonymize,
+                               const bool& aMinimizeMemoryUsage,
+                               const Maybe<FileDescriptor>& aDMDFile) override;
+
+  void AddBrowsingContextGroup(BrowsingContextGroup* aGroup);
+  void RemoveBrowsingContextGroup(BrowsingContextGroup* aGroup);
+
+  // See `BrowsingContext::mEpochs` for an explanation of this field.
+  uint64_t GetBrowsingContextFieldEpoch() const {
+    return mBrowsingContextFieldEpoch;
+  }
+
+  void UpdateNetworkLinkType();
+
+  already_AddRefed<JSActor> InitJSActor(JS::Handle<JSObject*> aMaybeActor,
+                                        const nsACString& aName,
+                                        ErrorResult& aRv) override;
+  mozilla::ipc::IProtocol* AsNativeActor() override { return this; }
+
+  static already_AddRefed<nsIPrincipal> CreateRemoteTypeIsolationPrincipal(
+      const nsACString& aRemoteType);
+
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+  bool IsBlockingShutdown() { return mBlockShutdownCalled; }
+#endif
+
+  ThreadsafeContentParentHandle* ThreadsafeHandle() const {
+    return mThreadsafeHandle;
+  }
+
+ private:
+  // Return an existing ContentParent if possible. Otherwise, `nullptr`.
+  static already_AddRefed<ContentParent> GetUsedBrowserProcess(
+      const nsACString& aRemoteType, nsTArray<ContentParent*>& aContentParents,
+      uint32_t aMaxContentParents, bool aPreferUsed, ProcessPriority aPriority);
+
+  void AddToPool(nsTArray<ContentParent*>&);
+  void RemoveFromPool(nsTArray<ContentParent*>&);
+  void AssertNotInPool();
+
+  void AssertAlive();
+
+ private:
+  // If you add strong pointers to cycle collected objects here, be sure to
+  // release these objects in ShutDownProcess.  See the comment there for more
+  // details.
+
+  GeckoChildProcessHost* mSubprocess;
+  const TimeStamp mLaunchTS;  // used to calculate time to start content process
+  TimeStamp mLaunchYieldTS;   // used to calculate async launch main thread time
+  TimeStamp mActivateTS;
+
+  bool mIsAPreallocBlocker;  // We called AddBlocker for this ContentParent
+
+  nsCString mRemoteType;
+  nsCString mProfile;
+  nsCOMPtr<nsIPrincipal> mRemoteTypeIsolationPrincipal;
+
+  ContentParentId mChildID;
+  int32_t mGeolocationWatchID;
+
+  // This contains the id for the JS plugin (@see nsFakePluginTag) if this is
+  // the ContentParent for a process containing iframes for that JS plugin. If
+  // this is not a ContentParent for a JS plugin then it contains the value
+  // nsFakePluginTag::NOT_JSPLUGIN.
+  int32_t mJSPluginID;
+
+  // After we initiate shutdown, we also start a timer to ensure
+  // that even content processes that are 100% blocked (say from
+  // SIGSTOP), are still killed eventually.  This task enforces that
+  // timer.
+  nsCOMPtr<nsITimer> mForceKillTimer;
+
+  // Threadsafe handle object which can be used by actors like PBackground to
+  // track the identity and other relevant information about the content process
+  // they're attached to.
+  const RefPtr<ThreadsafeContentParentHandle> mThreadsafeHandle;
+
+  // How many tabs we're waiting to finish their destruction
+  // sequence.  Precisely, how many BrowserParents have called
+  // NotifyTabDestroying() but not called NotifyTabDestroyed().
+  int32_t mNumDestroyingTabs;
+
+  uint32_t mNumKeepaliveCalls;
+
+  // The process starts in the LAUNCHING state, and transitions to
+  // ALIVE once it can accept IPC messages.  It remains ALIVE only
+  // while remote content is being actively used from this process.
+  // After the state becaomes DEAD, some previously scheduled IPC
+  // traffic may still pass through.
+  enum class LifecycleState : uint8_t {
+    LAUNCHING,
+    ALIVE,
+    INITIALIZED,
+    DEAD,
+  };
+
+  LifecycleState mLifecycleState;
+
+  uint8_t mIsForBrowser : 1;
+
+  // These variables track whether we've called Close() and KillHard() on our
+  // channel.
+  uint8_t mCalledClose : 1;
+  uint8_t mCalledKillHard : 1;
+  uint8_t mCreatedPairedMinidumps : 1;
+  uint8_t mShutdownPending : 1;
+
+  // Whether or not `LaunchSubprocessResolve` has been called, and whether or
+  // not it returned `true` when called.
+  uint8_t mLaunchResolved : 1;
+  uint8_t mLaunchResolvedOk : 1;
+
+  // True if the input event queue on the main thread of the content process is
+  // enabled.
+  uint8_t mIsRemoteInputEventQueueEnabled : 1;
+
+  // True if we send input events with input priority. Otherwise, we send input
+  // events with normal priority.
+  uint8_t mIsInputPriorityEventEnabled : 1;
+
+  uint8_t mIsInPool : 1;
+
+  // True if we already created a GMP service.
+  uint8_t mGMPCreated : 1;
+
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+  bool mNotifiedImpendingShutdownOnTabWillDestroy = false;
+  bool mBlockShutdownCalled;
+#endif
+
+  nsCOMPtr<nsIContentProcessInfo> mScriptableHelper;
+
+  nsTArray<nsCOMPtr<nsIObserver>> mIdleListeners;
+
+#ifdef MOZ_X11
+  // Dup of child's X socket, used to scope its resources to this
+  // object instead of the child process's lifetime.
+  ScopedClose mChildXSocketFdDup;
+#endif
+
+  RefPtr<PProcessHangMonitorParent> mHangMonitorActor;
+
+  UniquePtr<gfx::DriverCrashGuard> mDriverCrashGuard;
+  UniquePtr<MemoryReportRequestHost> mMemoryReportRequest;
+
+#if defined(XP_LINUX) && defined(MOZ_SANDBOX)
+  mozilla::UniquePtr<SandboxBroker> mSandboxBroker;
+  static mozilla::StaticAutoPtr<SandboxBrokerPolicyFactory>
+      sSandboxBrokerPolicyFactory;
+#endif
+
+  // This hashtable is used to run GetFilesHelper objects in the parent process.
+  // GetFilesHelper can be aborted by receiving RecvDeleteGetFilesRequest.
+  nsRefPtrHashtable<nsIDHashKey, GetFilesHelper> mGetFilesPendingRequests;
+
+  nsTHashSet<nsCString> mActivePermissionKeys;
+
+  nsTArray<nsCString> mBlobURLs;
+
+  // This is intended to be a memory and time efficient means of determining
+  // whether an origin has ever existed in a process so that Blob URL broadcast
+  // doesn't need to transmit every Blob URL to every content process. False
+  // positives are acceptable because receiving a Blob URL does not grant access
+  // to its contents, and the act of creating/revoking a Blob is currently
+  // viewed as an acceptable side-channel leak. In the future bug 1491018 will
+  // moot the need for this structure.
+  nsTArray<uint64_t> mLoadedOriginHashes;
+
+  UniquePtr<mozilla::ipc::CrashReporterHost> mCrashReporter;
+
+  // Collects any pref changes that occur during process launch (after
+  // the initial map is passed in command-line arguments) to be sent
+  // when the process can receive IPC messages.
+  nsTArray<Pref> mQueuedPrefs;
+
+  RefPtr<mozilla::dom::ProcessMessageManager> mMessageManager;
+
+#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
+  // When set to true, indicates that content processes should
+  // initialize their sandbox during startup instead of waiting
+  // for the SetProcessSandbox IPDL message.
+  static bool sEarlySandboxInit;
+#endif
+
+  nsTHashSet<RefPtr<BrowsingContextGroup>> mGroups;
+
+  // When we request a content process to load a document on our behalf, we'll
+  // record the nsDocShellLoadState we sent to the content process mapped by the
+  // load ID. If the load is then requested from the content process, we can
+  // compare the load state and ensure it matches.
+  nsTHashMap<uint64_t, RefPtr<nsDocShellLoadState>> mPendingLoadStates;
+
+  // See `BrowsingContext::mEpochs` for an explanation of this field.
+  uint64_t mBrowsingContextFieldEpoch = 0;
+
+  // A preference serializer used to share preferences with the process.
+  // Cleared once startup is complete.
+  UniquePtr<mozilla::ipc::SharedPreferenceSerializer> mPrefSerializer;
+
+  static uint32_t sMaxContentProcesses;
+  static uint32_t sPageLoadEventCounter;
+
+  bool mIsSignaledImpendingShutdown = false;
+  bool mIsNotifiedShutdownSuccess = false;
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(ContentParent, NS_CONTENTPARENT_IID)
+
+// Threadsafe handle object allowing off-main-thread code to get some
+// information and maintain a weak reference to a ContentParent.
+class ThreadsafeContentParentHandle final {
+  friend class ContentParent;
+
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ThreadsafeContentParentHandle);
+
+  // Get the ChildID of this process. Safe to call from any thread.
+  ContentParentId ChildID() const { return mChildID; }
+
+  // Get the current RemoteType of this ContentParent. Safe to call from any
+  // thread. If the returned RemoteType is PREALLOC_REMOTE_TYPE, it may change
+  // again in the future.
+  nsCString GetRemoteType() MOZ_EXCLUDES(mMutex);
+
+  // Try to get a reference to the real `ContentParent` object from this weak
+  // reference. This may only be called on the main thread.
+  already_AddRefed<ContentParent> GetContentParent()
+      MOZ_REQUIRES(sMainThreadCapability) {
+    return do_AddRef(mWeakActor);
+  }
+
+  // Calls `aCallback` with the current remote worker count and whether or not
+  // shutdown has been started. If the callback returns `true`, registers a new
+  // actor, and returns `true`, otherwise returns `false`.
+  //
+  // NOTE: The internal mutex is held while evaluating `aCallback`.
+  bool MaybeRegisterRemoteWorkerActor(
+      MoveOnlyFunction<bool(uint32_t, bool)> aCallback) MOZ_EXCLUDES(mMutex);
+
+  // Like `MaybeRegisterRemoteWorkerActor`, but unconditional.
+  void RegisterRemoteWorkerActor() MOZ_EXCLUDES(mMutex) {
+    MaybeRegisterRemoteWorkerActor([](uint32_t, bool) { return true; });
+  }
+
+ private:
+  ThreadsafeContentParentHandle(ContentParent* aActor, ContentParentId aChildID,
+                                const nsACString& aRemoteType)
+      : mChildID(aChildID), mRemoteType(aRemoteType), mWeakActor(aActor) {}
+  ~ThreadsafeContentParentHandle() { MOZ_ASSERT(!mWeakActor); }
+
+  mozilla::Mutex mMutex{"ContentParentIdentity"};
+
+  const ContentParentId mChildID;
+
+  nsCString mRemoteType MOZ_GUARDED_BY(mMutex);
+  uint32_t mRemoteWorkerActorCount MOZ_GUARDED_BY(mMutex) = 0;
+  bool mShutdownStarted MOZ_GUARDED_BY(mMutex) = false;
+
+  // Weak reference to the actual ContentParent actor. Only touched on the main
+  // thread to read or clear.
+  ContentParent* mWeakActor MOZ_GUARDED_BY(sMainThreadCapability);
+};
+
+// This is the C++ version of remoteTypePrefix in E10SUtils.sys.mjs.
+const nsDependentCSubstring RemoteTypePrefix(
+    const nsACString& aContentProcessType);
+
+// This is based on isWebRemoteType in E10SUtils.sys.mjs.
+bool IsWebRemoteType(const nsACString& aContentProcessType);
+
+bool IsWebCoopCoepRemoteType(const nsACString& aContentProcessType);
+
+bool IsPrivilegedMozillaRemoteType(const nsACString& aContentProcessType);
+
+bool IsExtensionRemoteType(const nsACString& aContentProcessType);
+
+inline nsISupports* ToSupports(mozilla::dom::ContentParent* aContentParent) {
+  return static_cast<nsIDOMProcessParent*>(aContentParent);
+}
+
+}  // namespace dom
+}  // namespace mozilla
+
+class ParentIdleListener : public nsIObserver {
+  friend class mozilla::dom::ContentParent;
+
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+
+  ParentIdleListener(mozilla::dom::ContentParent* aParent, uint64_t aObserver,
+                     uint32_t aTime)
+      : mParent(aParent), mObserver(aObserver), mTime(aTime) {}
+
+ private:
+  virtual ~ParentIdleListener() = default;
+
+  RefPtr<mozilla::dom::ContentParent> mParent;
+  uint64_t mObserver;
+  uint32_t mTime;
+};
+
+#endif  // mozilla_dom_ContentParent_h
diff --git a/dom/ipc/ContentProcess.cpp b/dom/ipc/ContentProcess.cpp
new file mode 100644
index 0000000000..8761b25860
--- /dev/null
+++ b/dom/ipc/ContentProcess.cpp
@@ -0,0 +1,185 @@
+/* -*- 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 "mozilla/ipc/IOThreadChild.h"
+
+#include "ContentProcess.h"
+#include "base/shared_memory.h"
+#include "mozilla/Preferences.h"
+
+#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
+#  include <stdlib.h>
+#  include "mozilla/Sandbox.h"
+#  include "mozilla/SandboxSettings.h"
+#endif
+
+#include "nsAppRunner.h"
+#include "mozilla/ipc/BackgroundChild.h"
+#include "mozilla/ipc/ProcessUtils.h"
+#include "mozilla/GeckoArgs.h"
+#include "nsCategoryManagerUtils.h"
+
+using mozilla::ipc::IOThreadChild;
+
+namespace mozilla::dom {
+
+static nsresult GetGREDir(nsIFile** aResult) {
+  nsCOMPtr<nsIFile> current;
+  nsresult rv = XRE_GetBinaryPath(getter_AddRefs(current));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+#ifdef OS_MACOSX
+  // Walk out of [subprocess].app/Contents/MacOS to the real GRE dir
+  const int depth = 4;
+#else
+  const int depth = 1;
+#endif
+
+  for (int i = 0; i < depth; ++i) {
+    nsCOMPtr<nsIFile> parent;
+    rv = current->GetParent(getter_AddRefs(parent));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    current = parent;
+    NS_ENSURE_TRUE(current, NS_ERROR_UNEXPECTED);
+  }
+
+#ifdef OS_MACOSX
+  rv = current->SetNativeLeafName("Resources"_ns);
+  NS_ENSURE_SUCCESS(rv, rv);
+#endif
+
+  current.forget(aResult);
+
+  return NS_OK;
+}
+
+ContentProcess::ContentProcess(ProcessId aParentPid,
+                               const nsID& aMessageChannelId)
+    : ProcessChild(aParentPid, aMessageChannelId) {
+  NS_LogInit();
+}
+
+ContentProcess::~ContentProcess() { NS_LogTerm(); }
+
+bool ContentProcess::Init(int aArgc, char* aArgv[]) {
+  Maybe<uint64_t> childID = geckoargs::sChildID.Get(aArgc, aArgv);
+  Maybe<bool> isForBrowser = Nothing();
+  Maybe<const char*> parentBuildID =
+      geckoargs::sParentBuildID.Get(aArgc, aArgv);
+  Maybe<uint64_t> jsInitHandle;
+  Maybe<uint64_t> jsInitLen = geckoargs::sJsInitLen.Get(aArgc, aArgv);
+
+  nsCOMPtr<nsIFile> appDirArg;
+  Maybe<const char*> appDir = geckoargs::sAppDir.Get(aArgc, aArgv);
+  if (appDir.isSome()) {
+    bool flag;
+    nsresult rv = XRE_GetFileFromPath(*appDir, getter_AddRefs(appDirArg));
+    if (NS_FAILED(rv) || NS_FAILED(appDirArg->Exists(&flag)) || !flag) {
+      NS_WARNING("Invalid application directory passed to content process.");
+      appDirArg = nullptr;
+    }
+  }
+
+  Maybe<bool> safeMode = geckoargs::sSafeMode.Get(aArgc, aArgv);
+  if (safeMode.isSome()) {
+    gSafeMode = *safeMode;
+  }
+
+  Maybe<bool> isForBrowerParam = geckoargs::sIsForBrowser.Get(aArgc, aArgv);
+  Maybe<bool> notForBrowserParam = geckoargs::sNotForBrowser.Get(aArgc, aArgv);
+  if (isForBrowerParam.isSome()) {
+    isForBrowser = Some(true);
+  }
+  if (notForBrowserParam.isSome()) {
+    isForBrowser = Some(false);
+  }
+
+  // command line: [-jsInitHandle handle] -jsInitLen length
+#ifdef XP_WIN
+  jsInitHandle = geckoargs::sJsInitHandle.Get(aArgc, aArgv);
+#endif
+
+#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
+  nsCOMPtr<nsIFile> profileDir;
+  bool flag;
+  Maybe<const char*> profile = geckoargs::sProfile.Get(aArgc, aArgv);
+  // xpcshell self-test on macOS will hit this, so check isSome() otherwise
+  // Maybe<> assertions will MOZ_CRASH() us.
+  if (profile.isSome()) {
+    nsresult rv = XRE_GetFileFromPath(*profile, getter_AddRefs(profileDir));
+    if (NS_FAILED(rv) || NS_FAILED(profileDir->Exists(&flag)) || !flag) {
+      NS_WARNING("Invalid profile directory passed to content process.");
+      profileDir = nullptr;
+    }
+  } else {
+    NS_WARNING("No profile directory passed to content process.");
+  }
+#endif /* XP_MACOSX && MOZ_SANDBOX */
+
+  // Did we find all the mandatory flags?
+  if (childID.isNothing() || isForBrowser.isNothing() ||
+      parentBuildID.isNothing()) {
+    return false;
+  }
+
+  if (!ProcessChild::InitPrefs(aArgc, aArgv)) {
+    return false;
+  }
+
+  if (!::mozilla::ipc::ImportSharedJSInit(jsInitHandle.valueOr(0),
+                                          jsInitLen.valueOr(0))) {
+    return false;
+  }
+
+  mContent.Init(TakeInitialEndpoint(), *parentBuildID, *childID, *isForBrowser);
+
+  nsCOMPtr<nsIFile> greDir;
+  nsresult rv = GetGREDir(getter_AddRefs(greDir));
+  if (NS_FAILED(rv)) {
+    return false;
+  }
+
+  nsCOMPtr<nsIFile> xpcomAppDir = appDirArg ? appDirArg : greDir;
+
+  rv = mDirProvider.Initialize(xpcomAppDir, greDir);
+  if (NS_FAILED(rv)) {
+    return false;
+  }
+
+  rv = NS_InitXPCOM(nullptr, xpcomAppDir, &mDirProvider);
+  if (NS_FAILED(rv)) {
+    return false;
+  }
+
+  // "app-startup" is the name of both the category and the event
+  NS_CreateServicesFromCategory("app-startup", nullptr, "app-startup", nullptr);
+
+#if (defined(XP_MACOSX)) && defined(MOZ_SANDBOX)
+  mContent.SetProfileDir(profileDir);
+#  if defined(DEBUG)
+  if (IsContentSandboxEnabled()) {
+    AssertMacSandboxEnabled();
+  }
+#  endif /* DEBUG */
+#endif   /* XP_MACOSX && MOZ_SANDBOX */
+
+  // Do this as early as possible to get the parent process to initialize the
+  // background thread since we'll likely need database information very soon.
+  mozilla::ipc::BackgroundChild::Startup();
+  mozilla::ipc::BackgroundChild::InitContentStarter(&mContent);
+
+  return true;
+}
+
+// Note: CleanUp() never gets called in non-debug builds because we exit early
+// in ContentChild::ActorDestroy().
+void ContentProcess::CleanUp() {
+  mDirProvider.DoShutdown();
+  NS_ShutdownXPCOM(nullptr);
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/ContentProcess.h b/dom/ipc/ContentProcess.h
new file mode 100644
index 0000000000..46d34098e7
--- /dev/null
+++ b/dom/ipc/ContentProcess.h
@@ -0,0 +1,46 @@
+/* -*- 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/. */
+
+#ifndef dom_tabs_ContentThread_h
+#define dom_tabs_ContentThread_h 1
+
+#include "mozilla/ipc/ProcessChild.h"
+#include "ContentChild.h"
+#include "nsXREDirProvider.h"
+
+#if defined(XP_WIN)
+#  include "mozilla/mscom/ProcessRuntime.h"
+#endif
+
+namespace mozilla::dom {
+
+/**
+ * ContentProcess is a singleton on the content process which represents
+ * the main thread where tab instances live.
+ */
+class ContentProcess : public mozilla::ipc::ProcessChild {
+  using ProcessChild = mozilla::ipc::ProcessChild;
+
+ public:
+  ContentProcess(ProcessId aParentPid, const nsID& aMessageChannelId);
+  ~ContentProcess();
+
+  virtual bool Init(int aArgc, char* aArgv[]) override;
+  virtual void CleanUp() override;
+
+ private:
+  ContentChild mContent;
+#if defined(XP_WIN)
+  // This object initializes and configures COM. This must happen prior to
+  // constructing mXREEmbed.
+  mozilla::mscom::ProcessRuntime mCOMRuntime;
+#endif
+  nsXREDirProvider mDirProvider;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // ifndef dom_tabs_ContentThread_h
diff --git a/dom/ipc/ContentProcessManager.cpp b/dom/ipc/ContentProcessManager.cpp
new file mode 100644
index 0000000000..c5647b4f26
--- /dev/null
+++ b/dom/ipc/ContentProcessManager.cpp
@@ -0,0 +1,142 @@
+/* -*- 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 "ContentProcessManager.h"
+#include "ContentParent.h"
+#include "mozilla/AppShutdown.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/dom/BrowsingContextGroup.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+
+#include "mozilla/StaticPtr.h"
+#include "mozilla/ClearOnShutdown.h"
+
+#include "nsPrintfCString.h"
+
+namespace mozilla::dom {
+
+/* static */
+StaticAutoPtr<ContentProcessManager> ContentProcessManager::sSingleton;
+
+/* static */
+ContentProcessManager* ContentProcessManager::GetSingleton() {
+  MOZ_ASSERT(XRE_IsParentProcess());
+
+  if (!sSingleton &&
+      !AppShutdown::IsInOrBeyond(ShutdownPhase::XPCOMShutdownFinal)) {
+    sSingleton = new ContentProcessManager();
+    ClearOnShutdown(&sSingleton);
+  }
+  return sSingleton;
+}
+
+void ContentProcessManager::AddContentProcess(ContentParent* aChildCp) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aChildCp);
+
+  mContentParentMap.WithEntryHandle(aChildCp->ChildID(), [&](auto&& entry) {
+    MOZ_ASSERT_IF(entry, entry.Data() == aChildCp);
+    entry.OrInsert(aChildCp);
+  });
+}
+
+void ContentProcessManager::RemoveContentProcess(
+    const ContentParentId& aChildCpId) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  MOZ_ALWAYS_TRUE(mContentParentMap.Remove(aChildCpId));
+}
+
+ContentParent* ContentProcessManager::GetContentProcessById(
+    const ContentParentId& aChildCpId) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  ContentParent* contentParent = mContentParentMap.Get(aChildCpId);
+  if (NS_WARN_IF(!contentParent)) {
+    return nullptr;
+  }
+  return contentParent;
+}
+
+bool ContentProcessManager::RegisterRemoteFrame(BrowserParent* aChildBp) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aChildBp);
+
+  return mBrowserParentMap.WithEntryHandle(
+      aChildBp->GetTabId(), [&](auto&& entry) {
+        if (entry) {
+          MOZ_ASSERT(entry.Data() == aChildBp);
+          return false;
+        }
+
+        // Ensure that this BrowserParent's BrowsingContextGroup is kept alive
+        // until the BrowserParent has been unregistered, ensuring the group
+        // isn't destroyed while this BrowserParent can still send messages.
+        aChildBp->GetBrowsingContext()->Group()->AddKeepAlive();
+        entry.Insert(aChildBp);
+        return true;
+      });
+}
+
+void ContentProcessManager::UnregisterRemoteFrame(const TabId& aChildTabId) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  auto childBp = mBrowserParentMap.Extract(aChildTabId);
+  MOZ_DIAGNOSTIC_ASSERT(childBp);
+
+  // Clear the corresponding keepalive which was added in `RegisterRemoteFrame`.
+  (*childBp)->GetBrowsingContext()->Group()->RemoveKeepAlive();
+}
+
+ContentParentId ContentProcessManager::GetTabProcessId(
+    const TabId& aChildTabId) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (BrowserParent* browserParent = mBrowserParentMap.Get(aChildTabId)) {
+    return browserParent->Manager()->ChildID();
+  }
+  return ContentParentId(0);
+}
+
+uint32_t ContentProcessManager::GetBrowserParentCountByProcessId(
+    const ContentParentId& aChildCpId) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  ContentParent* contentParent = mContentParentMap.Get(aChildCpId);
+  if (NS_WARN_IF(!contentParent)) {
+    return 0;
+  }
+  return contentParent->ManagedPBrowserParent().Count();
+}
+
+already_AddRefed<BrowserParent>
+ContentProcessManager::GetBrowserParentByProcessAndTabId(
+    const ContentParentId& aChildCpId, const TabId& aChildTabId) {
+  RefPtr<BrowserParent> browserParent = mBrowserParentMap.Get(aChildTabId);
+  if (NS_WARN_IF(!browserParent)) {
+    return nullptr;
+  }
+
+  if (NS_WARN_IF(browserParent->Manager()->ChildID() != aChildCpId)) {
+    return nullptr;
+  }
+
+  return browserParent.forget();
+}
+
+already_AddRefed<BrowserParent>
+ContentProcessManager::GetTopLevelBrowserParentByProcessAndTabId(
+    const ContentParentId& aChildCpId, const TabId& aChildTabId) {
+  RefPtr<BrowserParent> browserParent =
+      GetBrowserParentByProcessAndTabId(aChildCpId, aChildTabId);
+  while (browserParent && browserParent->GetBrowserBridgeParent()) {
+    browserParent = browserParent->GetBrowserBridgeParent()->Manager();
+  }
+
+  return browserParent.forget();
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/ContentProcessManager.h b/dom/ipc/ContentProcessManager.h
new file mode 100644
index 0000000000..bf76051a66
--- /dev/null
+++ b/dom/ipc/ContentProcessManager.h
@@ -0,0 +1,90 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_ContentProcessManager_h
+#define mozilla_dom_ContentProcessManager_h
+
+#include "mozilla/StaticPtr.h"
+#include "mozilla/dom/TabContext.h"
+#include "mozilla/dom/ipc/IdType.h"
+#include "nsTArray.h"
+#include "nsTHashMap.h"
+
+namespace mozilla::dom {
+class ContentParent;
+
+class ContentProcessManager final {
+ public:
+  static ContentProcessManager* GetSingleton();
+  MOZ_COUNTED_DTOR(ContentProcessManager);
+
+  /**
+   * Add a new content process into the map.
+   */
+  void AddContentProcess(ContentParent* aChildCp);
+
+  /**
+   * Remove the content process by id.
+   */
+  void RemoveContentProcess(const ContentParentId& aChildCpId);
+
+  /**
+   * Return the ContentParent pointer by id.
+   */
+  ContentParent* GetContentProcessById(const ContentParentId& aChildCpId);
+
+  /**
+   * Add a new browser parent into the map.
+   */
+  bool RegisterRemoteFrame(BrowserParent* aChildBp);
+
+  /**
+   * Remove the browser parent by the given tab id.
+   */
+  void UnregisterRemoteFrame(const TabId& aChildTabId);
+
+  /**
+   * Get the ContentParentId of the parent of the given tab id.
+   */
+  ContentParentId GetTabProcessId(const TabId& aChildTabId);
+
+  /**
+   * Get the number of BrowserParents managed by the givent content process.
+   * Return 0 when ContentParent couldn't be found via aChildCpId.
+   */
+  uint32_t GetBrowserParentCountByProcessId(const ContentParentId& aChildCpId);
+
+  /**
+   * Get the BrowserParent by the given content process and tab id.
+   * Return nullptr when BrowserParent couldn't be found via aChildCpId
+   * and aChildTabId.
+   */
+  already_AddRefed<BrowserParent> GetBrowserParentByProcessAndTabId(
+      const ContentParentId& aChildCpId, const TabId& aChildTabId);
+
+  /**
+   * Get the BrowserParent on top level by the given content process and tab id.
+   *
+   * This function returns the BrowserParent directly within a BrowserHost,
+   * called top-level BrowserParent here, by given aChildCpId and aChildTabId.
+   * The given aChildCpId and aChildTabId are related to a content process
+   * and a tab respectively.
+   */
+  already_AddRefed<BrowserParent> GetTopLevelBrowserParentByProcessAndTabId(
+      const ContentParentId& aChildCpId, const TabId& aChildTabId);
+
+ private:
+  static StaticAutoPtr<ContentProcessManager> sSingleton;
+
+  nsTHashMap<nsUint64HashKey, ContentParent*> mContentParentMap;
+  nsTHashMap<nsUint64HashKey, BrowserParent*> mBrowserParentMap;
+
+  MOZ_COUNTED_DEFAULT_CTOR(ContentProcessManager);
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_ContentProcessManager_h
diff --git a/dom/ipc/DOMTypes.ipdlh b/dom/ipc/DOMTypes.ipdlh
new file mode 100644
index 0000000000..2b546a9a3e
--- /dev/null
+++ b/dom/ipc/DOMTypes.ipdlh
@@ -0,0 +1,386 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */
+/* 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 "mozilla/GfxMessageUtils.h";
+include "mozilla/dom/CSPMessageUtils.h";
+include "mozilla/dom/DocShellMessageUtils.h";
+include "mozilla/dom/PermissionMessageUtils.h";
+include "mozilla/dom/PropertyBagUtils.h";
+include "mozilla/dom/ReferrerInfoUtils.h";
+include "mozilla/dom/TabMessageUtils.h";
+include "mozilla/ipc/URIUtils.h";
+include "mozilla/layers/LayersMessageUtils.h";
+include "mozilla/net/ClassOfService.h";
+
+include IPCBlob;
+include IPCStream;
+include ProtocolTypes;
+
+using struct mozilla::void_t from "mozilla/ipc/IPCCore.h";
+
+[MoveOnly=data] using struct mozilla::SerializedStructuredCloneBuffer
+  from "mozilla/ipc/SerializedStructuredCloneBuffer.h";
+
+using struct mozilla::dom::LoadingSessionHistoryInfo
+  from "mozilla/dom/SessionHistoryEntry.h";
+
+using mozilla::net::ClassOfService from "mozilla/net/ClassOfService.h";
+
+
+using mozilla::hal::ScreenOrientation from "mozilla/HalIPCUtils.h";
+using mozilla::LayoutDeviceIntRect from "Units.h";
+using mozilla::DesktopIntRect from "Units.h";
+using mozilla::DesktopToLayoutDeviceScale from "Units.h";
+using mozilla::CSSToLayoutDeviceScale from "Units.h";
+using mozilla::CSSRect from "Units.h";
+using mozilla::CSSSize from "Units.h";
+using mozilla::ScreenIntSize from "Units.h";
+using mozilla::LayoutDeviceIntPoint from "Units.h";
+using nsSizeMode from "nsIWidgetListener.h";
+using mozilla::ScrollbarPreference from "mozilla/ScrollbarPreferences.h";
+using mozilla::gfx::SurfaceFormat from "mozilla/gfx/Types.h";
+[RefCounted] using class nsIPrincipal from "nsIPrincipal.h";
+using mozilla::dom::MaybeDiscardedBrowsingContext from "mozilla/dom/BrowsingContext.h";
+[RefCounted] using class nsIURI from "nsIURI.h";
+[RefCounted] using class nsIContentSecurityPolicy from "nsIContentSecurityPolicy.h";
+[RefCounted] using class nsIInputStream from "mozilla/ipc/IPCStreamUtils.h";
+[RefCounted] using class nsIReferrerInfo from "nsIReferrerInfo.h";
+[RefCounted] using class nsIVariant from "nsIVariant.h";
+using mozilla::TimeStamp from "mozilla/TimeStamp.h";
+[RefCounted] using class mozilla::RemoteLazyInputStream from "mozilla/RemoteLazyInputStream.h";
+[MoveOnly] using class mozilla::ipc::BigBuffer from "mozilla/ipc/BigBuffer.h";
+
+namespace mozilla {
+namespace dom {
+
+struct MessagePortIdentifier
+{
+  nsID uuid;
+  nsID destinationUuid;
+  uint32_t sequenceId;
+  bool neutered;
+};
+
+/**
+ * Cross-process representation for postMessage() style payloads where Blobs may
+ * be referenced/"cloned" and (optionally) messageports transferred.  Use
+ * StructuredCloneData in your code to convert between this wire representation
+ * and the StructuredCloneData StructuredCloneHolder-subclass.
+ */
+struct ClonedMessageData
+{
+  SerializedStructuredCloneBuffer data;
+  IPCBlob[] blobs;
+  IPCStream[] inputStreams;
+  MessagePortIdentifier[] identifiers;
+};
+
+struct ErrorMessageData {
+};
+
+union ClonedOrErrorMessageData {
+  ClonedMessageData;
+  ErrorMessageData;
+};
+
+struct RefMessageData {
+  nsID uuid;
+};
+
+union MessageDataType {
+  ClonedMessageData;
+  RefMessageData;
+};
+
+struct MessageData {
+  nsID? agentClusterId;
+  MessageDataType data;
+};
+
+struct ScreenDetails {
+  LayoutDeviceIntRect rect;
+  DesktopIntRect rectDisplayPix;
+  LayoutDeviceIntRect availRect;
+  DesktopIntRect availRectDisplayPix;
+  int32_t pixelDepth;
+  int32_t colorDepth;
+  uint32_t refreshRate; // In Hz, or 0 if not known.
+  DesktopToLayoutDeviceScale contentsScaleFactor;
+  CSSToLayoutDeviceScale defaultCSSScaleFactor;
+  float dpi;
+  ScreenOrientation orientation;
+  uint16_t orientationAngle;
+  bool isPseudoDisplay;
+};
+
+struct DimensionInfo
+{
+  CSSRect rect;
+  CSSSize size;
+  LayoutDeviceIntPoint clientOffset;
+  LayoutDeviceIntPoint chromeOffset;
+};
+
+struct FrameScriptInfo
+{
+  nsString url;
+  bool runInGlobalScope;
+};
+
+struct FeaturePolicyInfo
+{
+  nsString[]   inheritedDeniedFeatureNames;
+  nsString[]   attributeEnabledFeatureNames;
+  nsString     declaredString;
+  nullable nsIPrincipal defaultOrigin;
+  nullable nsIPrincipal selfOrigin;
+  nullable nsIPrincipal srcOrigin;
+};
+
+/**
+ * The information required to complete a window creation request.
+ */
+struct CreatedWindowInfo
+{
+  nsresult rv;
+  bool windowOpened;
+  FrameScriptInfo[] frameScripts;
+  uint32_t maxTouchPoints;
+  DimensionInfo dimensions;
+};
+
+
+/**
+ * PerformanceInfo is used to pass performance info stored
+ * in WorkerPrivate and DocGroup instances, as well as
+ * memory-related information.
+ *
+ * Each (host, pid, windowId) is unique to a given DocGroup or
+ * Worker, and we collect the number of dispatches per Dispatch
+ * category and total execution duration as well as the current
+ * Zone JS Heap usage.
+ *
+ * This IPDL struct reflects the data collected in Performance counters,
+ * in addition of some memory usage information.
+ *
+ * see xpcom/threads/PerformanceCounter.h
+ */
+
+struct MediaMemoryInfo {
+  uint64_t audioSize;
+  uint64_t videoSize;
+  uint64_t resourcesSize;
+};
+
+struct PerformanceMemoryInfo {
+  MediaMemoryInfo media;
+  uint64_t domDom;
+  uint64_t domStyle;
+  uint64_t domOther;
+  uint64_t jsMemUsage;
+};
+
+struct CategoryDispatch
+{
+  // DispatchCategory value
+  uint16_t category;
+  // Number of dispatch
+  uint16_t count;
+};
+
+struct PerformanceInfo
+{
+  // Host of the document, if any
+  nsCString host;
+  // process id
+  uint32_t pid;
+  // window id
+  uint64_t windowId;
+  // Execution time in microseconds
+  uint64_t duration;
+  // Counter ID (unique across processes)
+  uint64_t counterId;
+  // True if the data is collected in a worker
+  bool isWorker;
+  // True if the document window is the top window
+  bool isTopLevel;
+  // Memory
+  PerformanceMemoryInfo memory;
+  // Counters per category. For workers, a single entry
+  CategoryDispatch[] items;
+};
+
+struct DocShellLoadStateInit
+{
+  nullable nsIURI URI;
+  nullable nsIURI OriginalURI;
+  nullable nsIURI ResultPrincipalURI;
+  nullable nsIPrincipal TriggeringPrincipal;
+  nullable nsIReferrerInfo ReferrerInfo;
+  nullable nsIPrincipal PrincipalToInherit;
+  nullable nsIPrincipal PartitionedPrincipalToInherit;
+  nullable nsIURI BaseURI;
+  // The Content Security Policy of the load, that is, the CSP of the entity
+  // responsible for causing the load to occur. Most likely this is the CSP
+  // of the document that started the load. In case the entity starting the
+  // load did not use a CSP, then Csp can be null. Please note that this is
+  // also the CSP that will be applied to the load in case the load
+  // encounters a server side redirect.
+  nullable nsIContentSecurityPolicy Csp;
+  nullable nsIInputStream PostDataStream;
+  nullable nsIInputStream HeadersStream;
+  nullable nsIURI UnstrippedURI;
+  uint64_t LoadIdentifier;
+  nsString Target;
+  nsCString TypeHint;
+  nsString FileName;
+
+  MaybeDiscardedBrowsingContext SourceBrowsingContext;
+  MaybeDiscardedBrowsingContext TargetBrowsingContext;
+
+  // The provided remote type of the process responsible for causing the load to
+  // occur. Validated in the parent process.
+  nsCString TriggeringRemoteType;
+
+  nsString SrcdocData; // useless without sourcedocshell
+
+  nsCString? OriginalURIString;
+
+  nsCString? RemoteTypeOverride;
+
+  LoadingSessionHistoryInfo? loadingSessionHistoryInfo;
+
+  uint32_t LoadType;
+  uint32_t LoadFlags;
+  uint32_t InternalLoadFlags;
+  
+  // The TriggineringSandboxFlags are the SandboxFlags of the entity
+  // responsible for causing the load to occur.
+  uint32_t TriggeringSandboxFlags;
+  int32_t? CancelContentJSEpoch;
+
+  bool ResultPrincipalURIIsSome;
+  bool KeepResultPrincipalURIIfSet;
+  bool LoadReplace;
+  bool InheritPrincipal;
+  bool PrincipalIsExplicit;
+  bool ForceAllowDataURI;
+  bool IsExemptFromHTTPSOnlyMode;
+  bool OriginalFrameSrc;
+  bool IsFormSubmission;
+  bool FirstParty;
+  bool HasValidUserGestureActivation;
+  bool AllowFocusMove;
+  bool IsFromProcessingFrameAttributes;
+
+  // Fields missing due to lack of need or serialization
+  // nsCOMPtr<nsIDocShell> mSourceDocShell;
+  // bool mIsSrcDocLoad; // useless without sourcedocshell
+  // nsIChannel pendingRedirectedChannel; // sent through other mechanism
+
+  bool ChannelInitialized;
+
+  bool TryToReplaceWithSessionHistoryLoad;
+
+  bool IsMetaRefresh;
+};
+
+struct TimedChannelInfo
+{
+  bool timingEnabled;
+  int8_t redirectCount;
+  int8_t internalRedirectCount;
+  TimeStamp asyncOpen;
+  TimeStamp channelCreation;
+  TimeStamp redirectStart;
+  TimeStamp redirectEnd;
+  nsString initiatorType;
+  bool allRedirectsSameOrigin;
+  bool allRedirectsPassTimingAllowCheck;
+  bool? timingAllowCheckForPrincipal;
+  TimeStamp launchServiceWorkerStart;
+  TimeStamp launchServiceWorkerEnd;
+  TimeStamp dispatchFetchEventStart;
+  TimeStamp dispatchFetchEventEnd;
+  TimeStamp handleFetchEventStart;
+  TimeStamp handleFetchEventEnd;
+  TimeStamp responseStart;
+  TimeStamp responseEnd;
+};
+
+struct ReplacementChannelConfigInit
+{
+  uint32_t redirectFlags;
+  ClassOfService classOfService;
+  bool? privateBrowsing;
+  nsCString? method;
+  nullable nsIReferrerInfo referrerInfo;
+  TimedChannelInfo? timedChannelInfo;
+  nullable RemoteLazyInputStream uploadStream;
+  uint64_t uploadStreamLength;
+  bool uploadStreamHasHeaders;
+  nsCString? contentType;
+  nsCString? contentLength;
+};
+
+union IPDLVariantValue
+{
+  bool;
+  uint8_t;   // In practice, uint8_t and uint16_t are likely unneeded,
+  int16_t;   // as signed->unsigned->signed has universal behavior.
+  uint16_t;  // but those conversions are only guaranteed in C++20.
+  int32_t;
+  uint32_t;
+  float;
+  double;
+  nsID;
+  nsString;
+  nsCString;
+  nullable nsIURI;
+  nullable nsIPrincipal;
+};
+
+struct IDPLVariant
+{
+  uint32_t type;  // We explicitly store the original nsIVariant type so that
+                  // the conversion back into a nsVariant later is lossless.
+  IPDLVariantValue data;
+};
+
+struct IPDLProperty
+{
+  nsString name;
+  nullable nsIVariant value;
+};
+
+// Struct with information to show a frame from the parent process.
+struct ParentShowInfo
+{
+  nsString name;
+  bool fakeShowInfo;
+  bool isTransparent;
+  float dpi;
+  int32_t widgetRounding;
+  double defaultScale;
+};
+
+// Struct with information to show an iframe from the process that owns the
+// frame.
+struct OwnerShowInfo {
+  // This can be an IntSize rather than a Rect because content processes always
+  // render to a virtual <0, 0> top-left point.
+  ScreenIntSize size;
+
+  // TODO(emilio): Margin preferences go here.
+  ScrollbarPreference scrollbarPreference;
+
+  // TODO(emilio): I think we should really be able to figure this out from the
+  // parent process too instead.
+  nsSizeMode sizeMode;
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/DocShellMessageUtils.cpp b/dom/ipc/DocShellMessageUtils.cpp
new file mode 100644
index 0000000000..011abe3246
--- /dev/null
+++ b/dom/ipc/DocShellMessageUtils.cpp
@@ -0,0 +1,46 @@
+/* -*- 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 "mozilla/dom/DocShellMessageUtils.h"
+#include "mozilla/dom/DOMTypes.h"
+#include "mozilla/ipc/IPDLParamTraits.h"
+#include "nsSerializationHelper.h"
+
+namespace IPC {
+
+void ParamTraits<nsDocShellLoadState*>::Write(IPC::MessageWriter* aWriter,
+                                              nsDocShellLoadState* aParam) {
+  MOZ_RELEASE_ASSERT(aParam);
+  WriteParam(aWriter, aParam->Serialize(aWriter->GetActor()));
+}
+
+bool ParamTraits<nsDocShellLoadState*>::Read(
+    IPC::MessageReader* aReader, RefPtr<nsDocShellLoadState>* aResult) {
+  mozilla::dom::DocShellLoadStateInit loadState;
+  if (!ReadParam(aReader, &loadState)) {
+    return false;
+  }
+
+  // Assert if we somehow don't have a URI in our IPDL type, because we can't
+  // construct anything out of it. This mimics the assertion in the constructor
+  // for nsDocShellLoadState, but makes it clearer that the
+  // DocShellLoadStateInit IPC object can't be clearly converted into a
+  // nsDocShellLoadState.
+  if (!loadState.URI()) {
+    MOZ_ASSERT_UNREACHABLE("no URI in load state from IPC");
+    return false;
+  }
+
+  bool readSuccess = false;
+  RefPtr result =
+      new nsDocShellLoadState(loadState, aReader->GetActor(), &readSuccess);
+  if (readSuccess) {
+    *aResult = result.forget();
+  }
+  return readSuccess;
+}
+
+}  // namespace IPC
diff --git a/dom/ipc/DocShellMessageUtils.h b/dom/ipc/DocShellMessageUtils.h
new file mode 100644
index 0000000000..1b628bc515
--- /dev/null
+++ b/dom/ipc/DocShellMessageUtils.h
@@ -0,0 +1,48 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_docshell_message_utils_h__
+#define mozilla_dom_docshell_message_utils_h__
+
+#include "ipc/EnumSerializer.h"
+#include "nsCOMPtr.h"
+#include "nsDocShellLoadState.h"
+#include "nsIContentViewer.h"
+#include "mozilla/ScrollbarPreferences.h"
+#include "mozilla/ipc/IPDLParamTraits.h"
+
+namespace IPC {
+
+template <>
+struct ParamTraits<nsDocShellLoadState*> {
+  static void Write(IPC::MessageWriter* aWriter, nsDocShellLoadState* aParam);
+  static bool Read(IPC::MessageReader* aReader,
+                   RefPtr<nsDocShellLoadState>* aResult);
+};
+
+template <>
+struct ParamTraits<mozilla::ScrollbarPreference>
+    : public ContiguousEnumSerializerInclusive<
+          mozilla::ScrollbarPreference, mozilla::ScrollbarPreference::Auto,
+          mozilla::ScrollbarPreference::LAST> {};
+
+template <>
+struct ParamTraits<mozilla::dom::PermitUnloadResult>
+    : public ContiguousEnumSerializerInclusive<
+          mozilla::dom::PermitUnloadResult,
+          mozilla::dom::PermitUnloadResult::eAllowNavigation,
+          mozilla::dom::PermitUnloadResult::eRequestBlockNavigation> {};
+
+template <>
+struct ParamTraits<mozilla::dom::XPCOMPermitUnloadAction>
+    : public ContiguousEnumSerializerInclusive<
+          mozilla::dom::XPCOMPermitUnloadAction,
+          mozilla::dom::XPCOMPermitUnloadAction::ePrompt,
+          mozilla::dom::XPCOMPermitUnloadAction::eDontPromptAndUnload> {};
+
+}  // namespace IPC
+
+#endif  // mozilla_dom_docshell_message_utils_h__
diff --git a/dom/ipc/EffectsInfo.h b/dom/ipc/EffectsInfo.h
new file mode 100644
index 0000000000..bd3a7cc721
--- /dev/null
+++ b/dom/ipc/EffectsInfo.h
@@ -0,0 +1,73 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_EffectsInfo_h
+#define mozilla_dom_EffectsInfo_h
+
+#include "nsRect.h"
+
+namespace mozilla::dom {
+
+/**
+ * An EffectsInfo contains information for a remote browser about the graphical
+ * effects that are being applied to it by ancestor browsers in different
+ * processes.
+ */
+class EffectsInfo {
+ public:
+  EffectsInfo() { *this = EffectsInfo::FullyHidden(); }
+
+  static EffectsInfo VisibleWithinRect(
+      const nsRect& aVisibleRect, const Scale2D& aRasterScale,
+      const ParentLayerToScreenScale2D& aTransformToAncestorScale) {
+    return EffectsInfo{aVisibleRect, aRasterScale, aTransformToAncestorScale};
+  }
+  static EffectsInfo FullyHidden() {
+    return EffectsInfo{nsRect(), Scale2D(), ParentLayerToScreenScale2D()};
+  }
+
+  bool operator==(const EffectsInfo& aOther) const {
+    return mVisibleRect == aOther.mVisibleRect &&
+           mRasterScale == aOther.mRasterScale &&
+           mTransformToAncestorScale == aOther.mTransformToAncestorScale;
+  }
+  bool operator!=(const EffectsInfo& aOther) const {
+    return !(*this == aOther);
+  }
+
+  bool IsVisible() const { return !mVisibleRect.IsEmpty(); }
+
+  // The visible rect of this browser relative to the root frame. If this is
+  // empty then the browser can be considered invisible.
+  nsRect mVisibleRect;
+  // The desired scale factors to apply to rasterized content to match
+  // transforms applied in ancestor browsers. This gets propagated into the
+  // scale in StackingContextHelper.
+  Scale2D mRasterScale;
+  // TransformToAncestorScale to be set on FrameMetrics. It includes CSS
+  // transform scales and cumulative presshell resolution.
+  ParentLayerToScreenScale2D mTransformToAncestorScale;
+  // The difference between mScaleX/Y and mTransformToAncestorScale is the way
+  // that CSS transforms contribute to the scale. mTransformToAncestorScale
+  // includes the exact scale factors of the combined CSS transform whereas
+  // mScaleX/Y tries to take into account animating transform scales by picking
+  // a larger scale so that we don't have to re-rasterize every frame but rather
+  // we can just scale down  content rasterized on a previous frame.
+
+  // If you add new fields here, you must also update operator== and
+  // TabMessageUtils.
+
+ private:
+  EffectsInfo(const nsRect& aVisibleRect, const Scale2D& aRasterScale,
+              const ParentLayerToScreenScale2D& aTransformToAncestorScale)
+      : mVisibleRect(aVisibleRect),
+        mRasterScale(aRasterScale),
+        mTransformToAncestorScale(aTransformToAncestorScale) {}
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_EffectsInfo_h
diff --git a/dom/ipc/FilePickerMessageUtils.h b/dom/ipc/FilePickerMessageUtils.h
new file mode 100644
index 0000000000..2f4338c8a1
--- /dev/null
+++ b/dom/ipc/FilePickerMessageUtils.h
@@ -0,0 +1,34 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_filepicker_message_utils_h__
+#define mozilla_dom_filepicker_message_utils_h__
+
+#include "ipc/EnumSerializer.h"
+#include "nsIFilePicker.h"
+
+namespace IPC {
+template <>
+struct ParamTraits<nsIFilePicker::Mode>
+    : public ContiguousEnumSerializerInclusive<
+          nsIFilePicker::Mode, nsIFilePicker::Mode::modeOpen,
+          nsIFilePicker::Mode::modeOpenMultiple> {};
+
+template <>
+struct ParamTraits<nsIFilePicker::CaptureTarget>
+    : public ContiguousEnumSerializerInclusive<
+          nsIFilePicker::CaptureTarget,
+          nsIFilePicker::CaptureTarget::captureNone,
+          nsIFilePicker::CaptureTarget::captureEnv> {};
+
+template <>
+struct ParamTraits<nsIFilePicker::ResultCode>
+    : public ContiguousEnumSerializerInclusive<
+          nsIFilePicker::ResultCode, nsIFilePicker::ResultCode::returnOK,
+          nsIFilePicker::ResultCode::returnReplace> {};
+}  // namespace IPC
+
+#endif  // mozilla_dom_filepicker_message_utils_h__
diff --git a/dom/ipc/FilePickerParent.cpp b/dom/ipc/FilePickerParent.cpp
new file mode 100644
index 0000000000..08f2a8fb6c
--- /dev/null
+++ b/dom/ipc/FilePickerParent.cpp
@@ -0,0 +1,293 @@
+/* -*- 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 "FilePickerParent.h"
+#include "nsComponentManagerUtils.h"
+#include "nsNetCID.h"
+#include "mozilla/dom/Document.h"
+#include "nsIFile.h"
+#include "nsISimpleEnumerator.h"
+#include "mozilla/Unused.h"
+#include "mozilla/dom/FileBlobImpl.h"
+#include "mozilla/dom/FileSystemSecurity.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/dom/IPCBlobUtils.h"
+
+using mozilla::Unused;
+using namespace mozilla::dom;
+
+NS_IMPL_ISUPPORTS(FilePickerParent::FilePickerShownCallback,
+                  nsIFilePickerShownCallback);
+
+NS_IMETHODIMP
+FilePickerParent::FilePickerShownCallback::Done(
+    nsIFilePicker::ResultCode aResult) {
+  if (mFilePickerParent) {
+    mFilePickerParent->Done(aResult);
+  }
+  return NS_OK;
+}
+
+void FilePickerParent::FilePickerShownCallback::Destroy() {
+  mFilePickerParent = nullptr;
+}
+
+FilePickerParent::~FilePickerParent() = default;
+
+// We run code in three places:
+// 1. The main thread calls Dispatch() to start the runnable.
+// 2. The stream transport thread stat()s the file in Run() and then dispatches
+// the same runnable on the main thread.
+// 3. The main thread sends the results over IPC.
+FilePickerParent::IORunnable::IORunnable(FilePickerParent* aFPParent,
+                                         nsTArray<nsCOMPtr<nsIFile>>&& aFiles,
+                                         bool aIsDirectory)
+    : mozilla::Runnable("dom::FilePickerParent::IORunnable"),
+      mFilePickerParent(aFPParent),
+      mFiles(std::move(aFiles)),
+      mIsDirectory(aIsDirectory) {
+  MOZ_ASSERT_IF(aIsDirectory, mFiles.Length() == 1);
+}
+
+bool FilePickerParent::IORunnable::Dispatch() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mEventTarget = do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
+  if (!mEventTarget) {
+    return false;
+  }
+
+  nsresult rv = mEventTarget->Dispatch(this, NS_DISPATCH_NORMAL);
+  return NS_SUCCEEDED(rv);
+}
+
+NS_IMETHODIMP
+FilePickerParent::IORunnable::Run() {
+  // If we're on the main thread, then that means we're done. Just send the
+  // results.
+  if (NS_IsMainThread()) {
+    if (mFilePickerParent) {
+      mFilePickerParent->SendFilesOrDirectories(mResults);
+    }
+    return NS_OK;
+  }
+
+  // We're not on the main thread, so do the IO.
+
+  for (uint32_t i = 0; i < mFiles.Length(); ++i) {
+    if (mIsDirectory) {
+      nsAutoString path;
+      nsresult rv = mFiles[i]->GetPath(path);
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        continue;
+      }
+
+      BlobImplOrString* data = mResults.AppendElement();
+      data->mType = BlobImplOrString::eDirectoryPath;
+      data->mDirectoryPath = path;
+      continue;
+    }
+
+    RefPtr<BlobImpl> blobImpl = new FileBlobImpl(mFiles[i]);
+
+    ErrorResult error;
+    blobImpl->GetSize(error);
+    if (NS_WARN_IF(error.Failed())) {
+      error.SuppressException();
+      continue;
+    }
+
+    blobImpl->GetLastModified(error);
+    if (NS_WARN_IF(error.Failed())) {
+      error.SuppressException();
+      continue;
+    }
+
+    BlobImplOrString* data = mResults.AppendElement();
+    data->mType = BlobImplOrString::eBlobImpl;
+    data->mBlobImpl = blobImpl;
+  }
+
+  // Dispatch ourselves back on the main thread.
+  if (NS_FAILED(NS_DispatchToMainThread(this))) {
+    // It's hard to see how we can recover gracefully in this case. The child
+    // process is waiting for an IPC, but that can only happen on the main
+    // thread.
+    MOZ_CRASH();
+  }
+
+  return NS_OK;
+}
+
+void FilePickerParent::IORunnable::Destroy() { mFilePickerParent = nullptr; }
+
+void FilePickerParent::SendFilesOrDirectories(
+    const nsTArray<BlobImplOrString>& aData) {
+  ContentParent* parent = BrowserParent::GetFrom(Manager())->Manager();
+
+  if (mMode == nsIFilePicker::modeGetFolder) {
+    MOZ_ASSERT(aData.Length() <= 1);
+    if (aData.IsEmpty()) {
+      Unused << Send__delete__(this, void_t(), mResult);
+      return;
+    }
+
+    MOZ_ASSERT(aData[0].mType == BlobImplOrString::eDirectoryPath);
+
+    // Let's inform the security singleton about the given access of this tab on
+    // this directory path.
+    RefPtr<FileSystemSecurity> fss = FileSystemSecurity::GetOrCreate();
+    fss->GrantAccessToContentProcess(parent->ChildID(),
+                                     aData[0].mDirectoryPath);
+
+    InputDirectory input;
+    input.directoryPath() = aData[0].mDirectoryPath;
+    Unused << Send__delete__(this, input, mResult);
+    return;
+  }
+
+  nsTArray<IPCBlob> ipcBlobs;
+
+  for (unsigned i = 0; i < aData.Length(); i++) {
+    IPCBlob ipcBlob;
+
+    MOZ_ASSERT(aData[i].mType == BlobImplOrString::eBlobImpl);
+    nsresult rv = IPCBlobUtils::Serialize(aData[i].mBlobImpl, ipcBlob);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      break;
+    }
+
+    ipcBlobs.AppendElement(ipcBlob);
+  }
+
+  InputBlobs inblobs;
+  inblobs.blobs() = std::move(ipcBlobs);
+
+  Unused << Send__delete__(this, inblobs, mResult);
+}
+
+void FilePickerParent::Done(nsIFilePicker::ResultCode aResult) {
+  mResult = aResult;
+
+  if (mResult != nsIFilePicker::returnOK) {
+    Unused << Send__delete__(this, void_t(), mResult);
+    return;
+  }
+
+  nsTArray<nsCOMPtr<nsIFile>> files;
+  if (mMode == nsIFilePicker::modeOpenMultiple) {
+    nsCOMPtr<nsISimpleEnumerator> iter;
+    NS_ENSURE_SUCCESS_VOID(mFilePicker->GetFiles(getter_AddRefs(iter)));
+
+    nsCOMPtr<nsISupports> supports;
+    bool loop = true;
+    while (NS_SUCCEEDED(iter->HasMoreElements(&loop)) && loop) {
+      iter->GetNext(getter_AddRefs(supports));
+      if (supports) {
+        nsCOMPtr<nsIFile> file = do_QueryInterface(supports);
+        MOZ_ASSERT(file);
+        files.AppendElement(file);
+      }
+    }
+  } else {
+    nsCOMPtr<nsIFile> file;
+    mFilePicker->GetFile(getter_AddRefs(file));
+    if (file) {
+      files.AppendElement(file);
+    }
+  }
+
+  if (files.IsEmpty()) {
+    Unused << Send__delete__(this, void_t(), mResult);
+    return;
+  }
+
+  MOZ_ASSERT(!mRunnable);
+  mRunnable = new IORunnable(this, std::move(files),
+                             mMode == nsIFilePicker::modeGetFolder);
+
+  // Dispatch to background thread to do I/O:
+  if (!mRunnable->Dispatch()) {
+    Unused << Send__delete__(this, void_t(), nsIFilePicker::returnCancel);
+  }
+}
+
+bool FilePickerParent::CreateFilePicker() {
+  mFilePicker = do_CreateInstance("@mozilla.org/filepicker;1");
+  if (!mFilePicker) {
+    return false;
+  }
+
+  Element* element = BrowserParent::GetFrom(Manager())->GetOwnerElement();
+  if (!element) {
+    return false;
+  }
+
+  nsCOMPtr<mozIDOMWindowProxy> window = element->OwnerDoc()->GetWindow();
+  if (!window) {
+    return false;
+  }
+
+  return NS_SUCCEEDED(mFilePicker->Init(window, mTitle, mMode));
+}
+
+mozilla::ipc::IPCResult FilePickerParent::RecvOpen(
+    const int16_t& aSelectedType, const bool& aAddToRecentDocs,
+    const nsString& aDefaultFile, const nsString& aDefaultExtension,
+    nsTArray<nsString>&& aFilters, nsTArray<nsString>&& aFilterNames,
+    nsTArray<nsString>&& aRawFilters, const nsString& aDisplayDirectory,
+    const nsString& aDisplaySpecialDirectory, const nsString& aOkButtonLabel,
+    const nsIFilePicker::CaptureTarget& aCapture) {
+  if (!CreateFilePicker()) {
+    Unused << Send__delete__(this, void_t(), nsIFilePicker::returnCancel);
+    return IPC_OK();
+  }
+
+  mFilePicker->SetAddToRecentDocs(aAddToRecentDocs);
+
+  for (uint32_t i = 0; i < aFilters.Length(); ++i) {
+    mFilePicker->AppendFilter(aFilterNames[i], aFilters[i]);
+  }
+
+  for (uint32_t i = 0; i < aRawFilters.Length(); ++i) {
+    mFilePicker->AppendRawFilter(aRawFilters[i]);
+  }
+
+  mFilePicker->SetDefaultString(aDefaultFile);
+  mFilePicker->SetDefaultExtension(aDefaultExtension);
+  mFilePicker->SetFilterIndex(aSelectedType);
+  mFilePicker->SetOkButtonLabel(aOkButtonLabel);
+  mFilePicker->SetCapture(aCapture);
+
+  if (!aDisplayDirectory.IsEmpty()) {
+    nsCOMPtr<nsIFile> localFile = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID);
+    if (localFile) {
+      localFile->InitWithPath(aDisplayDirectory);
+      mFilePicker->SetDisplayDirectory(localFile);
+    }
+  } else if (!aDisplaySpecialDirectory.IsEmpty()) {
+    mFilePicker->SetDisplaySpecialDirectory(aDisplaySpecialDirectory);
+  }
+
+  MOZ_ASSERT(!mCallback);
+  mCallback = new FilePickerShownCallback(this);
+
+  mFilePicker->Open(mCallback);
+  return IPC_OK();
+}
+
+void FilePickerParent::ActorDestroy(ActorDestroyReason aWhy) {
+  if (mCallback) {
+    mCallback->Destroy();
+    mCallback = nullptr;
+  }
+  if (mRunnable) {
+    mRunnable->Destroy();
+    mRunnable = nullptr;
+  }
+}
diff --git a/dom/ipc/FilePickerParent.h b/dom/ipc/FilePickerParent.h
new file mode 100644
index 0000000000..06875df9a7
--- /dev/null
+++ b/dom/ipc/FilePickerParent.h
@@ -0,0 +1,99 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_FilePickerParent_h
+#define mozilla_dom_FilePickerParent_h
+
+#include "nsIEventTarget.h"
+#include "nsIFilePicker.h"
+#include "nsCOMArray.h"
+#include "nsThreadUtils.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/PFilePickerParent.h"
+
+class nsIFile;
+
+namespace mozilla::dom {
+
+class FilePickerParent : public PFilePickerParent {
+ public:
+  FilePickerParent(const nsString& aTitle, const nsIFilePicker::Mode& aMode)
+      : mTitle(aTitle), mMode(aMode), mResult(nsIFilePicker::returnOK) {}
+
+ private:
+  virtual ~FilePickerParent();
+
+ public:
+  NS_INLINE_DECL_REFCOUNTING(FilePickerParent, final)
+
+  void Done(nsIFilePicker::ResultCode aResult);
+
+  struct BlobImplOrString {
+    RefPtr<BlobImpl> mBlobImpl;
+    nsString mDirectoryPath;
+
+    enum { eBlobImpl, eDirectoryPath } mType;
+  };
+
+  void SendFilesOrDirectories(const nsTArray<BlobImplOrString>& aData);
+
+  mozilla::ipc::IPCResult RecvOpen(
+      const int16_t& aSelectedType, const bool& aAddToRecentDocs,
+      const nsString& aDefaultFile, const nsString& aDefaultExtension,
+      nsTArray<nsString>&& aFilters, nsTArray<nsString>&& aFilterNames,
+      nsTArray<nsString>&& aRawFilters, const nsString& aDisplayDirectory,
+      const nsString& aDisplaySpecialDirectory, const nsString& aOkButtonLabel,
+      const nsIFilePicker::CaptureTarget& aCapture);
+
+  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  class FilePickerShownCallback : public nsIFilePickerShownCallback {
+   public:
+    explicit FilePickerShownCallback(FilePickerParent* aFilePickerParent)
+        : mFilePickerParent(aFilePickerParent) {}
+
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIFILEPICKERSHOWNCALLBACK
+
+    void Destroy();
+
+   private:
+    virtual ~FilePickerShownCallback() = default;
+    RefPtr<FilePickerParent> mFilePickerParent;
+  };
+
+ private:
+  bool CreateFilePicker();
+
+  // This runnable is used to do some I/O operation on a separate thread.
+  class IORunnable : public Runnable {
+    RefPtr<FilePickerParent> mFilePickerParent;
+    nsTArray<nsCOMPtr<nsIFile>> mFiles;
+    nsTArray<BlobImplOrString> mResults;
+    nsCOMPtr<nsIEventTarget> mEventTarget;
+    bool mIsDirectory;
+
+   public:
+    IORunnable(FilePickerParent* aFPParent,
+               nsTArray<nsCOMPtr<nsIFile>>&& aFiles, bool aIsDirectory);
+
+    bool Dispatch();
+    NS_IMETHOD Run() override;
+    void Destroy();
+  };
+
+  RefPtr<IORunnable> mRunnable;
+  RefPtr<FilePickerShownCallback> mCallback;
+  nsCOMPtr<nsIFilePicker> mFilePicker;
+
+  nsString mTitle;
+  nsIFilePicker::Mode mMode;
+  nsIFilePicker::ResultCode mResult;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_FilePickerParent_h
diff --git a/dom/ipc/IPCTransferable.ipdlh b/dom/ipc/IPCTransferable.ipdlh
new file mode 100644
index 0000000000..df82b7aa27
--- /dev/null
+++ b/dom/ipc/IPCTransferable.ipdlh
@@ -0,0 +1,88 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */
+/* 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 "mozilla/GfxMessageUtils.h";
+include "mozilla/dom/PermissionMessageUtils.h";
+
+include IPCBlob;
+include NeckoChannelParams;
+
+using mozilla::gfx::SurfaceFormat from "mozilla/gfx/Types.h";
+[RefCounted] using class nsIPrincipal from "nsIPrincipal.h";
+[RefCounted] using class nsIReferrerInfo from "nsIReferrerInfo.h";
+[MoveOnly] using class mozilla::ipc::BigBuffer from "mozilla/ipc/BigBuffer.h";
+
+namespace mozilla {
+namespace dom {
+
+struct IPCTransferableDataString
+{
+  BigBuffer data;
+};
+
+struct IPCTransferableDataCString
+{
+  BigBuffer data;
+};
+
+struct IPCTransferableDataInputStream
+{
+  // NOTE: Editor currently relies on these input streams being synchronous, so
+  // we can't safely serialize them using IPCStream (see bug 1778565). Instead,
+  // they're serialized as a `BigBuffer`, and converted to a nsStringInputStream
+  // on the receiving side. If we are able to use async streams reliably in the
+  // future, we could consider switching the code which adds `nsIInputStream`s
+  // to the transferable to use `BlobImpl` instead, for more consistency between
+  // image formats.
+  BigBuffer data;
+};
+
+struct IPCTransferableDataImageContainer
+{
+  BigBuffer data;
+  uint32_t width;
+  uint32_t height;
+  uint32_t stride;
+  SurfaceFormat format;
+};
+
+struct IPCTransferableDataBlob
+{
+  IPCBlob blob;
+};
+
+union IPCTransferableDataType
+{
+  IPCTransferableDataString;
+  IPCTransferableDataCString;
+  IPCTransferableDataInputStream;
+  IPCTransferableDataImageContainer;
+  IPCTransferableDataBlob;
+};
+
+struct IPCTransferableDataItem
+{
+  nsCString flavor;
+  IPCTransferableDataType data;
+};
+
+struct IPCTransferableData
+{
+  IPCTransferableDataItem[] items;
+};
+
+struct IPCTransferable
+{
+  IPCTransferableData data;
+  bool isPrivateData;
+  nullable nsIPrincipal requestingPrincipal;
+  CookieJarSettingsArgs? cookieJarSettings;
+  nsContentPolicyType contentPolicyType;
+  nullable nsIReferrerInfo referrerInfo;
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/IdType.h b/dom/ipc/IdType.h
new file mode 100644
index 0000000000..ccf8b52693
--- /dev/null
+++ b/dom/ipc/IdType.h
@@ -0,0 +1,64 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_IdType_h
+#define mozilla_dom_IdType_h
+
+#include "ipc/IPCMessageUtils.h"
+
+namespace IPC {
+template <typename T>
+struct ParamTraits;
+}  // namespace IPC
+
+namespace mozilla::dom {
+class BrowsingContext;
+class ContentParent;
+class BrowserParent;
+
+template <typename T>
+class IdType {
+  friend struct IPC::ParamTraits<IdType<T>>;
+
+ public:
+  IdType() : mId(0) {}
+  explicit IdType(uint64_t aId) : mId(aId) {}
+
+  operator uint64_t() const { return mId; }
+
+  IdType& operator=(uint64_t aId) {
+    mId = aId;
+    return *this;
+  }
+
+  bool operator<(const IdType& rhs) { return mId < rhs.mId; }
+
+ private:
+  uint64_t mId;
+};
+
+using TabId = IdType<BrowserParent>;
+using ContentParentId = IdType<ContentParent>;
+}  // namespace mozilla::dom
+
+namespace IPC {
+
+template <typename T>
+struct ParamTraits<mozilla::dom::IdType<T>> {
+  using paramType = mozilla::dom::IdType<T>;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam) {
+    WriteParam(aWriter, aParam.mId);
+  }
+
+  static bool Read(MessageReader* aReader, paramType* aResult) {
+    return ReadParam(aReader, &aResult->mId);
+  }
+};
+
+}  // namespace IPC
+
+#endif  // mozilla_dom_IdType_h
diff --git a/dom/ipc/InProcessChild.h b/dom/ipc/InProcessChild.h
new file mode 100644
index 0000000000..16176ef98b
--- /dev/null
+++ b/dom/ipc/InProcessChild.h
@@ -0,0 +1,69 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_InProcessChild_h
+#define mozilla_dom_InProcessChild_h
+
+#include "mozilla/dom/PInProcessChild.h"
+#include "mozilla/dom/JSProcessActorChild.h"
+#include "mozilla/dom/ProcessActor.h"
+#include "mozilla/dom/RemoteType.h"
+#include "mozilla/StaticPtr.h"
+#include "nsIDOMProcessChild.h"
+
+namespace mozilla::dom {
+class PWindowGlobalParent;
+class PWindowGlobalChild;
+class InProcessParent;
+
+/**
+ * The `InProcessChild` class represents the child half of a main-thread to
+ * main-thread actor.
+ *
+ * The `PInProcess` actor should be used as an alternate manager to `PContent`
+ * for async actors which want to communicate uniformly between Content->Chrome
+ * and Chrome->Chrome situations.
+ */
+class InProcessChild final : public nsIDOMProcessChild,
+                             public PInProcessChild,
+                             public ProcessActor {
+ public:
+  friend class InProcessParent;
+  friend class PInProcessChild;
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIDOMPROCESSCHILD
+
+  // Get the singleton instance of this actor.
+  static InProcessChild* Singleton();
+
+  // Get the parent side of the in-process child actor |aActor|. If |aActor| is
+  // not an in-process actor, or is not connected, this method will return
+  // |nullptr|.
+  static IProtocol* ParentActorFor(IProtocol* aActor);
+
+  const nsACString& GetRemoteType() const override { return NOT_REMOTE_TYPE; }
+
+ protected:
+  already_AddRefed<JSActor> InitJSActor(JS::Handle<JSObject*> aMaybeActor,
+                                        const nsACString& aName,
+                                        ErrorResult& aRv) override;
+  mozilla::ipc::IProtocol* AsNativeActor() override { return this; }
+
+ private:
+  // NOTE: PInProcess lifecycle management is declared as staic methods and
+  // state on InProcessParent, and implemented in InProcessImpl.cpp.
+  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+  ~InProcessChild() = default;
+
+  static StaticRefPtr<InProcessChild> sSingleton;
+
+  nsRefPtrHashtable<nsCStringHashKey, JSProcessActorChild> mProcessActors;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // defined(mozilla_dom_InProcessChild_h)
diff --git a/dom/ipc/InProcessImpl.cpp b/dom/ipc/InProcessImpl.cpp
new file mode 100644
index 0000000000..e076a84c44
--- /dev/null
+++ b/dom/ipc/InProcessImpl.cpp
@@ -0,0 +1,324 @@
+/* -*- 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 "mozilla/dom/InProcessParent.h"
+#include "mozilla/dom/InProcessChild.h"
+#include "mozilla/dom/JSProcessActorBinding.h"
+#include "nsIObserverService.h"
+#include "mozilla/Services.h"
+
+using namespace mozilla::ipc;
+
+// This file contains the implementation of core InProcess lifecycle management
+// facilities.
+
+namespace mozilla::dom {
+
+StaticRefPtr<InProcessParent> InProcessParent::sSingleton;
+StaticRefPtr<InProcessChild> InProcessChild::sSingleton;
+bool InProcessParent::sShutdown = false;
+
+//////////////////////////////////////////
+// InProcess actor lifecycle management //
+//////////////////////////////////////////
+
+/* static */
+InProcessChild* InProcessChild::Singleton() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!sSingleton) {
+    InProcessParent::Startup();
+  }
+  return sSingleton;
+}
+
+/* static */
+InProcessParent* InProcessParent::Singleton() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!sSingleton) {
+    InProcessParent::Startup();
+  }
+  return sSingleton;
+}
+
+/* static */
+void InProcessParent::Startup() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (sShutdown) {
+    NS_WARNING("Could not get in-process actor while shutting down!");
+    return;
+  }
+
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (!obs) {
+    sShutdown = true;
+    NS_WARNING("Failed to get nsIObserverService for in-process actor");
+    return;
+  }
+
+  RefPtr<InProcessParent> parent = new InProcessParent();
+  RefPtr<InProcessChild> child = new InProcessChild();
+
+  // Observe the shutdown event to close & clean up after ourselves.
+  nsresult rv = obs->AddObserver(parent, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return;
+  }
+
+  // Link the two actors
+  if (!child->OpenOnSameThread(parent, ChildSide)) {
+    MOZ_CRASH("Failed to open InProcessChild!");
+  }
+
+  parent->SetOtherProcessId(base::GetCurrentProcId());
+
+  // Stash global references to fetch the other side of the reference.
+  InProcessParent::sSingleton = std::move(parent);
+  InProcessChild::sSingleton = std::move(child);
+}
+
+/* static */
+void InProcessParent::Shutdown() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!sSingleton || sShutdown) {
+    return;
+  }
+
+  sShutdown = true;
+
+  RefPtr<InProcessParent> parent = sSingleton;
+  InProcessParent::sSingleton = nullptr;
+  InProcessChild::sSingleton = nullptr;
+
+  // Calling `Close` on the actor will cause the `Dealloc` methods to be called,
+  // freeing the remaining references.
+  parent->Close();
+}
+
+NS_IMETHODIMP
+InProcessParent::Observe(nsISupports* aSubject, const char* aTopic,
+                         const char16_t* aData) {
+  MOZ_ASSERT(!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID));
+  InProcessParent::Shutdown();
+  return NS_OK;
+}
+
+void InProcessParent::ActorDestroy(ActorDestroyReason aWhy) {
+  JSActorDidDestroy();
+  InProcessParent::Shutdown();
+}
+
+void InProcessChild::ActorDestroy(ActorDestroyReason aWhy) {
+  JSActorDidDestroy();
+  InProcessParent::Shutdown();
+}
+
+/////////////////////////
+// nsIDOMProcessParent //
+/////////////////////////
+
+NS_IMETHODIMP
+InProcessParent::GetChildID(uint64_t* aChildID) {
+  *aChildID = 0;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+InProcessParent::GetOsPid(int32_t* aOsPid) {
+  // InProcessParent always run in the parent process,
+  // so we can return the current process id.
+  *aOsPid = base::GetCurrentProcId();
+  return NS_OK;
+}
+
+NS_IMETHODIMP InProcessParent::GetRemoteType(nsACString& aRemoteType) {
+  aRemoteType = NOT_REMOTE_TYPE;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+InProcessParent::GetActor(const nsACString& aName, JSContext* aCx,
+                          JSProcessActorParent** aActor) {
+  ErrorResult error;
+  RefPtr<JSProcessActorParent> actor =
+      JSActorManager::GetActor(aCx, aName, error)
+          .downcast<JSProcessActorParent>();
+  if (error.MaybeSetPendingException(aCx)) {
+    return NS_ERROR_FAILURE;
+  }
+  actor.forget(aActor);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+InProcessParent::GetExistingActor(const nsACString& aName,
+                                  JSProcessActorParent** aActor) {
+  RefPtr<JSProcessActorParent> actor =
+      JSActorManager::GetExistingActor(aName).downcast<JSProcessActorParent>();
+  actor.forget(aActor);
+  return NS_OK;
+}
+
+already_AddRefed<JSActor> InProcessParent::InitJSActor(
+    JS::Handle<JSObject*> aMaybeActor, const nsACString& aName,
+    ErrorResult& aRv) {
+  RefPtr<JSProcessActorParent> actor;
+  if (aMaybeActor.get()) {
+    aRv = UNWRAP_OBJECT(JSProcessActorParent, aMaybeActor.get(), actor);
+    if (aRv.Failed()) {
+      return nullptr;
+    }
+  } else {
+    actor = new JSProcessActorParent();
+  }
+
+  MOZ_RELEASE_ASSERT(!actor->Manager(),
+                     "mManager was already initialized once!");
+  actor->Init(aName, this);
+  return actor.forget();
+}
+
+NS_IMETHODIMP
+InProcessParent::GetCanSend(bool* aCanSend) {
+  *aCanSend = CanSend();
+  return NS_OK;
+}
+
+ContentParent* InProcessParent::AsContentParent() { return nullptr; }
+
+JSActorManager* InProcessParent::AsJSActorManager() { return this; }
+
+////////////////////////
+// nsIDOMProcessChild //
+////////////////////////
+
+NS_IMETHODIMP
+InProcessChild::GetChildID(uint64_t* aChildID) {
+  *aChildID = 0;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+InProcessChild::GetActor(const nsACString& aName, JSContext* aCx,
+                         JSProcessActorChild** aActor) {
+  ErrorResult error;
+  RefPtr<JSProcessActorChild> actor =
+      JSActorManager::GetActor(aCx, aName, error)
+          .downcast<JSProcessActorChild>();
+  if (error.MaybeSetPendingException(aCx)) {
+    return NS_ERROR_FAILURE;
+  }
+  actor.forget(aActor);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+InProcessChild::GetExistingActor(const nsACString& aName,
+                                 JSProcessActorChild** aActor) {
+  RefPtr<JSProcessActorChild> actor =
+      JSActorManager::GetExistingActor(aName).downcast<JSProcessActorChild>();
+  actor.forget(aActor);
+  return NS_OK;
+}
+
+already_AddRefed<JSActor> InProcessChild::InitJSActor(
+    JS::Handle<JSObject*> aMaybeActor, const nsACString& aName,
+    ErrorResult& aRv) {
+  RefPtr<JSProcessActorChild> actor;
+  if (aMaybeActor.get()) {
+    aRv = UNWRAP_OBJECT(JSProcessActorChild, aMaybeActor.get(), actor);
+    if (aRv.Failed()) {
+      return nullptr;
+    }
+  } else {
+    actor = new JSProcessActorChild();
+  }
+
+  MOZ_RELEASE_ASSERT(!actor->Manager(),
+                     "mManager was already initialized once!");
+  actor->Init(aName, this);
+  return actor.forget();
+}
+
+NS_IMETHODIMP
+InProcessChild::GetCanSend(bool* aCanSend) {
+  *aCanSend = CanSend();
+  return NS_OK;
+}
+
+ContentChild* InProcessChild::AsContentChild() { return nullptr; }
+
+JSActorManager* InProcessChild::AsJSActorManager() { return this; }
+
+////////////////////////////////
+// In-Process Actor Utilities //
+////////////////////////////////
+
+// Helper method for implementing ParentActorFor and ChildActorFor.
+static IProtocol* GetOtherInProcessActor(IProtocol* aActor) {
+  MOZ_ASSERT(aActor->GetSide() != UnknownSide, "bad unknown side");
+
+  // Discover the manager of aActor which is PInProcess.
+  IProtocol* current = aActor;
+  while (current && current->CanRecv()) {
+    if (current->GetProtocolId() == PInProcessMsgStart) {
+      break;  // Found the correct actor.
+    }
+    current = current->Manager();
+  }
+  if (!current || !current->CanRecv()) {
+    return nullptr;  // Not a live PInProcess actor, return |nullptr|
+  }
+
+  MOZ_ASSERT(current->GetSide() == aActor->GetSide(), "side changed?");
+  MOZ_ASSERT_IF(aActor->GetSide() == ParentSide,
+                current == InProcessParent::Singleton());
+  MOZ_ASSERT_IF(aActor->GetSide() == ChildSide,
+                current == InProcessChild::Singleton());
+
+  // Check whether this is InProcessParent or InProcessChild, and get the other
+  // side's toplevel actor.
+  IProtocol* otherRoot = nullptr;
+  if (aActor->GetSide() == ParentSide) {
+    otherRoot = InProcessChild::Singleton();
+  } else {
+    otherRoot = InProcessParent::Singleton();
+  }
+  if (NS_WARN_IF(!otherRoot)) {
+    return nullptr;
+  }
+
+  // Look up the actor on the other side, and return it.
+  IProtocol* otherActor = otherRoot->Lookup(aActor->Id());
+  if (otherActor) {
+    MOZ_ASSERT(otherActor->GetSide() != UnknownSide, "bad unknown side");
+    MOZ_ASSERT(otherActor->GetSide() != aActor->GetSide(), "Wrong side!");
+    MOZ_ASSERT(otherActor->GetProtocolId() == aActor->GetProtocolId(),
+               "Wrong type of protocol!");
+  }
+
+  return otherActor;
+}
+
+/* static */
+IProtocol* InProcessParent::ChildActorFor(IProtocol* aActor) {
+  MOZ_ASSERT(aActor && aActor->GetSide() == ParentSide);
+  return GetOtherInProcessActor(aActor);
+}
+
+/* static */
+IProtocol* InProcessChild::ParentActorFor(IProtocol* aActor) {
+  MOZ_ASSERT(aActor && aActor->GetSide() == ChildSide);
+  return GetOtherInProcessActor(aActor);
+}
+
+NS_IMPL_ISUPPORTS(InProcessParent, nsIDOMProcessParent, nsIObserver)
+NS_IMPL_ISUPPORTS(InProcessChild, nsIDOMProcessChild)
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/InProcessParent.h b/dom/ipc/InProcessParent.h
new file mode 100644
index 0000000000..112558f5bd
--- /dev/null
+++ b/dom/ipc/InProcessParent.h
@@ -0,0 +1,74 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_InProcessParent_h
+#define mozilla_dom_InProcessParent_h
+
+#include "mozilla/dom/PInProcessParent.h"
+#include "mozilla/dom/JSProcessActorParent.h"
+#include "mozilla/dom/ProcessActor.h"
+#include "mozilla/dom/RemoteType.h"
+#include "mozilla/StaticPtr.h"
+#include "nsIDOMProcessParent.h"
+
+namespace mozilla::dom {
+class PWindowGlobalParent;
+class PWindowGlobalChild;
+class InProcessChild;
+
+/**
+ * The `InProcessParent` class represents the parent half of a main-thread to
+ * main-thread actor.
+ *
+ * The `PInProcess` actor should be used as an alternate manager to `PContent`
+ * for async actors which want to communicate uniformly between Content->Chrome
+ * and Chrome->Chrome situations.
+ */
+class InProcessParent final : public nsIDOMProcessParent,
+                              public nsIObserver,
+                              public PInProcessParent,
+                              public ProcessActor {
+ public:
+  friend class InProcessChild;
+  friend class PInProcessParent;
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIDOMPROCESSPARENT
+  NS_DECL_NSIOBSERVER
+
+  // Get the singleton instance of this actor.
+  static InProcessParent* Singleton();
+
+  // Get the child side of the in-process child actor |aActor|. If |aActor| is
+  // not an in-process actor, or is not connected, this method will return
+  // |nullptr|.
+  static IProtocol* ChildActorFor(IProtocol* aActor);
+
+  const nsACString& GetRemoteType() const override { return NOT_REMOTE_TYPE; };
+
+ protected:
+  already_AddRefed<JSActor> InitJSActor(JS::Handle<JSObject*> aMaybeActor,
+                                        const nsACString& aName,
+                                        ErrorResult& aRv) override;
+  mozilla::ipc::IProtocol* AsNativeActor() override { return this; }
+
+ private:
+  // Lifecycle management is implemented in InProcessImpl.cpp
+  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+  ~InProcessParent() = default;
+
+  static void Startup();
+  static void Shutdown();
+
+  static StaticRefPtr<InProcessParent> sSingleton;
+  static bool sShutdown;
+
+  nsRefPtrHashtable<nsCStringHashKey, JSProcessActorParent> mProcessActors;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // defined(mozilla_dom_InProcessParent_h)
diff --git a/dom/ipc/JSOracleChild.cpp b/dom/ipc/JSOracleChild.cpp
new file mode 100644
index 0000000000..abfd0d1b00
--- /dev/null
+++ b/dom/ipc/JSOracleChild.cpp
@@ -0,0 +1,57 @@
+/* -*- 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 "mozilla/dom/JSOracleChild.h"
+
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/dom/JSValidatorChild.h"
+#include "mozilla/dom/PJSValidatorChild.h"
+#include "mozilla/ipc/Endpoint.h"
+
+using namespace mozilla::dom;
+
+static mozilla::StaticRefPtr<JSOracleChild> sOracleSingletonChild;
+
+static mozilla::StaticAutoPtr<JSContextHolder> sJSContextHolder;
+
+/* static */
+void JSContextHolder::MaybeInit() {
+  if (!sJSContextHolder) {
+    sJSContextHolder = new JSContextHolder();
+    ClearOnShutdown(&sJSContextHolder);
+  }
+}
+
+/* static */
+JSContext* JSOracleChild::JSContext() {
+  MOZ_ASSERT(sJSContextHolder);
+  return sJSContextHolder->mCx;
+}
+
+/* static */
+JSObject* JSOracleChild::JSObject() {
+  MOZ_ASSERT(sJSContextHolder);
+  return sJSContextHolder->mGlobal;
+}
+
+JSOracleChild* JSOracleChild::GetSingleton() {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (!sOracleSingletonChild) {
+    sOracleSingletonChild = new JSOracleChild();
+    ClearOnShutdown(&sOracleSingletonChild);
+  }
+  return sOracleSingletonChild;
+}
+
+already_AddRefed<PJSValidatorChild> JSOracleChild::AllocPJSValidatorChild() {
+  return MakeAndAddRef<JSValidatorChild>();
+}
+
+void JSOracleChild::Start(Endpoint<PJSOracleChild>&& aEndpoint) {
+  DebugOnly<bool> ok = std::move(aEndpoint).Bind(this);
+  JSContextHolder::MaybeInit();
+  MOZ_ASSERT(ok);
+}
diff --git a/dom/ipc/JSOracleChild.h b/dom/ipc/JSOracleChild.h
new file mode 100644
index 0000000000..48e1cf2178
--- /dev/null
+++ b/dom/ipc/JSOracleChild.h
@@ -0,0 +1,87 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_JSOracleChild
+#define mozilla_dom_JSOracleChild
+
+#include "mozilla/dom/PJSOracleChild.h"
+
+#include "js/CharacterEncoding.h"
+#include "js/HeapAPI.h"
+#include "js/Initialization.h"
+#include "jsapi.h"
+#include "js/CompilationAndEvaluation.h"
+#include "js/Context.h"
+
+namespace mozilla::ipc {
+class UtilityProcessParent;
+}
+
+namespace mozilla::dom {
+struct JSContextHolder {
+  JSContextHolder() {
+    MOZ_RELEASE_ASSERT(JS_IsInitialized(),
+                       "UtilityProcessChild::Init should have JS initialized");
+
+    mCx = JS_NewContext(JS::DefaultHeapMaxBytes);
+    if (!mCx) {
+      MOZ_CRASH("Failed to create JS Context");
+      return;
+    }
+
+    if (!JS::InitSelfHostedCode(mCx)) {
+      MOZ_CRASH("Failed to initialize the runtime's self-hosted code");
+      return;
+    }
+
+    static JSClass jsValidatorGlobalClass = {
+        "JSValidatorGlobal", JSCLASS_GLOBAL_FLAGS, &JS::DefaultGlobalClassOps};
+
+    JS::Rooted<JSObject*> global(
+        mCx, JS_NewGlobalObject(mCx, &jsValidatorGlobalClass, nullptr,
+                                JS::FireOnNewGlobalHook, JS::RealmOptions()));
+
+    if (!global) {
+      MOZ_CRASH("Failed to create the global");
+      return;
+    }
+
+    mGlobal.init(mCx, global);
+  }
+
+  ~JSContextHolder() {
+    if (mCx) {
+      JS_DestroyContext(mCx);
+    }
+  }
+
+  static void MaybeInit();
+
+  JSContext* mCx;
+  JS::PersistentRooted<JSObject*> mGlobal;
+};
+
+class PJSValidatorChild;
+
+class JSOracleChild final : public PJSOracleChild {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(JSOracleChild, override);
+
+  already_AddRefed<PJSValidatorChild> AllocPJSValidatorChild();
+
+  void Start(Endpoint<PJSOracleChild>&& aEndpoint);
+
+  static struct JSContext* JSContext();
+  static class JSObject* JSObject();
+
+ private:
+  ~JSOracleChild() = default;
+
+  static JSOracleChild* GetSingleton();
+};
+}  // namespace mozilla::dom
+
+#endif  // defined(mozilla_dom_JSOracleChild)
diff --git a/dom/ipc/JSOracleParent.cpp b/dom/ipc/JSOracleParent.cpp
new file mode 100644
index 0000000000..31a8768422
--- /dev/null
+++ b/dom/ipc/JSOracleParent.cpp
@@ -0,0 +1,81 @@
+/* -*- 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 "mozilla/dom/JSOracleParent.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/dom/PJSOracle.h"
+#include "mozilla/ipc/Endpoint.h"
+#include "mozilla/ipc/UtilityProcessManager.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+static StaticRefPtr<JSOracleParent> sOracleSingleton;
+
+/* static */
+void JSOracleParent::WithJSOracle(
+    const std::function<void(JSOracleParent* aParent)>& aCallback) {
+  GetSingleton()->StartJSOracle()->Then(
+      GetMainThreadSerialEventTarget(), __func__,
+      [aCallback](const JSOraclePromise::ResolveOrRejectValue& aResult) {
+        aCallback(aResult.IsReject() || !aResult.ResolveValue()
+                      ? nullptr
+                      : GetSingleton());
+      });
+}
+
+void JSOracleParent::ActorDestroy(ActorDestroyReason aReason) {
+  // Given an actor can only be bound to one process,
+  // if the utility process crashes and we create a new one,
+  // we can't reuse the same JSOracleParent instance for it,
+  // so we always create a new JSOracleParent to replace
+  // the existing one.
+  if (aReason == ActorDestroyReason::AbnormalShutdown) {
+    sOracleSingleton = new JSOracleParent();
+  }
+}
+
+/* static */
+JSOracleParent* JSOracleParent::GetSingleton() {
+  if (!sOracleSingleton) {
+    sOracleSingleton = new JSOracleParent();
+    ClearOnShutdown(&sOracleSingleton);
+  }
+
+  return sOracleSingleton;
+}
+
+RefPtr<JSOracleParent::JSOraclePromise> JSOracleParent::StartJSOracle() {
+  using namespace mozilla::ipc;
+  RefPtr<JSOracleParent> parent = JSOracleParent::GetSingleton();
+  return UtilityProcessManager::GetSingleton()->StartJSOracle(parent);
+}
+
+nsresult JSOracleParent::BindToUtilityProcess(
+    const RefPtr<mozilla::ipc::UtilityProcessParent>& aUtilityParent) {
+  Endpoint<PJSOracleParent> parentEnd;
+  Endpoint<PJSOracleChild> childEnd;
+  MOZ_ASSERT(aUtilityParent);
+  if (NS_FAILED(PJSOracle::CreateEndpoints(base::GetCurrentProcId(),
+                                           aUtilityParent->OtherPid(),
+                                           &parentEnd, &childEnd))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!aUtilityParent->SendStartJSOracleService(std::move(childEnd))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  Bind(std::move(parentEnd));
+
+  return NS_OK;
+}
+
+void JSOracleParent::Bind(Endpoint<PJSOracleParent>&& aEndpoint) {
+  DebugOnly<bool> ok = aEndpoint.Bind(this);
+  MOZ_ASSERT(ok);
+}
diff --git a/dom/ipc/JSOracleParent.h b/dom/ipc/JSOracleParent.h
new file mode 100644
index 0000000000..f318123369
--- /dev/null
+++ b/dom/ipc/JSOracleParent.h
@@ -0,0 +1,48 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_JSOracleParent
+#define mozilla_dom_JSOracleParent
+
+#include "mozilla/MozPromise.h"
+#include "mozilla/ProcInfo.h"
+#include "mozilla/dom/PJSOracleParent.h"
+
+namespace mozilla::ipc {
+class UtilityProcessParent;
+}
+
+namespace mozilla::dom {
+
+class JSOracleParent final : public PJSOracleParent {
+ public:
+  JSOracleParent() = default;
+
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(JSOracleParent, override);
+
+  static void WithJSOracle(
+      const std::function<void(JSOracleParent* aParent)>& aCallback);
+
+  UtilityActorName GetActorName() { return UtilityActorName::JSOracle; }
+
+  void ActorDestroy(ActorDestroyReason aReason) override;
+
+  nsresult BindToUtilityProcess(
+      const RefPtr<mozilla::ipc::UtilityProcessParent>& aUtilityParent);
+
+  void Bind(Endpoint<PJSOracleParent>&& aEndpoint);
+
+ private:
+  ~JSOracleParent() = default;
+
+  static JSOracleParent* GetSingleton();
+
+  using JSOraclePromise = GenericNonExclusivePromise;
+  RefPtr<JSOraclePromise> StartJSOracle();
+};
+}  // namespace mozilla::dom
+
+#endif  // defined(mozilla_dom_JSOracleParent)
diff --git a/dom/ipc/JSValidatorChild.cpp b/dom/ipc/JSValidatorChild.cpp
new file mode 100644
index 0000000000..1b9b8e04ad
--- /dev/null
+++ b/dom/ipc/JSValidatorChild.cpp
@@ -0,0 +1,247 @@
+/* -*- 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 "mozilla/dom/JSValidatorChild.h"
+#include "js/JSON.h"
+#include "mozilla/dom/JSOracleChild.h"
+
+#include "mozilla/Encoding.h"
+#include "mozilla/dom/ScriptDecoding.h"
+#include "mozilla/ipc/Endpoint.h"
+
+#include "js/experimental/JSStencil.h"
+#include "js/SourceText.h"
+#include "js/Exception.h"
+#include "js/GlobalObject.h"
+#include "js/CompileOptions.h"
+#include "js/RealmOptions.h"
+
+using namespace mozilla::dom;
+using Encoding = mozilla::Encoding;
+
+mozilla::UniquePtr<mozilla::Decoder> TryGetDecoder(
+    const mozilla::Span<const uint8_t>& aSourceBytes,
+    const nsACString& aContentCharset, const nsAString& aHintCharset,
+    const nsAString& aDocumentCharset) {
+  const Encoding* encoding;
+  mozilla::UniquePtr<mozilla::Decoder> unicodeDecoder;
+
+  std::tie(encoding, std::ignore) = Encoding::ForBOM(aSourceBytes);
+  if (encoding) {
+    unicodeDecoder = encoding->NewDecoderWithBOMRemoval();
+  }
+
+  if (!unicodeDecoder) {
+    encoding = Encoding::ForLabel(aContentCharset);
+    if (encoding) {
+      unicodeDecoder = encoding->NewDecoderWithoutBOMHandling();
+    }
+
+    if (!unicodeDecoder) {
+      encoding = Encoding::ForLabel(aHintCharset);
+      if (encoding) {
+        unicodeDecoder = encoding->NewDecoderWithoutBOMHandling();
+      }
+    }
+
+    if (!unicodeDecoder) {
+      encoding = Encoding::ForLabel(aDocumentCharset);
+      if (encoding) {
+        unicodeDecoder = encoding->NewDecoderWithoutBOMHandling();
+      }
+    }
+  }
+
+  if (!unicodeDecoder && !IsUtf8(mozilla::Span(reinterpret_cast<const char*>(
+                                                   aSourceBytes.Elements()),
+                                               aSourceBytes.Length()))) {
+    // Curiously, there are various callers that don't pass aDocument. The
+    // fallback in the old code was ISO-8859-1, which behaved like
+    // windows-1252.
+    unicodeDecoder = WINDOWS_1252_ENCODING->NewDecoderWithoutBOMHandling();
+  }
+
+  return unicodeDecoder;
+}
+
+mozilla::ipc::IPCResult JSValidatorChild::RecvIsOpaqueResponseAllowed(
+    IsOpaqueResponseAllowedResolver&& aResolver) {
+  mResolver.emplace(aResolver);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult JSValidatorChild::RecvOnDataAvailable(Shmem&& aData) {
+  if (!mResolver) {
+    MOZ_ASSERT(!CanSend());
+    return IPC_OK();
+  }
+
+  if (!mSourceBytes.Append(Span(aData.get<char>(), aData.Size<char>()),
+                           mozilla::fallible)) {
+    // To prevent an attacker from flood the validation process,
+    // we don't validate here.
+    Resolve(ValidatorResult::Failure);
+  }
+  DeallocShmem(aData);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult JSValidatorChild::RecvOnStopRequest(
+    const nsresult& aReason, const nsACString& aContentCharset,
+    const nsAString& aHintCharset, const nsAString& aDocumentCharset) {
+  if (!mResolver) {
+    return IPC_OK();
+  }
+
+  if (NS_FAILED(aReason)) {
+    Resolve(ValidatorResult::Failure);
+  } else if (mSourceBytes.IsEmpty()) {
+    // The empty document parses as JavaScript.
+    Resolve(ValidatorResult::JavaScript);
+  } else {
+    UniquePtr<Decoder> unicodeDecoder = TryGetDecoder(
+        mSourceBytes, aContentCharset, aHintCharset, aDocumentCharset);
+
+    if (!unicodeDecoder) {
+      Resolve(ShouldAllowJS(mSourceBytes));
+    } else {
+      BufferUniquePtr<Utf8Unit[]> buffer;
+      auto result = GetUTF8EncodedContent(mSourceBytes, buffer, unicodeDecoder);
+      if (result.isErr()) {
+        Resolve(ValidatorResult::Failure);
+      } else {
+        Resolve(ShouldAllowJS(result.unwrap()));
+      }
+    }
+  }
+
+  return IPC_OK();
+}
+
+void JSValidatorChild::ActorDestroy(ActorDestroyReason aReason) {
+  if (mResolver) {
+    Resolve(ValidatorResult::Failure);
+  }
+};
+
+void JSValidatorChild::Resolve(ValidatorResult aResult) {
+  MOZ_ASSERT(mResolver);
+  Maybe<Shmem> data = Nothing();
+  if (aResult == ValidatorResult::JavaScript && !mSourceBytes.IsEmpty()) {
+    Shmem sharedData;
+    nsresult rv =
+        JSValidatorUtils::CopyCStringToShmem(this, mSourceBytes, sharedData);
+    if (NS_SUCCEEDED(rv)) {
+      data = Some(std::move(sharedData));
+    }
+  }
+
+  mResolver.ref()(std::tuple<mozilla::Maybe<Shmem>&&, const ValidatorResult&>(
+      std::move(data), aResult));
+  mResolver.reset();
+}
+
+mozilla::Result<mozilla::Span<const char>, nsresult>
+JSValidatorChild::GetUTF8EncodedContent(
+    const mozilla::Span<const uint8_t>& aData,
+    BufferUniquePtr<Utf8Unit[]>& aBuffer, UniquePtr<Decoder>& aDecoder) {
+  MOZ_ASSERT(aDecoder);
+  // We need the output buffer to be UTF8
+  CheckedInt<size_t> bufferLength =
+      ScriptDecoding<Utf8Unit>::MaxBufferLength(aDecoder, aData.Length());
+  if (!bufferLength.isValid()) {
+    return mozilla::Err(NS_ERROR_FAILURE);
+  }
+
+  CheckedInt<size_t> bufferByteSize = bufferLength * sizeof(Utf8Unit);
+  if (!bufferByteSize.isValid()) {
+    return mozilla::Err(NS_ERROR_FAILURE);
+  }
+
+  aBuffer.reset(static_cast<Utf8Unit*>(js_malloc(bufferByteSize.value())));
+  if (!aBuffer) {
+    return mozilla::Err(NS_ERROR_FAILURE);
+  }
+
+  size_t written = ScriptDecoding<Utf8Unit>::DecodeInto(
+      aDecoder, aData, Span(aBuffer.get(), bufferLength.value()),
+      /* aEndOfSource = */ true);
+  MOZ_ASSERT(written <= bufferLength.value());
+  MOZ_ASSERT(
+      IsUtf8(Span(reinterpret_cast<const char*>(aBuffer.get()), written)));
+
+  return Span(reinterpret_cast<const char*>(aBuffer.get()), written);
+}
+
+JSValidatorChild::ValidatorResult JSValidatorChild::ShouldAllowJS(
+    const mozilla::Span<const char>& aSpan) const {
+  MOZ_ASSERT(!aSpan.IsEmpty());
+
+  MOZ_DIAGNOSTIC_ASSERT(IsUtf8(aSpan));
+
+  JSContext* cx = JSOracleChild::JSContext();
+  if (!cx) {
+    return ValidatorResult::Failure;
+  }
+
+  JS::Rooted<JSObject*> global(cx, JSOracleChild::JSObject());
+  if (!global) {
+    return ValidatorResult::Failure;
+  }
+
+  JS::SourceText<Utf8Unit> srcBuf;
+  if (!srcBuf.init(cx, aSpan.Elements(), aSpan.Length(),
+                   JS::SourceOwnership::Borrowed)) {
+    JS_ClearPendingException(cx);
+    return ValidatorResult::Failure;
+  }
+
+  JSAutoRealm ar(cx, global);
+
+  // Parse to JavaScript
+  RefPtr<JS::Stencil> stencil =
+      CompileGlobalScriptToStencil(cx, JS::CompileOptions(cx), srcBuf);
+
+  if (!stencil) {
+    JS_ClearPendingException(cx);
+    return ValidatorResult::Other;
+  }
+
+  MOZ_ASSERT(!aSpan.IsEmpty());
+
+  // Parse to JSON
+  JS::Rooted<JS::Value> json(cx);
+  if (IsAscii(aSpan)) {
+    // Ascii is a subset of Latin1, and JS_ParseJSON can take Latin1 directly
+    if (JS_ParseJSON(cx,
+                     reinterpret_cast<const JS::Latin1Char*>(aSpan.Elements()),
+                     aSpan.Length(), &json)) {
+      return ValidatorResult::JSON;
+    }
+  } else {
+    nsString decoded;
+    nsresult rv = UTF_8_ENCODING->DecodeWithBOMRemoval(
+        Span(reinterpret_cast<const uint8_t*>(aSpan.Elements()),
+             aSpan.Length()),
+        decoded);
+    if (NS_FAILED(rv)) {
+      return ValidatorResult::Failure;
+    }
+
+    if (JS_ParseJSON(cx, decoded.BeginReading(), decoded.Length(), &json)) {
+      return ValidatorResult::JSON;
+    }
+  }
+
+  // Since the JSON parsing failed, we confirmed the file is Javascript and not
+  // JSON.
+  if (JS_IsExceptionPending(cx)) {
+    JS_ClearPendingException(cx);
+  }
+  return ValidatorResult::JavaScript;
+}
diff --git a/dom/ipc/JSValidatorChild.h b/dom/ipc/JSValidatorChild.h
new file mode 100644
index 0000000000..b8899afd5b
--- /dev/null
+++ b/dom/ipc/JSValidatorChild.h
@@ -0,0 +1,57 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_JSValidatorChild
+#define mozilla_dom_JSValidatorChild
+
+#include "mozilla/Result.h"
+#include "mozilla/ProcInfo.h"
+#include "mozilla/dom/PJSValidatorChild.h"
+#include "mozilla/dom/JSValidatorUtils.h"
+#include "mozilla/net/OpaqueResponseUtils.h"
+
+template <typename T>
+using BufferUniquePtr = mozilla::UniquePtr<T, JS::FreePolicy>;
+
+namespace mozilla {
+class Decoder;
+}  // namespace mozilla
+
+namespace mozilla::dom {
+class JSValidatorChild final : public PJSValidatorChild {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(JSValidatorChild, override);
+
+  mozilla::ipc::IPCResult RecvIsOpaqueResponseAllowed(
+      IsOpaqueResponseAllowedResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvOnDataAvailable(Shmem&& aData);
+
+  mozilla::ipc::IPCResult RecvOnStopRequest(const nsresult& aReason,
+                                            const nsACString& aContentCharset,
+                                            const nsAString& aHintCharset,
+                                            const nsAString& aDocumentCharset);
+
+  void ActorDestroy(ActorDestroyReason aReason) override;
+
+ private:
+  virtual ~JSValidatorChild() = default;
+
+  using ValidatorResult = net::OpaqueResponseBlocker::ValidatorResult;
+  void Resolve(ValidatorResult aResult);
+  ValidatorResult ShouldAllowJS(const mozilla::Span<const char>& aSpan) const;
+
+  mozilla::Result<mozilla::Span<const char>, nsresult> GetUTF8EncodedContent(
+      const mozilla::Span<const uint8_t>& aData,
+      BufferUniquePtr<Utf8Unit[]>& aBuffer,
+      UniquePtr<mozilla::Decoder>& aDecoder);
+
+  nsCString mSourceBytes;
+  Maybe<IsOpaqueResponseAllowedResolver> mResolver;
+};
+}  // namespace mozilla::dom
+
+#endif  // defined(mozilla_dom_JSValidatorChild)
diff --git a/dom/ipc/JSValidatorParent.cpp b/dom/ipc/JSValidatorParent.cpp
new file mode 100644
index 0000000000..45b6d9de4c
--- /dev/null
+++ b/dom/ipc/JSValidatorParent.cpp
@@ -0,0 +1,99 @@
+/* -*- 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 "mozilla/net/OpaqueResponseUtils.h"
+#include "mozilla/dom/JSValidatorParent.h"
+#include "mozilla/dom/JSValidatorUtils.h"
+#include "mozilla/dom/JSOracleParent.h"
+#include "mozilla/RefPtr.h"
+#include "nsCOMPtr.h"
+#include "HttpBaseChannel.h"
+
+namespace mozilla::dom {
+/* static */
+already_AddRefed<JSValidatorParent> JSValidatorParent::Create() {
+  RefPtr<JSValidatorParent> validator = new JSValidatorParent();
+  JSOracleParent::WithJSOracle([validator](JSOracleParent* aParent) {
+    MOZ_ASSERT_IF(aParent, aParent->CanSend());
+    if (aParent) {
+      MOZ_ALWAYS_TRUE(aParent->SendPJSValidatorConstructor(validator));
+    }
+  });
+  return validator.forget();
+}
+
+void JSValidatorParent::IsOpaqueResponseAllowed(
+    const std::function<void(Maybe<Shmem>, ValidatorResult)>& aCallback) {
+  JSOracleParent::WithJSOracle([=, self = RefPtr{this}](const auto* aParent) {
+    if (aParent) {
+      MOZ_DIAGNOSTIC_ASSERT(self->CanSend());
+      self->SendIsOpaqueResponseAllowed()->Then(
+          GetMainThreadSerialEventTarget(), __func__,
+          [aCallback](
+              const IsOpaqueResponseAllowedPromise::ResolveOrRejectValue&
+                  aResult) {
+            if (aResult.IsResolve()) {
+              auto [data, result] = aResult.ResolveValue();
+              aCallback(std::move(data), result);
+            } else {
+              // For cases like the Utility Process crashes, the promise will be
+              // rejected due to sending failures, and we'll block the request
+              // since we can't validate it.
+              aCallback(Nothing(), ValidatorResult::Failure);
+            }
+          });
+    } else {
+      aCallback(Nothing(), ValidatorResult::Failure);
+    }
+  });
+}
+
+void JSValidatorParent::OnDataAvailable(const nsACString& aData) {
+  JSOracleParent::WithJSOracle(
+      [self = RefPtr{this}, data = nsCString{aData}](const auto* aParent) {
+        if (!aParent) {
+          return;
+        }
+
+        if (self->CanSend()) {
+          Shmem sharedData;
+          nsresult rv =
+              JSValidatorUtils::CopyCStringToShmem(self, data, sharedData);
+          if (NS_FAILED(rv)) {
+            return;
+          }
+          Unused << self->SendOnDataAvailable(std::move(sharedData));
+        }
+      });
+}
+
+void JSValidatorParent::OnStopRequest(nsresult aResult, nsIRequest& aRequest) {
+  JSOracleParent::WithJSOracle(
+      [self = RefPtr{this}, aResult,
+       request = nsCOMPtr{&aRequest}](const auto* aParent) {
+        if (!aParent) {
+          return;
+        }
+        if (self->CanSend() && request) {
+          nsCOMPtr<net::HttpBaseChannel> httpBaseChannel =
+              do_QueryInterface(request);
+          MOZ_ASSERT(httpBaseChannel);
+
+          nsAutoCString contentCharset;
+          Unused << httpBaseChannel->GetContentCharset(contentCharset);
+
+          nsAutoString hintCharset;
+          Unused << httpBaseChannel->GetClassicScriptHintCharset(hintCharset);
+
+          nsAutoString documentCharset;
+          Unused << httpBaseChannel->GetDocumentCharacterSet(documentCharset);
+
+          Unused << self->SendOnStopRequest(aResult, contentCharset,
+                                            hintCharset, documentCharset);
+        }
+      });
+}
+}  // namespace mozilla::dom
diff --git a/dom/ipc/JSValidatorParent.h b/dom/ipc/JSValidatorParent.h
new file mode 100644
index 0000000000..66528a6470
--- /dev/null
+++ b/dom/ipc/JSValidatorParent.h
@@ -0,0 +1,40 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_JSValidatorParent
+#define mozilla_dom_JSValidatorParent
+
+#include "mozilla/MozPromise.h"
+#include "mozilla/ProcInfo.h"
+#include "mozilla/dom/PJSValidatorParent.h"
+
+namespace mozilla::ipc {
+class UtilityProcessParent;
+class IProtocol;
+}  // namespace mozilla::ipc
+
+namespace mozilla::dom {
+
+class JSValidatorParent final : public PJSValidatorParent {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(JSValidatorParent, override);
+
+  static already_AddRefed<JSValidatorParent> Create();
+
+  void IsOpaqueResponseAllowed(
+      const std::function<void(Maybe<mozilla::ipc::Shmem>, ValidatorResult)>&
+          aCallback);
+
+  void OnDataAvailable(const nsACString& aData);
+
+  void OnStopRequest(nsresult aResult, nsIRequest& aRequest);
+
+ private:
+  virtual ~JSValidatorParent() = default;
+};
+}  // namespace mozilla::dom
+
+#endif  // defined(mozilla_dom_JSValidatorParent)
diff --git a/dom/ipc/JSValidatorUtils.cpp b/dom/ipc/JSValidatorUtils.cpp
new file mode 100644
index 0000000000..cde22a453f
--- /dev/null
+++ b/dom/ipc/JSValidatorUtils.cpp
@@ -0,0 +1,25 @@
+/* -*- 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 "mozilla/dom/JSValidatorUtils.h"
+#include "mozilla/ipc/ProtocolUtils.h"
+#include "mozilla/ipc/Shmem.h"
+#include "nsStringFwd.h"
+
+using namespace mozilla::ipc;
+
+namespace mozilla::dom {
+/* static */
+nsresult JSValidatorUtils::CopyCStringToShmem(IProtocol* aActor,
+                                              const nsCString& aCString,
+                                              Shmem& aMem) {
+  if (!aActor->AllocShmem(aCString.Length(), &aMem)) {
+    return NS_ERROR_FAILURE;
+  }
+  memcpy(aMem.get<char>(), aCString.BeginReading(), aCString.Length());
+  return NS_OK;
+}
+}  // namespace mozilla::dom
diff --git a/dom/ipc/JSValidatorUtils.h b/dom/ipc/JSValidatorUtils.h
new file mode 100644
index 0000000000..a0541b3992
--- /dev/null
+++ b/dom/ipc/JSValidatorUtils.h
@@ -0,0 +1,26 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_JSValidatorUtils
+#define mozilla_dom_JSValidatorUtils
+#include "ErrorList.h"
+#include "nsStringFwd.h"
+
+namespace mozilla::ipc {
+class IProtocol;
+class Shmem;
+}  // namespace mozilla::ipc
+
+using namespace mozilla::ipc;
+
+namespace mozilla::dom {
+class JSValidatorUtils final {
+ public:
+  static nsresult CopyCStringToShmem(IProtocol* aActor,
+                                     const nsCString& aCString, Shmem& aMem);
+};
+};  // namespace mozilla::dom
+#endif
diff --git a/dom/ipc/LoginDetectionService.cpp b/dom/ipc/LoginDetectionService.cpp
new file mode 100644
index 0000000000..28342e430c
--- /dev/null
+++ b/dom/ipc/LoginDetectionService.cpp
@@ -0,0 +1,158 @@
+/* -*- 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 "LoginDetectionService.h"
+
+#include "nsILoginInfo.h"
+#include "nsILoginManager.h"
+#include "nsIObserver.h"
+#include "nsIXULRuntime.h"
+#include "nsServiceManagerUtils.h"
+#include "nsXULAppAPI.h"
+
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/StaticPrefs_fission.h"
+#include "mozilla/dom/ProcessIsolation.h"
+
+namespace mozilla::dom {
+
+static StaticRefPtr<LoginDetectionService> gLoginDetectionService;
+
+namespace {
+
+void OnFissionPrefsChange(const char* aPrefName, void* aData) {
+  MOZ_ASSERT(gLoginDetectionService);
+
+  gLoginDetectionService->MaybeStartMonitoring();
+}
+
+}  // namespace
+
+NS_IMPL_ISUPPORTS(LoginDetectionService, nsILoginDetectionService,
+                  nsILoginSearchCallback, nsIObserver, nsISupportsWeakReference)
+
+// static
+already_AddRefed<LoginDetectionService> LoginDetectionService::GetSingleton() {
+  if (gLoginDetectionService) {
+    return do_AddRef(gLoginDetectionService);
+  }
+
+  gLoginDetectionService = new LoginDetectionService();
+  ClearOnShutdown(&gLoginDetectionService);
+
+  return do_AddRef(gLoginDetectionService);
+}
+
+LoginDetectionService::LoginDetectionService() : mIsLoginsLoaded(false) {}
+LoginDetectionService::~LoginDetectionService() { UnregisterObserver(); }
+
+void LoginDetectionService::MaybeStartMonitoring() {
+  if (IsIsolateHighValueSiteEnabled()) {
+    // We want to isolate sites with a saved password, so fetch saved logins
+    // from the password manager, and then add the 'HighValue' permission.
+
+    // Note that we don't monitor whether a login is added or removed after
+    // logins are fetched. For adding logins, this will be covered by form
+    // submission detection heuristic. As for removing logins, it doesn't
+    // provide security benefit just to NOT isolate the removed site. The site
+    // will not be isolated when its permission expired.
+    FetchLogins();
+  }
+
+  if (IsIsolateHighValueSiteEnabled() ||
+      StaticPrefs::fission_highValue_login_monitor()) {
+    // When the pref is on, we monitor users' login attempt event when we
+    // are not isolating high value sites. This is because We can't detect the
+    // case where a user is already logged in to a site, and don't save a
+    // password for it. So we want to start monitoring login attempts prior
+    // to releasing the feature.
+    if (!mObs) {
+      mObs = mozilla::services::GetObserverService();
+      mObs->AddObserver(this, "passwordmgr-form-submission-detected", false);
+    }
+  } else {
+    UnregisterObserver();
+  }
+}
+
+void LoginDetectionService::FetchLogins() {
+  nsresult rv;
+  nsCOMPtr<nsILoginManager> loginManager =
+      do_GetService(NS_LOGINMANAGER_CONTRACTID, &rv);
+  if (NS_WARN_IF(!loginManager)) {
+    return;
+  }
+
+  Unused << loginManager->GetAllLoginsWithCallbackAsync(this);
+}
+
+void LoginDetectionService::UnregisterObserver() {
+  if (mObs) {
+    mObs->RemoveObserver(this, "passwordmgr-form-submission-detected");
+    mObs = nullptr;
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// nsILoginDetectionService implementation
+NS_IMETHODIMP LoginDetectionService::Init() {
+  if (XRE_IsContentProcess()) {
+    return NS_OK;
+  }
+
+  Preferences::RegisterCallback(OnFissionPrefsChange, "fission.autostart");
+  Preferences::RegisterCallback(OnFissionPrefsChange,
+                                "fission.webContentIsolationStrategy");
+
+  MaybeStartMonitoring();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP LoginDetectionService::IsLoginsLoaded(bool* aResult) {
+  if (IsIsolateHighValueSiteEnabled()) {
+    *aResult = mIsLoginsLoaded;
+  } else {
+    // When the feature is disabled, just returns true so testcases don't
+    // block on waiting for us to load logins.
+    *aResult = true;
+  }
+  return NS_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// nsILoginSearchObserver implementation
+NS_IMETHODIMP
+LoginDetectionService::OnSearchComplete(
+    const nsTArray<RefPtr<nsILoginInfo>>& aLogins) {
+  // Add all origins with saved passwords to the permission manager.
+  for (const auto& login : aLogins) {
+    nsString origin;
+    login->GetOrigin(origin);
+
+    AddHighValuePermission(NS_ConvertUTF16toUTF8(origin),
+                           mozilla::dom::kHighValueHasSavedLoginPermission);
+  }
+
+  mIsLoginsLoaded = true;
+  return NS_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// nsIObserver implementation
+NS_IMETHODIMP
+LoginDetectionService::Observe(nsISupports* aSubject, const char* aTopic,
+                               const char16_t* aData) {
+  if ("passwordmgr-form-submission-detected"_ns.Equals(aTopic)) {
+    nsDependentString origin(aData);
+    AddHighValuePermission(NS_ConvertUTF16toUTF8(origin),
+                           mozilla::dom::kHighValueIsLoggedInPermission);
+  }
+
+  return NS_OK;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/LoginDetectionService.h b/dom/ipc/LoginDetectionService.h
new file mode 100644
index 0000000000..b0fd170855
--- /dev/null
+++ b/dom/ipc/LoginDetectionService.h
@@ -0,0 +1,60 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_LoginDetectionService_h
+#define mozilla_dom_LoginDetectionService_h
+
+#include "nsIObserver.h"
+#include "nsIObserverService.h"
+#include "nsILoginDetectionService.h"
+#include "nsILoginManager.h"
+#include "nsWeakReference.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Preferences.h"
+
+namespace mozilla::dom {
+
+/**
+ * Detect whether the user is 'possibly' logged in to a site, and add the
+ * HighValue permission to the permission manager. We say 'possibly' because
+ * the detection is done in a very loose way. For example, for sites that have
+ * an associated login stored in the password manager are considered `logged in`
+ * by the service, which is not always true in terms of whether the users is
+ * really logged in to the site.
+ */
+class LoginDetectionService final : public nsILoginDetectionService,
+                                    public nsILoginSearchCallback,
+                                    public nsIObserver,
+                                    public nsSupportsWeakReference {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSILOGINDETECTIONSERVICE
+  NS_DECL_NSILOGINSEARCHCALLBACK
+  NS_DECL_NSIOBSERVER
+
+  static already_AddRefed<LoginDetectionService> GetSingleton();
+
+  void MaybeStartMonitoring();
+
+ private:
+  LoginDetectionService();
+  virtual ~LoginDetectionService();
+
+  // Fetch saved logins from the password manager.
+  void FetchLogins();
+
+  void RegisterObserver();
+  void UnregisterObserver();
+
+  nsCOMPtr<nsIObserverService> mObs;
+
+  // Used by testcase to make sure logins are fetched.
+  bool mIsLoginsLoaded;
+};
+
+}  // namespace mozilla::dom
+
+#endif
diff --git a/dom/ipc/MMPrinter.cpp b/dom/ipc/MMPrinter.cpp
new file mode 100644
index 0000000000..be2911341a
--- /dev/null
+++ b/dom/ipc/MMPrinter.cpp
@@ -0,0 +1,92 @@
+/* -*- 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 "MMPrinter.h"
+
+#include "jsapi.h"
+#include "nsJSUtils.h"
+#include "Logging.h"
+#include "mozilla/Bootstrap.h"
+#include "mozilla/dom/ipc/StructuredCloneData.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/RandomNum.h"
+#include "nsFrameMessageManager.h"
+#include "prenv.h"
+
+namespace mozilla::dom {
+
+LazyLogModule MMPrinter::sMMLog("MessageManager");
+
+// You can use
+// https://gist.github.com/tomrittervg/adb8688426a9a5340da96004e2c8af79 to parse
+// the output of the logs into logs more friendly to reading.
+
+/* static */
+void MMPrinter::PrintImpl(char const* aLocation, const nsAString& aMsg,
+                          ClonedMessageData const& aData) {
+  NS_ConvertUTF16toUTF8 charMsg(aMsg);
+
+  /*
+   * The topic will be skipped if the topic name appears anywhere as a substring
+   * of the filter.
+   *
+   * Example:
+   *   MOZ_LOG_MESSAGEMANAGER_SKIP="foobar|extension"
+   *     Will  match the topics 'foobar', 'foo', 'bar', and 'ten' (even though
+   * you may not have intended to match the latter three) and it will not match
+   * the topics 'extensionresult' or 'Foo'.
+   */
+  char* mmSkipLog = PR_GetEnv("MOZ_LOG_MESSAGEMANAGER_SKIP");
+
+  if (mmSkipLog && strstr(mmSkipLog, charMsg.get())) {
+    return;
+  }
+
+  uint64_t msg_id = RandomUint64OrDie();
+
+  MOZ_LOG(MMPrinter::sMMLog, LogLevel::Debug,
+          ("%" PRIu64 " %s Message: %s in process type: %s", msg_id, aLocation,
+           charMsg.get(), XRE_GetProcessTypeString()));
+
+  if (!MOZ_LOG_TEST(sMMLog, LogLevel::Verbose)) {
+    return;
+  }
+
+  ErrorResult rv;
+
+  AutoJSAPI jsapi;
+  // We're using this context to deserialize, stringify, and print a message
+  // manager message here. Since the messages are always sent from and to system
+  // scopes, we need to do this in a system scope, or attempting to deserialize
+  // certain privileged objects will fail.
+  MOZ_ALWAYS_TRUE(jsapi.Init(xpc::PrivilegedJunkScope()));
+  JSContext* cx = jsapi.cx();
+
+  ipc::StructuredCloneData data;
+  ipc::UnpackClonedMessageData(aData, data);
+
+  /* Read original StructuredCloneData. */
+  JS::Rooted<JS::Value> scdContent(cx);
+  data.Read(cx, &scdContent, rv);
+  if (rv.Failed()) {
+    // In testing, the only reason this would fail was if there was no data in
+    // the message; so it seems like this is safe-ish.
+    MOZ_LOG(MMPrinter::sMMLog, LogLevel::Verbose,
+            ("%" PRIu64 " (No Data)", msg_id));
+    rv.SuppressException();
+    return;
+  }
+
+  JS::Rooted<JSString*> unevalObj(cx, JS_ValueToSource(cx, scdContent));
+  nsAutoJSString srcString;
+  if (!srcString.init(cx, unevalObj)) return;
+
+  MOZ_LOG(MMPrinter::sMMLog, LogLevel::Verbose,
+          ("%" PRIu64 " %s", msg_id, NS_ConvertUTF16toUTF8(srcString).get()));
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/MMPrinter.h b/dom/ipc/MMPrinter.h
new file mode 100644
index 0000000000..7d89f9ee8f
--- /dev/null
+++ b/dom/ipc/MMPrinter.h
@@ -0,0 +1,32 @@
+/* -*- 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/. */
+
+#ifndef MMPrinter_h
+#define MMPrinter_h
+
+#include "mozilla/dom/DOMTypes.h"
+#include "nsString.h"
+
+namespace mozilla::dom {
+
+class MMPrinter {
+ public:
+  static void Print(char const* aLocation, const nsAString& aMsg,
+                    ClonedMessageData const& aData) {
+    if (MOZ_UNLIKELY(MOZ_LOG_TEST(MMPrinter::sMMLog, LogLevel::Debug))) {
+      MMPrinter::PrintImpl(aLocation, aMsg, aData);
+    }
+  }
+
+ private:
+  static LazyLogModule sMMLog;
+  static void PrintImpl(char const* aLocation, const nsAString& aMsg,
+                        ClonedMessageData const& aData);
+};
+
+}  // namespace mozilla::dom
+
+#endif /* MMPrinter_h */
diff --git a/dom/ipc/ManifestMessagesChild.sys.mjs b/dom/ipc/ManifestMessagesChild.sys.mjs
new file mode 100644
index 0000000000..5a42fd3206
--- /dev/null
+++ b/dom/ipc/ManifestMessagesChild.sys.mjs
@@ -0,0 +1,112 @@
+/* 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/.*/
+/*
+ * Manifest obtainer frame script implementation of:
+ * http://www.w3.org/TR/appmanifest/#obtaining
+ *
+ * It searches a top-level browsing context for
+ * a <link rel=manifest> element. Then fetches
+ * and processes the linked manifest.
+ *
+ * BUG: https://bugzilla.mozilla.org/show_bug.cgi?id=1083410
+ */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  ManifestFinder: "resource://gre/modules/ManifestFinder.sys.mjs",
+  ManifestIcons: "resource://gre/modules/ManifestIcons.sys.mjs",
+  ManifestObtainer: "resource://gre/modules/ManifestObtainer.sys.mjs",
+});
+
+export class ManifestMessagesChild extends JSWindowActorChild {
+  receiveMessage(message) {
+    switch (message.name) {
+      case "DOM:WebManifest:hasManifestLink":
+        return this.hasManifestLink();
+      case "DOM:ManifestObtainer:Obtain":
+        return this.obtainManifest(message.data);
+      case "DOM:WebManifest:fetchIcon":
+        return this.fetchIcon(message);
+    }
+    return undefined;
+  }
+
+  /**
+   * Check if the document includes a link to a web manifest.
+   */
+  hasManifestLink() {
+    const response = makeMsgResponse();
+    response.result = lazy.ManifestFinder.contentHasManifestLink(
+      this.contentWindow
+    );
+    response.success = true;
+    return response;
+  }
+
+  /**
+   * Asynchronously obtains a web manifest from this window by using the
+   * ManifestObtainer and returns the result.
+   * @param {Object} checkConformance True if spec conformance messages should be collected.
+   */
+  async obtainManifest(options) {
+    const { checkConformance } = options;
+    const response = makeMsgResponse();
+    try {
+      response.result = await lazy.ManifestObtainer.contentObtainManifest(
+        this.contentWindow,
+        { checkConformance }
+      );
+      response.success = true;
+    } catch (err) {
+      response.result = serializeError(err);
+    }
+    return response;
+  }
+
+  /**
+   * Given a manifest and an expected icon size, ask ManifestIcons
+   * to fetch the appropriate icon and send along result
+   */
+  async fetchIcon({ data: { manifest, iconSize } }) {
+    const response = makeMsgResponse();
+    try {
+      response.result = await lazy.ManifestIcons.contentFetchIcon(
+        this.contentWindow,
+        manifest,
+        iconSize
+      );
+      response.success = true;
+    } catch (err) {
+      response.result = serializeError(err);
+    }
+    return response;
+  }
+}
+
+/**
+ * Utility function to Serializes an JS Error, so it can be transferred over
+ * the message channel.
+ * FIX ME: https://bugzilla.mozilla.org/show_bug.cgi?id=1172586
+ * @param  {Error} aError The error to serialize.
+ * @return {Object} The serialized object.
+ */
+function serializeError(aError) {
+  const clone = {
+    fileName: aError.fileName,
+    lineNumber: aError.lineNumber,
+    columnNumber: aError.columnNumber,
+    stack: aError.stack,
+    message: aError.message,
+    name: aError.name,
+  };
+  return clone;
+}
+
+function makeMsgResponse() {
+  return {
+    success: false,
+    result: undefined,
+  };
+}
diff --git a/dom/ipc/MaybeDiscarded.h b/dom/ipc/MaybeDiscarded.h
new file mode 100644
index 0000000000..32c0dde3b9
--- /dev/null
+++ b/dom/ipc/MaybeDiscarded.h
@@ -0,0 +1,133 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_MaybeDiscarded_h
+#define mozilla_dom_MaybeDiscarded_h
+
+#include "mozilla/RefPtr.h"
+
+namespace mozilla::dom {
+
+// Wrapper type for a WindowContext or BrowsingContext instance which may be
+// discarded, and thus unavailable in the current process. This type is used to
+// pass WindowContext and BrowsingContext instances over IPC, as they may be
+// discarded in the receiving process.
+//
+// A MaybeDiscarded can generally be implicitly converted to from a
+// BrowsingContext* or WindowContext*, but requires an explicit check of
+// |IsDiscarded| and call to |get| to read from.
+template <typename T>
+class MaybeDiscarded {
+ public:
+  MaybeDiscarded() = default;
+  MaybeDiscarded(MaybeDiscarded<T>&&) = default;
+  MaybeDiscarded(const MaybeDiscarded<T>&) = default;
+
+  // Construct from raw pointers and |nullptr|.
+  MOZ_IMPLICIT MaybeDiscarded(T* aRawPtr)
+      : mId(aRawPtr ? aRawPtr->Id() : 0), mPtr(aRawPtr) {}
+  MOZ_IMPLICIT MaybeDiscarded(decltype(nullptr)) {}
+
+  // Construct from |RefPtr<I>|
+  template <typename I,
+            typename = std::enable_if_t<std::is_convertible_v<I*, T*>>>
+  MOZ_IMPLICIT MaybeDiscarded(RefPtr<I>&& aPtr)
+      : mId(aPtr ? aPtr->Id() : 0), mPtr(std::move(aPtr)) {}
+  template <typename I,
+            typename = std::enable_if_t<std::is_convertible_v<I*, T*>>>
+  MOZ_IMPLICIT MaybeDiscarded(const RefPtr<I>& aPtr)
+      : mId(aPtr ? aPtr->Id() : 0), mPtr(aPtr) {}
+
+  // Basic assignment operators.
+  MaybeDiscarded<T>& operator=(const MaybeDiscarded<T>&) = default;
+  MaybeDiscarded<T>& operator=(MaybeDiscarded<T>&&) = default;
+  MaybeDiscarded<T>& operator=(decltype(nullptr)) {
+    mId = 0;
+    mPtr = nullptr;
+    return *this;
+  }
+  MaybeDiscarded<T>& operator=(T* aRawPtr) {
+    mId = aRawPtr ? aRawPtr->Id() : 0;
+    mPtr = aRawPtr;
+    return *this;
+  }
+  template <typename I>
+  MaybeDiscarded<T>& operator=(const RefPtr<I>& aRhs) {
+    mId = aRhs ? aRhs->Id() : 0;
+    mPtr = aRhs;
+    return *this;
+  }
+  template <typename I>
+  MaybeDiscarded<T>& operator=(RefPtr<I>&& aRhs) {
+    mId = aRhs ? aRhs->Id() : 0;
+    mPtr = std::move(aRhs);
+    return *this;
+  }
+
+  // Validate that the value is neither discarded nor null.
+  bool IsNullOrDiscarded() const { return !mPtr || mPtr->IsDiscarded(); }
+  bool IsDiscarded() const { return IsNullOrDiscarded() && !IsNull(); }
+  bool IsNull() const { return mId == 0; }
+
+  explicit operator bool() const { return !IsNullOrDiscarded(); }
+
+  // Extract the wrapped |T|. Must not be called on a discarded |T|.
+  T* get() const {
+    MOZ_DIAGNOSTIC_ASSERT(!IsDiscarded());
+    return mPtr.get();
+  }
+  already_AddRefed<T> forget() {
+    MOZ_DIAGNOSTIC_ASSERT(!IsDiscarded());
+    return mPtr.forget();
+  }
+
+  T* operator->() const {
+    MOZ_ASSERT(!IsNull());
+    return get();
+  }
+
+  // Like "get", but gets the "Canonical" version of the type. This method may
+  // only be called in the parent process.
+  auto get_canonical() const -> decltype(get()->Canonical()) {
+    if (get()) {
+      return get()->Canonical();
+    } else {
+      return nullptr;
+    }
+  }
+
+  // The ID for the context wrapped by this MaybeDiscarded. This ID comes from a
+  // remote process, and should generally only be used for logging. A
+  // BrowsingContext with this ID may not exist in the current process.
+  uint64_t ContextId() const { return mId; }
+
+  // Tries to get the wrapped value, disregarding discarded status.
+  // This may return |nullptr| for a non-null |MaybeDiscarded|, in the case that
+  // the target is no longer available in this process.
+  T* GetMaybeDiscarded() const { return mPtr.get(); }
+
+  // Clear the value to a discarded state with the given ID.
+  void SetDiscarded(uint64_t aId) {
+    mId = aId;
+    mPtr = nullptr;
+  }
+
+  // Comparison operators required by IPDL
+  bool operator==(const MaybeDiscarded<T>& aRhs) const {
+    return mId == aRhs.mId && mPtr == aRhs.mPtr;
+  }
+  bool operator!=(const MaybeDiscarded<T>& aRhs) const {
+    return !operator==(aRhs);
+  }
+
+ private:
+  uint64_t mId = 0;
+  RefPtr<T> mPtr;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_MaybeDiscarded_h
diff --git a/dom/ipc/MemMapSnapshot.cpp b/dom/ipc/MemMapSnapshot.cpp
new file mode 100644
index 0000000000..7a104c420e
--- /dev/null
+++ b/dom/ipc/MemMapSnapshot.cpp
@@ -0,0 +1,44 @@
+/* -*- 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 "MemMapSnapshot.h"
+
+#include "mozilla/AutoMemMap.h"
+#include "mozilla/ResultExtensions.h"
+#include "mozilla/ipc/FileDescriptor.h"
+
+namespace mozilla::ipc {
+
+Result<Ok, nsresult> MemMapSnapshot::Init(size_t aSize) {
+  MOZ_ASSERT(!mInitialized);
+
+  if (NS_WARN_IF(!mMem.CreateFreezeable(aSize))) {
+    return Err(NS_ERROR_FAILURE);
+  }
+  if (NS_WARN_IF(!mMem.Map(aSize))) {
+    return Err(NS_ERROR_FAILURE);
+  }
+
+  mInitialized = true;
+  return Ok();
+}
+
+Result<Ok, nsresult> MemMapSnapshot::Finalize(loader::AutoMemMap& aMem) {
+  MOZ_ASSERT(mInitialized);
+
+  if (NS_WARN_IF(!mMem.Freeze())) {
+    return Err(NS_ERROR_FAILURE);
+  }
+  // TakeHandle resets mMem, so call max_size first.
+  size_t size = mMem.max_size();
+  FileDescriptor memHandle(mMem.TakeHandle());
+  MOZ_TRY(aMem.initWithHandle(memHandle, size));
+
+  mInitialized = false;
+  return Ok();
+}
+
+}  // namespace mozilla::ipc
diff --git a/dom/ipc/MemMapSnapshot.h b/dom/ipc/MemMapSnapshot.h
new file mode 100644
index 0000000000..12b4d353ad
--- /dev/null
+++ b/dom/ipc/MemMapSnapshot.h
@@ -0,0 +1,54 @@
+/* -*- 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/. */
+
+#ifndef dom_ipc_MemMapSnapshot_h
+#define dom_ipc_MemMapSnapshot_h
+
+#include "mozilla/Attributes.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/RangedPtr.h"
+#include "mozilla/Result.h"
+#include "base/shared_memory.h"
+#include "ErrorList.h"
+
+namespace mozilla {
+namespace loader {
+class AutoMemMap;
+}
+
+namespace ipc {
+
+/**
+ * A helper class for creating a read-only snapshot of memory-mapped data.
+ *
+ * The Init() method initializes a read-write memory mapped region of the given
+ * size, which can be initialized with arbitrary data. The Finalize() method
+ * remaps that region as read-only (and backs it with a read-only file
+ * descriptor), and initializes an AutoMemMap with the new contents.
+ *
+ * The file descriptor for the resulting AutoMemMap can be shared among
+ * processes, to safely access a shared, read-only copy of the data snapshot.
+ */
+class MOZ_RAII MemMapSnapshot {
+ public:
+  Result<Ok, nsresult> Init(size_t aSize);
+  Result<Ok, nsresult> Finalize(loader::AutoMemMap& aMap);
+
+  template <typename T>
+  RangedPtr<T> Get() {
+    MOZ_ASSERT(mInitialized);
+    return {static_cast<T*>(mMem.memory()), mMem.max_size() / sizeof(T)};
+  }
+
+ private:
+  base::SharedMemory mMem;
+  bool mInitialized = false;
+};
+
+}  // namespace ipc
+}  // namespace mozilla
+
+#endif  // dom_ipc_MemMapSnapshot_h
diff --git a/dom/ipc/MemoryReportRequest.cpp b/dom/ipc/MemoryReportRequest.cpp
new file mode 100644
index 0000000000..794351461d
--- /dev/null
+++ b/dom/ipc/MemoryReportRequest.cpp
@@ -0,0 +1,170 @@
+/* -*- 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 "nsMemoryReporterManager.h"
+#include "MemoryReportRequest.h"
+#include "mozilla/ipc/FileDescriptor.h"
+#include "mozilla/ipc/FileDescriptorUtils.h"
+
+using namespace mozilla::ipc;
+
+namespace mozilla::dom {
+
+MemoryReportRequestHost::MemoryReportRequestHost(uint32_t aGeneration)
+    : mGeneration(aGeneration), mSuccess(false) {
+  MOZ_COUNT_CTOR(MemoryReportRequestHost);
+  mReporterManager = nsMemoryReporterManager::GetOrCreate();
+  NS_WARNING_ASSERTION(mReporterManager, "GetOrCreate failed");
+}
+
+void MemoryReportRequestHost::RecvReport(const MemoryReport& aReport) {
+  // Skip reports from older generations. We need to do this here since we
+  // could receive older reports from a subprocesses before it acknowledges
+  // a new request, and we only track one active request per process.
+  if (aReport.generation() != mGeneration) {
+    return;
+  }
+
+  if (mReporterManager) {
+    mReporterManager->HandleChildReport(mGeneration, aReport);
+  }
+}
+
+void MemoryReportRequestHost::Finish(uint32_t aGeneration) {
+  // Skip reports from older generations. See the comment in RecvReport.
+  if (mGeneration != aGeneration) {
+    return;
+  }
+  mSuccess = true;
+}
+
+MemoryReportRequestHost::~MemoryReportRequestHost() {
+  MOZ_COUNT_DTOR(MemoryReportRequestHost);
+
+  if (mReporterManager) {
+    mReporterManager->EndProcessReport(mGeneration, mSuccess);
+    mReporterManager = nullptr;
+  }
+}
+
+NS_IMPL_ISUPPORTS(MemoryReportRequestClient, nsIRunnable)
+
+/* static */ void MemoryReportRequestClient::Start(
+    uint32_t aGeneration, bool aAnonymize, bool aMinimizeMemoryUsage,
+    const Maybe<FileDescriptor>& aDMDFile, const nsACString& aProcessString,
+    const ReportCallback& aReportCallback,
+    const FinishCallback& aFinishCallback) {
+  RefPtr<MemoryReportRequestClient> request = new MemoryReportRequestClient(
+      aGeneration, aAnonymize, aDMDFile, aProcessString, aReportCallback,
+      aFinishCallback);
+
+  DebugOnly<nsresult> rv;
+  if (aMinimizeMemoryUsage) {
+    nsCOMPtr<nsIMemoryReporterManager> mgr =
+        do_GetService("@mozilla.org/memory-reporter-manager;1");
+    rv = mgr->MinimizeMemoryUsage(request);
+    // mgr will eventually call actor->Run()
+  } else {
+    rv = request->Run();
+  }
+
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "actor operation failed");
+}
+
+MemoryReportRequestClient::MemoryReportRequestClient(
+    uint32_t aGeneration, bool aAnonymize,
+    const Maybe<FileDescriptor>& aDMDFile, const nsACString& aProcessString,
+    const ReportCallback& aReportCallback,
+    const FinishCallback& aFinishCallback)
+    : mGeneration(aGeneration),
+      mAnonymize(aAnonymize),
+      mProcessString(aProcessString),
+      mReportCallback(aReportCallback),
+      mFinishCallback(aFinishCallback) {
+  if (aDMDFile.isSome()) {
+    mDMDFile = aDMDFile.value();
+  }
+}
+
+MemoryReportRequestClient::~MemoryReportRequestClient() = default;
+
+class HandleReportCallback final : public nsIHandleReportCallback {
+ public:
+  using ReportCallback = typename MemoryReportRequestClient::ReportCallback;
+
+  NS_DECL_ISUPPORTS
+
+  explicit HandleReportCallback(uint32_t aGeneration,
+                                const nsACString& aProcess,
+                                const ReportCallback& aReportCallback)
+      : mGeneration(aGeneration),
+        mProcess(aProcess),
+        mReportCallback(aReportCallback) {}
+
+  NS_IMETHOD Callback(const nsACString& aProcess, const nsACString& aPath,
+                      int32_t aKind, int32_t aUnits, int64_t aAmount,
+                      const nsACString& aDescription,
+                      nsISupports* aUnused) override {
+    MemoryReport memreport(mProcess, nsCString(aPath), aKind, aUnits, aAmount,
+                           mGeneration, nsCString(aDescription));
+    mReportCallback(memreport);
+    return NS_OK;
+  }
+
+ private:
+  ~HandleReportCallback() = default;
+
+  uint32_t mGeneration;
+  const nsCString mProcess;
+  ReportCallback mReportCallback;
+};
+
+NS_IMPL_ISUPPORTS(HandleReportCallback, nsIHandleReportCallback)
+
+class FinishReportingCallback final : public nsIFinishReportingCallback {
+ public:
+  using FinishCallback = typename MemoryReportRequestClient::FinishCallback;
+
+  NS_DECL_ISUPPORTS
+
+  explicit FinishReportingCallback(uint32_t aGeneration,
+                                   const FinishCallback& aFinishCallback)
+      : mGeneration(aGeneration), mFinishCallback(aFinishCallback) {}
+
+  NS_IMETHOD Callback(nsISupports* aUnused) override {
+    mFinishCallback(mGeneration);
+    return NS_OK;
+  }
+
+ private:
+  ~FinishReportingCallback() = default;
+
+  uint32_t mGeneration;
+  FinishCallback mFinishCallback;
+};
+
+NS_IMPL_ISUPPORTS(FinishReportingCallback, nsIFinishReportingCallback)
+
+NS_IMETHODIMP MemoryReportRequestClient::Run() {
+  nsCOMPtr<nsIMemoryReporterManager> mgr =
+      do_GetService("@mozilla.org/memory-reporter-manager;1");
+
+  // Run the reporters.  The callback will turn each measurement into a
+  // MemoryReport.
+  RefPtr<HandleReportCallback> handleReport =
+      new HandleReportCallback(mGeneration, mProcessString, mReportCallback);
+  RefPtr<FinishReportingCallback> finishReporting =
+      new FinishReportingCallback(mGeneration, mFinishCallback);
+
+  nsresult rv = mgr->GetReportsForThisProcessExtended(
+      handleReport, nullptr, mAnonymize, FileDescriptorToFILE(mDMDFile, "wb"),
+      finishReporting, nullptr);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "GetReportsForThisProcessExtended failed");
+  return rv;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/MemoryReportRequest.h b/dom/ipc/MemoryReportRequest.h
new file mode 100644
index 0000000000..1e81a39bf6
--- /dev/null
+++ b/dom/ipc/MemoryReportRequest.h
@@ -0,0 +1,73 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_MemoryReportRequest_h_
+#define mozilla_dom_MemoryReportRequest_h_
+
+#include "mozilla/dom/MemoryReportTypes.h"
+#include "mozilla/ipc/FileDescriptor.h"
+#include "nsISupports.h"
+
+#include <functional>
+
+class nsMemoryReporterManager;
+
+namespace mozilla::dom {
+
+class MemoryReport;
+
+class MemoryReportRequestHost final {
+ public:
+  explicit MemoryReportRequestHost(uint32_t aGeneration);
+  ~MemoryReportRequestHost();
+
+  void RecvReport(const MemoryReport& aReport);
+  void Finish(uint32_t aGeneration);
+
+ private:
+  const uint32_t mGeneration;
+  // Non-null if we haven't yet called EndProcessReport() on it.
+  RefPtr<nsMemoryReporterManager> mReporterManager;
+  bool mSuccess;
+};
+
+class MemoryReportRequestClient final : public nsIRunnable {
+ public:
+  using ReportCallback = std::function<void(const MemoryReport&)>;
+  using FinishCallback = std::function<void(const uint32_t&)>;
+
+  NS_DECL_ISUPPORTS
+
+  static void Start(uint32_t aGeneration, bool aAnonymize,
+                    bool aMinimizeMemoryUsage,
+                    const Maybe<mozilla::ipc::FileDescriptor>& aDMDFile,
+                    const nsACString& aProcessString,
+                    const ReportCallback& aReportCallback,
+                    const FinishCallback& aFinishCallback);
+
+  NS_IMETHOD Run() override;
+
+ private:
+  MemoryReportRequestClient(uint32_t aGeneration, bool aAnonymize,
+                            const Maybe<mozilla::ipc::FileDescriptor>& aDMDFile,
+                            const nsACString& aProcessString,
+                            const ReportCallback& aReportCallback,
+                            const FinishCallback& aFinishCallback);
+
+ private:
+  ~MemoryReportRequestClient();
+
+  uint32_t mGeneration;
+  bool mAnonymize;
+  mozilla::ipc::FileDescriptor mDMDFile;
+  nsCString mProcessString;
+  ReportCallback mReportCallback;
+  FinishCallback mFinishCallback;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_MemoryReportRequest_h_
diff --git a/dom/ipc/MemoryReportTypes.ipdlh b/dom/ipc/MemoryReportTypes.ipdlh
new file mode 100644
index 0000000000..fb52e575f2
--- /dev/null
+++ b/dom/ipc/MemoryReportTypes.ipdlh
@@ -0,0 +1,22 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+using struct mozilla::void_t from "mozilla/ipc/IPCCore.h";
+
+namespace mozilla {
+namespace dom {
+
+struct MemoryReport {
+  nsCString process;
+  nsCString path;
+  int32_t kind;
+  int32_t units;
+  int64_t amount;
+  uint32_t generation;
+  nsCString desc;
+};
+
+}
+}
diff --git a/dom/ipc/NativeThreadId.h b/dom/ipc/NativeThreadId.h
new file mode 100644
index 0000000000..9193aefde1
--- /dev/null
+++ b/dom/ipc/NativeThreadId.h
@@ -0,0 +1,16 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_NativeThreadId_h
+#define mozilla_dom_NativeThreadId_h
+
+#include "nsExceptionHandler.h"
+
+namespace mozilla::dom {
+typedef CrashReporter::ThreadId NativeThreadId;
+}
+
+#endif
diff --git a/dom/ipc/PBrowser.ipdl b/dom/ipc/PBrowser.ipdl
new file mode 100644
index 0000000000..a120f7b38e
--- /dev/null
+++ b/dom/ipc/PBrowser.ipdl
@@ -0,0 +1,1024 @@
+/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=2 ts=8 et tw=80 ft=cpp : */
+
+/* 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 protocol PColorPicker;
+include protocol PContent;
+#ifdef ACCESSIBILITY
+include protocol PDocAccessible;
+#endif
+include protocol PFilePicker;
+include protocol PRemotePrintJob;
+include protocol PPaymentRequest;
+include protocol PSessionStore;
+include protocol PWindowGlobal;
+include protocol PBrowserBridge;
+include protocol PVsync;
+
+include DOMTypes;
+include NeckoChannelParams;
+include WindowGlobalTypes;
+include IPCBlob;
+include IPCStream;
+include IPCTransferable;
+include URIParams;
+include PPrintingTypes;
+include PTabContext;
+include PBackgroundSharedTypes;
+
+include "mozilla/AntiTrackingIPCUtils.h";
+include "mozilla/dom/BindingIPCUtils.h";
+include "mozilla/dom/CSPMessageUtils.h";
+include "mozilla/dom/DocShellMessageUtils.h";
+include "mozilla/dom/FilePickerMessageUtils.h";
+include "mozilla/dom/PermissionMessageUtils.h";
+include "mozilla/dom/ReferrerInfoUtils.h";
+include "mozilla/dom/TabMessageUtils.h";
+include "mozilla/GfxMessageUtils.h";
+include "mozilla/LayoutMessageUtils.h";
+include "mozilla/layers/LayersMessageUtils.h";
+include "mozilla/ipc/TransportSecurityInfoUtils.h";
+include "mozilla/ipc/URIUtils.h";
+
+using struct nsID from "nsID.h";
+using mozilla::gfx::Matrix4x4 from "mozilla/gfx/Matrix.h";
+using mozilla::gfx::SurfaceFormat from "mozilla/gfx/Types.h";
+using mozilla::LayoutDeviceIntPoint from "Units.h";
+using mozilla::LayoutDevicePoint from "Units.h";
+using mozilla::ScreenIntCoord from "Units.h";
+using mozilla::ScreenIntMargin from "Units.h";
+using mozilla::ScreenIntPoint from "Units.h";
+using mozilla::ScreenRect from "Units.h";
+using struct mozilla::layers::ScrollableLayerGuid from "mozilla/layers/ScrollableLayerGuid.h";
+using struct mozilla::layers::ZoomConstraints from "mozilla/layers/ZoomConstraints.h";
+using mozilla::layers::LayersId from "mozilla/layers/LayersTypes.h";
+using mozilla::layers::LayersObserverEpoch from "mozilla/layers/LayersTypes.h";
+using mozilla::layers::GeckoContentController_TapType from "mozilla/layers/GeckoContentControllerTypes.h";
+using mozilla::layers::ScrollableLayerGuid::ViewID from "mozilla/layers/ScrollableLayerGuid.h";
+using struct mozilla::void_t from "mozilla/ipc/IPCCore.h";
+using mozilla::WindowsHandle from "mozilla/ipc/IPCTypes.h";
+using class mozilla::WidgetCompositionEvent from "ipc/nsGUIEventIPC.h";
+using struct mozilla::widget::IMENotification from "mozilla/widget/IMEData.h";
+using struct mozilla::widget::IMENotificationRequests from "mozilla/widget/IMEData.h";
+using struct mozilla::widget::IMEState from "mozilla/widget/IMEData.h";
+using struct mozilla::widget::InputContext from "mozilla/widget/IMEData.h";
+using struct mozilla::widget::InputContextAction from "mozilla/widget/IMEData.h";
+using mozilla::gfx::IntSize from "mozilla/gfx/Point.h";
+using mozilla::gfx::IntPoint from "mozilla/gfx/Point.h";
+using class mozilla::ContentCache from "ipc/nsGUIEventIPC.h";
+using class mozilla::WidgetKeyboardEvent from "ipc/nsGUIEventIPC.h";
+using class mozilla::WidgetMouseEvent from "ipc/nsGUIEventIPC.h";
+using class mozilla::WidgetWheelEvent from "ipc/nsGUIEventIPC.h";
+using class mozilla::WidgetDragEvent from "ipc/nsGUIEventIPC.h";
+using struct nsRect from "nsRect.h";
+using class mozilla::WidgetSelectionEvent from "ipc/nsGUIEventIPC.h";
+using class mozilla::WidgetTouchEvent from "ipc/nsGUIEventIPC.h";
+using struct mozilla::dom::RemoteDOMEvent from "mozilla/dom/TabMessageTypes.h";
+using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h";
+using mozilla::layers::CompositorOptions from "mozilla/layers/CompositorOptions.h";
+using mozilla::CSSToScreenScale from "Units.h";
+using mozilla::CommandInt from "mozilla/EventForwards.h";
+using nsIWidget::TouchPointerState from "nsIWidget.h";
+using nsIWidget::TouchpadGesturePhase from "nsIWidget.h";
+using nsCursor from "nsIWidget.h";
+using struct LookAndFeelInt from "mozilla/widget/WidgetMessageUtils.h";
+using struct mozilla::DimensionRequest from "mozilla/widget/WidgetMessageUtils.h";
+using class mozilla::dom::MessagePort from "mozilla/dom/MessagePort.h";
+using class mozilla::dom::ipc::StructuredCloneData from "mozilla/dom/ipc/StructuredCloneData.h";
+using mozilla::dom::MaybeDiscardedWindowContext from "mozilla/dom/WindowContext.h";
+using mozilla::EventMessage from "mozilla/EventForwards.h";
+using nsEventStatus from "mozilla/EventForwards.h";
+using mozilla::Modifiers from "mozilla/EventForwards.h";
+using struct mozilla::widget::CandidateWindowPosition from "ipc/nsGUIEventIPC.h";
+using struct mozilla::FontRange from "ipc/nsGUIEventIPC.h";
+using mozilla::OriginAttributes from "mozilla/ipc/BackgroundUtils.h";
+using mozilla::dom::EffectsInfo from "mozilla/dom/EffectsInfo.h";
+using mozilla::dom::TabId from "mozilla/dom/ipc/IdType.h";
+using mozilla::ScrollAxis from "mozilla/PresShellForwards.h";
+using mozilla::ScrollFlags from "mozilla/PresShellForwards.h";
+using struct InputFormData from "mozilla/dom/SessionStoreMessageUtils.h";
+using struct CollectedInputDataValue from "mozilla/dom/SessionStoreMessageUtils.h";
+using mozilla::ContentBlockingNotifier::StorageAccessPermissionGrantedReason from "mozilla/ContentBlockingNotifier.h";
+using mozilla::dom::CallerType from "mozilla/dom/BindingDeclarations.h";
+using mozilla::dom::EmbedderElementEventType from "mozilla/dom/TabMessageTypes.h";
+using mozilla::IntrinsicSize from "nsIFrame.h";
+using mozilla::AspectRatio from "mozilla/AspectRatio.h";
+using mozilla::NativeKeyBindingsType from "mozilla/NativeKeyBindingsType.h";
+using mozilla::StyleImageRendering from "mozilla/ServoStyleConsts.h";
+[MoveOnly] using class mozilla::ipc::BigBuffer from "mozilla/ipc/BigBuffer.h";
+using nsIFilePicker::Mode from "nsIFilePicker.h";
+
+namespace mozilla {
+namespace dom {
+
+struct WebProgressData
+{
+  MaybeDiscardedBrowsingContext browsingContext;
+  uint32_t loadType;
+};
+
+struct RequestData
+{
+  nullable nsIURI requestURI;
+  nullable nsIURI originalRequestURI;
+  nsCString matchedList;
+};
+
+struct WebProgressStateChangeData
+{
+  bool isNavigating;
+  bool mayEnableCharacterEncodingMenu;
+
+  // The following fields are only set when the aStateFlags param passed with
+  // this struct is |nsIWebProgress.STATE_STOP|.
+  nsString contentType;
+  nsString charset;
+  nullable nsIURI documentURI;
+};
+
+struct WebProgressLocationChangeData
+{
+  bool isNavigating;
+  bool isSyntheticDocument;
+  bool mayEnableCharacterEncodingMenu;
+  nsString contentType;
+  nsString title;
+  nsString charset;
+  nullable nsIURI documentURI;
+  nullable nsIPrincipal contentPrincipal;
+  nullable nsIPrincipal contentPartitionedPrincipal;
+  nullable nsIContentSecurityPolicy csp;
+  nullable nsIReferrerInfo referrerInfo;
+  uint64_t? requestContextID;
+};
+
+/**
+ * If creating the print preview document or updating it with new print
+ * settings fails, sheetCount will be zero.
+ */
+struct PrintPreviewResultInfo
+{
+  uint32_t sheetCount;
+  uint32_t totalPageCount;
+  bool isEmpty;
+  // Whether there's a selection in the previewed page, including its subframes.
+  bool hasSelection;
+  // Whether there's a selection in the previewed page, excluding its subframes.
+  bool hasSelfSelection;
+  // If present, indicates if the page should be printed landscape when true or
+  // portrait when false;
+  bool? printLandscape;
+  // The at-page specified page width or null when no width is provided.
+  float? pageWidth;
+  // The at-page specified page height or null when no height is provided.
+  float? pageHeight;
+};
+
+/**
+ * A PBrowser manages a maximal locally connected subtree of BrowsingContexts
+ * in a content process.
+ *
+ * See `dom/docs/Fission-IPC-Diagram.svg` for an overview of the DOM IPC
+ * actors.
+ */
+[NestedUpTo=inside_cpow] sync protocol PBrowser
+{
+    manager PContent;
+
+    manages PColorPicker;
+
+#ifdef ACCESSIBILITY
+    manages PDocAccessible;
+#endif
+
+    manages PFilePicker;
+    manages PPaymentRequest;
+    manages PSessionStore;
+    manages PWindowGlobal;
+    manages PBrowserBridge;
+    manages PVsync;
+
+both:
+    async AsyncMessage(nsString aMessage, ClonedMessageData aData);
+
+parent:
+#ifdef ACCESSIBILITY
+    /**
+     * Tell the parent process a new accessible document has been created.
+     * aParentDoc is the accessible document it was created in if any, and
+     * aParentAcc is the id of the accessible in that document the new document
+     * is a child of.
+     */
+    async PDocAccessible(nullable PDocAccessible aParentDoc, uint64_t aParentAcc,
+                         MaybeDiscardedBrowsingContext aBrowsingContext);
+#endif
+
+    async PPaymentRequest();
+
+    /**
+     * Create a new Vsync connection for our associated root widget
+     */
+    async PVsync();
+
+    /**
+     * When the child process unsuppresses painting, we send the message for the
+     * parent process to start painting the new document, if it's still painting
+     * the old one.
+     */
+    [Priority=control] async DidUnsuppressPainting();
+
+    async DidUnsuppressPaintingNormalPriority();
+
+    /**
+     * When child sends this message, parent should move focus to
+     * the next or previous focusable element or document.
+     */
+    async MoveFocus(bool forward, bool forDocumentNavigation);
+
+    /**
+     * Called by the child to inform the parent that links are dropped into
+     * content area.
+     *
+     * aLinks A flat array of url, name, and type for each link
+     */
+    async DropLinks(nsString[] aLinks);
+
+    sync SyncMessage(nsString aMessage, ClonedMessageData aData)
+      returns (StructuredCloneData[] retval);
+
+    /**
+     * Notifies chrome that there is a focus change involving an editable
+     * object (input, textarea, document, contentEditable. etc.)
+     *
+     *  contentCache Cache of content
+     *  notification Whole data of the notification
+     *  requests     Requests of notification for IME of the native widget
+     */
+    [Nested=inside_cpow] async NotifyIMEFocus(ContentCache contentCache,
+                                              IMENotification notification)
+      returns (IMENotificationRequests requests);
+
+    /**
+     * Notifies chrome that there has been a change in text content
+     * One call can encompass both a delete and an insert operation
+     * Only called when NotifyIMEFocus returns PR_TRUE for mWantUpdates
+     *
+     *  contentCache Cache of content
+     *  notification Whole data of the notification
+     */
+    [Nested=inside_cpow] async NotifyIMETextChange(ContentCache contentCache,
+                                                   IMENotification notification);
+
+    /**
+     * Notifies chrome that there is a IME compostion rect updated
+     *
+     *  contentCache Cache of content
+     */
+    [Nested=inside_cpow] async NotifyIMECompositionUpdate(ContentCache contentCache,
+                                                          IMENotification notification);
+
+    /**
+     * Notifies chrome that there has been a change in selection
+     * Only called when NotifyIMEFocus returns PR_TRUE for mWantUpdates
+     *
+     *  contentCache Cache of content
+     *  notification Whole data of the notification
+     */
+    [Nested=inside_cpow] async NotifyIMESelection(ContentCache contentCache,
+                                                  IMENotification notification);
+
+    /**
+     * Notifies chrome of updating its content cache.
+     * This is useful if content is modified but we don't need to notify IME.
+     *
+     *  contentCache Cache of content
+     */
+    [Nested=inside_cpow] async UpdateContentCache(ContentCache contentCache);
+
+    /**
+     * Notifies IME of mouse button event on a character in focused editor.
+     *
+     * Returns true if the mouse button event is consumed by IME.
+     */
+    [Nested=inside_cpow] sync NotifyIMEMouseButtonEvent(IMENotification notification)
+      returns (bool consumedByIME);
+
+    /**
+     * Notifies chrome to position change
+     *
+     *  contentCache Cache of content
+     */
+    [Nested=inside_cpow] async NotifyIMEPositionChange(ContentCache contentCache,
+                                                       IMENotification notification);
+
+    /**
+     * Requests chrome to commit or cancel composition of IME.
+     *
+     *  cancel                Set true if composition should be cancelled.
+     *
+     *  isCommitted           Returns true if the request causes composition
+     *                        being committed synchronously.
+     *  committedString       Returns committed string.  The may be non-empty
+     *                        string even if cancel is true because IME may
+     *                        try to restore selected string which was
+     *                        replaced with the composition.
+     */
+    [Nested=inside_cpow] sync RequestIMEToCommitComposition(bool cancel)
+      returns (bool isCommitted, nsString committedString);
+
+    /**
+     * OnEventNeedingAckHandled() is called after a child process dispatches a
+     * composition event or a selection event which is sent from the parent
+     * process.
+     *
+     * message      The message value of the handled event.
+     */
+    [Nested=inside_cpow] async OnEventNeedingAckHandled(EventMessage message);
+
+    /**
+     * Request that the parent process move focus to the browser's frame. If
+     * canRaise is true, the window can be raised if it is inactive.
+     */
+    async RequestFocus(bool canRaise, CallerType aCallerType);
+
+    /**
+     * Sends a mouse wheel zoom change to the parent process, to be handled by
+     * the front end as needed.
+     */
+    async WheelZoomChange(bool increase);
+
+    /**
+     * Indicate, based on the current state, that some commands are enabled and
+     * some are disabled.
+     */
+    async EnableDisableCommands(MaybeDiscardedBrowsingContext bc,
+                                nsString action,
+                                nsCString[] enabledCommands,
+                                nsCString[] disabledCommands);
+
+    [Nested=inside_cpow] sync GetInputContext() returns (IMEState state);
+
+    [Nested=inside_cpow] async SetInputContext(InputContext context,
+                                               InputContextAction action);
+
+    /**
+     * Set the native cursor.
+     * @param value
+     *   The widget cursor to set.
+     * @param hasCustomCursor
+     *   Whether there's any custom cursor represented by cursorData and
+     *   company.
+     * @param customCursorData
+     *   Serialized image data.
+     * @param width
+     *   Width of the image.
+     * @param height
+     *   Height of the image.
+     * @param resolutionX
+     *   Resolution of the image X axis in dppx units.
+     * @param resolutionY
+     *   Resolution of the image Y axis in dppx units.
+     * @param stride
+     *   Stride used in the image data.
+     * @param format
+     *   Image format, see gfx::SurfaceFormat for possible values.
+     * @param hotspotX
+     *   Horizontal hotspot of the image, as specified by the css cursor property.
+     * @param hotspotY
+     *   Vertical hotspot of the image, as specified by the css cursor property.
+     * @param force
+     *   Invalidate any locally cached cursor settings and force an
+     *   update.
+     */
+    async SetCursor(nsCursor value,
+                    bool hasCustomCursor,
+                    BigBuffer? customCursorData,
+                    uint32_t width, uint32_t height,
+                    float resolutionX, float resolutionY,
+                    uint32_t stride, SurfaceFormat format,
+                    uint32_t hotspotX, uint32_t hotspotY, bool force);
+
+    /**
+     * Used to set the current text of the status tooltip.
+     * Nowadays this is only used for link locations on hover.
+     */
+    async SetLinkStatus(nsString status);
+
+    /**
+     * Show/hide a tooltip when the mouse hovers over an element in the content
+     * document.
+     */
+    async ShowTooltip(uint32_t x, uint32_t y, nsString tooltip, nsString direction);
+    async HideTooltip();
+
+    /**
+     * Create an asynchronous color picker on the parent side,
+     * but don't open it yet.
+     */
+    async PColorPicker(nsString title, nsString initialColor, nsString[] defaultColors);
+
+    async PFilePicker(nsString aTitle, Mode aMode);
+
+    /**
+     * Tells the containing widget whether the given input block results in a
+     * swipe. Should be called in response to a WidgetWheelEvent that has
+     * mFlags.mCanTriggerSwipe set on it.
+     */
+    async RespondStartSwipeEvent(uint64_t aInputBlockId, bool aStartSwipe);
+
+    /**
+     * Look up dictionary by selected word for OSX
+     *
+     * @param aText       The word to look up
+     * @param aFontRange  Text decoration of aText
+     * @param aIsVertical true if vertical layout
+     */
+    async LookUpDictionary(nsString aText, FontRange[] aFontRangeArray,
+                           bool aIsVertical, LayoutDeviceIntPoint aPoint);
+
+    async __delete__();
+
+    /**
+     * Send a reply of keyboard event to the parent.  Then, parent can consider
+     * whether the event should kick a shortcut key or ignore.
+     *
+     * @param aEvent    The event which was sent from the parent and handled
+     *                  in a remote process.
+     * @param aUUI      The UUID which was generated when aEvent was sent to
+     *                  a remote process.
+     */
+    async ReplyKeyEvent(WidgetKeyboardEvent aEvent, nsID aUUID);
+
+    /**
+     * Retrieves edit commands for the key combination represented by aEvent.
+     *
+     * @param aType       One of NativeKeyBindingsType.
+     * @param aEvent      KeyboardEvent which represents a key combination.
+     *                    Note that this must be a trusted event.
+     * @return            Array of edit commands which should be executed in
+     *                    editor of native applications.
+     */
+    sync RequestNativeKeyBindings(uint32_t aType, WidgetKeyboardEvent aEvent)
+        returns (CommandInt[] commands);
+
+    async SynthesizeNativeKeyEvent(int32_t aNativeKeyboardLayout,
+                                   int32_t aNativeKeyCode,
+                                   uint32_t aModifierFlags,
+                                   nsString aCharacters,
+                                   nsString aUnmodifiedCharacters,
+                                   uint64_t aObserverId);
+    async SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint,
+                                     uint32_t aNativeMessage,
+                                     int16_t aButton,
+                                     uint32_t aModifierFlags,
+                                     uint64_t aObserverId);
+    async SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint,
+                                    uint64_t aObserverId);
+    async SynthesizeNativeMouseScrollEvent(LayoutDeviceIntPoint aPoint,
+                                           uint32_t aNativeMessage,
+                                           double aDeltaX,
+                                           double aDeltaY,
+                                           double aDeltaZ,
+                                           uint32_t aModifierFlags,
+                                           uint32_t aAdditionalFlags,
+                                           uint64_t aObserverId);
+    async SynthesizeNativeTouchPoint(uint32_t aPointerId,
+                                     TouchPointerState aPointerState,
+                                     LayoutDeviceIntPoint aPoint,
+                                     double aPointerPressure,
+                                     uint32_t aPointerOrientation,
+                                     uint64_t aObserverId);
+    async SynthesizeNativeTouchPadPinch(TouchpadGesturePhase aEventPhase,
+                                        float aScale,
+                                        LayoutDeviceIntPoint aPoint,
+                                        int32_t aModifierFlags);
+    async SynthesizeNativeTouchTap(LayoutDeviceIntPoint aPoint,
+                                   bool aLongTap,
+                                   uint64_t aObserverId);
+    async ClearNativeTouchSequence(uint64_t aObserverId);
+    async SynthesizeNativePenInput(uint32_t aPointerId,
+                                   TouchPointerState aPointerState,
+                                   LayoutDeviceIntPoint aPoint,
+                                   double aPressure,
+                                   uint32_t aRotation,
+                                   int32_t aTiltX,
+                                   int32_t aTiltY,
+                                   int32_t aButton,
+                                   uint64_t aObserverId);
+    async SynthesizeNativeTouchpadDoubleTap(LayoutDeviceIntPoint aPoint,
+                                            uint32_t aModifierFlags);
+    async SynthesizeNativeTouchpadPan(TouchpadGesturePhase aEventPhase,
+                                      LayoutDeviceIntPoint aPoint,
+                                      double aDeltaX, double aDeltaY,
+                                      int32_t aModifierFlags,
+                                      uint64_t aObserverId);
+
+    async LockNativePointer();
+    async UnlockNativePointer();
+
+    async AccessKeyNotHandled(WidgetKeyboardEvent event);
+
+    async RegisterProtocolHandler(nsString scheme, nullable nsIURI handlerURI, nsString title,
+                                  nullable nsIURI documentURI);
+
+    async OnStateChange(WebProgressData aWebProgressData,
+                        RequestData aRequestData, uint32_t aStateFlags,
+                        nsresult aStatus,
+                        WebProgressStateChangeData? aStateChangeData);
+
+    async OnLocationChange(WebProgressData aWebProgressData,
+                           RequestData aRequestData, nullable nsIURI aLocation,
+                           uint32_t aFlags, bool aCanGoBack,
+                           bool aCanGoForward,
+                           WebProgressLocationChangeData? aLocationChangeData);
+
+    // We only track information about total progress in the parent process.
+    // This value is throttled using nsBrowserStatusFilter, and records the full
+    // total progress for nsDocShells managed by this actor.
+    async OnProgressChange(int32_t aCurTotalProgress, int32_t aMaxTotalProgress);
+
+    // Calls to OnStatusChange are throttled by nsBrowserStatusFilter, meaning
+    // they are only called with a status of `NS_OK`, and with no webProgress or
+    // request.
+    async OnStatusChange(nsString aMessage);
+
+    async NotifyContentBlockingEvent(uint32_t aEvent, RequestData aRequestData,
+                                     bool aBlocked, nsCString aTrackingOrigin,
+                                     nsCString[] aTrackingFullHashes,
+                                     StorageAccessPermissionGrantedReason? aReason);
+
+    async NavigationFinished();
+
+    async IntrinsicSizeOrRatioChanged(IntrinsicSize? aIntrinsicSize,
+                                      AspectRatio? aIntrinsicRatio);
+
+    async ImageLoadComplete(nsresult aResult);
+
+    /**
+     * Child informs the parent that a pointer lock has requested/released.
+     */
+    async RequestPointerLock() returns (nsCString error);
+    async ReleasePointerLock();
+
+    /**
+     * Child informs the parent that a pointer capture has requested/released.
+     */
+    async RequestPointerCapture(uint32_t aPointerId) returns (bool aSuccess);
+    async ReleasePointerCapture(uint32_t aPointerId);
+
+child:
+    async NativeSynthesisResponse(uint64_t aObserverId, nsCString aResponse);
+    async UpdateSHistory();
+    async CloneDocumentTreeIntoSelf(MaybeDiscardedBrowsingContext aBc, PrintData aPrintData) returns(bool aSuccess);
+    async UpdateRemotePrintSettings(PrintData aPrintData);
+
+    /**
+     * Parent informs the child to release all pointer capture.
+     */
+    [Priority=input] async ReleaseAllPointerCapture();
+
+parent:
+
+    /**
+     * Child informs the parent that the content is ready to handle input
+     * events. This is sent when the BrowserChild is created.
+     */
+    async RemoteIsReadyToHandleInputEvents();
+
+    /**
+     * Child informs the parent that the layer tree is already available.
+     */
+    async PaintWhileInterruptingJSNoOp(LayersObserverEpoch aEpoch);
+
+child:
+    /**
+     * Parent informs the child of graphical effects that are being applied
+     * to the child browser.
+     */
+    async UpdateEffects(EffectsInfo aEffects);
+
+parent:
+
+    /**
+     * Sent by the child to the parent to inform it that an update to the
+     * dimensions has been requested.
+     *
+     * @param aRequest  The requested change of inner or outer dimensions.
+     * @param aScale    The scale at the time of the request. This is to allow
+     *                  the parent to recompute the dimensions in case of an
+     *                  ongoing scale change.
+     */
+    async SetDimensions(DimensionRequest aRequest, double aScale);
+
+    [Nested=inside_sync] sync DispatchWheelEvent(WidgetWheelEvent event);
+    [Nested=inside_sync] sync DispatchMouseEvent(WidgetMouseEvent event);
+    [Nested=inside_sync] sync DispatchKeyboardEvent(WidgetKeyboardEvent event);
+    [Nested=inside_sync] sync DispatchTouchEvent(WidgetTouchEvent event);
+
+    async InvokeDragSession(IPCTransferableData[] transfers, uint32_t action,
+                            BigBuffer? visualData,
+                            uint32_t stride, SurfaceFormat format,
+                            LayoutDeviceIntRect dragRect,
+                            nullable nsIPrincipal principal,
+                            nullable nsIContentSecurityPolicy csp,
+                            CookieJarSettingsArgs cookieJarSettings,
+                            MaybeDiscardedWindowContext sourceWindowContext,
+                            MaybeDiscardedWindowContext sourceTopWindowContext);
+
+    // After a compositor reset, it is necessary to reconnect each layers ID to
+    // the compositor of the widget that will render those layers. Note that
+    // this is sync so we can ensure that messages to the window compositor
+    // arrive before the BrowserChild attempts to use its cross-process compositor
+    // bridge.
+    sync EnsureLayersConnected() returns (CompositorOptions compositorOptions);
+
+    /**
+     * This function is used to notify the parent that it should display a
+     * canvas permission prompt.
+     *
+     * @param aOrigin origin string of the document that is requesting access.
+     */
+    async ShowCanvasPermissionPrompt(nsCString aOrigin,
+                                     bool aHideDoorHanger);
+
+    sync SetSystemFont(nsCString aFontName);
+    sync GetSystemFont() returns (nsCString retval);
+
+    /**
+     * Called once this PBrowser's OOP subdoc no longer blocks its
+     * embedding element's and embedding doc's 'load' events.
+     */
+    async MaybeFireEmbedderLoadEvents(EmbedderElementEventType aFireEventAtEmbeddingElement);
+
+    async ScrollRectIntoView(nsRect aRect, ScrollAxis aVertical,
+                             ScrollAxis aHorizontal, ScrollFlags aScrollFlags,
+                             int32_t aAppUnitsPerDevPixel);
+
+    async ShowDynamicToolbar();
+
+child:
+    /**
+     * Notify the remote browser that it has been Show()n on this side. This
+     * message is expected to trigger creation of the remote browser's "widget".
+     */
+    async Show(ParentShowInfo parentInfo, OwnerShowInfo childInfo);
+
+    /**
+     * Sending an activate message moves focus to the child.
+     */
+    async Activate(uint64_t aActionId);
+
+    async Deactivate(uint64_t aActionId);
+
+    async ScrollbarPreferenceChanged(ScrollbarPreference pref);
+
+    async InitRendering(TextureFactoryIdentifier textureFactoryIdentifier,
+                        LayersId layersId,
+                        CompositorOptions compositorOptions,
+                        bool layersConnected);
+
+    async CompositorOptionsChanged(CompositorOptions newOptions);
+
+    async LoadURL(nsDocShellLoadState loadState, ParentShowInfo info);
+
+    async CreateAboutBlankContentViewer(nullable nsIPrincipal principal,
+                                        nullable nsIPrincipal partitionedPrincipal);
+
+    async ResumeLoad(uint64_t pendingSwitchID, ParentShowInfo info);
+
+    [Compress=all] async UpdateDimensions(DimensionInfo dimensions);
+
+    async SizeModeChanged(nsSizeMode sizeMode);
+
+    async ChildToParentMatrix(Matrix4x4? aMatrix,
+                              ScreenRect aRemoteDocumentRect);
+
+    async UpdateRemoteStyle(StyleImageRendering aImageRendering);
+
+    async DynamicToolbarMaxHeightChanged(ScreenIntCoord height);
+
+    async DynamicToolbarOffsetChanged(ScreenIntCoord height);
+
+    /**
+     * StopIMEStateManagement() is called when the process loses focus and
+     * should stop managing IME state.
+     */
+    async StopIMEStateManagement();
+
+    /**
+     * When two consecutive mouse move events would be added to the message queue,
+     * they are 'compressed' by dumping the oldest one.
+     */
+    [Compress, Priority=input]
+    async RealMouseMoveEvent(WidgetMouseEvent event,
+                             ScrollableLayerGuid aGuid,
+                             uint64_t aInputBlockId);
+    [Compress]
+    async NormalPriorityRealMouseMoveEvent(WidgetMouseEvent event,
+                                           ScrollableLayerGuid aGuid,
+                                           uint64_t aInputBlockId);
+
+    /**
+     * But don't compress mousemove events for tests since every event is
+     * important for the test since synthesizing various input events may
+     * be faster than what the user operates same things.  If you need to
+     * test the `Compress`, send mouse move events with setting `isSyntehsized`
+     * of `aEvent` of `EventUtils#syntehsizeMouse*()`.
+     */
+    [Priority=input]
+    async RealMouseMoveEventForTests(WidgetMouseEvent event,
+                                     ScrollableLayerGuid aGuid,
+                                     uint64_t aInputBlockId);
+    async NormalPriorityRealMouseMoveEventForTests(WidgetMouseEvent event,
+                                                   ScrollableLayerGuid aGuid,
+                                                   uint64_t aInputBlockId);
+
+    /**
+     * Mouse move events with |reason == eSynthesized| are sent via a separate
+     * message because they do not generate DOM 'mousemove' events, and the
+     * 'Compress' attribute on RealMouseMoveEvent() could result in a
+     * |reason == eReal| event being dropped in favour of an |eSynthesized|
+     * event, and thus a DOM 'mousemove' event to be lost.
+     */
+    [Priority=input]
+    async SynthMouseMoveEvent(WidgetMouseEvent event,
+                              ScrollableLayerGuid aGuid,
+                              uint64_t aInputBlockId);
+    async NormalPrioritySynthMouseMoveEvent(WidgetMouseEvent event,
+                                            ScrollableLayerGuid aGuid,
+                                            uint64_t aInputBlockId);
+
+    [Priority=input]
+    async RealMouseButtonEvent(WidgetMouseEvent event,
+                               ScrollableLayerGuid aGuid,
+                               uint64_t aInputBlockId);
+    async NormalPriorityRealMouseButtonEvent(WidgetMouseEvent event,
+                                             ScrollableLayerGuid aGuid,
+                                             uint64_t aInputBlockId);
+
+    [Priority=input]
+    async RealMouseEnterExitWidgetEvent(WidgetMouseEvent event,
+                                                    ScrollableLayerGuid aGuid,
+                                                    uint64_t aInputBlockId);
+    async NormalPriorityRealMouseEnterExitWidgetEvent(WidgetMouseEvent event,
+                                                      ScrollableLayerGuid aGuid,
+                                                      uint64_t aInputBlockId);
+
+    /**
+     * Send a keyboard event which reporesents a user input to a remote process.
+     *
+     * @param aEvent    The event which user typed a key.
+     * @param aUUID     A UUID which is generated in the parent at sending it.
+     *                  This must be specified when the child sends a reply
+     *                  event to the parent.
+     */
+    [Priority=input]
+    async RealKeyEvent(WidgetKeyboardEvent aEvent, nsID aUUID);
+    async NormalPriorityRealKeyEvent(WidgetKeyboardEvent aEvent, nsID aUUID);
+
+    [Priority=input]
+    async MouseWheelEvent(WidgetWheelEvent event,
+                          ScrollableLayerGuid aGuid,
+                          uint64_t aInputBlockId);
+    async NormalPriorityMouseWheelEvent(WidgetWheelEvent event,
+                                        ScrollableLayerGuid aGuid,
+                                        uint64_t aInputBlockId);
+
+    [Priority=input]
+    async RealTouchEvent(WidgetTouchEvent aEvent,
+                         ScrollableLayerGuid aGuid,
+                         uint64_t aInputBlockId,
+                         nsEventStatus aApzResponse);
+    async NormalPriorityRealTouchEvent(WidgetTouchEvent aEvent,
+                                       ScrollableLayerGuid aGuid,
+                                       uint64_t aInputBlockId,
+                                       nsEventStatus aApzResponse);
+
+    [Priority=input]
+    async HandleTap(GeckoContentController_TapType aType, LayoutDevicePoint point,
+                    Modifiers aModifiers, ScrollableLayerGuid aGuid,
+                    uint64_t aInputBlockId);
+    async NormalPriorityHandleTap(GeckoContentController_TapType aType, LayoutDevicePoint point,
+                                  Modifiers aModifiers, ScrollableLayerGuid aGuid,
+                                  uint64_t aInputBlockId);
+
+    [Compress, Priority=input]
+    async RealTouchMoveEvent(WidgetTouchEvent aEvent,
+                             ScrollableLayerGuid aGuid,
+                             uint64_t aInputBlockId,
+                             nsEventStatus aApzResponse);
+    [Compress]
+    async NormalPriorityRealTouchMoveEvent(WidgetTouchEvent aEvent,
+                                           ScrollableLayerGuid aGuid,
+                                           uint64_t aInputBlockId,
+                                           nsEventStatus aApzResponse);
+    [Compress, Priority=input]
+    async RealTouchMoveEvent2(WidgetTouchEvent aEvent,
+                              ScrollableLayerGuid aGuid,
+                              uint64_t aInputBlockId,
+                              nsEventStatus aApzResponse);
+    [Compress]
+    async NormalPriorityRealTouchMoveEvent2(WidgetTouchEvent aEvent,
+                                            ScrollableLayerGuid aGuid,
+                                            uint64_t aInputBlockId,
+                                            nsEventStatus aApzResponse);
+
+    /*
+     * We disable the input event queue when there is an active dnd session. We
+     * don't need support RealDragEvent with input priority.
+     */
+    async RealDragEvent(WidgetDragEvent aEvent, uint32_t aDragAction,
+                        uint32_t aDropEffect, nullable nsIPrincipal aPrincipal,
+                        nullable nsIContentSecurityPolicy csp);
+
+    [Priority=input] async CompositionEvent(WidgetCompositionEvent event);
+    async NormalPriorityCompositionEvent(WidgetCompositionEvent event);
+
+    [Priority=input] async SelectionEvent(WidgetSelectionEvent event);
+    async NormalPrioritySelectionEvent(WidgetSelectionEvent event);
+
+    /**
+     * Dispatch eContentCommandInsertText event in the remote process.
+     */
+    [Priority=input] async InsertText(nsString aStringToInsert);
+    async NormalPriorityInsertText(nsString aStringToInsert);
+
+    /**
+     * Call PasteTransferable via a controller on the content process
+     * to handle the command content event, "pasteTransferable".
+     */
+    // XXX Do we really need data other than IPCTransferableData? See bug 1833172.
+    async PasteTransferable(IPCTransferableData aTransferableData,
+                            bool aIsPrivateData,
+                            nullable nsIPrincipal aRequestingPrincipal,
+                            nsContentPolicyType aContentPolicyType);
+
+    async LoadRemoteScript(nsString aURL, bool aRunInGlobalScope);
+
+    /**
+     * Sent by the chrome process when it no longer wants this remote
+     * <browser>.  The child side cleans up in response, then
+     * finalizing its death by sending back __delete__() to the
+     * parent.
+     */
+    async Destroy();
+
+    /**
+     * If aEnabled is true, tells the child to paint and upload layers to
+     * the compositor. If aEnabled is false, the child stops painting and
+     * clears the layers from the compositor.
+     *
+     * @param aEnabled
+     *        True if the child should render and upload layers, false if the
+     *        child should clear layers.
+     * @param aEpoch
+     *        The layer observer epoch for this activation. This message should be
+     *        ignored if this epoch has already been observed (via
+     *        PaintWhileInterruptingJS).
+     */
+    async RenderLayers(bool aEnabled, LayersObserverEpoch aEpoch);
+
+    /**
+     * Communicates the child that we want layers to be preserved even when the
+     * browser is inactive.
+     */
+    async PreserveLayers(bool aPreserve);
+child:
+    /**
+     * Notify the child that it shouldn't paint the offscreen displayport.
+     * This is useful to speed up interactive operations over async
+     * scrolling performance like resize, tabswitch, pageload.
+     *
+     * Each enable call must be matched with a disable call. The child
+     * will remain in the suppress mode as long as there's
+     * a single unmatched call.
+     */
+    async SuppressDisplayport(bool aEnabled);
+
+    /**
+     * Navigate by key (Tab/Shift+Tab/F6/Shift+f6).
+     */
+    async NavigateByKey(bool aForward, bool aForDocumentNavigation);
+
+    /**
+     * Tell the child that the UI resolution changed for the containing
+     * window.
+     * To avoid some sync messages from child to parent, we also send the dpi
+     * and default scale with the notification.
+     * If we don't know the dpi and default scale, we just pass in a negative
+     * value (-1) but in the majority of the cases this saves us from two
+     * sync requests from the child to the parent.
+     */
+    async UIResolutionChanged(float dpi, int32_t rounding, double scale);
+
+    /**
+     * Tell the child that the safe area of widget has changed.
+     *
+     */
+    async SafeAreaInsetsChanged(ScreenIntMargin aSafeAreaInsets);
+
+    /**
+     * Tell the browser that its frame loader has been swapped
+     * with another.
+     */
+    async SwappedWithOtherRemoteLoader(IPCTabContext context);
+
+    /**
+     * A potential accesskey was just pressed. Look for accesskey targets
+     * using the list of provided charCodes.
+     *
+     * @param event keyboard event
+     * @param isTrusted true if triggered by a trusted key event
+     */
+    async HandleAccessKey(WidgetKeyboardEvent event,
+                          uint32_t[] charCodes);
+
+    /**
+     * Tell the child to create a print preview document in this browser, or
+     * to update the existing print preview document with new print settings.
+     *
+     * @param aPrintData The serialized print settings to use to layout the
+     *   print preview document.
+     * @param aSourceBrowsingContext Optionally, the browsing context that
+     *   contains the document from which the print preview is to be generated.
+     *   This should only be passed on the first call.  It should not be passed
+     *   for any subsequent calls that are made to update the existing print
+     *   preview document with a new print settings object.
+     */
+    async PrintPreview(PrintData aPrintData,
+                       MaybeDiscardedBrowsingContext aSourceBrowsingContext) returns (PrintPreviewResultInfo aInfo);
+
+    /**
+     * Inform the print preview document that we're done with it.
+     */
+    async ExitPrintPreview();
+
+    /**
+     * Tell the child to print the current page with the given settings.
+     *
+     * @param aBrowsingContext the browsing context to print.
+     * @param aPrintData the serialized settings to print with
+     */
+    async Print(MaybeDiscardedBrowsingContext aBC, PrintData aPrintData);
+
+    /**
+     * Update the child with the tab's current top-level native window handle.
+     * This is used by a11y objects who must expose their native window.
+     *
+     * @param aNewHandle The native window handle of the tab's top-level window.
+     */
+    async UpdateNativeWindowHandle(uintptr_t aNewHandle);
+
+    /**
+     * Tell the BrowserChild to allow scripts in the docshell to close the window.
+     */
+    async AllowScriptsToClose();
+
+    async WillChangeProcess();
+
+parent:
+    /**
+     * Fetches whether this window supports protected media, which is sent back in response.
+     */
+    async IsWindowSupportingProtectedMedia(uint64_t aOuterWindowID) returns(bool isSupported);
+
+    /**
+    * Fetches whether this window supports WebVR, which is sent back in response.
+    */
+    async IsWindowSupportingWebVR(uint64_t aOuterWindowID) returns(bool isSupported);
+
+    /** Records a history visit. */
+    async VisitURI(nullable nsIURI aURI, nullable nsIURI aLastVisitedURI, uint32_t aFlags, uint64_t aBrowserId);
+
+    /** Fetches the visited status for an array of URIs (Android-only). */
+    async QueryVisitedState(nullable nsIURI[] aURIs);
+
+    /** Create a session store for a browser child. */
+    async PSessionStore();
+
+    /**
+     * Construct a new WindowGlobal for an existing global in the content process
+     */
+    async NewWindowGlobal(ManagedEndpoint<PWindowGlobalParent> aEndpoint,
+                          WindowGlobalInit aInit);
+
+/*
+ * FIXME: write protocol!
+
+state LIVE:
+    send LoadURL goto LIVE;
+//etc.
+    send Destroy goto DYING;
+
+state DYING:
+    discard send blah;
+// etc.
+    recv __delete__;
+ */
+};
+
+}
+}
diff --git a/dom/ipc/PBrowserBridge.ipdl b/dom/ipc/PBrowserBridge.ipdl
new file mode 100644
index 0000000000..674a576d7b
--- /dev/null
+++ b/dom/ipc/PBrowserBridge.ipdl
@@ -0,0 +1,135 @@
+/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */
+/* 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 protocol PBrowser;
+#ifdef ACCESSIBILITY
+include protocol PDocAccessible;
+#endif
+
+include DOMTypes;
+include PPrintingTypes;
+
+include "mozilla/LayoutMessageUtils.h";
+include "mozilla/dom/BindingIPCUtils.h";
+include "mozilla/dom/DocShellMessageUtils.h";
+include "mozilla/dom/TabMessageUtils.h";
+
+using mozilla::layers::LayersObserverEpoch from "mozilla/layers/LayersTypes.h";
+using class mozilla::WidgetMouseEvent from "ipc/nsGUIEventIPC.h";
+using mozilla::dom::EffectsInfo from "mozilla/dom/EffectsInfo.h";
+using mozilla::ScrollAxis from "mozilla/PresShellForwards.h";
+using mozilla::ScrollFlags from "mozilla/PresShellForwards.h";
+using struct nsRect from "nsRect.h";
+using mozilla::dom::CallerType from "mozilla/dom/BindingDeclarations.h";
+using nsIntRect from "nsRect.h";
+using mozilla::dom::EmbedderElementEventType from "mozilla/dom/TabMessageTypes.h";
+[RefCounted] using class nsDocShellLoadState from "nsDocShellLoadState.h";
+using mozilla::IntrinsicSize from "nsIFrame.h";
+using mozilla::AspectRatio from "mozilla/AspectRatio.h";
+using mozilla::StyleImageRendering from "mozilla/ServoStyleConsts.h";
+
+namespace mozilla {
+namespace dom {
+
+/**
+ * A PBrowserBridge connects an iframe/browser in a content process to the
+ * PBrowser that manages the embedded content.
+ *
+ * See `dom/docs/Fission-IPC-Diagram.svg` for an overview of the DOM IPC
+ * actors.
+ */
+async protocol PBrowserBridge {
+  manager PBrowser;
+
+child:
+  /**
+   * Request that the IPC child / Web parent process move focus to the
+   * browser's frame. If canRaise is true, the window can be raised if
+   * it is inactive.
+   */
+  async RequestFocus(bool canRaise, CallerType aCallerType);
+
+  /**
+   * When IPC parent / Web child sends this message, the IPC child / Web parent
+   * should move focus to the next or previous focusable element or document.
+   */
+  async MoveFocus(bool forward, bool forDocumentNavigation);
+
+  /**
+   * Called once this PBrowserBridge's OOP subdoc no longer blocks its
+   * embedding element's and embedding doc's 'load' events.
+   */
+  async MaybeFireEmbedderLoadEvents(EmbedderElementEventType aFireEventAtEmbeddingElement);
+
+  async ScrollRectIntoView(nsRect aRect, ScrollAxis aVertical,
+                           ScrollAxis aHorizontal, ScrollFlags aScrollFlags,
+                           int32_t aAppUnitsPerDevPixel);
+
+  async SubFrameCrashed();
+
+  async IntrinsicSizeOrRatioChanged(IntrinsicSize? aIntrinsicSize,
+                                    AspectRatio? aIntrinsicRatio);
+
+  async ImageLoadComplete(nsresult aResult);
+
+both:
+
+  // Destroy the remote web browser due to the nsFrameLoader going away.
+  // Before initialization we sync-delete it from the child. After
+  // initialization we sync-delete it from the parent after BeginDestroy().
+  async __delete__();
+
+parent:
+
+  async BeginDestroy();
+
+  // DocShell messaging.
+  async LoadURL(nsDocShellLoadState aLoadState);
+  async ResumeLoad(uint64_t aPendingSwitchID);
+
+  // Out of process rendering.
+  async Show(OwnerShowInfo info);
+  async ScrollbarPreferenceChanged(ScrollbarPreference pref);
+  [Compress=all] async UpdateDimensions(nsIntRect rect, ScreenIntSize size);
+  async RenderLayers(bool aEnabled, LayersObserverEpoch aEpoch);
+
+  async UpdateEffects(EffectsInfo aEffects);
+  async UpdateRemotePrintSettings(PrintData aPrintData);
+
+  /**
+   * Navigate by key (Tab/Shift+Tab/F6/Shift+f6).
+   */
+  async NavigateByKey(bool aForward, bool aForDocumentNavigation);
+
+  /**
+   * Dispatch the given synthesized mousemove event to the child.
+   */
+  async DispatchSynthesizedMouseEvent(WidgetMouseEvent event);
+
+  /**
+   * Sending an activate message moves focus to the iframe.
+   */
+  async Activate(uint64_t aActionId);
+
+  async Deactivate(bool aWindowLowering, uint64_t aActionId);
+
+  async UpdateRemoteStyle(StyleImageRendering aImageRendering);
+
+  async WillChangeProcess();
+
+#ifdef ACCESSIBILITY
+  /**
+   * Tell the parent the accessible for this iframe's embedder
+   * OuterDocAccessible.
+   * aDoc is the actor for the containing document.
+   * aID is the unique id of the embedder accessible within that document.
+   */
+  async SetEmbedderAccessible(nullable PDocAccessible aDoc, uint64_t aID);
+#endif
+};
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/ipc/PColorPicker.ipdl b/dom/ipc/PColorPicker.ipdl
new file mode 100644
index 0000000000..9690327d1d
--- /dev/null
+++ b/dom/ipc/PColorPicker.ipdl
@@ -0,0 +1,28 @@
+/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */
+
+/* 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 protocol PBrowser;
+
+namespace mozilla {
+namespace dom {
+
+[ChildImpl=virtual, ParentImpl=virtual]
+protocol PColorPicker
+{
+    manager PBrowser;
+
+parent:
+    async Open();
+
+child:
+    async Update(nsString color);
+
+    async __delete__(nsString color);
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/PContent.ipdl b/dom/ipc/PContent.ipdl
new file mode 100644
index 0000000000..3f93b5fb73
--- /dev/null
+++ b/dom/ipc/PContent.ipdl
@@ -0,0 +1,1986 @@
+/* -*- tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=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 protocol PBackgroundStarter;
+include protocol PBrowser;
+include protocol PClipboardWriteRequest;
+include protocol PCompositorManager;
+include protocol PContentPermissionRequest;
+include protocol PCycleCollectWithLogs;
+include protocol PDocumentChannel;
+include protocol PExtensions;
+include protocol PExternalHelperApp;
+include protocol PHandlerService;
+include protocol PHal;
+include protocol PHeapSnapshotTempFileHelper;
+include protocol PProcessHangMonitor;
+include protocol PImageBridge;
+include protocol PRemotePrintJob;
+include protocol PLoginReputation;
+include protocol PMedia;
+include protocol PNecko;
+include protocol PStreamFilter;
+include protocol PGMPContent;
+include protocol PGMPService;
+include protocol PGMP;
+#ifdef MOZ_WEBSPEECH
+include protocol PSpeechSynthesis;
+#endif
+include protocol PTestShell;
+include protocol PRemoteSpellcheckEngine;
+include protocol PWebBrowserPersistDocument;
+#ifdef MOZ_WEBRTC
+include protocol PWebrtcGlobal;
+#endif
+include protocol PWindowGlobal;
+include protocol PURLClassifier;
+include protocol PURLClassifierLocal;
+include protocol PVRManager;
+include protocol PRemoteDecoderManager;
+include protocol PProfiler;
+include protocol PScriptCache;
+include protocol PSessionStorageObserver;
+include protocol PBenchmarkStorage;
+include DOMTypes;
+include WindowGlobalTypes;
+include IPCBlob;
+include IPCStream;
+include IPCTransferable;
+include PPrintingTypes;
+include PTabContext;
+include ProtocolTypes;
+include PBackgroundSharedTypes;
+include PContentPermission;
+include GraphicsMessages;
+include MemoryReportTypes;
+include ClientIPCTypes;
+include HangTypes;
+include PrefsTypes;
+include NeckoChannelParams;
+include PSMIPCTypes;
+include LookAndFeelTypes;
+
+#if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
+include protocol PSandboxTesting;
+#endif
+
+include "ipc/MediaControlIPC.h";
+include "mozilla/AntiTrackingIPCUtils.h";
+include "mozilla/GfxMessageUtils.h";
+include "mozilla/dom/BindingIPCUtils.h";
+include "mozilla/dom/CSPMessageUtils.h";
+include "mozilla/dom/DocShellMessageUtils.h";
+include "mozilla/dom/FeaturePolicyUtils.h";
+include "mozilla/dom/MediaSessionIPCUtils.h";
+include "mozilla/dom/PageLoadEventUtils.h";
+include "mozilla/dom/ReferrerInfoUtils.h";
+include "mozilla/glean/GleanMetrics.h";
+include "mozilla/ipc/ByteBufUtils.h";
+include "mozilla/ipc/TransportSecurityInfoUtils.h";
+include "mozilla/ipc/URIUtils.h";
+include "mozilla/net/NeckoMessageUtils.h";
+include "mozilla/PermissionDelegateIPCUtils.h";
+
+[RefCounted] using class nsIDOMGeoPosition from "nsGeoPositionIPCSerialiser.h";
+[RefCounted] using class nsIAlertNotification from "mozilla/AlertNotificationIPCSerializer.h";
+
+using struct ChromePackage from "mozilla/chrome/RegistryMessageUtils.h";
+using struct SubstitutionMapping from "mozilla/chrome/RegistryMessageUtils.h";
+using struct OverrideMapping from "mozilla/chrome/RegistryMessageUtils.h";
+using base::ProcessId from "base/process.h";
+using struct IPC::Permission from "mozilla/net/NeckoMessageUtils.h";
+using mozilla::dom::NativeThreadId from "mozilla/dom/NativeThreadId.h";
+using mozilla::hal::ProcessPriority from "mozilla/HalTypes.h";
+using mozilla::gfx::IntSize from "mozilla/gfx/2D.h";
+using mozilla::gfx::SurfaceFormat from "mozilla/gfx/Types.h";
+using mozilla::dom::TabId from "mozilla/dom/ipc/IdType.h";
+using mozilla::dom::ContentParentId from "mozilla/dom/ipc/IdType.h";
+using mozilla::LayoutDeviceIntPoint from "Units.h";
+using mozilla::ImagePoint from "Units.h";
+using mozilla::ImageIntSize from "Units.h";
+using mozilla::widget::ThemeChangeKind from "mozilla/widget/WidgetMessageUtils.h";
+using class mozilla::dom::MessagePort from "mozilla/dom/MessagePort.h";
+using class mozilla::dom::ipc::StructuredCloneData from "mozilla/dom/ipc/StructuredCloneData.h";
+using mozilla::OriginAttributes from "mozilla/ipc/BackgroundUtils.h";
+using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h";
+using mozilla::layers::CompositorOptions from "mozilla/layers/CompositorOptions.h";
+using mozilla::layers::LayersId from "mozilla/layers/LayersTypes.h";
+using mozilla::Telemetry::HistogramAccumulation from "mozilla/TelemetryComms.h";
+using mozilla::Telemetry::KeyedHistogramAccumulation from "mozilla/TelemetryComms.h";
+using mozilla::Telemetry::ScalarAction from "mozilla/TelemetryComms.h";
+using mozilla::Telemetry::KeyedScalarAction from "mozilla/TelemetryComms.h";
+using mozilla::Telemetry::DynamicScalarDefinition from "mozilla/TelemetryComms.h";
+using mozilla::Telemetry::ChildEventData from "mozilla/TelemetryComms.h";
+
+#if defined(XP_WIN)
+[MoveOnly] using mozilla::UntrustedModulesData from "mozilla/UntrustedModulesData.h";
+[MoveOnly] using mozilla::ModulePaths from "mozilla/UntrustedModulesData.h";
+[MoveOnly] using mozilla::ModulesMapResult from "mozilla/UntrustedModulesData.h";
+#endif  // defined(XP_WIN)
+
+using mozilla::Telemetry::DiscardedData from "mozilla/TelemetryComms.h";
+using mozilla::glean::perf::PageLoadExtra from "mozilla/glean/GleanMetrics.h";
+[MoveOnly] using mozilla::CrossProcessMutexHandle from "mozilla/ipc/CrossProcessMutex.h";
+using mozilla::dom::MaybeDiscardedBrowsingContext from "mozilla/dom/BrowsingContext.h";
+using mozilla::dom::BrowsingContextTransaction from "mozilla/dom/BrowsingContext.h";
+using mozilla::dom::BrowsingContextInitializer from "mozilla/dom/BrowsingContext.h";
+using mozilla::dom::PermitUnloadResult from "nsIContentViewer.h";
+using mozilla::dom::MaybeDiscardedWindowContext from "mozilla/dom/WindowContext.h";
+using mozilla::dom::WindowContextTransaction from "mozilla/dom/WindowContext.h";
+[MoveOnly] using base::SharedMemoryHandle from "base/shared_memory.h";
+using mozilla::fontlist::Pointer from "SharedFontList.h";
+using gfxSparseBitSet from "gfxFontUtils.h";
+using FontVisibility from "gfxFontEntry.h";
+using mozilla::dom::MediaControlAction from "mozilla/dom/MediaControlKeySource.h";
+using mozilla::dom::MediaPlaybackState from "mozilla/dom/MediaPlaybackStatus.h";
+using mozilla::dom::MediaAudibleState from "mozilla/dom/MediaPlaybackStatus.h";
+using mozilla::dom::MediaMetadataBase from "mozilla/dom/MediaMetadata.h";
+using mozilla::dom::MediaSessionAction from "mozilla/dom/MediaSessionBinding.h";
+using mozilla::dom::MediaSessionPlaybackState from "mozilla/dom/MediaSessionBinding.h";
+using mozilla::dom::PositionState from "mozilla/dom/MediaSession.h";
+using mozilla::dom::ServiceWorkerShutdownState::Progress from "mozilla/dom/ServiceWorkerShutdownState.h";
+using mozilla::ContentBlockingNotifier::StorageAccessPermissionGrantedReason from "mozilla/ContentBlockingNotifier.h";
+using mozilla::ContentBlockingNotifier::BlockingDecision from "mozilla/ContentBlockingNotifier.h";
+using mozilla::StorageAccessAPIHelper::StorageAccessPromptChoices from "mozilla/StorageAccessAPIHelper.h";
+using mozilla::dom::JSActorMessageKind from "mozilla/dom/JSActor.h";
+using mozilla::dom::JSActorMessageMeta from "mozilla/dom/PWindowGlobal.h";
+using mozilla::PermissionDelegateHandler::DelegatedPermissionList from "mozilla/PermissionDelegateHandler.h";
+[RefCounted] using class nsILayoutHistoryState from "nsILayoutHistoryState.h";
+using class mozilla::dom::SessionHistoryInfo from "mozilla/dom/SessionHistoryEntry.h";
+using struct nsPoint from "nsPoint.h";
+using struct mozilla::dom::LoadingSessionHistoryInfo from "mozilla/dom/SessionHistoryEntry.h";
+using mozilla::media::MediaCodecsSupported from "MediaCodecsSupport.h";
+using mozilla::RemoteDecodeIn from "mozilla/RemoteDecoderManagerChild.h";
+using mozilla::dom::PerformanceTimingData from "mozilla/dom/PerformanceTiming.h";
+[RefCounted] using mozilla::dom::FeaturePolicy from "mozilla/dom/FeaturePolicy.h";
+using mozilla::dom::Wireframe from "mozilla/dom/DocumentBinding.h";
+using mozilla::PerfStats::MetricMask from "mozilla/PerfStats.h";
+[RefCounted] using class nsIX509Cert from "nsIX509Cert.h";
+using nsIDNSService::ResolverMode from "nsIDNSService.h";
+
+union ChromeRegistryItem
+{
+    ChromePackage;
+    OverrideMapping;
+    SubstitutionMapping;
+};
+
+namespace mozilla {
+namespace dom {
+
+// SetXPCOMProcessAttributes passes an array of font data to the child,
+// but each platform needs different details so we have platform-specific
+// versions of the SystemFontListEntry type:
+#if defined(ANDROID)
+// Used on Android to pass the list of fonts on the device
+// to the child process
+struct SystemFontListEntry {
+    nsCString familyName;
+    nsCString faceName;
+    nsCString filepath;
+    uint32_t  weightRange;
+    uint32_t  stretchRange;
+    uint32_t  styleRange;
+    uint8_t   index;
+    FontVisibility visibility;
+};
+#elif defined(XP_MACOSX)
+// Used on Mac OS X to pass the list of font families (not faces)
+// from chrome to content processes.
+// The entryType field distinguishes several types of font family
+// record; see gfxMacPlatformFontList.h for values and meaning.
+struct SystemFontListEntry {
+    nsCString familyName;
+    FontVisibility visibility;
+    uint8_t   entryType;
+};
+#else
+// Used on Linux to pass list of font patterns from chrome to content.
+// (Unused on Windows, but there needs to be a definition of the type.)
+struct SystemFontListEntry {
+    nsCString pattern;
+    bool      appFontFamily;
+};
+#endif
+
+#ifdef MOZ_WIDGET_GTK
+struct SystemFontOptions {
+    int32_t antialias; // cairo_antialias_t
+    int32_t subpixelOrder; // cairo_subpixel_order_t
+    int32_t hintStyle; // cairo_hint_style_t
+    int32_t lcdFilter; // cairo_lcd_filter_t
+};
+#endif
+
+struct SystemFontList {
+    SystemFontListEntry[] entries;
+#ifdef MOZ_WIDGET_GTK
+    SystemFontOptions options;
+#endif
+};
+
+union SystemParameterValue {
+  bool;
+  float;
+};
+
+struct ClipboardCapabilities {
+  bool supportsSelectionClipboard;
+  bool supportsFindClipboard;
+  bool supportsSelectionCache;
+};
+
+union FileDescOrError {
+    FileDescriptor;
+    nsresult;
+};
+
+struct DomainPolicyClone
+{
+    bool        active;
+    nullable nsIURI[] blocklist;
+    nullable nsIURI[] allowlist;
+    nullable nsIURI[] superBlocklist;
+    nullable nsIURI[] superAllowlist;
+};
+
+struct AndroidSystemInfo
+{
+    nsString device;
+    nsString manufacturer;
+    nsString release_version;
+    nsString hardware;
+    uint32_t sdk_version;
+    bool     isTablet;
+};
+
+struct GetFilesResponseSuccess
+{
+  IPCBlob[] blobs;
+};
+
+struct GetFilesResponseFailure
+{
+  nsresult errorCode;
+};
+
+union GetFilesResponseResult
+{
+  GetFilesResponseSuccess;
+  GetFilesResponseFailure;
+};
+
+struct BlobURLRegistrationData
+{
+  nsCString url;
+  IPCBlob blob;
+  nullable nsIPrincipal principal;
+  nsID? agentClusterId;
+  bool revoked;
+};
+
+struct JSWindowActorEventDecl
+{
+  nsString name;
+  bool capture;
+  bool systemGroup;
+  bool allowUntrusted;
+  bool? passive;
+  bool createActor;
+};
+
+struct JSWindowActorInfo
+{
+  nsCString name;
+  bool allFrames;
+
+  // True if `url` is for ESM.
+  // False if `url` is for JSM or nothing.
+  bool isESModule;
+
+  // The module of the url.
+  nsCString? url;
+
+  JSWindowActorEventDecl[] events;
+
+  // Observer notifications this actor listens to.
+  nsCString[] observers;
+  nsString[] matches;
+  nsCString[] remoteTypes;
+  nsString[] messageManagerGroups;
+};
+
+struct JSProcessActorInfo
+{
+    // The name of the actor.
+    nsCString name;
+
+    // True if `url` is for ESM.
+    // False if `url` is for JSM or nothing.
+    bool isESModule;
+
+    // The module of the url.
+    nsCString? url;
+
+    // Observer notifications this actor listens to.
+    nsCString[] observers;
+    nsCString[] remoteTypes;
+};
+
+struct GMPAPITags
+{
+    nsCString api;
+    nsCString[] tags;
+};
+
+struct GMPCapabilityData
+{
+    nsCString name;
+    nsCString version;
+    GMPAPITags[] capabilities;
+};
+
+struct L10nFileSourceDescriptor {
+  nsCString name;
+  nsCString metasource;
+  nsCString[] locales;
+  nsCString prePath;
+  nsCString[] index;
+};
+
+struct XPCOMInitData
+{
+    bool isOffline;
+    bool isConnected;
+    int32_t captivePortalState;
+    bool isLangRTL;
+    bool haveBidiKeyboards;
+    nsCString[] dictionaries;
+    ClipboardCapabilities clipboardCaps;
+    DomainPolicyClone domainPolicy;
+    nullable nsIURI userContentSheetURL;
+    GfxVarUpdate[] gfxNonDefaultVarUpdates;
+    ContentDeviceData contentDeviceData;
+    GfxInfoFeatureStatus[] gfxFeatureStatus;
+    nsCString[] appLocales;
+    nsCString[] requestedLocales;
+    L10nFileSourceDescriptor[] l10nFileSources;
+    DynamicScalarDefinition[] dynamicScalarDefs;
+    MetricMask perfStatsMask;
+    nsCString trrDomain;
+    ResolverMode trrMode;
+    // This is the value of network.trr.mode and can be diffrent than trrMode.
+    ResolverMode trrModeFromPref;
+};
+
+struct VisitedQueryResult
+{
+    nullable nsIURI uri;
+    bool visited;
+};
+
+struct StringBundleDescriptor
+{
+    nsCString bundleURL;
+    FileDescriptor mapFile;
+    uint32_t mapSize;
+};
+
+struct IPCURLClassifierFeature
+{
+    nsCString featureName;
+    nsCString[] tables;
+    nsCString exceptionHostList;
+};
+
+// Transport structure for Notifications API notifications
+// (https://developer.mozilla.org/en-US/docs/Web/API/notification) instances
+// used exclusively by the NotificationEvent PContent method.
+struct NotificationEventData
+{
+    nsCString originSuffix;
+    nsCString scope;
+    nsString ID;
+    nsString title;
+    nsString dir;
+    nsString lang;
+    nsString body;
+    nsString tag;
+    nsString icon;
+    nsString data;
+    nsString behavior;
+};
+
+struct PostMessageData
+{
+    MaybeDiscardedBrowsingContext source;
+    nsString origin;
+    nsString targetOrigin;
+    nullable nsIURI targetOriginURI;
+    nullable nsIPrincipal callerPrincipal;
+    nullable nsIPrincipal subjectPrincipal;
+    nullable nsIURI callerURI;
+    bool isFromPrivateWindow;
+    nsCString scriptLocation;
+    uint64_t innerWindowId;
+};
+
+union SyncedContextInitializer
+{
+    BrowsingContextInitializer;
+    WindowContextInitializer;
+};
+
+union BlobURLDataRequestResult
+{
+  IPCBlob;
+  nsresult;
+};
+
+struct TextRecognitionQuad {
+    float confidence;
+    nsString string;
+    ImagePoint[] points;
+};
+
+struct TextRecognitionResult {
+    TextRecognitionQuad[] quads;
+};
+
+union TextRecognitionResultOrError {
+    TextRecognitionResult;
+    nsCString;
+};
+
+struct IPCImage {
+    BigBuffer data;
+    uint32_t stride;
+    SurfaceFormat format;
+    ImageIntSize size;
+};
+
+union IPCTransferableDataOrError {
+    IPCTransferableData;
+    nsresult;
+};
+
+/**
+ * The PContent protocol is a top-level protocol between the UI process
+ * and a content process. There is exactly one PContentParent/PContentChild pair
+ * for each content process.
+ */
+[NestedUpTo=inside_cpow, NeedsOtherPid]
+sync protocol PContent
+{
+    manages PBrowser;
+    manages PClipboardWriteRequest;
+    manages PContentPermissionRequest;
+    manages PCycleCollectWithLogs;
+    manages PExtensions;
+    manages PExternalHelperApp;
+    manages PHal;
+    manages PHandlerService;
+    manages PHeapSnapshotTempFileHelper;
+    manages PRemotePrintJob;
+    manages PMedia;
+    manages PNecko;
+#ifdef MOZ_WEBSPEECH
+    manages PSpeechSynthesis;
+#endif
+    manages PTestShell;
+    manages PRemoteSpellcheckEngine;
+    manages PWebBrowserPersistDocument;
+#ifdef MOZ_WEBRTC
+    manages PWebrtcGlobal;
+#endif
+    manages PURLClassifier;
+    manages PURLClassifierLocal;
+    manages PScriptCache;
+    manages PLoginReputation;
+    manages PSessionStorageObserver;
+    manages PBenchmarkStorage;
+
+    // Depending on exactly how the new browser is being created, it might be
+    // created from either the child or parent process!
+    //
+    // The child creates the PBrowser as part of
+    // BrowserChild::BrowserFrameProvideWindow (which happens when the child's
+    // content calls window.open()), and the parent creates the PBrowser as part
+    // of ContentParent::CreateBrowser.
+    //
+    // When the parent constructs a PBrowser, the child trusts the attributes it
+    // receives from the parent.  In that case, the context should be
+    // FrameIPCTabContext.
+    //
+    // When the child constructs a PBrowser, the parent doesn't trust the
+    // attributes it receives from the child.  In this case, context must have
+    // type PopupIPCTabContext.  The parent checks that if the opener is a
+    // browser element, the context is also for a browser element.
+    //
+    // If |sameTabGroupAs| is non-zero, the new tab should go in the same
+    // TabGroup as |sameTabGroupAs|. This parameter should always be zero
+    // for PBrowser messages sent from the child to the parent.
+    //
+    // Separate messages are used for the parent and child side constructors due
+    // to the differences in data and actor setup required.
+    //
+    // Keep the last 3 attributes in sync with GetProcessAttributes!
+parent:
+    async ConstructPopupBrowser(ManagedEndpoint<PBrowserParent> browserEp,
+                                ManagedEndpoint<PWindowGlobalParent> windowEp,
+                                TabId tabId, IPCTabContext context,
+                                WindowGlobalInit windowInit,
+                                uint32_t chromeFlags);
+
+    // TODO: Do I need to make this return something to watch for completion?
+    // Guess we'll see how we end up triggering the actual print, for preview
+    // this should be enough...
+    async CloneDocumentTreeInto(MaybeDiscardedBrowsingContext aSourceBc,
+                                MaybeDiscardedBrowsingContext aTargetBc,
+                                PrintData aPrintData);
+
+    async UpdateRemotePrintSettings(MaybeDiscardedBrowsingContext aBc,
+                                    PrintData aPrintData);
+
+    async PExtensions();
+
+child:
+    async ConstructBrowser(ManagedEndpoint<PBrowserChild> browserEp,
+                           ManagedEndpoint<PWindowGlobalChild> windowEp,
+                           TabId tabId,
+                           IPCTabContext context,
+                           WindowGlobalInit windowInit,
+                           uint32_t chromeFlags, ContentParentId cpId,
+                           bool isForBrowser, bool isTopLevel);
+
+both:
+    // For parent->child, aBrowser must be non-null; aContext can
+    // be null to indicate the browser's current root document, or non-null
+    // to persist a subdocument.  For child->parent, arguments are
+    // ignored and should be null.
+    async PWebBrowserPersistDocument(nullable PBrowser aBrowser,
+                                     MaybeDiscardedBrowsingContext aContext);
+
+    async RawMessage(JSActorMessageMeta aMetadata, ClonedMessageData? aData,
+                     ClonedMessageData? aStack);
+
+child:
+    async InitGMPService(Endpoint<PGMPServiceChild> service);
+    async InitProcessHangMonitor(Endpoint<PProcessHangMonitorChild> hangMonitor);
+    async InitProfiler(Endpoint<PProfilerChild> aEndpoint);
+
+    // Give the content process its endpoints to the compositor.
+    async InitRendering(
+      Endpoint<PCompositorManagerChild> compositor,
+      Endpoint<PImageBridgeChild> imageBridge,
+      Endpoint<PVRManagerChild> vr,
+      Endpoint<PRemoteDecoderManagerChild> video,
+      uint32_t[] namespaces);
+
+    // Re-create the rendering stack using the given endpoints. This is sent
+    // after the compositor process has crashed. The new endpoints may be to a
+    // newly launched GPU process, or the compositor thread of the UI process.
+    async ReinitRendering(
+      Endpoint<PCompositorManagerChild> compositor,
+      Endpoint<PImageBridgeChild> bridge,
+      Endpoint<PVRManagerChild> vr,
+      Endpoint<PRemoteDecoderManagerChild> video,
+      uint32_t[] namespaces);
+
+    async NetworkLinkTypeChange(uint32_t type);
+    async SocketProcessCrashed();
+
+    // Re-create the rendering stack for a device reset.
+    async ReinitRenderingForDeviceReset();
+
+    /**
+     * Enable system-level sandboxing features, if available.  Can
+     * usually only be performed zero or one times.  The child may
+     * abnormally exit if this fails; the details are OS-specific.
+     */
+    async SetProcessSandbox(FileDescriptor? aBroker);
+
+    async RequestMemoryReport(uint32_t generation,
+                              bool anonymize,
+                              bool minimizeMemoryUsage,
+                              FileDescriptor? DMDFile)
+        returns (uint32_t aGeneration);
+
+    async RequestPerformanceMetrics(nsID aID);
+
+#if defined(XP_WIN)
+    /**
+     * Used by third-party modules telemetry (aka "untrusted modules" telemetry)
+     * to pull data from content processes.
+     */
+    async GetUntrustedModulesData() returns (UntrustedModulesData? data);
+
+    /**
+    * This method is used to notifty a child process to start
+    * processing module loading events in UntrustedModulesProcessor.
+    * This should be called when the parent process has gone idle.
+    */
+    async UnblockUntrustedModulesThread();
+#endif  // defined(XP_WIN)
+
+    /**
+     * Communication between the PuppetBidiKeyboard and the actual
+     * BidiKeyboard hosted by the parent
+     */
+    async BidiKeyboardNotify(bool isLangRTL, bool haveBidiKeyboards);
+
+    /**
+     * Dump this process's GC and CC logs to the provided files.
+     *
+     * For documentation on the other args, see dumpGCAndCCLogsToFile in
+     * nsIMemoryInfoDumper.idl
+     */
+    async PCycleCollectWithLogs(bool dumpAllTraces,
+                                FileDescriptor gcLog,
+                                FileDescriptor ccLog);
+
+    async PTestShell();
+
+    async PScriptCache(FileDescOrError cacheFile, bool wantCacheData);
+
+    async RegisterChrome(ChromePackage[] packages, SubstitutionMapping[] substitutions,
+                         OverrideMapping[] overrides, nsCString locale, bool reset);
+    async RegisterChromeItem(ChromeRegistryItem item);
+
+    async ClearImageCacheFromPrincipal(nullable nsIPrincipal aPrincipal);
+
+    async ClearImageCacheFromBaseDomain(nsCString aBaseDomain);
+
+    async ClearImageCache(bool privateLoader, bool chrome);
+
+    async ClearStyleSheetCache(nullable nsIPrincipal? aForPrincipal,
+                               nsCString? aBaseDomain);
+
+    async SetOffline(bool offline);
+    async SetConnectivity(bool connectivity);
+    async SetCaptivePortalState(int32_t aState);
+    async SetTRRMode(ResolverMode aMode, ResolverMode aModeFromPref);
+
+    async NotifyVisited(VisitedQueryResult[] uri);
+
+    /**
+     * Tell the child that the system theme has changed, and that a repaint is
+     * necessary.
+     */
+    async ThemeChanged(FullLookAndFeel lookAndFeelData, ThemeChangeKind aKind);
+
+    async PreferenceUpdate(Pref pref);
+    async VarUpdate(GfxVarUpdate var);
+
+    async UpdatePerfStatsCollectionMask(uint64_t aMask);
+    async CollectPerfStatsJSON() returns (nsCString aStats);
+
+    async CollectScrollingMetrics() returns (uint32_t pixelsScrolled, uint32_t scrollDurationMS);
+
+    async NotifyAlertsObserver(nsCString topic, nsString data);
+
+    async GeolocationUpdate(nullable nsIDOMGeoPosition aPosition);
+
+    async GeolocationError(uint16_t errorCode);
+
+    async UpdateDictionaryList(nsCString[] dictionaries);
+
+    async UpdateFontList(SystemFontList fontList);
+
+    /**
+     * The shared font list has been updated by the parent, so child processes
+     * should globally reflow everything to pick up new character coverage etc.
+     * If aFullRebuild is true, child processes must discard and recreate
+     * their mappings to the shmem blocks, as those are no longer valid.
+     * This message has raised priority so that it will take precedence over
+     * vsync messages to the child.
+     */
+    [Priority=mediumhigh] async RebuildFontList(bool aFullRebuild);
+
+    /**
+     * The shared font list has been modified, potentially adding matches
+     * for src:local() names that were previously not known, so content
+     * may need to be reflowed.
+     */
+    async FontListChanged();
+
+    /**
+     * The font list or prefs have been updated in such a way that we might need
+     * to do a reflow and maybe reframe.
+     */
+    async ForceGlobalReflow(bool aNeedsReframe);
+
+    /**
+     * A new shmem block has been added to the font list; the child process
+     * should map the new block and add to its index.
+     */
+    async FontListShmBlockAdded(uint32_t aGeneration, uint32_t aIndex,
+                                SharedMemoryHandle aHandle);
+
+    async UpdateAppLocales(nsCString[] appLocales);
+    async UpdateRequestedLocales(nsCString[] requestedLocales);
+
+    /**
+     * The system timezone has changed; the child process should ensure that
+     * calls to get the default timezone return the new value.
+     */
+    async SystemTimezoneChanged();
+
+    async UpdateL10nFileSources(L10nFileSourceDescriptor[] sources);
+
+    async RegisterStringBundles(StringBundleDescriptor[] stringBundles);
+
+    async UpdateSharedData(FileDescriptor mapFile, uint32_t aSize,
+                           IPCBlob[] blobs,
+                           nsCString[] changedKeys);
+
+    // nsIPermissionManager messages
+    async AddPermission(Permission permission);
+    async RemoveAllPermissions();
+
+    async FlushMemory(nsString reason);
+
+    async ApplicationBackground();
+    async ApplicationForeground();
+    async GarbageCollect();
+    async CycleCollect();
+    async UnlinkGhosts();
+
+    /**
+     * Start accessibility engine in content process.
+     */
+    async ActivateA11y();
+
+    /**
+     * Shutdown accessibility engine in content process (if not in use).
+     */
+    async ShutdownA11y();
+
+    async AppInfo(nsCString version, nsCString buildID, nsCString name, nsCString UAName,
+                  nsCString ID, nsCString vendor, nsCString sourceURL, nsCString updateURL);
+
+    /**
+     * Send the remote type associated with the content process.
+     */
+    async RemoteType(nsCString aRemoteType, nsCString aProfile);
+
+    /**
+     * Send BlobURLRegistrationData to child process.
+     */
+    async InitBlobURLs(BlobURLRegistrationData[] registrations);
+
+    /**
+     * Send JS{Content, Window}ActorInfos to child process.
+     */
+    async InitJSActorInfos(JSProcessActorInfo[] aContentInfos, JSWindowActorInfo[] aWindowInfos);
+
+    /**
+     * Unregister a previously registered JSWindowActor in the child process.
+     */
+    async UnregisterJSWindowActor(nsCString name);
+
+    /**
+     * Unregister a previously registered JSProcessActor in the child process.
+     */
+    async UnregisterJSProcessActor(nsCString name);
+
+    async SetXPCOMProcessAttributes(XPCOMInitData xpcomInit,
+                                    StructuredCloneData initialData,
+                                    FullLookAndFeel lookAndFeeldata,
+                                    /* used on MacOSX/Linux/Android only: */
+                                    SystemFontList systemFontList,
+                                    SharedMemoryHandle? sharedUASheetHandle,
+                                    uintptr_t sharedUASheetAddress,
+                                    SharedMemoryHandle[] sharedFontListBlocks,
+                                    bool aIsStartingUp);
+
+    // Notify child that last-pb-context-exited notification was observed
+    async LastPrivateDocShellDestroyed();
+
+    async NotifyProcessPriorityChanged(ProcessPriority priority);
+    async MinimizeMemoryUsage();
+
+    /**
+     * Used to manage nsIStyleSheetService across processes.
+     */
+    async LoadAndRegisterSheet(nullable nsIURI uri, uint32_t type);
+    async UnregisterSheet(nullable nsIURI uri, uint32_t type);
+
+    /**
+     * Notify idle observers in the child
+     */
+    async NotifyIdleObserver(uint64_t observerId, nsCString topic, nsString str);
+
+    async InvokeDragSession(MaybeDiscardedWindowContext aSourceWindowContext,
+                            MaybeDiscardedWindowContext aSourceTopWindowContext,
+                            IPCTransferableData[] transfers, uint32_t action);
+
+    async EndDragSession(bool aDoneDrag, bool aUserCancelled,
+                         LayoutDeviceIntPoint aDragEndPoint,
+                         uint32_t aKeyModifiers,
+                         uint32_t aDropEffect);
+
+    async DomainSetChanged(uint32_t aSetType, uint32_t aChangeType, nullable nsIURI aDomain);
+
+    /**
+     * Notify the child that it will soon be asked to shutdown.
+     * This is sent with high priority right before the normal shutdown.
+     */
+    [Priority=control] async ShutdownConfirmedHP();
+
+    /**
+     * Notify the child to shutdown. The child will in turn call FinishShutdown
+     * and let the parent close the channel.
+     */
+    async Shutdown();
+
+    async LoadProcessScript(nsString url);
+
+    /**
+     * Requests a full native update of a native plugin child window. This is
+     * a Windows specific call.
+     */
+    async UpdateWindow(uintptr_t aChildId);
+
+    /**
+     * Notify the child that cache is emptied.
+     */
+    async NotifyEmptyHTTPCache();
+
+    /**
+     * Send a `push` event without data to a service worker in the child.
+     */
+    async Push(nsCString scope, nullable nsIPrincipal principal, nsString messageId);
+
+    /**
+     * Send a `push` event with data to a service worker in the child.
+     */
+    async PushWithData(nsCString scope, nullable nsIPrincipal principal,
+                       nsString messageId, uint8_t[] data);
+
+    /**
+     * Send a `pushsubscriptionchange` event to a service worker in the child.
+     */
+    async PushSubscriptionChange(nsCString scope, nullable nsIPrincipal principal);
+
+    async GetFilesResponse(nsID aID, GetFilesResponseResult aResult);
+
+    async BlobURLRegistration(nsCString aURI, IPCBlob aBlob,
+                              nullable nsIPrincipal aPrincipal,
+                              nsID? aAgentClusterId);
+
+    async BlobURLUnregistration(nsCString aURI);
+
+    async GMPsChanged(GMPCapabilityData[] capabilities);
+
+
+    async ProvideAnonymousTemporaryFile(uint64_t aID, FileDescOrError aFD);
+
+    async SetPermissionsWithKey(nsCString aPermissionKey, Permission[] aPermissions);
+
+    async RefreshScreens(ScreenDetails[] aScreens);
+
+    async ShareCodeCoverageMutex(CrossProcessMutexHandle handle);
+    async FlushCodeCoverageCounters() returns (bool unused);
+
+    /*
+     * IPC message to enable the input event queue on the main thread of the
+     * content process.
+     */
+    async SetInputEventQueueEnabled();
+
+    /*
+     * IPC message to flush the input event queue on the main thread of the
+     * content process.
+     *
+     * When the ContentParent stops sending the input event with input priority,
+     * there may be some pending events in the input event queue and normal
+     * event queue. Here is a possible scenario.
+     * R: Runnables.
+     * D: Enable the input priority event.
+     * E: Disable the input priority evnet.
+     *
+     *                     D       E
+     * Normal Queue: R1      R2      R3
+     * Input Queue:     II      I2      I3
+     *
+     * To avoid the newly added normal events (e.g. R2, which may be an input
+     * event) preempt the pending input events (e.g. I1), or the newly added
+     * input events (e.g. I3) preempt the pending normal events (e.g. R2), we
+     * have to flush all pending events before enabling and disabling the input
+     * priority event.
+     *
+     * To flush the normal event queue and the input event queue, we use three
+     * IPC messages as the followings.
+     * FI: Flush the input queue.
+     * SI: Suspend the input queue.
+     * RI: Resume the input queue.
+     *
+     * Normal Queue: R1    FI    RI R2   FI    RI R3
+     * Input Queue:     II    SI      I2    SI       I3
+     *
+     * When the flush input request is processed before the other two requests,
+     * we consume all input events until the suspend request. After handling the
+     * suspend request, we stop consuming the input events until the resume
+     * request to make sure we consume all pending normal events.
+     *
+     * If we process the suspend request before the other two requests, we
+     * ignore the flush request and consume all pending normal events until the
+     * resume request.
+     */
+    async FlushInputEventQueue();
+
+    /*
+     * IPC message to resume consuming the pending events in the input event
+     * queue.
+     */
+    async ResumeInputEventQueue();
+
+    /*
+     * IPC message to suspend consuming the pending events in the input event
+     * queue.
+     */
+    [Priority=input] async SuspendInputEventQueue();
+
+    /*
+     * IPC message to propagate dynamic scalar definitions, added after the
+     * content process is spawned, from the parent to the child.
+     * Dynamic scalar definitions added at the process startup are handled
+     * using the |TelemetryIPC::AddDynamicScalarDefinitions| functions.
+     */
+    async AddDynamicScalars(DynamicScalarDefinition[] definitions);
+
+    // This message is sent to content processes, and triggers the creation of a
+    // new HttpChannelChild that will be connected to the parent channel
+    // represented by registrarId.
+    // This is on PContent not PNecko, as PNecko may not be initialized yet.
+    // The returned loadInfo needs to be set on the channel - since the channel
+    // moved to a new process it now has different properties.
+
+    async CrossProcessRedirect(RedirectToRealChannelArgs args,
+                               Endpoint<PStreamFilterParent>[] aEndpoint)
+        returns (nsresult rv);
+
+    /**
+    * This method is used to notifty content process to start delayed autoplay
+    * media via browsing context.
+    */
+    async StartDelayedAutoplayMediaComponents(MaybeDiscardedBrowsingContext aContext);
+
+    /**
+     * This method is used to dispatch MediaControlAction to content process in
+     * order to control media within a specific browsing context tree.
+     */
+    async UpdateMediaControlAction(MaybeDiscardedBrowsingContext aContext,
+                                   MediaControlAction aAction);
+
+    // Begin subscribing to a new BrowsingContextGroup, sending down the current
+    // value for every individual BrowsingContext.
+    async RegisterBrowsingContextGroup(uint64_t aGroupId, SyncedContextInitializer[] aInits);
+
+    // The BrowsingContextGroup has been destroyed in the parent process. The
+    // content process won't destroy the group until it receives this message or
+    // during shutdown.
+    //
+    // When the content process receives this message, all contexts in the group
+    // should have already been destroyed.
+    async DestroyBrowsingContextGroup(uint64_t aGroupId);
+
+#if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
+    // Initialize top-level actor for testing content process sandbox.
+    async InitSandboxTesting(Endpoint<PSandboxTestingChild> aEndpoint);
+#endif
+
+    async LoadURI(MaybeDiscardedBrowsingContext aContext, nsDocShellLoadState aLoadState, bool aSetNavigating)
+        returns (bool aSuccess);
+
+    async InternalLoad(nsDocShellLoadState aLoadState);
+
+    async DisplayLoadError(MaybeDiscardedBrowsingContext aContext, nsString aURI);
+
+    async GoBack(MaybeDiscardedBrowsingContext aContext, int32_t? aCancelContentJSEpoch, bool aRequireUserInteraction, bool aUserActivation);
+    async GoForward(MaybeDiscardedBrowsingContext aContext, int32_t? aCancelContentJSEpoch, bool aRequireUserInteraction, bool aUserActivation);
+    async GoToIndex(MaybeDiscardedBrowsingContext aContext, int32_t aIndex, int32_t? aCancelContentJSEpoch, bool aUserActivation);
+    async Reload(MaybeDiscardedBrowsingContext aContext, uint32_t aReloadFlags);
+    async StopLoad(MaybeDiscardedBrowsingContext aContext, uint32_t aStopFlags);
+
+    async OnAllowAccessFor(MaybeDiscardedBrowsingContext aParentContext,
+                           nsCString aTrackingOrigin,
+                           uint32_t aCookieBehavior,
+                           StorageAccessPermissionGrantedReason aReason);
+
+    async OnContentBlockingDecision(MaybeDiscardedBrowsingContext aContext,
+                                    BlockingDecision aReason,
+                                    uint32_t aRejectedReason);
+
+    /**
+     * Abort orientationPendingPromises for documents in the child which
+     * are part of a BrowsingContextGroup.
+     */
+    async AbortOrientationPendingPromises(MaybeDiscardedBrowsingContext aContext);
+
+    async HistoryCommitIndexAndLength(MaybeDiscardedBrowsingContext aContext,
+                                      uint32_t aIndex, uint32_t aLength,
+                                      nsID aChangeID);
+
+    async GetLayoutHistoryState(MaybeDiscardedBrowsingContext aContext)
+        returns (nullable nsILayoutHistoryState aState, Wireframe? aWireframe);
+
+    async DispatchLocationChangeEvent(MaybeDiscardedBrowsingContext aContext);
+
+    // Dispatches a "beforeunload" event to each in-process content window in the
+    // subtree beginning at `aStartingAt`, and returns the result as documented in
+    // the `PermitUnloadResult` enum.
+    async DispatchBeforeUnloadToSubtree(MaybeDiscardedBrowsingContext aStartingAt)
+        returns (PermitUnloadResult result);
+
+    // Update the cached list of codec supported in the given process.
+    async UpdateMediaCodecsSupported(RemoteDecodeIn aLocation, MediaCodecsSupported aSupported);
+
+    // Send the list of the supported mimetypes in the given process. GeckoView-specific
+    async DecoderSupportedMimeTypes(nsCString[] supportedTypes);
+
+    // Used to initialize the global variable in content processes with the
+    // latched value in the parent process. See dom/LocalStorageCommon.h for more
+    // details.
+    async InitNextGenLocalStorageEnabled(bool enabled);
+
+  async PRemotePrintJob();
+
+parent:
+
+    async SynchronizeLayoutHistoryState(MaybeDiscardedBrowsingContext aContext,
+                                        nullable nsILayoutHistoryState aState);
+
+    async SessionHistoryEntryTitle(MaybeDiscardedBrowsingContext aContext,
+                                   nsString aTitle);
+
+    async SessionHistoryEntryScrollRestorationIsManual(MaybeDiscardedBrowsingContext aContext,
+                                                       bool aIsManual);
+    async SessionHistoryEntryScrollPosition(MaybeDiscardedBrowsingContext aContext,
+                                            int32_t aX, int32_t aY);
+
+    async SessionHistoryEntryCacheKey(MaybeDiscardedBrowsingContext aContext,
+                                      uint32_t aCacheKey);
+
+    async SessionHistoryEntryStoreWindowNameInContiguousEntries(MaybeDiscardedBrowsingContext aContext,
+                                                                nsString aName);
+
+    async SessionHistoryEntryWireframe(MaybeDiscardedBrowsingContext aContext,
+                                       Wireframe aWireframe);
+
+    async GetLoadingSessionHistoryInfoFromParent(MaybeDiscardedBrowsingContext aContext)
+        returns (LoadingSessionHistoryInfo? aLoadingInfo);
+
+    async RemoveFromBFCache(MaybeDiscardedBrowsingContext aContext);
+
+    async InitBackground(Endpoint<PBackgroundStarterParent> aEndpoint);
+
+    async CreateGMPService();
+
+    async InitStreamFilter(uint64_t channelId, nsString addonId)
+        returns (Endpoint<PStreamFilterChild> aEndpoint);
+
+    async PRemoteSpellcheckEngine();
+
+    async InitCrashReporter(NativeThreadId tid);
+
+    sync IsSecureURI(nullable nsIURI aURI, OriginAttributes aOriginAttributes)
+        returns (bool isSecureURI);
+
+    async AccumulateMixedContentHSTS(nullable nsIURI aURI, bool aActive,
+                                     OriginAttributes aOriginAttributes);
+
+    [Nested=inside_cpow] async PHal();
+
+    async PHeapSnapshotTempFileHelper();
+
+    async PNecko();
+
+#ifdef MOZ_WEBSPEECH
+    async PSpeechSynthesis();
+#endif
+
+    async PMedia();
+
+#ifdef MOZ_WEBRTC
+    async PWebrtcGlobal();
+#endif
+
+    async CreateAudioIPCConnection() returns (FileDescOrError fd);
+
+    sync PURLClassifier(nullable nsIPrincipal principal)
+        returns (bool success);
+
+    async PURLClassifierLocal(nullable nsIURI uri, IPCURLClassifierFeature[] features);
+
+    async PLoginReputation(nullable nsIURI formURI);
+
+    async PSessionStorageObserver();
+
+    async PBenchmarkStorage();
+
+    // Services remoting
+
+    async StartVisitedQueries(nullable nsIURI[] uri);
+    async SetURITitle(nullable nsIURI uri, nsString title);
+
+    async LoadURIExternal(nullable nsIURI uri,
+                          nullable nsIPrincipal triggeringPrincipal,
+                          nullable nsIPrincipal redirectPrincipal,
+                          MaybeDiscardedBrowsingContext browsingContext,
+                          bool wasExternallyTriggered,
+                          bool hasValidUserGestureActivation);
+    async ExtProtocolChannelConnectParent(uint64_t registrarId);
+
+    // PrefService message
+    sync GetGfxVars() returns (GfxVarUpdate[] vars);
+
+    sync SyncMessage(nsString aMessage, ClonedMessageData aData)
+      returns (StructuredCloneData[] retval);
+
+    async ShowAlert(nullable nsIAlertNotification alert);
+
+    async CloseAlert(nsString name, bool contextClosed);
+
+    async DisableNotifications(nullable nsIPrincipal principal);
+
+    async OpenNotificationSettings(nullable nsIPrincipal principal);
+
+    async AddSecurityState(MaybeDiscardedWindowContext aContext, uint32_t aStateFlags);
+
+    // Request that the ServiceWorkerManager in the parent process create a
+    // notification "click" or "close" event and dispatch it on the relevant
+    // ServiceWorker. This needs to happen because when a notification is
+    // created it is tied to a specific content process and when the user clicks
+    // on the notification, it will be that content process that is notified.
+    // However, even if the ServiceWorker lives in that process (it may no
+    // longer be in that process, or may have never lived there), the right/only
+    // way to talk through the ServiceWorker is through the parent.
+    //
+    // This happens on PContent because the ServiceWorkerManager lives on the
+    // main thread and bouncing this off of PBackground would be silly and
+    // complex. In the long run, the notification implementation will be
+    // overhauled to directly process the notification click/close and directly
+    // translate that to a ServiceWorker event.
+    async NotificationEvent(nsString type, NotificationEventData data);
+
+    // Creates a helper for forwarding data from an nsExternalAppHandler
+    // running in the content process, to one running in the parent
+    // process.
+    // Bug 1574372 aims to run nsExternalAppHandler entirely in the
+    // parent so that we can remove this.
+    //
+    // Serializes the uri, loadInfo, contentType, referrer, contentDisposition
+    // headers and contentLength of the channel so that we can make them
+    // available to the parent instance via a nsIChannel helper. Also
+    // passes whether the original channel was an instance of nsIFileChannel.
+    //
+    // aContext is the BrowsingContext that initiated the load, and created the
+    // channel.
+    //
+    // Pass true for aForceSave to always save this content to disk, regardless of
+    // nsIMIMEInfo and other such influences.
+    // Pass true for aShouldCloseWindow to specify that aContext was opened specifically
+    // for this load, and should be closed once we've handled it.
+    async PExternalHelperApp(nullable nsIURI uri,
+                             LoadInfoArgs? loadInfoArgs,
+                             nsCString aMimeContentType,
+                             nsCString aContentDisposition,
+                             uint32_t aContentDispositionHint,
+                             nsString aContentDispositionFilename,
+                             bool aForceSave,
+                             int64_t aContentLength,
+                             bool aWasFileChannel,
+                             nullable nsIURI aReferrer,
+                             MaybeDiscardedBrowsingContext aContext,
+                             bool aShouldCloseWindow);
+
+    async PHandlerService();
+
+    async AddGeolocationListener(bool highAccuracy);
+    async RemoveGeolocationListener();
+    async SetGeolocationHigherAccuracy(bool enable);
+
+    async ConsoleMessage(nsString message);
+    async ScriptErrorWithStack(nsString message, nsString sourceName, nsString sourceLine,
+                               uint32_t lineNumber, uint32_t colNumber, uint32_t flags,
+                               nsCString category, bool privateWindow,
+                               bool fromChromeContext, ClonedMessageData stack);
+
+    // Places the items within dataTransfer on the clipboard.
+    async SetClipboard(IPCTransferable aTransferable,
+                       int32_t aWhichClipboard);
+
+    // Given a list of supported types, returns the clipboard data for the
+    // first type that matches.
+    sync GetClipboard(nsCString[] aTypes, int32_t aWhichClipboard)
+        returns (IPCTransferableData transferableData);
+
+    // Returns a list of formats supported by the clipboard
+    sync GetExternalClipboardFormats(int32_t aWhichClipboard, bool aPlainTextOnly) returns (nsCString[] aTypes);
+
+    // Given a list of supported types, returns the clipboard data for the
+    // first type that matches.
+    async GetClipboardAsync(nsCString[] aTypes, int32_t aWhichClipboard) returns (IPCTransferableDataOrError transferableData);
+
+    // Clears the clipboard.
+    async EmptyClipboard(int32_t aWhichClipboard);
+
+    // Returns true if data of one of the specified types is on the clipboard.
+    sync ClipboardHasType(nsCString[] aTypes, int32_t aWhichClipboard)
+        returns (bool hasType);
+
+    // Given a list of supported types, returns a list of types that clipboard
+    // constains the data for the specified type.
+    async ClipboardHasTypesAsync(nsCString [] aTypes, int32_t aWhichClipboard)
+        returns (nsCString [] types);
+
+    /**
+     * Notify the parent that the child has started a clipboard write request,
+     * and that the data will be sent over another IPC message once it is ready.
+     * @param  aClipboardType
+     *         The clipboard type defined in nsIClipboard.
+     */
+    async PClipboardWriteRequest(int32_t aClipboardType);
+
+    // 'Play', 'Beep' and 'PlayEventSound' are the only nsISound methods used in
+    // the content process.
+    [Compress] async PlaySound(nullable nsIURI aURL);
+    [Compress] async Beep();
+    [Compress] async PlayEventSound(uint32_t aEventId);
+
+    sync GetIconForExtension(nsCString aFileExt, uint32_t aIconSize)
+        returns (uint8_t[] bits);
+
+    // Tell the parent that the child has gone idle for the first time.
+    async FirstIdle();
+
+    async CopyFavicon(nullable nsIURI oldURI, nullable nsIURI newURI, bool isPrivate);
+
+    async FindImageText(IPCImage image, nsCString[] languages)
+        returns (TextRecognitionResultOrError result);
+
+    /**
+     * Notifies the parent about a recording device is starting or shutdown.
+     * @param recordingStatus starting or shutdown
+     * @param pageURL URL that request that changing the recording status
+     * @param isAudio recording start with microphone
+     * @param isVideo recording start with camera
+     */
+    async RecordingDeviceEvents(nsString recordingStatus,
+                                nsString pageURL,
+                                bool isAudio,
+                                bool isVideo);
+
+    // Graphics errors
+    async GraphicsError(nsCString aError);
+
+    // Driver crash guards. aGuardType must be a member of CrashGuardType.
+    sync BeginDriverCrashGuard(uint32_t aGuardType) returns (bool crashDetected);
+    sync EndDriverCrashGuard(uint32_t aGuardType);
+
+    async AddIdleObserver(uint64_t observerId, uint32_t idleTimeInS);
+    async RemoveIdleObserver(uint64_t observerId, uint32_t idleTimeInS);
+
+    /**
+     * This message is only used on X11 platforms.
+     *
+     * Send a dup of the plugin process's X socket to the parent
+     * process.  In theory, this scheme keeps the plugin's X resources
+     * around until after both the plugin process shuts down *and* the
+     * parent process closes the dup fd.  This is used to prevent the
+     * parent process from crashing on X errors if, e.g., the plugin
+     * crashes *just before* a repaint and the parent process tries to
+     * use the newly-invalid surface.
+     */
+    async BackUpXResources(FileDescriptor aXSocketFd);
+
+    async RequestAnonymousTemporaryFile(uint64_t aID);
+
+    /**
+     * Notifies the parent that the child needs no more ForceKill dump.
+     */
+    [Priority=control] async NotifyShutdownSuccess();
+
+    /**
+     * Notifies the parent to continue shutting down after the child performs
+     * its shutdown tasks.
+     */
+    async FinishShutdown();
+
+    async UpdateDropEffect(uint32_t aDragAction, uint32_t aDropEffect);
+
+    /**
+     * Initiates an asynchronous request for permission for the
+     * provided principal.
+     *
+     * @param aRequests
+     *   The array of permissions to request.
+     * @param aPrincipal
+     *   The principal of the request.
+     * @param aTopLevelPrincipal
+     *   The principal of the top level page the request comes from.
+     * @param tabId
+     *   To identify which tab issues this request.
+     *
+     * NOTE: The principal is untrusted in the parent process. Only
+     *       principals that can live in the content process should
+     *       provided.
+     */
+    async PContentPermissionRequest(PermissionRequest[] aRequests,
+                                    nullable nsIPrincipal aPrincipal,
+                                    nullable nsIPrincipal aTopLevelPrincipal,
+                                    bool aIsHandlingUserInput,
+                                    bool aMaybeUnsafePermissionDelegate,
+                                    TabId tabId);
+
+    /**
+     * If the profiler is running when the process shuts down, this sends the
+     * profile data collected so far.
+     *
+     * @param aProfile
+     *   This may contain an empty string (unknown issue), an error message
+     *   starting with '*', or a profile as a stringified JSON object.
+     */
+    async ShutdownProfile(nsCString aProfile);
+
+    /**
+     * This sends any collected perf stats data on shutdown.
+     */
+    async ShutdownPerfStats(nsCString aPerfStats);
+
+    /**
+     * Request graphics initialization information from the parent.
+     */
+    sync GetGraphicsDeviceInitData()
+        returns (ContentDeviceData aData);
+
+    /**
+     * Request a buffer containing the contents of the output color profile.
+     * If set, this is the file pointed to by
+     * gfx.color_management.display_profile, otherwise it contains a
+     * platform-specific default
+     */
+    sync GetOutputColorProfileData()
+        returns (uint8_t[] aOutputColorProfileData);
+
+    /**
+     * A shared font list (see gfx/thebes/SharedFontList.*) contains a list
+     * of shared-memory blocks that are used to store all the font list data.
+     * The font list created in the parent process is the only one that can
+     * create or store objects into the shared memory; content processes font
+     * lists have read-only access to it.
+     *
+     * To minimize the cost of record allocations, the shared font list
+     * bump-allocates new objects that it adds to the shared memory blocks
+     * (i.e. the records stored in the shared memory blocks are only ever
+     * appended, and never freed except when the entire font list is
+     * reconstructed).
+     *
+     * When initially created by the parent process, the font list may contain
+     * nothing except a header, and the list of the system's installed font
+     * family names. Additional data about the families (styled faces available
+     * and character coverage) is appended to the font list during the session
+     * as a given font is considered for use, because loading all data for all
+     * installed fonts during startup is too expensive/slow.
+     *
+     * During content process launch, a content process's first step in
+     * gaining access to the font list is to call GetFontListShmBlock,
+     * passing index zero in order to get access to the first block, which
+     * contains the font list header and the list of font-family records
+     * (which may be virtually all uninitialized at this time, containing
+     * nothing but the family names). Once a content process determines a
+     * font-family name it wants to use (e.g. from a CSS font-family list, or
+     * from preferences), if that Family record has not yet been initialized,
+     * it will call InitializeFamily (below) to have the parent process
+     * populate Face records in the shared memory with the family's styles.
+     * The content process can then pick the face with best style match from
+     * the available faces according to the CSS font matching algorithm, load
+     * its character map, then send the map to the parent process using
+     * SetCharacterMap (so that the parent process can share the map with all
+     * processes to avoid duplication of work).
+     *
+     * At some point, as the parent process adds data to the font list, a new
+     * shared-memory block will probably be needed. At that point the parent
+     * will create a new block and append it to its share memory block list.
+     * The new Block index will start to appear in Pointer records in the
+     * shared memory, and the content process's can then fetch those other
+     * blocks using this function as needed.
+     *
+     * @param aGeneration
+     *   The font list has a Generation ID stored in its Header, and any time
+     *   the parent process needs to reinitialize the list (because of a change
+     *   in the available font repertoire) a new Generation ID is assigned.
+     *   Content processes pass the Generation of the list they're using in
+     *   all messages, so that the parent can recognize if they're out of date
+     *   and safely ignore such messages. (When the parent rebuilds the list,
+     *   it will notify all content processes, but they may still send a few
+     *   messages that relate to the obsolete list before they have processed
+     *   this notification.)
+     * @param aIndex
+     *   (Zero-based) index of the shared-memory block to be mapped.
+     *   In a typical case, there will be a handful of blocks altogether, so
+     *   each content process only needs to make this request a few times.
+     * @returns aHandle
+     *   Handle that can be used to construct a SharedMemory that maps the
+     *   requested block of memory.
+     *   If aGeneration does not match the parent's font list generation ID, or
+     *   if requesting a block that does not exist (i.e. with aIndex greater
+     *   than or equal to the number of blocks actually in existence), returns
+     *   a null handle.
+     *
+     * This is a sync message because the content process needs font data in
+     * order to perform font-matching (e.g. during reflow), and cannot continue
+     * until it has mapped the font-list memory.
+     */
+    sync GetFontListShmBlock(uint32_t aGeneration, uint32_t aIndex)
+        returns (SharedMemoryHandle aHandle);
+
+    /**
+     * Ask the parent to initialize a given font family, so that face metadata
+     * will be available. Content processes will only call this for families
+     * where the Face data has not yet been populated, so it will generally be
+     * called no more than once per family. (It may not be needed at all, if
+     * the parent process has already initialized the families that content
+     * wants to use.)
+     *
+     * @param aGeneration
+     *   Font-list generation, so requests relating to an obsolete list can be
+     *   ignored (see comments for GetFontListShmBlock).
+     * @param aFamilyIndex
+     *   The 0-based index of the Family within the font-list that a content
+     *   process needs to use.
+     * @param aLoadCmaps
+     *   If true, the parent should eagerly load character maps for the faces
+     *   in the family.
+     *
+     * This is a sync message because the content process cannot complete its
+     * font-matching until the family is fully populated with Face records.
+     * If we make it async, content processes will reflow using fallbacks,
+     * and then have to reflow again once all the font information needed
+     * becomes available.
+     */
+    sync InitializeFamily(uint32_t aGeneration, uint32_t aFamilyIndex,
+                          bool aLoadCmaps);
+
+    /**
+     * Record the character map of a given Face in the font list.
+     *
+     * @param aGeneration
+     *   Font-list generation, so requests relating to an obsolete list can be
+     *   ignored (see comments for GetFontListShmBlock).
+     * @param aFacePtr
+     *   Font-list shared-memory "pointer" to the Face record to be updated.
+     *   A Pointer is a record of a shared-memory block index and an offset
+     *   within that block, which each process that maps the block can convert
+     *   into a real pointer in its address space.
+     * @param aMap
+     *   The character coverage map of the face. (This will be stored as a
+     *   SharedBitSet record within the shared font list, and the Face record
+     *   will be updated to reference it.)
+     */
+    async SetCharacterMap(uint32_t aGeneration, Pointer aFacePtr, gfxSparseBitSet aMap);
+
+    /**
+     * Ask the parent to set up the merged charmap for a family, to accelerate
+     * future fallback searches.
+     * aFamilyPtr may refer to an element of either the Families() or AliasFamilies().
+     */
+    async SetupFamilyCharMap(uint32_t aGeneration, Pointer aFamilyPtr);
+
+    /**
+     * Ask the parent to try and complete the InitOtherFamilyNames task, because
+     * we're trying to look up a localized font name. This is a sync method so that
+     * the update will be available before the child continues reflow; however, it
+     * is possible the task will have timed-out in the parent and not actually
+     * completed during this call.
+     *
+     * @param aGeneration
+     *   Font-list generation, so requests relating to an obsolete list can be
+     *   ignored (see comments for GetFontListShmBlock).
+     * @param aDefer
+     *   Parameter aDeferOtherFamilyNamesLoading to be passed to
+     *   gfxPlatformFontList::InitOtherFamilyNames, to determine whether name
+     *   loading should be deferred to a background task or run immediately.
+     * @param aLoaded
+     *   Returns whether the font name loading process has completed.
+     *
+     * TODO: This is currently a sync message but can probably be made async,
+     * at the cost of an increased chance of some testcases failing because
+     * they depend on lazily-loaded font names.
+     */
+    sync InitOtherFamilyNames(uint32_t aGeneration, bool aDefer) returns (bool aLoaded);
+
+    /**
+     * Ask the parent to load all font character maps, as we need to do an
+     * exhaustive font-fallback search. This is done asynchronously; when it
+     * finishes, the parent will trigger global reflow so that font selection
+     * is re-done in all content, making use of the newly-loaded cmaps.
+     * Normally this will only happen once per browser session (unless the
+     * font list is rebuilt due to installation/removal of system fonts).
+     *
+     * @param aGeneration
+     *   Font-list generation, so requests relating to an obsolete list can be
+     *   ignored (see comments for GetFontListShmBlock).
+     * @param aStartIndex
+     *   The family index to start from; the sender has determined that cmaps
+     *   up to this point are already loaded.
+     */
+    async StartCmapLoading(uint32_t aGeneration, uint32_t aStartIndex);
+
+    /**
+     * Ask the parent for a specific hyphenation resource (identified by URI)
+     * as a shared memory block.
+     *
+     * This is a sync method because at the point where a content process finds
+     * that it requires a particular hyphenation dictionary, this is blocking
+     * reflow; making it async would require scheduling another reflow after
+     * the resource is available, and a possible layout "jump" as line-breaks
+     * change. Note that the content process retains a reference to each such
+     * resource it requests, so it will only make this call once per locale for
+     * which hyphenation data exists.
+     *
+     * @param aURI
+     *   The URI (which currently must always point to an omnijar resource)
+     *   for the required hyphenation dictionary.
+     * @param aHandle
+     *   Returns the shmem handle to the resource (or an invalid shmem handle
+     *   in case of failure).
+     * @param aLoaded
+     *   Returns the size in bytes of the resource.
+     */
+    sync GetHyphDict(nullable nsIURI aURI) returns (SharedMemoryHandle aHandle, uint32_t aSize);
+
+    async CreateWindow(PBrowser aThisTab,
+                       MaybeDiscardedBrowsingContext aParent,
+                       PBrowser aNewTab,
+                       uint32_t aChromeFlags,
+                       bool aCalledFromJS,
+                       bool aForPrinting,
+                       bool aForWindowDotPrint,
+                       nullable nsIURI aURIToLoad,
+                       nsCString aFeatures,
+                       nullable nsIPrincipal aTriggeringPrincipal,
+                       nullable nsIContentSecurityPolicy aCsp,
+                       nullable nsIReferrerInfo aReferrerInfo,
+                       OriginAttributes aOriginAttributes)
+        returns (CreatedWindowInfo window);
+
+    async CreateWindowInDifferentProcess(
+      PBrowser aThisTab,
+      MaybeDiscardedBrowsingContext aParent,
+      uint32_t aChromeFlags,
+      bool aCalledFromJS,
+      nullable nsIURI aURIToLoad,
+      nsCString aFeatures,
+      nsString aName,
+      nullable nsIPrincipal aTriggeringPrincipal,
+      nullable nsIContentSecurityPolicy aCsp,
+      nullable nsIReferrerInfo aReferrerInfo,
+      OriginAttributes aOriginAttributes);
+
+    sync RemovePermission(nullable nsIPrincipal principal, nsCString permissionType) returns (nsresult rv);
+
+    /**
+     * Tell the parent that a decoder's' benchmark has been completed.
+     * The result can then be stored in permanent storage.
+     */
+    async NotifyBenchmarkResult(nsString aCodecName, uint32_t aDecodeFPS);
+
+    /**
+     * Notify `push-message` observers without data in the parent.
+     */
+    async NotifyPushObservers(nsCString scope, nullable nsIPrincipal principal,
+                              nsString messageId);
+
+    /**
+     * Notify `push-message` observers with data in the parent.
+     */
+    async NotifyPushObserversWithData(nsCString scope, nullable nsIPrincipal principal,
+                                      nsString messageId, uint8_t[] data);
+
+    /**
+     * Notify `push-subscription-change` observers in the parent.
+     */
+    async NotifyPushSubscriptionChangeObservers(nsCString scope,
+                                                nullable nsIPrincipal principal);
+
+     async GetFilesRequest(nsID aID, nsString aDirectory, bool aRecursiveFlag);
+     async DeleteGetFilesRequest(nsID aID);
+
+     async StoreAndBroadcastBlobURLRegistration(nsCString url, IPCBlob blob,
+                                                nullable nsIPrincipal principal,
+                                                nsID? aAgentClusterId);
+
+     async UnstoreAndBroadcastBlobURLUnregistration(nsCString url, nullable nsIPrincipal principal);
+
+    /**
+     * Messages for communicating child Glean data to the parent process
+     */
+    async RecordPageLoadEvent(PageLoadExtra event);
+
+    /**
+     * Messages for communicating child Telemetry to the parent process
+     */
+    async AccumulateChildHistograms(HistogramAccumulation[] accumulations);
+    async AccumulateChildKeyedHistograms(KeyedHistogramAccumulation[] accumulations);
+    async UpdateChildScalars(ScalarAction[] updates);
+    async UpdateChildKeyedScalars(KeyedScalarAction[] updates);
+    async RecordChildEvents(ChildEventData[] events);
+    async RecordDiscardedData(DiscardedData data);
+
+    async AddMemoryReport(MemoryReport aReport);
+
+    async BHRThreadHang(HangDetails aHangDetails);
+
+    async AddPerformanceMetrics(nsID aID, PerformanceInfo[] aMetrics);
+
+    /*
+     * Adds a certificate exception for the given hostname and port.
+     */
+    async AddCertException(nullable nsIX509Cert aCert, nsCString aHostName,
+                           int32_t aPort, OriginAttributes aOriginAttributes,
+                           bool aIsTemporary)
+          returns (nsresult success);
+
+    /*
+     * Determines whether storage access can be granted automatically by the
+     * storage access API without showing a user prompt.
+     */
+    async AutomaticStorageAccessPermissionCanBeGranted(nullable nsIPrincipal aPrincipal)
+          returns (bool success);
+
+    /*
+     * A 3rd party tracking origin (aTrackingOrigin) has received the permission
+     * granted to have access to aGrantedOrigin when loaded by aParentWindowId.
+     */
+    async StorageAccessPermissionGrantedForOrigin(uint64_t aTopLevelWindowId,
+                                                  MaybeDiscardedBrowsingContext aParentContext,
+                                                  nullable nsIPrincipal aTrackingPrincipal,
+                                                  nsCString aTrackingOrigin,
+                                                  int aAllowMode,
+                                                  StorageAccessPermissionGrantedReason? aReason)
+          returns (bool unused);
+
+    async CompleteAllowAccessFor(MaybeDiscardedBrowsingContext aParentContext,
+                                 uint64_t aTopLevelWindowId,
+                                 nullable nsIPrincipal aTrackingPrincipal,
+                                 nsCString aTrackingOrigin,
+                                 uint32_t aCookieBehavior,
+                                 StorageAccessPermissionGrantedReason aReason)
+          returns (StorageAccessPromptChoices? choice);
+
+    async SetAllowStorageAccessRequestFlag(
+                                 nullable nsIPrincipal aEmbeddingPrincipal,
+                                 nullable nsIURI aEmbeddedOrigin)
+          returns (bool success);
+
+    async TestAllowStorageAccessRequestFlag(
+                                 nullable nsIPrincipal aEmbeddedPrincipal,
+                                 nullable nsIURI aEmbeddingOrigin)
+          returns (bool success);
+
+    async StoreUserInteractionAsPermission(nullable nsIPrincipal aPrincipal);
+
+    async TestCookiePermissionDecided(MaybeDiscardedBrowsingContext aContext,
+                         nullable nsIPrincipal aPrincipal)
+          returns (bool? allowed);
+
+    async TestStorageAccessPermission(nullable nsIPrincipal aEmbeddingPrincipal,
+                         nsCString aEmbeddedOrigin)
+          returns (bool? allowed);
+
+   /**
+    * When media element's controlled state changed in the content process, we
+    * have to notify the chrome process in order to update the status of the
+    * corresponding media controller, which is used to control all media in the
+    * certain tab. We would use the browsing context to find the corresponding
+    * controller.
+    */
+    async NotifyMediaPlaybackChanged(MaybeDiscardedBrowsingContext aContext,
+                                     MediaPlaybackState aState);
+
+   /**
+    * When media became audible or inaudible in content process, we have to
+    * notify chrome process in order to which tab is audible.
+    */
+    async NotifyMediaAudibleChanged(MaybeDiscardedBrowsingContext aContext,
+                                    MediaAudibleState aState);
+
+   /**
+    * When media enabled or disabled the Picture-in-Picture mode, we have to
+    * update that to the media controller in the chrome process.
+    */
+    async NotifyPictureInPictureModeChanged(
+        MaybeDiscardedBrowsingContext aContext, bool aEnabled);
+
+   /**
+    * This method is used to update media session's status when it's being
+    * created or destroyed.
+    */
+    async NotifyMediaSessionUpdated(MaybeDiscardedBrowsingContext aContext, bool aIsCreated);
+
+    /**
+     * This method is used to update media session's media metadata whenever its
+     * metadata is being updated.
+     */
+    async NotifyUpdateMediaMetadata(MaybeDiscardedBrowsingContext aContext,
+                                    MediaMetadataBase? aMetadata);
+
+    /**
+     * This method is used to update media session's playback state whenever its
+     * playback state is changed.
+     */
+    async NotifyMediaSessionPlaybackStateChanged(
+        MaybeDiscardedBrowsingContext aContext,
+        MediaSessionPlaybackState aMetadata);
+
+    /**
+     * This method is used to update media session's supported media session
+     * action when the action becomes supported or unsupported.
+     */
+    async NotifyMediaSessionSupportedActionChanged(
+        MaybeDiscardedBrowsingContext aContext,
+        MediaSessionAction aAction,
+        bool aEnabled);
+
+    /**
+     * This method is used to notify the media controller in chrome process that
+     * the media element in the browsing context entered fullscreen.
+     */
+    async NotifyMediaFullScreenState(
+        MaybeDiscardedBrowsingContext aContext,
+        bool aIsInFullScreen);
+
+    /**
+     * This method is used to update media session's position state whenever its
+     * position state is being updated.
+     */
+    async NotifyPositionStateChanged(
+        MaybeDiscardedBrowsingContext aContext,
+        PositionState aState);
+
+    /**
+     * This method will make canonical browsing context to update the count of
+     * callers which want to keep the page from being suspended even if the page
+     * is inactive.
+     */
+    async AddOrRemovePageAwakeRequest(MaybeDiscardedBrowsingContext aContext,
+                                      bool aShouldAddCount);
+
+#if defined(XP_WIN)
+    /**
+     * Due to sandboxing, a child process's UntrustedModulesProcessor cannot
+     * obtain enough information about a DLL file to determine its
+     * trustworthiness. This API asks the chrome process to perform that
+     * evaluation.
+     */
+    async GetModulesTrust(ModulePaths aModPaths, bool aRunAtNormalPriority)
+        returns (ModulesMapResult? modMapResult);
+#endif  // defined(XP_WIN)
+
+    /**
+     * Used to route shutdown diagnostic info from the content process
+     * ServiceWorkers to the parent process' ServiceWorkerManager's
+     * ServiceWorkerShutdownBlocker. (The only other actor chain available
+     * for this would be very convoluted and create ordering problems).
+     */
+    async ReportServiceWorkerShutdownProgress(uint32_t aShutdownStateId,
+                                              Progress aProgress);
+
+    /**
+     * Whenever a document is updating the OrientationLock, we need to
+     * reject the orientationPendingPromises in other processes.
+     */
+    async AbortOtherOrientationPendingPromises(MaybeDiscardedBrowsingContext aContext);
+
+    async HistoryReload(MaybeDiscardedBrowsingContext aContext, uint32_t aReloadFlags);
+
+    async NotifyOnHistoryReload(MaybeDiscardedBrowsingContext aContext,
+                                bool aForceReload)
+            returns (bool canReload, nsDocShellLoadState? loadState,
+                     bool? reloadActiveEntry);
+
+    async HistoryCommit(MaybeDiscardedBrowsingContext aContext,
+                        uint64_t aLoadID, nsID aChangeID, uint32_t aLoadType,
+                        bool aPersist, bool aCloneEntryChildren,
+                        bool aChannelExpired, uint32_t aCacheKey);
+
+    async HistoryGo(MaybeDiscardedBrowsingContext aContext, int32_t aOffset,
+                    uint64_t aHistoryEpoch, bool aRequireUserInteraction,
+                    bool aUserActivation) returns(int32_t? requestedIndex);
+
+    async BlobURLDataRequest(nsCString aBlobURL,
+                             nullable nsIPrincipal aTriggeringPrincipal,
+                             nullable nsIPrincipal aLoadingPrincipal,
+                             OriginAttributes aOriginAttributes,
+                             uint64_t aInnerWindowId,
+                             nsID? aAgentClusterId)
+      returns (BlobURLDataRequestResult aResult);
+
+    async SetActiveSessionHistoryEntry(MaybeDiscardedBrowsingContext context,
+                                       nsPoint? previousScrollPosition,
+                                       SessionHistoryInfo info, uint32_t loadType,
+                                       uint32_t updatedCacheKey, nsID changeID);
+    async ReplaceActiveSessionHistoryEntry(
+        MaybeDiscardedBrowsingContext context, SessionHistoryInfo info);
+
+    async RemoveDynEntriesFromActiveSessionHistoryEntry(
+        MaybeDiscardedBrowsingContext aContext);
+
+    async RemoveFromSessionHistory(
+        MaybeDiscardedBrowsingContext aContext, nsID changeID);
+
+    // Called when a nsDocShellLoadState which was received over IPC is
+    // destroyed in the content process to clean up pending state left behind
+    // tracking the load state in the parent process.
+    [LazySend] async CleanupPendingLoadState(uint64_t aLoadIdentifier);
+
+both:
+    async ScriptError(nsString message, nsString sourceName, nsString sourceLine,
+                      uint32_t lineNumber, uint32_t colNumber, uint32_t flags,
+                      nsCString category, bool privateWindow, uint64_t innerWindowId,
+                      bool fromChromeContext);
+
+    /**
+     * Used in fission to report timing data when the parent window is in
+     * another process. Child frame will send data to its ContentParent which
+     * will then identify the ContentParent for the innerWindowId and pass
+     * the data to the correct process.
+     * loadInfo is passed in order to enforce same-origin security checks
+     * aData must be non-null.
+     */
+    async ReportFrameTimingData(LoadInfoArgs? loadInfo, nsString entryName,
+                                nsString initiatorType,
+                                UniquePtr<PerformanceTimingData> aData);
+
+    async CommitBrowsingContextTransaction(MaybeDiscardedBrowsingContext aContext,
+                                           BrowsingContextTransaction aTransaction,
+                                           uint64_t aEpoch);
+
+    async AsyncMessage(nsString aMessage, ClonedMessageData aData);
+
+    /**
+     * Notify `push-subscription-modified` observers in the parent and child.
+     */
+    async NotifyPushSubscriptionModifiedObservers(nsCString scope,
+                                                  nullable nsIPrincipal principal);
+
+    /**
+     * Send a Push error message to all service worker clients in the parent or
+     * child.
+     */
+    async PushError(nsCString scope, nullable nsIPrincipal principal, nsString message,
+                    uint32_t flags);
+
+    /**
+     * Creates a new BrowsingContext, initialized with the values provided in
+     * `BrowsingContextInitializer`.
+     *
+     * This message may only be sent to the parent in limited situations. If the
+     * new BrowsingContext has a parent window, it must be owned by the
+     * embedding process, otherwise it must be owned by the opener, if set.
+     */
+    [LazySend] async CreateBrowsingContext(uint64_t aGroupId, BrowsingContextInitializer aInit);
+
+    /**
+     * If aDoDiscard is true, discards the passed-in BrowsingContext. If the
+     * BrowsingContext has already been discarded, this message does nothing.
+     * If the receiver is the parent process, resolves when all content
+     * processes have flagged the BrowsingContext as discarded, and if the
+     * receiver is a child process, resolves when that child process has flagged
+     * the BrowsingContext as discarded.
+     */
+    async DiscardBrowsingContext(MaybeDiscardedBrowsingContext aContext, bool aDoDiscard)
+            returns (uint64_t unused);
+
+    async AdjustWindowFocus(MaybeDiscardedBrowsingContext aContext,
+                            bool aIsVisible, uint64_t aActionId);
+    async WindowClose(MaybeDiscardedBrowsingContext aContext,
+                      bool aTrustedCaller);
+    async WindowFocus(MaybeDiscardedBrowsingContext aContext,
+                      CallerType aCallerType, uint64_t aActionId);
+    async WindowBlur(MaybeDiscardedBrowsingContext aContext,
+                     CallerType aCallerType);
+    async RaiseWindow(MaybeDiscardedBrowsingContext aContext, CallerType aCallerType, uint64_t aActionId);
+    async ClearFocus(MaybeDiscardedBrowsingContext aContext);
+    async SetFocusedBrowsingContext(MaybeDiscardedBrowsingContext aContext, uint64_t aActionId);
+    async SetActiveBrowsingContext(MaybeDiscardedBrowsingContext aContext, uint64_t aActionId);
+    async UnsetActiveBrowsingContext(MaybeDiscardedBrowsingContext aContext, uint64_t aActionId);
+    async SetFocusedElement(MaybeDiscardedBrowsingContext aContext, bool aNeedsFocus);
+    async FinalizeFocusOuter(MaybeDiscardedBrowsingContext aContext, bool aCanFocus,
+                             CallerType aCallerType);
+parent:
+    [LazySend] async InsertNewFocusActionId(uint64_t aActionId);
+    async BlurToParent(MaybeDiscardedBrowsingContext aFocusedBrowsingContext,
+                      MaybeDiscardedBrowsingContext aBrowsingContextToClear,
+                      MaybeDiscardedBrowsingContext aAncestorBrowsingContextToFocus,
+                      bool aIsLeavingDocument, bool aAdjustWidget,
+                      bool aBrowsingContextToClearHandled,
+                      bool aAncestorBrowsingContextToFocusHandled, uint64_t aActionId);
+child:
+    async BlurToChild(MaybeDiscardedBrowsingContext aFocusedBrowsingContext,
+                      MaybeDiscardedBrowsingContext aBrowsingContextToClear,
+                      MaybeDiscardedBrowsingContext aAncestorBrowsingContextToFocus,
+                      bool aIsLeavingDocument, bool aAdjustWidget, uint64_t aActionId);
+    async SetupFocusedAndActive(MaybeDiscardedBrowsingContext aFocusedBrowsingContext,
+                                uint64_t aActionIdForFocused,
+                                MaybeDiscardedBrowsingContext aActiveBrowsingContext,
+                                uint64_t aActionId);
+    async ReviseActiveBrowsingContext(uint64_t aOldActionId,
+                                      MaybeDiscardedBrowsingContext aActiveBrowsingContext,
+                                      uint64_t aNewActionId);
+    async ReviseFocusedBrowsingContext(uint64_t aOldActionId,
+                                       MaybeDiscardedBrowsingContext aFocusedBrowsingContext,
+                                       uint64_t aNewActionId);
+both:
+    async MaybeExitFullscreen(MaybeDiscardedBrowsingContext aContext);
+    async WindowPostMessage(MaybeDiscardedBrowsingContext aContext,
+                            ClonedOrErrorMessageData aMessage,
+                            PostMessageData aData);
+
+    async CommitWindowContextTransaction(MaybeDiscardedWindowContext aContext,
+                                         WindowContextTransaction aTransaction,
+                                         uint64_t aEpoch);
+
+child:
+    // NOTE: These methods are only needed on the child, as the parent
+    // WindowContext is managed using the PWindowGlobal actor's lifecycle.
+    [LazySend] async CreateWindowContext(WindowContextInitializer aInit);
+    async DiscardWindowContext(uint64_t aContextId) returns (bool unused);
+
+parent:
+    // Temporary (bug 1641989) conduit for Glean data in content processes.
+    // Sent from time-to-time to limit the amount of data vulnerable to loss.
+    // Buffer contains bincoded Rust structs.
+    async FOGData(ByteBuf buf);
+
+child:
+    // Temporary (bug 1641989) conduit for Glean data in content processes.
+    // Tells the child to flush any pending data. Used in tests and ping
+    // assembly. Buffer contains bincoded Rust structs.
+    async FlushFOGData() returns (ByteBuf buf);
+
+parent:
+    async SetContainerFeaturePolicy(MaybeDiscardedBrowsingContext aContainerContext,
+                                    nullable FeaturePolicy aContainerFeaturePolicy);
+
+    // Obtain an icon from the system widget toolkit, in nsIconDecoder
+    // format.  Not supported (or needed) on all platforms; see the
+    // implementation in ContentParent::RecvGetSystemIcon for details.
+    async GetSystemIcon(nullable nsIURI aURI) returns (nsresult aResult, ByteBuf? aData);
+
+#ifdef FUZZING_SNAPSHOT
+    // Used by the child process to signal that it is ready to start fuzzing.
+    // This can in particular be used to wait for a particular event in a
+    // test document before taking the snapshot and starting e.g. IPC fuzzing.
+    async SignalFuzzingReady();
+#endif
+};
+
+}
+}
diff --git a/dom/ipc/PContentPermission.ipdlh b/dom/ipc/PContentPermission.ipdlh
new file mode 100644
index 0000000000..a70b5bca94
--- /dev/null
+++ b/dom/ipc/PContentPermission.ipdlh
@@ -0,0 +1,19 @@
+/* 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/. */
+
+namespace mozilla {
+namespace dom {
+
+struct PermissionRequest {
+  nsCString type;
+  nsString[] options;
+};
+
+struct PermissionChoice {
+  nsCString type;
+  nsString choice;
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/PContentPermissionRequest.ipdl b/dom/ipc/PContentPermissionRequest.ipdl
new file mode 100644
index 0000000000..0ce5acbe95
--- /dev/null
+++ b/dom/ipc/PContentPermissionRequest.ipdl
@@ -0,0 +1,29 @@
+/* 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 protocol PContent;
+include PContentPermission;
+
+include "nsContentPermissionHelper.h";
+
+namespace mozilla {
+namespace dom {
+
+[ManualDealloc, ChildImpl="RemotePermissionRequest", ParentImpl=virtual]
+protocol PContentPermissionRequest
+{
+  manager PContent;
+
+parent:
+  async prompt();
+  async Destroy();
+
+child:
+  async NotifyResult(bool allow, PermissionChoice[] choices);
+  async __delete__();
+};
+
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/PCycleCollectWithLogs.ipdl b/dom/ipc/PCycleCollectWithLogs.ipdl
new file mode 100644
index 0000000000..9ecfe3da4e
--- /dev/null
+++ b/dom/ipc/PCycleCollectWithLogs.ipdl
@@ -0,0 +1,23 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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 protocol PContent;
+
+namespace mozilla {
+namespace dom {
+
+[ManualDealloc, ChildImpl=virtual, ParentImpl=virtual]
+protocol PCycleCollectWithLogs {
+    manager PContent;
+
+parent:
+    async CloseGCLog();
+    async CloseCCLog();
+
+    async __delete__();
+};
+
+}
+}
diff --git a/dom/ipc/PFilePicker.ipdl b/dom/ipc/PFilePicker.ipdl
new file mode 100644
index 0000000000..2e75c4ee9c
--- /dev/null
+++ b/dom/ipc/PFilePicker.ipdl
@@ -0,0 +1,46 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */
+/* 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 protocol PBrowser;
+
+include IPCBlob;
+
+include "mozilla/dom/FilePickerMessageUtils.h";
+
+using struct mozilla::void_t from "mozilla/ipc/IPCCore.h";
+using nsIFilePicker::CaptureTarget from "nsIFilePicker.h";
+using nsIFilePicker::ResultCode from "nsIFilePicker.h";
+
+namespace mozilla {
+namespace dom {
+
+struct InputBlobs { IPCBlob[] blobs; };
+struct InputDirectory { nsString directoryPath; };
+union MaybeInputData
+{
+  InputBlobs;
+  InputDirectory;
+  void_t;
+};
+
+[ChildImpl=virtual]
+protocol PFilePicker
+{
+  manager PBrowser;
+
+parent:
+    async Open(int16_t selectedType, bool addToRecentDocs, nsString defaultFile,
+               nsString defaultExtension, nsString[] filters, nsString[] filterNames,
+               nsString[] rawFilters, nsString displayDirectory,
+               nsString displaySpecialDirectory, nsString okButtonLabel,
+               CaptureTarget capture);
+
+child:
+    async __delete__(MaybeInputData data, ResultCode result);
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/PInProcess.ipdl b/dom/ipc/PInProcess.ipdl
new file mode 100644
index 0000000000..fc1dc92e18
--- /dev/null
+++ b/dom/ipc/PInProcess.ipdl
@@ -0,0 +1,32 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=2 ts=8 et tw=80 ft=cpp : */
+/* 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 protocol PExtensions;
+include protocol PSessionStore;
+include protocol PWindowGlobal;
+
+include DOMTypes;
+
+namespace mozilla {
+namespace dom {
+
+/**
+ * PInProcess is intended for use as an alternative actor manager to PContent
+ * for async actors which want to be used uniformly in both Content->Chrome and
+ * Chrome->Chrome circumstances.
+ *
+ * `mozilla::dom::InProcess{Parent, Child}::Singleton()` should be used to get
+ * an instance of this actor.
+ */
+async protocol PInProcess
+{
+  manages PExtensions;
+  manages PSessionStore;
+  manages PWindowGlobal;
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/PJSOracle.ipdl b/dom/ipc/PJSOracle.ipdl
new file mode 100644
index 0000000000..2da50d76df
--- /dev/null
+++ b/dom/ipc/PJSOracle.ipdl
@@ -0,0 +1,20 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 protocol PJSValidator;
+
+namespace mozilla {
+namespace dom {
+
+// PJSOracle is a top-level actor which manages PJSValidator
+async protocol PJSOracle {
+  manages PJSValidator;
+
+child:
+  async PJSValidator();
+};
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/ipc/PJSValidator.ipdl b/dom/ipc/PJSValidator.ipdl
new file mode 100644
index 0000000000..7d369c5a21
--- /dev/null
+++ b/dom/ipc/PJSValidator.ipdl
@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 protocol PJSOracle;
+
+using mozilla::net::OpaqueResponseBlocker::ValidatorResult from "mozilla/net/OpaqueResponseUtils.h";
+
+namespace mozilla {
+namespace dom {
+
+async protocol PJSValidator {
+  manager PJSOracle;
+
+child:
+  [ReplyPriority=control]
+  async IsOpaqueResponseAllowed() returns (Shmem? aMem, ValidatorResult aResult);
+
+  async OnDataAvailable(Shmem aData);
+
+  // aContentCharset, aHintCharset and aDocumentCharset
+  // are needed to determine the decoder for the received data
+  async OnStopRequest(nsresult aReason, nsCString aContentCharset,
+                              nsString aHintCharset,
+                              nsString aDocumentCharset);
+
+  async __delete__();
+};
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/ipc/PLoginReputation.ipdl b/dom/ipc/PLoginReputation.ipdl
new file mode 100644
index 0000000000..1a9c553a1c
--- /dev/null
+++ b/dom/ipc/PLoginReputation.ipdl
@@ -0,0 +1,29 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=8 et :
+ */
+/* 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 protocol PContent;
+
+include "mozilla/LoginReputationIPC.h";
+
+namespace mozilla {
+namespace dom {
+
+// PLoginReputation allows child to send URL to parent when user focuses
+// on a password field. Right now this is an one way IPC call (No callback
+// will return after parent receives the IPC message) since we just process
+// the URL in parent (LoginReputationService) and stores the result to telemetry.
+[ManualDealloc, ChildImpl=virtual, ParentImpl="LoginReputationParent"]
+protocol PLoginReputation
+{
+  manager PContent;
+
+child:
+  async __delete__();
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/PProcessHangMonitor.ipdl b/dom/ipc/PProcessHangMonitor.ipdl
new file mode 100644
index 0000000000..09236c14d2
--- /dev/null
+++ b/dom/ipc/PProcessHangMonitor.ipdl
@@ -0,0 +1,48 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=8 et :
+ */
+/* 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/. */
+
+// ParamTraits stuff for nsIRemoteTab::NavigationType
+include "mozilla/dom/TabMessageUtils.h";
+using nsIRemoteTab::NavigationType from "nsIRemoteTab.h";
+
+using base::ProcessId from "base/process.h";
+using mozilla::dom::TabId from "mozilla/dom/ipc/IdType.h";
+using mozilla::layers::LayersObserverEpoch from "mozilla/layers/LayersTypes.h";
+
+namespace mozilla {
+
+struct SlowScriptData
+{
+  TabId tabId;
+  nsCString filename;
+  nsString addonId;
+  double duration;
+};
+
+[ChildImpl=virtual, ParentImpl=virtual]
+protocol PProcessHangMonitor
+{
+parent:
+  async HangEvidence(SlowScriptData data);
+  async ClearHang();
+
+child:
+  async TerminateScript();
+  async RequestContentJSInterrupt();
+
+  async BeginStartingDebugger();
+  async EndStartingDebugger();
+
+  async PaintWhileInterruptingJS(TabId tabId, LayersObserverEpoch aEpoch);
+  async UnloadLayersWhileInterruptingJS(TabId tabId, LayersObserverEpoch aEpoch);
+
+  async CancelContentJSExecutionIfRunning(
+      TabId tabId, NavigationType aNavigationType,
+      int32_t aNavigationIndex, nsCString? aNavigationURI, int32_t aEpoch);
+};
+
+} // namespace mozilla
diff --git a/dom/ipc/PTabContext.ipdlh b/dom/ipc/PTabContext.ipdlh
new file mode 100644
index 0000000000..380bb911ee
--- /dev/null
+++ b/dom/ipc/PTabContext.ipdlh
@@ -0,0 +1,53 @@
+/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */
+/* 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 "mozilla/dom/TabMessageUtils.h";
+
+include protocol PBrowser;
+
+using mozilla::OriginAttributes from "mozilla/ipc/BackgroundUtils.h";
+
+namespace mozilla {
+namespace dom {
+
+// An IPCTabContext which corresponds to a PBrowser opened by a child when it
+// receives window.open().
+struct PopupIPCTabContext
+{
+  PBrowser opener;
+  uint64_t chromeOuterWindowID;
+};
+
+// An IPCTabContext which corresponds to an app, browser, or normal frame.
+struct FrameIPCTabContext
+{
+  uint64_t chromeOuterWindowID;
+
+  // Maximum number of touch points on the screen.
+  uint32_t maxTouchPoints;
+};
+
+struct JSPluginFrameIPCTabContext
+{
+  uint32_t jsPluginId;
+};
+
+// IPCTabContext is an analog to mozilla::dom::TabContext.  Both specify an
+// iframe/PBrowser's own and containing app-ids and tell you whether the
+// iframe/PBrowser is a browser frame.  But only IPCTabContext is allowed to
+// travel over IPC.
+//
+// We need IPCTabContext (specifically, PopupIPCTabContext) to prevent a
+// privilege escalation attack by a compromised child process.
+union IPCTabContext
+{
+  PopupIPCTabContext;
+  FrameIPCTabContext;
+  JSPluginFrameIPCTabContext;
+};
+
+}
+}
diff --git a/dom/ipc/PURLClassifier.ipdl b/dom/ipc/PURLClassifier.ipdl
new file mode 100644
index 0000000000..d4eb5480aa
--- /dev/null
+++ b/dom/ipc/PURLClassifier.ipdl
@@ -0,0 +1,24 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=8 et :
+ */
+/* 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 protocol PContent;
+include PURLClassifierInfo;
+
+namespace mozilla {
+namespace dom {
+
+[ManualDealloc]
+protocol PURLClassifier
+{
+  manager PContent;
+
+child:
+  async __delete__(ClassifierInfo? info, nsresult errorCode);
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/PURLClassifierInfo.ipdlh b/dom/ipc/PURLClassifierInfo.ipdlh
new file mode 100644
index 0000000000..e4e198fa4c
--- /dev/null
+++ b/dom/ipc/PURLClassifierInfo.ipdlh
@@ -0,0 +1,15 @@
+/* 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/. */
+
+namespace mozilla {
+namespace dom {
+
+struct ClassifierInfo {
+  nsCString list;
+  nsCString provider;
+  nsCString fullhash;
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/PURLClassifierLocal.ipdl b/dom/ipc/PURLClassifierLocal.ipdl
new file mode 100644
index 0000000000..a551fc779c
--- /dev/null
+++ b/dom/ipc/PURLClassifierLocal.ipdl
@@ -0,0 +1,38 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=8 et :
+ */
+/* 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 protocol PContent;
+
+include PURLClassifierInfo;
+
+include "mozilla/ipc/URIUtils.h";
+include "mozilla/dom/URLClassifierParent.h";
+include "mozilla/dom/URLClassifierChild.h";
+
+[RefCounted] using class nsIURI from "nsIURI.h";
+
+namespace mozilla {
+namespace dom {
+
+struct URLClassifierLocalResult
+{
+  nullable nsIURI uri;
+  nsCString featureName;
+  nsCString matchingList;
+};
+
+[ManualDealloc, ChildImpl="URLClassifierLocalChild", ParentImpl="URLClassifierLocalParent"]
+protocol PURLClassifierLocal
+{
+  manager PContent;
+
+child:
+  async __delete__(URLClassifierLocalResult[] results);
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/PVsync.ipdl b/dom/ipc/PVsync.ipdl
new file mode 100644
index 0000000000..10d8ab4760
--- /dev/null
+++ b/dom/ipc/PVsync.ipdl
@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 protocol PBackground;
+include protocol PBrowser;
+include "mozilla/layers/LayersMessageUtils.h";
+
+using class mozilla::TimeStamp from "mozilla/TimeStamp.h";
+using mozilla::VsyncEvent from "mozilla/VsyncDispatcher.h";
+
+namespace mozilla {
+namespace dom {
+
+/*
+ * The PVsync is a sub-protocol in PBackground or PBrowser and it is used to
+ * notify the vsync event from chrome to content process. It also provides the
+ * interfaces for content to observe/unobserve vsync event notifications.
+ */
+async protocol PVsync
+{
+  manager PBackground or PBrowser;
+
+child:
+  // Send vsync event and vsync rate from chrome to content process.
+  [Compress, Priority=vsync] async Notify(VsyncEvent aVsync, float aVsyncRate);
+
+parent:
+  // Content process use these messages to acquire the vsync event.
+  async Observe();
+  async Unobserve();
+
+  // This message is never sent. Each PVsync actor will stay alive as long as
+  // its PBackground or PBrowser manager.
+  async __delete__();
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/PWindowGlobal.ipdl b/dom/ipc/PWindowGlobal.ipdl
new file mode 100644
index 0000000000..fba327b6f6
--- /dev/null
+++ b/dom/ipc/PWindowGlobal.ipdl
@@ -0,0 +1,215 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=2 ts=8 et tw=80 ft=cpp : */
+/* 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 "mozilla/dom/DocShellMessageUtils.h";
+include "mozilla/dom/FeaturePolicyUtils.h";
+include "mozilla/dom/IdentityCredentialSerializationHelpers.h";
+include "mozilla/dom/PermissionMessageUtils.h";
+include "mozilla/dom/SessionStoreMessageUtils.h";
+include "mozilla/ipc/TransportSecurityInfoUtils.h";
+include "mozilla/ipc/URIUtils.h";
+
+include protocol PBrowser;
+include protocol PInProcess;
+include protocol PBrowserBridge;
+
+include DOMTypes;
+include ClientIPCTypes;
+include IPCIdentityCredential;
+include NeckoChannelParams;
+include SessionStoreTypes;
+
+include "mozilla/layers/LayersMessageUtils.h";
+
+using mozilla::dom::JSActorMessageKind from "mozilla/dom/JSActor.h";
+using mozilla::gfx::IntRect from "mozilla/gfx/Rect.h";
+[MoveOnly] using mozilla::gfx::PaintFragment from "mozilla/gfx/CrossProcessPaint.h";
+using nscolor from "nsColor.h";
+using mozilla::dom::XPCOMPermitUnloadAction from "nsIContentViewer.h";
+using mozilla::dom::TabId from "mozilla/dom/ipc/IdType.h";
+using mozilla::layers::LayersId from "mozilla/layers/LayersTypes.h";
+[RefCounted] using class nsITransportSecurityInfo from "nsITransportSecurityInfo.h";
+using mozilla::UseCounters from "mozilla/UseCounter.h";
+using mozilla::dom::MaybeDiscardedWindowContext from "mozilla/dom/WindowContext.h";
+[RefCounted] using mozilla::dom::FeaturePolicy from "mozilla/dom/FeaturePolicy.h";
+[RefCounted] using mozilla::dom::SessionStoreRestoreData from "mozilla/dom/SessionStoreRestoreData.h";
+using mozilla::dom::IdentityCredentialRequestOptions from "mozilla/dom/IdentityCredentialBinding.h";
+
+namespace mozilla {
+namespace dom {
+
+struct JSActorMessageMeta {
+  nsCString actorName;
+  nsString messageName;
+  uint64_t queryId;
+  JSActorMessageKind kind;
+};
+
+struct IPCWebShareData
+{
+  nsCString title;
+  nsCString text;
+  nullable nsIURI url;
+};
+
+/**
+ * A PWindowGlobal actor has a lifetime matching that of a single Window Global,
+ * specifically a |nsGlobalWindowInner|. These actors will form a parent/child
+ * link either between the chrome/content process, or will be in-process, for
+ * documents which are loaded in the chrome process.
+ */
+async protocol PWindowGlobal
+{
+  manager PBrowser or PInProcess;
+
+child:
+  async __delete__();
+
+  async MakeFrameLocal(MaybeDiscardedBrowsingContext aFrameContext,
+                       uint64_t aSwitchId);
+  async MakeFrameRemote(MaybeDiscardedBrowsingContext aFrameContext,
+                        ManagedEndpoint<PBrowserBridgeChild> aEndpoint,
+                        TabId aTabId, LayersId aLayersId) returns (bool success);
+
+  async DrawSnapshot(IntRect? aRect, float aScale, nscolor aBackgroundColor,
+                     uint32_t aFlags) returns (PaintFragment retval);
+
+  async DispatchSecurityPolicyViolation(nsString aViolationEventJSON);
+
+  async SaveStorageAccessPermissionGranted();
+
+  async AddBlockedFrameNodeByClassifier(MaybeDiscardedBrowsingContext aNode);
+
+  /**
+   * Request from UI to reset the scaling zoom that is controlled by APZ.
+   */
+  async ResetScalingZoom();
+
+  async SetContainerFeaturePolicy(nullable FeaturePolicy aContainerFeaturePolicy);
+
+  async RestoreDocShellState(DocShellRestoreState aState)
+    returns (bool success);
+
+  async RestoreTabContent(nullable SessionStoreRestoreData aData) returns (bool success);
+
+both:
+  async RawMessage(JSActorMessageMeta aMetadata, ClonedMessageData? aData,
+                   ClonedMessageData? aStack);
+
+parent:
+  // Load the given URI load state into the current owner process of the given
+  // BrowsingContext. aTargetBC must be in the same BrowsingContextGroup as this
+  // window global.
+  async LoadURI(MaybeDiscardedBrowsingContext aTargetBC,
+                nsDocShellLoadState aLoadState, bool aSetNavigating);
+
+  async InternalLoad(nsDocShellLoadState aLoadState);
+
+  /// Update the URI of the document in this WindowGlobal.
+  [LazySend] async UpdateDocumentURI(nullable nsIURI aUri);
+
+  // We expose frameAncestors to web-extensions and they extract URIs from the
+  // principals collected. In order to be compatible with that API, we need to
+  // update the document's principal. This is only allowed if the principals are
+  // `equals` to each other.
+  [LazySend] async UpdateDocumentPrincipal(nullable nsIPrincipal aPrincipal,
+                                           nullable nsIPrincipal aStoragePrincipal);
+
+  // Update document's `documentHasLoaded` bit in this WindowGlobal.
+  [LazySend] async UpdateDocumentHasLoaded(bool aDocumentHasLoaded);
+
+  // Update document's 'documentHasUserInteracted' bit in this WindowGlobal.
+  [LazySend] async UpdateDocumentHasUserInteracted(bool aDocumentHasUserInteracted);
+
+  // Update document's sandbox flags in this WindowGlobal.
+  [LazySend] async UpdateSandboxFlags(uint32_t aSandboxFlags);
+
+  // Update document csp's fields in this WindowGlobal.
+  [LazySend] async UpdateDocumentCspSettings(bool aBlockAllMixedContent, bool aUpgradeInsecureRequests);
+
+  // Update document's cookie settings in this WindowGlobal.
+  [LazySend] async UpdateCookieJarSettings(CookieJarSettingsArgs cookieJarSettings);
+
+  // Update the title of the document in this WindowGlobal.
+  [LazySend] async UpdateDocumentTitle(nsString aTitle);
+
+  [LazySend] async UpdateDocumentSecurityInfo(nullable nsITransportSecurityInfo aSecurityInfo);
+
+  // Update the document's HTTPS-Only Mode flags in this WindowGlobal.
+  [LazySend] async UpdateHttpsOnlyStatus(uint32_t aHttpsOnlyStatus);
+
+  /// Send down initial document bit to the parent.
+  [LazySend] async SetIsInitialDocument(bool aIsInitialDocument);
+
+  // Attempts to perform a "Web Share".
+  async Share(IPCWebShareData aData) returns (nsresult rv);
+
+  // Get content blocking events from the parent process.
+  async GetContentBlockingEvents() returns (uint32_t events);
+
+  // Send the ClientInfo associated with a top-level document load.
+  [LazySend] async SetClientInfo(IPCClientInfo aClientInfo);
+
+  // Checks whether any "beforeunload" event listener in the document subtree
+  // wants to block unload, and prompts the user to allow if any does (depending
+  // on the action specified, using nsIContentViewer::PermitUnloadAction
+  // values). The sender is responsible for checking documents in its own
+  // process, and passing true for `aHasInProcessBlocker` if any exist. Windows
+  // hosted outside of the caller process will be checked automatically.
+  async CheckPermitUnload(bool aHasInProcessBlocker, XPCOMPermitUnloadAction aAction)
+    returns (bool permitUnload);
+
+  /**
+   * Informs the parent process that the document in aTop should expect to
+   * receive page use counter contributions from the document in this
+   * WindowGlobal.
+   */
+  async ExpectPageUseCounters(MaybeDiscardedWindowContext aTop);
+
+  /**
+   * Accumulates use counter data from the document in this WindowGlobal into
+   * the document previously passed into the ExpectPageUseCounters call.
+   */
+  async AccumulatePageUseCounters(UseCounters aUseCounters);
+
+  async RequestRestoreTabContent();
+
+  // Add the flags in aOnFlags to the current BFCache status and remove the
+  // flags in aOffFlags from the current BFCache status. See the BFCacheStatus
+  // enum for the valid flags.
+  async UpdateBFCacheStatus(uint32_t aOnFlags, uint32_t aOffFlags);
+
+  // Signal whether the first connection is added (aIsAdded = true) or
+  // the last connection is removed (aIsAdded = false).
+  async UpdateActivePeerConnectionStatus(bool aIsAdded);
+
+  /**
+   * Used to notify the parent when there's a change in the number of requests
+   * in the loadgroup. If there are no requests this will be set to Nothing().
+   * If there is one request this will be set to the ID of that request, if it
+   * implements nsIIdentChannel. If there are more than one requests this will
+   * be set to 0.
+   * Note that some requests are ignored (eg. favicon loads).
+   */
+  async SetSingleChannelId(uint64_t? singleChannelId);
+
+  async SetDocumentDomain(nullable nsIURI aDomain);
+
+  async Destroy();
+
+  async ReloadWithHttpsOnlyException();
+
+  // Used by the Credential Manager API and FedCM to keep the discovery of
+  // a credential abstracted from the content process. This is required because
+  // credentialed requests that are specifically not partitioned are made and
+  // the results must not enter the child process until the user consents via
+  // purpose built UI.
+  async DiscoverIdentityCredentialFromExternalSource(IdentityCredentialRequestOptions aOptions) 
+      returns (IPCIdentityCredential? identityCredential);
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/PageLoadEventUtils.h b/dom/ipc/PageLoadEventUtils.h
new file mode 100644
index 0000000000..6a49e4b660
--- /dev/null
+++ b/dom/ipc/PageLoadEventUtils.h
@@ -0,0 +1,50 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_page_load_event_utils_h__
+#define mozilla_dom_page_load_event_utils_h__
+
+#include "ipc/IPCMessageUtils.h"
+#include "mozilla/glean/GleanMetrics.h"
+
+namespace IPC {
+
+template <>
+struct ParamTraits<mozilla::glean::perf::PageLoadExtra> {
+  typedef mozilla::glean::perf::PageLoadExtra paramType;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam) {
+    WriteParam(aWriter, aParam.fcpTime);
+    WriteParam(aWriter, aParam.jsExecTime);
+    WriteParam(aWriter, aParam.loadTime);
+    WriteParam(aWriter, aParam.loadType);
+    WriteParam(aWriter, aParam.responseTime);
+    WriteParam(aWriter, aParam.httpVer);
+    WriteParam(aWriter, aParam.redirectCount);
+    WriteParam(aWriter, aParam.redirectTime);
+    WriteParam(aWriter, aParam.sameOriginNav);
+    WriteParam(aWriter, aParam.trrDomain);
+    WriteParam(aWriter, aParam.dnsLookupTime);
+  }
+
+  static bool Read(MessageReader* aReader, paramType* aResult) {
+    return ReadParam(aReader, &aResult->fcpTime) &&
+           ReadParam(aReader, &aResult->jsExecTime) &&
+           ReadParam(aReader, &aResult->loadTime) &&
+           ReadParam(aReader, &aResult->loadType) &&
+           ReadParam(aReader, &aResult->responseTime) &&
+           ReadParam(aReader, &aResult->httpVer) &&
+           ReadParam(aReader, &aResult->redirectCount) &&
+           ReadParam(aReader, &aResult->redirectTime) &&
+           ReadParam(aReader, &aResult->sameOriginNav) &&
+           ReadParam(aReader, &aResult->trrDomain) &&
+           ReadParam(aReader, &aResult->dnsLookupTime);
+  }
+};
+
+}  // namespace IPC
+
+#endif  // mozilla_dom_page_load_event_utils_h__
diff --git a/dom/ipc/PermissionMessageUtils.cpp b/dom/ipc/PermissionMessageUtils.cpp
new file mode 100644
index 0000000000..19d232a7bc
--- /dev/null
+++ b/dom/ipc/PermissionMessageUtils.cpp
@@ -0,0 +1,51 @@
+/* -*- 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 "mozilla/dom/PermissionMessageUtils.h"
+#include "mozilla/ipc/BackgroundUtils.h"
+#include "mozilla/ipc/PBackgroundSharedTypes.h"
+#include "nsCOMPtr.h"
+#include "nsIPrincipal.h"
+
+namespace mozilla::ipc {
+
+void IPDLParamTraits<nsIPrincipal*>::Write(IPC::MessageWriter* aWriter,
+                                           IProtocol* aActor,
+                                           nsIPrincipal* aParam) {
+  Maybe<PrincipalInfo> info;
+  if (aParam) {
+    info.emplace();
+    nsresult rv = PrincipalToPrincipalInfo(aParam, info.ptr());
+    MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv));
+  }
+
+  WriteIPDLParam(aWriter, aActor, info);
+}
+
+bool IPDLParamTraits<nsIPrincipal*>::Read(IPC::MessageReader* aReader,
+                                          IProtocol* aActor,
+                                          RefPtr<nsIPrincipal>* aResult) {
+  Maybe<PrincipalInfo> info;
+  if (!ReadIPDLParam(aReader, aActor, &info)) {
+    return false;
+  }
+
+  if (info.isNothing()) {
+    return true;
+  }
+
+  auto principalOrErr = PrincipalInfoToPrincipal(info.ref());
+
+  if (NS_WARN_IF(principalOrErr.isErr())) {
+    return false;
+  }
+
+  nsCOMPtr<nsIPrincipal> principal = principalOrErr.unwrap();
+  *aResult = principal;
+  return true;
+}
+
+}  // namespace mozilla::ipc
diff --git a/dom/ipc/PermissionMessageUtils.h b/dom/ipc/PermissionMessageUtils.h
new file mode 100644
index 0000000000..7a32b9e930
--- /dev/null
+++ b/dom/ipc/PermissionMessageUtils.h
@@ -0,0 +1,38 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_permission_message_utils_h__
+#define mozilla_dom_permission_message_utils_h__
+
+#include "mozilla/ipc/IPDLParamTraits.h"
+#include "ipc/IPCMessageUtils.h"
+#include "nsCOMPtr.h"
+#include "nsIPrincipal.h"
+
+namespace mozilla::ipc {
+
+template <>
+struct IPDLParamTraits<nsIPrincipal*> {
+  static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
+                    nsIPrincipal* aParam);
+  static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
+                   RefPtr<nsIPrincipal>* aResult);
+
+  // Overload to support deserializing nsCOMPtr<nsIPrincipal> directly.
+  static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
+                   nsCOMPtr<nsIPrincipal>* aResult) {
+    RefPtr<nsIPrincipal> result;
+    if (!Read(aReader, aActor, &result)) {
+      return false;
+    }
+    *aResult = std::move(result);
+    return true;
+  }
+};
+
+}  // namespace mozilla::ipc
+
+#endif  // mozilla_dom_permission_message_utils_h__
diff --git a/dom/ipc/PreallocatedProcessManager.cpp b/dom/ipc/PreallocatedProcessManager.cpp
new file mode 100644
index 0000000000..b96521492f
--- /dev/null
+++ b/dom/ipc/PreallocatedProcessManager.cpp
@@ -0,0 +1,440 @@
+/* -*- 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 "mozilla/PreallocatedProcessManager.h"
+
+#include "mozilla/AppShutdown.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/ProfilerMarkers.h"
+#include "mozilla/Unused.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "nsIPropertyBag2.h"
+#include "ProcessPriorityManager.h"
+#include "nsServiceManagerUtils.h"
+#include "nsIXULRuntime.h"
+#include "nsTArray.h"
+#include "prsystem.h"
+
+using namespace mozilla::hal;
+using namespace mozilla::dom;
+
+namespace mozilla {
+/**
+ * This singleton class implements the static methods on
+ * PreallocatedProcessManager.
+ */
+class PreallocatedProcessManagerImpl final : public nsIObserver {
+  friend class PreallocatedProcessManager;
+
+ public:
+  static PreallocatedProcessManagerImpl* Singleton();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+
+  // See comments on PreallocatedProcessManager for these methods.
+  void AddBlocker(ContentParent* aParent);
+  void RemoveBlocker(ContentParent* aParent);
+  already_AddRefed<ContentParent> Take(const nsACString& aRemoteType);
+  void Erase(ContentParent* aParent);
+
+ private:
+  static const char* const kObserverTopics[];
+
+  static StaticRefPtr<PreallocatedProcessManagerImpl> sSingleton;
+
+  PreallocatedProcessManagerImpl();
+  ~PreallocatedProcessManagerImpl();
+  PreallocatedProcessManagerImpl(const PreallocatedProcessManagerImpl&) =
+      delete;
+
+  const PreallocatedProcessManagerImpl& operator=(
+      const PreallocatedProcessManagerImpl&) = delete;
+
+  void Init();
+
+  bool CanAllocate();
+  void AllocateAfterDelay(bool aStartup = false);
+  void AllocateOnIdle();
+  void AllocateNow();
+
+  void RereadPrefs();
+  void Enable(uint32_t aProcesses);
+  void Disable();
+  void CloseProcesses();
+
+  bool IsEmpty() const { return mPreallocatedProcesses.IsEmpty(); }
+  static bool IsShutdown() {
+    return AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed);
+  }
+  bool IsEnabled() { return mEnabled && !IsShutdown(); }
+
+  bool mEnabled;
+  uint32_t mNumberPreallocs;
+  AutoTArray<RefPtr<ContentParent>, 3> mPreallocatedProcesses;
+  // Even if we have multiple PreallocatedProcessManagerImpls, we'll have
+  // one blocker counter
+  static uint32_t sNumBlockers;
+  TimeStamp mBlockingStartTime;
+};
+
+/* static */
+uint32_t PreallocatedProcessManagerImpl::sNumBlockers = 0;
+
+const char* const PreallocatedProcessManagerImpl::kObserverTopics[] = {
+    "memory-pressure",
+    "profile-change-teardown",
+    NS_XPCOM_SHUTDOWN_OBSERVER_ID,
+};
+
+/* static */
+StaticRefPtr<PreallocatedProcessManagerImpl>
+    PreallocatedProcessManagerImpl::sSingleton;
+
+/* static */
+PreallocatedProcessManagerImpl* PreallocatedProcessManagerImpl::Singleton() {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (!sSingleton) {
+    sSingleton = new PreallocatedProcessManagerImpl;
+    sSingleton->Init();
+    ClearOnShutdown(&sSingleton);
+  }
+  return sSingleton;
+  //  PreallocatedProcessManagers live until shutdown
+}
+
+NS_IMPL_ISUPPORTS(PreallocatedProcessManagerImpl, nsIObserver)
+
+PreallocatedProcessManagerImpl::PreallocatedProcessManagerImpl()
+    : mEnabled(false), mNumberPreallocs(1) {}
+
+PreallocatedProcessManagerImpl::~PreallocatedProcessManagerImpl() {
+  // Note: mPreallocatedProcesses may not be null, but all processes should
+  // be dead (IsDead==true).  We block Erase() when our observer sees
+  // shutdown starting.
+}
+
+void PreallocatedProcessManagerImpl::Init() {
+  Preferences::AddStrongObserver(this, "dom.ipc.processPrelaunch.enabled");
+  // We have to respect processCount at all time. This is especially important
+  // for testing.
+  Preferences::AddStrongObserver(this, "dom.ipc.processCount");
+  // A StaticPref, but we need to adjust the number of preallocated processes
+  // if the value goes up or down, so we need to run code on change.
+  Preferences::AddStrongObserver(this,
+                                 "dom.ipc.processPrelaunch.fission.number");
+
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  MOZ_ASSERT(os);
+  for (auto topic : kObserverTopics) {
+    os->AddObserver(this, topic, /* ownsWeak */ false);
+  }
+  RereadPrefs();
+}
+
+NS_IMETHODIMP
+PreallocatedProcessManagerImpl::Observe(nsISupports* aSubject,
+                                        const char* aTopic,
+                                        const char16_t* aData) {
+  if (!strcmp("nsPref:changed", aTopic)) {
+    // The only other observer we registered was for our prefs.
+    RereadPrefs();
+  } else if (!strcmp(NS_XPCOM_SHUTDOWN_OBSERVER_ID, aTopic) ||
+             !strcmp("profile-change-teardown", aTopic)) {
+    Preferences::RemoveObserver(this, "dom.ipc.processPrelaunch.enabled");
+    Preferences::RemoveObserver(this, "dom.ipc.processCount");
+    Preferences::RemoveObserver(this,
+                                "dom.ipc.processPrelaunch.fission.number");
+
+    nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+    MOZ_ASSERT(os);
+    for (auto topic : kObserverTopics) {
+      os->RemoveObserver(this, topic);
+    }
+  } else if (!strcmp("memory-pressure", aTopic)) {
+    CloseProcesses();
+  } else {
+    MOZ_ASSERT_UNREACHABLE("Unknown topic");
+  }
+
+  return NS_OK;
+}
+
+void PreallocatedProcessManagerImpl::RereadPrefs() {
+  if (mozilla::BrowserTabsRemoteAutostart() &&
+      Preferences::GetBool("dom.ipc.processPrelaunch.enabled")) {
+    int32_t number = 1;
+    if (mozilla::FissionAutostart()) {
+      number = StaticPrefs::dom_ipc_processPrelaunch_fission_number();
+      // limit preallocated processes on low-mem machines
+      PRUint64 bytes = PR_GetPhysicalMemorySize();
+      if (bytes > 0 &&
+          bytes <=
+              StaticPrefs::dom_ipc_processPrelaunch_lowmem_mb() * 1024 * 1024) {
+        number = 1;
+      }
+    }
+    if (number >= 0) {
+      Enable(number);
+      // We have one prealloc queue for all types except File now
+      if (static_cast<uint64_t>(number) < mPreallocatedProcesses.Length()) {
+        CloseProcesses();
+      }
+    }
+  } else {
+    Disable();
+  }
+}
+
+already_AddRefed<ContentParent> PreallocatedProcessManagerImpl::Take(
+    const nsACString& aRemoteType) {
+  if (!IsEnabled()) {
+    return nullptr;
+  }
+  RefPtr<ContentParent> process;
+  if (!IsEmpty()) {
+    process = mPreallocatedProcesses.ElementAt(0);
+    mPreallocatedProcesses.RemoveElementAt(0);
+
+    // Don't set the priority to FOREGROUND here, since it may not have
+    // finished starting
+
+    // We took a preallocated process. Let's try to start up a new one
+    // soon.
+    ContentParent* last = mPreallocatedProcesses.SafeLastElement(nullptr);
+    // There could be a launching process that isn't the last, but that's
+    // ok (and unlikely)
+    if (!last || !last->IsLaunching()) {
+      AllocateAfterDelay();
+    }
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+            ("Use prealloc process %p%s, %lu available", process.get(),
+             process->IsLaunching() ? " (still launching)" : "",
+             (unsigned long)mPreallocatedProcesses.Length()));
+  }
+  if (process && !process->IsLaunching()) {
+    ProcessPriorityManager::SetProcessPriority(process,
+                                               PROCESS_PRIORITY_FOREGROUND);
+  }  // else this will get set by the caller when they call InitInternal()
+
+  return process.forget();
+}
+
+void PreallocatedProcessManagerImpl::Erase(ContentParent* aParent) {
+  (void)mPreallocatedProcesses.RemoveElement(aParent);
+}
+
+void PreallocatedProcessManagerImpl::Enable(uint32_t aProcesses) {
+  mNumberPreallocs = aProcesses;
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+          ("Enabling preallocation: %u", aProcesses));
+  if (mEnabled || IsShutdown()) {
+    return;
+  }
+
+  mEnabled = true;
+  AllocateAfterDelay(/* aStartup */ true);
+}
+
+void PreallocatedProcessManagerImpl::AddBlocker(ContentParent* aParent) {
+  if (sNumBlockers == 0) {
+    mBlockingStartTime = TimeStamp::Now();
+  }
+  sNumBlockers++;
+}
+
+void PreallocatedProcessManagerImpl::RemoveBlocker(ContentParent* aParent) {
+  // This used to assert that the blocker existed, but preallocated
+  // processes aren't blockers anymore because it's not useful and
+  // interferes with async launch, and it's simpler if content
+  // processes don't need to remember whether they were preallocated.
+
+  MOZ_DIAGNOSTIC_ASSERT(sNumBlockers > 0);
+  sNumBlockers--;
+  if (sNumBlockers == 0) {
+    MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+            ("Blocked preallocation for %fms",
+             (TimeStamp::Now() - mBlockingStartTime).ToMilliseconds()));
+    PROFILER_MARKER_TEXT("Process", DOM,
+                         MarkerTiming::IntervalUntilNowFrom(mBlockingStartTime),
+                         "Blocked preallocation");
+    if (IsEmpty()) {
+      AllocateAfterDelay();
+    }
+  }
+}
+
+bool PreallocatedProcessManagerImpl::CanAllocate() {
+  return IsEnabled() && sNumBlockers == 0 &&
+         mPreallocatedProcesses.Length() < mNumberPreallocs && !IsShutdown() &&
+         (FissionAutostart() ||
+          !ContentParent::IsMaxProcessCountReached(DEFAULT_REMOTE_TYPE));
+}
+
+void PreallocatedProcessManagerImpl::AllocateAfterDelay(bool aStartup) {
+  if (!IsEnabled()) {
+    return;
+  }
+  long delay = aStartup ? StaticPrefs::dom_ipc_processPrelaunch_startupDelayMs()
+                        : StaticPrefs::dom_ipc_processPrelaunch_delayMs();
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+          ("Starting delayed process start, delay=%ld", delay));
+  NS_DelayedDispatchToCurrentThread(
+      NewRunnableMethod("PreallocatedProcessManagerImpl::AllocateOnIdle", this,
+                        &PreallocatedProcessManagerImpl::AllocateOnIdle),
+      delay);
+}
+
+void PreallocatedProcessManagerImpl::AllocateOnIdle() {
+  if (!IsEnabled()) {
+    return;
+  }
+
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+          ("Starting process allocate on idle"));
+  NS_DispatchToCurrentThreadQueue(
+      NewRunnableMethod("PreallocatedProcessManagerImpl::AllocateNow", this,
+                        &PreallocatedProcessManagerImpl::AllocateNow),
+      EventQueuePriority::Idle);
+}
+
+void PreallocatedProcessManagerImpl::AllocateNow() {
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+          ("Trying to start process now"));
+  if (!CanAllocate()) {
+    if (IsEnabled() && IsEmpty() && sNumBlockers > 0) {
+      // If it's too early to allocate a process let's retry later.
+      AllocateAfterDelay();
+    }
+    return;
+  }
+
+  RefPtr<ContentParent> process = ContentParent::MakePreallocProcess();
+  mPreallocatedProcesses.AppendElement(process);
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+          ("Preallocated = %lu of %d processes",
+           (unsigned long)mPreallocatedProcesses.Length(), mNumberPreallocs));
+
+  RefPtr<PreallocatedProcessManagerImpl> self(this);
+  process->LaunchSubprocessAsync(PROCESS_PRIORITY_PREALLOC)
+      ->Then(
+          GetCurrentSerialEventTarget(), __func__,
+          [self, this, process](const RefPtr<ContentParent>&) {
+            if (process->IsDead()) {
+              Erase(process);
+              // Process died in startup (before we could add it).  If it
+              // dies after this, MarkAsDead() will Erase() this entry.
+              // Shouldn't be in the sBrowserContentParents, so we don't need
+              // RemoveFromList().  We won't try to kick off a new
+              // preallocation here, to avoid possible looping if something is
+              // causing them to consistently fail; if everything is ok on the
+              // next allocation request we'll kick off creation.
+            } else {
+              // Continue prestarting processes if needed
+              if (CanAllocate()) {
+                if (mPreallocatedProcesses.Length() < mNumberPreallocs) {
+                  AllocateOnIdle();
+                }
+              } else if (!IsEnabled()) {
+                // if this has a remote type set, it's been allocated for use
+                // already
+                if (process->mRemoteType == PREALLOC_REMOTE_TYPE) {
+                  // This will Erase() it
+                  process->ShutDownProcess(
+                      ContentParent::SEND_SHUTDOWN_MESSAGE);
+                }
+              }
+            }
+          },
+          [self, this, process]() { Erase(process); });
+}
+
+void PreallocatedProcessManagerImpl::Disable() {
+  if (!mEnabled) {
+    return;
+  }
+
+  mEnabled = false;
+  CloseProcesses();
+}
+
+void PreallocatedProcessManagerImpl::CloseProcesses() {
+  while (!IsEmpty()) {
+    RefPtr<ContentParent> process(mPreallocatedProcesses.ElementAt(0));
+    mPreallocatedProcesses.RemoveElementAt(0);
+    process->ShutDownProcess(ContentParent::SEND_SHUTDOWN_MESSAGE);
+    // drop ref and let it free
+  }
+
+  // Make sure to also clear out the recycled E10S process cache, as it's also
+  // controlled by the same preference, and can be cleaned up due to memory
+  // pressure.
+  if (RefPtr<ContentParent> recycled =
+          ContentParent::sRecycledE10SProcess.forget()) {
+    recycled->MaybeBeginShutDown();
+  }
+}
+
+inline PreallocatedProcessManagerImpl*
+PreallocatedProcessManager::GetPPMImpl() {
+  if (PreallocatedProcessManagerImpl::IsShutdown()) {
+    return nullptr;
+  }
+  return PreallocatedProcessManagerImpl::Singleton();
+}
+
+/* static */
+bool PreallocatedProcessManager::Enabled() {
+  if (auto impl = GetPPMImpl()) {
+    return impl->IsEnabled();
+  }
+  return false;
+}
+
+/* static */
+void PreallocatedProcessManager::AddBlocker(const nsACString& aRemoteType,
+                                            ContentParent* aParent) {
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+          ("AddBlocker: %s %p (sNumBlockers=%d)",
+           PromiseFlatCString(aRemoteType).get(), aParent,
+           PreallocatedProcessManagerImpl::sNumBlockers));
+  if (auto impl = GetPPMImpl()) {
+    impl->AddBlocker(aParent);
+  }
+}
+
+/* static */
+void PreallocatedProcessManager::RemoveBlocker(const nsACString& aRemoteType,
+                                               ContentParent* aParent) {
+  MOZ_LOG(ContentParent::GetLog(), LogLevel::Debug,
+          ("RemoveBlocker: %s %p (sNumBlockers=%d)",
+           PromiseFlatCString(aRemoteType).get(), aParent,
+           PreallocatedProcessManagerImpl::sNumBlockers));
+  if (auto impl = GetPPMImpl()) {
+    impl->RemoveBlocker(aParent);
+  }
+}
+
+/* static */
+already_AddRefed<ContentParent> PreallocatedProcessManager::Take(
+    const nsACString& aRemoteType) {
+  if (auto impl = GetPPMImpl()) {
+    return impl->Take(aRemoteType);
+  }
+  return nullptr;
+}
+
+/* static */
+void PreallocatedProcessManager::Erase(ContentParent* aParent) {
+  if (auto impl = GetPPMImpl()) {
+    impl->Erase(aParent);
+  }
+}
+
+}  // namespace mozilla
diff --git a/dom/ipc/PreallocatedProcessManager.h b/dom/ipc/PreallocatedProcessManager.h
new file mode 100644
index 0000000000..9dea534dbd
--- /dev/null
+++ b/dom/ipc/PreallocatedProcessManager.h
@@ -0,0 +1,73 @@
+/* -*- 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/. */
+
+#ifndef mozilla_PreallocatedProcessManager_h
+#define mozilla_PreallocatedProcessManager_h
+
+#include "base/basictypes.h"
+#include "mozilla/AlreadyAddRefed.h"
+#include "nsStringFwd.h"
+
+namespace mozilla {
+namespace dom {
+class ContentParent;
+}  // namespace dom
+
+/**
+ * This class manages a ContentParent that it starts up ahead of any particular
+ * need.  You can then call Take() to get this process and use it.  Since we
+ * already started it up, it should be ready for use faster than if you'd
+ * created the process when you needed it.
+ *
+ * This class watches the dom.ipc.processPrelaunch.enabled pref.  If it changes
+ * from false to true, it preallocates a process.  If it changes from true to
+ * false, it kills the preallocated process, if any.
+ *
+ * We don't expect this pref to flip between true and false in production, but
+ * flipping the pref is important for tests.
+ */
+class PreallocatedProcessManagerImpl;
+
+class PreallocatedProcessManager final {
+  typedef mozilla::dom::ContentParent ContentParent;
+
+ public:
+  static PreallocatedProcessManagerImpl* GetPPMImpl();
+
+  static bool Enabled();
+
+  /**
+   * Before first paint we don't want to allocate any processes in the
+   * background. To avoid that, the PreallocatedProcessManager won't start up
+   * any processes while there is a blocker active.
+   */
+  static void AddBlocker(const nsACString& aRemoteType, ContentParent* aParent);
+  static void RemoveBlocker(const nsACString& aRemoteType,
+                            ContentParent* aParent);
+
+  /**
+   * Take a preallocated process, if we have one. If we don't have a
+   * preallocated process to return, this returns null.
+   *
+   * If we use a preallocated process, it will schedule the start of
+   * another on Idle (AllocateOnIdle()).
+   */
+  static already_AddRefed<ContentParent> Take(const nsACString& aRemoteType);
+
+  /**
+   * Note that a process was shut down, and should no longer be tracked as a
+   * preallocated process.
+   */
+  static void Erase(ContentParent* aParent);
+
+ private:
+  PreallocatedProcessManager();
+  DISALLOW_EVIL_CONSTRUCTORS(PreallocatedProcessManager);
+};
+
+}  // namespace mozilla
+
+#endif  // defined mozilla_PreallocatedProcessManager_h
diff --git a/dom/ipc/PrefsTypes.ipdlh b/dom/ipc/PrefsTypes.ipdlh
new file mode 100644
index 0000000000..403c7aaf42
--- /dev/null
+++ b/dom/ipc/PrefsTypes.ipdlh
@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+using struct mozilla::null_t from "mozilla/ipc/IPCCore.h";
+
+namespace mozilla {
+namespace dom {
+
+union PrefValue {
+  nsCString;
+  int32_t;
+  bool;
+};
+
+// This serialization form mirrors that used in mozilla::Pref in
+// Preferences.cpp. The two should be kept in sync, e.g. if something is added
+// to one it should also be added to the other.
+//
+// Note: there is no need to pass the isSticky attribute because that's an
+// immutable attribute obtained from file at startup.
+struct Pref {
+  nsCString name;
+  bool isLocked;
+  bool isSanitized;
+  PrefValue? defaultValue;
+  PrefValue? userValue;
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/ProcessActor.cpp b/dom/ipc/ProcessActor.cpp
new file mode 100644
index 0000000000..b036f625c2
--- /dev/null
+++ b/dom/ipc/ProcessActor.cpp
@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "mozilla/dom/ProcessActor.h"
+
+#include "nsContentUtils.h"
+#include "mozilla/ContentBlockingAllowList.h"
+#include "mozilla/Logging.h"
+#include "mozilla/dom/JSActorService.h"
+#include "mozilla/dom/JSProcessActorParent.h"
+#include "mozilla/dom/JSProcessActorChild.h"
+#include "mozilla/dom/JSProcessActorProtocol.h"
+
+namespace mozilla::dom {
+
+already_AddRefed<JSActorProtocol> ProcessActor::MatchingJSActorProtocol(
+    JSActorService* aActorSvc, const nsACString& aName, ErrorResult& aRv) {
+  RefPtr<JSProcessActorProtocol> proto =
+      aActorSvc->GetJSProcessActorProtocol(aName);
+  if (!proto) {
+    aRv.ThrowNotFoundError(nsPrintfCString("No such JSProcessActor '%s'",
+                                           PromiseFlatCString(aName).get()));
+    return nullptr;
+  }
+
+  if (!proto->Matches(GetRemoteType(), aRv)) {
+    MOZ_ASSERT(aRv.Failed());
+    return nullptr;
+  }
+  MOZ_ASSERT(!aRv.Failed());
+  return proto.forget();
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/ProcessActor.h b/dom/ipc/ProcessActor.h
new file mode 100644
index 0000000000..a80300b672
--- /dev/null
+++ b/dom/ipc/ProcessActor.h
@@ -0,0 +1,36 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_ProcessActor_h
+#define mozilla_dom_ProcessActor_h
+
+#include "mozilla/dom/JSActorManager.h"
+#include "nsStringFwd.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class JSActorProtocol;
+class JSActorService;
+
+// Common base class for Content{Parent, Child} and InProcess{Parent, Child}.
+class ProcessActor : public JSActorManager {
+ protected:
+  virtual ~ProcessActor() = default;
+
+  already_AddRefed<JSActorProtocol> MatchingJSActorProtocol(
+      JSActorService* aActorSvc, const nsACString& aName,
+      ErrorResult& aRv) final;
+
+  virtual const nsACString& GetRemoteType() const = 0;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_ProcessActor_h
diff --git a/dom/ipc/ProcessHangMonitor.cpp b/dom/ipc/ProcessHangMonitor.cpp
new file mode 100644
index 0000000000..22b5ac8aa4
--- /dev/null
+++ b/dom/ipc/ProcessHangMonitor.cpp
@@ -0,0 +1,1333 @@
+/* -*- 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 "mozilla/ProcessHangMonitor.h"
+#include "mozilla/ProcessHangMonitorIPC.h"
+
+#include "jsapi.h"
+#include "xpcprivate.h"
+
+#include "mozilla/Atomics.h"
+#include "mozilla/BackgroundHangMonitor.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/dom/CancelContentJSOptionsBinding.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/dom/BrowserChild.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/ipc/Endpoint.h"
+#include "mozilla/ipc/ProcessChild.h"
+#include "mozilla/ipc/TaskFactory.h"
+#include "mozilla/Monitor.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/StaticMonitor.h"
+#include "mozilla/StaticPrefs_browser.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/Unused.h"
+#include "mozilla/WeakPtr.h"
+
+#include "MainThreadUtils.h"
+#include "nsExceptionHandler.h"
+#include "nsFrameLoader.h"
+#include "nsIHangReport.h"
+#include "nsIRemoteTab.h"
+#include "nsNetUtil.h"
+#include "nsQueryObject.h"
+#include "nsPluginHost.h"
+#include "nsThreadUtils.h"
+
+#include "base/task.h"
+#include "base/thread.h"
+
+#ifdef XP_WIN
+// For IsDebuggerPresent()
+#  include <windows.h>
+#endif
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::ipc;
+
+/*
+ * Basic architecture:
+ *
+ * Each process has its own ProcessHangMonitor singleton. This singleton exists
+ * as long as there is at least one content process in the system. Each content
+ * process has a HangMonitorChild and the chrome process has one
+ * HangMonitorParent per process. Each process (including the chrome process)
+ * runs a hang monitoring thread. The PHangMonitor actors are bound to this
+ * thread so that they never block on the main thread.
+ *
+ * When the content process detects a hang, it posts a task to its hang thread,
+ * which sends an IPC message to the hang thread in the parent. The parent
+ * cancels any ongoing CPOW requests and then posts a runnable to the main
+ * thread that notifies Firefox frontend code of the hang. The frontend code is
+ * passed an nsIHangReport, which can be used to terminate the hang.
+ *
+ * If the user chooses to terminate a script, a task is posted to the chrome
+ * process's hang monitoring thread, which sends an IPC message to the hang
+ * thread in the content process. That thread sets a flag to indicate that JS
+ * execution should be terminated the next time it hits the interrupt
+ * callback. A similar scheme is used for debugging slow scripts. If a content
+ * process or plug-in needs to be terminated, the chrome process does so
+ * directly, without messaging the content process.
+ */
+
+namespace {
+
+/* Child process objects */
+
+class HangMonitorChild : public PProcessHangMonitorChild,
+                         public BackgroundHangAnnotator {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING_WITH_DELETE_ON_MAIN_THREAD(
+      HangMonitorChild, override)
+
+  void Bind(Endpoint<PProcessHangMonitorChild>&& aEndpoint);
+
+  using SlowScriptAction = ProcessHangMonitor::SlowScriptAction;
+  SlowScriptAction NotifySlowScript(nsIBrowserChild* aBrowserChild,
+                                    const char* aFileName,
+                                    const nsString& aAddonId,
+                                    const double aDuration);
+  void NotifySlowScriptAsync(TabId aTabId, const nsCString& aFileName,
+                             const nsString& aAddonId, const double aDuration);
+
+  bool IsDebuggerStartupComplete();
+
+  void ClearHang();
+  void ClearHangAsync();
+  void ClearPaintWhileInterruptingJS(const LayersObserverEpoch& aEpoch);
+
+  // MaybeStartPaintWhileInterruptingJS will notify the background hang monitor
+  // of activity if this is the first time calling it since
+  // ClearPaintWhileInterruptingJS. It should be callable from any thread, but
+  // you must be holding mMonitor if using it off the main thread, since it
+  // could race with ClearPaintWhileInterruptingJS.
+  void MaybeStartPaintWhileInterruptingJS();
+
+  mozilla::ipc::IPCResult RecvTerminateScript() override;
+  mozilla::ipc::IPCResult RecvRequestContentJSInterrupt() override;
+  mozilla::ipc::IPCResult RecvBeginStartingDebugger() override;
+  mozilla::ipc::IPCResult RecvEndStartingDebugger() override;
+
+  mozilla::ipc::IPCResult RecvPaintWhileInterruptingJS(
+      const TabId& aTabId, const LayersObserverEpoch& aEpoch) override;
+
+  mozilla::ipc::IPCResult RecvUnloadLayersWhileInterruptingJS(
+      const TabId& aTabId, const LayersObserverEpoch& aEpoch) override;
+
+  mozilla::ipc::IPCResult RecvCancelContentJSExecutionIfRunning(
+      const TabId& aTabId, const nsIRemoteTab::NavigationType& aNavigationType,
+      const int32_t& aNavigationIndex,
+      const mozilla::Maybe<nsCString>& aNavigationURI,
+      const int32_t& aEpoch) override;
+
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  bool InterruptCallback();
+  void Shutdown();
+
+  static HangMonitorChild* Get() MOZ_REQUIRES(sMainThreadCapability) {
+    return sInstance;
+  }
+
+  static void CreateAndBind(ProcessHangMonitor* aMonitor,
+                            Endpoint<PProcessHangMonitorChild>&& aEndpoint);
+
+  void Dispatch(already_AddRefed<nsIRunnable> aRunnable) {
+    mHangMonitor->Dispatch(std::move(aRunnable));
+  }
+  bool IsOnThread() { return mHangMonitor->IsOnThread(); }
+
+  void AnnotateHang(BackgroundHangAnnotations& aAnnotations) override;
+
+ protected:
+  friend class mozilla::ProcessHangMonitor;
+
+ private:
+  explicit HangMonitorChild(ProcessHangMonitor* aMonitor);
+  ~HangMonitorChild() override;
+
+  void ShutdownOnThread();
+
+  static StaticRefPtr<HangMonitorChild> sInstance
+      MOZ_GUARDED_BY(sMainThreadCapability);
+
+  const RefPtr<ProcessHangMonitor> mHangMonitor;
+  Monitor mMonitor;
+
+  // Main thread-only.
+  bool mSentReport;
+
+  // These fields must be accessed with mMonitor held.
+  bool mTerminateScript MOZ_GUARDED_BY(mMonitor);
+  bool mStartDebugger MOZ_GUARDED_BY(mMonitor);
+  bool mFinishedStartingDebugger MOZ_GUARDED_BY(mMonitor);
+
+  // this variable is used to paint/unload layers
+  // if not set, no action required
+  // true means, we will paint. false - unload layers
+  Maybe<bool> mPaintWhileInterruptingJS MOZ_GUARDED_BY(mMonitor);
+  TabId mPaintWhileInterruptingJSTab MOZ_GUARDED_BY(mMonitor);
+  MOZ_INIT_OUTSIDE_CTOR LayersObserverEpoch mPaintWhileInterruptingJSEpoch
+      MOZ_GUARDED_BY(mMonitor);
+  bool mCancelContentJS MOZ_GUARDED_BY(mMonitor);
+  TabId mCancelContentJSTab MOZ_GUARDED_BY(mMonitor);
+  nsIRemoteTab::NavigationType mCancelContentJSNavigationType
+      MOZ_GUARDED_BY(mMonitor);
+  int32_t mCancelContentJSNavigationIndex MOZ_GUARDED_BY(mMonitor);
+  mozilla::Maybe<nsCString> mCancelContentJSNavigationURI
+      MOZ_GUARDED_BY(mMonitor);
+  int32_t mCancelContentJSEpoch MOZ_GUARDED_BY(mMonitor);
+  bool mShutdownDone MOZ_GUARDED_BY(mMonitor);
+
+  JSContext* mContext;  // const after constructor
+
+  // This field is only accessed on the hang thread.
+  bool mIPCOpen;
+
+  // Allows us to ensure we NotifyActivity only once, allowing
+  // either thread to do so.
+  Atomic<bool> mPaintWhileInterruptingJSActive;
+};
+
+StaticRefPtr<HangMonitorChild> HangMonitorChild::sInstance;
+
+/* Parent process objects */
+
+class HangMonitorParent;
+
+class HangMonitoredProcess final : public nsIHangReport {
+ public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  HangMonitoredProcess(HangMonitorParent* aActor, ContentParent* aContentParent)
+      : mActor(aActor), mContentParent(aContentParent) {}
+
+  NS_DECL_NSIHANGREPORT
+
+  // Called when a content process shuts down.
+  void Clear() {
+    mContentParent = nullptr;
+    mActor = nullptr;
+  }
+
+  /**
+   * Sets the information associated with this hang: this includes the tab ID,
+   * filename, duration, and an add-on ID if it was caused by an add-on.
+   *
+   * @param aDumpId The ID of a minidump taken when the hang occurred
+   */
+  void SetSlowScriptData(const SlowScriptData& aSlowScriptData,
+                         const nsAString& aDumpId) {
+    mSlowScriptData = aSlowScriptData;
+    mDumpId = aDumpId;
+  }
+
+  void ClearHang() {
+    mSlowScriptData = SlowScriptData();
+    mDumpId.Truncate();
+  }
+
+ private:
+  ~HangMonitoredProcess() = default;
+
+  // Everything here is main thread-only.
+  HangMonitorParent* mActor;
+  ContentParent* mContentParent;
+  SlowScriptData mSlowScriptData;
+  nsAutoString mDumpId;
+};
+
+class HangMonitorParent : public PProcessHangMonitorParent {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING_WITH_DELETE_ON_MAIN_THREAD(
+      HangMonitorParent, override)
+
+  explicit HangMonitorParent(ProcessHangMonitor* aMonitor);
+
+  void Bind(Endpoint<PProcessHangMonitorParent>&& aEndpoint);
+
+  mozilla::ipc::IPCResult RecvHangEvidence(
+      const SlowScriptData& aSlowScriptData) override;
+  mozilla::ipc::IPCResult RecvClearHang() override;
+
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  void SetProcess(HangMonitoredProcess* aProcess) { mProcess = aProcess; }
+
+  void Shutdown();
+
+  void PaintWhileInterruptingJS(dom::BrowserParent* aTab,
+                                const LayersObserverEpoch& aEpoch);
+
+  void UnloadLayersWhileInterruptingJS(dom::BrowserParent* aTab,
+                                       const LayersObserverEpoch& aEpoch);
+  void CancelContentJSExecutionIfRunning(
+      dom::BrowserParent* aBrowserParent,
+      nsIRemoteTab::NavigationType aNavigationType,
+      const dom::CancelContentJSOptions& aCancelContentJSOptions);
+
+  void TerminateScript();
+  void BeginStartingDebugger();
+  void EndStartingDebugger();
+
+  nsresult Dispatch(already_AddRefed<nsIRunnable> aRunnable) {
+    return mHangMonitor->Dispatch(std::move(aRunnable));
+  }
+  bool IsOnThread() { return mHangMonitor->IsOnThread(); }
+
+ private:
+  ~HangMonitorParent() override;
+
+  void SendHangNotification(const SlowScriptData& aSlowScriptData,
+                            const nsString& aBrowserDumpId);
+
+  void ClearHangNotification();
+
+  void PaintOrUnloadLayersWhileInterruptingJSOnThread(
+      bool aPaint, TabId aTabId, const LayersObserverEpoch& aEpoch);
+  void CancelContentJSExecutionIfRunningOnThread(
+      TabId aTabId, nsIRemoteTab::NavigationType aNavigationType,
+      int32_t aNavigationIndex, nsIURI* aNavigationURI, int32_t aEpoch);
+
+  void ShutdownOnThread();
+
+  const RefPtr<ProcessHangMonitor> mHangMonitor;
+
+  // This field is only accessed on the hang thread.
+  bool mIPCOpen;
+
+  Monitor mMonitor;
+
+  // MainThread only
+  RefPtr<HangMonitoredProcess> mProcess;
+
+  // Must be accessed with mMonitor held.
+  bool mShutdownDone MOZ_GUARDED_BY(mMonitor);
+  // Map from plugin ID to crash dump ID. Protected by
+  // mBrowserCrashDumpHashLock.
+  nsTHashMap<nsUint32HashKey, nsString> mBrowserCrashDumpIds
+      MOZ_GUARDED_BY(mMonitor);
+  Mutex mBrowserCrashDumpHashLock MOZ_GUARDED_BY(mMonitor);
+  mozilla::ipc::TaskFactory<HangMonitorParent> mMainThreadTaskFactory
+      MOZ_GUARDED_BY(mMonitor);
+};
+
+}  // namespace
+
+/* HangMonitorChild implementation */
+
+HangMonitorChild::HangMonitorChild(ProcessHangMonitor* aMonitor)
+    : mHangMonitor(aMonitor),
+      mMonitor("HangMonitorChild lock"),
+      mSentReport(false),
+      mTerminateScript(false),
+      mStartDebugger(false),
+      mFinishedStartingDebugger(false),
+      mCancelContentJS(false),
+      mCancelContentJSNavigationType(nsIRemoteTab::NAVIGATE_BACK),
+      mCancelContentJSNavigationIndex(0),
+      mCancelContentJSEpoch(0),
+      mShutdownDone(false),
+      mIPCOpen(true),
+      mPaintWhileInterruptingJSActive(false) {
+  ReleaseAssertIsOnMainThread();
+  MOZ_ASSERT(!sInstance);
+
+  mContext = danger::GetJSContext();
+}
+
+HangMonitorChild::~HangMonitorChild() {
+  ReleaseAssertIsOnMainThread();
+  MOZ_ASSERT(sInstance != this);
+}
+
+void HangMonitorChild::CreateAndBind(
+    ProcessHangMonitor* aMonitor,
+    Endpoint<PProcessHangMonitorChild>&& aEndpoint) {
+  ReleaseAssertIsOnMainThread();
+  MOZ_ASSERT(!sInstance);
+
+  sInstance = new HangMonitorChild(aMonitor);
+
+  BackgroundHangMonitor::RegisterAnnotator(*sInstance);
+
+  aMonitor->Dispatch(NewRunnableMethod<Endpoint<PProcessHangMonitorChild>&&>(
+      "HangMonitorChild::Bind", sInstance.get(), &HangMonitorChild::Bind,
+      std::move(aEndpoint)));
+}
+
+bool HangMonitorChild::InterruptCallback() {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+  if (StaticPrefs::dom_abort_script_on_child_shutdown() &&
+      mozilla::ipc::ProcessChild::ExpectingShutdown()) {
+    // We preserve chrome JS from cancel, but not extension content JS.
+    if (!nsContentUtils::IsCallerChrome()) {
+      NS_WARNING(
+          "HangMonitorChild::InterruptCallback: ExpectingShutdown, "
+          "canceling content JS execution.\n");
+      return false;
+    }
+    return true;
+  }
+
+  // Don't start painting if we're not in a good place to run script. We run
+  // chrome script during layout and such, and it wouldn't be good to interrupt
+  // painting code from there.
+  if (!nsContentUtils::IsSafeToRunScript()) {
+    return true;
+  }
+
+  Maybe<bool> paintWhileInterruptingJS;
+  TabId paintWhileInterruptingJSTab;
+  LayersObserverEpoch paintWhileInterruptingJSEpoch;
+
+  {
+    MonitorAutoLock lock(mMonitor);
+    paintWhileInterruptingJS = mPaintWhileInterruptingJS;
+    paintWhileInterruptingJSTab = mPaintWhileInterruptingJSTab;
+    paintWhileInterruptingJSEpoch = mPaintWhileInterruptingJSEpoch;
+
+    mPaintWhileInterruptingJS.reset();
+  }
+
+  if (paintWhileInterruptingJS.isSome()) {
+    RefPtr<BrowserChild> browserChild =
+        BrowserChild::FindBrowserChild(paintWhileInterruptingJSTab);
+    if (browserChild) {
+      js::AutoAssertNoContentJS nojs(mContext);
+      if (paintWhileInterruptingJS.value()) {
+        browserChild->PaintWhileInterruptingJS(paintWhileInterruptingJSEpoch);
+      } else {
+        browserChild->UnloadLayersWhileInterruptingJS(
+            paintWhileInterruptingJSEpoch);
+      }
+    }
+  }
+
+  // Only handle the interrupt for cancelling content JS if we have a
+  // non-privileged script (i.e. not part of Gecko or an add-on).
+  JS::Rooted<JSObject*> global(mContext, JS::CurrentGlobalOrNull(mContext));
+  nsIPrincipal* principal = xpc::GetObjectPrincipal(global);
+  if (principal && (principal->IsSystemPrincipal() ||
+                    principal->GetIsAddonOrExpandedAddonPrincipal())) {
+    return true;
+  }
+
+  nsCOMPtr<nsPIDOMWindowInner> win = xpc::WindowOrNull(global);
+  if (!win) {
+    return true;
+  }
+
+  bool cancelContentJS;
+  TabId cancelContentJSTab;
+  nsIRemoteTab::NavigationType cancelContentJSNavigationType;
+  int32_t cancelContentJSNavigationIndex;
+  mozilla::Maybe<nsCString> cancelContentJSNavigationURI;
+  int32_t cancelContentJSEpoch;
+
+  {
+    MonitorAutoLock lock(mMonitor);
+    cancelContentJS = mCancelContentJS;
+    cancelContentJSTab = mCancelContentJSTab;
+    cancelContentJSNavigationType = mCancelContentJSNavigationType;
+    cancelContentJSNavigationIndex = mCancelContentJSNavigationIndex;
+    cancelContentJSNavigationURI = std::move(mCancelContentJSNavigationURI);
+    cancelContentJSEpoch = mCancelContentJSEpoch;
+
+    mCancelContentJS = false;
+  }
+
+  if (cancelContentJS) {
+    js::AutoAssertNoContentJS nojs(mContext);
+
+    RefPtr<BrowserChild> browserChild =
+        BrowserChild::FindBrowserChild(cancelContentJSTab);
+    RefPtr<BrowserChild> browserChildFromWin = BrowserChild::GetFrom(win);
+    if (!browserChild || !browserChildFromWin) {
+      return true;
+    }
+
+    TabId tabIdFromWin = browserChildFromWin->GetTabId();
+    if (tabIdFromWin != cancelContentJSTab) {
+      // The currently-executing content JS doesn't belong to the tab that
+      // requested cancellation of JS. Just return and let the JS continue.
+      return true;
+    }
+
+    nsresult rv;
+    nsCOMPtr<nsIURI> uri;
+
+    if (cancelContentJSNavigationURI) {
+      rv = NS_NewURI(getter_AddRefs(uri), cancelContentJSNavigationURI.value());
+      if (NS_FAILED(rv)) {
+        return true;
+      }
+    }
+
+    bool canCancel;
+    rv = browserChild->CanCancelContentJS(cancelContentJSNavigationType,
+                                          cancelContentJSNavigationIndex, uri,
+                                          cancelContentJSEpoch, &canCancel);
+    if (NS_SUCCEEDED(rv) && canCancel) {
+      // Don't add this page to the BF cache, since we're cancelling its JS.
+      if (Document* doc = win->GetExtantDoc()) {
+        doc->DisallowBFCaching();
+      }
+
+      return false;
+    }
+  }
+
+  return true;
+}
+
+void HangMonitorChild::AnnotateHang(BackgroundHangAnnotations& aAnnotations) {
+  if (mPaintWhileInterruptingJSActive) {
+    aAnnotations.AddAnnotation(u"PaintWhileInterruptingJS"_ns, true);
+  }
+}
+
+void HangMonitorChild::Shutdown() {
+  ReleaseAssertIsOnMainThread();
+
+  BackgroundHangMonitor::UnregisterAnnotator(*this);
+
+  {
+    MonitorAutoLock lock(mMonitor);
+    while (!mShutdownDone) {
+      mMonitor.Wait();
+    }
+  }
+
+  MOZ_ASSERT(sInstance == this);
+  sInstance = nullptr;
+}
+
+void HangMonitorChild::ShutdownOnThread() {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  MonitorAutoLock lock(mMonitor);
+  mShutdownDone = true;
+  mMonitor.Notify();
+}
+
+void HangMonitorChild::ActorDestroy(ActorDestroyReason aWhy) {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  mIPCOpen = false;
+
+  // We use a task here to ensure that IPDL is finished with this
+  // HangMonitorChild before it gets deleted on the main thread.
+  Dispatch(NewNonOwningRunnableMethod("HangMonitorChild::ShutdownOnThread",
+                                      this,
+                                      &HangMonitorChild::ShutdownOnThread));
+}
+
+mozilla::ipc::IPCResult HangMonitorChild::RecvTerminateScript() {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  MonitorAutoLock lock(mMonitor);
+  mTerminateScript = true;
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult HangMonitorChild::RecvRequestContentJSInterrupt() {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  // In order to cancel JS execution on shutdown, we expect that
+  // ProcessChild::NotifiedImpendingShutdown has been called before.
+  if (mozilla::ipc::ProcessChild::ExpectingShutdown()) {
+    CrashReporter::AppendToCrashReportAnnotation(
+        CrashReporter::Annotation::IPCShutdownState,
+        "HangMonitorChild::RecvRequestContentJSInterrupt (expected)"_ns);
+  } else {
+    CrashReporter::AppendToCrashReportAnnotation(
+        CrashReporter::Annotation::IPCShutdownState,
+        "HangMonitorChild::RecvRequestContentJSInterrupt (unexpected)"_ns);
+  }
+  JS_RequestInterruptCallback(mContext);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult HangMonitorChild::RecvBeginStartingDebugger() {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  MonitorAutoLock lock(mMonitor);
+  mStartDebugger = true;
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult HangMonitorChild::RecvEndStartingDebugger() {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  MonitorAutoLock lock(mMonitor);
+  mFinishedStartingDebugger = true;
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult HangMonitorChild::RecvPaintWhileInterruptingJS(
+    const TabId& aTabId, const LayersObserverEpoch& aEpoch) {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  {
+    MonitorAutoLock lock(mMonitor);
+    MaybeStartPaintWhileInterruptingJS();
+    mPaintWhileInterruptingJS = Some(true);
+    mPaintWhileInterruptingJSTab = aTabId;
+    mPaintWhileInterruptingJSEpoch = aEpoch;
+  }
+
+  JS_RequestInterruptCallback(mContext);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult HangMonitorChild::RecvUnloadLayersWhileInterruptingJS(
+    const TabId& aTabId, const LayersObserverEpoch& aEpoch) {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  {
+    MonitorAutoLock lock(mMonitor);
+    MaybeStartPaintWhileInterruptingJS();
+    mPaintWhileInterruptingJS = Some(false);
+    mPaintWhileInterruptingJSTab = aTabId;
+    mPaintWhileInterruptingJSEpoch = aEpoch;
+  }
+
+  JS_RequestInterruptCallback(mContext);
+
+  return IPC_OK();
+}
+
+void HangMonitorChild::MaybeStartPaintWhileInterruptingJS() {
+  mPaintWhileInterruptingJSActive = true;
+}
+
+void HangMonitorChild::ClearPaintWhileInterruptingJS(
+    const LayersObserverEpoch& aEpoch) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  MOZ_RELEASE_ASSERT(XRE_IsContentProcess());
+  mPaintWhileInterruptingJSActive = false;
+}
+
+mozilla::ipc::IPCResult HangMonitorChild::RecvCancelContentJSExecutionIfRunning(
+    const TabId& aTabId, const nsIRemoteTab::NavigationType& aNavigationType,
+    const int32_t& aNavigationIndex,
+    const mozilla::Maybe<nsCString>& aNavigationURI, const int32_t& aEpoch) {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  {
+    MonitorAutoLock lock(mMonitor);
+    mCancelContentJS = true;
+    mCancelContentJSTab = aTabId;
+    mCancelContentJSNavigationType = aNavigationType;
+    mCancelContentJSNavigationIndex = aNavigationIndex;
+    mCancelContentJSNavigationURI = aNavigationURI;
+    mCancelContentJSEpoch = aEpoch;
+  }
+
+  JS_RequestInterruptCallback(mContext);
+
+  return IPC_OK();
+}
+
+void HangMonitorChild::Bind(Endpoint<PProcessHangMonitorChild>&& aEndpoint) {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  DebugOnly<bool> ok = aEndpoint.Bind(this);
+  MOZ_ASSERT(ok);
+}
+
+void HangMonitorChild::NotifySlowScriptAsync(TabId aTabId,
+                                             const nsCString& aFileName,
+                                             const nsString& aAddonId,
+                                             const double aDuration) {
+  if (mIPCOpen) {
+    Unused << SendHangEvidence(
+        SlowScriptData(aTabId, aFileName, aAddonId, aDuration));
+  }
+}
+
+HangMonitorChild::SlowScriptAction HangMonitorChild::NotifySlowScript(
+    nsIBrowserChild* aBrowserChild, const char* aFileName,
+    const nsString& aAddonId, const double aDuration) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+  mSentReport = true;
+
+  {
+    MonitorAutoLock lock(mMonitor);
+
+    if (mTerminateScript) {
+      mTerminateScript = false;
+      return SlowScriptAction::Terminate;
+    }
+
+    if (mStartDebugger) {
+      mStartDebugger = false;
+      return SlowScriptAction::StartDebugger;
+    }
+  }
+
+  TabId id;
+  if (aBrowserChild) {
+    RefPtr<BrowserChild> browserChild =
+        static_cast<BrowserChild*>(aBrowserChild);
+    id = browserChild->GetTabId();
+  }
+  nsAutoCString filename(aFileName);
+
+  Dispatch(NewNonOwningRunnableMethod<TabId, nsCString, nsString, double>(
+      "HangMonitorChild::NotifySlowScriptAsync", this,
+      &HangMonitorChild::NotifySlowScriptAsync, id, filename, aAddonId,
+      aDuration));
+  return SlowScriptAction::Continue;
+}
+
+bool HangMonitorChild::IsDebuggerStartupComplete() {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+  MonitorAutoLock lock(mMonitor);
+
+  if (mFinishedStartingDebugger) {
+    mFinishedStartingDebugger = false;
+    return true;
+  }
+
+  return false;
+}
+
+void HangMonitorChild::ClearHang() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mSentReport) {
+    // bounce to background thread
+    Dispatch(NewNonOwningRunnableMethod("HangMonitorChild::ClearHangAsync",
+                                        this,
+                                        &HangMonitorChild::ClearHangAsync));
+
+    MonitorAutoLock lock(mMonitor);
+    mSentReport = false;
+    mTerminateScript = false;
+    mStartDebugger = false;
+    mFinishedStartingDebugger = false;
+  }
+}
+
+void HangMonitorChild::ClearHangAsync() {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  // bounce back to parent on background thread
+  if (mIPCOpen) {
+    Unused << SendClearHang();
+  }
+}
+
+/* HangMonitorParent implementation */
+
+HangMonitorParent::HangMonitorParent(ProcessHangMonitor* aMonitor)
+    : mHangMonitor(aMonitor),
+      mIPCOpen(true),
+      mMonitor("HangMonitorParent lock"),
+      mShutdownDone(false),
+      mBrowserCrashDumpHashLock("mBrowserCrashDumpIds lock"),
+      mMainThreadTaskFactory(this) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+}
+
+HangMonitorParent::~HangMonitorParent() {
+  MutexAutoLock lock(mBrowserCrashDumpHashLock);
+
+  for (const auto& crashId : mBrowserCrashDumpIds.Values()) {
+    if (!crashId.IsEmpty()) {
+      CrashReporter::DeleteMinidumpFilesForID(crashId);
+    }
+  }
+}
+
+void HangMonitorParent::Shutdown() {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+  MonitorAutoLock lock(mMonitor);
+
+  if (mProcess) {
+    mProcess->Clear();
+    mProcess = nullptr;
+  }
+
+  nsresult rv = Dispatch(
+      NewNonOwningRunnableMethod("HangMonitorParent::ShutdownOnThread", this,
+                                 &HangMonitorParent::ShutdownOnThread));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return;
+  }
+
+  while (!mShutdownDone) {
+    mMonitor.Wait();
+  }
+}
+
+void HangMonitorParent::ShutdownOnThread() {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  // mIPCOpen is only written from this thread, so need need to take the lock
+  // here. We'd be shooting ourselves in the foot, because ActorDestroy takes
+  // it.
+  if (mIPCOpen) {
+    Close();
+  }
+
+  MonitorAutoLock lock(mMonitor);
+  mShutdownDone = true;
+  mMonitor.Notify();
+}
+
+void HangMonitorParent::PaintWhileInterruptingJS(
+    dom::BrowserParent* aTab, const LayersObserverEpoch& aEpoch) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  if (StaticPrefs::browser_tabs_remote_force_paint()) {
+    TabId id = aTab->GetTabId();
+    Dispatch(NewNonOwningRunnableMethod<bool, TabId, LayersObserverEpoch>(
+        "HangMonitorParent::PaintOrUnloadLayersWhileInterruptingJSOnThread ",
+        this,
+        &HangMonitorParent::PaintOrUnloadLayersWhileInterruptingJSOnThread,
+        true, id, aEpoch));
+  }
+}
+
+void HangMonitorParent::UnloadLayersWhileInterruptingJS(
+    dom::BrowserParent* aTab, const LayersObserverEpoch& aEpoch) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  TabId id = aTab->GetTabId();
+  Dispatch(NewNonOwningRunnableMethod<bool, TabId, LayersObserverEpoch>(
+      "HangMonitorParent::PaintOrUnloadLayersWhileInterruptingJSOnThread ",
+      this, &HangMonitorParent::PaintOrUnloadLayersWhileInterruptingJSOnThread,
+      false, id, aEpoch));
+}
+
+void HangMonitorParent::PaintOrUnloadLayersWhileInterruptingJSOnThread(
+    const bool aPaint, TabId aTabId, const LayersObserverEpoch& aEpoch) {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  if (mIPCOpen) {
+    if (aPaint) {
+      Unused << SendPaintWhileInterruptingJS(aTabId, aEpoch);
+    } else {
+      Unused << SendUnloadLayersWhileInterruptingJS(aTabId, aEpoch);
+    }
+  }
+}
+
+void HangMonitorParent::CancelContentJSExecutionIfRunning(
+    dom::BrowserParent* aBrowserParent,
+    nsIRemoteTab::NavigationType aNavigationType,
+    const dom::CancelContentJSOptions& aCancelContentJSOptions) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+  if (!aBrowserParent->CanCancelContentJS(aNavigationType,
+                                          aCancelContentJSOptions.mIndex,
+                                          aCancelContentJSOptions.mUri)) {
+    return;
+  }
+
+  TabId id = aBrowserParent->GetTabId();
+  Dispatch(NewNonOwningRunnableMethod<TabId, nsIRemoteTab::NavigationType,
+                                      int32_t, nsIURI*, int32_t>(
+      "HangMonitorParent::CancelContentJSExecutionIfRunningOnThread", this,
+      &HangMonitorParent::CancelContentJSExecutionIfRunningOnThread, id,
+      aNavigationType, aCancelContentJSOptions.mIndex,
+      aCancelContentJSOptions.mUri, aCancelContentJSOptions.mEpoch));
+}
+
+void HangMonitorParent::CancelContentJSExecutionIfRunningOnThread(
+    TabId aTabId, nsIRemoteTab::NavigationType aNavigationType,
+    int32_t aNavigationIndex, nsIURI* aNavigationURI, int32_t aEpoch) {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  mozilla::Maybe<nsCString> spec;
+  if (aNavigationURI) {
+    nsAutoCString tmp;
+    nsresult rv = aNavigationURI->GetSpec(tmp);
+    if (NS_SUCCEEDED(rv)) {
+      spec.emplace(tmp);
+    }
+  }
+
+  if (mIPCOpen) {
+    Unused << SendCancelContentJSExecutionIfRunning(
+        aTabId, aNavigationType, aNavigationIndex, spec, aEpoch);
+  }
+}
+
+void HangMonitorParent::ActorDestroy(ActorDestroyReason aWhy) {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+  mIPCOpen = false;
+}
+
+void HangMonitorParent::Bind(Endpoint<PProcessHangMonitorParent>&& aEndpoint) {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  DebugOnly<bool> ok = aEndpoint.Bind(this);
+  MOZ_ASSERT(ok);
+}
+
+void HangMonitorParent::SendHangNotification(
+    const SlowScriptData& aSlowScriptData, const nsString& aBrowserDumpId) {
+  // chrome process, main thread
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+  nsString dumpId;
+
+  // We already have a full minidump; go ahead and use it.
+  dumpId = aBrowserDumpId;
+
+  mProcess->SetSlowScriptData(aSlowScriptData, dumpId);
+
+  nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+  observerService->NotifyObservers(mProcess, "process-hang-report", nullptr);
+}
+
+void HangMonitorParent::ClearHangNotification() {
+  // chrome process, main thread
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+  nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+  observerService->NotifyObservers(mProcess, "clear-hang-report", nullptr);
+
+  mProcess->ClearHang();
+}
+
+mozilla::ipc::IPCResult HangMonitorParent::RecvHangEvidence(
+    const SlowScriptData& aSlowScriptData) {
+  // chrome process, background thread
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  if (!StaticPrefs::dom_ipc_reportProcessHangs()) {
+    return IPC_OK();
+  }
+
+#ifdef XP_WIN
+  // Don't report hangs if we're debugging the process. You can comment this
+  // line out for testing purposes.
+  if (IsDebuggerPresent()) {
+    return IPC_OK();
+  }
+#endif
+
+  // Before we wake up the browser main thread we want to take a
+  // browser minidump.
+  nsAutoString crashId;
+
+  mHangMonitor->InitiateCPOWTimeout();
+
+  MonitorAutoLock lock(mMonitor);
+
+  NS_DispatchToMainThread(mMainThreadTaskFactory.NewRunnableMethod(
+      &HangMonitorParent::SendHangNotification, aSlowScriptData, crashId));
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult HangMonitorParent::RecvClearHang() {
+  // chrome process, background thread
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  if (!StaticPrefs::dom_ipc_reportProcessHangs()) {
+    return IPC_OK();
+  }
+
+  mHangMonitor->InitiateCPOWTimeout();
+
+  MonitorAutoLock lock(mMonitor);
+
+  NS_DispatchToMainThread(mMainThreadTaskFactory.NewRunnableMethod(
+      &HangMonitorParent::ClearHangNotification));
+
+  return IPC_OK();
+}
+
+void HangMonitorParent::TerminateScript() {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  if (mIPCOpen) {
+    Unused << SendTerminateScript();
+  }
+}
+
+void HangMonitorParent::BeginStartingDebugger() {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  if (mIPCOpen) {
+    Unused << SendBeginStartingDebugger();
+  }
+}
+
+void HangMonitorParent::EndStartingDebugger() {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+
+  if (mIPCOpen) {
+    Unused << SendEndStartingDebugger();
+  }
+}
+
+/* HangMonitoredProcess implementation */
+
+NS_IMPL_ISUPPORTS(HangMonitoredProcess, nsIHangReport)
+
+NS_IMETHODIMP
+HangMonitoredProcess::GetHangDuration(double* aHangDuration) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  *aHangDuration = mSlowScriptData.duration();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HangMonitoredProcess::GetScriptBrowser(Element** aBrowser) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  TabId tabId = mSlowScriptData.tabId();
+  if (!mContentParent) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  nsTArray<PBrowserParent*> tabs;
+  mContentParent->ManagedPBrowserParent(tabs);
+  for (size_t i = 0; i < tabs.Length(); i++) {
+    BrowserParent* tp = BrowserParent::GetFrom(tabs[i]);
+    if (tp->GetTabId() == tabId) {
+      RefPtr<Element> node = tp->GetOwnerElement();
+      node.forget(aBrowser);
+      return NS_OK;
+    }
+  }
+
+  *aBrowser = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HangMonitoredProcess::GetScriptFileName(nsACString& aFileName) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  aFileName = mSlowScriptData.filename();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HangMonitoredProcess::GetAddonId(nsAString& aAddonId) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  aAddonId = mSlowScriptData.addonId();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HangMonitoredProcess::TerminateScript() {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  if (!mActor) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  ProcessHangMonitor::Get()->Dispatch(
+      NewNonOwningRunnableMethod("HangMonitorParent::TerminateScript", mActor,
+                                 &HangMonitorParent::TerminateScript));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HangMonitoredProcess::BeginStartingDebugger() {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  if (!mActor) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  ProcessHangMonitor::Get()->Dispatch(NewNonOwningRunnableMethod(
+      "HangMonitorParent::BeginStartingDebugger", mActor,
+      &HangMonitorParent::BeginStartingDebugger));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HangMonitoredProcess::EndStartingDebugger() {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  if (!mActor) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  ProcessHangMonitor::Get()->Dispatch(NewNonOwningRunnableMethod(
+      "HangMonitorParent::EndStartingDebugger", mActor,
+      &HangMonitorParent::EndStartingDebugger));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HangMonitoredProcess::IsReportForBrowserOrChildren(nsFrameLoader* aFrameLoader,
+                                                   bool* aResult) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  MOZ_RELEASE_ASSERT(XRE_IsParentProcess());
+
+  if (!mActor) {
+    *aResult = false;
+    return NS_OK;
+  }
+
+  NS_ENSURE_STATE(aFrameLoader);
+
+  AutoTArray<RefPtr<BrowsingContext>, 10> bcs;
+  bcs.AppendElement(aFrameLoader->GetExtantBrowsingContext());
+  while (!bcs.IsEmpty()) {
+    RefPtr<BrowsingContext> bc = bcs[bcs.Length() - 1];
+    bcs.RemoveLastElement();
+    if (!bc) {
+      continue;
+    }
+    if (mContentParent == bc->Canonical()->GetContentParent()) {
+      *aResult = true;
+      return NS_OK;
+    }
+    bc->GetChildren(bcs);
+  }
+
+  *aResult = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HangMonitoredProcess::UserCanceled() { return NS_OK; }
+
+NS_IMETHODIMP
+HangMonitoredProcess::GetChildID(uint64_t* aChildID) {
+  if (!mContentParent) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  *aChildID = mContentParent->ChildID();
+  return NS_OK;
+}
+
+static bool InterruptCallback(JSContext* cx) {
+  AssertIsOnMainThread();
+  if (HangMonitorChild* child = HangMonitorChild::Get()) {
+    return child->InterruptCallback();
+  }
+
+  return true;
+}
+
+ProcessHangMonitor* ProcessHangMonitor::sInstance;
+
+ProcessHangMonitor::ProcessHangMonitor() : mCPOWTimeout(false) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+  if (XRE_IsContentProcess()) {
+    nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+    obs->AddObserver(this, "xpcom-shutdown", false);
+  }
+
+  if (NS_FAILED(NS_NewNamedThread("ProcessHangMon", getter_AddRefs(mThread)))) {
+    mThread = nullptr;
+  }
+}
+
+ProcessHangMonitor::~ProcessHangMonitor() {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+  MOZ_ASSERT(sInstance == this);
+  sInstance = nullptr;
+
+  mThread->Shutdown();
+  mThread = nullptr;
+}
+
+ProcessHangMonitor* ProcessHangMonitor::GetOrCreate() {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  if (!sInstance) {
+    sInstance = new ProcessHangMonitor();
+  }
+  return sInstance;
+}
+
+NS_IMPL_ISUPPORTS(ProcessHangMonitor, nsIObserver)
+
+NS_IMETHODIMP
+ProcessHangMonitor::Observe(nsISupports* aSubject, const char* aTopic,
+                            const char16_t* aData) {
+  ReleaseAssertIsOnMainThread();
+  if (!strcmp(aTopic, "xpcom-shutdown")) {
+    if (RefPtr<HangMonitorChild> child = HangMonitorChild::Get()) {
+      child->Shutdown();
+    }
+
+    nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+    obs->RemoveObserver(this, "xpcom-shutdown");
+  }
+  return NS_OK;
+}
+
+ProcessHangMonitor::SlowScriptAction ProcessHangMonitor::NotifySlowScript(
+    nsIBrowserChild* aBrowserChild, const char* aFileName,
+    const nsString& aAddonId, const double aDuration) {
+  ReleaseAssertIsOnMainThread();
+  return HangMonitorChild::Get()->NotifySlowScript(aBrowserChild, aFileName,
+                                                   aAddonId, aDuration);
+}
+
+bool ProcessHangMonitor::IsDebuggerStartupComplete() {
+  ReleaseAssertIsOnMainThread();
+  return HangMonitorChild::Get()->IsDebuggerStartupComplete();
+}
+
+bool ProcessHangMonitor::ShouldTimeOutCPOWs() {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+  if (mCPOWTimeout) {
+    mCPOWTimeout = false;
+    return true;
+  }
+  return false;
+}
+
+void ProcessHangMonitor::InitiateCPOWTimeout() {
+  MOZ_RELEASE_ASSERT(IsOnThread());
+  mCPOWTimeout = true;
+}
+
+static already_AddRefed<PProcessHangMonitorParent> CreateHangMonitorParent(
+    ContentParent* aContentParent,
+    Endpoint<PProcessHangMonitorParent>&& aEndpoint) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+  ProcessHangMonitor* monitor = ProcessHangMonitor::GetOrCreate();
+  RefPtr<HangMonitorParent> parent = new HangMonitorParent(monitor);
+
+  auto* process = new HangMonitoredProcess(parent, aContentParent);
+  parent->SetProcess(process);
+
+  monitor->Dispatch(
+      NewNonOwningRunnableMethod<Endpoint<PProcessHangMonitorParent>&&>(
+          "HangMonitorParent::Bind", parent, &HangMonitorParent::Bind,
+          std::move(aEndpoint)));
+
+  return parent.forget();
+}
+
+void mozilla::CreateHangMonitorChild(
+    Endpoint<PProcessHangMonitorChild>&& aEndpoint) {
+  ReleaseAssertIsOnMainThread();
+
+  JSContext* cx = danger::GetJSContext();
+  JS_AddInterruptCallback(cx, InterruptCallback);
+
+  ProcessHangMonitor* monitor = ProcessHangMonitor::GetOrCreate();
+  HangMonitorChild::CreateAndBind(monitor, std::move(aEndpoint));
+}
+
+nsresult ProcessHangMonitor::Dispatch(already_AddRefed<nsIRunnable> aRunnable) {
+  return mThread->Dispatch(std::move(aRunnable),
+                           nsIEventTarget::NS_DISPATCH_NORMAL);
+}
+
+bool ProcessHangMonitor::IsOnThread() {
+  bool on;
+  return NS_SUCCEEDED(mThread->IsOnCurrentThread(&on)) && on;
+}
+
+/* static */
+already_AddRefed<PProcessHangMonitorParent> ProcessHangMonitor::AddProcess(
+    ContentParent* aContentParent) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+
+  if (!StaticPrefs::dom_ipc_processHangMonitor_AtStartup()) {
+    return nullptr;
+  }
+
+  Endpoint<PProcessHangMonitorParent> parent;
+  Endpoint<PProcessHangMonitorChild> child;
+  nsresult rv;
+  rv = PProcessHangMonitor::CreateEndpoints(&parent, &child);
+  if (NS_FAILED(rv)) {
+    MOZ_ASSERT(false, "PProcessHangMonitor::CreateEndpoints failed");
+    return nullptr;
+  }
+
+  if (!aContentParent->SendInitProcessHangMonitor(std::move(child))) {
+    MOZ_ASSERT(false);
+    return nullptr;
+  }
+
+  return CreateHangMonitorParent(aContentParent, std::move(parent));
+}
+
+/* static */
+void ProcessHangMonitor::RemoveProcess(PProcessHangMonitorParent* aParent) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  auto parent = static_cast<HangMonitorParent*>(aParent);
+  parent->Shutdown();
+}
+
+/* static */
+void ProcessHangMonitor::ClearHang() {
+  AssertIsOnMainThread();
+  if (HangMonitorChild* child = HangMonitorChild::Get()) {
+    child->ClearHang();
+  }
+}
+
+/* static */
+void ProcessHangMonitor::PaintWhileInterruptingJS(
+    PProcessHangMonitorParent* aParent, dom::BrowserParent* aTab,
+    const layers::LayersObserverEpoch& aEpoch) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  auto* parent = static_cast<HangMonitorParent*>(aParent);
+  parent->PaintWhileInterruptingJS(aTab, aEpoch);
+}
+
+/* static */
+void ProcessHangMonitor::UnloadLayersWhileInterruptingJS(
+    PProcessHangMonitorParent* aParent, dom::BrowserParent* aTab,
+    const layers::LayersObserverEpoch& aEpoch) {
+  MOZ_RELEASE_ASSERT(NS_IsMainThread());
+  auto* parent = static_cast<HangMonitorParent*>(aParent);
+  parent->UnloadLayersWhileInterruptingJS(aTab, aEpoch);
+}
+
+/* static */
+void ProcessHangMonitor::ClearPaintWhileInterruptingJS(
+    const layers::LayersObserverEpoch& aEpoch) {
+  ReleaseAssertIsOnMainThread();
+  MOZ_RELEASE_ASSERT(XRE_IsContentProcess());
+
+  if (HangMonitorChild* child = HangMonitorChild::Get()) {
+    child->ClearPaintWhileInterruptingJS(aEpoch);
+  }
+}
+
+/* static */
+void ProcessHangMonitor::MaybeStartPaintWhileInterruptingJS() {
+  ReleaseAssertIsOnMainThread();
+  MOZ_RELEASE_ASSERT(XRE_IsContentProcess());
+
+  if (HangMonitorChild* child = HangMonitorChild::Get()) {
+    child->MaybeStartPaintWhileInterruptingJS();
+  }
+}
+
+/* static */
+void ProcessHangMonitor::CancelContentJSExecutionIfRunning(
+    PProcessHangMonitorParent* aParent, dom::BrowserParent* aBrowserParent,
+    nsIRemoteTab::NavigationType aNavigationType,
+    const dom::CancelContentJSOptions& aCancelContentJSOptions) {
+  ReleaseAssertIsOnMainThread();
+  auto* parent = static_cast<HangMonitorParent*>(aParent);
+  parent->CancelContentJSExecutionIfRunning(aBrowserParent, aNavigationType,
+                                            aCancelContentJSOptions);
+}
diff --git a/dom/ipc/ProcessHangMonitor.h b/dom/ipc/ProcessHangMonitor.h
new file mode 100644
index 0000000000..13324c2eda
--- /dev/null
+++ b/dom/ipc/ProcessHangMonitor.h
@@ -0,0 +1,100 @@
+/* -*- 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/. */
+
+#ifndef mozilla_ProcessHangMonitor_h
+#define mozilla_ProcessHangMonitor_h
+
+#include "mozilla/AlreadyAddRefed.h"
+#include "mozilla/Atomics.h"
+#include "nsCOMPtr.h"
+#include "nsIObserver.h"
+#include "nsIRemoteTab.h"
+#include "nsStringFwd.h"
+
+class nsIRunnable;
+class nsIBrowserChild;
+class nsIThread;
+
+namespace mozilla {
+
+namespace dom {
+class ContentParent;
+class BrowserParent;
+struct CancelContentJSOptions;
+}  // namespace dom
+
+namespace layers {
+struct LayersObserverEpoch;
+}  // namespace layers
+
+class PProcessHangMonitorParent;
+
+class ProcessHangMonitor final : public nsIObserver {
+ private:
+  ProcessHangMonitor();
+  virtual ~ProcessHangMonitor();
+
+ public:
+  static ProcessHangMonitor* Get() { return sInstance; }
+  static ProcessHangMonitor* GetOrCreate();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+
+  static already_AddRefed<PProcessHangMonitorParent> AddProcess(
+      dom::ContentParent* aContentParent);
+  static void RemoveProcess(PProcessHangMonitorParent* aParent);
+
+  static void ClearHang();
+
+  static void PaintWhileInterruptingJS(
+      PProcessHangMonitorParent* aParent, dom::BrowserParent* aTab,
+      const layers::LayersObserverEpoch& aEpoch);
+
+  static void UnloadLayersWhileInterruptingJS(
+      PProcessHangMonitorParent* aParent, dom::BrowserParent* aTab,
+      const layers::LayersObserverEpoch& aEpoch);
+
+  static void ClearPaintWhileInterruptingJS(
+      const layers::LayersObserverEpoch& aEpoch);
+  static void MaybeStartPaintWhileInterruptingJS();
+
+  static void CancelContentJSExecutionIfRunning(
+      PProcessHangMonitorParent* aParent, dom::BrowserParent* aTab,
+      nsIRemoteTab::NavigationType aNavigationType,
+      const dom::CancelContentJSOptions& aCancelContentJSOptions);
+
+  enum SlowScriptAction {
+    Continue,
+    Terminate,
+    StartDebugger,
+  };
+  SlowScriptAction NotifySlowScript(nsIBrowserChild* aBrowserChild,
+                                    const char* aFileName,
+                                    const nsString& aAddonId,
+                                    const double aDuration);
+
+  void NotifyPluginHang(uint32_t aPluginId);
+
+  bool IsDebuggerStartupComplete();
+
+  void InitiateCPOWTimeout();
+  bool ShouldTimeOutCPOWs();
+
+  nsresult Dispatch(already_AddRefed<nsIRunnable> aRunnable);
+  bool IsOnThread();
+
+ private:
+  static ProcessHangMonitor* sInstance;
+
+  Atomic<bool> mCPOWTimeout;
+
+  nsCOMPtr<nsIThread> mThread;
+};
+
+}  // namespace mozilla
+
+#endif  // mozilla_ProcessHangMonitor_h
diff --git a/dom/ipc/ProcessHangMonitorIPC.h b/dom/ipc/ProcessHangMonitorIPC.h
new file mode 100644
index 0000000000..c40ffa7d3b
--- /dev/null
+++ b/dom/ipc/ProcessHangMonitorIPC.h
@@ -0,0 +1,28 @@
+/* -*- 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/. */
+
+#ifndef mozilla_ProcessHangMonitorIPC_h
+#define mozilla_ProcessHangMonitorIPC_h
+
+#include "base/task.h"
+#include "base/thread.h"
+
+#include "mozilla/PProcessHangMonitor.h"
+#include "mozilla/PProcessHangMonitorParent.h"
+#include "mozilla/PProcessHangMonitorChild.h"
+
+namespace mozilla {
+
+namespace dom {
+class ContentParent;
+}  // namespace dom
+
+void CreateHangMonitorChild(
+    ipc::Endpoint<PProcessHangMonitorChild>&& aEndpoint);
+
+}  // namespace mozilla
+
+#endif  // mozilla_ProcessHangMonitorIPC_h
diff --git a/dom/ipc/ProcessIsolation.cpp b/dom/ipc/ProcessIsolation.cpp
new file mode 100644
index 0000000000..cd223e647f
--- /dev/null
+++ b/dom/ipc/ProcessIsolation.cpp
@@ -0,0 +1,956 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et 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 "mozilla/dom/ProcessIsolation.h"
+
+#include "mozilla/Assertions.h"
+#include "mozilla/dom/BrowsingContextGroup.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/RemoteType.h"
+#include "mozilla/dom/WindowGlobalParent.h"
+#include "mozilla/extensions/WebExtensionPolicy.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/ContentPrincipal.h"
+#include "mozilla/ExtensionPolicyService.h"
+#include "mozilla/Logging.h"
+#include "mozilla/NullPrincipal.h"
+#include "mozilla/PermissionManager.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/StaticPrefs_browser.h"
+#include "mozilla/StaticPrefs_fission.h"
+#include "mozilla/StaticPtr.h"
+#include "nsAboutProtocolUtils.h"
+#include "nsDocShell.h"
+#include "nsError.h"
+#include "nsIChromeRegistry.h"
+#include "nsIHttpChannel.h"
+#include "nsIHttpChannelInternal.h"
+#include "nsIProtocolHandler.h"
+#include "nsIXULRuntime.h"
+#include "nsNetUtil.h"
+#include "nsServiceManagerUtils.h"
+#include "nsSHistory.h"
+#include "nsURLHelper.h"
+
+namespace mozilla::dom {
+
+mozilla::LazyLogModule gProcessIsolationLog{"ProcessIsolation"};
+
+namespace {
+
+// Strategy used to determine whether or not a particular site should load into
+// a webIsolated content process. The particular strategy chosen is controlled
+// by the `fission.webContentIsolationStrategy` pref, which must hold one of the
+// following values.
+enum class WebContentIsolationStrategy : uint32_t {
+  // All web content is loaded into a shared `web` content process. This is
+  // similar to the non-Fission behaviour, however remote subframes may still
+  // be used for sites with special isolation behaviour, such as extension or
+  // mozillaweb content processes.
+  IsolateNothing = 0,
+  // Web content is always isolated into its own `webIsolated` content process
+  // based on site-origin, and will only load in a shared `web` content process
+  // if site-origin could not be determined.
+  IsolateEverything = 1,
+  // Only isolates web content loaded by sites which are considered "high
+  // value". A site is considered "high value" if it has been granted a
+  // `highValue*` permission by the permission manager, which is done in
+  // response to certain actions.
+  IsolateHighValue = 2,
+};
+
+/**
+ * Helper class for caching the result of splitting prefs which are represented
+ * as a comma-separated list of strings.
+ */
+struct CommaSeparatedPref {
+ public:
+  explicit constexpr CommaSeparatedPref(nsLiteralCString aPrefName)
+      : mPrefName(aPrefName) {}
+
+  void OnChange() {
+    if (mValues) {
+      mValues->Clear();
+      nsAutoCString prefValue;
+      if (NS_SUCCEEDED(Preferences::GetCString(mPrefName.get(), prefValue))) {
+        for (const auto& value :
+             nsCCharSeparatedTokenizer(prefValue, ',').ToRange()) {
+          mValues->EmplaceBack(value);
+        }
+      }
+    }
+  }
+
+  const nsTArray<nsCString>& Get() {
+    if (!mValues) {
+      mValues = new nsTArray<nsCString>;
+      Preferences::RegisterCallbackAndCall(
+          [](const char*, void* aData) {
+            static_cast<CommaSeparatedPref*>(aData)->OnChange();
+          },
+          mPrefName, this);
+      RunOnShutdown([this] {
+        delete this->mValues;
+        this->mValues = nullptr;
+      });
+    }
+    return *mValues;
+  }
+
+  auto begin() { return Get().cbegin(); }
+  auto end() { return Get().cend(); }
+
+ private:
+  nsLiteralCString mPrefName;
+  nsTArray<nsCString>* MOZ_OWNING_REF mValues = nullptr;
+};
+
+CommaSeparatedPref sSeparatedMozillaDomains{
+    "browser.tabs.remote.separatedMozillaDomains"_ns};
+
+/**
+ * Certain URIs have special isolation behaviour, and need to be loaded within
+ * specific process types.
+ */
+enum class IsolationBehavior {
+  // This URI loads web content and should be treated as a content load, being
+  // isolated based on the response principal.
+  WebContent,
+  // Forcibly load in a process with the "web" remote type.
+  ForceWebRemoteType,
+  // Load this URI in the privileged about content process.
+  PrivilegedAbout,
+  // Load this URI in the extension process.
+  Extension,
+  // Load this URI in the file content process.
+  File,
+  // Load this URI in the priviliged mozilla content process.
+  PrivilegedMozilla,
+  // Load this URI explicitly in the parent process.
+  Parent,
+  // Load this URI wherever the browsing context is currently loaded. This is
+  // generally used for error pages.
+  Anywhere,
+  // May only be returned for subframes. Inherits the remote type of the parent
+  // document which is embedding this document.
+  Inherit,
+  // Special case for the `about:reader` URI which should be loaded in the same
+  // process which would be used for the "url" query parameter.
+  AboutReader,
+  // There was a fatal error, and the load should be aborted.
+  Error,
+};
+
+/**
+ * Returns a static string with the name of the given isolation behaviour. For
+ * use in logging code.
+ */
+static const char* IsolationBehaviorName(IsolationBehavior aBehavior) {
+  switch (aBehavior) {
+    case IsolationBehavior::WebContent:
+      return "WebContent";
+    case IsolationBehavior::ForceWebRemoteType:
+      return "ForceWebRemoteType";
+    case IsolationBehavior::PrivilegedAbout:
+      return "PrivilegedAbout";
+    case IsolationBehavior::Extension:
+      return "Extension";
+    case IsolationBehavior::File:
+      return "File";
+    case IsolationBehavior::PrivilegedMozilla:
+      return "PrivilegedMozilla";
+    case IsolationBehavior::Parent:
+      return "Parent";
+    case IsolationBehavior::Anywhere:
+      return "Anywhere";
+    case IsolationBehavior::Inherit:
+      return "Inherit";
+    case IsolationBehavior::AboutReader:
+      return "AboutReader";
+    case IsolationBehavior::Error:
+      return "Error";
+    default:
+      return "Unknown";
+  }
+}
+
+/**
+ * Check if a given URI has specialized process isolation behaviour, such as
+ * needing to be loaded within a specific type of content process.
+ *
+ * When handling a navigation, this method will be called twice: first with the
+ * channel's creation URI, and then it will be called with a result principal's
+ * URI.
+ */
+static IsolationBehavior IsolationBehaviorForURI(nsIURI* aURI, bool aIsSubframe,
+                                                 bool aForChannelCreationURI) {
+  nsAutoCString scheme;
+  MOZ_ALWAYS_SUCCEEDS(aURI->GetScheme(scheme));
+
+  if (scheme == "chrome"_ns) {
+    // `chrome://` URIs are always loaded in the parent process, unless they
+    // have opted in to loading in a content process. This is currently only
+    // done in tests.
+    //
+    // FIXME: These flags should be removed from `chrome` URIs at some point.
+    nsCOMPtr<nsIXULChromeRegistry> chromeReg =
+        do_GetService("@mozilla.org/chrome/chrome-registry;1");
+    bool mustLoadRemotely = false;
+    if (NS_SUCCEEDED(chromeReg->MustLoadURLRemotely(aURI, &mustLoadRemotely)) &&
+        mustLoadRemotely) {
+      return IsolationBehavior::ForceWebRemoteType;
+    }
+    bool canLoadRemotely = false;
+    if (NS_SUCCEEDED(chromeReg->CanLoadURLRemotely(aURI, &canLoadRemotely)) &&
+        canLoadRemotely) {
+      return IsolationBehavior::Anywhere;
+    }
+    return IsolationBehavior::Parent;
+  }
+
+  if (scheme == "about"_ns) {
+    nsAutoCString path;
+    MOZ_ALWAYS_SUCCEEDS(NS_GetAboutModuleName(aURI, path));
+
+    // The `about:blank` and `about:srcdoc` pages are loaded by normal web
+    // content, and should be allocated processes based on their simple content
+    // principals.
+    if (path == "blank"_ns || path == "srcdoc"_ns) {
+      MOZ_ASSERT(NS_IsContentAccessibleAboutURI(aURI));
+      return IsolationBehavior::WebContent;
+    }
+
+    MOZ_ASSERT(!NS_IsContentAccessibleAboutURI(aURI));
+    // If we're loading an `about:reader` URI, perform isolation based on the
+    // principal of the URI being loaded.
+    if (path == "reader"_ns && aForChannelCreationURI) {
+      return IsolationBehavior::AboutReader;
+    }
+
+    // Otherwise, we're going to be loading an about: page. Consult the module.
+    nsCOMPtr<nsIAboutModule> aboutModule;
+    if (NS_FAILED(NS_GetAboutModule(aURI, getter_AddRefs(aboutModule))) ||
+        !aboutModule) {
+      // If we don't know of an about: module for this load, it's going to end
+      // up being a network error. Allow the load to finish as normal.
+      return IsolationBehavior::WebContent;
+    }
+
+    // NOTE: about modules can be implemented in JS, so this may run script, and
+    // therefore can spuriously fail.
+    uint32_t flags = 0;
+    if (NS_FAILED(aboutModule->GetURIFlags(aURI, &flags))) {
+      NS_WARNING(
+          "nsIAboutModule::GetURIFlags unexpectedly failed. Abort the load");
+      return IsolationBehavior::Error;
+    }
+
+    if (flags & nsIAboutModule::URI_MUST_LOAD_IN_EXTENSION_PROCESS) {
+      return IsolationBehavior::Extension;
+    }
+
+    if (flags & nsIAboutModule::URI_MUST_LOAD_IN_CHILD) {
+      if (flags & nsIAboutModule::URI_CAN_LOAD_IN_PRIVILEGEDABOUT_PROCESS) {
+        return IsolationBehavior::PrivilegedAbout;
+      }
+      return IsolationBehavior::ForceWebRemoteType;
+    }
+
+    if (flags & nsIAboutModule::URI_CAN_LOAD_IN_CHILD) {
+      return IsolationBehavior::Anywhere;
+    }
+
+    return IsolationBehavior::Parent;
+  }
+
+  // If the test-only `dataUriInDefaultWebProcess` pref is enabled, dump all
+  // `data:` URIs in a "web" content process, rather than loading them in
+  // content processes based on their precursor origins.
+  if (StaticPrefs::browser_tabs_remote_dataUriInDefaultWebProcess() &&
+      scheme == "data"_ns) {
+    return IsolationBehavior::ForceWebRemoteType;
+  }
+
+  // Make sure to unwrap nested URIs before we early return for channel creation
+  // URI. The checks past this point are intended to operate on the principal,
+  // which has it's origin constructed from the innermost URI.
+  nsCOMPtr<nsIURI> inner;
+  if (nsCOMPtr<nsINestedURI> nested = do_QueryInterface(aURI);
+      nested && NS_SUCCEEDED(nested->GetInnerURI(getter_AddRefs(inner)))) {
+    return IsolationBehaviorForURI(inner, aIsSubframe, aForChannelCreationURI);
+  }
+
+  // If we're doing the initial check based on the channel creation URI, stop
+  // here as we want to only perform the following checks on the true channel
+  // result principal.
+  if (aForChannelCreationURI) {
+    return IsolationBehavior::WebContent;
+  }
+
+  // Protocols used by Thunderbird to display email messages.
+  if (scheme == "imap"_ns || scheme == "mailbox"_ns || scheme == "news"_ns ||
+      scheme == "nntp"_ns || scheme == "snews"_ns) {
+    return IsolationBehavior::Parent;
+  }
+
+  // There is more handling for extension content processes in the caller, but
+  // they should load in an extension content process unless we're loading a
+  // subframe.
+  if (scheme == "moz-extension"_ns) {
+    if (aIsSubframe) {
+      // As a temporary measure, extension iframes must be loaded within the
+      // same process as their parent document.
+      return IsolationBehavior::Inherit;
+    }
+    return IsolationBehavior::Extension;
+  }
+
+  if (scheme == "file"_ns) {
+    return IsolationBehavior::File;
+  }
+
+  // Check if the URI is listed as a privileged mozilla content process.
+  if (scheme == "https"_ns &&
+      StaticPrefs::
+          browser_tabs_remote_separatePrivilegedMozillaWebContentProcess()) {
+    nsAutoCString host;
+    if (NS_SUCCEEDED(aURI->GetAsciiHost(host))) {
+      for (const auto& separatedDomain : sSeparatedMozillaDomains) {
+        // If the domain exactly matches our host, or our host ends with "." +
+        // separatedDomain, we consider it matching.
+        if (separatedDomain == host ||
+            (separatedDomain.Length() < host.Length() &&
+             host.CharAt(host.Length() - separatedDomain.Length() - 1) == '.' &&
+             StringEndsWith(host, separatedDomain))) {
+          return IsolationBehavior::PrivilegedMozilla;
+        }
+      }
+    }
+  }
+
+  nsCOMPtr<nsIScriptSecurityManager> secMan =
+      nsContentUtils::GetSecurityManager();
+  bool inFileURIAllowList = false;
+  if (NS_SUCCEEDED(secMan->InFileURIAllowlist(aURI, &inFileURIAllowList)) &&
+      inFileURIAllowList) {
+    return IsolationBehavior::File;
+  }
+
+  return IsolationBehavior::WebContent;
+}
+
+/**
+ * Helper method for logging the origin of a principal as a string.
+ */
+static nsAutoCString OriginString(nsIPrincipal* aPrincipal) {
+  nsAutoCString origin;
+  aPrincipal->GetOrigin(origin);
+  return origin;
+}
+
+/**
+ * Given an about:reader URI, extract the "url" query parameter, and use it to
+ * construct a principal which should be used for process selection.
+ */
+static already_AddRefed<BasePrincipal> GetAboutReaderURLPrincipal(
+    nsIURI* aURI, const OriginAttributes& aAttrs) {
+#ifdef DEBUG
+  MOZ_ASSERT(aURI->SchemeIs("about"));
+  nsAutoCString path;
+  MOZ_ALWAYS_SUCCEEDS(NS_GetAboutModuleName(aURI, path));
+  MOZ_ASSERT(path == "reader"_ns);
+#endif
+
+  nsAutoCString query;
+  MOZ_ALWAYS_SUCCEEDS(aURI->GetQuery(query));
+
+  // Extract the "url" parameter from the `about:reader`'s query parameters,
+  // and recover a content principal from it.
+  nsAutoString readerSpec;
+  if (URLParams::Extract(query, u"url"_ns, readerSpec)) {
+    nsCOMPtr<nsIURI> readerUri;
+    if (NS_SUCCEEDED(NS_NewURI(getter_AddRefs(readerUri), readerSpec))) {
+      return BasePrincipal::CreateContentPrincipal(readerUri, aAttrs);
+    }
+  }
+  return nullptr;
+}
+
+/**
+ * Returns `true` if loads for this site should be isolated on a per-site basis.
+ * If `aTopBC` is nullptr, this is being called to check if a shared or service
+ * worker should be isolated.
+ */
+static bool ShouldIsolateSite(nsIPrincipal* aPrincipal,
+                              CanonicalBrowsingContext* aTopBC) {
+  // If Fission is disabled, we never want to isolate. We check the toplevel BC
+  // if it's available, or the global pref if checking for shared or service
+  // workers.
+  if (aTopBC && !aTopBC->UseRemoteSubframes()) {
+    return false;
+  }
+  if (!aTopBC && !mozilla::FissionAutostart()) {
+    return false;
+  }
+
+  // non-content principals currently can't have webIsolated remote types
+  // assigned to them, so should not be isolated.
+  if (!aPrincipal->GetIsContentPrincipal()) {
+    return false;
+  }
+
+  switch (WebContentIsolationStrategy(
+      StaticPrefs::fission_webContentIsolationStrategy())) {
+    case WebContentIsolationStrategy::IsolateNothing:
+      MOZ_LOG(gProcessIsolationLog, LogLevel::Verbose,
+              ("Not isolating '%s' as isolation is disabled",
+               OriginString(aPrincipal).get()));
+      return false;
+    case WebContentIsolationStrategy::IsolateEverything:
+      MOZ_LOG(gProcessIsolationLog, LogLevel::Verbose,
+              ("Isolating '%s' as isolation is enabled for all sites",
+               OriginString(aPrincipal).get()));
+      return true;
+    case WebContentIsolationStrategy::IsolateHighValue: {
+      RefPtr<PermissionManager> perms = PermissionManager::GetInstance();
+      if (NS_WARN_IF(!perms)) {
+        // If we somehow have no permission manager, fall back to the safest
+        // option, and try to isolate.
+        MOZ_ASSERT_UNREACHABLE("Permission manager is missing");
+        return true;
+      }
+
+      static constexpr nsLiteralCString kHighValuePermissions[] = {
+          mozilla::dom::kHighValueCOOPPermission,
+          mozilla::dom::kHighValueHasSavedLoginPermission,
+          mozilla::dom::kHighValueIsLoggedInPermission,
+      };
+
+      for (const auto& type : kHighValuePermissions) {
+        uint32_t permission = nsIPermissionManager::UNKNOWN_ACTION;
+        if (NS_SUCCEEDED(perms->TestPermissionFromPrincipal(aPrincipal, type,
+                                                            &permission)) &&
+            permission == nsIPermissionManager::ALLOW_ACTION) {
+          MOZ_LOG(gProcessIsolationLog, LogLevel::Verbose,
+                  ("Isolating '%s' due to high-value permission '%s'",
+                   OriginString(aPrincipal).get(), type.get()));
+          return true;
+        }
+      }
+      MOZ_LOG(gProcessIsolationLog, LogLevel::Verbose,
+              ("Not isolating '%s' as it is not high-value",
+               OriginString(aPrincipal).get()));
+      return false;
+    }
+    default:
+      // An invalid pref value was used. Fall back to the safest option and
+      // isolate everything.
+      NS_WARNING("Invalid pref value for fission.webContentIsolationStrategy");
+      MOZ_LOG(gProcessIsolationLog, LogLevel::Verbose,
+              ("Isolating '%s' due to unknown strategy pref value",
+               OriginString(aPrincipal).get()));
+      return true;
+  }
+}
+
+enum class WebProcessType {
+  Web,
+  WebIsolated,
+  WebCoopCoep,
+};
+
+}  // namespace
+
+Result<NavigationIsolationOptions, nsresult> IsolationOptionsForNavigation(
+    CanonicalBrowsingContext* aTopBC, WindowGlobalParent* aParentWindow,
+    nsIURI* aChannelCreationURI, nsIChannel* aChannel,
+    const nsACString& aCurrentRemoteType, bool aHasCOOPMismatch,
+    bool aForNewTab, uint32_t aLoadStateLoadType,
+    const Maybe<uint64_t>& aChannelId,
+    const Maybe<nsCString>& aRemoteTypeOverride) {
+  // Get the final principal, used to select which process to load into.
+  nsCOMPtr<nsIPrincipal> resultPrincipal;
+  nsresult rv = nsContentUtils::GetSecurityManager()->GetChannelResultPrincipal(
+      aChannel, getter_AddRefs(resultPrincipal));
+  if (NS_FAILED(rv)) {
+    MOZ_LOG(gProcessIsolationLog, LogLevel::Error,
+            ("failed to get channel result principal"));
+    return Err(rv);
+  }
+
+  MOZ_LOG(
+      gProcessIsolationLog, LogLevel::Verbose,
+      ("IsolationOptionsForNavigation principal:%s, uri:%s, parentUri:%s",
+       OriginString(resultPrincipal).get(),
+       aChannelCreationURI->GetSpecOrDefault().get(),
+       aParentWindow ? aParentWindow->GetDocumentURI()->GetSpecOrDefault().get()
+                     : ""));
+
+  // If we're loading a null principal, we can't easily make a process
+  // selection decision off ot it. Instead, we'll use our null principal's
+  // precursor principal to make process selection decisions.
+  bool principalIsSandboxed = false;
+  nsCOMPtr<nsIPrincipal> resultOrPrecursor(resultPrincipal);
+  if (nsCOMPtr<nsIPrincipal> precursor =
+          resultOrPrecursor->GetPrecursorPrincipal()) {
+    MOZ_LOG(gProcessIsolationLog, LogLevel::Verbose,
+            ("using null principal precursor origin %s",
+             OriginString(precursor).get()));
+    resultOrPrecursor = precursor;
+    principalIsSandboxed = true;
+  }
+
+  NavigationIsolationOptions options;
+  options.mReplaceBrowsingContext = aHasCOOPMismatch;
+
+  // Check if this load has an explicit remote type override. This is used to
+  // perform an about:blank load within a specific content process.
+  if (aRemoteTypeOverride) {
+    MOZ_DIAGNOSTIC_ASSERT(
+        NS_IsAboutBlank(aChannelCreationURI),
+        "Should only have aRemoteTypeOverride for about:blank URIs");
+    if (NS_WARN_IF(!resultPrincipal->GetIsNullPrincipal())) {
+      MOZ_LOG(gProcessIsolationLog, LogLevel::Error,
+              ("invalid remote type override on non-null principal"));
+      return Err(NS_ERROR_DOM_SECURITY_ERR);
+    }
+
+    MOZ_LOG(gProcessIsolationLog, LogLevel::Verbose,
+            ("using remote type override (%s) for load",
+             aRemoteTypeOverride->get()));
+    options.mRemoteType = *aRemoteTypeOverride;
+    return options;
+  }
+
+  // First, check for any special cases which should be handled using the
+  // channel creation URI, and handle them.
+  auto behavior = IsolationBehaviorForURI(aChannelCreationURI, aParentWindow,
+                                          /* aForChannelCreationURI */ true);
+  MOZ_LOG(gProcessIsolationLog, LogLevel::Verbose,
+          ("Channel Creation Isolation Behavior: %s",
+           IsolationBehaviorName(behavior)));
+
+  // In the about:reader special case, we want to fetch the relevant information
+  // from the URI, an then treat it as a normal web content load.
+  if (behavior == IsolationBehavior::AboutReader) {
+    if (RefPtr<BasePrincipal> readerURIPrincipal = GetAboutReaderURLPrincipal(
+            aChannelCreationURI, resultOrPrecursor->OriginAttributesRef())) {
+      MOZ_LOG(gProcessIsolationLog, LogLevel::Verbose,
+              ("using about:reader's url origin %s",
+               OriginString(readerURIPrincipal).get()));
+      resultOrPrecursor = readerURIPrincipal;
+    }
+    behavior = IsolationBehavior::WebContent;
+    // If loading an about:reader page in a BrowsingContext which shares a
+    // BrowsingContextGroup with other toplevel documents, replace the
+    // BrowsingContext to destroy any references.
+    //
+    // With SHIP we can apply this to all about:reader loads, but otherwise
+    // do it at least where there are opener/group relationships.
+    if (mozilla::SessionHistoryInParent() ||
+        aTopBC->Group()->Toplevels().Length() > 1) {
+      options.mReplaceBrowsingContext = true;
+    }
+  }
+
+  // If we're running in a test which is requesting that system-triggered
+  // about:blank documents load within the current process, override the
+  // behaviour for loads which meet the requirements.
+  if (StaticPrefs::browser_tabs_remote_systemTriggeredAboutBlankAnywhere() &&
+      NS_IsAboutBlank(aChannelCreationURI)) {
+    nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
+    if (loadInfo->TriggeringPrincipal()->IsSystemPrincipal() &&
+        resultOrPrecursor->GetIsNullPrincipal()) {
+      MOZ_LOG(gProcessIsolationLog, LogLevel::Warning,
+              ("Forcing system-principal triggered about:blank load to "
+               "complete in the current process"));
+      behavior = IsolationBehavior::Anywhere;
+    }
+  }
+
+  // If we're loading for a specific extension, we'll need to perform a
+  // BCG-switching load to get our toplevel extension window in the correct
+  // BrowsingContextGroup.
+  if (auto* addonPolicy =
+          BasePrincipal::Cast(resultOrPrecursor)->AddonPolicy()) {
+    if (aParentWindow) {
+      // As a temporary measure, extension iframes must be loaded within the
+      // same process as their parent document.
+      MOZ_LOG(gProcessIsolationLog, LogLevel::Verbose,
+              ("Loading extension subframe in same process as parent"));
+      behavior = IsolationBehavior::Inherit;
+    } else {
+      MOZ_LOG(
+          gProcessIsolationLog, LogLevel::Verbose,
+          ("Found extension frame with addon policy. Will use group id %" PRIx64
+           " (currentId: %" PRIx64 ")",
+           addonPolicy->GetBrowsingContextGroupId(), aTopBC->Group()->Id()));
+      behavior = IsolationBehavior::Extension;
+      if (aTopBC->Group()->Id() != addonPolicy->GetBrowsingContextGroupId()) {
+        options.mReplaceBrowsingContext = true;
+        options.mSpecificGroupId = addonPolicy->GetBrowsingContextGroupId();
+      }
+    }
+  }
+
+  // Do a second run of `GetIsolationBehavior`, this time using the
+  // principal's URI to handle additional special cases such as the file and
+  // privilegedmozilla content process.
+  if (behavior == IsolationBehavior::WebContent) {
+    if (resultOrPrecursor->IsSystemPrincipal()) {
+      // We're loading something with a system principal which isn't caught in
+      // one of our other edge-cases. If the load started in the parent process,
+      // and it's safe for it to end in the parent process, we should finish the
+      // load there.
+      bool isUIResource = false;
+      if (aCurrentRemoteType.IsEmpty() &&
+          (aChannelCreationURI->SchemeIs("about") ||
+           (NS_SUCCEEDED(NS_URIChainHasFlags(
+                aChannelCreationURI, nsIProtocolHandler::URI_IS_UI_RESOURCE,
+                &isUIResource)) &&
+            isUIResource))) {
+        behavior = IsolationBehavior::Parent;
+      } else {
+        // In general, we don't want to load documents with a system principal
+        // in a content process, however we need to in some cases, such as when
+        // loading blob: URLs created by system code. We can force the load to
+        // finish in a content process instead.
+        behavior = IsolationBehavior::ForceWebRemoteType;
+      }
+    } else if (nsCOMPtr<nsIURI> principalURI = resultOrPrecursor->GetURI()) {
+      behavior = IsolationBehaviorForURI(principalURI, aParentWindow,
+                                         /* aForChannelCreationURI */ false);
+    }
+  }
+
+  // If we're currently loaded in the extension process, and are going to switch
+  // to some other remote type, make sure we leave the extension's BCG which we
+  // may have entered earlier to separate extension and non-extension BCGs from
+  // each-other.
+  if (!aParentWindow && aCurrentRemoteType == EXTENSION_REMOTE_TYPE &&
+      behavior != IsolationBehavior::Extension &&
+      behavior != IsolationBehavior::Anywhere) {
+    MOZ_LOG(gProcessIsolationLog, LogLevel::Verbose,
+            ("Forcing BC replacement to leave extension BrowsingContextGroup "
+             "%" PRIx64 " on navigation",
+             aTopBC->Group()->Id()));
+    options.mReplaceBrowsingContext = true;
+  }
+
+  // We don't want to load documents with sandboxed null principals, like
+  // `data:` URIs, in the parent process, even if they were created by a
+  // document which would otherwise be loaded in the parent process.
+  if (behavior == IsolationBehavior::Parent && principalIsSandboxed) {
+    MOZ_LOG(gProcessIsolationLog, LogLevel::Debug,
+            ("Ensuring sandboxed null-principal load doesn't occur in the "
+             "parent process"));
+    behavior = IsolationBehavior::ForceWebRemoteType;
+  }
+
+  MOZ_LOG(
+      gProcessIsolationLog, LogLevel::Debug,
+      ("Using IsolationBehavior %s for %s (original uri %s)",
+       IsolationBehaviorName(behavior), OriginString(resultOrPrecursor).get(),
+       aChannelCreationURI->GetSpecOrDefault().get()));
+
+  // Check if we can put the previous document into the BFCache.
+  if (mozilla::BFCacheInParent() && nsSHistory::GetMaxTotalViewers() > 0 &&
+      !aForNewTab && !aParentWindow && !aTopBC->HadOriginalOpener() &&
+      behavior != IsolationBehavior::Parent &&
+      (ExtensionPolicyService::GetSingleton().UseRemoteExtensions() ||
+       behavior != IsolationBehavior::Extension) &&
+      !aCurrentRemoteType.IsEmpty() &&
+      aTopBC->GetHasLoadedNonInitialDocument() &&
+      (aLoadStateLoadType == LOAD_NORMAL ||
+       aLoadStateLoadType == LOAD_HISTORY || aLoadStateLoadType == LOAD_LINK ||
+       aLoadStateLoadType == LOAD_STOP_CONTENT ||
+       aLoadStateLoadType == LOAD_STOP_CONTENT_AND_REPLACE) &&
+      (!aTopBC->GetActiveSessionHistoryEntry() ||
+       aTopBC->GetActiveSessionHistoryEntry()->GetSaveLayoutStateFlag())) {
+    if (nsCOMPtr<nsIURI> uri = aTopBC->GetCurrentURI()) {
+      MOZ_LOG(gProcessIsolationLog, LogLevel::Verbose,
+              ("current uri: %s", uri->GetSpecOrDefault().get()));
+    }
+    options.mTryUseBFCache =
+        aTopBC->AllowedInBFCache(aChannelId, aChannelCreationURI);
+    if (options.mTryUseBFCache) {
+      options.mReplaceBrowsingContext = true;
+      options.mActiveSessionHistoryEntry =
+          aTopBC->GetActiveSessionHistoryEntry();
+    }
+  }
+
+  // If the load has any special remote type handling, do so at this point.
+  if (behavior != IsolationBehavior::WebContent) {
+    switch (behavior) {
+      case IsolationBehavior::ForceWebRemoteType:
+        options.mRemoteType = WEB_REMOTE_TYPE;
+        break;
+      case IsolationBehavior::PrivilegedAbout:
+        // The privileged about: content process cannot be disabled, as it
+        // causes various actors to break.
+        options.mRemoteType = PRIVILEGEDABOUT_REMOTE_TYPE;
+        break;
+      case IsolationBehavior::Extension:
+        if (ExtensionPolicyService::GetSingleton().UseRemoteExtensions()) {
+          options.mRemoteType = EXTENSION_REMOTE_TYPE;
+        } else {
+          options.mRemoteType = NOT_REMOTE_TYPE;
+        }
+        break;
+      case IsolationBehavior::File:
+        if (StaticPrefs::browser_tabs_remote_separateFileUriProcess()) {
+          options.mRemoteType = FILE_REMOTE_TYPE;
+        } else {
+          options.mRemoteType = WEB_REMOTE_TYPE;
+        }
+        break;
+      case IsolationBehavior::PrivilegedMozilla:
+        options.mRemoteType = PRIVILEGEDMOZILLA_REMOTE_TYPE;
+        break;
+      case IsolationBehavior::Parent:
+        options.mRemoteType = NOT_REMOTE_TYPE;
+        break;
+      case IsolationBehavior::Anywhere:
+        options.mRemoteType = aCurrentRemoteType;
+        break;
+      case IsolationBehavior::Inherit:
+        MOZ_DIAGNOSTIC_ASSERT(aParentWindow);
+        options.mRemoteType = aParentWindow->GetRemoteType();
+        break;
+
+      case IsolationBehavior::WebContent:
+      case IsolationBehavior::AboutReader:
+        MOZ_ASSERT_UNREACHABLE();
+        return Err(NS_ERROR_UNEXPECTED);
+
+      case IsolationBehavior::Error:
+        return Err(NS_ERROR_UNEXPECTED);
+    }
+
+    if (options.mRemoteType != aCurrentRemoteType &&
+        (options.mRemoteType.IsEmpty() || aCurrentRemoteType.IsEmpty())) {
+      options.mReplaceBrowsingContext = true;
+    }
+
+    MOZ_LOG(
+        gProcessIsolationLog, LogLevel::Debug,
+        ("Selecting specific remote type (%s) due to a special case isolation "
+         "behavior %s",
+         options.mRemoteType.get(), IsolationBehaviorName(behavior)));
+    return options;
+  }
+
+  // At this point we're definitely not going to be loading in the parent
+  // process anymore, so we're definitely going to be replacing BrowsingContext
+  // if we're in the parent process.
+  if (aCurrentRemoteType.IsEmpty()) {
+    MOZ_ASSERT(!aParentWindow);
+    options.mReplaceBrowsingContext = true;
+  }
+
+  nsAutoCString siteOriginNoSuffix;
+  MOZ_TRY(resultOrPrecursor->GetSiteOriginNoSuffix(siteOriginNoSuffix));
+
+  // Check if we've already loaded a document with the given principal in some
+  // content process. We want to finish the load in the same process in that
+  // case.
+  //
+  // The exception to that is with extension loads and the system principal,
+  // where we may have multiple documents with the same principal in different
+  // processes. Those have been handled above, and will not be reaching here.
+  //
+  // If we're doing a replace load or opening a new tab, we won't be staying in
+  // the same BrowsingContextGroup, so ignore this step.
+  if (!options.mReplaceBrowsingContext && !aForNewTab) {
+    // Helper for efficiently determining if a given origin is same-site. This
+    // will attempt to do a fast equality check, and will only fall back to
+    // computing the site-origin for content principals.
+    auto principalIsSameSite = [&](nsIPrincipal* aDocumentPrincipal) -> bool {
+      // If we're working with a null principal with a precursor, compare
+      // precursors, as `resultOrPrecursor` has already been stripped to its
+      // precursor.
+      nsCOMPtr<nsIPrincipal> documentPrincipal(aDocumentPrincipal);
+      if (nsCOMPtr<nsIPrincipal> precursor =
+              documentPrincipal->GetPrecursorPrincipal()) {
+        documentPrincipal = precursor;
+      }
+
+      // First, attempt to use `Equals` to compare principals, and if that
+      // fails compare siteOrigins. Only compare siteOrigin for content
+      // principals, as non-content principals will never have siteOrigin !=
+      // origin.
+      nsAutoCString documentSiteOrigin;
+      return resultOrPrecursor->Equals(documentPrincipal) ||
+             (documentPrincipal->GetIsContentPrincipal() &&
+              resultOrPrecursor->GetIsContentPrincipal() &&
+              NS_SUCCEEDED(documentPrincipal->GetSiteOriginNoSuffix(
+                  documentSiteOrigin)) &&
+              documentSiteOrigin == siteOriginNoSuffix);
+    };
+
+    // XXX: Consider also checking in-flight process switches to see if any have
+    // matching principals?
+    AutoTArray<RefPtr<BrowsingContext>, 8> contexts;
+    aTopBC->Group()->GetToplevels(contexts);
+    while (!contexts.IsEmpty()) {
+      auto bc = contexts.PopLastElement();
+      for (const auto& wc : bc->GetWindowContexts()) {
+        WindowGlobalParent* wgp = wc->Canonical();
+
+        // Check if this WindowGlobalParent has the given resultPrincipal, and
+        // if it does, we need to load in that process.
+        if (!wgp->GetRemoteType().IsEmpty() &&
+            principalIsSameSite(wgp->DocumentPrincipal())) {
+          MOZ_LOG(gProcessIsolationLog, LogLevel::Debug,
+                  ("Found existing frame with matching principal "
+                   "(remoteType:(%s), origin:%s)",
+                   PromiseFlatCString(wgp->GetRemoteType()).get(),
+                   OriginString(wgp->DocumentPrincipal()).get()));
+          options.mRemoteType = wgp->GetRemoteType();
+          return options;
+        }
+
+        // Also enumerate over this WindowContexts' subframes.
+        contexts.AppendElements(wc->Children());
+      }
+    }
+  }
+
+  nsAutoCString originSuffix;
+  OriginAttributes attrs = resultOrPrecursor->OriginAttributesRef();
+  attrs.StripAttributes(OriginAttributes::STRIP_FIRST_PARTY_DOMAIN |
+                        OriginAttributes::STRIP_PARITION_KEY);
+  attrs.CreateSuffix(originSuffix);
+
+  WebProcessType webProcessType = WebProcessType::Web;
+  if (ShouldIsolateSite(resultOrPrecursor, aTopBC)) {
+    webProcessType = WebProcessType::WebIsolated;
+  }
+
+  // Check if we should be loading in a webCOOP+COEP remote type due to our COOP
+  // status.
+  nsILoadInfo::CrossOriginOpenerPolicy coop =
+      nsILoadInfo::OPENER_POLICY_UNSAFE_NONE;
+  if (aParentWindow) {
+    coop = aTopBC->GetOpenerPolicy();
+  } else if (nsCOMPtr<nsIHttpChannelInternal> httpChannel =
+                 do_QueryInterface(aChannel)) {
+    MOZ_ALWAYS_SUCCEEDS(httpChannel->GetCrossOriginOpenerPolicy(&coop));
+  }
+  if (coop ==
+      nsILoadInfo::OPENER_POLICY_SAME_ORIGIN_EMBEDDER_POLICY_REQUIRE_CORP) {
+    webProcessType = WebProcessType::WebCoopCoep;
+
+    // If we're changing BrowsingContext, and are going to end up within a
+    // webCOOP+COEP group, ensure we use a cross-origin isolated BCG ID.
+    if (options.mReplaceBrowsingContext) {
+      MOZ_ASSERT(!options.mSpecificGroupId,
+                 "overriding previously-specified BCG ID");
+      options.mSpecificGroupId = BrowsingContextGroup::CreateId(
+          /* aPotentiallyCrossOriginIsolated */ true);
+    }
+  }
+
+  switch (webProcessType) {
+    case WebProcessType::Web:
+      options.mRemoteType = WEB_REMOTE_TYPE;
+      break;
+    case WebProcessType::WebIsolated:
+      options.mRemoteType =
+          FISSION_WEB_REMOTE_TYPE "="_ns + siteOriginNoSuffix + originSuffix;
+      break;
+    case WebProcessType::WebCoopCoep:
+      options.mRemoteType =
+          WITH_COOP_COEP_REMOTE_TYPE "="_ns + siteOriginNoSuffix + originSuffix;
+      break;
+  }
+  return options;
+}
+
+void AddHighValuePermission(nsIPrincipal* aResultPrincipal,
+                            const nsACString& aPermissionType) {
+  RefPtr<PermissionManager> perms = PermissionManager::GetInstance();
+  if (NS_WARN_IF(!perms)) {
+    return;
+  }
+
+  // We can't act on non-content principals, so if the load was sandboxed, try
+  // to use the unsandboxed precursor principal to add the highValue permission.
+  nsCOMPtr<nsIPrincipal> resultOrPrecursor(aResultPrincipal);
+  if (!aResultPrincipal->GetIsContentPrincipal()) {
+    resultOrPrecursor = aResultPrincipal->GetPrecursorPrincipal();
+    if (!resultOrPrecursor) {
+      return;
+    }
+  }
+
+  // Use the site-origin principal as we want to add the permission for the
+  // entire site, rather than a specific subdomain, as process isolation acts on
+  // a site granularity.
+  nsAutoCString siteOrigin;
+  if (NS_FAILED(resultOrPrecursor->GetSiteOrigin(siteOrigin))) {
+    return;
+  }
+
+  nsCOMPtr<nsIPrincipal> sitePrincipal =
+      BasePrincipal::CreateContentPrincipal(siteOrigin);
+  if (!sitePrincipal || !sitePrincipal->GetIsContentPrincipal()) {
+    return;
+  }
+
+  MOZ_LOG(dom::gProcessIsolationLog, LogLevel::Verbose,
+          ("Adding %s Permission for site '%s'", aPermissionType.BeginReading(),
+           siteOrigin.get()));
+
+  uint32_t expiration = 0;
+  if (aPermissionType.Equals(mozilla::dom::kHighValueCOOPPermission)) {
+    expiration = StaticPrefs::fission_highValue_coop_expiration();
+  } else if (aPermissionType.Equals(
+                 mozilla::dom::kHighValueHasSavedLoginPermission) ||
+             aPermissionType.Equals(
+                 mozilla::dom::kHighValueIsLoggedInPermission)) {
+    expiration = StaticPrefs::fission_highValue_login_expiration();
+  } else {
+    MOZ_ASSERT_UNREACHABLE("Unknown permission type");
+  }
+
+  // XXX: Would be nice if we could use `TimeStamp` here, but there's
+  // unfortunately no convenient way to recover a time in milliseconds since the
+  // unix epoch from `TimeStamp`.
+  int64_t expirationTime =
+      (PR_Now() / PR_USEC_PER_MSEC) + (int64_t(expiration) * PR_MSEC_PER_SEC);
+  Unused << perms->AddFromPrincipal(
+      sitePrincipal, aPermissionType, nsIPermissionManager::ALLOW_ACTION,
+      nsIPermissionManager::EXPIRE_TIME, expirationTime);
+}
+
+void AddHighValuePermission(const nsACString& aOrigin,
+                            const nsACString& aPermissionType) {
+  nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
+  nsCOMPtr<nsIPrincipal> principal;
+  nsresult rv =
+      ssm->CreateContentPrincipalFromOrigin(aOrigin, getter_AddRefs(principal));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return;
+  }
+
+  AddHighValuePermission(principal, aPermissionType);
+}
+
+bool IsIsolateHighValueSiteEnabled() {
+  return mozilla::FissionAutostart() &&
+         WebContentIsolationStrategy(
+             StaticPrefs::fission_webContentIsolationStrategy()) ==
+             WebContentIsolationStrategy::IsolateHighValue;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/ProcessIsolation.h b/dom/ipc/ProcessIsolation.h
new file mode 100644
index 0000000000..5f21ac5745
--- /dev/null
+++ b/dom/ipc/ProcessIsolation.h
@@ -0,0 +1,94 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_ProcessIsolation_h
+#define mozilla_dom_ProcessIsolation_h
+
+#include <stdint.h>
+
+#include "mozilla/Logging.h"
+#include "mozilla/dom/RemoteType.h"
+#include "mozilla/dom/SessionHistoryEntry.h"
+#include "nsString.h"
+#include "nsIPrincipal.h"
+#include "nsIURI.h"
+
+namespace mozilla::dom {
+
+class CanonicalBrowsingContext;
+class WindowGlobalParent;
+
+extern mozilla::LazyLogModule gProcessIsolationLog;
+
+constexpr nsLiteralCString kHighValueCOOPPermission = "highValueCOOP"_ns;
+constexpr nsLiteralCString kHighValueHasSavedLoginPermission =
+    "highValueHasSavedLogin"_ns;
+constexpr nsLiteralCString kHighValueIsLoggedInPermission =
+    "highValueIsLoggedIn"_ns;
+
+// NavigationIsolationOptions is passed through the methods to store the state
+// of the possible process and/or browsing context change.
+struct NavigationIsolationOptions {
+  nsCString mRemoteType;
+  bool mReplaceBrowsingContext = false;
+  uint64_t mSpecificGroupId = 0;
+  bool mTryUseBFCache = false;
+  RefPtr<SessionHistoryEntry> mActiveSessionHistoryEntry;
+};
+
+/**
+ * Given a specific channel, determines which process the navigation should
+ * complete in, and whether or not to perform a BrowsingContext-replace load
+ * or enter the BFCache.
+ *
+ * This method will always return a `NavigationIsolationOptions` even if the
+ * current remote type is compatible. Compatibility with the current process
+ * should be checked at the call-site. An error should only be returned in
+ * exceptional circumstances, and should lead to the load being cancelled.
+ *
+ * This method is only intended for use with document navigations.
+ */
+Result<NavigationIsolationOptions, nsresult> IsolationOptionsForNavigation(
+    CanonicalBrowsingContext* aTopBC, WindowGlobalParent* aParentWindow,
+    nsIURI* aChannelCreationURI, nsIChannel* aChannel,
+    const nsACString& aCurrentRemoteType, bool aHasCOOPMismatch,
+    bool aForNewTab, uint32_t aLoadStateLoadType,
+    const Maybe<uint64_t>& aChannelId,
+    const Maybe<nsCString>& aRemoteTypeOverride);
+
+/**
+ * Adds a `highValue` permission to the permissions database, and make loads of
+ * that origin isolated.
+ *
+ * The 'aPermissionType' parameter indicates why the site is treated as a high
+ * value site. The possible values are:
+ *
+ * kHighValueCOOPPermission
+ *     Called when a document request responds with a
+ * `Cross-Origin-Opener-Policy` header.
+ *
+ * kHighValueHasSavedLoginPermission
+ *     Called for sites that have an associated login saved in the password
+ * manager.
+ *
+ * kHighValueIsLoggedInPermission
+ *     Called when we detect a form with a password is submitted.
+ */
+void AddHighValuePermission(nsIPrincipal* aResultPrincipal,
+                            const nsACString& aPermissionType);
+
+void AddHighValuePermission(const nsACString& aOrigin,
+                            const nsACString& aPermissionType);
+
+/**
+ * Returns true when fission is enabled and the
+ * `fission.webContentIsolationStrategy` pref is set to `IsolateHighValue`.
+ */
+bool IsIsolateHighValueSiteEnabled();
+
+}  // namespace mozilla::dom
+
+#endif
diff --git a/dom/ipc/ProcessPriorityManager.cpp b/dom/ipc/ProcessPriorityManager.cpp
new file mode 100644
index 0000000000..e373d6b3e9
--- /dev/null
+++ b/dom/ipc/ProcessPriorityManager.cpp
@@ -0,0 +1,1027 @@
+/* -*- 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 "ProcessPriorityManager.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/BrowserHost.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/Hal.h"
+#include "mozilla/IntegerPrintfMacros.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/ProfilerMarkers.h"
+#include "mozilla/ProfilerState.h"
+#include "mozilla/Services.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/Unused.h"
+#include "mozilla/Logging.h"
+#include "nsPrintfCString.h"
+#include "nsXULAppAPI.h"
+#include "nsFrameLoader.h"
+#include "nsINamed.h"
+#include "nsIObserverService.h"
+#include "StaticPtr.h"
+#include "nsIObserver.h"
+#include "nsITimer.h"
+#include "nsIPropertyBag2.h"
+#include "nsComponentManagerUtils.h"
+#include "nsCRT.h"
+#include "nsTHashSet.h"
+#include "nsQueryObject.h"
+#include "nsTHashMap.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::hal;
+
+#ifdef XP_WIN
+#  include <process.h>
+#  define getpid _getpid
+#else
+#  include <unistd.h>
+#endif
+
+#ifdef LOG
+#  undef LOG
+#endif
+
+// Use LOGP inside a ParticularProcessPriorityManager method; use LOG
+// everywhere else.  LOGP prints out information about the particular process
+// priority manager.
+//
+// (Wow, our logging story is a huge mess.)
+
+// #define ENABLE_LOGGING 1
+
+#if defined(ANDROID) && defined(ENABLE_LOGGING)
+#  include <android/log.h>
+#  define LOG(fmt, ...)                                                        \
+    __android_log_print(ANDROID_LOG_INFO, "Gecko:ProcessPriorityManager", fmt, \
+                        ##__VA_ARGS__)
+#  define LOGP(fmt, ...)                                                \
+    __android_log_print(                                                \
+        ANDROID_LOG_INFO, "Gecko:ProcessPriorityManager",               \
+        "[%schild-id=%" PRIu64 ", pid=%d] " fmt, NameWithComma().get(), \
+        static_cast<uint64_t>(ChildID()), Pid(), ##__VA_ARGS__)
+
+#elif defined(ENABLE_LOGGING)
+#  define LOG(fmt, ...) \
+    printf("ProcessPriorityManager - " fmt "\n", ##__VA_ARGS__)
+#  define LOGP(fmt, ...)                                                   \
+    printf("ProcessPriorityManager[%schild-id=%" PRIu64 ", pid=%d] - " fmt \
+           "\n",                                                           \
+           NameWithComma().get(), static_cast<uint64_t>(ChildID()), Pid(), \
+           ##__VA_ARGS__)
+#else
+static LogModule* GetPPMLog() {
+  static LazyLogModule sLog("ProcessPriorityManager");
+  return sLog;
+}
+#  define LOG(fmt, ...)                   \
+    MOZ_LOG(GetPPMLog(), LogLevel::Debug, \
+            ("ProcessPriorityManager - " fmt, ##__VA_ARGS__))
+#  define LOGP(fmt, ...)                                                      \
+    MOZ_LOG(GetPPMLog(), LogLevel::Debug,                                     \
+            ("ProcessPriorityManager[%schild-id=%" PRIu64 ", pid=%d] - " fmt, \
+             NameWithComma().get(), static_cast<uint64_t>(ChildID()), Pid(),  \
+             ##__VA_ARGS__))
+#endif
+
+namespace geckoprofiler::markers {
+struct SubProcessPriorityChange {
+  static constexpr Span<const char> MarkerTypeName() {
+    return MakeStringSpan("subprocessprioritychange");
+  }
+  static void StreamJSONMarkerData(baseprofiler::SpliceableJSONWriter& aWriter,
+                                   int32_t aPid,
+                                   const ProfilerString8View& aPreviousPriority,
+                                   const ProfilerString8View& aNewPriority) {
+    aWriter.IntProperty("pid", aPid);
+    aWriter.StringProperty("Before", aPreviousPriority);
+    aWriter.StringProperty("After", aNewPriority);
+  }
+  static MarkerSchema MarkerTypeDisplay() {
+    using MS = MarkerSchema;
+    MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable};
+    schema.AddKeyFormat("pid", MS::Format::Integer);
+    schema.AddKeyFormat("Before", MS::Format::String);
+    schema.AddKeyFormat("After", MS::Format::String);
+    schema.SetAllLabels(
+        "priority of child {marker.data.pid}:"
+        " {marker.data.Before} -> {marker.data.After}");
+    return schema;
+  }
+};
+
+struct SubProcessPriority {
+  static constexpr Span<const char> MarkerTypeName() {
+    return MakeStringSpan("subprocesspriority");
+  }
+  static void StreamJSONMarkerData(baseprofiler::SpliceableJSONWriter& aWriter,
+                                   int32_t aPid,
+                                   const ProfilerString8View& aPriority,
+                                   const ProfilingState& aProfilingState) {
+    aWriter.IntProperty("pid", aPid);
+    aWriter.StringProperty("Priority", aPriority);
+    aWriter.StringProperty("Marker cause",
+                           ProfilerString8View::WrapNullTerminatedString(
+                               ProfilingStateToString(aProfilingState)));
+  }
+  static MarkerSchema MarkerTypeDisplay() {
+    using MS = MarkerSchema;
+    MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable};
+    schema.AddKeyFormat("pid", MS::Format::Integer);
+    schema.AddKeyFormat("Priority", MS::Format::String);
+    schema.AddKeyFormat("Marker cause", MS::Format::String);
+    schema.SetAllLabels(
+        "priority of child {marker.data.pid}: {marker.data.Priority}");
+    return schema;
+  }
+};
+}  // namespace geckoprofiler::markers
+
+namespace {
+
+class ParticularProcessPriorityManager;
+
+/**
+ * This singleton class does the work to implement the process priority manager
+ * in the main process.  This class may not be used in child processes.  (You
+ * can call StaticInit, but it won't do anything, and GetSingleton() will
+ * return null.)
+ *
+ * ProcessPriorityManager::CurrentProcessIsForeground() and
+ * ProcessPriorityManager::AnyProcessHasHighPriority() which can be called in
+ * any process, are handled separately, by the ProcessPriorityManagerChild
+ * class.
+ */
+class ProcessPriorityManagerImpl final : public nsIObserver,
+                                         public nsSupportsWeakReference {
+ public:
+  /**
+   * If we're in the main process, get the ProcessPriorityManagerImpl
+   * singleton.  If we're in a child process, return null.
+   */
+  static ProcessPriorityManagerImpl* GetSingleton();
+
+  static void StaticInit();
+  static bool PrefsEnabled();
+  static void SetProcessPriorityIfEnabled(int aPid, ProcessPriority aPriority);
+  static bool TestMode();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+
+  /**
+   * This function implements ProcessPriorityManager::SetProcessPriority.
+   */
+  void SetProcessPriority(ContentParent* aContentParent,
+                          ProcessPriority aPriority);
+
+  /**
+   * If a magic testing-only pref is set, notify the observer service on the
+   * given topic with the given data.  This is used for testing
+   */
+  void FireTestOnlyObserverNotification(const char* aTopic,
+                                        const nsACString& aData);
+
+  /**
+   * This must be called by a ParticularProcessPriorityManager when it changes
+   * its priority.
+   */
+  void NotifyProcessPriorityChanged(
+      ParticularProcessPriorityManager* aParticularManager,
+      hal::ProcessPriority aOldPriority);
+
+  void BrowserPriorityChanged(CanonicalBrowsingContext* aBC, bool aPriority);
+  void BrowserPriorityChanged(BrowserParent* aBrowserParent, bool aPriority);
+
+  void ResetPriority(ContentParent* aContentParent);
+
+ private:
+  static bool sPrefListenersRegistered;
+  static bool sInitialized;
+  static StaticRefPtr<ProcessPriorityManagerImpl> sSingleton;
+
+  static void PrefChangedCallback(const char* aPref, void* aClosure);
+
+  ProcessPriorityManagerImpl();
+  ~ProcessPriorityManagerImpl();
+  ProcessPriorityManagerImpl(const ProcessPriorityManagerImpl&) = delete;
+
+  const ProcessPriorityManagerImpl& operator=(
+      const ProcessPriorityManagerImpl&) = delete;
+
+  void Init();
+
+  already_AddRefed<ParticularProcessPriorityManager>
+  GetParticularProcessPriorityManager(ContentParent* aContentParent);
+
+  void ObserveContentParentDestroyed(nsISupports* aSubject);
+
+  nsTHashMap<uint64_t, RefPtr<ParticularProcessPriorityManager> >
+      mParticularManagers;
+
+  /** Contains the PIDs of child processes holding high-priority wakelocks */
+  nsTHashSet<uint64_t> mHighPriorityChildIDs;
+};
+
+/**
+ * This singleton class implements the parts of the process priority manager
+ * that are available from all processes.
+ */
+class ProcessPriorityManagerChild final : public nsIObserver {
+ public:
+  static void StaticInit();
+  static ProcessPriorityManagerChild* Singleton();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+
+  bool CurrentProcessIsForeground();
+
+ private:
+  static StaticRefPtr<ProcessPriorityManagerChild> sSingleton;
+
+  ProcessPriorityManagerChild();
+  ~ProcessPriorityManagerChild() = default;
+  ProcessPriorityManagerChild(const ProcessPriorityManagerChild&) = delete;
+
+  const ProcessPriorityManagerChild& operator=(
+      const ProcessPriorityManagerChild&) = delete;
+
+  void Init();
+
+  hal::ProcessPriority mCachedPriority;
+};
+
+/**
+ * This class manages the priority of one particular process.  It is
+ * main-process only.
+ */
+class ParticularProcessPriorityManager final : public WakeLockObserver,
+                                               public nsITimerCallback,
+                                               public nsINamed,
+                                               public nsSupportsWeakReference {
+  ~ParticularProcessPriorityManager();
+
+ public:
+  explicit ParticularProcessPriorityManager(ContentParent* aContentParent);
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSITIMERCALLBACK
+
+  virtual void Notify(const WakeLockInformation& aInfo) override;
+  void Init();
+
+  int32_t Pid() const;
+  uint64_t ChildID() const;
+
+  /**
+   * Used in logging, this method returns the ContentParent's name followed by
+   * ", ".  If we can't get the ContentParent's name for some reason, it
+   * returns an empty string.
+   *
+   * The reference returned here is guaranteed to be live until the next call
+   * to NameWithComma() or until the ParticularProcessPriorityManager is
+   * destroyed, whichever comes first.
+   */
+  const nsAutoCString& NameWithComma();
+
+  ProcessPriority CurrentPriority();
+  ProcessPriority ComputePriority();
+
+  enum TimeoutPref {
+    BACKGROUND_PERCEIVABLE_GRACE_PERIOD,
+    BACKGROUND_GRACE_PERIOD,
+  };
+
+  void ScheduleResetPriority(TimeoutPref aTimeoutPref);
+  void ResetPriority();
+  void ResetPriorityNow();
+  void SetPriorityNow(ProcessPriority aPriority);
+
+  void BrowserPriorityChanged(BrowserParent* aBrowserParent, bool aPriority);
+
+  void ShutDown();
+
+  NS_IMETHOD GetName(nsACString& aName) override {
+    aName.AssignLiteral("ParticularProcessPriorityManager");
+    return NS_OK;
+  }
+
+ private:
+  void FireTestOnlyObserverNotification(const char* aTopic, const char* aData);
+
+  bool IsHoldingWakeLock(const nsAString& aTopic);
+
+  ContentParent* mContentParent;
+  uint64_t mChildID;
+  ProcessPriority mPriority;
+  bool mHoldsCPUWakeLock;
+  bool mHoldsHighPriorityWakeLock;
+  bool mHoldsPlayingAudioWakeLock;
+  bool mHoldsPlayingVideoWakeLock;
+
+  /**
+   * Used to implement NameWithComma().
+   */
+  nsAutoCString mNameWithComma;
+
+  nsCOMPtr<nsITimer> mResetPriorityTimer;
+
+  // This hashtable contains the list of high priority TabIds for this process.
+  nsTHashSet<uint64_t> mHighPriorityBrowserParents;
+};
+
+/* static */
+bool ProcessPriorityManagerImpl::sInitialized = false;
+/* static */
+bool ProcessPriorityManagerImpl::sPrefListenersRegistered = false;
+/* static */
+StaticRefPtr<ProcessPriorityManagerImpl> ProcessPriorityManagerImpl::sSingleton;
+
+NS_IMPL_ISUPPORTS(ProcessPriorityManagerImpl, nsIObserver,
+                  nsISupportsWeakReference);
+
+/* static */
+void ProcessPriorityManagerImpl::PrefChangedCallback(const char* aPref,
+                                                     void* aClosure) {
+  StaticInit();
+  if (!PrefsEnabled() && sSingleton) {
+    sSingleton = nullptr;
+    sInitialized = false;
+  }
+}
+
+/* static */
+bool ProcessPriorityManagerImpl::PrefsEnabled() {
+  return StaticPrefs::dom_ipc_processPriorityManager_enabled() &&
+         !StaticPrefs::dom_ipc_tabs_disabled();
+}
+
+/* static */
+void ProcessPriorityManagerImpl::SetProcessPriorityIfEnabled(
+    int aPid, ProcessPriority aPriority) {
+  // The preference doesn't disable the process priority manager, but only its
+  // effect. This way the IPCs still happen and can be used to collect telemetry
+  // about CPU use.
+  if (PrefsEnabled()) {
+    hal::SetProcessPriority(aPid, aPriority);
+  }
+}
+
+/* static */
+bool ProcessPriorityManagerImpl::TestMode() {
+  return StaticPrefs::dom_ipc_processPriorityManager_testMode();
+}
+
+/* static */
+void ProcessPriorityManagerImpl::StaticInit() {
+  if (sInitialized) {
+    return;
+  }
+
+  // The process priority manager is main-process only.
+  if (!XRE_IsParentProcess()) {
+    sInitialized = true;
+    return;
+  }
+
+  // Run StaticInit() again if the prefs change.  We don't expect this to
+  // happen in normal operation, but it happens during testing.
+  if (!sPrefListenersRegistered) {
+    sPrefListenersRegistered = true;
+    Preferences::RegisterCallback(PrefChangedCallback,
+                                  "dom.ipc.processPriorityManager.enabled");
+    Preferences::RegisterCallback(PrefChangedCallback, "dom.ipc.tabs.disabled");
+  }
+
+  sInitialized = true;
+
+  sSingleton = new ProcessPriorityManagerImpl();
+  sSingleton->Init();
+  ClearOnShutdown(&sSingleton);
+}
+
+/* static */
+ProcessPriorityManagerImpl* ProcessPriorityManagerImpl::GetSingleton() {
+  if (!sSingleton) {
+    StaticInit();
+  }
+
+  return sSingleton;
+}
+
+ProcessPriorityManagerImpl::ProcessPriorityManagerImpl() {
+  MOZ_ASSERT(XRE_IsParentProcess());
+}
+
+ProcessPriorityManagerImpl::~ProcessPriorityManagerImpl() = default;
+
+void ProcessPriorityManagerImpl::Init() {
+  LOG("Starting up.  This is the parent process.");
+
+  // The parent process's priority never changes; set it here and then forget
+  // about it. We'll manage only subprocesses' priorities using the process
+  // priority manager.
+  SetProcessPriorityIfEnabled(getpid(), PROCESS_PRIORITY_PARENT_PROCESS);
+
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  if (os) {
+    os->AddObserver(this, "ipc:content-shutdown", /* ownsWeak */ true);
+  }
+}
+
+NS_IMETHODIMP
+ProcessPriorityManagerImpl::Observe(nsISupports* aSubject, const char* aTopic,
+                                    const char16_t* aData) {
+  nsDependentCString topic(aTopic);
+  if (topic.EqualsLiteral("ipc:content-shutdown")) {
+    ObserveContentParentDestroyed(aSubject);
+  } else {
+    MOZ_ASSERT(false);
+  }
+
+  return NS_OK;
+}
+
+already_AddRefed<ParticularProcessPriorityManager>
+ProcessPriorityManagerImpl::GetParticularProcessPriorityManager(
+    ContentParent* aContentParent) {
+  // If this content parent is already being shut down, there's no
+  // need to adjust its priority.
+  if (aContentParent->IsDead()) {
+    return nullptr;
+  }
+
+  const uint64_t cpId = aContentParent->ChildID();
+  return mParticularManagers.WithEntryHandle(cpId, [&](auto&& entry) {
+    if (!entry) {
+      entry.Insert(new ParticularProcessPriorityManager(aContentParent));
+      entry.Data()->Init();
+    }
+    return do_AddRef(entry.Data());
+  });
+}
+
+void ProcessPriorityManagerImpl::SetProcessPriority(
+    ContentParent* aContentParent, ProcessPriority aPriority) {
+  MOZ_ASSERT(aContentParent);
+  if (RefPtr pppm = GetParticularProcessPriorityManager(aContentParent)) {
+    pppm->SetPriorityNow(aPriority);
+  }
+}
+
+void ProcessPriorityManagerImpl::ObserveContentParentDestroyed(
+    nsISupports* aSubject) {
+  nsCOMPtr<nsIPropertyBag2> props = do_QueryInterface(aSubject);
+  NS_ENSURE_TRUE_VOID(props);
+
+  uint64_t childID = CONTENT_PROCESS_ID_UNKNOWN;
+  props->GetPropertyAsUint64(u"childID"_ns, &childID);
+  NS_ENSURE_TRUE_VOID(childID != CONTENT_PROCESS_ID_UNKNOWN);
+
+  if (auto entry = mParticularManagers.Lookup(childID)) {
+    entry.Data()->ShutDown();
+    mHighPriorityChildIDs.Remove(childID);
+    entry.Remove();
+  }
+}
+
+void ProcessPriorityManagerImpl::NotifyProcessPriorityChanged(
+    ParticularProcessPriorityManager* aParticularManager,
+    ProcessPriority aOldPriority) {
+  ProcessPriority newPriority = aParticularManager->CurrentPriority();
+
+  if (newPriority >= PROCESS_PRIORITY_FOREGROUND_HIGH &&
+      aOldPriority < PROCESS_PRIORITY_FOREGROUND_HIGH) {
+    mHighPriorityChildIDs.Insert(aParticularManager->ChildID());
+  } else if (newPriority < PROCESS_PRIORITY_FOREGROUND_HIGH &&
+             aOldPriority >= PROCESS_PRIORITY_FOREGROUND_HIGH) {
+    mHighPriorityChildIDs.Remove(aParticularManager->ChildID());
+  }
+}
+
+static nsCString BCToString(dom::CanonicalBrowsingContext* aBC) {
+  nsCOMPtr<nsIURI> uri = aBC->GetCurrentURI();
+  return nsPrintfCString("id=%" PRIu64 " uri=%s active=%d pactive=%d",
+                         aBC->Id(),
+                         uri ? uri->GetSpecOrDefault().get() : "(no uri)",
+                         aBC->IsActive(), aBC->IsPriorityActive());
+}
+
+void ProcessPriorityManagerImpl::BrowserPriorityChanged(
+    dom::CanonicalBrowsingContext* aBC, bool aPriority) {
+  MOZ_ASSERT(aBC->IsTop());
+
+  LOG("BrowserPriorityChanged(%s, %d)\n", BCToString(aBC).get(), aPriority);
+
+  bool alreadyActive = aBC->IsPriorityActive();
+  if (alreadyActive == aPriority) {
+    return;
+  }
+
+  Telemetry::ScalarAdd(
+      Telemetry::ScalarID::DOM_CONTENTPROCESS_OS_PRIORITY_CHANGE_CONSIDERED, 1);
+
+  aBC->SetPriorityActive(aPriority);
+
+  aBC->PreOrderWalk([&](BrowsingContext* aContext) {
+    CanonicalBrowsingContext* canonical = aContext->Canonical();
+    LOG("PreOrderWalk for %p: %p -> %p, %p\n", aBC, canonical,
+        canonical->GetContentParent(), canonical->GetBrowserParent());
+    if (ContentParent* cp = canonical->GetContentParent()) {
+      if (RefPtr pppm = GetParticularProcessPriorityManager(cp)) {
+        if (auto* bp = canonical->GetBrowserParent()) {
+          pppm->BrowserPriorityChanged(bp, aPriority);
+        }
+      }
+    }
+  });
+}
+
+void ProcessPriorityManagerImpl::BrowserPriorityChanged(
+    BrowserParent* aBrowserParent, bool aPriority) {
+  LOG("BrowserPriorityChanged(bp=%p, %d)\n", aBrowserParent, aPriority);
+
+  if (RefPtr pppm =
+          GetParticularProcessPriorityManager(aBrowserParent->Manager())) {
+    Telemetry::ScalarAdd(
+        Telemetry::ScalarID::DOM_CONTENTPROCESS_OS_PRIORITY_CHANGE_CONSIDERED,
+        1);
+    pppm->BrowserPriorityChanged(aBrowserParent, aPriority);
+  }
+}
+
+void ProcessPriorityManagerImpl::ResetPriority(ContentParent* aContentParent) {
+  if (RefPtr pppm = GetParticularProcessPriorityManager(aContentParent)) {
+    pppm->ResetPriority();
+  }
+}
+
+NS_IMPL_ISUPPORTS(ParticularProcessPriorityManager, nsITimerCallback,
+                  nsISupportsWeakReference, nsINamed);
+
+ParticularProcessPriorityManager::ParticularProcessPriorityManager(
+    ContentParent* aContentParent)
+    : mContentParent(aContentParent),
+      mChildID(aContentParent->ChildID()),
+      mPriority(PROCESS_PRIORITY_UNKNOWN),
+      mHoldsCPUWakeLock(false),
+      mHoldsHighPriorityWakeLock(false),
+      mHoldsPlayingAudioWakeLock(false),
+      mHoldsPlayingVideoWakeLock(false) {
+  MOZ_ASSERT(XRE_IsParentProcess());
+  MOZ_RELEASE_ASSERT(!aContentParent->IsDead());
+  LOGP("Creating ParticularProcessPriorityManager.");
+  // Our static analysis doesn't allow capturing ref-counted pointers in
+  // lambdas, so we need to hide it in a uintptr_t. This is safe because this
+  // lambda will be destroyed in ~ParticularProcessPriorityManager().
+  uintptr_t self = reinterpret_cast<uintptr_t>(this);
+  profiler_add_state_change_callback(
+      AllProfilingStates(),
+      [self](ProfilingState aProfilingState) {
+        const ParticularProcessPriorityManager* selfPtr =
+            reinterpret_cast<const ParticularProcessPriorityManager*>(self);
+        PROFILER_MARKER("Subprocess Priority", OTHER,
+                        MarkerThreadId::MainThread(), SubProcessPriority,
+                        selfPtr->Pid(),
+                        ProfilerString8View::WrapNullTerminatedString(
+                            ProcessPriorityToString(selfPtr->mPriority)),
+                        aProfilingState);
+      },
+      self);
+}
+
+void ParticularProcessPriorityManager::Init() {
+  RegisterWakeLockObserver(this);
+
+  // This process may already hold the CPU lock; for example, our parent may
+  // have acquired it on our behalf.
+  mHoldsCPUWakeLock = IsHoldingWakeLock(u"cpu"_ns);
+  mHoldsHighPriorityWakeLock = IsHoldingWakeLock(u"high-priority"_ns);
+  mHoldsPlayingAudioWakeLock = IsHoldingWakeLock(u"audio-playing"_ns);
+  mHoldsPlayingVideoWakeLock = IsHoldingWakeLock(u"video-playing"_ns);
+
+  LOGP(
+      "Done starting up.  mHoldsCPUWakeLock=%d, "
+      "mHoldsHighPriorityWakeLock=%d, mHoldsPlayingAudioWakeLock=%d, "
+      "mHoldsPlayingVideoWakeLock=%d",
+      mHoldsCPUWakeLock, mHoldsHighPriorityWakeLock, mHoldsPlayingAudioWakeLock,
+      mHoldsPlayingVideoWakeLock);
+}
+
+bool ParticularProcessPriorityManager::IsHoldingWakeLock(
+    const nsAString& aTopic) {
+  WakeLockInformation info;
+  GetWakeLockInfo(aTopic, &info);
+  return info.lockingProcesses().Contains(ChildID());
+}
+
+ParticularProcessPriorityManager::~ParticularProcessPriorityManager() {
+  LOGP("Destroying ParticularProcessPriorityManager.");
+
+  profiler_remove_state_change_callback(reinterpret_cast<uintptr_t>(this));
+
+  ShutDown();
+}
+
+/* virtual */
+void ParticularProcessPriorityManager::Notify(
+    const WakeLockInformation& aInfo) {
+  if (!mContentParent) {
+    // We've been shut down.
+    return;
+  }
+
+  bool* dest = nullptr;
+  if (aInfo.topic().EqualsLiteral("cpu")) {
+    dest = &mHoldsCPUWakeLock;
+  } else if (aInfo.topic().EqualsLiteral("high-priority")) {
+    dest = &mHoldsHighPriorityWakeLock;
+  } else if (aInfo.topic().EqualsLiteral("audio-playing")) {
+    dest = &mHoldsPlayingAudioWakeLock;
+  } else if (aInfo.topic().EqualsLiteral("video-playing")) {
+    dest = &mHoldsPlayingVideoWakeLock;
+  }
+
+  if (dest) {
+    bool thisProcessLocks = aInfo.lockingProcesses().Contains(ChildID());
+    if (thisProcessLocks != *dest) {
+      *dest = thisProcessLocks;
+      LOGP(
+          "Got wake lock changed event. "
+          "Now mHoldsCPUWakeLock=%d, mHoldsHighPriorityWakeLock=%d, "
+          "mHoldsPlayingAudioWakeLock=%d, mHoldsPlayingVideoWakeLock=%d",
+          mHoldsCPUWakeLock, mHoldsHighPriorityWakeLock,
+          mHoldsPlayingAudioWakeLock, mHoldsPlayingVideoWakeLock);
+      ResetPriority();
+    }
+  }
+}
+
+uint64_t ParticularProcessPriorityManager::ChildID() const {
+  // We have to cache mContentParent->ChildID() instead of getting it from the
+  // ContentParent each time because after ShutDown() is called, mContentParent
+  // is null.  If we didn't cache ChildID(), then we wouldn't be able to run
+  // LOGP() after ShutDown().
+  return mChildID;
+}
+
+int32_t ParticularProcessPriorityManager::Pid() const {
+  return mContentParent ? mContentParent->Pid() : -1;
+}
+
+const nsAutoCString& ParticularProcessPriorityManager::NameWithComma() {
+  mNameWithComma.Truncate();
+  if (!mContentParent) {
+    return mNameWithComma;  // empty string
+  }
+
+  nsAutoString name;
+  mContentParent->FriendlyName(name);
+  if (name.IsEmpty()) {
+    return mNameWithComma;  // empty string
+  }
+
+  CopyUTF16toUTF8(name, mNameWithComma);
+  mNameWithComma.AppendLiteral(", ");
+  return mNameWithComma;
+}
+
+void ParticularProcessPriorityManager::ResetPriority() {
+  ProcessPriority processPriority = ComputePriority();
+  if (mPriority == PROCESS_PRIORITY_UNKNOWN || mPriority > processPriority) {
+    // Apps set at a perceivable background priority are often playing media.
+    // Most media will have short gaps while changing tracks between songs,
+    // switching videos, etc.  Give these apps a longer grace period so they
+    // can get their next track started, if there is one, before getting
+    // downgraded.
+    if (mPriority == PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE) {
+      ScheduleResetPriority(BACKGROUND_PERCEIVABLE_GRACE_PERIOD);
+    } else {
+      ScheduleResetPriority(BACKGROUND_GRACE_PERIOD);
+    }
+    return;
+  }
+
+  SetPriorityNow(processPriority);
+}
+
+void ParticularProcessPriorityManager::ResetPriorityNow() {
+  SetPriorityNow(ComputePriority());
+}
+
+void ParticularProcessPriorityManager::ScheduleResetPriority(
+    TimeoutPref aTimeoutPref) {
+  if (mResetPriorityTimer) {
+    LOGP("ScheduleResetPriority bailing; the timer is already running.");
+    return;
+  }
+
+  uint32_t timeout = 0;
+  switch (aTimeoutPref) {
+    case BACKGROUND_PERCEIVABLE_GRACE_PERIOD:
+      timeout = StaticPrefs::
+          dom_ipc_processPriorityManager_backgroundPerceivableGracePeriodMS();
+      break;
+    case BACKGROUND_GRACE_PERIOD:
+      timeout =
+          StaticPrefs::dom_ipc_processPriorityManager_backgroundGracePeriodMS();
+      break;
+    default:
+      MOZ_ASSERT(false, "Unrecognized timeout pref");
+      break;
+  }
+
+  LOGP("Scheduling reset timer to fire in %dms.", timeout);
+  NS_NewTimerWithCallback(getter_AddRefs(mResetPriorityTimer), this, timeout,
+                          nsITimer::TYPE_ONE_SHOT);
+}
+
+NS_IMETHODIMP
+ParticularProcessPriorityManager::Notify(nsITimer* aTimer) {
+  LOGP("Reset priority timer callback; about to ResetPriorityNow.");
+  ResetPriorityNow();
+  mResetPriorityTimer = nullptr;
+  return NS_OK;
+}
+
+ProcessPriority ParticularProcessPriorityManager::CurrentPriority() {
+  return mPriority;
+}
+
+ProcessPriority ParticularProcessPriorityManager::ComputePriority() {
+  if (!mHighPriorityBrowserParents.IsEmpty() ||
+      mContentParent->GetRemoteType() == EXTENSION_REMOTE_TYPE ||
+      mHoldsPlayingAudioWakeLock) {
+    return PROCESS_PRIORITY_FOREGROUND;
+  }
+
+  if (mHoldsCPUWakeLock || mHoldsHighPriorityWakeLock ||
+      mHoldsPlayingVideoWakeLock) {
+    return PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE;
+  }
+
+  return PROCESS_PRIORITY_BACKGROUND;
+}
+
+void ParticularProcessPriorityManager::SetPriorityNow(
+    ProcessPriority aPriority) {
+  if (aPriority == PROCESS_PRIORITY_UNKNOWN) {
+    MOZ_ASSERT(false);
+    return;
+  }
+
+  LOGP("Changing priority from %s to %s (cp=%p).",
+       ProcessPriorityToString(mPriority), ProcessPriorityToString(aPriority),
+       mContentParent);
+
+  if (!mContentParent || mPriority == aPriority) {
+    return;
+  }
+
+  PROFILER_MARKER(
+      "Subprocess Priority", OTHER,
+      MarkerOptions(MarkerThreadId::MainThread(), MarkerStack::Capture()),
+      SubProcessPriorityChange, this->Pid(),
+      ProfilerString8View::WrapNullTerminatedString(
+          ProcessPriorityToString(mPriority)),
+      ProfilerString8View::WrapNullTerminatedString(
+          ProcessPriorityToString(aPriority)));
+
+  ProcessPriority oldPriority = mPriority;
+
+  mPriority = aPriority;
+
+  // We skip incrementing the DOM_CONTENTPROCESS_OS_PRIORITY_RAISED if we're
+  // transitioning from the PROCESS_PRIORITY_UNKNOWN level, which is where
+  // we initialize at.
+  if (oldPriority < mPriority && oldPriority != PROCESS_PRIORITY_UNKNOWN) {
+    Telemetry::ScalarAdd(
+        Telemetry::ScalarID::DOM_CONTENTPROCESS_OS_PRIORITY_RAISED, 1);
+  } else if (oldPriority > mPriority) {
+    Telemetry::ScalarAdd(
+        Telemetry::ScalarID::DOM_CONTENTPROCESS_OS_PRIORITY_LOWERED, 1);
+  }
+
+  ProcessPriorityManagerImpl::SetProcessPriorityIfEnabled(Pid(), mPriority);
+
+  if (oldPriority != mPriority) {
+    ProcessPriorityManagerImpl::GetSingleton()->NotifyProcessPriorityChanged(
+        this, oldPriority);
+
+    Unused << mContentParent->SendNotifyProcessPriorityChanged(mPriority);
+  }
+
+  FireTestOnlyObserverNotification("process-priority-set",
+                                   ProcessPriorityToString(mPriority));
+}
+
+void ParticularProcessPriorityManager::BrowserPriorityChanged(
+    BrowserParent* aBrowserParent, bool aPriority) {
+  MOZ_ASSERT(aBrowserParent);
+
+  if (!aPriority) {
+    mHighPriorityBrowserParents.Remove(aBrowserParent->GetTabId());
+  } else {
+    mHighPriorityBrowserParents.Insert(aBrowserParent->GetTabId());
+  }
+
+  ResetPriority();
+}
+
+void ParticularProcessPriorityManager::ShutDown() {
+  LOGP("shutdown for %p (mContentParent %p)", this, mContentParent);
+
+  // Unregister our wake lock observer if ShutDown hasn't been called.  (The
+  // wake lock observer takes raw refs, so we don't want to take chances here!)
+  // We don't call UnregisterWakeLockObserver unconditionally because the code
+  // will print a warning if it's called unnecessarily.
+  if (mContentParent) {
+    UnregisterWakeLockObserver(this);
+  }
+
+  if (mResetPriorityTimer) {
+    mResetPriorityTimer->Cancel();
+    mResetPriorityTimer = nullptr;
+  }
+
+  mContentParent = nullptr;
+}
+
+void ProcessPriorityManagerImpl::FireTestOnlyObserverNotification(
+    const char* aTopic, const nsACString& aData) {
+  if (!TestMode()) {
+    return;
+  }
+
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  NS_ENSURE_TRUE_VOID(os);
+
+  nsPrintfCString topic("process-priority-manager:TEST-ONLY:%s", aTopic);
+
+  LOG("Notifying observer %s, data %s", topic.get(),
+      PromiseFlatCString(aData).get());
+  os->NotifyObservers(nullptr, topic.get(), NS_ConvertUTF8toUTF16(aData).get());
+}
+
+void ParticularProcessPriorityManager::FireTestOnlyObserverNotification(
+    const char* aTopic, const char* aData) {
+  MOZ_ASSERT(aData, "Pass in data");
+
+  if (!ProcessPriorityManagerImpl::TestMode()) {
+    return;
+  }
+
+  nsAutoCString data(nsPrintfCString("%" PRIu64, ChildID()));
+  data.Append(':');
+  data.AppendASCII(aData);
+
+  // ProcessPriorityManagerImpl::GetSingleton() is guaranteed not to return
+  // null, since ProcessPriorityManagerImpl is the only class which creates
+  // ParticularProcessPriorityManagers.
+
+  ProcessPriorityManagerImpl::GetSingleton()->FireTestOnlyObserverNotification(
+      aTopic, data);
+}
+
+StaticRefPtr<ProcessPriorityManagerChild>
+    ProcessPriorityManagerChild::sSingleton;
+
+/* static */
+void ProcessPriorityManagerChild::StaticInit() {
+  if (!sSingleton) {
+    sSingleton = new ProcessPriorityManagerChild();
+    sSingleton->Init();
+    ClearOnShutdown(&sSingleton);
+  }
+}
+
+/* static */
+ProcessPriorityManagerChild* ProcessPriorityManagerChild::Singleton() {
+  StaticInit();
+  return sSingleton;
+}
+
+NS_IMPL_ISUPPORTS(ProcessPriorityManagerChild, nsIObserver)
+
+ProcessPriorityManagerChild::ProcessPriorityManagerChild() {
+  if (XRE_IsParentProcess()) {
+    mCachedPriority = PROCESS_PRIORITY_PARENT_PROCESS;
+  } else {
+    mCachedPriority = PROCESS_PRIORITY_UNKNOWN;
+  }
+}
+
+void ProcessPriorityManagerChild::Init() {
+  // The process priority should only be changed in child processes; don't even
+  // bother listening for changes if we're in the main process.
+  if (!XRE_IsParentProcess()) {
+    nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+    NS_ENSURE_TRUE_VOID(os);
+    os->AddObserver(this, "ipc:process-priority-changed", /* weak = */ false);
+  }
+}
+
+NS_IMETHODIMP
+ProcessPriorityManagerChild::Observe(nsISupports* aSubject, const char* aTopic,
+                                     const char16_t* aData) {
+  MOZ_ASSERT(!strcmp(aTopic, "ipc:process-priority-changed"));
+
+  nsCOMPtr<nsIPropertyBag2> props = do_QueryInterface(aSubject);
+  NS_ENSURE_TRUE(props, NS_OK);
+
+  int32_t priority = static_cast<int32_t>(PROCESS_PRIORITY_UNKNOWN);
+  props->GetPropertyAsInt32(u"priority"_ns, &priority);
+  NS_ENSURE_TRUE(ProcessPriority(priority) != PROCESS_PRIORITY_UNKNOWN, NS_OK);
+
+  mCachedPriority = static_cast<ProcessPriority>(priority);
+
+  return NS_OK;
+}
+
+bool ProcessPriorityManagerChild::CurrentProcessIsForeground() {
+  return mCachedPriority == PROCESS_PRIORITY_UNKNOWN ||
+         mCachedPriority >= PROCESS_PRIORITY_FOREGROUND;
+}
+
+}  // namespace
+
+namespace mozilla {
+
+/* static */
+void ProcessPriorityManager::Init() {
+  ProcessPriorityManagerImpl::StaticInit();
+  ProcessPriorityManagerChild::StaticInit();
+}
+
+/* static */
+void ProcessPriorityManager::SetProcessPriority(ContentParent* aContentParent,
+                                                ProcessPriority aPriority) {
+  MOZ_ASSERT(aContentParent);
+  MOZ_ASSERT(aContentParent->Pid() != -1);
+
+  ProcessPriorityManagerImpl* singleton =
+      ProcessPriorityManagerImpl::GetSingleton();
+  if (singleton) {
+    singleton->SetProcessPriority(aContentParent, aPriority);
+  }
+}
+
+/* static */
+bool ProcessPriorityManager::CurrentProcessIsForeground() {
+  return ProcessPriorityManagerChild::Singleton()->CurrentProcessIsForeground();
+}
+
+/* static */
+void ProcessPriorityManager::BrowserPriorityChanged(
+    CanonicalBrowsingContext* aBC, bool aPriority) {
+  if (auto* singleton = ProcessPriorityManagerImpl::GetSingleton()) {
+    singleton->BrowserPriorityChanged(aBC, aPriority);
+  }
+}
+
+/* static */
+void ProcessPriorityManager::BrowserPriorityChanged(
+    BrowserParent* aBrowserParent, bool aPriority) {
+  MOZ_ASSERT(aBrowserParent);
+
+  ProcessPriorityManagerImpl* singleton =
+      ProcessPriorityManagerImpl::GetSingleton();
+  if (!singleton) {
+    return;
+  }
+  singleton->BrowserPriorityChanged(aBrowserParent, aPriority);
+}
+
+/* static */
+void ProcessPriorityManager::RemoteBrowserFrameShown(
+    nsFrameLoader* aFrameLoader) {
+  ProcessPriorityManagerImpl* singleton =
+      ProcessPriorityManagerImpl::GetSingleton();
+  if (!singleton) {
+    return;
+  }
+
+  BrowserParent* bp = BrowserParent::GetFrom(aFrameLoader);
+  NS_ENSURE_TRUE_VOID(bp);
+
+  MOZ_ASSERT(XRE_IsParentProcess());
+
+  // Ignore calls that aren't from a Browser.
+  if (!aFrameLoader->OwnerIsMozBrowserFrame()) {
+    return;
+  }
+
+  singleton->ResetPriority(bp->Manager());
+}
+
+}  // namespace mozilla
diff --git a/dom/ipc/ProcessPriorityManager.h b/dom/ipc/ProcessPriorityManager.h
new file mode 100644
index 0000000000..8153a60993
--- /dev/null
+++ b/dom/ipc/ProcessPriorityManager.h
@@ -0,0 +1,95 @@
+/* -*- 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/. */
+
+#ifndef mozilla_ProcessPriorityManager_h_
+#define mozilla_ProcessPriorityManager_h_
+
+#include "mozilla/HalTypes.h"
+
+class nsFrameLoader;
+
+namespace mozilla {
+namespace dom {
+class BrowserParent;
+class CanonicalBrowsingContext;
+class ContentParent;
+}  // namespace dom
+
+/**
+ * This class sets the priority of subprocesses in response to explicit
+ * requests and events in the system.
+ *
+ * A process's priority changes e.g. when it goes into the background via
+ * mozbrowser's setVisible(false).  Process priority affects CPU scheduling and
+ * also which processes get killed when we run out of memory.
+ *
+ * After you call Initialize(), the only thing you probably have to do is call
+ * SetProcessPriority on processes immediately after creating them in order to
+ * set their initial priority.  The ProcessPriorityManager takes care of the
+ * rest.
+ */
+class ProcessPriorityManager final {
+ public:
+  /**
+   * Initialize the ProcessPriorityManager machinery, causing the
+   * ProcessPriorityManager to actively manage the priorities of all
+   * subprocesses.  You should call this before creating any subprocesses.
+   *
+   * You should also call this function even if you're in a child process,
+   * since it will initialize ProcessPriorityManagerChild.
+   */
+  static void Init();
+
+  /**
+   * Set the process priority of a given ContentParent's process.
+   *
+   * Note that because this method takes a ContentParent*, you can only set the
+   * priority of your subprocesses.  In fact, because we don't support nested
+   * content processes (bug 761935), you can only call this method from the
+   * main process.
+   *
+   * It probably only makes sense to call this function immediately after a
+   * process is created.  At this point, the process priority manager doesn't
+   * have enough context about the processs to know what its priority should
+   * be.
+   *
+   * Eventually whatever priority you set here can and probably will be
+   * overwritten by the process priority manager.
+   */
+  static void SetProcessPriority(dom::ContentParent* aContentParent,
+                                 hal::ProcessPriority aPriority);
+
+  /**
+   * Returns true iff this process's priority is FOREGROUND*.
+   *
+   * Note that because process priorities are set in the main process, it's
+   * possible for this method to return a stale value.  So be careful about
+   * what you use this for.
+   */
+  static bool CurrentProcessIsForeground();
+
+  /**
+   * Updates the contents of mHighPriorityBrowserParents to keep track of
+   * the list of TabIds for this process that are high priority.
+   */
+  static void BrowserPriorityChanged(dom::CanonicalBrowsingContext* aBC,
+                                     bool aPriority);
+  static void BrowserPriorityChanged(dom::BrowserParent* aBrowserParent,
+                                     bool aPriority);
+
+  static void RemoteBrowserFrameShown(nsFrameLoader* aFrameLoader);
+
+ private:
+  ProcessPriorityManager();
+  ProcessPriorityManager(const ProcessPriorityManager&) = delete;
+
+  const ProcessPriorityManager& operator=(const ProcessPriorityManager&) =
+      delete;
+};
+
+}  // namespace mozilla
+
+#endif
diff --git a/dom/ipc/PropertyBagUtils.cpp b/dom/ipc/PropertyBagUtils.cpp
new file mode 100644
index 0000000000..6c1b3e8fea
--- /dev/null
+++ b/dom/ipc/PropertyBagUtils.cpp
@@ -0,0 +1,261 @@
+/* -*- 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 "PropertyBagUtils.h"
+
+#include "mozilla/SimpleEnumerator.h"
+#include "mozilla/dom/DOMTypes.h"
+#include "nsCOMPtr.h"
+#include "nsHashPropertyBag.h"
+#include "nsID.h"
+#include "nsIProperty.h"
+#include "nsIURI.h"
+#include "nsVariant.h"
+
+using namespace IPC;
+using namespace mozilla::dom;
+
+namespace mozilla::ipc {
+
+void IPDLParamTraits<nsIVariant*>::Write(MessageWriter* aWriter,
+                                         IProtocol* aActor,
+                                         nsIVariant* aParam) {
+  IDPLVariant variant;
+
+  variant.type() = aParam->GetDataType();
+
+  switch (variant.type()) {
+    case nsIDataType::VTYPE_INT8:
+    case nsIDataType::VTYPE_UINT8:
+    case nsIDataType::VTYPE_CHAR: {
+      uint8_t value;
+      MOZ_ALWAYS_SUCCEEDS(aParam->GetAsUint8(&value));
+      variant.data() = value;
+      break;
+    }
+    case nsIDataType::VTYPE_WCHAR:
+    case nsIDataType::VTYPE_INT16: {
+      int16_t value;
+      MOZ_ALWAYS_SUCCEEDS(aParam->GetAsInt16(&value));
+      variant.data() = value;
+      break;
+    }
+    case nsIDataType::VTYPE_UINT16: {
+      uint16_t value;
+      MOZ_ALWAYS_SUCCEEDS(aParam->GetAsUint16(&value));
+      variant.data() = value;
+      break;
+    }
+    case nsIDataType::VTYPE_INT32: {
+      int32_t value;
+      MOZ_ALWAYS_SUCCEEDS(aParam->GetAsInt32(&value));
+      variant.data() = value;
+      break;
+    }
+    case nsIDataType::VTYPE_UINT32: {
+      uint32_t value;
+      MOZ_ALWAYS_SUCCEEDS(aParam->GetAsUint32(&value));
+      variant.data() = value;
+      break;
+    }
+    case nsIDataType::VTYPE_FLOAT: {
+      float value;
+      MOZ_ALWAYS_SUCCEEDS(aParam->GetAsFloat(&value));
+      variant.data() = value;
+      break;
+    }
+    case nsIDataType::VTYPE_DOUBLE: {
+      double value;
+      MOZ_ALWAYS_SUCCEEDS(aParam->GetAsDouble(&value));
+      variant.data() = value;
+      break;
+    }
+    case nsIDataType::VTYPE_BOOL: {
+      bool value;
+      MOZ_ALWAYS_SUCCEEDS(aParam->GetAsBool(&value));
+      variant.data() = value;
+      break;
+    }
+    case nsIDataType::VTYPE_ID: {
+      nsID value;
+      MOZ_ALWAYS_SUCCEEDS(aParam->GetAsID(&value));
+      variant.data() = value;
+      break;
+    }
+    case nsIDataType::VTYPE_ASTRING:
+    case nsIDataType::VTYPE_WCHAR_STR:
+    case nsIDataType::VTYPE_WSTRING_SIZE_IS: {
+      nsString value;
+      MOZ_ALWAYS_SUCCEEDS(aParam->GetAsAString(value));
+      variant.data() = value;
+      break;
+    }
+    case nsIDataType::VTYPE_CSTRING:
+    case nsIDataType::VTYPE_CHAR_STR:
+    case nsIDataType::VTYPE_STRING_SIZE_IS:
+    case nsIDataType::VTYPE_UTF8STRING: {
+      nsCString value;
+      MOZ_ALWAYS_SUCCEEDS(aParam->GetAsACString(value));
+      variant.data() = value;
+      break;
+    }
+    case nsIDataType::VTYPE_INTERFACE:
+    case nsIDataType::VTYPE_INTERFACE_IS: {
+      nsIID* iid;
+      nsCOMPtr<nsISupports> value;
+      MOZ_ALWAYS_SUCCEEDS(aParam->GetAsInterface(&iid, getter_AddRefs(value)));
+      free(iid);
+      // We only accept nsIURI and nsIPrincipal interface types, patch welcome.
+      if (nsCOMPtr<nsIURI> uri = do_QueryInterface(value)) {
+        variant.data() = uri;
+      } else if (nsCOMPtr<nsIPrincipal> principal = do_QueryInterface(value)) {
+        variant.data() = principal;
+      } else if (value) {
+        variant.type() = nsIDataType::VTYPE_EMPTY;
+        variant.data() = false;  // because we need something.
+      } else {
+        // Let's pretend like we had a null URI, though how do we know
+        // it wasn't a null principal?
+        variant.data() = (nsIURI*)nullptr;
+      }
+      break;
+    }
+    case nsIDataType::VTYPE_VOID:
+    case nsIDataType::VTYPE_EMPTY:
+      variant.data() = false;  // because we need something.
+      break;
+    default:
+      MOZ_CRASH("Non handled variant type, patch welcome");
+      break;
+  }
+  WriteIPDLParam(aWriter, aActor, variant);
+}
+
+bool IPDLParamTraits<nsIVariant*>::Read(MessageReader* aReader,
+                                        IProtocol* aActor,
+                                        RefPtr<nsIVariant>* aResult) {
+  IDPLVariant value;
+  if (!ReadIPDLParam(aReader, aActor, &value)) {
+    return false;
+  }
+
+  auto variant = MakeRefPtr<nsVariant>();
+
+  switch (value.type()) {
+    case nsIDataType::VTYPE_INT8:
+    case nsIDataType::VTYPE_UINT8:
+      if (value.type() == nsIDataType::VTYPE_INT8) {
+        variant->SetAsInt8(value.data().get_uint8_t());
+      } else {
+        variant->SetAsUint8(value.data().get_uint8_t());
+      }
+      break;
+    case nsIDataType::VTYPE_INT16:
+      variant->SetAsInt16(value.data().get_int16_t());
+      break;
+    case nsIDataType::VTYPE_INT32:
+      variant->SetAsInt32(value.data().get_int32_t());
+      break;
+    case nsIDataType::VTYPE_UINT16:
+      variant->SetAsUint16(value.data().get_uint16_t());
+      break;
+    case nsIDataType::VTYPE_UINT32:
+      variant->SetAsUint32(value.data().get_uint32_t());
+      break;
+    case nsIDataType::VTYPE_FLOAT:
+      variant->SetAsFloat(value.data().get_float());
+      break;
+    case nsIDataType::VTYPE_DOUBLE:
+      variant->SetAsDouble(value.data().get_double());
+      break;
+    case nsIDataType::VTYPE_BOOL:
+      variant->SetAsBool(value.data().get_bool());
+      break;
+    case nsIDataType::VTYPE_CHAR:
+      variant->SetAsChar(value.data().get_uint8_t());
+      break;
+    case nsIDataType::VTYPE_WCHAR:
+      variant->SetAsWChar(value.data().get_int16_t());
+      break;
+    case nsIDataType::VTYPE_ID:
+      variant->SetAsID(value.data().get_nsID());
+      break;
+    case nsIDataType::VTYPE_ASTRING:
+    case nsIDataType::VTYPE_WCHAR_STR:
+    case nsIDataType::VTYPE_WSTRING_SIZE_IS:
+      variant->SetAsAString(value.data().get_nsString());
+      break;
+    case nsIDataType::VTYPE_CSTRING:
+    case nsIDataType::VTYPE_CHAR_STR:
+    case nsIDataType::VTYPE_STRING_SIZE_IS:
+      variant->SetAsACString(value.data().get_nsCString());
+      break;
+    case nsIDataType::VTYPE_UTF8STRING:
+      variant->SetAsAUTF8String(value.data().get_nsCString());
+      break;
+    case nsIDataType::VTYPE_INTERFACE:
+    case nsIDataType::VTYPE_INTERFACE_IS:
+      if (value.data().type() == IPDLVariantValue::TnsIURI) {
+        variant->SetAsISupports(value.data().get_nsIURI());
+      } else if (value.data().type() == IPDLVariantValue::TnsIPrincipal) {
+        variant->SetAsISupports(value.data().get_nsIPrincipal());
+      } else {
+        MOZ_CRASH("Unexpected interface type");
+      }
+      break;
+    case nsIDataType::VTYPE_VOID:
+      variant->SetAsVoid();
+      break;
+    case nsIDataType::VTYPE_EMPTY:
+      break;
+    default:
+      MOZ_CRASH("Non handled variant type, patch welcome");
+      return false;
+  }
+  *aResult = std::move(variant);
+  return true;
+}
+
+void IPDLParamTraits<nsIPropertyBag2*>::Write(MessageWriter* aWriter,
+                                              IProtocol* aActor,
+                                              nsIPropertyBag2* aParam) {
+  // We send a nsIPropertyBag as an array of IPDLProperty
+  nsTArray<IPDLProperty> bag;
+
+  nsCOMPtr<nsISimpleEnumerator> enumerator;
+  if (aParam &&
+      NS_SUCCEEDED(aParam->GetEnumerator(getter_AddRefs(enumerator)))) {
+    for (auto& property : SimpleEnumerator<nsIProperty>(enumerator)) {
+      nsString name;
+      nsCOMPtr<nsIVariant> value;
+      MOZ_ALWAYS_SUCCEEDS(property->GetName(name));
+      MOZ_ALWAYS_SUCCEEDS(property->GetValue(getter_AddRefs(value)));
+      bag.AppendElement(IPDLProperty{name, value});
+    }
+  }
+  WriteIPDLParam(aWriter, aActor, bag);
+}
+
+bool IPDLParamTraits<nsIPropertyBag2*>::Read(MessageReader* aReader,
+                                             IProtocol* aActor,
+                                             RefPtr<nsIPropertyBag2>* aResult) {
+  nsTArray<IPDLProperty> bag;
+  if (!ReadIPDLParam(aReader, aActor, &bag)) {
+    return false;
+  }
+
+  auto properties = MakeRefPtr<nsHashPropertyBag>();
+
+  for (auto& entry : bag) {
+    nsCOMPtr<nsIVariant> variant = std::move(entry.value());
+    MOZ_ALWAYS_SUCCEEDS(
+        properties->SetProperty(std::move(entry.name()), variant));
+  }
+  *aResult = std::move(properties);
+  return true;
+}
+
+}  // namespace mozilla::ipc
diff --git a/dom/ipc/PropertyBagUtils.h b/dom/ipc/PropertyBagUtils.h
new file mode 100644
index 0000000000..7eb94b46a7
--- /dev/null
+++ b/dom/ipc/PropertyBagUtils.h
@@ -0,0 +1,38 @@
+/* -*- 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/. */
+
+#ifndef IPC_PropertyBagUtils_h
+#define IPC_PropertyBagUtils_h
+
+#include "mozilla/ipc/IPDLParamTraits.h"
+#include "nsIPropertyBag2.h"
+#include "nsIVariant.h"
+
+namespace mozilla::ipc {
+
+/**
+ * Limited nsIVariant support. Not all types are implemented and only
+ * nsIURI is implemented with nsIVariant::GetAsInterface.
+ */
+template <>
+struct IPDLParamTraits<nsIVariant*> {
+  static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
+                    nsIVariant* aParam);
+  static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
+                   RefPtr<nsIVariant>* aResult);
+};
+
+template <>
+struct IPDLParamTraits<nsIPropertyBag2*> {
+  static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
+                    nsIPropertyBag2* aParam);
+  static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
+                   RefPtr<nsIPropertyBag2>* aResult);
+};
+
+}  // namespace mozilla::ipc
+
+#endif  // mozilla_ipc_URIUtils_h
diff --git a/dom/ipc/RefMessageBodyService.cpp b/dom/ipc/RefMessageBodyService.cpp
new file mode 100644
index 0000000000..e340443a53
--- /dev/null
+++ b/dom/ipc/RefMessageBodyService.cpp
@@ -0,0 +1,161 @@
+/* -*- 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 "RefMessageBodyService.h"
+
+#include <cstdint>
+#include <cstdlib>
+#include "mozilla/ErrorResult.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/dom/ipc/StructuredCloneData.h"
+#include "nsBaseHashtable.h"
+#include "nsDebug.h"
+
+namespace mozilla::dom {
+
+// Guards sService and its members.
+StaticMutex sRefMessageBodyServiceMutex;
+
+// Raw pointer because the service is kept alive by other objects.
+// See the CTOR and the DTOR of this object.
+RefMessageBodyService* sService;
+
+// static
+already_AddRefed<RefMessageBodyService> RefMessageBodyService::GetOrCreate() {
+  StaticMutexAutoLock lock(sRefMessageBodyServiceMutex);
+
+  RefPtr<RefMessageBodyService> service = GetOrCreateInternal(lock);
+  return service.forget();
+}
+
+// static
+RefMessageBodyService* RefMessageBodyService::GetOrCreateInternal(
+    const StaticMutexAutoLock& aProofOfLock) {
+  if (!sService) {
+    sService = new RefMessageBodyService(aProofOfLock);
+  }
+  return sService;
+}
+
+RefMessageBodyService::RefMessageBodyService(
+    const StaticMutexAutoLock& aProofOfLock) {
+  MOZ_DIAGNOSTIC_ASSERT(sService == nullptr);
+}
+
+RefMessageBodyService::~RefMessageBodyService() {
+  StaticMutexAutoLock lock(sRefMessageBodyServiceMutex);
+  MOZ_DIAGNOSTIC_ASSERT(sService == this);
+  sService = nullptr;
+}
+
+const nsID RefMessageBodyService::Register(
+    already_AddRefed<RefMessageBody> aBody, ErrorResult& aRv) {
+  RefPtr<RefMessageBody> body = aBody;
+  MOZ_ASSERT(body);
+
+  nsID uuid = {};
+  aRv = nsID::GenerateUUIDInPlace(uuid);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nsID();
+  }
+
+  StaticMutexAutoLock lock(sRefMessageBodyServiceMutex);
+  GetOrCreateInternal(lock)->mMessages.InsertOrUpdate(uuid, std::move(body));
+  return uuid;
+}
+
+already_AddRefed<RefMessageBody> RefMessageBodyService::Steal(const nsID& aID) {
+  StaticMutexAutoLock lock(sRefMessageBodyServiceMutex);
+  if (!sService) {
+    return nullptr;
+  }
+
+  RefPtr<RefMessageBody> body;
+  sService->mMessages.Remove(aID, getter_AddRefs(body));
+
+  return body.forget();
+}
+
+already_AddRefed<RefMessageBody> RefMessageBodyService::GetAndCount(
+    const nsID& aID) {
+  StaticMutexAutoLock lock(sRefMessageBodyServiceMutex);
+  if (!sService) {
+    return nullptr;
+  }
+
+  RefPtr<RefMessageBody> body = sService->mMessages.Get(aID);
+  if (!body) {
+    return nullptr;
+  }
+
+  ++body->mCount;
+
+  MOZ_ASSERT_IF(body->mMaxCount.isSome(),
+                body->mCount <= body->mMaxCount.value());
+  if (body->mMaxCount.isSome() && body->mCount >= body->mMaxCount.value()) {
+    sService->mMessages.Remove(aID);
+  }
+
+  return body.forget();
+}
+
+void RefMessageBodyService::SetMaxCount(const nsID& aID, uint32_t aMaxCount) {
+  StaticMutexAutoLock lock(sRefMessageBodyServiceMutex);
+  if (!sService) {
+    return;
+  }
+
+  RefPtr<RefMessageBody> body = sService->mMessages.Get(aID);
+  if (!body) {
+    return;
+  }
+
+  MOZ_ASSERT(body->mMaxCount.isNothing());
+  body->mMaxCount.emplace(aMaxCount);
+
+  MOZ_ASSERT(body->mCount <= body->mMaxCount.value());
+  if (body->mCount >= body->mMaxCount.value()) {
+    sService->mMessages.Remove(aID);
+  }
+}
+
+void RefMessageBodyService::ForgetPort(const nsID& aPortID) {
+  StaticMutexAutoLock lock(sRefMessageBodyServiceMutex);
+  if (!sService) {
+    return;
+  }
+
+  for (auto iter = sService->mMessages.Iter(); !iter.Done(); iter.Next()) {
+    if (iter.UserData()->PortID() == aPortID) {
+      iter.Remove();
+    }
+  }
+}
+
+RefMessageBody::RefMessageBody(const nsID& aPortID,
+                               UniquePtr<ipc::StructuredCloneData>&& aCloneData)
+    : mPortID(aPortID),
+      mMutex("RefMessageBody::mMutex"),
+      mCloneData(std::move(aCloneData)),
+      mMaxCount(Nothing()),
+      mCount(0) {}
+
+RefMessageBody::~RefMessageBody() = default;
+
+void RefMessageBody::Read(JSContext* aCx, JS::MutableHandle<JS::Value> aValue,
+                          const JS::CloneDataPolicy& aCloneDataPolicy,
+                          ErrorResult& aRv) {
+  MutexAutoLock lock(mMutex);
+  mCloneData->Read(aCx, aValue, aCloneDataPolicy, aRv);
+}
+
+bool RefMessageBody::TakeTransferredPortsAsSequence(
+    Sequence<OwningNonNull<mozilla::dom::MessagePort>>& aPorts) {
+  MOZ_ASSERT(mMaxCount.isNothing());
+  return mCloneData->TakeTransferredPortsAsSequence(aPorts);
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/RefMessageBodyService.h b/dom/ipc/RefMessageBodyService.h
new file mode 100644
index 0000000000..6cca2a836e
--- /dev/null
+++ b/dom/ipc/RefMessageBodyService.h
@@ -0,0 +1,137 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_RefMessageBodyService_h
+#define mozilla_dom_RefMessageBodyService_h
+
+#include <cstdint>
+#include "js/TypeDecls.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/Mutex.h"
+#include "mozilla/StaticMutex.h"
+#include "mozilla/UniquePtr.h"
+#include "nsHashKeys.h"
+#include "nsID.h"
+#include "nsISupports.h"
+#include "nsRefPtrHashtable.h"
+
+namespace JS {
+class CloneDataPolicy;
+}  // namespace JS
+
+namespace mozilla {
+
+class ErrorResult;
+template <class T>
+class OwningNonNull;
+
+namespace dom {
+
+class MessagePort;
+template <typename T>
+class Sequence;
+
+namespace ipc {
+class StructuredCloneData;
+}
+
+/**
+ * At the time a BroadcastChannel or MessagePort sends messages, we don't know
+ * which process is going to receive it. Because of this, we need to check if
+ * the message is able to cross the process boundary.
+ * If the message contains objects such as SharedArrayBuffers, WASM modules or
+ * ImageBitmaps, it can be delivered on the current process only.
+ * Instead of sending the whole message via IPC, we send a unique ID, while the
+ * message is kept alive by RefMessageBodyService, on the current process using
+ * a ref-counted RefMessageBody object.
+ * When the receiver obtains the message ID, it checks if the local
+ * RefMessageBodyService knows that ID. If yes, the sender and the receiver are
+ * on the same process and the delivery can be completed; if not, a
+ * messageerror event has to be dispatched instead.
+ *
+ * For MessagePort communication is 1-to-1 and because of this, the
+ * receiver takes ownership of the message (RefMessageBodyService::Steal()).
+ * If the receiver port is on a different process, RefMessageBodyService will
+ * return a nullptr and a messageerror event will be dispatched.
+
+ * For BroadcastChannel, the life-time of a message is a bit different than for
+ * MessagePort. It has a 1-to-many communication and we could have multiple
+ * receivers. Each one needs to deliver the message without taking full
+ * ownership of it.
+ * In order to support this feature, BroadcastChannel needs to call
+ * RefMessageBodyService::SetMaxCount() to inform how many ports are allowed to
+ * retrieve the current message, on the current process. Receivers on other
+ * processes are not kept in consideration because they will not be able to
+ * retrieve the message from RefMessageBodyService. When the last allowed
+ * port has called RefMessageBodyService::GetAndCount(), the message is
+ * released.
+ */
+class RefMessageBody final {
+  friend class RefMessageBodyService;
+
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RefMessageBody)
+
+  RefMessageBody(const nsID& aPortID,
+                 UniquePtr<ipc::StructuredCloneData>&& aCloneData);
+
+  const nsID& PortID() const { return mPortID; }
+
+  void Read(JSContext* aCx, JS::MutableHandle<JS::Value> aValue,
+            const JS::CloneDataPolicy& aCloneDataPolicy, ErrorResult& aRv);
+
+  // This method can be called only if the RefMessageBody is not supposed to be
+  // ref-counted (see mMaxCount).
+  bool TakeTransferredPortsAsSequence(
+      Sequence<OwningNonNull<mozilla::dom::MessagePort>>& aPorts);
+
+ private:
+  ~RefMessageBody();
+
+  const nsID mPortID;
+
+  // In case the RefMessageBody is shared and refcounted (see mCount/mMaxCount),
+  // we must enforce that the reading does not happen simultaneously on
+  // different threads.
+  Mutex mMutex MOZ_UNANNOTATED;
+
+  UniquePtr<ipc::StructuredCloneData> mCloneData;
+
+  // When mCount reaches mMaxCount, this object is released by the service.
+  Maybe<uint32_t> mMaxCount;
+  uint32_t mCount;
+};
+
+class RefMessageBodyService final {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RefMessageBodyService)
+
+  static already_AddRefed<RefMessageBodyService> GetOrCreate();
+
+  void ForgetPort(const nsID& aPortID);
+
+  const nsID Register(already_AddRefed<RefMessageBody> aBody, ErrorResult& aRv);
+
+  already_AddRefed<RefMessageBody> Steal(const nsID& aID);
+
+  already_AddRefed<RefMessageBody> GetAndCount(const nsID& aID);
+
+  void SetMaxCount(const nsID& aID, uint32_t aMaxCount);
+
+ private:
+  explicit RefMessageBodyService(const StaticMutexAutoLock& aProofOfLock);
+  ~RefMessageBodyService();
+
+  static RefMessageBodyService* GetOrCreateInternal(
+      const StaticMutexAutoLock& aProofOfLock);
+
+  nsRefPtrHashtable<nsIDHashKey, RefMessageBody> mMessages;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_RefMessageBodyService_h
diff --git a/dom/ipc/ReferrerInfoUtils.cpp b/dom/ipc/ReferrerInfoUtils.cpp
new file mode 100644
index 0000000000..a2728e342c
--- /dev/null
+++ b/dom/ipc/ReferrerInfoUtils.cpp
@@ -0,0 +1,54 @@
+/* -*- 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 "mozilla/dom/ReferrerInfoUtils.h"
+
+#include "ipc/IPCMessageUtilsSpecializations.h"
+#include "nsSerializationHelper.h"
+#include "nsString.h"
+
+namespace IPC {
+
+void ParamTraits<nsIReferrerInfo*>::Write(MessageWriter* aWriter,
+                                          nsIReferrerInfo* aParam) {
+  bool isNull = !aParam;
+  WriteParam(aWriter, isNull);
+  if (isNull) {
+    return;
+  }
+  nsAutoCString infoString;
+  nsresult rv = NS_SerializeToString(aParam, infoString);
+  if (NS_FAILED(rv)) {
+    MOZ_CRASH("Unable to serialize referrer info.");
+    return;
+  }
+  WriteParam(aWriter, infoString);
+}
+
+bool ParamTraits<nsIReferrerInfo*>::Read(MessageReader* aReader,
+                                         RefPtr<nsIReferrerInfo>* aResult) {
+  bool isNull;
+  if (!ReadParam(aReader, &isNull)) {
+    return false;
+  }
+  if (isNull) {
+    *aResult = nullptr;
+    return true;
+  }
+  nsAutoCString infoString;
+  if (!ReadParam(aReader, &infoString)) {
+    return false;
+  }
+  nsCOMPtr<nsISupports> iSupports;
+  nsresult rv = NS_DeserializeObject(infoString, getter_AddRefs(iSupports));
+  NS_ENSURE_SUCCESS(rv, false);
+  nsCOMPtr<nsIReferrerInfo> referrerInfo = do_QueryInterface(iSupports);
+  NS_ENSURE_TRUE(referrerInfo, false);
+  *aResult = ToRefPtr(std::move(referrerInfo));
+  return true;
+}
+
+}  // namespace IPC
diff --git a/dom/ipc/ReferrerInfoUtils.h b/dom/ipc/ReferrerInfoUtils.h
new file mode 100644
index 0000000000..9a17f9d148
--- /dev/null
+++ b/dom/ipc/ReferrerInfoUtils.h
@@ -0,0 +1,24 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_referrer_info_utils_h__
+#define mozilla_dom_referrer_info_utils_h__
+
+#include "ipc/IPCMessageUtils.h"
+#include "nsCOMPtr.h"
+#include "nsIReferrerInfo.h"
+
+namespace IPC {
+
+template <>
+struct ParamTraits<nsIReferrerInfo*> {
+  static void Write(MessageWriter* aWriter, nsIReferrerInfo* aParam);
+  static bool Read(MessageReader* aReader, RefPtr<nsIReferrerInfo>* aResult);
+};
+
+}  // namespace IPC
+
+#endif  // mozilla_dom_referrer_info_utils_h__
diff --git a/dom/ipc/RemoteBrowser.cpp b/dom/ipc/RemoteBrowser.cpp
new file mode 100644
index 0000000000..9fabb8e67f
--- /dev/null
+++ b/dom/ipc/RemoteBrowser.cpp
@@ -0,0 +1,31 @@
+/* -*- 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 "RemoteBrowser.h"
+
+#include "nsFrameLoader.h"
+#include "nsFrameLoaderOwner.h"
+#include "nsQueryObject.h"
+
+namespace mozilla::dom {
+
+RemoteBrowser* RemoteBrowser::GetFrom(nsFrameLoader* aFrameLoader) {
+  if (!aFrameLoader) {
+    return nullptr;
+  }
+  return aFrameLoader->GetRemoteBrowser();
+}
+
+RemoteBrowser* RemoteBrowser::GetFrom(nsIContent* aContent) {
+  RefPtr<nsFrameLoaderOwner> loaderOwner = do_QueryObject(aContent);
+  if (!loaderOwner) {
+    return nullptr;
+  }
+  RefPtr<nsFrameLoader> frameLoader = loaderOwner->GetFrameLoader();
+  return GetFrom(frameLoader);
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/RemoteBrowser.h b/dom/ipc/RemoteBrowser.h
new file mode 100644
index 0000000000..7ea0b669fd
--- /dev/null
+++ b/dom/ipc/RemoteBrowser.h
@@ -0,0 +1,72 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_ipc_RemoteBrowser_h
+#define mozilla_dom_ipc_RemoteBrowser_h
+
+#include "mozilla/dom/ipc/IdType.h"
+#include "mozilla/layers/LayersTypes.h"
+#include "nsISupports.h"
+#include "nsRect.h"
+#include "Units.h"
+
+class nsDocShellLoadState;
+class nsFrameLoader;
+class nsILoadContext;
+class nsIContent;
+
+namespace mozilla::dom {
+
+class BrowserHost;
+class BrowserBridgeHost;
+class BrowsingContext;
+class EffectsInfo;
+class OwnerShowInfo;
+
+/**
+ * An interface to control a browser hosted in another process.
+ *
+ * This is used by nsFrameLoader to abstract between hosting a top-level remote
+ * browser in the chrome process and hosting an OOP-iframe in a content process.
+ *
+ * There are two concrete implementations that are used depending on whether
+ * the nsFrameLoader is in the chrome or content process. A chrome process
+ * nsFrameLoader will use BrowserHost, and a content process nsFrameLoader will
+ * use BrowserBridgeHost.
+ */
+class RemoteBrowser : public nsISupports {
+ public:
+  using LayersId = mozilla::layers::LayersId;
+
+  static RemoteBrowser* GetFrom(nsFrameLoader* aFrameLoader);
+  static RemoteBrowser* GetFrom(nsIContent* aContent);
+
+  // Try to cast this RemoteBrowser to a BrowserHost, may return null
+  virtual BrowserHost* AsBrowserHost() = 0;
+  // Try to cast this RemoteBrowser to a BrowserBridgeHost, may return null
+  virtual BrowserBridgeHost* AsBrowserBridgeHost() = 0;
+
+  virtual TabId GetTabId() const = 0;
+  virtual LayersId GetLayersId() const = 0;
+  virtual BrowsingContext* GetBrowsingContext() const = 0;
+  virtual nsILoadContext* GetLoadContext() const = 0;
+  virtual bool CanRecv() const = 0;
+
+  virtual void LoadURL(nsDocShellLoadState* aLoadState) = 0;
+  virtual void ResumeLoad(uint64_t aPendingSwitchId) = 0;
+  virtual void DestroyStart() = 0;
+  virtual void DestroyComplete() = 0;
+
+  virtual bool Show(const OwnerShowInfo&) = 0;
+  virtual void UpdateDimensions(const nsIntRect& aRect,
+                                const ScreenIntSize& aSize) = 0;
+
+  virtual void UpdateEffects(EffectsInfo aInfo) = 0;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_ipc_RemoteBrowser_h
diff --git a/dom/ipc/RemoteType.h b/dom/ipc/RemoteType.h
new file mode 100644
index 0000000000..43183c7dee
--- /dev/null
+++ b/dom/ipc/RemoteType.h
@@ -0,0 +1,35 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_RemoteType_h
+#define mozilla_dom_RemoteType_h
+
+#include "nsString.h"
+#include "nsReadableUtils.h"
+
+// These must match the similar ones in E10SUtils.sys.mjs and ProcInfo.h and
+// ChromeUtils.webidl Process names as reported by about:memory are defined in
+// ContentChild:RecvRemoteType.  Add your value there too or it will be called
+// "Web Content".
+#define PREALLOC_REMOTE_TYPE "prealloc"_ns
+#define WEB_REMOTE_TYPE "web"_ns
+#define FILE_REMOTE_TYPE "file"_ns
+#define EXTENSION_REMOTE_TYPE "extension"_ns
+#define PRIVILEGEDABOUT_REMOTE_TYPE "privilegedabout"_ns
+#define PRIVILEGEDMOZILLA_REMOTE_TYPE "privilegedmozilla"_ns
+
+#define DEFAULT_REMOTE_TYPE WEB_REMOTE_TYPE
+
+// These must start with the WEB_REMOTE_TYPE above.
+#define FISSION_WEB_REMOTE_TYPE "webIsolated"_ns
+#define WITH_COOP_COEP_REMOTE_TYPE "webCOOP+COEP"_ns
+#define WITH_COOP_COEP_REMOTE_TYPE_PREFIX "webCOOP+COEP="_ns
+#define SERVICEWORKER_REMOTE_TYPE "webServiceWorker"_ns
+
+// Remote type value used to represent being non-remote.
+#define NOT_REMOTE_TYPE VoidCString()
+
+#endif  // mozilla_dom_RemoteType_h
diff --git a/dom/ipc/RemoteWebProgressRequest.cpp b/dom/ipc/RemoteWebProgressRequest.cpp
new file mode 100644
index 0000000000..72c80b3e6b
--- /dev/null
+++ b/dom/ipc/RemoteWebProgressRequest.cpp
@@ -0,0 +1,270 @@
+/* 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 "RemoteWebProgressRequest.h"
+
+#include "nsIURI.h"
+
+namespace mozilla::dom {
+
+NS_IMPL_ISUPPORTS(RemoteWebProgressRequest, nsIRequest, nsIChannel,
+                  nsIClassifiedChannel)
+
+// nsIChannel methods
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetOriginalURI(nsIURI** aOriginalURI) {
+  NS_ENSURE_ARG_POINTER(aOriginalURI);
+  NS_ADDREF(*aOriginalURI = mOriginalURI);
+  return NS_OK;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetOriginalURI(nsIURI* aOriginalURI) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetURI(nsIURI** aURI) {
+  NS_ENSURE_ARG_POINTER(aURI);
+  NS_ADDREF(*aURI = mURI);
+  return NS_OK;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetOwner(nsISupports** aOwner) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetOwner(nsISupports* aOwner) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetNotificationCallbacks(
+    nsIInterfaceRequestor** aNotificationCallbacks) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetNotificationCallbacks(
+    nsIInterfaceRequestor* aNotificationCallbacks) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetSecurityInfo(
+    nsITransportSecurityInfo** aSecurityInfo) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetContentType(
+    nsACString& aContentType) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetContentType(
+    const nsACString& aContentType) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetContentCharset(
+    nsACString& aContentCharset) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetContentCharset(
+    const nsACString& aContentCharset) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetContentLength(
+    int64_t* aContentLength) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetContentLength(
+    int64_t aContentLength) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::Open(nsIInputStream** _retval) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::AsyncOpen(
+    nsIStreamListener* aListener) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetContentDisposition(
+    uint32_t* aContentDisposition) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetContentDisposition(
+    uint32_t aContentDisposition) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetContentDispositionFilename(
+    nsAString& aContentDispositionFilename) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetContentDispositionFilename(
+    const nsAString& aContentDispositionFilename) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetContentDispositionHeader(
+    nsACString& aContentDispositionHeader) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetLoadInfo(nsILoadInfo** aLoadInfo) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetLoadInfo(nsILoadInfo* aLoadInfo) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetIsDocument(bool* aIsDocument) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+// nsIClassifiedChannel methods
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetMatchedInfo(
+    const nsACString& aList, const nsACString& aProvider,
+    const nsACString& aFullHash) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetMatchedList(
+    nsACString& aMatchedList) {
+  aMatchedList = mMatchedList;
+  return NS_OK;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetMatchedProvider(
+    nsACString& aMatchedProvider) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetMatchedFullHash(
+    nsACString& aMatchedFullHash) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetMatchedTrackingInfo(
+    const nsTArray<nsCString>& aLists, const nsTArray<nsCString>& aFullHashes) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetMatchedTrackingLists(
+    nsTArray<nsCString>& aLists) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetMatchedTrackingFullHashes(
+    nsTArray<nsCString>& aFullHashes) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+// nsIRequest methods
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetName(nsACString& aName) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::IsPending(bool* _retval) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetStatus(nsresult* aStatus) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetCanceledReason(
+    const nsACString& aReason) {
+  return SetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetCanceledReason(nsACString& aReason) {
+  return GetCanceledReasonImpl(aReason);
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::CancelWithReason(
+    nsresult aStatus, const nsACString& aReason) {
+  return CancelWithReasonImpl(aStatus, aReason);
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::Cancel(nsresult aStatus) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetCanceled(bool* aCanceled) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::Suspend(void) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::Resume(void) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetLoadGroup(
+    nsILoadGroup** aLoadGroup) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetLoadGroup(nsILoadGroup* aLoadGroup) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetLoadFlags(nsLoadFlags* aLoadFlags) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::GetTRRMode(
+    nsIRequest::TRRMode* aTRRMode) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetTRRMode(
+    nsIRequest::TRRMode aTRRMode) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP RemoteWebProgressRequest::SetLoadFlags(nsLoadFlags aLoadFlags) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+RemoteWebProgressRequest::IsThirdPartyTrackingResource(
+    bool* aIsTrackingResource) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+RemoteWebProgressRequest::IsThirdPartySocialTrackingResource(
+    bool* aIsThirdPartySocialTrackingResource) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+RemoteWebProgressRequest::GetClassificationFlags(
+    uint32_t* aClassificationFlags) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+RemoteWebProgressRequest::GetFirstPartyClassificationFlags(
+    uint32_t* aClassificationFlags) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+RemoteWebProgressRequest::GetThirdPartyClassificationFlags(
+    uint32_t* aClassificationFlags) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/RemoteWebProgressRequest.h b/dom/ipc/RemoteWebProgressRequest.h
new file mode 100644
index 0000000000..cef1cb76f6
--- /dev/null
+++ b/dom/ipc/RemoteWebProgressRequest.h
@@ -0,0 +1,36 @@
+/* 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/. */
+
+#ifndef mozilla_dom_RemoteWebProgressRequest_h
+#define mozilla_dom_RemoteWebProgressRequest_h
+
+#include "nsIChannel.h"
+#include "nsIClassifiedChannel.h"
+
+namespace mozilla::dom {
+
+class RemoteWebProgressRequest final : public nsIChannel,
+                                       public nsIClassifiedChannel {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSICHANNEL
+  NS_DECL_NSICLASSIFIEDCHANNEL
+  NS_DECL_NSIREQUEST
+
+  RemoteWebProgressRequest(nsIURI* aURI, nsIURI* aOriginalURI,
+                           const nsACString& aMatchedList)
+      : mURI(aURI), mOriginalURI(aOriginalURI), mMatchedList(aMatchedList) {}
+
+ protected:
+  ~RemoteWebProgressRequest() = default;
+
+ private:
+  nsCOMPtr<nsIURI> mURI;
+  nsCOMPtr<nsIURI> mOriginalURI;
+  nsCString mMatchedList;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_RemoteWebProgressRequest_h
diff --git a/dom/ipc/ServiceWorkerConfiguration.ipdlh b/dom/ipc/ServiceWorkerConfiguration.ipdlh
new file mode 100644
index 0000000000..16e0d46eab
--- /dev/null
+++ b/dom/ipc/ServiceWorkerConfiguration.ipdlh
@@ -0,0 +1,18 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */
+/* 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 ServiceWorkerRegistrarTypes;
+
+namespace mozilla {
+namespace dom {
+
+struct ServiceWorkerConfiguration
+{
+  ServiceWorkerRegistrationData[] serviceWorkerRegistrations;
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/SharedMap.cpp b/dom/ipc/SharedMap.cpp
new file mode 100644
index 0000000000..70e12784e9
--- /dev/null
+++ b/dom/ipc/SharedMap.cpp
@@ -0,0 +1,466 @@
+/* -*- 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 "SharedMap.h"
+#include "SharedMapChangeEvent.h"
+
+#include "MemMapSnapshot.h"
+#include "ScriptPreloader-inl.h"
+
+#include "mozilla/dom/AutoEntryScript.h"
+#include "mozilla/dom/BlobImpl.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/ContentProcessMessageManager.h"
+#include "mozilla/dom/IPCBlobUtils.h"
+#include "mozilla/dom/RootedDictionary.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/IOBuffers.h"
+#include "mozilla/ScriptPreloader.h"
+
+using namespace mozilla::loader;
+
+namespace mozilla {
+
+using namespace ipc;
+
+namespace dom::ipc {
+
+// Align to size of uintptr_t here, to be safe. It's probably not strictly
+// necessary, though.
+constexpr size_t kStructuredCloneAlign = sizeof(uintptr_t);
+
+static inline void AlignTo(size_t* aOffset, size_t aAlign) {
+  if (auto mod = *aOffset % aAlign) {
+    *aOffset += aAlign - mod;
+  }
+}
+
+SharedMap::SharedMap() : DOMEventTargetHelper() {}
+
+SharedMap::SharedMap(nsIGlobalObject* aGlobal, const FileDescriptor& aMapFile,
+                     size_t aMapSize, nsTArray<RefPtr<BlobImpl>>&& aBlobs)
+    : DOMEventTargetHelper(aGlobal), mBlobImpls(std::move(aBlobs)) {
+  mMapFile.reset(new FileDescriptor(aMapFile));
+  mMapSize = aMapSize;
+}
+
+bool SharedMap::Has(const nsACString& aName) {
+  Unused << MaybeRebuild();
+  return mEntries.Contains(aName);
+}
+
+void SharedMap::Get(JSContext* aCx, const nsACString& aName,
+                    JS::MutableHandle<JS::Value> aRetVal, ErrorResult& aRv) {
+  auto res = MaybeRebuild();
+  if (res.isErr()) {
+    aRv.Throw(res.unwrapErr());
+    return;
+  }
+
+  Entry* entry = mEntries.Get(aName);
+  if (!entry) {
+    aRetVal.setNull();
+    return;
+  }
+
+  entry->Read(aCx, aRetVal, aRv);
+}
+
+void SharedMap::Entry::Read(JSContext* aCx,
+                            JS::MutableHandle<JS::Value> aRetVal,
+                            ErrorResult& aRv) {
+  if (mData.is<StructuredCloneData>()) {
+    // We have a temporary buffer for a key that was changed after the last
+    // snapshot. Just decode it directly.
+    auto& holder = mData.as<StructuredCloneData>();
+    holder.Read(aCx, aRetVal, aRv);
+    return;
+  }
+
+  // We have a pointer to a shared memory region containing our structured
+  // clone data. Create a temporary buffer to decode that data, and then
+  // discard it so that we don't keep a separate process-local copy around any
+  // longer than necessary.
+  StructuredCloneData holder;
+  if (!holder.CopyExternalData(Data(), Size())) {
+    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+    return;
+  }
+  if (mBlobCount) {
+    holder.BlobImpls().AppendElements(Blobs());
+  }
+  holder.Read(aCx, aRetVal, aRv);
+}
+
+FileDescriptor SharedMap::CloneMapFile() const {
+  if (mMap.initialized()) {
+    return mMap.cloneHandle();
+  }
+  return *mMapFile;
+}
+
+void SharedMap::Update(const FileDescriptor& aMapFile, size_t aMapSize,
+                       nsTArray<RefPtr<BlobImpl>>&& aBlobs,
+                       nsTArray<nsCString>&& aChangedKeys) {
+  MOZ_DIAGNOSTIC_ASSERT(!mWritable);
+
+  mMap.reset();
+  if (mMapFile) {
+    *mMapFile = aMapFile;
+  } else {
+    mMapFile.reset(new FileDescriptor(aMapFile));
+  }
+  mMapSize = aMapSize;
+  mEntries.Clear();
+  mEntryArray.reset();
+
+  mBlobImpls = std::move(aBlobs);
+
+  AutoEntryScript aes(GetParentObject(), "SharedMap change event");
+  JSContext* cx = aes.cx();
+
+  RootedDictionary<MozSharedMapChangeEventInit> init(cx);
+  if (!init.mChangedKeys.SetCapacity(aChangedKeys.Length(), fallible)) {
+    NS_WARNING("Failed to dispatch SharedMap change event");
+    return;
+  }
+  for (auto& key : aChangedKeys) {
+    Unused << init.mChangedKeys.AppendElement(NS_ConvertUTF8toUTF16(key),
+                                              fallible);
+  }
+
+  RefPtr<SharedMapChangeEvent> event =
+      SharedMapChangeEvent::Constructor(this, u"change"_ns, init);
+  event->SetTrusted(true);
+
+  DispatchEvent(*event);
+}
+
+const nsTArray<SharedMap::Entry*>& SharedMap::EntryArray() const {
+  if (mEntryArray.isNothing()) {
+    MaybeRebuild();
+
+    mEntryArray.emplace(mEntries.Count());
+    auto& array = mEntryArray.ref();
+    for (auto& entry : mEntries) {
+      array.AppendElement(entry.GetWeak());
+    }
+  }
+
+  return mEntryArray.ref();
+}
+
+const nsString SharedMap::GetKeyAtIndex(uint32_t aIndex) const {
+  return NS_ConvertUTF8toUTF16(EntryArray()[aIndex]->Name());
+}
+
+bool SharedMap::GetValueAtIndex(JSContext* aCx, uint32_t aIndex,
+                                JS::MutableHandle<JS::Value> aResult) const {
+  ErrorResult rv;
+  EntryArray()[aIndex]->Read(aCx, aResult, rv);
+  if (rv.MaybeSetPendingException(aCx)) {
+    return false;
+  }
+  return true;
+}
+
+void SharedMap::Entry::TakeData(StructuredCloneData&& aHolder) {
+  mData = AsVariant(std::move(aHolder));
+
+  mSize = Holder().Data().Size();
+  mBlobCount = Holder().BlobImpls().Length();
+}
+
+void SharedMap::Entry::ExtractData(char* aDestPtr, uint32_t aNewOffset,
+                                   uint16_t aNewBlobOffset) {
+  if (mData.is<StructuredCloneData>()) {
+    char* ptr = aDestPtr;
+    Holder().Data().ForEachDataChunk([&](const char* aData, size_t aSize) {
+      memcpy(ptr, aData, aSize);
+      ptr += aSize;
+      return true;
+    });
+    MOZ_ASSERT(uint32_t(ptr - aDestPtr) == mSize);
+  } else {
+    memcpy(aDestPtr, Data(), mSize);
+  }
+
+  mData = AsVariant(aNewOffset);
+  mBlobOffset = aNewBlobOffset;
+}
+
+Result<Ok, nsresult> SharedMap::MaybeRebuild() {
+  if (!mMapFile) {
+    return Ok();
+  }
+
+  // This function maps a shared memory region created by Serialize() and reads
+  // its header block to build a new mEntries hashtable of its contents.
+  //
+  // The entries created by this function contain a pointer to this SharedMap
+  // instance, and the offsets and sizes of their structured clone data within
+  // its shared memory region. When needed, that structured clone data is
+  // retrieved directly as indexes into the SharedMap's shared memory region.
+
+  MOZ_TRY(mMap.initWithHandle(*mMapFile, mMapSize));
+  mMapFile.reset();
+
+  // We should be able to pass this range as an initializer list or an immediate
+  // param, but gcc currently chokes on that if optimization is enabled, and
+  // initializes everything to 0.
+  Range<uint8_t> range(&mMap.get<uint8_t>()[0], mMap.size());
+  InputBuffer buffer(range);
+
+  uint32_t count;
+  buffer.codeUint32(count);
+
+  for (uint32_t i = 0; i < count; i++) {
+    auto entry = MakeUnique<Entry>(*this);
+    entry->Code(buffer);
+
+    // This buffer was created at runtime, during this session, so any errors
+    // indicate memory corruption, and are fatal.
+    MOZ_RELEASE_ASSERT(!buffer.error());
+
+    // Note: While the order of evaluation of the arguments to Put doesn't
+    // matter for this (the actual move will only happen within Put), to be
+    // clear about this, we call entry->Name() before calling Put.
+    const auto& name = entry->Name();
+    mEntries.InsertOrUpdate(name, std::move(entry));
+  }
+
+  return Ok();
+}
+
+void SharedMap::MaybeRebuild() const {
+  Unused << const_cast<SharedMap*>(this)->MaybeRebuild();
+}
+
+WritableSharedMap::WritableSharedMap() : SharedMap() {
+  mWritable = true;
+  // Serialize the initial empty contents of the map immediately so that we
+  // always have a file descriptor to send to callers of CloneMapFile().
+  Unused << Serialize();
+  MOZ_RELEASE_ASSERT(mMap.initialized());
+}
+
+SharedMap* WritableSharedMap::GetReadOnly() {
+  if (!mReadOnly) {
+    nsTArray<RefPtr<BlobImpl>> blobs(mBlobImpls.Clone());
+    mReadOnly =
+        new SharedMap(ContentProcessMessageManager::Get()->GetParentObject(),
+                      CloneMapFile(), MapSize(), std::move(blobs));
+  }
+  return mReadOnly;
+}
+
+Result<Ok, nsresult> WritableSharedMap::Serialize() {
+  // Serializes a new snapshot of the map, initializes a new read-only shared
+  // memory region with its contents, and updates all entries to point to that
+  // new snapshot.
+  //
+  // The layout of the snapshot is as follows:
+  //
+  // - A header containing a uint32 count field containing the number of
+  //   entries in the map, followed by that number of serialized entry headers,
+  //   as produced by Entry::Code.
+  //
+  // - A data block containing structured clone data for each of the entries'
+  //   values. This data is referenced by absolute byte offsets from the start
+  //   of the shared memory region, encoded in each of the entry header values.
+  //   Each entry's data is aligned to kStructuredCloneAlign, and therefore may
+  //   have alignment padding before it.
+  //
+  // This serialization format is decoded by the MaybeRebuild() method of
+  // read-only SharedMap() instances, and used to populate their mEntries
+  // hashtables.
+  //
+  // Writable instances never read the header blocks, but instead directly
+  // update their Entry instances to point to the appropriate offsets in the
+  // shared memory region created by this function.
+
+  uint32_t count = mEntries.Count();
+
+  size_t dataSize = 0;
+  size_t headerSize = sizeof(count);
+  size_t blobCount = 0;
+
+  for (const auto& entry : mEntries.Values()) {
+    headerSize += entry->HeaderSize();
+    blobCount += entry->BlobCount();
+
+    dataSize += entry->Size();
+    AlignTo(&dataSize, kStructuredCloneAlign);
+  }
+
+  size_t offset = headerSize;
+  AlignTo(&offset, kStructuredCloneAlign);
+
+  OutputBuffer header;
+  header.codeUint32(count);
+
+  MemMapSnapshot mem;
+  MOZ_TRY(mem.Init(offset + dataSize));
+
+  auto ptr = mem.Get<char>();
+
+  // We need to build the new array of blobs before we overwrite the existing
+  // one, since previously-serialized entries will store their blob references
+  // as indexes into our blobs array.
+  nsTArray<RefPtr<BlobImpl>> blobImpls(blobCount);
+
+  for (const auto& entry : mEntries.Values()) {
+    AlignTo(&offset, kStructuredCloneAlign);
+
+    size_t blobOffset = blobImpls.Length();
+    if (entry->BlobCount()) {
+      blobImpls.AppendElements(entry->Blobs());
+    }
+
+    entry->ExtractData(&ptr[offset], offset, blobOffset);
+    entry->Code(header);
+
+    offset += entry->Size();
+  }
+
+  mBlobImpls = std::move(blobImpls);
+
+  // FIXME: We should create a separate OutputBuffer class which can encode to
+  // a static memory region rather than dynamically allocating and then
+  // copying.
+  MOZ_ASSERT(header.cursor() == headerSize);
+  memcpy(ptr.get(), header.Get(), header.cursor());
+
+  // We've already updated offsets at this point. We need this to succeed.
+  mMap.reset();
+  MOZ_RELEASE_ASSERT(mem.Finalize(mMap).isOk());
+
+  return Ok();
+}
+
+void WritableSharedMap::SendTo(ContentParent* aParent) const {
+  nsTArray<IPCBlob> blobs(mBlobImpls.Length());
+
+  for (auto& blobImpl : mBlobImpls) {
+    nsresult rv = IPCBlobUtils::Serialize(blobImpl, *blobs.AppendElement());
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      continue;
+    }
+  }
+
+  Unused << aParent->SendUpdateSharedData(CloneMapFile(), mMap.size(), blobs,
+                                          mChangedKeys);
+}
+
+void WritableSharedMap::BroadcastChanges() {
+  if (mChangedKeys.IsEmpty()) {
+    return;
+  }
+
+  if (!Serialize().isOk()) {
+    return;
+  }
+
+  nsTArray<ContentParent*> parents;
+  ContentParent::GetAll(parents);
+  for (auto& parent : parents) {
+    SendTo(parent);
+  }
+
+  if (mReadOnly) {
+    nsTArray<RefPtr<BlobImpl>> blobImpls(mBlobImpls.Clone());
+    mReadOnly->Update(CloneMapFile(), mMap.size(), std::move(blobImpls),
+                      std::move(mChangedKeys));
+  }
+
+  mChangedKeys.Clear();
+}
+
+void WritableSharedMap::Delete(const nsACString& aName) {
+  if (mEntries.Remove(aName)) {
+    KeyChanged(aName);
+  }
+}
+
+void WritableSharedMap::Set(JSContext* aCx, const nsACString& aName,
+                            JS::Handle<JS::Value> aValue, ErrorResult& aRv) {
+  StructuredCloneData holder;
+
+  holder.Write(aCx, aValue, aRv);
+  if (aRv.Failed()) {
+    return;
+  }
+
+  if (!holder.InputStreams().IsEmpty()) {
+    aRv.Throw(NS_ERROR_INVALID_ARG);
+    return;
+  }
+
+  Entry* entry = mEntries.GetOrInsertNew(aName, *this, aName);
+  entry->TakeData(std::move(holder));
+
+  KeyChanged(aName);
+}
+
+void WritableSharedMap::Flush() { BroadcastChanges(); }
+
+void WritableSharedMap::IdleFlush() {
+  mPendingFlush = false;
+  Flush();
+}
+
+nsresult WritableSharedMap::KeyChanged(const nsACString& aName) {
+  if (!mChangedKeys.ContainsSorted(aName)) {
+    mChangedKeys.InsertElementSorted(aName);
+  }
+  mEntryArray.reset();
+
+  if (!mPendingFlush) {
+    MOZ_TRY(NS_DispatchToCurrentThreadQueue(
+        NewRunnableMethod("WritableSharedMap::IdleFlush", this,
+                          &WritableSharedMap::IdleFlush),
+        EventQueuePriority::Idle));
+    mPendingFlush = true;
+  }
+  return NS_OK;
+}
+
+JSObject* SharedMap::WrapObject(JSContext* aCx,
+                                JS::Handle<JSObject*> aGivenProto) {
+  return MozSharedMap_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+JSObject* WritableSharedMap::WrapObject(JSContext* aCx,
+                                        JS::Handle<JSObject*> aGivenProto) {
+  return MozWritableSharedMap_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+/* static */
+already_AddRefed<SharedMapChangeEvent> SharedMapChangeEvent::Constructor(
+    EventTarget* aEventTarget, const nsAString& aType,
+    const MozSharedMapChangeEventInit& aInit) {
+  RefPtr<SharedMapChangeEvent> event = new SharedMapChangeEvent(aEventTarget);
+
+  bool trusted = event->Init(aEventTarget);
+  event->InitEvent(aType, aInit.mBubbles, aInit.mCancelable);
+  event->SetTrusted(trusted);
+  event->SetComposed(aInit.mComposed);
+
+  event->mChangedKeys = aInit.mChangedKeys;
+
+  return event.forget();
+}
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(WritableSharedMap, SharedMap, mReadOnly)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WritableSharedMap)
+NS_INTERFACE_MAP_END_INHERITING(SharedMap)
+
+NS_IMPL_ADDREF_INHERITED(WritableSharedMap, SharedMap)
+NS_IMPL_RELEASE_INHERITED(WritableSharedMap, SharedMap)
+
+}  // namespace dom::ipc
+}  // namespace mozilla
diff --git a/dom/ipc/SharedMap.h b/dom/ipc/SharedMap.h
new file mode 100644
index 0000000000..0a5b686c62
--- /dev/null
+++ b/dom/ipc/SharedMap.h
@@ -0,0 +1,361 @@
+/* -*- 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/. */
+
+#ifndef dom_ipc_SharedMap_h
+#define dom_ipc_SharedMap_h
+
+#include "mozilla/dom/MozSharedMapBinding.h"
+
+#include "mozilla/AutoMemMap.h"
+#include "mozilla/dom/ipc/StructuredCloneData.h"
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Variant.h"
+#include "nsClassHashtable.h"
+#include "nsTArray.h"
+
+class nsIGlobalObject;
+
+namespace mozilla::dom {
+
+class ContentParent;
+
+namespace ipc {
+
+/**
+ * Together, the SharedMap and WritableSharedMap classes allow sharing a
+ * dynamically-updated, shared-memory key-value store across processes.
+ *
+ * The maps may only ever be updated in the parent process, via
+ * WritableSharedMap instances. When that map changes, its entire contents are
+ * serialized into a contiguous shared memory buffer, and broadcast to all child
+ * processes, which in turn update their entire map contents wholesale.
+ *
+ * Keys are arbitrary UTF-8 strings (currently exposed to JavaScript as UTF-16),
+ * and values are structured clone buffers. Values are eagerly encoded whenever
+ * they are updated, and lazily decoded each time they're read.
+ *
+ * Updates are batched. Rather than each key change triggering an immediate
+ * update, combined updates are broadcast after a delay. Changes are flushed
+ * immediately any time a new process is created. Additionally, any time a key
+ * is changed, a flush task is scheduled for the next time the event loop
+ * becomes idle. Changes can be flushed immediately by calling the flush()
+ * method.
+ *
+ *
+ * Whenever a read-only SharedMap is updated, it dispatches a "change" event.
+ * The event contains a "changedKeys" property with a list of all keys which
+ * were changed in the last update batch. Change events are never dispatched to
+ * WritableSharedMap instances.
+ */
+class SharedMap : public DOMEventTargetHelper {
+  using FileDescriptor = mozilla::ipc::FileDescriptor;
+
+ public:
+  SharedMap();
+
+  SharedMap(nsIGlobalObject* aGlobal, const FileDescriptor&, size_t,
+            nsTArray<RefPtr<BlobImpl>>&& aBlobs);
+
+  // Returns true if the map contains the given (UTF-8) key.
+  bool Has(const nsACString& name);
+
+  // If the map contains the given (UTF-8) key, decodes and returns a new copy
+  // of its value. Otherwise returns null.
+  void Get(JSContext* cx, const nsACString& name,
+           JS::MutableHandle<JS::Value> aRetVal, ErrorResult& aRv);
+
+  // Conversion helpers for WebIDL callers
+  bool Has(const nsAString& aName) { return Has(NS_ConvertUTF16toUTF8(aName)); }
+
+  void Get(JSContext* aCx, const nsAString& aName,
+           JS::MutableHandle<JS::Value> aRetVal, ErrorResult& aRv) {
+    return Get(aCx, NS_ConvertUTF16toUTF8(aName), aRetVal, aRv);
+  }
+
+  /**
+   * WebIDL iterator glue.
+   */
+  uint32_t GetIterableLength() const { return EntryArray().Length(); }
+
+  /**
+   * These functions return the key or value, respectively, at the given index.
+   * The index *must* be less than the value returned by GetIterableLength(), or
+   * the program will crash.
+   */
+  const nsString GetKeyAtIndex(uint32_t aIndex) const;
+  bool GetValueAtIndex(JSContext* aCx, uint32_t aIndex,
+                       JS::MutableHandle<JS::Value> aResult) const;
+
+  /**
+   * Returns a copy of the read-only file descriptor which backs the shared
+   * memory region for this map. The file descriptor may be passed between
+   * processes, and used to update corresponding instances in child processes.
+   */
+  FileDescriptor CloneMapFile() const;
+
+  /**
+   * Returns the size of the memory mapped region that backs this map. Must be
+   * passed to the SharedMap() constructor or Update() method along with the
+   * descriptor returned by CloneMapFile() in order to initialize or update a
+   * child SharedMap.
+   */
+  size_t MapSize() const { return mMap.size(); }
+
+  /**
+   * Updates this instance to reflect the contents of the shared memory region
+   * in the given map file, and broadcasts a change event for the given set of
+   * changed (UTF-8-encoded) keys.
+   */
+  void Update(const FileDescriptor& aMapFile, size_t aMapSize,
+              nsTArray<RefPtr<BlobImpl>>&& aBlobs,
+              nsTArray<nsCString>&& aChangedKeys);
+
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override;
+
+ protected:
+  ~SharedMap() override = default;
+
+  class Entry {
+   public:
+    Entry(Entry&&) = delete;
+
+    explicit Entry(SharedMap& aMap, const nsACString& aName = ""_ns)
+        : mMap(aMap), mName(aName), mData(AsVariant(uint32_t(0))) {}
+
+    ~Entry() = default;
+
+    /**
+     * Encodes or decodes this entry into or from the given OutputBuffer or
+     * InputBuffer.
+     */
+    template <typename Buffer>
+    void Code(Buffer& buffer) {
+      DebugOnly<size_t> startOffset = buffer.cursor();
+
+      buffer.codeString(mName);
+      buffer.codeUint32(DataOffset());
+      buffer.codeUint32(mSize);
+      buffer.codeUint16(mBlobOffset);
+      buffer.codeUint16(mBlobCount);
+
+      MOZ_ASSERT(buffer.cursor() == startOffset + HeaderSize());
+    }
+
+    /**
+     * Returns the size that this entry will take up in the map header. This
+     * must be equal to the number of bytes encoded by Code().
+     */
+    size_t HeaderSize() const {
+      return (sizeof(uint16_t) + mName.Length() + sizeof(DataOffset()) +
+              sizeof(mSize) + sizeof(mBlobOffset) + sizeof(mBlobCount));
+    }
+
+    /**
+     * Updates the value of this entry to the given structured clone data, of
+     * which it takes ownership. The passed StructuredCloneData object must not
+     * be used after this call.
+     */
+    void TakeData(StructuredCloneData&&);
+
+    /**
+     * This is called while building a new snapshot of the SharedMap. aDestPtr
+     * must point to a buffer within the new snapshot with Size() bytes reserved
+     * for it, and `aNewOffset` must be the offset of that buffer from the start
+     * of the snapshot's memory region.
+     *
+     * This function copies the raw structured clone data for the entry's value
+     * to the new buffer, and updates its internal state for use with the new
+     * data. Its offset is updated to aNewOffset, and any StructuredCloneData
+     * object it holds is destroyed.
+     *
+     * After this call, the entry is only valid in reference to the new
+     * snapshot, and must not be accessed again until the SharedMap mMap has
+     * been updated to point to it.
+     */
+    void ExtractData(char* aDestPtr, uint32_t aNewOffset,
+                     uint16_t aNewBlobOffset);
+
+    // Returns the UTF-8-encoded name of the entry, which is used as its key in
+    // the map.
+    const nsCString& Name() const { return mName; }
+
+    // Decodes the entry's value into the current Realm of the given JS context
+    // and puts the result in aRetVal on success.
+    void Read(JSContext* aCx, JS::MutableHandle<JS::Value> aRetVal,
+              ErrorResult& aRv);
+
+    // Returns the byte size of the entry's raw structured clone data.
+    uint32_t Size() const { return mSize; }
+
+   private:
+    // Returns a pointer to the entry value's structured clone data within the
+    // SharedMap's mapped memory region. This is *only* valid shen mData
+    // contains a uint32_t.
+    const char* Data() const { return mMap.Data() + DataOffset(); }
+
+    // Returns the offset of the entry value's structured clone data within the
+    // SharedMap's mapped memory region. This is *only* valid shen mData
+    // contains a uint32_t.
+    uint32_t& DataOffset() { return mData.as<uint32_t>(); }
+    const uint32_t& DataOffset() const { return mData.as<uint32_t>(); }
+
+   public:
+    uint16_t BlobOffset() const { return mBlobOffset; }
+    uint16_t BlobCount() const { return mBlobCount; }
+
+    Span<const RefPtr<BlobImpl>> Blobs() {
+      if (mData.is<StructuredCloneData>()) {
+        return mData.as<StructuredCloneData>().BlobImpls();
+      }
+      return {&mMap.mBlobImpls[mBlobOffset], BlobCount()};
+    }
+
+   private:
+    // Returns the temporary StructuredCloneData object containing the entry's
+    // value. This is *only* value when mData contains a StructuredCloneDAta
+    // object.
+    const StructuredCloneData& Holder() const {
+      return mData.as<StructuredCloneData>();
+    }
+
+    SharedMap& mMap;
+
+    // The entry's (UTF-8 encoded) name, which serves as its key in the map.
+    nsCString mName;
+
+    /**
+     * This member provides a reference to the entry's structured clone data.
+     * Its type varies depending on the state of the entry:
+     *
+     * - For entries which have been snapshotted into a shared memory region,
+     *   this is a uint32_t offset into the parent SharedMap's Data() buffer.
+     *
+     * - For entries which have been changed in a WritableSharedMap instance,
+     *   but not serialized to a shared memory snapshot yet, this is a
+     *   StructuredCloneData instance, containing a process-local copy of the
+     *   data. This will be discarded the next time the map is serialized, and
+     *   replaced with a buffer offset, as described above.
+     */
+    Variant<uint32_t, StructuredCloneData> mData;
+
+    // The size, in bytes, of the entry's structured clone data.
+    uint32_t mSize = 0;
+
+    uint16_t mBlobOffset = 0;
+    uint16_t mBlobCount = 0;
+  };
+
+  const nsTArray<Entry*>& EntryArray() const;
+
+  nsTArray<RefPtr<BlobImpl>> mBlobImpls;
+
+  // Rebuilds the entry hashtable mEntries from the values serialized in the
+  // current snapshot, if necessary. The hashtable is rebuilt lazily after
+  // construction and after every Update() call, so this function must be called
+  // before any attempt to access mEntries.
+  Result<Ok, nsresult> MaybeRebuild();
+  void MaybeRebuild() const;
+
+  // Note: This header is included by WebIDL binding headers, and therefore
+  // can't include "windows.h". Since FileDescriptor.h does include "windows.h"
+  // on Windows, we can only forward declare FileDescriptor, and can't include
+  // it as an inline member.
+  UniquePtr<FileDescriptor> mMapFile;
+  // The size of the memory-mapped region backed by mMapFile, in bytes.
+  size_t mMapSize = 0;
+
+  mutable nsClassHashtable<nsCStringHashKey, Entry> mEntries;
+  mutable Maybe<nsTArray<Entry*>> mEntryArray;
+
+  // Manages the memory mapping of the current snapshot. This is initialized
+  // lazily after each SharedMap construction or updated, based on the values in
+  // mMapFile and mMapSize.
+  loader::AutoMemMap mMap;
+
+  bool mWritable = false;
+
+  // Returns a pointer to the beginning of the memory mapped snapshot. Entry
+  // offsets are relative to this pointer, and Entry objects access their
+  // structured clone data by indexing this pointer.
+  char* Data() { return mMap.get<char>().get(); }
+};
+
+class WritableSharedMap final : public SharedMap {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(WritableSharedMap, SharedMap)
+
+  WritableSharedMap();
+
+  // Sets the value of the given (UTF-8 encoded) key to a structured clone
+  // snapshot of the given value.
+  void Set(JSContext* cx, const nsACString& name, JS::Handle<JS::Value> value,
+           ErrorResult& aRv);
+
+  // Deletes the given (UTF-8 encoded) key from the map.
+  void Delete(const nsACString& name);
+
+  // Conversion helpers for WebIDL callers
+  void Set(JSContext* aCx, const nsAString& aName, JS::Handle<JS::Value> aValue,
+           ErrorResult& aRv) {
+    return Set(aCx, NS_ConvertUTF16toUTF8(aName), aValue, aRv);
+  }
+
+  void Delete(const nsAString& aName) {
+    return Delete(NS_ConvertUTF16toUTF8(aName));
+  }
+
+  // Flushes any queued changes to a new snapshot, and broadcasts it to all
+  // child SharedMap instances.
+  void Flush();
+
+  // Sends the current set of shared map data to the given content process.
+  void SendTo(ContentParent* aContentParent) const;
+
+  /**
+   * Returns the read-only SharedMap instance corresponding to this
+   * WritableSharedMap for use in the parent process.
+   */
+  SharedMap* GetReadOnly();
+
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override;
+
+ protected:
+  ~WritableSharedMap() override = default;
+
+ private:
+  // The set of (UTF-8 encoded) keys which have changed, or been deleted, since
+  // the last snapshot.
+  nsTArray<nsCString> mChangedKeys;
+
+  RefPtr<SharedMap> mReadOnly;
+
+  bool mPendingFlush = false;
+
+  // Creates a new snapshot of the map, and updates all Entry instance to
+  // reference its data.
+  Result<Ok, nsresult> Serialize();
+
+  void IdleFlush();
+
+  // If there have been any changes since the last snapshot, creates a new
+  // serialization and broadcasts it to all child SharedMap instances.
+  void BroadcastChanges();
+
+  // Marks the given (UTF-8 encoded) key as having changed. This adds it to
+  // mChangedKeys, if not already present, and schedules a flush for the next
+  // time the event loop is idle.
+  nsresult KeyChanged(const nsACString& aName);
+};
+
+}  // namespace ipc
+}  // namespace mozilla::dom
+
+#endif  // dom_ipc_SharedMap_h
diff --git a/dom/ipc/SharedMapChangeEvent.h b/dom/ipc/SharedMapChangeEvent.h
new file mode 100644
index 0000000000..06bc53933b
--- /dev/null
+++ b/dom/ipc/SharedMapChangeEvent.h
@@ -0,0 +1,46 @@
+/* -*- 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/. */
+
+#ifndef dom_ipc_SharedMapChangeEvent_h
+#define dom_ipc_SharedMapChangeEvent_h
+
+#include "mozilla/dom/MozSharedMapBinding.h"
+
+#include "mozilla/dom/Event.h"
+#include "nsTArray.h"
+
+namespace mozilla::dom::ipc {
+
+class SharedMapChangeEvent final : public Event {
+ public:
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(SharedMapChangeEvent, Event)
+
+  JSObject* WrapObjectInternal(JSContext* aCx,
+                               JS::Handle<JSObject*> aGivenProto) override {
+    return MozSharedMapChangeEvent_Binding::Wrap(aCx, this, aGivenProto);
+  }
+
+  static already_AddRefed<SharedMapChangeEvent> Constructor(
+      EventTarget* aEventTarget, const nsAString& aType,
+      const MozSharedMapChangeEventInit& aInit);
+
+  void GetChangedKeys(nsTArray<nsString>& aChangedKeys) const {
+    aChangedKeys.AppendElements(mChangedKeys);
+  }
+
+ protected:
+  ~SharedMapChangeEvent() override = default;
+
+ private:
+  explicit SharedMapChangeEvent(EventTarget* aEventTarget)
+      : Event(aEventTarget, nullptr, nullptr) {}
+
+  nsTArray<nsString> mChangedKeys;
+};
+
+}  // namespace mozilla::dom::ipc
+
+#endif  // dom_ipc_SharedMapChangeEvent_h
diff --git a/dom/ipc/SharedMessageBody.cpp b/dom/ipc/SharedMessageBody.cpp
new file mode 100644
index 0000000000..e09ff2fd55
--- /dev/null
+++ b/dom/ipc/SharedMessageBody.cpp
@@ -0,0 +1,298 @@
+/* -*- 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 "SharedMessageBody.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/MessagePort.h"
+#include "mozilla/dom/RefMessageBodyService.h"
+#include "mozilla/dom/PMessagePort.h"
+#include "mozilla/ipc/BackgroundChild.h"
+#include "mozilla/ipc/BackgroundParent.h"
+#include "xpcpublic.h"
+
+namespace mozilla {
+
+using namespace ipc;
+
+namespace dom {
+
+SharedMessageBody::SharedMessageBody(
+    StructuredCloneHolder::TransferringSupport aSupportsTransferring,
+    const Maybe<nsID>& aAgentClusterId)
+    : mRefDataId(Nothing()),
+      mSupportsTransferring(aSupportsTransferring),
+      mAgentClusterId(aAgentClusterId) {}
+
+void SharedMessageBody::Write(JSContext* aCx, JS::Handle<JS::Value> aValue,
+                              JS::Handle<JS::Value> aTransfers, nsID& aPortID,
+                              RefMessageBodyService* aRefMessageBodyService,
+                              ErrorResult& aRv) {
+  MOZ_ASSERT(!mCloneData && !mRefData);
+  MOZ_ASSERT(aRefMessageBodyService);
+
+  JS::CloneDataPolicy cloneDataPolicy;
+  // During a writing, we don't know the destination, so we assume it is part of
+  // the same agent cluster.
+  cloneDataPolicy.allowIntraClusterClonableSharedObjects();
+
+  nsIGlobalObject* global = xpc::CurrentNativeGlobal(aCx);
+  MOZ_ASSERT(global);
+
+  if (global->IsSharedMemoryAllowed()) {
+    cloneDataPolicy.allowSharedMemoryObjects();
+  }
+
+  mCloneData = MakeUnique<ipc::StructuredCloneData>(
+      JS::StructuredCloneScope::UnknownDestination, mSupportsTransferring);
+  mCloneData->Write(aCx, aValue, aTransfers, cloneDataPolicy, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  if (mCloneData->CloneScope() == JS::StructuredCloneScope::DifferentProcess) {
+    return;
+  }
+
+  MOZ_ASSERT(mCloneData->CloneScope() == JS::StructuredCloneScope::SameProcess);
+  RefPtr<RefMessageBody> refData =
+      new RefMessageBody(aPortID, std::move(mCloneData));
+
+  mRefDataId.emplace(aRefMessageBodyService->Register(refData.forget(), aRv));
+}
+
+void SharedMessageBody::Read(JSContext* aCx,
+                             JS::MutableHandle<JS::Value> aValue,
+                             RefMessageBodyService* aRefMessageBodyService,
+                             SharedMessageBody::ReadMethod aReadMethod,
+                             ErrorResult& aRv) {
+  MOZ_ASSERT(aRefMessageBodyService);
+
+  if (mCloneData) {
+    // Use a default cloneDataPolicy here, because SharedArrayBuffers and WASM
+    // are not supported.
+    return mCloneData->Read(aCx, aValue, JS::CloneDataPolicy(), aRv);
+  }
+
+  JS::CloneDataPolicy cloneDataPolicy;
+
+  nsIGlobalObject* global = xpc::CurrentNativeGlobal(aCx);
+  MOZ_ASSERT(global);
+
+  // Clones within the same agent cluster are allowed to use shared array
+  // buffers and WASM modules.
+  if (mAgentClusterId.isSome()) {
+    Maybe<nsID> agentClusterId = global->GetAgentClusterId();
+    if (agentClusterId.isSome() &&
+        mAgentClusterId.value().Equals(agentClusterId.value())) {
+      cloneDataPolicy.allowIntraClusterClonableSharedObjects();
+    }
+  }
+
+  if (global->IsSharedMemoryAllowed()) {
+    cloneDataPolicy.allowSharedMemoryObjects();
+  }
+
+  MOZ_ASSERT(!mRefData);
+  MOZ_ASSERT(mRefDataId.isSome());
+
+  if (aReadMethod == SharedMessageBody::StealRefMessageBody) {
+    mRefData = aRefMessageBodyService->Steal(mRefDataId.value());
+  } else {
+    MOZ_ASSERT(aReadMethod == SharedMessageBody::KeepRefMessageBody);
+    mRefData = aRefMessageBodyService->GetAndCount(mRefDataId.value());
+  }
+
+  if (!mRefData) {
+    aRv.Throw(NS_ERROR_DOM_DATA_CLONE_ERR);
+    return;
+  }
+
+  mRefData->Read(aCx, aValue, cloneDataPolicy, aRv);
+}
+
+bool SharedMessageBody::TakeTransferredPortsAsSequence(
+    Sequence<OwningNonNull<mozilla::dom::MessagePort>>& aPorts) {
+  if (mCloneData) {
+    return mCloneData->TakeTransferredPortsAsSequence(aPorts);
+  }
+
+  MOZ_ASSERT(mRefData);
+  return mRefData->TakeTransferredPortsAsSequence(aPorts);
+}
+
+/* static */
+void SharedMessageBody::FromSharedToMessageChild(
+    mozilla::ipc::PBackgroundChild* aManager, SharedMessageBody* aData,
+    MessageData& aMessage) {
+  MOZ_ASSERT(aManager);
+  MOZ_ASSERT(aData);
+
+  aMessage.agentClusterId() = aData->mAgentClusterId;
+
+  if (aData->mCloneData) {
+    ClonedMessageData clonedData;
+    aData->mCloneData->BuildClonedMessageData(clonedData);
+    aMessage.data() = std::move(clonedData);
+    return;
+  }
+
+  MOZ_ASSERT(aData->mRefDataId.isSome());
+  aMessage.data() = RefMessageData(aData->mRefDataId.value());
+}
+
+/* static */
+void SharedMessageBody::FromSharedToMessagesChild(
+    PBackgroundChild* aManager,
+    const nsTArray<RefPtr<SharedMessageBody>>& aData,
+    nsTArray<MessageData>& aArray) {
+  MOZ_ASSERT(aManager);
+  MOZ_ASSERT(aArray.IsEmpty());
+  aArray.SetCapacity(aData.Length());
+
+  for (auto& data : aData) {
+    MessageData* message = aArray.AppendElement();
+    FromSharedToMessageChild(aManager, data, *message);
+  }
+}
+
+/* static */
+already_AddRefed<SharedMessageBody> SharedMessageBody::FromMessageToSharedChild(
+    MessageData& aMessage,
+    StructuredCloneHolder::TransferringSupport aSupportsTransferring) {
+  RefPtr<SharedMessageBody> data =
+      new SharedMessageBody(aSupportsTransferring, aMessage.agentClusterId());
+
+  if (aMessage.data().type() == MessageDataType::TClonedMessageData) {
+    data->mCloneData = MakeUnique<ipc::StructuredCloneData>(
+        JS::StructuredCloneScope::UnknownDestination, aSupportsTransferring);
+    data->mCloneData->StealFromClonedMessageData(
+        aMessage.data().get_ClonedMessageData());
+  } else {
+    MOZ_ASSERT(aMessage.data().type() == MessageDataType::TRefMessageData);
+    data->mRefDataId.emplace(aMessage.data().get_RefMessageData().uuid());
+  }
+
+  return data.forget();
+}
+
+/* static */
+already_AddRefed<SharedMessageBody> SharedMessageBody::FromMessageToSharedChild(
+    const MessageData& aMessage,
+    StructuredCloneHolder::TransferringSupport aSupportsTransferring) {
+  RefPtr<SharedMessageBody> data =
+      new SharedMessageBody(aSupportsTransferring, aMessage.agentClusterId());
+
+  if (aMessage.data().type() == MessageDataType::TClonedMessageData) {
+    data->mCloneData = MakeUnique<ipc::StructuredCloneData>(
+        JS::StructuredCloneScope::UnknownDestination, aSupportsTransferring);
+    data->mCloneData->BorrowFromClonedMessageData(
+        aMessage.data().get_ClonedMessageData());
+  } else {
+    MOZ_ASSERT(aMessage.data().type() == MessageDataType::TRefMessageData);
+    data->mRefDataId.emplace(aMessage.data().get_RefMessageData().uuid());
+  }
+
+  return data.forget();
+}
+
+/* static */
+bool SharedMessageBody::FromMessagesToSharedChild(
+    nsTArray<MessageData>& aArray,
+    FallibleTArray<RefPtr<SharedMessageBody>>& aData,
+    StructuredCloneHolder::TransferringSupport aSupportsTransferring) {
+  MOZ_ASSERT(aData.IsEmpty());
+
+  if (NS_WARN_IF(!aData.SetCapacity(aArray.Length(), mozilla::fallible))) {
+    return false;
+  }
+
+  for (auto& message : aArray) {
+    RefPtr<SharedMessageBody> data =
+        FromMessageToSharedChild(message, aSupportsTransferring);
+    if (!data || !aData.AppendElement(data, mozilla::fallible)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/* static */
+bool SharedMessageBody::FromSharedToMessagesParent(
+    PBackgroundParent* aManager,
+    const nsTArray<RefPtr<SharedMessageBody>>& aData,
+    nsTArray<MessageData>& aArray) {
+  MOZ_ASSERT(aManager);
+  MOZ_ASSERT(aArray.IsEmpty());
+
+  if (NS_WARN_IF(!aArray.SetCapacity(aData.Length(), mozilla::fallible))) {
+    return false;
+  }
+
+  for (auto& data : aData) {
+    MessageData* message = aArray.AppendElement();
+    message->agentClusterId() = data->mAgentClusterId;
+
+    if (data->mCloneData) {
+      ClonedMessageData clonedData;
+      data->mCloneData->BuildClonedMessageData(clonedData);
+      message->data() = std::move(clonedData);
+      continue;
+    }
+
+    MOZ_ASSERT(data->mRefDataId.isSome());
+    message->data() = RefMessageData(data->mRefDataId.value());
+  }
+
+  return true;
+}
+
+/* static */
+already_AddRefed<SharedMessageBody>
+SharedMessageBody::FromMessageToSharedParent(
+    MessageData& aMessage,
+    StructuredCloneHolder::TransferringSupport aSupportsTransferring) {
+  // TODO: This alloc is not fallible and there is no codepath that returns
+  // nullptr. But the caller checks for nullptr and handles array allocations
+  // for these items as fallible. See bug 1750497.
+  RefPtr<SharedMessageBody> data =
+      new SharedMessageBody(aSupportsTransferring, aMessage.agentClusterId());
+
+  if (aMessage.data().type() == MessageDataType::TClonedMessageData) {
+    data->mCloneData = MakeUnique<ipc::StructuredCloneData>(
+        JS::StructuredCloneScope::UnknownDestination, aSupportsTransferring);
+    data->mCloneData->StealFromClonedMessageData(
+        aMessage.data().get_ClonedMessageData());
+  } else {
+    MOZ_ASSERT(aMessage.data().type() == MessageDataType::TRefMessageData);
+    data->mRefDataId.emplace(aMessage.data().get_RefMessageData().uuid());
+  }
+
+  return data.forget();
+}
+
+bool SharedMessageBody::FromMessagesToSharedParent(
+    nsTArray<MessageData>& aArray,
+    FallibleTArray<RefPtr<SharedMessageBody>>& aData,
+    StructuredCloneHolder::TransferringSupport aSupportsTransferring) {
+  MOZ_ASSERT(aData.IsEmpty());
+
+  if (NS_WARN_IF(!aData.SetCapacity(aArray.Length(), mozilla::fallible))) {
+    return false;
+  }
+
+  for (auto& message : aArray) {
+    RefPtr<SharedMessageBody> data = FromMessageToSharedParent(message);
+    if (!data || !aData.AppendElement(data, mozilla::fallible)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/ipc/SharedMessageBody.h b/dom/ipc/SharedMessageBody.h
new file mode 100644
index 0000000000..2c82473678
--- /dev/null
+++ b/dom/ipc/SharedMessageBody.h
@@ -0,0 +1,112 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_SharedMessageBody_h
+#define mozilla_dom_SharedMessageBody_h
+
+#include "mozilla/dom/ipc/StructuredCloneData.h"
+#include "mozilla/Maybe.h"
+
+namespace mozilla {
+
+namespace ipc {
+class PBackgroundChild;
+}
+
+namespace dom {
+
+class MessagePort;
+class RefMessageBody;
+class RefMessageBodyService;
+
+class SharedMessageBody final {
+ public:
+  NS_INLINE_DECL_REFCOUNTING(SharedMessageBody)
+
+  SharedMessageBody(
+      StructuredCloneHolder::TransferringSupport aSupportsTransferring,
+      const Maybe<nsID>& aAgentClusterId);
+
+  // Note that the populated MessageData borrows the underlying
+  // JSStructuredCloneData from the SharedMessageBody, so the caller is
+  // required to ensure that the MessageData instances are destroyed prior to
+  // the SharedMessageBody instances.
+  static void FromSharedToMessageChild(
+      mozilla::ipc::PBackgroundChild* aBackgroundManager,
+      SharedMessageBody* aData, MessageData& aMessage);
+  static void FromSharedToMessagesChild(
+      mozilla::ipc::PBackgroundChild* aBackgroundManager,
+      const nsTArray<RefPtr<SharedMessageBody>>& aData,
+      nsTArray<MessageData>& aArray);
+
+  // Const MessageData.
+  static already_AddRefed<SharedMessageBody> FromMessageToSharedChild(
+      MessageData& aMessage,
+      StructuredCloneHolder::TransferringSupport aSupportsTransferring =
+          StructuredCloneHolder::TransferringSupported);
+  // Non-const MessageData.
+  static already_AddRefed<SharedMessageBody> FromMessageToSharedChild(
+      const MessageData& aMessage,
+      StructuredCloneHolder::TransferringSupport aSupportsTransferring =
+          StructuredCloneHolder::TransferringSupported);
+  // Array of MessageData objects
+  static bool FromMessagesToSharedChild(
+      nsTArray<MessageData>& aArray,
+      FallibleTArray<RefPtr<SharedMessageBody>>& aData,
+      StructuredCloneHolder::TransferringSupport aSupportsTransferring =
+          StructuredCloneHolder::TransferringSupported);
+
+  // Note that the populated MessageData borrows the underlying
+  // JSStructuredCloneData from the SharedMessageBody, so the caller is
+  // required to ensure that the MessageData instances are destroyed prior to
+  // the SharedMessageBody instances.
+  static bool FromSharedToMessagesParent(
+      mozilla::ipc::PBackgroundParent* aManager,
+      const nsTArray<RefPtr<SharedMessageBody>>& aData,
+      nsTArray<MessageData>& aArray);
+
+  static already_AddRefed<SharedMessageBody> FromMessageToSharedParent(
+      MessageData& aMessage,
+      StructuredCloneHolder::TransferringSupport aSupportsTransferring =
+          StructuredCloneHolder::TransferringSupported);
+  static bool FromMessagesToSharedParent(
+      nsTArray<MessageData>& aArray,
+      FallibleTArray<RefPtr<SharedMessageBody>>& aData,
+      StructuredCloneHolder::TransferringSupport aSupportsTransferring =
+          StructuredCloneHolder::TransferringSupported);
+
+  enum ReadMethod {
+    StealRefMessageBody,
+    KeepRefMessageBody,
+  };
+
+  void Read(JSContext* aCx, JS::MutableHandle<JS::Value> aValue,
+            RefMessageBodyService* aRefMessageBodyService,
+            ReadMethod aReadMethod, ErrorResult& aRv);
+
+  void Write(JSContext* aCx, JS::Handle<JS::Value> aValue,
+             JS::Handle<JS::Value> aTransfers, nsID& aPortID,
+             RefMessageBodyService* aRefMessageBodyService, ErrorResult& aRv);
+
+  bool TakeTransferredPortsAsSequence(
+      Sequence<OwningNonNull<mozilla::dom::MessagePort>>& aPorts);
+
+ private:
+  ~SharedMessageBody() = default;
+
+  UniquePtr<ipc::StructuredCloneData> mCloneData;
+
+  RefPtr<RefMessageBody> mRefData;
+  Maybe<nsID> mRefDataId;
+
+  const StructuredCloneHolder::TransferringSupport mSupportsTransferring;
+  const Maybe<nsID> mAgentClusterId;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_SharedMessageBody_h
diff --git a/dom/ipc/SharedStringMap.cpp b/dom/ipc/SharedStringMap.cpp
new file mode 100644
index 0000000000..9525c9f285
--- /dev/null
+++ b/dom/ipc/SharedStringMap.cpp
@@ -0,0 +1,139 @@
+/* -*- 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 "SharedStringMap.h"
+
+#include "MemMapSnapshot.h"
+#include "ScriptPreloader-inl.h"
+
+#include "mozilla/BinarySearch.h"
+#include "mozilla/ipc/FileDescriptor.h"
+
+using namespace mozilla::loader;
+
+namespace mozilla {
+
+using namespace ipc;
+
+namespace dom::ipc {
+
+static constexpr uint32_t kSharedStringMapMagic = 0x9e3779b9;
+
+static inline size_t GetAlignmentOffset(size_t aOffset, size_t aAlign) {
+  auto mod = aOffset % aAlign;
+  return mod ? aAlign - mod : 0;
+}
+
+SharedStringMap::SharedStringMap(const FileDescriptor& aMapFile,
+                                 size_t aMapSize) {
+  auto result = mMap.initWithHandle(aMapFile, aMapSize);
+  MOZ_RELEASE_ASSERT(result.isOk());
+  MOZ_RELEASE_ASSERT(GetHeader().mMagic == kSharedStringMapMagic);
+  // We return literal nsStrings and nsCStrings pointing to the mapped data,
+  // which means that we may still have references to the mapped data even
+  // after this instance is destroyed. That means that we need to keep the
+  // mapping alive until process shutdown, in order to be safe.
+  mMap.setPersistent();
+}
+
+SharedStringMap::SharedStringMap(SharedStringMapBuilder&& aBuilder) {
+  auto result = aBuilder.Finalize(mMap);
+  MOZ_RELEASE_ASSERT(result.isOk());
+  MOZ_RELEASE_ASSERT(GetHeader().mMagic == kSharedStringMapMagic);
+  mMap.setPersistent();
+}
+
+mozilla::ipc::FileDescriptor SharedStringMap::CloneFileDescriptor() const {
+  return mMap.cloneHandle();
+}
+
+bool SharedStringMap::Has(const nsCString& aKey) {
+  size_t index;
+  return Find(aKey, &index);
+}
+
+bool SharedStringMap::Get(const nsCString& aKey, nsAString& aValue) {
+  const auto& entries = Entries();
+
+  size_t index;
+  if (!Find(aKey, &index)) {
+    return false;
+  }
+
+  aValue.Assign(ValueTable().Get(entries[index].mValue));
+  return true;
+}
+
+bool SharedStringMap::Find(const nsCString& aKey, size_t* aIndex) {
+  const auto& keys = KeyTable();
+
+  return BinarySearchIf(
+      Entries(), 0, EntryCount(),
+      [&](const Entry& aEntry) { return Compare(aKey, keys.Get(aEntry.mKey)); },
+      aIndex);
+}
+
+void SharedStringMapBuilder::Add(const nsCString& aKey,
+                                 const nsString& aValue) {
+  mEntries.InsertOrUpdate(aKey,
+                          Entry{mKeyTable.Add(aKey), mValueTable.Add(aValue)});
+}
+
+Result<Ok, nsresult> SharedStringMapBuilder::Finalize(
+    loader::AutoMemMap& aMap) {
+  using Header = SharedStringMap::Header;
+
+  MOZ_ASSERT(mEntries.Count() == mKeyTable.Count());
+
+  auto keys = ToTArray<nsTArray<nsCString>>(mEntries.Keys());
+  keys.Sort();
+
+  Header header = {kSharedStringMapMagic, uint32_t(keys.Length())};
+
+  size_t offset = sizeof(header);
+  offset += GetAlignmentOffset(offset, alignof(Header));
+
+  offset += keys.Length() * sizeof(SharedStringMap::Entry);
+
+  header.mKeyStringsOffset = offset;
+  header.mKeyStringsSize = mKeyTable.Size();
+
+  offset += header.mKeyStringsSize;
+  offset +=
+      GetAlignmentOffset(offset, alignof(decltype(mValueTable)::ElemType));
+
+  header.mValueStringsOffset = offset;
+  header.mValueStringsSize = mValueTable.Size();
+
+  offset += header.mValueStringsSize;
+
+  MemMapSnapshot mem;
+  MOZ_TRY(mem.Init(offset));
+
+  auto headerPtr = mem.Get<Header>();
+  headerPtr[0] = header;
+
+  auto* entry = reinterpret_cast<Entry*>(&headerPtr[1]);
+  for (auto& key : keys) {
+    *entry++ = mEntries.Get(key);
+  }
+
+  auto ptr = mem.Get<uint8_t>();
+
+  mKeyTable.Write({&ptr[header.mKeyStringsOffset], header.mKeyStringsSize});
+
+  mValueTable.Write(
+      {&ptr[header.mValueStringsOffset], header.mValueStringsSize});
+
+  mKeyTable.Clear();
+  mValueTable.Clear();
+  mEntries.Clear();
+
+  return mem.Finalize(aMap);
+}
+
+}  // namespace dom::ipc
+}  // namespace mozilla
diff --git a/dom/ipc/SharedStringMap.h b/dom/ipc/SharedStringMap.h
new file mode 100644
index 0000000000..cb14e09dbc
--- /dev/null
+++ b/dom/ipc/SharedStringMap.h
@@ -0,0 +1,220 @@
+/* -*- 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/. */
+
+#ifndef dom_ipc_SharedStringMap_h
+#define dom_ipc_SharedStringMap_h
+
+#include "mozilla/AutoMemMap.h"
+#include "mozilla/Result.h"
+#include "mozilla/dom/ipc/StringTable.h"
+#include "nsTHashMap.h"
+
+namespace mozilla::dom::ipc {
+
+class SharedStringMapBuilder;
+
+/**
+ * This class provides a simple, read-only key-value string store, with all
+ * data packed into a single segment of memory, which can be shared between
+ * processes.
+ *
+ * Look-ups are performed by binary search of a static table in the mapped
+ * memory region, and all returned strings are literals which reference the
+ * mapped data. No copies are performed on instantiation or look-up.
+ *
+ * Important: The mapped memory created by this class is persistent. Once an
+ * instance has been initialized, the memory that it allocates can never be
+ * freed before process shutdown. Do not use it for short-lived mappings.
+ */
+class SharedStringMap {
+  using FileDescriptor = mozilla::ipc::FileDescriptor;
+
+ public:
+  /**
+   * The header at the beginning of the shared memory region describing its
+   * layout. The layout of the shared memory is as follows:
+   *
+   * - Header:
+   *   A Header struct describing the contents of the rest of the memory region.
+   *
+   * - Optional alignment padding for Header[].
+   *
+   * - Entry[header.mEntryCount]:
+   *   An array of Entry structs, one for each entry in the map. Entries are
+   *   lexocographically sorted by key.
+   *
+   * - StringTable<nsCString>:
+   *   A region of flat, null-terminated C strings. Entry key strings are
+   *   encoded as character offsets into this region.
+   *
+   * - Optional alignment padding for char16_t[]
+   *
+   * - StringTable<nsString>:
+   *   A region of flat, null-terminated UTF-16 strings. Entry value strings are
+   *   encoded as character (*not* byte) offsets into this region.
+   */
+  struct Header {
+    uint32_t mMagic;
+    // The number of entries in this map.
+    uint32_t mEntryCount;
+
+    // The raw byte offset of the beginning of the key string table, from the
+    // start of the shared memory region, and its size in bytes.
+    size_t mKeyStringsOffset;
+    size_t mKeyStringsSize;
+
+    // The raw byte offset of the beginning of the value string table, from the
+    // start of the shared memory region, and its size in bytes (*not*
+    // characters).
+    size_t mValueStringsOffset;
+    size_t mValueStringsSize;
+  };
+
+  /**
+   * Describes a value in the string map, as offsets into the key and value
+   * string tables.
+   */
+  struct Entry {
+    // The offset and size of the entry's UTF-8 key in the key string table.
+    StringTableEntry mKey;
+    // The offset and size of the entry's UTF-16 value in the value string
+    // table.
+    StringTableEntry mValue;
+  };
+
+  NS_INLINE_DECL_REFCOUNTING(SharedStringMap)
+
+  // Note: These constructors are infallible on the premise that this class
+  // is used primarily in cases where it is critical to platform
+  // functionality.
+  explicit SharedStringMap(const FileDescriptor&, size_t);
+  explicit SharedStringMap(SharedStringMapBuilder&&);
+
+  /**
+   * Searches for the given value in the map, and returns true if it exists.
+   */
+  bool Has(const nsCString& aKey);
+
+  /**
+   * Searches for the given value in the map, and, if it exists, returns true
+   * and places its value in aValue.
+   *
+   * The returned value is a literal string which references the mapped memory
+   * region.
+   */
+  bool Get(const nsCString& aKey, nsAString& aValue);
+
+ private:
+  /**
+   * Searches for an entry for the given key. If found, returns true, and
+   * places its index in the entry array in aIndex.
+   */
+  bool Find(const nsCString& aKey, size_t* aIndex);
+
+ public:
+  /**
+   * Returns the number of entries in the map.
+   */
+  uint32_t Count() const { return EntryCount(); }
+
+  /**
+   * Returns the string entry at the given index. Keys are guaranteed to be
+   * sorted lexographically.
+   *
+   * The given index *must* be less than the value returned by Count().
+   *
+   * The returned value is a literal string which references the mapped memory
+   * region.
+   */
+  nsCString GetKeyAt(uint32_t aIndex) const {
+    MOZ_ASSERT(aIndex < Count());
+    return KeyTable().Get(Entries()[aIndex].mKey);
+  }
+
+  /**
+   * Returns the string value for the entry at the given index.
+   *
+   * The given index *must* be less than the value returned by Count().
+   *
+   * The returned value is a literal string which references the mapped memory
+   * region.
+   */
+  nsString GetValueAt(uint32_t aIndex) const {
+    MOZ_ASSERT(aIndex < Count());
+    return ValueTable().Get(Entries()[aIndex].mValue);
+  }
+
+  /**
+   * Returns a copy of the read-only file descriptor which backs the shared
+   * memory region for this map. The file descriptor may be passed between
+   * processes, and used to construct new instances of SharedStringMap with
+   * the same data as this instance.
+   */
+  FileDescriptor CloneFileDescriptor() const;
+
+  size_t MapSize() const { return mMap.size(); }
+
+ protected:
+  ~SharedStringMap() = default;
+
+ private:
+  // Type-safe getters for values in the shared memory region:
+  const Header& GetHeader() const { return mMap.get<Header>()[0]; }
+
+  RangedPtr<const Entry> Entries() const {
+    return {reinterpret_cast<const Entry*>(&GetHeader() + 1), EntryCount()};
+  }
+
+  uint32_t EntryCount() const { return GetHeader().mEntryCount; }
+
+  StringTable<nsCString> KeyTable() const {
+    auto& header = GetHeader();
+    return {{&mMap.get<uint8_t>()[header.mKeyStringsOffset],
+             header.mKeyStringsSize}};
+  }
+
+  StringTable<nsString> ValueTable() const {
+    auto& header = GetHeader();
+    return {{&mMap.get<uint8_t>()[header.mValueStringsOffset],
+             header.mValueStringsSize}};
+  }
+
+  loader::AutoMemMap mMap;
+};
+
+/**
+ * A helper class which builds the contiguous look-up table used by
+ * SharedStringMap. Each key-value pair in the final map is added to the
+ * builder, before it is finalized and transformed into a snapshot.
+ */
+class MOZ_RAII SharedStringMapBuilder {
+ public:
+  SharedStringMapBuilder() = default;
+
+  /**
+   * Adds a key-value pair to the map.
+   */
+  void Add(const nsCString& aKey, const nsString& aValue);
+
+  /**
+   * Finalizes the binary representation of the map, writes it to a shared
+   * memory region, and then initializes the given AutoMemMap with a reference
+   * to the read-only copy of it.
+   */
+  Result<Ok, nsresult> Finalize(loader::AutoMemMap& aMap);
+
+ private:
+  using Entry = SharedStringMap::Entry;
+
+  StringTableBuilder<nsCStringHashKey, nsCString> mKeyTable;
+  StringTableBuilder<nsStringHashKey, nsString> mValueTable;
+
+  nsTHashMap<nsCStringHashKey, Entry> mEntries;
+};
+
+}  // namespace mozilla::dom::ipc
+
+#endif  // dom_ipc_SharedStringMap_h
diff --git a/dom/ipc/StringTable.h b/dom/ipc/StringTable.h
new file mode 100644
index 0000000000..5de3cb9226
--- /dev/null
+++ b/dom/ipc/StringTable.h
@@ -0,0 +1,116 @@
+/* -*- 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/. */
+
+#ifndef dom_ipc_StringTable_h
+#define dom_ipc_StringTable_h
+
+#include "mozilla/RangedPtr.h"
+#include "nsTHashMap.h"
+
+/**
+ * This file contains helper classes for creating and accessing compact string
+ * tables, which can be used as the building blocks of shared memory databases.
+ * Each string table a de-duplicated set of strings which can be referenced
+ * using their character offsets within a data block and their lengths. The
+ * string tables, once created, cannot be modified, and are primarily useful in
+ * read-only shared memory or memory mapped files.
+ */
+
+namespace mozilla::dom::ipc {
+
+/**
+ * Contains the character offset and character length of an entry in a string
+ * table. This may be used for either 8-bit or 16-bit strings, and is required
+ * to retrieve an entry from a string table.
+ */
+struct StringTableEntry {
+  uint32_t mOffset;
+  uint32_t mLength;
+
+  // Ignore mLength. It must be the same for any two strings with the same
+  // offset.
+  uint32_t Hash() const { return mOffset; }
+
+  bool operator==(const StringTableEntry& aOther) const {
+    return mOffset == aOther.mOffset;
+  }
+};
+
+template <typename StringType>
+class StringTable {
+  using ElemType = typename StringType::char_type;
+
+ public:
+  MOZ_IMPLICIT StringTable(const RangedPtr<uint8_t>& aBuffer)
+      : mBuffer(aBuffer.ReinterpretCast<ElemType>()) {
+    MOZ_ASSERT(uintptr_t(aBuffer.get()) % alignof(ElemType) == 0,
+               "Got misalinged buffer");
+  }
+
+  StringType Get(const StringTableEntry& aEntry) const {
+    StringType res;
+    res.AssignLiteral(GetBare(aEntry), aEntry.mLength);
+    return res;
+  }
+
+  const ElemType* GetBare(const StringTableEntry& aEntry) const {
+    return &mBuffer[aEntry.mOffset];
+  }
+
+ private:
+  RangedPtr<ElemType> mBuffer;
+};
+
+template <typename KeyType, typename StringType>
+class StringTableBuilder {
+ public:
+  using ElemType = typename StringType::char_type;
+
+  StringTableEntry Add(const StringType& aKey) {
+    return mEntries.WithEntryHandle(aKey,
+                                    [&](auto&& entry) -> StringTableEntry {
+                                      auto length = uint32_t(aKey.Length());
+                                      entry.OrInsertWith([&]() {
+                                        Entry newEntry{mSize, aKey};
+                                        mSize += length + 1;
+
+                                        return newEntry;
+                                      });
+
+                                      return {entry->mOffset, length};
+                                    });
+  }
+
+  void Write(const RangedPtr<uint8_t>& aBuffer) {
+    auto buffer = aBuffer.ReinterpretCast<ElemType>();
+
+    for (const auto& entry : mEntries.Values()) {
+      memcpy(&buffer[entry.mOffset], entry.mValue.BeginReading(),
+             sizeof(ElemType) * (entry.mValue.Length() + 1));
+    }
+  }
+
+  uint32_t Count() const { return mEntries.Count(); }
+
+  uint32_t Size() const { return mSize * sizeof(ElemType); }
+
+  void Clear() { mEntries.Clear(); }
+
+  static constexpr size_t Alignment() { return alignof(ElemType); }
+
+ private:
+  struct Entry {
+    uint32_t mOffset;
+    StringType mValue;
+  };
+
+  nsTHashMap<KeyType, Entry> mEntries;
+  uint32_t mSize = 0;
+};
+
+}  // namespace mozilla::dom::ipc
+
+#endif
diff --git a/dom/ipc/StructuredCloneData.cpp b/dom/ipc/StructuredCloneData.cpp
new file mode 100644
index 0000000000..956653ce59
--- /dev/null
+++ b/dom/ipc/StructuredCloneData.cpp
@@ -0,0 +1,328 @@
+/* -*- 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 "StructuredCloneData.h"
+
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/BlobBinding.h"
+#include "mozilla/dom/BlobImpl.h"
+#include "mozilla/dom/DOMTypes.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/IPCBlobUtils.h"
+#include "mozilla/ipc/BackgroundParent.h"
+#include "mozilla/ipc/IPCStreamUtils.h"
+#include "mozilla/ipc/SerializedStructuredCloneBuffer.h"
+#include "nsContentUtils.h"
+#include "nsJSEnvironment.h"
+#include "MainThreadUtils.h"
+#include "StructuredCloneTags.h"
+#include "jsapi.h"
+
+using namespace mozilla::ipc;
+
+namespace mozilla::dom::ipc {
+
+using mozilla::ipc::IPCStream;
+using mozilla::ipc::PBackgroundChild;
+using mozilla::ipc::PBackgroundParent;
+
+StructuredCloneData::StructuredCloneData()
+    : StructuredCloneData(
+          StructuredCloneHolder::StructuredCloneScope::DifferentProcess,
+          StructuredCloneHolder::TransferringSupported) {}
+
+StructuredCloneData::StructuredCloneData(StructuredCloneData&& aOther)
+    : StructuredCloneData(
+          StructuredCloneHolder::StructuredCloneScope::DifferentProcess,
+          StructuredCloneHolder::TransferringSupported) {
+  *this = std::move(aOther);
+}
+
+StructuredCloneData::StructuredCloneData(
+    StructuredCloneHolder::StructuredCloneScope aScope,
+    TransferringSupport aSupportsTransferring)
+    : StructuredCloneHolder(StructuredCloneHolder::CloningSupported,
+                            aSupportsTransferring, aScope),
+      mExternalData(JS::StructuredCloneScope::DifferentProcess),
+      mInitialized(false) {
+  MOZ_ASSERT(
+      aScope == StructuredCloneHolder::StructuredCloneScope::DifferentProcess ||
+      aScope ==
+          StructuredCloneHolder::StructuredCloneScope::UnknownDestination);
+}
+
+StructuredCloneData::~StructuredCloneData() = default;
+
+StructuredCloneData& StructuredCloneData::operator=(
+    StructuredCloneData&& aOther) {
+  mBlobImplArray = std::move(aOther.mBlobImplArray);
+  mExternalData = std::move(aOther.mExternalData);
+  mSharedData = std::move(aOther.mSharedData);
+  mInitialized = aOther.mInitialized;
+
+  return *this;
+}
+
+bool StructuredCloneData::Copy(const StructuredCloneData& aData) {
+  if (!aData.mInitialized) {
+    return true;
+  }
+
+  if (aData.SharedData()) {
+    mSharedData = aData.SharedData();
+  } else {
+    mSharedData = SharedJSAllocatedData::CreateFromExternalData(aData.Data());
+    NS_ENSURE_TRUE(mSharedData, false);
+  }
+
+  if (mSupportsTransferring) {
+    PortIdentifiers().AppendElements(aData.PortIdentifiers());
+  }
+
+  MOZ_ASSERT(BlobImpls().IsEmpty());
+  BlobImpls().AppendElements(aData.BlobImpls());
+
+  MOZ_ASSERT(GetSurfaces().IsEmpty());
+  MOZ_ASSERT(WasmModules().IsEmpty());
+
+  MOZ_ASSERT(InputStreams().IsEmpty());
+  InputStreams().AppendElements(aData.InputStreams());
+
+  mInitialized = true;
+
+  return true;
+}
+
+void StructuredCloneData::Read(JSContext* aCx,
+                               JS::MutableHandle<JS::Value> aValue,
+                               ErrorResult& aRv) {
+  Read(aCx, aValue, JS::CloneDataPolicy(), aRv);
+}
+
+void StructuredCloneData::Read(JSContext* aCx,
+                               JS::MutableHandle<JS::Value> aValue,
+                               const JS::CloneDataPolicy& aCloneDataPolicy,
+                               ErrorResult& aRv) {
+  MOZ_ASSERT(mInitialized);
+
+  nsIGlobalObject* global = xpc::CurrentNativeGlobal(aCx);
+  MOZ_ASSERT(global);
+
+  ReadFromBuffer(global, aCx, Data(), aValue, aCloneDataPolicy, aRv);
+}
+
+void StructuredCloneData::Write(JSContext* aCx, JS::Handle<JS::Value> aValue,
+                                ErrorResult& aRv) {
+  Write(aCx, aValue, JS::UndefinedHandleValue, JS::CloneDataPolicy(), aRv);
+}
+
+void StructuredCloneData::Write(JSContext* aCx, JS::Handle<JS::Value> aValue,
+                                JS::Handle<JS::Value> aTransfer,
+                                const JS::CloneDataPolicy& aCloneDataPolicy,
+                                ErrorResult& aRv) {
+  MOZ_ASSERT(!mInitialized);
+
+  StructuredCloneHolder::Write(aCx, aValue, aTransfer, aCloneDataPolicy, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  JSStructuredCloneData data(mBuffer->scope());
+  mBuffer->giveTo(&data);
+  mBuffer = nullptr;
+  mSharedData = new SharedJSAllocatedData(std::move(data));
+  mInitialized = true;
+}
+
+bool StructuredCloneData::BuildClonedMessageData(
+    ClonedMessageData& aClonedData) {
+  SerializedStructuredCloneBuffer& buffer = aClonedData.data();
+  auto iter = Data().Start();
+  size_t size = Data().Size();
+  bool success;
+  buffer.data = Data().Borrow(iter, size, &success);
+  if (NS_WARN_IF(!success)) {
+    return false;
+  }
+  if (SupportsTransferring()) {
+    aClonedData.identifiers().AppendElements(PortIdentifiers());
+  }
+
+  const nsTArray<RefPtr<BlobImpl>>& blobImpls = BlobImpls();
+
+  if (!blobImpls.IsEmpty()) {
+    if (NS_WARN_IF(
+            !aClonedData.blobs().SetLength(blobImpls.Length(), fallible))) {
+      return false;
+    }
+
+    for (uint32_t i = 0; i < blobImpls.Length(); ++i) {
+      nsresult rv =
+          IPCBlobUtils::Serialize(blobImpls[i], aClonedData.blobs()[i]);
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return false;
+      }
+    }
+  }
+
+  const nsTArray<nsCOMPtr<nsIInputStream>>& inputStreams = InputStreams();
+  if (!inputStreams.IsEmpty()) {
+    nsTArray<IPCStream>& streams = aClonedData.inputStreams();
+    uint32_t length = inputStreams.Length();
+    streams.SetCapacity(length);
+    for (uint32_t i = 0; i < length; ++i) {
+      IPCStream value;
+      if (!mozilla::ipc::SerializeIPCStream(do_AddRef(inputStreams[i]), value,
+                                            /* aAllowLazy */ false)) {
+        return false;
+      }
+      streams.AppendElement(value);
+    }
+  }
+
+  return true;
+}
+
+// See the StructuredCloneData class block comment for the meanings of each val.
+enum MemoryFlavorEnum { BorrowMemory = 0, CopyMemory, StealMemory };
+
+template <MemoryFlavorEnum>
+struct MemoryTraits {};
+
+template <>
+struct MemoryTraits<BorrowMemory> {
+  using ClonedMessageType = const mozilla::dom::ClonedMessageData;
+
+  static void ProvideBuffer(const ClonedMessageData& aClonedData,
+                            StructuredCloneData& aData) {
+    const SerializedStructuredCloneBuffer& buffer = aClonedData.data();
+    aData.UseExternalData(buffer.data);
+  }
+};
+
+template <>
+struct MemoryTraits<CopyMemory> {
+  using ClonedMessageType = const mozilla::dom::ClonedMessageData;
+
+  static void ProvideBuffer(const ClonedMessageData& aClonedData,
+                            StructuredCloneData& aData) {
+    const SerializedStructuredCloneBuffer& buffer = aClonedData.data();
+    aData.CopyExternalData(buffer.data);
+  }
+};
+
+template <>
+struct MemoryTraits<StealMemory> {
+  // note: not const!
+  using ClonedMessageType = mozilla::dom::ClonedMessageData;
+
+  static void ProvideBuffer(ClonedMessageData& aClonedData,
+                            StructuredCloneData& aData) {
+    SerializedStructuredCloneBuffer& buffer = aClonedData.data();
+    aData.StealExternalData(buffer.data);
+  }
+};
+
+// Note that there isn't actually a difference between Parent/BackgroundParent
+// and Child/BackgroundChild in this implementation.  The calling methods,
+// however, do maintain the distinction for code-reading purposes and are backed
+// by assertions to enforce there is no misuse.
+template <MemoryFlavorEnum MemoryFlavor>
+static void UnpackClonedMessageData(
+    typename MemoryTraits<MemoryFlavor>::ClonedMessageType& aClonedData,
+    StructuredCloneData& aData) {
+  const nsTArray<MessagePortIdentifier>& identifiers =
+      aClonedData.identifiers();
+
+  MemoryTraits<MemoryFlavor>::ProvideBuffer(aClonedData, aData);
+
+  if (aData.SupportsTransferring()) {
+    aData.PortIdentifiers().AppendElements(identifiers);
+  }
+
+  const nsTArray<IPCBlob>& blobs = aClonedData.blobs();
+  if (!blobs.IsEmpty()) {
+    uint32_t length = blobs.Length();
+    aData.BlobImpls().SetCapacity(length);
+    for (uint32_t i = 0; i < length; ++i) {
+      RefPtr<BlobImpl> blobImpl = IPCBlobUtils::Deserialize(blobs[i]);
+      MOZ_ASSERT(blobImpl);
+
+      aData.BlobImpls().AppendElement(blobImpl);
+    }
+  }
+
+  const nsTArray<IPCStream>& streams = aClonedData.inputStreams();
+  if (!streams.IsEmpty()) {
+    uint32_t length = streams.Length();
+    aData.InputStreams().SetCapacity(length);
+    for (uint32_t i = 0; i < length; ++i) {
+      nsCOMPtr<nsIInputStream> stream = DeserializeIPCStream(streams[i]);
+      aData.InputStreams().AppendElement(stream);
+    }
+  }
+}
+
+void StructuredCloneData::BorrowFromClonedMessageData(
+    const ClonedMessageData& aClonedData) {
+  UnpackClonedMessageData<BorrowMemory>(aClonedData, *this);
+}
+
+void StructuredCloneData::CopyFromClonedMessageData(
+    const ClonedMessageData& aClonedData) {
+  UnpackClonedMessageData<CopyMemory>(aClonedData, *this);
+}
+
+void StructuredCloneData::StealFromClonedMessageData(
+    ClonedMessageData& aClonedData) {
+  UnpackClonedMessageData<StealMemory>(aClonedData, *this);
+}
+
+void StructuredCloneData::WriteIPCParams(IPC::MessageWriter* aWriter) const {
+  WriteParam(aWriter, Data());
+}
+
+bool StructuredCloneData::ReadIPCParams(IPC::MessageReader* aReader) {
+  MOZ_ASSERT(!mInitialized);
+  JSStructuredCloneData data(JS::StructuredCloneScope::DifferentProcess);
+  if (!ReadParam(aReader, &data)) {
+    return false;
+  }
+  mSharedData = new SharedJSAllocatedData(std::move(data));
+  mInitialized = true;
+  return true;
+}
+
+bool StructuredCloneData::CopyExternalData(const char* aData,
+                                           size_t aDataLength) {
+  MOZ_ASSERT(!mInitialized);
+  mSharedData =
+      SharedJSAllocatedData::CreateFromExternalData(aData, aDataLength);
+  NS_ENSURE_TRUE(mSharedData, false);
+  mInitialized = true;
+  return true;
+}
+
+bool StructuredCloneData::CopyExternalData(const JSStructuredCloneData& aData) {
+  MOZ_ASSERT(!mInitialized);
+  mSharedData = SharedJSAllocatedData::CreateFromExternalData(aData);
+  NS_ENSURE_TRUE(mSharedData, false);
+  mInitialized = true;
+  return true;
+}
+
+bool StructuredCloneData::StealExternalData(JSStructuredCloneData& aData) {
+  MOZ_ASSERT(!mInitialized);
+  mSharedData = new SharedJSAllocatedData(std::move(aData));
+  mInitialized = true;
+  return true;
+}
+
+already_AddRefed<SharedJSAllocatedData> StructuredCloneData::TakeSharedData() {
+  return mSharedData.forget();
+}
+
+}  // namespace mozilla::dom::ipc
diff --git a/dom/ipc/StructuredCloneData.h b/dom/ipc/StructuredCloneData.h
new file mode 100644
index 0000000000..0566a3b07f
--- /dev/null
+++ b/dom/ipc/StructuredCloneData.h
@@ -0,0 +1,268 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_ipc_StructuredCloneData_h
+#define mozilla_dom_ipc_StructuredCloneData_h
+
+#include <algorithm>
+#include "mozilla/RefPtr.h"
+#include "mozilla/dom/StructuredCloneHolder.h"
+#include "nsISupportsImpl.h"
+#include "nsIInputStream.h"
+
+namespace IPC {
+class Message;
+class MessageReader;
+class MessageWriter;
+}  // namespace IPC
+class PickleIterator;
+
+namespace mozilla {
+namespace ipc {
+
+class PBackgroundChild;
+class PBackgroundParent;
+
+}  // namespace ipc
+
+namespace dom {
+
+class ContentChild;
+class ContentParent;
+
+namespace ipc {
+
+/**
+ * Wraps the non-reference-counted JSStructuredCloneData class to have a
+ * reference count so that multiple StructuredCloneData instances can reference
+ * a single underlying serialized representation.
+ *
+ * As used by StructuredCloneData, it is an invariant that our
+ * JSStructuredCloneData owns its buffers.  (For the non-owning case,
+ * StructuredCloneData uses mExternalData which holds a BufferList::Borrow()ed
+ * read-only view of the data.)
+ */
+class SharedJSAllocatedData final {
+ public:
+  explicit SharedJSAllocatedData(JSStructuredCloneData&& aData)
+      : mData(std::move(aData)) {}
+
+  static already_AddRefed<SharedJSAllocatedData> CreateFromExternalData(
+      const char* aData, size_t aDataLength) {
+    JSStructuredCloneData buf(JS::StructuredCloneScope::DifferentProcess);
+    NS_ENSURE_TRUE(buf.AppendBytes(aData, aDataLength), nullptr);
+    RefPtr<SharedJSAllocatedData> sharedData =
+        new SharedJSAllocatedData(std::move(buf));
+    return sharedData.forget();
+  }
+
+  static already_AddRefed<SharedJSAllocatedData> CreateFromExternalData(
+      const JSStructuredCloneData& aData) {
+    JSStructuredCloneData buf(aData.scope());
+    NS_ENSURE_TRUE(buf.Append(aData), nullptr);
+    RefPtr<SharedJSAllocatedData> sharedData =
+        new SharedJSAllocatedData(std::move(buf));
+    return sharedData.forget();
+  }
+
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SharedJSAllocatedData)
+
+  JSStructuredCloneData& Data() { return mData; }
+  size_t DataLength() const { return mData.Size(); }
+
+ private:
+  ~SharedJSAllocatedData() = default;
+
+  JSStructuredCloneData mData;
+};
+
+/**
+ * IPC-aware StructuredCloneHolder subclass that serves as both a helper class
+ * for dealing with message data (blobs, transferables) and also an IPDL
+ * data-type in cases where message data is not needed.  If your use-case does
+ * not (potentially) involve IPC, then you should use StructuredCloneHolder or
+ * one of its other subclasses instead.
+ *
+ * ## Usage ##
+ *
+ * The general recipe for using this class is:
+ * - In your IPDL definition, use the ClonedMessageData type whenever you want
+ *   to send a structured clone that may include blobs or transferables such as
+ *   message ports.
+ * - To send the data, instantiate a StructuredCloneData instance and Write()
+ *   into it like a normal structure clone.  When you are ready to send the
+ *   ClonedMessageData-bearing IPC message, use the appropriate
+ *   BuildClonedMessageDataFor{Parent,Child,BackgroundParent,BackgroundChild}
+ *   method to populate the ClonedMessageData and then send it before your
+ *   StructuredCloneData instance is destroyed.  (Buffer borrowing is used
+ *   under-the-hood to avoid duplicating the serialized data, requiring this.)
+ * - To receive the data, instantiate a StructuredCloneData and use the
+ *   appropriate {Borrow,Copy,Steal}FromClonedMessageDataFor{Parent,Child,
+ *   BackgroundParent,BackgroundChild} method.  See the memory management
+ *   section for more info.
+ *
+ * Variations:
+ * - If transferables are not allowed (ex: BroadcastChannel), then use the
+ *   StructuredCloneDataNoTransfers subclass instead of StructuredCloneData.
+ *
+ * ## Memory Management ##
+ *
+ * Serialized structured clone representations can be quite large.  So it's best
+ * to avoid wasteful duplication.  When Write()ing into the StructuredCloneData,
+ * you don't need to worry about this[1], but when you already have serialized
+ * structured clone data you plan to Read(), you do need to.  Similarly, if
+ * you're using StructuredCloneData as an IPDL type, it efficiently unmarshals.
+ *
+ * The from-ClonedMessageData memory management strategies available are:
+ * - Borrow: Create a JSStructuredCloneData that holds a non-owning, read-only
+ *   BufferList::Borrow()ed copy of the source.  Your StructuredCloneData needs
+ *   to be destroyed before the source is.  Commonly used when the
+ *   StructuredCloneData instance is stack-allocated (and Read() is used before
+ *   the function returns).
+ * - Copy: Makes a reference-counted copy of the source JSStructuredCloneData,
+ *   making it safe for the StructuredCloneData to outlive the source data.
+ * - Steal: Steal the buffers from the underlying JSStructuredCloneData so that
+ *   it's safe for the StructuredCloneData to outlive the source data.  This is
+ *   safe to use with IPC-provided ClonedMessageData instances because
+ *   JSStructuredCloneData's IPC ParamTraits::Read method copies the relevant
+ *   data into owned buffers.  But if it's possible the ClonedMessageData came
+ *   from a different source that might have borrowed the buffers itself, then
+ *   things will crash.  That would be a pretty strange implementation; if you
+ *   see one, change it to use SharedJSAllocatedData.
+ *
+ * 1: Specifically, in the Write() case an owning SharedJSAllocatedData is
+ *    created efficiently (by stealing from StructuredCloneHolder).  The
+ *    BuildClonedMessageDataFor* method can be called at any time and it will
+ *    borrow the underlying memory.  While it would be even better if
+ *    SerializedStructuredCloneBuffer could hold a SharedJSAllocatedData ref,
+ *    there's no reason you can't wait to BuildClonedMessageDataFor* until you
+ *    need to make the IPC Send* call.
+ */
+class StructuredCloneData : public StructuredCloneHolder {
+ public:
+  StructuredCloneData();
+
+  StructuredCloneData(const StructuredCloneData&) = delete;
+
+  StructuredCloneData(StructuredCloneData&& aOther);
+
+  // Only DifferentProcess and UnknownDestination scopes are supported.
+  StructuredCloneData(StructuredCloneScope aScope,
+                      TransferringSupport aSupportsTransferring);
+
+  ~StructuredCloneData();
+
+  StructuredCloneData& operator=(const StructuredCloneData& aOther) = delete;
+
+  StructuredCloneData& operator=(StructuredCloneData&& aOther);
+
+  const nsTArray<RefPtr<BlobImpl>>& BlobImpls() const { return mBlobImplArray; }
+
+  nsTArray<RefPtr<BlobImpl>>& BlobImpls() { return mBlobImplArray; }
+
+  const nsTArray<nsCOMPtr<nsIInputStream>>& InputStreams() const {
+    return mInputStreamArray;
+  }
+
+  nsTArray<nsCOMPtr<nsIInputStream>>& InputStreams() {
+    return mInputStreamArray;
+  }
+
+  bool Copy(const StructuredCloneData& aData);
+
+  void Read(JSContext* aCx, JS::MutableHandle<JS::Value> aValue,
+            ErrorResult& aRv);
+
+  void Read(JSContext* aCx, JS::MutableHandle<JS::Value> aValue,
+            const JS::CloneDataPolicy& aCloneDataPolicy, ErrorResult& aRv);
+
+  // Write with no transfer objects and with the default CloneDataPolicy.  With
+  // a default CloneDataPolicy, read and write will not be considered as part of
+  // the same agent cluster and shared memory objects will not be supported.
+  void Write(JSContext* aCx, JS::Handle<JS::Value> aValue,
+             ErrorResult& aRv) override;
+
+  // The most generic Write method, with tansfers and CloneDataPolicy.
+  void Write(JSContext* aCx, JS::Handle<JS::Value> aValue,
+             JS::Handle<JS::Value> aTransfers,
+             const JS::CloneDataPolicy& aCloneDataPolicy,
+             ErrorResult& aRv) override;
+
+  // Method to convert the structured clone stored in this holder by a previous
+  // call to Write() into ClonedMessageData IPC representation.
+  bool BuildClonedMessageData(ClonedMessageData& aClonedData);
+
+  // Memory-management-strategy-varying methods to initialize this holder from a
+  // ClonedMessageData representation.
+  void BorrowFromClonedMessageData(const ClonedMessageData& aClonedData);
+
+  void CopyFromClonedMessageData(const ClonedMessageData& aClonedData);
+
+  // The steal variant of course takes a non-const ClonedMessageData.
+  void StealFromClonedMessageData(ClonedMessageData& aClonedData);
+
+  // Initialize this instance, borrowing the contents of the given
+  // JSStructuredCloneData.  You are responsible for ensuring that this
+  // StructuredCloneData instance is destroyed before aData is destroyed.
+  bool UseExternalData(const JSStructuredCloneData& aData) {
+    auto iter = aData.Start();
+    bool success = false;
+    mExternalData = aData.Borrow(iter, aData.Size(), &success);
+    mInitialized = true;
+    return success;
+  }
+
+  // Initialize this instance by copying the given data that probably came from
+  // nsStructuredClone doing a base64 decode.  Don't use this.
+  bool CopyExternalData(const char* aData, size_t aDataLength);
+  // Initialize this instance by copying the contents of an existing
+  // JSStructuredCloneData.  Use when this StructuredCloneData instance may
+  // outlive aData.
+  bool CopyExternalData(const JSStructuredCloneData& aData);
+
+  // Initialize this instance by stealing the contents of aData via Move
+  // constructor, clearing the original aData as a side-effect.  This is only
+  // safe if aData owns the underlying buffers.  This is the case for instances
+  // provided by IPC to Recv calls.
+  bool StealExternalData(JSStructuredCloneData& aData);
+
+  JSStructuredCloneData& Data() {
+    return mSharedData ? mSharedData->Data() : mExternalData;
+  }
+
+  const JSStructuredCloneData& Data() const {
+    return mSharedData ? mSharedData->Data() : mExternalData;
+  }
+
+  void InitScope(JS::StructuredCloneScope aScope) { Data().initScope(aScope); }
+
+  size_t DataLength() const {
+    return mSharedData ? mSharedData->DataLength() : mExternalData.Size();
+  }
+
+  SharedJSAllocatedData* SharedData() const { return mSharedData; }
+
+  bool SupportsTransferring() { return mSupportsTransferring; }
+
+  // For IPC serialization
+  void WriteIPCParams(IPC::MessageWriter* aWriter) const;
+  bool ReadIPCParams(IPC::MessageReader* aReader);
+
+ protected:
+  already_AddRefed<SharedJSAllocatedData> TakeSharedData();
+
+ private:
+  JSStructuredCloneData mExternalData;
+  RefPtr<SharedJSAllocatedData> mSharedData;
+
+  bool mInitialized;
+};
+
+}  // namespace ipc
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_ipc_StructuredCloneData_h
diff --git a/dom/ipc/TabContext.cpp b/dom/ipc/TabContext.cpp
new file mode 100644
index 0000000000..c4fff2b66c
--- /dev/null
+++ b/dom/ipc/TabContext.cpp
@@ -0,0 +1,137 @@
+/* -*- 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 "mozilla/dom/TabContext.h"
+#include "mozilla/dom/PTabContext.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/dom/BrowserChild.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "nsServiceManagerUtils.h"
+
+using namespace mozilla::dom::ipc;
+using namespace mozilla::layout;
+
+namespace mozilla::dom {
+
+TabContext::TabContext()
+    : mInitialized(false),
+      mChromeOuterWindowID(0),
+      mJSPluginID(-1),
+      mMaxTouchPoints(0) {}
+
+bool TabContext::IsJSPlugin() const { return mJSPluginID >= 0; }
+
+int32_t TabContext::JSPluginId() const { return mJSPluginID; }
+
+uint64_t TabContext::ChromeOuterWindowID() const {
+  return mChromeOuterWindowID;
+}
+
+bool TabContext::SetTabContext(const TabContext& aContext) {
+  NS_ENSURE_FALSE(mInitialized, false);
+
+  *this = aContext;
+  mInitialized = true;
+
+  return true;
+}
+
+bool TabContext::UpdateTabContextAfterSwap(const TabContext& aContext) {
+  // This is only used after already initialized.
+  MOZ_ASSERT(mInitialized);
+
+  // The only permissable changes are to mChromeOuterWindowID.  All other fields
+  // must match for the change to be accepted.
+
+  mChromeOuterWindowID = aContext.mChromeOuterWindowID;
+  return true;
+}
+
+bool TabContext::SetTabContext(uint64_t aChromeOuterWindowID,
+                               uint32_t aMaxTouchPoints) {
+  NS_ENSURE_FALSE(mInitialized, false);
+
+  mInitialized = true;
+  mChromeOuterWindowID = aChromeOuterWindowID;
+  mMaxTouchPoints = aMaxTouchPoints;
+  return true;
+}
+
+bool TabContext::SetTabContextForJSPluginFrame(int32_t aJSPluginID) {
+  NS_ENSURE_FALSE(mInitialized, false);
+
+  mInitialized = true;
+  mJSPluginID = aJSPluginID;
+  return true;
+}
+
+IPCTabContext TabContext::AsIPCTabContext() const {
+  if (IsJSPlugin()) {
+    return IPCTabContext(JSPluginFrameIPCTabContext(mJSPluginID));
+  }
+
+  return IPCTabContext(
+      FrameIPCTabContext(mChromeOuterWindowID, mMaxTouchPoints));
+}
+
+MaybeInvalidTabContext::MaybeInvalidTabContext(const IPCTabContext& aParams)
+    : mInvalidReason(nullptr) {
+  uint64_t chromeOuterWindowID = 0;
+  int32_t jsPluginId = -1;
+  uint32_t maxTouchPoints = 0;
+
+  switch (aParams.type()) {
+    case IPCTabContext::TPopupIPCTabContext: {
+      const PopupIPCTabContext& ipcContext = aParams.get_PopupIPCTabContext();
+
+      chromeOuterWindowID = ipcContext.chromeOuterWindowID();
+      break;
+    }
+    case IPCTabContext::TJSPluginFrameIPCTabContext: {
+      const JSPluginFrameIPCTabContext& ipcContext =
+          aParams.get_JSPluginFrameIPCTabContext();
+
+      jsPluginId = ipcContext.jsPluginId();
+      break;
+    }
+    case IPCTabContext::TFrameIPCTabContext: {
+      const FrameIPCTabContext& ipcContext = aParams.get_FrameIPCTabContext();
+
+      chromeOuterWindowID = ipcContext.chromeOuterWindowID();
+      maxTouchPoints = ipcContext.maxTouchPoints();
+      break;
+    }
+    default: {
+      MOZ_CRASH();
+    }
+  }
+
+  bool rv;
+  if (jsPluginId >= 0) {
+    rv = mTabContext.SetTabContextForJSPluginFrame(jsPluginId);
+  } else {
+    rv = mTabContext.SetTabContext(chromeOuterWindowID, maxTouchPoints);
+  }
+  if (!rv) {
+    mInvalidReason = "Couldn't initialize TabContext.";
+  }
+}
+
+bool MaybeInvalidTabContext::IsValid() { return mInvalidReason == nullptr; }
+
+const char* MaybeInvalidTabContext::GetInvalidReason() {
+  return mInvalidReason;
+}
+
+const TabContext& MaybeInvalidTabContext::GetTabContext() {
+  if (!IsValid()) {
+    MOZ_CRASH("Can't GetTabContext() if !IsValid().");
+  }
+
+  return mTabContext;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/TabContext.h b/dom/ipc/TabContext.h
new file mode 100644
index 0000000000..2780e514c4
--- /dev/null
+++ b/dom/ipc/TabContext.h
@@ -0,0 +1,190 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_TabContext_h
+#define mozilla_dom_TabContext_h
+
+#include "nsCOMPtr.h"
+#include "mozilla/BasePrincipal.h"
+#include "nsPIDOMWindow.h"
+#include "nsPIWindowRoot.h"
+
+namespace mozilla::dom {
+
+class IPCTabContext;
+
+/**
+ * TabContext encapsulates information about an iframe.
+ *
+ * BrowserParent and BrowserChild both inherit from TabContext, and you can also
+ * have standalone TabContext objects.
+ *
+ * This class is immutable except by calling one of the protected
+ * SetTabContext*() methods (and those methods can only be called once).  See
+ * also MutableTabContext.
+ */
+class TabContext {
+ public:
+  TabContext();
+
+  /* (The implicit copy-constructor and operator= are fine.) */
+
+  /**
+   * Generates IPCTabContext of type BrowserFrameIPCTabContext from this
+   * TabContext's information.
+   */
+  IPCTabContext AsIPCTabContext() const;
+
+  bool IsJSPlugin() const;
+  int32_t JSPluginId() const;
+
+  uint64_t ChromeOuterWindowID() const;
+
+  uint32_t MaxTouchPoints() const { return mMaxTouchPoints; }
+
+ protected:
+  friend class MaybeInvalidTabContext;
+
+  /**
+   * These protected mutator methods let you modify a TabContext once.  Further
+   * attempts to modify a given TabContext will fail (the method will return
+   * false).
+   *
+   * These mutators will also fail if the TabContext was created with anything
+   * other than the no-args constructor.
+   */
+
+  /**
+   * Set this TabContext to match the given TabContext.
+   */
+  bool SetTabContext(const TabContext& aContext);
+
+  bool SetTabContext(uint64_t aChromeOuterWindowID, uint32_t aMaxTouchPoints);
+
+  /**
+   * Modify this TabContext to match the given TabContext.  This is a special
+   * case triggered by nsFrameLoader::SwapWithOtherRemoteLoader which may have
+   * caused the owner content to change.
+   *
+   * This special case only allows the field `mChromeOuterWindowID` to be
+   * changed.  If any other fields have changed, the update is ignored and
+   * returns false.
+   */
+  bool UpdateTabContextAfterSwap(const TabContext& aContext);
+
+  /**
+   * Set this TabContext to be for a JS plugin. aPluginID is the id of the JS
+   * plugin
+   * (@see nsFakePlugin::mId).
+   * As with the other protected mutator methods, this lets you modify a
+   * TabContext once.
+   * (@see TabContext::SetTabContext above for more details).
+   */
+  bool SetTabContextForJSPluginFrame(int32_t aJSPluginID);
+
+  void SetMaxTouchPoints(uint32_t aMaxTouchPoints) {
+    mMaxTouchPoints = aMaxTouchPoints;
+  }
+
+ private:
+  /**
+   * Has this TabContext been initialized?  If so, mutator methods will fail.
+   */
+  bool mInitialized;
+
+  /**
+   * The outerWindowID of the window hosting the remote frameloader.
+   */
+  uint64_t mChromeOuterWindowID;
+
+  int32_t mJSPluginID;
+
+  /**
+   * Maximum number of touch points.
+   */
+  uint32_t mMaxTouchPoints;
+};
+
+/**
+ * MutableTabContext is the same as MaybeInvalidTabContext, except the mutation
+ * methods are public instead of protected.  You can still only call these
+ * mutation methods once on a given object.
+ */
+class MutableTabContext : public TabContext {
+ public:
+  bool SetTabContext(const TabContext& aContext) {
+    return TabContext::SetTabContext(aContext);
+  }
+
+  bool SetTabContext(uint64_t aChromeOuterWindowID, uint32_t aMaxTouchPoints) {
+    return TabContext::SetTabContext(aChromeOuterWindowID, aMaxTouchPoints);
+  }
+
+  bool SetTabContextForJSPluginFrame(uint32_t aJSPluginID) {
+    return TabContext::SetTabContextForJSPluginFrame(aJSPluginID);
+  }
+};
+
+/**
+ * MaybeInvalidTabContext is a simple class that lets you transform an
+ * IPCTabContext into a TabContext.
+ *
+ * The issue is that an IPCTabContext is not necessarily valid.  So to convert
+ * an IPCTabContext into a TabContext, you construct a MaybeInvalidTabContext,
+ * check whether it's valid, and, if so, read out your TabContext.
+ *
+ * Example usage:
+ *
+ *   void UseTabContext(const TabContext& aTabContext);
+ *
+ *   void CreateTab(const IPCTabContext& aContext) {
+ *     MaybeInvalidTabContext tc(aContext);
+ *     if (!tc.IsValid()) {
+ *       NS_ERROR(nsPrintfCString("Got an invalid IPCTabContext: %s",
+ *                                tc.GetInvalidReason()));
+ *       return;
+ *     }
+ *     UseTabContext(tc.GetTabContext());
+ *   }
+ */
+class MaybeInvalidTabContext {
+ public:
+  /**
+   * This constructor copies the information in aContext and sets IsValid() as
+   * appropriate.
+   */
+  explicit MaybeInvalidTabContext(const IPCTabContext& aContext);
+
+  /**
+   * Was the IPCTabContext we received in our constructor valid?
+   */
+  bool IsValid();
+
+  /**
+   * If IsValid(), this function returns null.  Otherwise, it returns a
+   * human-readable string indicating why the IPCTabContext passed to our
+   * constructor was not valid.
+   */
+  const char* GetInvalidReason();
+
+  /**
+   * If IsValid(), this function returns a reference to a TabContext
+   * corresponding to the IPCTabContext passed to our constructor.  If
+   * !IsValid(), this function crashes.
+   */
+  const TabContext& GetTabContext();
+
+ private:
+  MaybeInvalidTabContext(const MaybeInvalidTabContext&) = delete;
+  MaybeInvalidTabContext& operator=(const MaybeInvalidTabContext&) = delete;
+
+  const char* mInvalidReason;
+  MutableTabContext mTabContext;
+};
+
+}  // namespace mozilla::dom
+
+#endif
diff --git a/dom/ipc/TabMessageTypes.h b/dom/ipc/TabMessageTypes.h
new file mode 100644
index 0000000000..7768c9879c
--- /dev/null
+++ b/dom/ipc/TabMessageTypes.h
@@ -0,0 +1,23 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_TabMessageTypes_h
+#define mozilla_dom_TabMessageTypes_h
+
+#include "mozilla/RefPtr.h"
+
+namespace mozilla::dom {
+
+enum class EmbedderElementEventType {
+  NoEvent,
+  LoadEvent,
+  ErrorEvent,
+  EndGuard_,
+};
+
+}  // namespace mozilla::dom
+
+#endif  // TABMESSAGE_TYPES_H
diff --git a/dom/ipc/TabMessageUtils.h b/dom/ipc/TabMessageUtils.h
new file mode 100644
index 0000000000..794d3dffa2
--- /dev/null
+++ b/dom/ipc/TabMessageUtils.h
@@ -0,0 +1,115 @@
+/* -*- 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/. */
+
+#ifndef TABMESSAGE_UTILS_H
+#define TABMESSAGE_UTILS_H
+
+#include "ipc/EnumSerializer.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/dom/Event.h"
+#include "nsIRemoteTab.h"
+#include "nsPIDOMWindow.h"
+#include "nsCOMPtr.h"
+#include "mozilla/dom/EffectsInfo.h"
+#include "mozilla/layers/LayersMessageUtils.h"
+#include "TabMessageTypes.h"
+#include "X11UndefineNone.h"
+
+namespace IPC {
+
+template <>
+struct ParamTraits<nsSizeMode>
+    : public ContiguousEnumSerializer<nsSizeMode, nsSizeMode_Normal,
+                                      nsSizeMode_Invalid> {};
+
+template <>
+struct ParamTraits<nsIRemoteTab::NavigationType>
+    : public ContiguousEnumSerializerInclusive<
+          nsIRemoteTab::NavigationType,
+          nsIRemoteTab::NavigationType::NAVIGATE_BACK,
+          nsIRemoteTab::NavigationType::NAVIGATE_URL> {};
+
+template <>
+struct ParamTraits<mozilla::dom::EffectsInfo> {
+  typedef mozilla::dom::EffectsInfo paramType;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam) {
+    WriteParam(aWriter, aParam.mVisibleRect);
+    WriteParam(aWriter, aParam.mRasterScale);
+    WriteParam(aWriter, aParam.mTransformToAncestorScale);
+  }
+
+  static bool Read(MessageReader* aReader, paramType* aResult) {
+    return ReadParam(aReader, &aResult->mVisibleRect) &&
+           ReadParam(aReader, &aResult->mRasterScale) &&
+           ReadParam(aReader, &aResult->mTransformToAncestorScale);
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::WhenToScroll>
+    : public ContiguousEnumSerializerInclusive<
+          mozilla::WhenToScroll, mozilla::WhenToScroll::Always,
+          mozilla::WhenToScroll::IfNotFullyVisible> {};
+
+template <>
+struct ParamTraits<mozilla::ScrollFlags>
+    : public BitFlagsEnumSerializer<mozilla::ScrollFlags,
+                                    mozilla::ScrollFlags::ALL_BITS> {};
+
+template <>
+struct ParamTraits<mozilla::WhereToScroll> {
+  using paramType = mozilla::WhereToScroll;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam) {
+    WriteParam(aWriter, aParam.mPercentage);
+  }
+
+  static bool Read(MessageReader* aReader, paramType* aResult) {
+    return ReadParam(aReader, &aResult->mPercentage);
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::ScrollAxis> {
+  typedef mozilla::ScrollAxis paramType;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam) {
+    WriteParam(aWriter, aParam.mWhereToScroll);
+    WriteParam(aWriter, aParam.mWhenToScroll);
+    WriteParam(aWriter, aParam.mOnlyIfPerceivedScrollableDirection);
+  }
+
+  static bool Read(MessageReader* aReader, paramType* aResult) {
+    if (!ReadParam(aReader, &aResult->mWhereToScroll)) {
+      return false;
+    }
+    if (!ReadParam(aReader, &aResult->mWhenToScroll)) {
+      return false;
+    }
+
+    // We can't set mOnlyIfPerceivedScrollableDirection directly since it's
+    // a bitfield.
+    bool value;
+    if (!ReadParam(aReader, &value)) {
+      return false;
+    }
+    aResult->mOnlyIfPerceivedScrollableDirection = value;
+
+    return true;
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::dom::EmbedderElementEventType>
+    : public ContiguousEnumSerializer<
+          mozilla::dom::EmbedderElementEventType,
+          mozilla::dom::EmbedderElementEventType::NoEvent,
+          mozilla::dom::EmbedderElementEventType::EndGuard_> {};
+
+}  // namespace IPC
+
+#endif  // TABMESSAGE_UTILS_H
diff --git a/dom/ipc/URLClassifierChild.h b/dom/ipc/URLClassifierChild.h
new file mode 100644
index 0000000000..b5f0537ddc
--- /dev/null
+++ b/dom/ipc/URLClassifierChild.h
@@ -0,0 +1,90 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_URLClassifierChild_h
+#define mozilla_dom_URLClassifierChild_h
+
+#include "mozilla/dom/PURLClassifierChild.h"
+#include "mozilla/dom/PURLClassifierLocalChild.h"
+#include "mozilla/ipc/URIUtils.h"
+#include "mozilla/net/UrlClassifierFeatureResult.h"
+#include "nsIURIClassifier.h"
+#include "nsIUrlClassifierFeature.h"
+
+namespace mozilla::dom {
+
+class URLClassifierChild : public PURLClassifierChild {
+ public:
+  void SetCallback(nsIURIClassifierCallback* aCallback) {
+    mCallback = aCallback;
+  }
+
+  mozilla::ipc::IPCResult Recv__delete__(const Maybe<ClassifierInfo>& aInfo,
+                                         const nsresult& aResult) {
+    MOZ_ASSERT(mCallback);
+    if (aInfo.isSome()) {
+      mCallback->OnClassifyComplete(aResult, aInfo.ref().list(),
+                                    aInfo.ref().provider(),
+                                    aInfo.ref().fullhash());
+    }
+    return IPC_OK();
+  }
+
+ private:
+  nsCOMPtr<nsIURIClassifierCallback> mCallback;
+};
+
+class URLClassifierLocalChild : public PURLClassifierLocalChild {
+ public:
+  void SetFeaturesAndCallback(
+      const nsTArray<RefPtr<nsIUrlClassifierFeature>>& aFeatures,
+      nsIUrlClassifierFeatureCallback* aCallback) {
+    mCallback = aCallback;
+    mFeatures = aFeatures.Clone();
+  }
+
+  mozilla::ipc::IPCResult Recv__delete__(
+      nsTArray<URLClassifierLocalResult>&& aResults) {
+    nsTArray<RefPtr<nsIUrlClassifierFeatureResult>> finalResults;
+
+    nsTArray<URLClassifierLocalResult> results = std::move(aResults);
+    for (URLClassifierLocalResult& result : results) {
+      for (nsIUrlClassifierFeature* feature : mFeatures) {
+        nsAutoCString name;
+        nsresult rv = feature->GetName(name);
+        if (NS_WARN_IF(NS_FAILED(rv))) {
+          continue;
+        }
+
+        if (result.featureName() != name) {
+          continue;
+        }
+
+        RefPtr<nsIURI> uri = result.uri();
+        if (NS_WARN_IF(!uri)) {
+          continue;
+        }
+
+        RefPtr<net::UrlClassifierFeatureResult> r =
+            new net::UrlClassifierFeatureResult(uri, feature,
+                                                result.matchingList());
+        finalResults.AppendElement(r);
+        break;
+      }
+    }
+
+    mCallback->OnClassifyComplete(finalResults);
+    return IPC_OK();
+  }
+
+ private:
+  nsCOMPtr<nsIUrlClassifierFeatureCallback> mCallback;
+  nsTArray<RefPtr<nsIUrlClassifierFeature>> mFeatures;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_URLClassifierChild_h
diff --git a/dom/ipc/URLClassifierParent.cpp b/dom/ipc/URLClassifierParent.cpp
new file mode 100644
index 0000000000..d0d2f8f26e
--- /dev/null
+++ b/dom/ipc/URLClassifierParent.cpp
@@ -0,0 +1,186 @@
+/* -*- 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 "URLClassifierParent.h"
+#include "nsComponentManagerUtils.h"
+#include "nsIUrlClassifierFeature.h"
+#include "nsNetCID.h"
+#include "mozilla/net/UrlClassifierFeatureResult.h"
+#include "mozilla/Unused.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+/////////////////////////////////////////////////////////////////////
+// URLClassifierParent.
+
+NS_IMPL_ISUPPORTS(URLClassifierParent, nsIURIClassifierCallback)
+
+mozilla::ipc::IPCResult URLClassifierParent::StartClassify(
+    nsIPrincipal* aPrincipal, bool* aSuccess) {
+  *aSuccess = false;
+  nsresult rv = NS_OK;
+  // Note that in safe mode, the URL classifier service isn't available, so we
+  // should handle the service not being present gracefully.
+  nsCOMPtr<nsIURIClassifier> uriClassifier =
+      do_GetService(NS_URICLASSIFIERSERVICE_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv)) {
+    rv = uriClassifier->Classify(aPrincipal, this, aSuccess);
+  }
+  if (NS_FAILED(rv) || !*aSuccess) {
+    // We treat the case where we fail to classify and the case where the
+    // classifier returns successfully but doesn't perform a lookup as the
+    // classification not yielding any results, so we just kill the child actor
+    // without ever calling out callback in both cases.
+    // This means that code using this in the child process will only get a hit
+    // on its callback if some classification actually happens.
+    *aSuccess = false;
+    ClassificationFailed();
+  }
+  return IPC_OK();
+}
+
+/////////////////////////////////////////////////////////////////////
+// URLClassifierLocalParent.
+
+namespace {
+
+// This class implements a nsIUrlClassifierFeature on the parent side, starting
+// from an IPC data struct.
+class IPCFeature final : public nsIUrlClassifierFeature {
+ public:
+  NS_DECL_ISUPPORTS
+
+  IPCFeature(nsIURI* aURI, const IPCURLClassifierFeature& aFeature)
+      : mURI(aURI), mIPCFeature(aFeature) {}
+
+  NS_IMETHOD
+  GetName(nsACString& aName) override {
+    aName = mIPCFeature.featureName();
+    return NS_OK;
+  }
+
+  NS_IMETHOD
+  GetTables(nsIUrlClassifierFeature::listType,
+            nsTArray<nsCString>& aTables) override {
+    aTables.AppendElements(mIPCFeature.tables());
+    return NS_OK;
+  }
+
+  NS_IMETHOD
+  HasTable(const nsACString& aTable, nsIUrlClassifierFeature::listType,
+           bool* aResult) override {
+    NS_ENSURE_ARG_POINTER(aResult);
+    *aResult = mIPCFeature.tables().Contains(aTable);
+    return NS_OK;
+  }
+
+  NS_IMETHOD
+  HasHostInPreferences(const nsACString& aHost,
+                       nsIUrlClassifierFeature::listType,
+                       nsACString& aTableName, bool* aResult) override {
+    NS_ENSURE_ARG_POINTER(aResult);
+    *aResult = false;
+    return NS_OK;
+  }
+
+  NS_IMETHOD
+  GetExceptionHostList(nsACString& aList) override {
+    aList = mIPCFeature.exceptionHostList();
+    return NS_OK;
+  }
+
+  NS_IMETHOD
+  ProcessChannel(nsIChannel* aChannel, const nsTArray<nsCString>& aList,
+                 const nsTArray<nsCString>& aHashes,
+                 bool* aShouldContinue) override {
+    NS_ENSURE_ARG_POINTER(aShouldContinue);
+    *aShouldContinue = true;
+
+    // Nothing to do here.
+    return NS_OK;
+  }
+
+  NS_IMETHOD
+  GetURIByListType(nsIChannel* aChannel,
+                   nsIUrlClassifierFeature::listType aListType,
+                   nsIUrlClassifierFeature::URIType* aURIType,
+                   nsIURI** aURI) override {
+    NS_ENSURE_ARG_POINTER(aURI);
+
+    // This method should not be called, but we have a URI, let's return it.
+    nsCOMPtr<nsIURI> uri = mURI;
+    uri.forget(aURI);
+    *aURIType = aListType == nsIUrlClassifierFeature::blocklist
+                    ? nsIUrlClassifierFeature::URIType::blocklistURI
+                    : nsIUrlClassifierFeature::URIType::entitylistURI;
+    return NS_OK;
+  }
+
+ private:
+  ~IPCFeature() = default;
+
+  nsCOMPtr<nsIURI> mURI;
+  IPCURLClassifierFeature mIPCFeature;
+};
+
+NS_IMPL_ISUPPORTS(IPCFeature, nsIUrlClassifierFeature)
+
+}  // namespace
+
+NS_IMPL_ISUPPORTS(URLClassifierLocalParent, nsIUrlClassifierFeatureCallback)
+
+mozilla::ipc::IPCResult URLClassifierLocalParent::StartClassify(
+    nsIURI* aURI, const nsTArray<IPCURLClassifierFeature>& aFeatures) {
+  MOZ_ASSERT(aURI);
+
+  nsresult rv = NS_OK;
+  // Note that in safe mode, the URL classifier service isn't available, so we
+  // should handle the service not being present gracefully.
+  nsCOMPtr<nsIURIClassifier> uriClassifier =
+      do_GetService(NS_URICLASSIFIERSERVICE_CONTRACTID, &rv);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    OnClassifyComplete(nsTArray<RefPtr<nsIUrlClassifierFeatureResult>>());
+    return IPC_OK();
+  }
+
+  nsTArray<RefPtr<nsIUrlClassifierFeature>> features;
+  for (const IPCURLClassifierFeature& feature : aFeatures) {
+    features.AppendElement(new IPCFeature(aURI, feature));
+  }
+
+  // Doesn't matter if we pass blocklist, entitylist or any other list.
+  // IPCFeature returns always the same values.
+  rv = uriClassifier->AsyncClassifyLocalWithFeatures(
+      aURI, features, nsIUrlClassifierFeature::blocklist, this);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    OnClassifyComplete(nsTArray<RefPtr<nsIUrlClassifierFeatureResult>>());
+    return IPC_OK();
+  }
+
+  return IPC_OK();
+}
+
+NS_IMETHODIMP
+URLClassifierLocalParent::OnClassifyComplete(
+    const nsTArray<RefPtr<nsIUrlClassifierFeatureResult>>& aResults) {
+  if (mIPCOpen) {
+    nsTArray<URLClassifierLocalResult> ipcResults;
+    for (nsIUrlClassifierFeatureResult* result : aResults) {
+      URLClassifierLocalResult* ipcResult = ipcResults.AppendElement();
+
+      net::UrlClassifierFeatureResult* r =
+          static_cast<net::UrlClassifierFeatureResult*>(result);
+
+      ipcResult->uri() = r->URI();
+      r->Feature()->GetName(ipcResult->featureName());
+      ipcResult->matchingList() = r->List();
+    }
+
+    Unused << Send__delete__(this, ipcResults);
+  }
+  return NS_OK;
+}
diff --git a/dom/ipc/URLClassifierParent.h b/dom/ipc/URLClassifierParent.h
new file mode 100644
index 0000000000..1eb6b2fcce
--- /dev/null
+++ b/dom/ipc/URLClassifierParent.h
@@ -0,0 +1,87 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_URLClassifierParent_h
+#define mozilla_dom_URLClassifierParent_h
+
+#include "mozilla/dom/PContent.h"
+#include "mozilla/dom/PURLClassifierParent.h"
+#include "mozilla/dom/PURLClassifierLocalParent.h"
+#include "nsIURIClassifier.h"
+#include "nsIUrlClassifierFeature.h"
+
+namespace mozilla::dom {
+
+class IPCURLClassifierFeature;
+
+//////////////////////////////////////////////////////////////
+// URLClassifierParent
+
+class URLClassifierParent : public nsIURIClassifierCallback,
+                            public PURLClassifierParent {
+ public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  mozilla::ipc::IPCResult StartClassify(nsIPrincipal* aPrincipal,
+                                        bool* aSuccess);
+
+  // nsIURIClassifierCallback.
+  NS_IMETHOD OnClassifyComplete(nsresult aErrorCode, const nsACString& aList,
+                                const nsACString& aProvider,
+                                const nsACString& aFullHash) override {
+    if (mIPCOpen) {
+      ClassifierInfo info = ClassifierInfo(
+          nsCString(aList), nsCString(aProvider), nsCString(aFullHash));
+      Unused << Send__delete__(this, Some(info), aErrorCode);
+    }
+    return NS_OK;
+  }
+
+  // Custom.
+  void ClassificationFailed() {
+    if (mIPCOpen) {
+      Unused << Send__delete__(this, Nothing(), NS_ERROR_FAILURE);
+    }
+  }
+
+ private:
+  ~URLClassifierParent() = default;
+
+  // Override PURLClassifierParent::ActorDestroy. We seem to unable to
+  // override from the base template class.
+  void ActorDestroy(ActorDestroyReason aWhy) override { mIPCOpen = false; }
+
+  bool mIPCOpen = true;
+};
+
+//////////////////////////////////////////////////////////////
+// URLClassifierLocalParent
+
+class URLClassifierLocalParent : public nsIUrlClassifierFeatureCallback,
+                                 public PURLClassifierLocalParent {
+ public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  mozilla::ipc::IPCResult StartClassify(
+      nsIURI* aURI, const nsTArray<IPCURLClassifierFeature>& aFeatureNames);
+
+  // nsIUrlClassifierFeatureCallback.
+  NS_IMETHOD
+  OnClassifyComplete(
+      const nsTArray<RefPtr<nsIUrlClassifierFeatureResult>>& aResults) override;
+
+ private:
+  ~URLClassifierLocalParent() = default;
+
+  // Override PURLClassifierLocalParent::ActorDestroy.
+  void ActorDestroy(ActorDestroyReason aWhy) override { mIPCOpen = false; }
+
+  bool mIPCOpen = true;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_URLClassifierParent_h
diff --git a/dom/ipc/UserActivationIPCUtils.h b/dom/ipc/UserActivationIPCUtils.h
new file mode 100644
index 0000000000..ebf0aa20c9
--- /dev/null
+++ b/dom/ipc/UserActivationIPCUtils.h
@@ -0,0 +1,28 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_useractivation_ipc_utils_h__
+#define mozilla_dom_useractivation_ipc_utils_h__
+
+#include "ipc/EnumSerializer.h"
+
+// Undo X11/X.h's definition of None
+#undef None
+
+#include "mozilla/dom/UserActivation.h"
+
+namespace IPC {
+
+template <>
+struct ParamTraits<mozilla::dom::UserActivation::State>
+    : public ContiguousEnumSerializer<
+          mozilla::dom::UserActivation::State,
+          mozilla::dom::UserActivation::State::None,
+          mozilla::dom::UserActivation::State::EndGuard_> {};
+
+}  // namespace IPC
+
+#endif  // mozilla_dom_useractivation_ipc_utils_h__
diff --git a/dom/ipc/VsyncChild.h b/dom/ipc/VsyncChild.h
new file mode 100644
index 0000000000..98250e950d
--- /dev/null
+++ b/dom/ipc/VsyncChild.h
@@ -0,0 +1,24 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_ipc_VsyncChild_h
+#define mozilla_dom_ipc_VsyncChild_h
+
+#include "mozilla/dom/PVsyncChild.h"
+
+namespace mozilla::dom {
+
+class VsyncChild : public PVsyncChild {
+  friend class PVsyncChild;
+
+ protected:
+  virtual mozilla::ipc::IPCResult RecvNotify(const VsyncEvent& aVsync,
+                                             const float& aVsyncRate) = 0;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_ipc_VsyncChild_h
diff --git a/dom/ipc/VsyncMainChild.cpp b/dom/ipc/VsyncMainChild.cpp
new file mode 100644
index 0000000000..a1ea332e75
--- /dev/null
+++ b/dom/ipc/VsyncMainChild.cpp
@@ -0,0 +1,73 @@
+/* -*- 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 "VsyncMainChild.h"
+
+#include "mozilla/SchedulerGroup.h"
+#include "mozilla/VsyncDispatcher.h"
+#include "nsThreadUtils.h"
+
+namespace mozilla::dom {
+
+VsyncMainChild::VsyncMainChild()
+    : mIsShutdown(false), mVsyncRate(TimeDuration::Forever()) {
+  MOZ_ASSERT(NS_IsMainThread());
+}
+
+VsyncMainChild::~VsyncMainChild() { MOZ_ASSERT(NS_IsMainThread()); }
+
+void VsyncMainChild::AddChildRefreshTimer(VsyncObserver* aVsyncObserver) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!mObservers.Contains(aVsyncObserver));
+
+  if (mIsShutdown) {
+    return;
+  }
+
+  if (mObservers.IsEmpty()) {
+    Unused << PVsyncChild::SendObserve();
+  }
+  mObservers.AppendElement(std::move(aVsyncObserver));
+}
+
+void VsyncMainChild::RemoveChildRefreshTimer(VsyncObserver* aVsyncObserver) {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (mIsShutdown) {
+    return;
+  }
+
+  if (mObservers.RemoveElement(aVsyncObserver) && mObservers.IsEmpty()) {
+    Unused << PVsyncChild::SendUnobserve();
+  }
+}
+
+void VsyncMainChild::ActorDestroy(ActorDestroyReason aActorDestroyReason) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!mIsShutdown);
+  mIsShutdown = true;
+
+  if (!mObservers.IsEmpty()) {
+    Unused << PVsyncChild::SendUnobserve();
+  }
+  mObservers.Clear();
+}
+
+mozilla::ipc::IPCResult VsyncMainChild::RecvNotify(const VsyncEvent& aVsync,
+                                                   const float& aVsyncRate) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!mIsShutdown);
+
+  mVsyncRate = TimeDuration::FromMilliseconds(aVsyncRate);
+
+  for (RefPtr<VsyncObserver> observer : mObservers.ForwardRange()) {
+    observer->NotifyVsync(aVsync);
+  }
+  return IPC_OK();
+}
+
+TimeDuration VsyncMainChild::GetVsyncRate() { return mVsyncRate; }
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/VsyncMainChild.h b/dom/ipc/VsyncMainChild.h
new file mode 100644
index 0000000000..f5678ab0e9
--- /dev/null
+++ b/dom/ipc/VsyncMainChild.h
@@ -0,0 +1,51 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_ipc_VsyncMainChild_h
+#define mozilla_dom_ipc_VsyncMainChild_h
+
+#include "mozilla/dom/VsyncChild.h"
+#include "nsTObserverArray.h"
+
+namespace mozilla {
+
+class VsyncObserver;
+
+namespace dom {
+
+// The PVsyncChild actor receives a vsync event from the main process and
+// delivers it to the child process. Currently this is restricted to the main
+// thread only. The actor will stay alive until the process dies or its
+// PVsyncParent actor dies.
+class VsyncMainChild final : public VsyncChild {
+  NS_INLINE_DECL_REFCOUNTING(VsyncMainChild, override)
+
+  friend class PVsyncChild;
+
+ public:
+  VsyncMainChild();
+
+  void AddChildRefreshTimer(VsyncObserver* aVsyncObserver);
+  void RemoveChildRefreshTimer(VsyncObserver* aVsyncObserver);
+
+  TimeDuration GetVsyncRate();
+
+ private:
+  ~VsyncMainChild() override;
+
+  mozilla::ipc::IPCResult RecvNotify(const VsyncEvent& aVsync,
+                                     const float& aVsyncRate) override;
+  void ActorDestroy(ActorDestroyReason aActorDestroyReason) override;
+
+  bool mIsShutdown;
+  TimeDuration mVsyncRate;
+  nsTObserverArray<VsyncObserver*> mObservers;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_ipc_VsyncChild_h
diff --git a/dom/ipc/VsyncParent.cpp b/dom/ipc/VsyncParent.cpp
new file mode 100644
index 0000000000..617e054cd3
--- /dev/null
+++ b/dom/ipc/VsyncParent.cpp
@@ -0,0 +1,103 @@
+/* -*- 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 "VsyncParent.h"
+
+#include "mozilla/Unused.h"
+#include "nsThreadUtils.h"
+#include "nsIThread.h"
+
+namespace mozilla::dom {
+
+VsyncParent::VsyncParent()
+    : mObservingVsync(false),
+      mDestroyed(false),
+      mInitialThread(NS_GetCurrentThread()) {}
+
+void VsyncParent::UpdateVsyncDispatcher(
+    const RefPtr<VsyncDispatcher>& aVsyncDispatcher) {
+  if (aVsyncDispatcher == mVsyncDispatcher) {
+    return;
+  }
+
+  if (mObservingVsync && mVsyncDispatcher) {
+    mVsyncDispatcher->RemoveVsyncObserver(this);
+  }
+  mVsyncDispatcher = aVsyncDispatcher;
+  if (mObservingVsync) {
+    mVsyncDispatcher->AddVsyncObserver(this);
+  }
+}
+
+void VsyncParent::NotifyVsync(const VsyncEvent& aVsync) {
+  if (IsOnInitialThread()) {
+    DispatchVsyncEvent(aVsync);
+    return;
+  }
+
+  // Called on hardware vsync thread. We should post to current ipc thread.
+  nsCOMPtr<nsIRunnable> vsyncEvent = NewRunnableMethod<VsyncEvent>(
+      "dom::VsyncParent::DispatchVsyncEvent", this,
+      &VsyncParent::DispatchVsyncEvent, aVsync);
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToThreadQueue(
+      vsyncEvent.forget(), mInitialThread, EventQueuePriority::Vsync));
+}
+
+void VsyncParent::DispatchVsyncEvent(const VsyncEvent& aVsync) {
+  AssertIsOnInitialThread();
+
+  // If we call NotifyVsync() when we handle ActorDestroy() message, we might
+  // still call DispatchVsyncEvent().
+  // Similarly, we might also receive RecvUnobserveVsync() when call
+  // NotifyVsync(). We use mObservingVsync and mDestroyed flags to skip this
+  // notification.
+  if (mObservingVsync && !mDestroyed) {
+    TimeDuration vsyncRate = mVsyncDispatcher->GetVsyncRate();
+    Unused << SendNotify(aVsync, vsyncRate.ToMilliseconds());
+  }
+}
+
+mozilla::ipc::IPCResult VsyncParent::RecvObserve() {
+  AssertIsOnInitialThread();
+  if (!mObservingVsync) {
+    if (mVsyncDispatcher) {
+      mVsyncDispatcher->AddVsyncObserver(this);
+    }
+    mObservingVsync = true;
+    return IPC_OK();
+  }
+  return IPC_FAIL_NO_REASON(this);
+}
+
+mozilla::ipc::IPCResult VsyncParent::RecvUnobserve() {
+  AssertIsOnInitialThread();
+  if (mObservingVsync) {
+    if (mVsyncDispatcher) {
+      mVsyncDispatcher->RemoveVsyncObserver(this);
+    }
+    mObservingVsync = false;
+    return IPC_OK();
+  }
+  return IPC_FAIL_NO_REASON(this);
+}
+
+void VsyncParent::ActorDestroy(ActorDestroyReason aActorDestroyReason) {
+  MOZ_ASSERT(!mDestroyed);
+  AssertIsOnInitialThread();
+  if (mObservingVsync && mVsyncDispatcher) {
+    mVsyncDispatcher->RemoveVsyncObserver(this);
+  }
+  mVsyncDispatcher = nullptr;
+  mDestroyed = true;
+}
+
+bool VsyncParent::IsOnInitialThread() {
+  return NS_GetCurrentThread() == mInitialThread;
+}
+
+void VsyncParent::AssertIsOnInitialThread() { MOZ_ASSERT(IsOnInitialThread()); }
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/VsyncParent.h b/dom/ipc/VsyncParent.h
new file mode 100644
index 0000000000..3fe8a8e5f2
--- /dev/null
+++ b/dom/ipc/VsyncParent.h
@@ -0,0 +1,54 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_ipc_VsyncParent_h
+#define mozilla_dom_ipc_VsyncParent_h
+
+#include "mozilla/dom/PVsyncParent.h"
+#include "mozilla/VsyncDispatcher.h"
+#include "nsCOMPtr.h"
+#include "mozilla/RefPtr.h"
+
+class nsIThread;
+
+namespace mozilla::dom {
+
+// Use PBackground thread in the main process to send vsync notifications to
+// content process. This actor will be released when its parent protocol calls
+// DeallocPVsyncParent().
+class VsyncParent final : public PVsyncParent, public VsyncObserver {
+  friend class PVsyncParent;
+
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VsyncParent, override)
+
+ public:
+  VsyncParent();
+  void UpdateVsyncDispatcher(const RefPtr<VsyncDispatcher>& aVsyncDispatcher);
+
+ private:
+  virtual ~VsyncParent() = default;
+
+  void NotifyVsync(const VsyncEvent& aVsync) override;
+  virtual void ActorDestroy(ActorDestroyReason aActorDestroyReason) override;
+
+  mozilla::ipc::IPCResult RecvObserve();
+  mozilla::ipc::IPCResult RecvUnobserve();
+
+  void DispatchVsyncEvent(const VsyncEvent& aVsync);
+  void UpdateVsyncRate();
+
+  bool IsOnInitialThread();
+  void AssertIsOnInitialThread();
+
+  bool mObservingVsync;
+  bool mDestroyed;
+  nsCOMPtr<nsIThread> mInitialThread;
+  RefPtr<VsyncDispatcher> mVsyncDispatcher;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_ipc_VsyncParent_h
diff --git a/dom/ipc/VsyncWorkerChild.cpp b/dom/ipc/VsyncWorkerChild.cpp
new file mode 100644
index 0000000000..470ff73a27
--- /dev/null
+++ b/dom/ipc/VsyncWorkerChild.cpp
@@ -0,0 +1,67 @@
+/* -*- 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 "VsyncWorkerChild.h"
+#include "mozilla/dom/WorkerPrivate.h"
+#include "mozilla/dom/WorkerRef.h"
+#include "mozilla/dom/WorkerScope.h"
+
+namespace mozilla::dom {
+
+VsyncWorkerChild::VsyncWorkerChild() = default;
+
+VsyncWorkerChild::~VsyncWorkerChild() = default;
+
+bool VsyncWorkerChild::Initialize(WorkerPrivate* aWorkerPrivate) {
+  MOZ_ASSERT(aWorkerPrivate);
+  MOZ_ASSERT(!mWorkerRef);
+
+  mWorkerRef =
+      IPCWorkerRef::Create(aWorkerPrivate, "VsyncWorkerChild",
+                           [self = RefPtr{this}]() { self->Destroy(); });
+  return !!mWorkerRef;
+}
+
+void VsyncWorkerChild::Destroy() {
+  MOZ_ASSERT_IF(!CanSend(), !mWorkerRef);
+  MOZ_ASSERT_IF(!CanSend(), !mObserving);
+  Send__delete__(this);
+  MOZ_ASSERT(!mWorkerRef);
+  MOZ_ASSERT(!mObserving);
+}
+
+void VsyncWorkerChild::TryObserve() {
+  if (CanSend() && !mObserving) {
+    mObserving = SendObserve();
+  }
+}
+
+void VsyncWorkerChild::TryUnobserve() {
+  if (CanSend() && mObserving) {
+    mObserving = !SendUnobserve();
+  }
+}
+
+mozilla::ipc::IPCResult VsyncWorkerChild::RecvNotify(const VsyncEvent& aVsync,
+                                                     const float& aVsyncRate) {
+  // For MOZ_CAN_RUN_SCRIPT_BOUNDARY purposes: We know IPDL is explicitly
+  // keeping our actor alive until it is done processing the messages. We know
+  // that the WorkerGlobalScope callee is responsible keeping itself alive
+  // during the OnVsync callback.
+  WorkerPrivate* workerPrivate = mWorkerRef->Private();
+  WorkerGlobalScope* scope = workerPrivate->GlobalScope();
+  if (scope) {
+    scope->OnVsync(aVsync);
+  }
+  return IPC_OK();
+}
+
+void VsyncWorkerChild::ActorDestroy(ActorDestroyReason aActorDestroyReason) {
+  mWorkerRef = nullptr;
+  mObserving = false;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/VsyncWorkerChild.h b/dom/ipc/VsyncWorkerChild.h
new file mode 100644
index 0000000000..e34555936d
--- /dev/null
+++ b/dom/ipc/VsyncWorkerChild.h
@@ -0,0 +1,52 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_ipc_VsyncWorkerChild_h
+#define mozilla_dom_ipc_VsyncWorkerChild_h
+
+#include "mozilla/dom/VsyncChild.h"
+#include "mozilla/RefPtr.h"
+#include "nsISupportsImpl.h"
+
+namespace mozilla::dom {
+class DedicatedWorkerGlobalScope;
+class IPCWorkerRef;
+class WorkerPrivate;
+
+// The PVsyncWorkerChild actor receives a vsync event from the main process and
+// delivers it to the child process. This is specific for workers which wish to
+// subscribe to vsync events to drive requestAnimationFrame callbacks.
+class VsyncWorkerChild final : public VsyncChild {
+  NS_INLINE_DECL_REFCOUNTING(VsyncWorkerChild, override)
+
+  friend class PVsyncChild;
+
+ public:
+  VsyncWorkerChild();
+
+  bool Initialize(WorkerPrivate* aWorkerPrivate);
+
+  void Destroy();
+
+  void TryObserve();
+
+  void TryUnobserve();
+
+ private:
+  ~VsyncWorkerChild() override;
+
+  mozilla::ipc::IPCResult RecvNotify(const VsyncEvent& aVsync,
+                                     const float& aVsyncRate) override;
+
+  void ActorDestroy(ActorDestroyReason aActorDestroyReason) override;
+
+  RefPtr<IPCWorkerRef> mWorkerRef;
+  bool mObserving = false;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_ipc_VsyncWorkerChild_h
diff --git a/dom/ipc/WindowGlobalActor.cpp b/dom/ipc/WindowGlobalActor.cpp
new file mode 100644
index 0000000000..ce5fa3eaf4
--- /dev/null
+++ b/dom/ipc/WindowGlobalActor.cpp
@@ -0,0 +1,187 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "mozilla/dom/WindowGlobalActor.h"
+
+#include "AutoplayPolicy.h"
+#include "nsContentUtils.h"
+#include "mozilla/Components.h"
+#include "mozilla/ContentBlockingAllowList.h"
+#include "mozilla/Logging.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/JSActorService.h"
+#include "mozilla/dom/JSWindowActorParent.h"
+#include "mozilla/dom/JSWindowActorChild.h"
+#include "mozilla/dom/JSWindowActorProtocol.h"
+#include "mozilla/dom/PopupBlocker.h"
+#include "mozilla/net/CookieJarSettings.h"
+#include "mozilla/dom/WindowContext.h"
+#include "mozilla/dom/WindowGlobalChild.h"
+#include "mozilla/dom/WindowGlobalParent.h"
+
+#include "nsGlobalWindowInner.h"
+#include "nsNetUtil.h"
+
+namespace mozilla::dom {
+
+// CORPP 3.1.3 https://mikewest.github.io/corpp/#integration-html
+static nsILoadInfo::CrossOriginEmbedderPolicy InheritedPolicy(
+    dom::BrowsingContext* aBrowsingContext) {
+  WindowContext* inherit = aBrowsingContext->GetParentWindowContext();
+  if (inherit) {
+    return inherit->GetEmbedderPolicy();
+  }
+
+  return nsILoadInfo::EMBEDDER_POLICY_NULL;
+}
+
+// Common WindowGlobalInit creation code used by both `AboutBlankInitializer`
+// and `WindowInitializer`.
+WindowGlobalInit WindowGlobalActor::BaseInitializer(
+    dom::BrowsingContext* aBrowsingContext, uint64_t aInnerWindowId,
+    uint64_t aOuterWindowId) {
+  MOZ_DIAGNOSTIC_ASSERT(aBrowsingContext);
+
+  using Indexes = WindowContext::FieldIndexes;
+
+  WindowGlobalInit init;
+  auto& ctx = init.context();
+  ctx.mInnerWindowId = aInnerWindowId;
+  ctx.mOuterWindowId = aOuterWindowId;
+  ctx.mBrowsingContextId = aBrowsingContext->Id();
+
+  // If any synced fields need to be initialized from our BrowsingContext, we
+  // can initialize them here.
+  auto& fields = ctx.mFields;
+  fields.Get<Indexes::IDX_EmbedderPolicy>() = InheritedPolicy(aBrowsingContext);
+  fields.Get<Indexes::IDX_AutoplayPermission>() =
+      nsIPermissionManager::UNKNOWN_ACTION;
+  fields.Get<Indexes::IDX_AllowJavascript>() = true;
+  return init;
+}
+
+WindowGlobalInit WindowGlobalActor::AboutBlankInitializer(
+    dom::BrowsingContext* aBrowsingContext, nsIPrincipal* aPrincipal) {
+  WindowGlobalInit init =
+      BaseInitializer(aBrowsingContext, nsContentUtils::GenerateWindowId(),
+                      nsContentUtils::GenerateWindowId());
+
+  init.principal() = aPrincipal;
+  init.storagePrincipal() = aPrincipal;
+  Unused << NS_NewURI(getter_AddRefs(init.documentURI()), "about:blank");
+  init.isInitialDocument() = true;
+
+  return init;
+}
+
+WindowGlobalInit WindowGlobalActor::WindowInitializer(
+    nsGlobalWindowInner* aWindow) {
+  WindowGlobalInit init =
+      BaseInitializer(aWindow->GetBrowsingContext(), aWindow->WindowID(),
+                      aWindow->GetOuterWindow()->WindowID());
+
+  init.principal() = aWindow->GetPrincipal();
+  init.storagePrincipal() = aWindow->GetEffectiveStoragePrincipal();
+  init.documentURI() = aWindow->GetDocumentURI();
+
+  Document* doc = aWindow->GetDocument();
+
+  init.isInitialDocument() = doc->IsInitialDocument();
+  init.blockAllMixedContent() = doc->GetBlockAllMixedContent(false);
+  init.upgradeInsecureRequests() = doc->GetUpgradeInsecureRequests(false);
+  init.sandboxFlags() = doc->GetSandboxFlags();
+  net::CookieJarSettings::Cast(doc->CookieJarSettings())
+      ->Serialize(init.cookieJarSettings());
+  init.httpsOnlyStatus() = doc->HttpsOnlyStatus();
+
+  using Indexes = WindowContext::FieldIndexes;
+
+  auto& fields = init.context().mFields;
+  fields.Get<Indexes::IDX_CookieBehavior>() =
+      Some(doc->CookieJarSettings()->GetCookieBehavior());
+  fields.Get<Indexes::IDX_IsOnContentBlockingAllowList>() =
+      doc->CookieJarSettings()->GetIsOnContentBlockingAllowList();
+  fields.Get<Indexes::IDX_IsThirdPartyWindow>() = doc->HasThirdPartyChannel();
+  fields.Get<Indexes::IDX_IsThirdPartyTrackingResourceWindow>() =
+      nsContentUtils::IsThirdPartyTrackingResourceWindow(aWindow);
+  fields.Get<Indexes::IDX_ShouldResistFingerprinting>() =
+      doc->ShouldResistFingerprinting(RFPTarget::IsAlwaysEnabledForPrecompute);
+  fields.Get<Indexes::IDX_IsSecureContext>() = aWindow->IsSecureContext();
+
+  // Initialze permission fields
+  fields.Get<Indexes::IDX_AutoplayPermission>() =
+      media::AutoplayPolicy::GetSiteAutoplayPermission(init.principal());
+  fields.Get<Indexes::IDX_PopupPermission>() =
+      PopupBlocker::GetPopupPermission(init.principal());
+
+  // Initialize top level permission fields
+  if (aWindow->GetBrowsingContext()->IsTop()) {
+    fields.Get<Indexes::IDX_AllowMixedContent>() = [&] {
+      uint32_t permit = nsIPermissionManager::UNKNOWN_ACTION;
+      nsCOMPtr<nsIPermissionManager> permissionManager =
+          components::PermissionManager::Service();
+
+      if (permissionManager) {
+        permissionManager->TestPermissionFromPrincipal(
+            init.principal(), "mixed-content"_ns, &permit);
+      }
+
+      return permit == nsIPermissionManager::ALLOW_ACTION;
+    }();
+
+    fields.Get<Indexes::IDX_ShortcutsPermission>() =
+        nsGlobalWindowInner::GetShortcutsPermission(init.principal());
+  }
+
+  if (auto policy = doc->GetEmbedderPolicy()) {
+    fields.Get<Indexes::IDX_EmbedderPolicy>() = *policy;
+  }
+
+  // Init Mixed Content Fields
+  nsCOMPtr<nsIURI> innerDocURI = NS_GetInnermostURI(doc->GetDocumentURI());
+  fields.Get<Indexes::IDX_IsSecure>() =
+      innerDocURI && innerDocURI->SchemeIs("https");
+
+  nsCOMPtr<nsITransportSecurityInfo> securityInfo;
+  if (nsCOMPtr<nsIChannel> channel = doc->GetChannel()) {
+    nsCOMPtr<nsILoadInfo> loadInfo(channel->LoadInfo());
+    fields.Get<Indexes::IDX_IsOriginalFrameSource>() =
+        loadInfo->GetOriginalFrameSrcLoad();
+
+    channel->GetSecurityInfo(getter_AddRefs(securityInfo));
+  }
+  init.securityInfo() = securityInfo;
+
+  fields.Get<Indexes::IDX_IsLocalIP>() =
+      init.principal()->GetIsLocalIpAddress();
+
+  // Most data here is specific to the Document, which can change without
+  // creating a new WindowGlobal. Anything new added here which fits that
+  // description should also be synchronized in
+  // WindowGlobalChild::OnNewDocument.
+  return init;
+}
+
+already_AddRefed<JSActorProtocol> WindowGlobalActor::MatchingJSActorProtocol(
+    JSActorService* aActorSvc, const nsACString& aName, ErrorResult& aRv) {
+  RefPtr<JSWindowActorProtocol> proto =
+      aActorSvc->GetJSWindowActorProtocol(aName);
+  if (!proto) {
+    aRv.ThrowNotFoundError(nsPrintfCString("No such JSWindowActor '%s'",
+                                           PromiseFlatCString(aName).get()));
+    return nullptr;
+  }
+
+  if (!proto->Matches(BrowsingContext(), GetDocumentURI(), GetRemoteType(),
+                      aRv)) {
+    MOZ_ASSERT(aRv.Failed());
+    return nullptr;
+  }
+  MOZ_ASSERT(!aRv.Failed());
+  return proto.forget();
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/WindowGlobalActor.h b/dom/ipc/WindowGlobalActor.h
new file mode 100644
index 0000000000..7ab19c292e
--- /dev/null
+++ b/dom/ipc/WindowGlobalActor.h
@@ -0,0 +1,55 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_WindowGlobalActor_h
+#define mozilla_dom_WindowGlobalActor_h
+
+#include "nsWrapperCache.h"
+#include "nsISupports.h"
+#include "mozilla/dom/BrowsingContext.h"
+#include "nsIURI.h"
+#include "nsString.h"
+#include "mozilla/dom/JSActor.h"
+#include "mozilla/dom/JSActorManager.h"
+#include "mozilla/dom/WindowGlobalTypes.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+// Common base class for WindowGlobal{Parent, Child}.
+class WindowGlobalActor : public JSActorManager {
+ public:
+  // Called to determine initial state for a window global actor created for an
+  // initial about:blank document.
+  static WindowGlobalInit AboutBlankInitializer(
+      dom::BrowsingContext* aBrowsingContext, nsIPrincipal* aPrincipal);
+
+  // Called to determine initial state for a window global actor created for a
+  // specific existing nsGlobalWindowInner.
+  static WindowGlobalInit WindowInitializer(nsGlobalWindowInner* aWindow);
+
+ protected:
+  virtual ~WindowGlobalActor() = default;
+
+  already_AddRefed<JSActorProtocol> MatchingJSActorProtocol(
+      JSActorService* aActorSvc, const nsACString& aName,
+      ErrorResult& aRv) final;
+
+  virtual nsIURI* GetDocumentURI() = 0;
+  virtual const nsACString& GetRemoteType() = 0;
+  virtual dom::BrowsingContext* BrowsingContext() = 0;
+
+  static WindowGlobalInit BaseInitializer(
+      dom::BrowsingContext* aBrowsingContext, uint64_t aInnerWindowId,
+      uint64_t aOuterWindowId);
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_WindowGlobalActor_h
diff --git a/dom/ipc/WindowGlobalChild.cpp b/dom/ipc/WindowGlobalChild.cpp
new file mode 100644
index 0000000000..f400bef2b4
--- /dev/null
+++ b/dom/ipc/WindowGlobalChild.cpp
@@ -0,0 +1,839 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=2 ts=8 et tw=80 ft=cpp : */
+/* 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 "mozilla/dom/WindowGlobalChild.h"
+
+#include "mozilla/AntiTrackingUtils.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/dom/WindowGlobalParent.h"
+#include "mozilla/dom/BrowsingContext.h"
+#include "mozilla/dom/BrowsingContextGroup.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/MozFrameLoaderOwnerBinding.h"
+#include "mozilla/dom/BrowserChild.h"
+#include "mozilla/dom/BrowserBridgeChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/SecurityPolicyViolationEvent.h"
+#include "mozilla/dom/SessionStoreRestoreData.h"
+#include "mozilla/dom/WindowGlobalActorsBinding.h"
+#include "mozilla/dom/WindowContext.h"
+#include "mozilla/dom/InProcessChild.h"
+#include "mozilla/dom/InProcessParent.h"
+#include "mozilla/ipc/Endpoint.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/ScopeExit.h"
+#include "GeckoProfiler.h"
+#include "nsContentUtils.h"
+#include "nsDocShell.h"
+#include "nsFocusManager.h"
+#include "nsFrameLoaderOwner.h"
+#include "nsGlobalWindowInner.h"
+#include "nsNetUtil.h"
+#include "nsQueryObject.h"
+#include "nsSerializationHelper.h"
+#include "nsFrameLoader.h"
+
+#include "mozilla/dom/JSWindowActorBinding.h"
+#include "mozilla/dom/JSWindowActorChild.h"
+#include "mozilla/dom/JSActorService.h"
+#include "nsIHttpChannelInternal.h"
+#include "nsIURIMutator.h"
+#include "nsURLHelper.h"
+
+using namespace mozilla::ipc;
+using namespace mozilla::dom::ipc;
+
+namespace mozilla::dom {
+
+WindowGlobalChild::WindowGlobalChild(dom::WindowContext* aWindowContext,
+                                     nsIPrincipal* aPrincipal,
+                                     nsIURI* aDocumentURI)
+    : mWindowContext(aWindowContext),
+      mDocumentPrincipal(aPrincipal),
+      mDocumentURI(aDocumentURI) {
+  MOZ_DIAGNOSTIC_ASSERT(mWindowContext);
+  MOZ_DIAGNOSTIC_ASSERT(mDocumentPrincipal);
+
+  if (!mDocumentURI) {
+    NS_NewURI(getter_AddRefs(mDocumentURI), "about:blank");
+  }
+
+  // Registers a DOM Window with the profiler. It re-registers the same Inner
+  // Window ID with different URIs because when a Browsing context is first
+  // loaded, the first url loaded in it will be about:blank. This call keeps the
+  // first non-about:blank registration of window and discards the previous one.
+  uint64_t embedderInnerWindowID = 0;
+  if (BrowsingContext()->GetParent()) {
+    embedderInnerWindowID = BrowsingContext()->GetEmbedderInnerWindowId();
+  }
+  profiler_register_page(
+      BrowsingContext()->BrowserId(), InnerWindowId(),
+      nsContentUtils::TruncatedURLForDisplay(aDocumentURI, 1024),
+      embedderInnerWindowID, BrowsingContext()->UsePrivateBrowsing());
+}
+
+already_AddRefed<WindowGlobalChild> WindowGlobalChild::Create(
+    nsGlobalWindowInner* aWindow) {
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+  // Opener policy is set when we start to load a document. Here, we ensure we
+  // have set the correct Opener policy so that it will be available in the
+  // parent process through window global child.
+  nsCOMPtr<nsIChannel> chan = aWindow->GetDocument()->GetChannel();
+  nsCOMPtr<nsILoadInfo> loadInfo = chan ? chan->LoadInfo() : nullptr;
+  nsCOMPtr<nsIHttpChannelInternal> httpChan = do_QueryInterface(chan);
+  nsILoadInfo::CrossOriginOpenerPolicy policy;
+  if (httpChan &&
+      loadInfo->GetExternalContentPolicyType() ==
+          ExtContentPolicy::TYPE_DOCUMENT &&
+      NS_SUCCEEDED(httpChan->GetCrossOriginOpenerPolicy(&policy))) {
+    MOZ_DIAGNOSTIC_ASSERT(policy ==
+                          aWindow->GetBrowsingContext()->GetOpenerPolicy());
+  }
+#endif
+
+  WindowGlobalInit init = WindowGlobalActor::WindowInitializer(aWindow);
+  RefPtr<WindowGlobalChild> wgc = CreateDisconnected(init);
+
+  // Send the link constructor over PBrowser, or link over PInProcess.
+  if (XRE_IsParentProcess()) {
+    InProcessChild* ipChild = InProcessChild::Singleton();
+    InProcessParent* ipParent = InProcessParent::Singleton();
+    if (!ipChild || !ipParent) {
+      return nullptr;
+    }
+
+    ManagedEndpoint<PWindowGlobalParent> endpoint =
+        ipChild->OpenPWindowGlobalEndpoint(wgc);
+    ipParent->BindPWindowGlobalEndpoint(std::move(endpoint),
+                                        wgc->WindowContext()->Canonical());
+  } else {
+    RefPtr<BrowserChild> browserChild =
+        BrowserChild::GetFrom(static_cast<mozIDOMWindow*>(aWindow));
+    MOZ_ASSERT(browserChild);
+
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+    dom::BrowsingContext* bc = aWindow->GetBrowsingContext();
+#endif
+
+    MOZ_DIAGNOSTIC_ASSERT(bc->AncestorsAreCurrent());
+    MOZ_DIAGNOSTIC_ASSERT(bc->IsInProcess());
+
+    ManagedEndpoint<PWindowGlobalParent> endpoint =
+        browserChild->OpenPWindowGlobalEndpoint(wgc);
+    browserChild->SendNewWindowGlobal(std::move(endpoint), init);
+  }
+
+  wgc->Init();
+  wgc->InitWindowGlobal(aWindow);
+  return wgc.forget();
+}
+
+already_AddRefed<WindowGlobalChild> WindowGlobalChild::CreateDisconnected(
+    const WindowGlobalInit& aInit) {
+  RefPtr<dom::BrowsingContext> browsingContext =
+      dom::BrowsingContext::Get(aInit.context().mBrowsingContextId);
+
+  RefPtr<dom::WindowContext> windowContext =
+      dom::WindowContext::GetById(aInit.context().mInnerWindowId);
+  MOZ_RELEASE_ASSERT(!windowContext, "Creating duplicate WindowContext");
+
+  // Create our new WindowContext
+  if (XRE_IsParentProcess()) {
+    windowContext = WindowGlobalParent::CreateDisconnected(aInit);
+  } else {
+    dom::WindowContext::FieldValues fields = aInit.context().mFields;
+    windowContext = new dom::WindowContext(
+        browsingContext, aInit.context().mInnerWindowId,
+        aInit.context().mOuterWindowId, std::move(fields));
+  }
+
+  RefPtr<WindowGlobalChild> windowChild = new WindowGlobalChild(
+      windowContext, aInit.principal(), aInit.documentURI());
+  windowContext->mIsInProcess = true;
+  windowContext->mWindowGlobalChild = windowChild;
+  return windowChild.forget();
+}
+
+void WindowGlobalChild::Init() {
+  MOZ_ASSERT(mWindowContext->mWindowGlobalChild == this);
+  mWindowContext->Init();
+}
+
+void WindowGlobalChild::InitWindowGlobal(nsGlobalWindowInner* aWindow) {
+  mWindowGlobal = aWindow;
+}
+
+void WindowGlobalChild::OnNewDocument(Document* aDocument) {
+  MOZ_RELEASE_ASSERT(mWindowGlobal);
+  MOZ_RELEASE_ASSERT(aDocument);
+
+  // Send a series of messages to update document-specific state on
+  // WindowGlobalParent, when we change documents on an existing WindowGlobal.
+  // This data is also all sent when we construct a WindowGlobal, so anything
+  // added here should also be added to WindowGlobalActor::WindowInitializer.
+
+  // FIXME: Perhaps these should be combined into a smaller number of messages?
+  SendSetIsInitialDocument(aDocument->IsInitialDocument());
+  SetDocumentURI(aDocument->GetDocumentURI());
+  SetDocumentPrincipal(aDocument->NodePrincipal(),
+                       aDocument->EffectiveStoragePrincipal());
+
+  nsCOMPtr<nsITransportSecurityInfo> securityInfo;
+  if (nsCOMPtr<nsIChannel> channel = aDocument->GetChannel()) {
+    channel->GetSecurityInfo(getter_AddRefs(securityInfo));
+  }
+  SendUpdateDocumentSecurityInfo(securityInfo);
+
+  SendUpdateDocumentCspSettings(aDocument->GetBlockAllMixedContent(false),
+                                aDocument->GetUpgradeInsecureRequests(false));
+  SendUpdateSandboxFlags(aDocument->GetSandboxFlags());
+
+  net::CookieJarSettingsArgs csArgs;
+  net::CookieJarSettings::Cast(aDocument->CookieJarSettings())
+      ->Serialize(csArgs);
+  if (!SendUpdateCookieJarSettings(csArgs)) {
+    NS_WARNING(
+        "Failed to update document's cookie jar settings on the "
+        "WindowGlobalParent");
+  }
+
+  SendUpdateHttpsOnlyStatus(aDocument->HttpsOnlyStatus());
+
+  // Update window context fields for the newly loaded Document.
+  WindowContext::Transaction txn;
+  txn.SetCookieBehavior(
+      Some(aDocument->CookieJarSettings()->GetCookieBehavior()));
+  txn.SetIsOnContentBlockingAllowList(
+      aDocument->CookieJarSettings()->GetIsOnContentBlockingAllowList());
+  txn.SetIsThirdPartyWindow(aDocument->HasThirdPartyChannel());
+  txn.SetIsThirdPartyTrackingResourceWindow(
+      nsContentUtils::IsThirdPartyTrackingResourceWindow(mWindowGlobal));
+  txn.SetIsSecureContext(mWindowGlobal->IsSecureContext());
+  if (auto policy = aDocument->GetEmbedderPolicy()) {
+    txn.SetEmbedderPolicy(*policy);
+  }
+
+  if (nsCOMPtr<nsIChannel> channel = aDocument->GetChannel()) {
+    nsCOMPtr<nsILoadInfo> loadInfo(channel->LoadInfo());
+    txn.SetIsOriginalFrameSource(loadInfo->GetOriginalFrameSrcLoad());
+  } else {
+    txn.SetIsOriginalFrameSource(false);
+  }
+
+  // Init Mixed Content Fields
+  nsCOMPtr<nsIURI> innerDocURI =
+      NS_GetInnermostURI(aDocument->GetDocumentURI());
+  if (innerDocURI) {
+    txn.SetIsSecure(innerDocURI->SchemeIs("https"));
+  }
+
+  MOZ_DIAGNOSTIC_ASSERT(mDocumentPrincipal->GetIsLocalIpAddress() ==
+                        mWindowContext->IsLocalIP());
+
+  MOZ_ALWAYS_SUCCEEDS(txn.Commit(mWindowContext));
+}
+
+/* static */
+already_AddRefed<WindowGlobalChild> WindowGlobalChild::GetByInnerWindowId(
+    uint64_t aInnerWindowId) {
+  if (RefPtr<dom::WindowContext> context =
+          dom::WindowContext::GetById(aInnerWindowId)) {
+    return do_AddRef(context->GetWindowGlobalChild());
+  }
+  return nullptr;
+}
+
+dom::BrowsingContext* WindowGlobalChild::BrowsingContext() {
+  return mWindowContext->GetBrowsingContext();
+}
+
+uint64_t WindowGlobalChild::InnerWindowId() {
+  return mWindowContext->InnerWindowId();
+}
+
+uint64_t WindowGlobalChild::OuterWindowId() {
+  return mWindowContext->OuterWindowId();
+}
+
+bool WindowGlobalChild::IsCurrentGlobal() {
+  return CanSend() && mWindowGlobal->IsCurrentInnerWindow();
+}
+
+already_AddRefed<WindowGlobalParent> WindowGlobalChild::GetParentActor() {
+  if (!CanSend()) {
+    return nullptr;
+  }
+  IProtocol* otherSide = InProcessChild::ParentActorFor(this);
+  return do_AddRef(static_cast<WindowGlobalParent*>(otherSide));
+}
+
+already_AddRefed<BrowserChild> WindowGlobalChild::GetBrowserChild() {
+  if (IsInProcess() || !CanSend()) {
+    return nullptr;
+  }
+  return do_AddRef(static_cast<BrowserChild*>(Manager()));
+}
+
+uint64_t WindowGlobalChild::ContentParentId() {
+  if (XRE_IsParentProcess()) {
+    return 0;
+  }
+  return ContentChild::GetSingleton()->GetID();
+}
+
+// A WindowGlobalChild is the root in its process if it has no parent, or its
+// embedder is in a different process.
+bool WindowGlobalChild::IsProcessRoot() {
+  if (!BrowsingContext()->GetParent()) {
+    return true;
+  }
+
+  return !BrowsingContext()->GetEmbedderElement();
+}
+
+void WindowGlobalChild::BeforeUnloadAdded() {
+  // Don't bother notifying the parent if we don't have an IPC link open.
+  if (mBeforeUnloadListeners == 0 && CanSend()) {
+    Unused << mWindowContext->SetHasBeforeUnload(true);
+  }
+
+  mBeforeUnloadListeners++;
+  MOZ_ASSERT(mBeforeUnloadListeners > 0);
+}
+
+void WindowGlobalChild::BeforeUnloadRemoved() {
+  mBeforeUnloadListeners--;
+  MOZ_ASSERT(mBeforeUnloadListeners >= 0);
+
+  if (mBeforeUnloadListeners == 0) {
+    Unused << mWindowContext->SetHasBeforeUnload(false);
+  }
+}
+
+void WindowGlobalChild::Destroy() {
+  JSActorWillDestroy();
+
+  mWindowContext->Discard();
+
+  // Perform async IPC shutdown unless we're not in-process, and our
+  // BrowserChild is in the process of being destroyed, which will destroy
+  // us as well.
+  RefPtr<BrowserChild> browserChild = GetBrowserChild();
+  if (!browserChild || !browserChild->IsDestroyed()) {
+    SendDestroy();
+  }
+}
+
+mozilla::ipc::IPCResult WindowGlobalChild::RecvMakeFrameLocal(
+    const MaybeDiscarded<dom::BrowsingContext>& aFrameContext,
+    uint64_t aPendingSwitchId) {
+  MOZ_DIAGNOSTIC_ASSERT(XRE_IsContentProcess());
+
+  MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+          ("RecvMakeFrameLocal ID=%" PRIx64, aFrameContext.ContextId()));
+
+  if (NS_WARN_IF(aFrameContext.IsNullOrDiscarded())) {
+    return IPC_OK();
+  }
+  dom::BrowsingContext* frameContext = aFrameContext.get();
+
+  RefPtr<Element> embedderElt = frameContext->GetEmbedderElement();
+  if (NS_WARN_IF(!embedderElt)) {
+    return IPC_OK();
+  }
+
+  if (NS_WARN_IF(embedderElt->GetOwnerGlobal() != GetWindowGlobal())) {
+    return IPC_OK();
+  }
+
+  RefPtr<nsFrameLoaderOwner> flo = do_QueryObject(embedderElt);
+  MOZ_DIAGNOSTIC_ASSERT(flo, "Embedder must be a nsFrameLoaderOwner");
+
+  // Trigger a process switch into the current process.
+  RemotenessOptions options;
+  options.mRemoteType = NOT_REMOTE_TYPE;
+  options.mPendingSwitchID.Construct(aPendingSwitchId);
+  options.mSwitchingInProgressLoad = true;
+  flo->ChangeRemoteness(options, IgnoreErrors());
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalChild::RecvMakeFrameRemote(
+    const MaybeDiscarded<dom::BrowsingContext>& aFrameContext,
+    ManagedEndpoint<PBrowserBridgeChild>&& aEndpoint, const TabId& aTabId,
+    const LayersId& aLayersId, MakeFrameRemoteResolver&& aResolve) {
+  MOZ_DIAGNOSTIC_ASSERT(XRE_IsContentProcess());
+
+  MOZ_LOG(BrowsingContext::GetLog(), LogLevel::Debug,
+          ("RecvMakeFrameRemote ID=%" PRIx64, aFrameContext.ContextId()));
+
+  if (!aLayersId.IsValid()) {
+    return IPC_FAIL(this, "Received an invalid LayersId");
+  }
+
+  // Resolve the promise when this function exits, as we'll have fully unloaded
+  // at that point.
+  auto scopeExit = MakeScopeExit([&] { aResolve(true); });
+
+  // Get a BrowsingContext if we're not null or discarded. We don't want to
+  // early-return before we connect the BrowserBridgeChild, as otherwise we'll
+  // never break the channel in the parent.
+  RefPtr<dom::BrowsingContext> frameContext;
+  if (!aFrameContext.IsDiscarded()) {
+    frameContext = aFrameContext.get();
+  }
+
+  // Immediately construct the BrowserBridgeChild so we can destroy it cleanly
+  // if the process switch fails.
+  RefPtr<BrowserBridgeChild> bridge =
+      new BrowserBridgeChild(frameContext, aTabId, aLayersId);
+  RefPtr<BrowserChild> manager = GetBrowserChild();
+  if (NS_WARN_IF(
+          !manager->BindPBrowserBridgeEndpoint(std::move(aEndpoint), bridge))) {
+    return IPC_OK();
+  }
+
+  // Synchronously delete de actor here rather than using SendBeginDestroy(), as
+  // we haven't initialized it yet.
+  auto deleteBridge =
+      MakeScopeExit([&] { BrowserBridgeChild::Send__delete__(bridge); });
+
+  // Immediately tear down the actor if we don't have a valid FrameContext.
+  if (NS_WARN_IF(aFrameContext.IsNullOrDiscarded())) {
+    return IPC_OK();
+  }
+
+  RefPtr<Element> embedderElt = frameContext->GetEmbedderElement();
+  if (NS_WARN_IF(!embedderElt)) {
+    return IPC_OK();
+  }
+
+  if (NS_WARN_IF(embedderElt->GetOwnerGlobal() != GetWindowGlobal())) {
+    return IPC_OK();
+  }
+
+  RefPtr<nsFrameLoaderOwner> flo = do_QueryObject(embedderElt);
+  MOZ_DIAGNOSTIC_ASSERT(flo, "Embedder must be a nsFrameLoaderOwner");
+
+  // Trgger a process switch into the specified process.
+  IgnoredErrorResult rv;
+  flo->ChangeRemotenessWithBridge(bridge, rv);
+  if (NS_WARN_IF(rv.Failed())) {
+    return IPC_OK();
+  }
+
+  // Everything succeeded, so don't delete the bridge.
+  deleteBridge.release();
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalChild::RecvDrawSnapshot(
+    const Maybe<IntRect>& aRect, const float& aScale,
+    const nscolor& aBackgroundColor, const uint32_t& aFlags,
+    DrawSnapshotResolver&& aResolve) {
+  aResolve(gfx::PaintFragment::Record(BrowsingContext(), aRect, aScale,
+                                      aBackgroundColor,
+                                      (gfx::CrossProcessPaintFlags)aFlags));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+WindowGlobalChild::RecvSaveStorageAccessPermissionGranted() {
+  nsCOMPtr<nsPIDOMWindowInner> inner = GetWindowGlobal();
+  if (inner) {
+    inner->SaveStorageAccessPermissionGranted();
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalChild::RecvDispatchSecurityPolicyViolation(
+    const nsString& aViolationEventJSON) {
+  nsGlobalWindowInner* window = GetWindowGlobal();
+  if (!window) {
+    return IPC_OK();
+  }
+
+  Document* doc = window->GetDocument();
+  if (!doc) {
+    return IPC_OK();
+  }
+
+  SecurityPolicyViolationEventInit violationEvent;
+  if (!violationEvent.Init(aViolationEventJSON)) {
+    return IPC_OK();
+  }
+
+  RefPtr<Event> event = SecurityPolicyViolationEvent::Constructor(
+      doc, u"securitypolicyviolation"_ns, violationEvent);
+  event->SetTrusted(true);
+  doc->DispatchEvent(*event, IgnoreErrors());
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalChild::RecvAddBlockedFrameNodeByClassifier(
+    const MaybeDiscardedBrowsingContext& aNode) {
+  if (aNode.IsNullOrDiscarded()) {
+    return IPC_OK();
+  }
+
+  nsGlobalWindowInner* window = GetWindowGlobal();
+  if (!window) {
+    return IPC_OK();
+  }
+
+  Document* doc = window->GetDocument();
+  if (!doc) {
+    return IPC_OK();
+  }
+
+  MOZ_ASSERT(aNode.get()->GetEmbedderElement()->OwnerDoc() == doc);
+  doc->AddBlockedNodeByClassifier(aNode.get()->GetEmbedderElement());
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalChild::RecvResetScalingZoom() {
+  if (Document* doc = mWindowGlobal->GetExtantDoc()) {
+    if (PresShell* ps = doc->GetPresShell()) {
+      ps->SetResolutionAndScaleTo(1.0,
+                                  ResolutionChangeOrigin::MainThreadAdjustment);
+    }
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalChild::RecvSetContainerFeaturePolicy(
+    dom::FeaturePolicy* aContainerFeaturePolicy) {
+  mContainerFeaturePolicy = aContainerFeaturePolicy;
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalChild::RecvRestoreDocShellState(
+    const dom::sessionstore::DocShellRestoreState& aState,
+    RestoreDocShellStateResolver&& aResolve) {
+  if (mWindowGlobal) {
+    SessionStoreUtils::RestoreDocShellState(mWindowGlobal->GetDocShell(),
+                                            aState);
+  }
+  aResolve(true);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalChild::RecvRestoreTabContent(
+    dom::SessionStoreRestoreData* aData, RestoreTabContentResolver&& aResolve) {
+  aData->RestoreInto(BrowsingContext());
+  aResolve(true);
+  return IPC_OK();
+}
+
+IPCResult WindowGlobalChild::RecvRawMessage(
+    const JSActorMessageMeta& aMeta, const Maybe<ClonedMessageData>& aData,
+    const Maybe<ClonedMessageData>& aStack) {
+  Maybe<StructuredCloneData> data;
+  if (aData) {
+    data.emplace();
+    data->BorrowFromClonedMessageData(*aData);
+  }
+  Maybe<StructuredCloneData> stack;
+  if (aStack) {
+    stack.emplace();
+    stack->BorrowFromClonedMessageData(*aStack);
+  }
+  ReceiveRawMessage(aMeta, std::move(data), std::move(stack));
+  return IPC_OK();
+}
+
+void WindowGlobalChild::SetDocumentURI(nsIURI* aDocumentURI) {
+  // Registers a DOM Window with the profiler. It re-registers the same Inner
+  // Window ID with different URIs because when a Browsing context is first
+  // loaded, the first url loaded in it will be about:blank. This call keeps the
+  // first non-about:blank registration of window and discards the previous one.
+  uint64_t embedderInnerWindowID = 0;
+  if (BrowsingContext()->GetParent()) {
+    embedderInnerWindowID = BrowsingContext()->GetEmbedderInnerWindowId();
+  }
+  profiler_register_page(
+      BrowsingContext()->BrowserId(), InnerWindowId(),
+      nsContentUtils::TruncatedURLForDisplay(aDocumentURI, 1024),
+      embedderInnerWindowID, BrowsingContext()->UsePrivateBrowsing());
+  mDocumentURI = aDocumentURI;
+  SendUpdateDocumentURI(aDocumentURI);
+}
+
+void WindowGlobalChild::SetDocumentPrincipal(
+    nsIPrincipal* aNewDocumentPrincipal,
+    nsIPrincipal* aNewDocumentStoragePrincipal) {
+  MOZ_ASSERT(mDocumentPrincipal->Equals(aNewDocumentPrincipal));
+  mDocumentPrincipal = aNewDocumentPrincipal;
+  SendUpdateDocumentPrincipal(aNewDocumentPrincipal,
+                              aNewDocumentStoragePrincipal);
+}
+
+const nsACString& WindowGlobalChild::GetRemoteType() {
+  if (XRE_IsContentProcess()) {
+    return ContentChild::GetSingleton()->GetRemoteType();
+  }
+
+  return NOT_REMOTE_TYPE;
+}
+
+already_AddRefed<JSWindowActorChild> WindowGlobalChild::GetActor(
+    JSContext* aCx, const nsACString& aName, ErrorResult& aRv) {
+  return JSActorManager::GetActor(aCx, aName, aRv)
+      .downcast<JSWindowActorChild>();
+}
+
+already_AddRefed<JSWindowActorChild> WindowGlobalChild::GetExistingActor(
+    const nsACString& aName) {
+  return JSActorManager::GetExistingActor(aName).downcast<JSWindowActorChild>();
+}
+
+already_AddRefed<JSActor> WindowGlobalChild::InitJSActor(
+    JS::Handle<JSObject*> aMaybeActor, const nsACString& aName,
+    ErrorResult& aRv) {
+  RefPtr<JSWindowActorChild> actor;
+  if (aMaybeActor.get()) {
+    aRv = UNWRAP_OBJECT(JSWindowActorChild, aMaybeActor.get(), actor);
+    if (aRv.Failed()) {
+      return nullptr;
+    }
+  } else {
+    actor = new JSWindowActorChild();
+  }
+
+  MOZ_RELEASE_ASSERT(!actor->GetManager(),
+                     "mManager was already initialized once!");
+  actor->Init(aName, this);
+  return actor.forget();
+}
+
+void WindowGlobalChild::ActorDestroy(ActorDestroyReason aWhy) {
+  MOZ_ASSERT(nsContentUtils::IsSafeToRunScript(),
+             "Destroying WindowGlobalChild can run script");
+
+  // If our WindowContext hasn't been marked as discarded yet, ensure it's
+  // marked as discarded at this point.
+  mWindowContext->Discard();
+
+  profiler_unregister_page(InnerWindowId());
+
+  // Destroy our JSActors, and reject any pending queries.
+  JSActorDidDestroy();
+}
+
+bool WindowGlobalChild::IsSameOriginWith(
+    const dom::WindowContext* aOther) const {
+  if (aOther == WindowContext()) {
+    return true;
+  }
+
+  MOZ_DIAGNOSTIC_ASSERT(WindowContext()->Group() == aOther->Group());
+  if (nsGlobalWindowInner* otherWin = aOther->GetInnerWindow()) {
+    return mDocumentPrincipal->Equals(otherWin->GetPrincipal());
+  }
+  return false;
+}
+
+bool WindowGlobalChild::SameOriginWithTop() {
+  return IsSameOriginWith(WindowContext()->TopWindowContext());
+}
+
+// For historical context, see:
+//
+// Bug 13871:   Prevent frameset spoofing
+// Bug 103638:  Targets with same name in different windows open in wrong
+//              window with javascript
+// Bug 408052:  Adopt "ancestor" frame navigation policy
+// Bug 1570207: Refactor logic to rely on BrowsingContextGroups to enforce
+//              origin attribute isolation
+// Bug 1810619: Crash at null in nsDocShell::ValidateOrigin
+bool WindowGlobalChild::CanNavigate(dom::BrowsingContext* aTarget,
+                                    bool aConsiderOpener) {
+  MOZ_DIAGNOSTIC_ASSERT(WindowContext()->Group() == aTarget->Group(),
+                        "A WindowGlobalChild should never try to navigate a "
+                        "BrowsingContext from another group");
+
+  auto isFileScheme = [](nsIPrincipal* aPrincipal) -> bool {
+    // NOTE: This code previously checked for a file scheme using
+    // `nsIPrincipal::GetURI()` combined with `NS_GetInnermostURI`. We no longer
+    // use GetURI, as it has been deprecated, and it makes more sense to take
+    // advantage of the pre-computed origin, which will already use the
+    // innermost URI (bug 1810619)
+    nsAutoCString origin, scheme;
+    return NS_SUCCEEDED(aPrincipal->GetOriginNoSuffix(origin)) &&
+           NS_SUCCEEDED(net_ExtractURLScheme(origin, scheme)) &&
+           scheme == "file"_ns;
+  };
+
+  // A frame can navigate itself and its own root.
+  if (aTarget == BrowsingContext() || aTarget == BrowsingContext()->Top()) {
+    return true;
+  }
+
+  // If the target frame doesn't yet have a WindowContext, start checking
+  // principals from its direct ancestor instead. It would inherit its principal
+  // from this document upon creation.
+  dom::WindowContext* initialWc = aTarget->GetCurrentWindowContext();
+  if (!initialWc) {
+    initialWc = aTarget->GetParentWindowContext();
+  }
+
+  // A frame can navigate any frame with a same-origin ancestor.
+  bool isFileDocument = isFileScheme(DocumentPrincipal());
+  for (dom::WindowContext* wc = initialWc; wc;
+       wc = wc->GetParentWindowContext()) {
+    dom::WindowGlobalChild* wgc = wc->GetWindowGlobalChild();
+    if (!wgc) {
+      continue;  // out-of process, so not same-origin.
+    }
+
+    if (DocumentPrincipal()->Equals(wgc->DocumentPrincipal())) {
+      return true;
+    }
+
+    // Not strictly equal, special case if both are file: URIs.
+    //
+    // file: URIs are considered the same domain for the purpose of frame
+    // navigation, regardless of script accessibility (bug 420425).
+    if (isFileDocument && isFileScheme(wgc->DocumentPrincipal())) {
+      return true;
+    }
+  }
+
+  // If the target is a top-level document, a frame can navigate it if it can
+  // navigate its opener.
+  if (aConsiderOpener && !aTarget->GetParent()) {
+    if (RefPtr<dom::BrowsingContext> opener = aTarget->GetOpener()) {
+      return CanNavigate(opener, false);
+    }
+  }
+
+  return false;
+}
+
+// FindWithName follows the rules for choosing a browsing context,
+// with the exception of sandboxing for iframes. The implementation
+// for arbitrarily choosing between two browsing contexts with the
+// same name is as follows:
+//
+// 1) The start browsing context, i.e. 'this'
+// 2) Descendants in insertion order
+// 3) The parent
+// 4) Siblings and their children, both in insertion order
+// 5) After this we iteratively follow the parent chain, repeating 3
+//    and 4 until
+// 6) If there is no parent, consider all other top level browsing
+//    contexts and their children, both in insertion order
+//
+// See
+// https://html.spec.whatwg.org/multipage/browsers.html#the-rules-for-choosing-a-browsing-context-given-a-browsing-context-name
+dom::BrowsingContext* WindowGlobalChild::FindBrowsingContextWithName(
+    const nsAString& aName, bool aUseEntryGlobalForAccessCheck) {
+  RefPtr<WindowGlobalChild> requestingContext = this;
+  if (aUseEntryGlobalForAccessCheck) {
+    if (nsGlobalWindowInner* caller = nsContentUtils::EntryInnerWindow()) {
+      if (caller->GetBrowsingContextGroup() == WindowContext()->Group()) {
+        requestingContext = caller->GetWindowGlobalChild();
+      } else {
+        MOZ_RELEASE_ASSERT(caller->GetPrincipal()->IsSystemPrincipal(),
+                           "caller must be either same-group or system");
+      }
+    }
+  }
+  MOZ_ASSERT(requestingContext, "must have a requestingContext");
+
+  dom::BrowsingContext* found = nullptr;
+  if (aName.IsEmpty()) {
+    // You can't find a browsing context with an empty name.
+    found = nullptr;
+  } else if (aName.LowerCaseEqualsLiteral("_blank")) {
+    // Just return null. Caller must handle creating a new window with
+    // a blank name.
+    found = nullptr;
+  } else if (nsContentUtils::IsSpecialName(aName)) {
+    found = BrowsingContext()->FindWithSpecialName(aName, *requestingContext);
+  } else if (dom::BrowsingContext* child =
+                 BrowsingContext()->FindWithNameInSubtree(aName,
+                                                          requestingContext)) {
+    found = child;
+  } else {
+    dom::WindowContext* current = WindowContext();
+
+    do {
+      Span<RefPtr<dom::BrowsingContext>> siblings;
+      dom::WindowContext* parent = current->GetParentWindowContext();
+
+      if (!parent) {
+        // We've reached the root of the tree, consider browsing
+        // contexts in the same browsing context group.
+        siblings = WindowContext()->Group()->Toplevels();
+      } else if (dom::BrowsingContext* bc = parent->GetBrowsingContext();
+                 bc && bc->NameEquals(aName) &&
+                 requestingContext->CanNavigate(bc) && bc->IsTargetable()) {
+        found = bc;
+        break;
+      } else {
+        siblings = parent->NonSyntheticChildren();
+      }
+
+      for (dom::BrowsingContext* sibling : siblings) {
+        if (sibling == current->GetBrowsingContext()) {
+          continue;
+        }
+
+        if (dom::BrowsingContext* relative =
+                sibling->FindWithNameInSubtree(aName, requestingContext)) {
+          found = relative;
+          // Breaks the outer loop
+          parent = nullptr;
+          break;
+        }
+      }
+
+      current = parent;
+    } while (current);
+  }
+
+  // Helpers should perform access control checks, which means that we
+  // only need to assert that we can access found.
+  MOZ_DIAGNOSTIC_ASSERT(!found || requestingContext->CanNavigate(found));
+
+  return found;
+}
+
+void WindowGlobalChild::UnblockBFCacheFor(BFCacheStatus aStatus) {
+  SendUpdateBFCacheStatus(0, aStatus);
+}
+
+void WindowGlobalChild::BlockBFCacheFor(BFCacheStatus aStatus) {
+  SendUpdateBFCacheStatus(aStatus, 0);
+}
+
+WindowGlobalChild::~WindowGlobalChild() = default;
+
+JSObject* WindowGlobalChild::WrapObject(JSContext* aCx,
+                                        JS::Handle<JSObject*> aGivenProto) {
+  return WindowGlobalChild_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+nsISupports* WindowGlobalChild::GetParentObject() {
+  return xpc::NativeGlobal(xpc::PrivilegedJunkScope());
+}
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_WEAK_PTR(WindowGlobalChild, mWindowGlobal,
+                                               mContainerFeaturePolicy,
+                                               mWindowContext)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WindowGlobalChild)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(WindowGlobalChild)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(WindowGlobalChild)
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/WindowGlobalChild.h b/dom/ipc/WindowGlobalChild.h
new file mode 100644
index 0000000000..0572386788
--- /dev/null
+++ b/dom/ipc/WindowGlobalChild.h
@@ -0,0 +1,222 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=2 ts=8 et tw=80 ft=cpp : */
+/* 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/. */
+
+#ifndef mozilla_dom_WindowGlobalChild_h
+#define mozilla_dom_WindowGlobalChild_h
+
+#include "mozilla/RefPtr.h"
+#include "mozilla/WeakPtr.h"
+#include "mozilla/dom/PWindowGlobalChild.h"
+#include "nsRefPtrHashtable.h"
+#include "nsWrapperCache.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/WindowGlobalActor.h"
+
+class nsGlobalWindowInner;
+class nsDocShell;
+
+namespace mozilla::dom {
+
+class BrowsingContext;
+class FeaturePolicy;
+class WindowContext;
+class WindowGlobalParent;
+class JSWindowActorChild;
+class JSActorMessageMeta;
+class BrowserChild;
+
+/**
+ * Actor for a single nsGlobalWindowInner. This actor is used to communicate
+ * information to the parent process asynchronously.
+ */
+class WindowGlobalChild final : public WindowGlobalActor,
+                                public nsWrapperCache,
+                                public PWindowGlobalChild,
+                                public SupportsWeakPtr {
+  friend class PWindowGlobalChild;
+
+ public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(WindowGlobalChild)
+
+  static already_AddRefed<WindowGlobalChild> GetByInnerWindowId(
+      uint64_t aInnerWindowId);
+
+  static already_AddRefed<WindowGlobalChild> GetByInnerWindowId(
+      const GlobalObject& aGlobal, uint64_t aInnerWindowId) {
+    return GetByInnerWindowId(aInnerWindowId);
+  }
+
+  dom::BrowsingContext* BrowsingContext() override;
+  dom::WindowContext* WindowContext() const { return mWindowContext; }
+  nsGlobalWindowInner* GetWindowGlobal() const { return mWindowGlobal; }
+
+  // Has this actor been shut down
+  bool IsClosed() { return !CanSend(); }
+  void Destroy();
+
+  // Check if this actor is managed by PInProcess, as-in the document is loaded
+  // in the chrome process.
+  bool IsInProcess() { return XRE_IsParentProcess(); }
+
+  nsIURI* GetDocumentURI() override { return mDocumentURI; }
+  void SetDocumentURI(nsIURI* aDocumentURI);
+  // See the corresponding comment for `UpdateDocumentPrincipal` in
+  // PWindowGlobal on why and when this is allowed
+  void SetDocumentPrincipal(nsIPrincipal* aNewDocumentPrincipal,
+                            nsIPrincipal* aNewDocumentStoragePrincipal);
+
+  nsIPrincipal* DocumentPrincipal() { return mDocumentPrincipal; }
+
+  // The Window ID for this WindowGlobal
+  uint64_t InnerWindowId();
+  uint64_t OuterWindowId();
+
+  uint64_t ContentParentId();
+
+  int64_t BeforeUnloadListeners() { return mBeforeUnloadListeners; }
+  void BeforeUnloadAdded();
+  void BeforeUnloadRemoved();
+
+  bool IsCurrentGlobal();
+
+  bool IsProcessRoot();
+
+  // Get the other side of this actor if it is an in-process actor. Returns
+  // |nullptr| if the actor has been torn down, or is not in-process.
+  already_AddRefed<WindowGlobalParent> GetParentActor();
+
+  // Get this actor's manager if it is not an in-process actor. Returns
+  // |nullptr| if the actor has been torn down, or is in-process.
+  already_AddRefed<BrowserChild> GetBrowserChild();
+
+  // Get a JS actor object by name.
+  already_AddRefed<JSWindowActorChild> GetActor(JSContext* aCx,
+                                                const nsACString& aName,
+                                                ErrorResult& aRv);
+  already_AddRefed<JSWindowActorChild> GetExistingActor(
+      const nsACString& aName);
+
+  // Create and initialize the WindowGlobalChild object.
+  static already_AddRefed<WindowGlobalChild> Create(
+      nsGlobalWindowInner* aWindow);
+  static already_AddRefed<WindowGlobalChild> CreateDisconnected(
+      const WindowGlobalInit& aInit);
+
+  void Init();
+
+  void InitWindowGlobal(nsGlobalWindowInner* aWindow);
+
+  // Called when a new document is loaded in this WindowGlobalChild.
+  void OnNewDocument(Document* aNewDocument);
+
+  // Returns true if this WindowGlobal is same-origin with the given
+  // WindowContext. Out-of-process WindowContexts are supported, and are assumed
+  // to be cross-origin.
+  //
+  // The given WindowContext must be in the same BrowsingContextGroup as this
+  // window global.
+  bool IsSameOriginWith(const dom::WindowContext* aOther) const;
+
+  bool SameOriginWithTop();
+
+  // Returns `true` if this WindowGlobal is allowed to navigate the given
+  // BrowsingContext. BrowsingContexts which are currently out-of-process are
+  // supported, and assumed to be cross-origin.
+  //
+  // The given BrowsingContext must be in the same BrowsingContextGroup as this
+  // WindowGlobal.
+  bool CanNavigate(dom::BrowsingContext* aTarget, bool aConsiderOpener = true);
+
+  // Using the rules for choosing a browsing context we try to find
+  // the browsing context with the given name in the set of
+  // transitively reachable browsing contexts. Performs access control
+  // checks with regard to this.
+  // See
+  // https://html.spec.whatwg.org/multipage/browsers.html#the-rules-for-choosing-a-browsing-context-given-a-browsing-context-name.
+  dom::BrowsingContext* FindBrowsingContextWithName(
+      const nsAString& aName, bool aUseEntryGlobalForAccessCheck = true);
+
+  nsISupports* GetParentObject();
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override;
+
+  dom::FeaturePolicy* GetContainerFeaturePolicy() const {
+    return mContainerFeaturePolicy;
+  }
+
+  void UnblockBFCacheFor(BFCacheStatus aStatus);
+  void BlockBFCacheFor(BFCacheStatus aStatus);
+
+ protected:
+  const nsACString& GetRemoteType() override;
+
+  already_AddRefed<JSActor> InitJSActor(JS::Handle<JSObject*> aMaybeActor,
+                                        const nsACString& aName,
+                                        ErrorResult& aRv) override;
+  mozilla::ipc::IProtocol* AsNativeActor() override { return this; }
+
+  // IPC messages
+  mozilla::ipc::IPCResult RecvRawMessage(
+      const JSActorMessageMeta& aMeta, const Maybe<ClonedMessageData>& aData,
+      const Maybe<ClonedMessageData>& aStack);
+
+  mozilla::ipc::IPCResult RecvMakeFrameLocal(
+      const MaybeDiscarded<dom::BrowsingContext>& aFrameContext,
+      uint64_t aPendingSwitchId);
+
+  mozilla::ipc::IPCResult RecvMakeFrameRemote(
+      const MaybeDiscarded<dom::BrowsingContext>& aFrameContext,
+      ManagedEndpoint<PBrowserBridgeChild>&& aEndpoint, const TabId& aTabId,
+      const LayersId& aLayersId, MakeFrameRemoteResolver&& aResolve);
+
+  mozilla::ipc::IPCResult RecvDrawSnapshot(const Maybe<IntRect>& aRect,
+                                           const float& aScale,
+                                           const nscolor& aBackgroundColor,
+                                           const uint32_t& aFlags,
+                                           DrawSnapshotResolver&& aResolve);
+
+  mozilla::ipc::IPCResult RecvDispatchSecurityPolicyViolation(
+      const nsString& aViolationEventJSON);
+
+  mozilla::ipc::IPCResult RecvSaveStorageAccessPermissionGranted();
+
+  mozilla::ipc::IPCResult RecvAddBlockedFrameNodeByClassifier(
+      const MaybeDiscardedBrowsingContext& aNode);
+
+  mozilla::ipc::IPCResult RecvResetScalingZoom();
+
+  mozilla::ipc::IPCResult RecvSetContainerFeaturePolicy(
+      dom::FeaturePolicy* aContainerFeaturePolicy);
+
+  mozilla::ipc::IPCResult RecvRestoreDocShellState(
+      const dom::sessionstore::DocShellRestoreState& aState,
+      RestoreDocShellStateResolver&& aResolve);
+
+  // TODO: Use MOZ_CAN_RUN_SCRIPT when it gains IPDL support (bug 1539864)
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvRestoreTabContent(
+      dom::SessionStoreRestoreData* aData,
+      RestoreTabContentResolver&& aResolve);
+
+  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+
+ private:
+  WindowGlobalChild(dom::WindowContext* aWindowContext,
+                    nsIPrincipal* aPrincipal, nsIURI* aURI);
+
+  ~WindowGlobalChild();
+
+  RefPtr<nsGlobalWindowInner> mWindowGlobal;
+  RefPtr<dom::WindowContext> mWindowContext;
+  nsCOMPtr<nsIPrincipal> mDocumentPrincipal;
+  RefPtr<dom::FeaturePolicy> mContainerFeaturePolicy;
+  nsCOMPtr<nsIURI> mDocumentURI;
+  int64_t mBeforeUnloadListeners = 0;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // !defined(mozilla_dom_WindowGlobalChild_h)
diff --git a/dom/ipc/WindowGlobalParent.cpp b/dom/ipc/WindowGlobalParent.cpp
new file mode 100644
index 0000000000..0e345e9107
--- /dev/null
+++ b/dom/ipc/WindowGlobalParent.cpp
@@ -0,0 +1,1604 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=2 ts=8 et tw=80 ft=cpp : */
+/* 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 "mozilla/dom/WindowGlobalParent.h"
+
+#include <algorithm>
+
+#include "mozilla/AsyncEventDispatcher.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/ContentBlockingAllowList.h"
+#include "mozilla/dom/InProcessParent.h"
+#include "mozilla/dom/BrowserBridgeParent.h"
+#include "mozilla/dom/BrowsingContextGroup.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/dom/ClientInfo.h"
+#include "mozilla/dom/ClientIPCTypes.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/BrowserHost.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/dom/IdentityCredential.h"
+#include "mozilla/dom/MediaController.h"
+#include "mozilla/dom/WindowGlobalChild.h"
+#include "mozilla/dom/ChromeUtils.h"
+#include "mozilla/dom/ipc/IdType.h"
+#include "mozilla/dom/ipc/StructuredCloneData.h"
+#include "mozilla/Components.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/ServoCSSParser.h"
+#include "mozilla/ServoStyleSet.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/StaticPrefs_network.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/Variant.h"
+#include "nsContentUtils.h"
+#include "nsDocShell.h"
+#include "nsDocShellLoadState.h"
+#include "nsError.h"
+#include "nsFrameLoader.h"
+#include "nsFrameLoaderOwner.h"
+#include "nsGlobalWindowInner.h"
+#include "nsQueryObject.h"
+#include "nsNetUtil.h"
+#include "nsSandboxFlags.h"
+#include "nsSerializationHelper.h"
+#include "nsIBrowser.h"
+#include "nsIEffectiveTLDService.h"
+#include "nsIHttpsOnlyModePermission.h"
+#include "nsIPromptCollection.h"
+#include "nsITimer.h"
+#include "nsITransportSecurityInfo.h"
+#include "nsISharePicker.h"
+#include "nsIURIMutator.h"
+
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/DOMExceptionBinding.h"
+
+#include "mozilla/dom/JSActorService.h"
+#include "mozilla/dom/JSWindowActorBinding.h"
+#include "mozilla/dom/JSWindowActorParent.h"
+
+#include "SessionStoreFunctions.h"
+#include "nsIXPConnect.h"
+#include "nsImportModule.h"
+#include "nsIXULRuntime.h"
+
+#include "mozilla/dom/PBackgroundSessionStorageCache.h"
+
+using namespace mozilla::ipc;
+using namespace mozilla::dom::ipc;
+
+extern mozilla::LazyLogModule gSHIPBFCacheLog;
+extern mozilla::LazyLogModule gUseCountersLog;
+
+namespace mozilla::dom {
+
+WindowGlobalParent::WindowGlobalParent(
+    CanonicalBrowsingContext* aBrowsingContext, uint64_t aInnerWindowId,
+    uint64_t aOuterWindowId, FieldValues&& aInit)
+    : WindowContext(aBrowsingContext, aInnerWindowId, aOuterWindowId,
+                    std::move(aInit)),
+      mIsInitialDocument(false),
+      mSandboxFlags(0),
+      mDocumentHasLoaded(false),
+      mDocumentHasUserInteracted(false),
+      mBlockAllMixedContent(false),
+      mUpgradeInsecureRequests(false) {
+  MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess(), "Parent process only");
+}
+
+already_AddRefed<WindowGlobalParent> WindowGlobalParent::CreateDisconnected(
+    const WindowGlobalInit& aInit) {
+  RefPtr<CanonicalBrowsingContext> browsingContext =
+      CanonicalBrowsingContext::Get(aInit.context().mBrowsingContextId);
+  if (NS_WARN_IF(!browsingContext)) {
+    return nullptr;
+  }
+
+  RefPtr<WindowGlobalParent> wgp =
+      GetByInnerWindowId(aInit.context().mInnerWindowId);
+  MOZ_RELEASE_ASSERT(!wgp, "Creating duplicate WindowGlobalParent");
+
+  FieldValues fields(aInit.context().mFields);
+  wgp =
+      new WindowGlobalParent(browsingContext, aInit.context().mInnerWindowId,
+                             aInit.context().mOuterWindowId, std::move(fields));
+  wgp->mDocumentPrincipal = aInit.principal();
+  wgp->mDocumentURI = aInit.documentURI();
+  wgp->mIsInitialDocument = aInit.isInitialDocument();
+  wgp->mBlockAllMixedContent = aInit.blockAllMixedContent();
+  wgp->mUpgradeInsecureRequests = aInit.upgradeInsecureRequests();
+  wgp->mSandboxFlags = aInit.sandboxFlags();
+  wgp->mHttpsOnlyStatus = aInit.httpsOnlyStatus();
+  wgp->mSecurityInfo = aInit.securityInfo();
+  net::CookieJarSettings::Deserialize(aInit.cookieJarSettings(),
+                                      getter_AddRefs(wgp->mCookieJarSettings));
+  MOZ_RELEASE_ASSERT(wgp->mDocumentPrincipal, "Must have a valid principal");
+
+  nsresult rv = wgp->SetDocumentStoragePrincipal(aInit.storagePrincipal());
+  MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv),
+                     "Must succeed in setting storage principal");
+
+  return wgp.forget();
+}
+
+void WindowGlobalParent::Init() {
+  MOZ_ASSERT(Manager(), "Should have a manager!");
+
+  // Invoke our base class' `Init` method. This will register us in
+  // `gWindowContexts`.
+  WindowContext::Init();
+
+  // Determine which content process the window global is coming from.
+  dom::ContentParentId processId(0);
+  ContentParent* cp = nullptr;
+  if (!IsInProcess()) {
+    cp = static_cast<ContentParent*>(Manager()->Manager());
+    processId = cp->ChildID();
+
+    // Ensure the content process has permissions for this principal.
+    cp->TransmitPermissionsForPrincipal(mDocumentPrincipal);
+  }
+
+  MOZ_DIAGNOSTIC_ASSERT(
+      !BrowsingContext()->GetParent() ||
+          BrowsingContext()->GetEmbedderInnerWindowId(),
+      "When creating a non-root WindowGlobalParent, the WindowGlobalParent "
+      "for our embedder should've already been created.");
+
+  // Ensure we have a document URI
+  if (!mDocumentURI) {
+    NS_NewURI(getter_AddRefs(mDocumentURI), "about:blank");
+  }
+
+  // NOTE: `cp` may be nullptr, but that's OK, we need to tell every other
+  // process in our group in that case.
+  IPCInitializer ipcinit = GetIPCInitializer();
+  Group()->EachOtherParent(cp, [&](ContentParent* otherContent) {
+    Unused << otherContent->SendCreateWindowContext(ipcinit);
+  });
+
+  if (!BrowsingContext()->IsDiscarded()) {
+    MOZ_ALWAYS_SUCCEEDS(
+        BrowsingContext()->SetCurrentInnerWindowId(InnerWindowId()));
+
+    Unused << SendSetContainerFeaturePolicy(
+        BrowsingContext()->GetContainerFeaturePolicy());
+  }
+
+  if (BrowsingContext()->IsTopContent()) {
+    // For top level sandboxed documents we need to create a new principal
+    // from URI + OriginAttributes, since the document principal will be a
+    // NullPrincipal. See Bug 1654546.
+    if (mSandboxFlags & SANDBOXED_ORIGIN) {
+      ContentBlockingAllowList::RecomputePrincipal(
+          mDocumentURI, mDocumentPrincipal->OriginAttributesRef(),
+          getter_AddRefs(mDocContentBlockingAllowListPrincipal));
+    } else {
+      ContentBlockingAllowList::ComputePrincipal(
+          mDocumentPrincipal,
+          getter_AddRefs(mDocContentBlockingAllowListPrincipal));
+    }
+  }
+
+  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
+  if (obs) {
+    obs->NotifyObservers(ToSupports(this), "window-global-created", nullptr);
+  }
+
+  if (!BrowsingContext()->IsDiscarded() && ShouldTrackSiteOriginTelemetry()) {
+    mOriginCounter.emplace();
+    mOriginCounter->UpdateSiteOriginsFrom(this, /* aIncrease = */ true);
+  }
+}
+
+void WindowGlobalParent::OriginCounter::UpdateSiteOriginsFrom(
+    WindowGlobalParent* aParent, bool aIncrease) {
+  MOZ_RELEASE_ASSERT(aParent);
+
+  if (aParent->DocumentPrincipal()->GetIsContentPrincipal()) {
+    nsAutoCString origin;
+    aParent->DocumentPrincipal()->GetSiteOrigin(origin);
+
+    if (aIncrease) {
+      int32_t& count = mOriginMap.LookupOrInsert(origin);
+      count += 1;
+      mMaxOrigins = std::max(mMaxOrigins, mOriginMap.Count());
+    } else if (auto entry = mOriginMap.Lookup(origin)) {
+      entry.Data() -= 1;
+
+      if (entry.Data() == 0) {
+        entry.Remove();
+      }
+    }
+  }
+}
+
+void WindowGlobalParent::OriginCounter::Accumulate() {
+  mozilla::Telemetry::Accumulate(
+      mozilla::Telemetry::HistogramID::
+          FX_NUMBER_OF_UNIQUE_SITE_ORIGINS_PER_DOCUMENT,
+      mMaxOrigins);
+
+  mMaxOrigins = 0;
+  mOriginMap.Clear();
+}
+
+/* static */
+already_AddRefed<WindowGlobalParent> WindowGlobalParent::GetByInnerWindowId(
+    uint64_t aInnerWindowId) {
+  if (!XRE_IsParentProcess()) {
+    return nullptr;
+  }
+
+  return WindowContext::GetById(aInnerWindowId).downcast<WindowGlobalParent>();
+}
+
+already_AddRefed<WindowGlobalChild> WindowGlobalParent::GetChildActor() {
+  if (!CanSend()) {
+    return nullptr;
+  }
+  IProtocol* otherSide = InProcessParent::ChildActorFor(this);
+  return do_AddRef(static_cast<WindowGlobalChild*>(otherSide));
+}
+
+BrowserParent* WindowGlobalParent::GetBrowserParent() {
+  if (IsInProcess() || !CanSend()) {
+    return nullptr;
+  }
+  return static_cast<BrowserParent*>(Manager());
+}
+
+ContentParent* WindowGlobalParent::GetContentParent() {
+  if (IsInProcess() || !CanSend()) {
+    return nullptr;
+  }
+  return static_cast<ContentParent*>(Manager()->Manager());
+}
+
+already_AddRefed<nsFrameLoader> WindowGlobalParent::GetRootFrameLoader() {
+  dom::BrowsingContext* top = BrowsingContext()->Top();
+
+  RefPtr<nsFrameLoaderOwner> frameLoaderOwner =
+      do_QueryObject(top->GetEmbedderElement());
+  if (frameLoaderOwner) {
+    return frameLoaderOwner->GetFrameLoader();
+  }
+  return nullptr;
+}
+
+uint64_t WindowGlobalParent::ContentParentId() {
+  RefPtr<BrowserParent> browserParent = GetBrowserParent();
+  return browserParent ? browserParent->Manager()->ChildID() : 0;
+}
+
+int32_t WindowGlobalParent::OsPid() {
+  RefPtr<BrowserParent> browserParent = GetBrowserParent();
+  return browserParent ? browserParent->Manager()->Pid() : -1;
+}
+
+// A WindowGlobalPaernt is the root in its process if it has no parent, or its
+// embedder is in a different process.
+bool WindowGlobalParent::IsProcessRoot() {
+  if (!BrowsingContext()->GetParent()) {
+    return true;
+  }
+
+  RefPtr<WindowGlobalParent> embedder =
+      BrowsingContext()->GetEmbedderWindowGlobal();
+  if (NS_WARN_IF(!embedder)) {
+    return false;
+  }
+
+  return ContentParentId() != embedder->ContentParentId();
+}
+
+uint32_t WindowGlobalParent::ContentBlockingEvents() {
+  return GetContentBlockingLog()->GetContentBlockingEventsInLog();
+}
+
+void WindowGlobalParent::GetContentBlockingLog(nsAString& aLog) {
+  NS_ConvertUTF8toUTF16 log(GetContentBlockingLog()->Stringify());
+  aLog.Assign(std::move(log));
+}
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvLoadURI(
+    const MaybeDiscarded<dom::BrowsingContext>& aTargetBC,
+    nsDocShellLoadState* aLoadState, bool aSetNavigating) {
+  if (aTargetBC.IsNullOrDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message with dead or detached context"));
+    return IPC_OK();
+  }
+
+  if (net::SchemeIsJavascript(aLoadState->URI())) {
+    return IPC_FAIL(this, "Illegal cross-process javascript: load attempt");
+  }
+
+  RefPtr<CanonicalBrowsingContext> targetBC = aTargetBC.get_canonical();
+
+  // FIXME: For cross-process loads, we should double check CanAccess() for the
+  // source browsing context in the parent process.
+
+  if (targetBC->Group() != BrowsingContext()->Group()) {
+    return IPC_FAIL(this, "Illegal cross-group BrowsingContext load");
+  }
+
+  // FIXME: We should really initiate the load in the parent before bouncing
+  // back down to the child.
+
+  targetBC->LoadURI(aLoadState, aSetNavigating);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvInternalLoad(
+    nsDocShellLoadState* aLoadState) {
+  if (!aLoadState->Target().IsEmpty() ||
+      aLoadState->TargetBrowsingContext().IsNull()) {
+    return IPC_FAIL(this, "must already be retargeted");
+  }
+  if (aLoadState->TargetBrowsingContext().IsDiscarded()) {
+    MOZ_LOG(
+        BrowsingContext::GetLog(), LogLevel::Debug,
+        ("ParentIPC: Trying to send a message with dead or detached context"));
+    return IPC_OK();
+  }
+
+  if (net::SchemeIsJavascript(aLoadState->URI())) {
+    return IPC_FAIL(this, "Illegal cross-process javascript: load attempt");
+  }
+
+  RefPtr<CanonicalBrowsingContext> targetBC =
+      aLoadState->TargetBrowsingContext().get_canonical();
+
+  // FIXME: For cross-process loads, we should double check CanAccess() for the
+  // source browsing context in the parent process.
+
+  if (targetBC->Group() != BrowsingContext()->Group()) {
+    return IPC_FAIL(this, "Illegal cross-group BrowsingContext load");
+  }
+
+  // FIXME: We should really initiate the load in the parent before bouncing
+  // back down to the child.
+
+  targetBC->InternalLoad(aLoadState);
+  return IPC_OK();
+}
+
+IPCResult WindowGlobalParent::RecvUpdateDocumentURI(nsIURI* aURI) {
+  // XXX(nika): Assert that the URI change was one which makes sense (either
+  // about:blank -> a real URI, or a legal push/popstate URI change?)
+  mDocumentURI = aURI;
+  return IPC_OK();
+}
+
+nsresult WindowGlobalParent::SetDocumentStoragePrincipal(
+    nsIPrincipal* aNewDocumentStoragePrincipal) {
+  if (mDocumentPrincipal->Equals(aNewDocumentStoragePrincipal)) {
+    mDocumentStoragePrincipal = mDocumentPrincipal;
+    return NS_OK;
+  }
+
+  // Compare originNoSuffix to ensure it's equal.
+  nsCString noSuffix;
+  nsresult rv = mDocumentPrincipal->GetOriginNoSuffix(noSuffix);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  nsCString storageNoSuffix;
+  rv = aNewDocumentStoragePrincipal->GetOriginNoSuffix(storageNoSuffix);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  if (noSuffix != storageNoSuffix) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!mDocumentPrincipal->OriginAttributesRef().EqualsIgnoringPartitionKey(
+          aNewDocumentStoragePrincipal->OriginAttributesRef())) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mDocumentStoragePrincipal = aNewDocumentStoragePrincipal;
+  return NS_OK;
+}
+
+IPCResult WindowGlobalParent::RecvUpdateDocumentPrincipal(
+    nsIPrincipal* aNewDocumentPrincipal,
+    nsIPrincipal* aNewDocumentStoragePrincipal) {
+  if (!mDocumentPrincipal->Equals(aNewDocumentPrincipal)) {
+    return IPC_FAIL(this,
+                    "Trying to reuse WindowGlobalParent but the principal of "
+                    "the new document does not match the old one");
+  }
+  mDocumentPrincipal = aNewDocumentPrincipal;
+
+  if (NS_FAILED(SetDocumentStoragePrincipal(aNewDocumentStoragePrincipal))) {
+    return IPC_FAIL(this,
+                    "Trying to reuse WindowGlobalParent but the principal of "
+                    "the new document does not match the storage principal");
+  }
+
+  return IPC_OK();
+}
+mozilla::ipc::IPCResult WindowGlobalParent::RecvUpdateDocumentTitle(
+    const nsString& aTitle) {
+  if (mDocumentTitle.isSome() && mDocumentTitle.value() == aTitle) {
+    return IPC_OK();
+  }
+
+  mDocumentTitle = Some(aTitle);
+
+  // Send a pagetitlechanged event only for changes to the title
+  // for top-level frames.
+  if (!BrowsingContext()->IsTop()) {
+    return IPC_OK();
+  }
+
+  // Notify media controller in order to update its default metadata.
+  if (BrowsingContext()->HasCreatedMediaController()) {
+    BrowsingContext()->GetMediaController()->NotifyPageTitleChanged();
+  }
+
+  Element* frameElement = BrowsingContext()->GetEmbedderElement();
+  if (!frameElement) {
+    return IPC_OK();
+  }
+
+  AsyncEventDispatcher::RunDOMEventWhenSafe(
+      *frameElement, u"pagetitlechanged"_ns, CanBubble::eYes,
+      ChromeOnlyDispatch::eYes);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvUpdateHttpsOnlyStatus(
+    uint32_t aHttpsOnlyStatus) {
+  mHttpsOnlyStatus = aHttpsOnlyStatus;
+  return IPC_OK();
+}
+
+IPCResult WindowGlobalParent::RecvUpdateDocumentHasLoaded(
+    bool aDocumentHasLoaded) {
+  mDocumentHasLoaded = aDocumentHasLoaded;
+  return IPC_OK();
+}
+
+IPCResult WindowGlobalParent::RecvUpdateDocumentHasUserInteracted(
+    bool aDocumentHasUserInteracted) {
+  mDocumentHasUserInteracted = aDocumentHasUserInteracted;
+  return IPC_OK();
+}
+
+IPCResult WindowGlobalParent::RecvUpdateSandboxFlags(uint32_t aSandboxFlags) {
+  mSandboxFlags = aSandboxFlags;
+  return IPC_OK();
+}
+
+IPCResult WindowGlobalParent::RecvUpdateDocumentCspSettings(
+    bool aBlockAllMixedContent, bool aUpgradeInsecureRequests) {
+  mBlockAllMixedContent = aBlockAllMixedContent;
+  mUpgradeInsecureRequests = aUpgradeInsecureRequests;
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvSetClientInfo(
+    const IPCClientInfo& aIPCClientInfo) {
+  mClientInfo = Some(ClientInfo(aIPCClientInfo));
+  return IPC_OK();
+}
+
+IPCResult WindowGlobalParent::RecvDestroy() {
+  // Make a copy so that we can avoid potential iterator invalidation when
+  // calling the user-provided Destroy() methods.
+  JSActorWillDestroy();
+
+  if (CanSend()) {
+    RefPtr<BrowserParent> browserParent = GetBrowserParent();
+    if (!browserParent || !browserParent->IsDestroyed()) {
+      Unused << Send__delete__(this);
+    }
+  }
+  return IPC_OK();
+}
+
+IPCResult WindowGlobalParent::RecvRawMessage(
+    const JSActorMessageMeta& aMeta, const Maybe<ClonedMessageData>& aData,
+    const Maybe<ClonedMessageData>& aStack) {
+  Maybe<StructuredCloneData> data;
+  if (aData) {
+    data.emplace();
+    data->BorrowFromClonedMessageData(*aData);
+  }
+  Maybe<StructuredCloneData> stack;
+  if (aStack) {
+    stack.emplace();
+    stack->BorrowFromClonedMessageData(*aStack);
+  }
+  ReceiveRawMessage(aMeta, std::move(data), std::move(stack));
+  return IPC_OK();
+}
+
+const nsACString& WindowGlobalParent::GetRemoteType() {
+  if (RefPtr<BrowserParent> browserParent = GetBrowserParent()) {
+    return browserParent->Manager()->GetRemoteType();
+  }
+
+  return NOT_REMOTE_TYPE;
+}
+
+void WindowGlobalParent::NotifyContentBlockingEvent(
+    uint32_t aEvent, nsIRequest* aRequest, bool aBlocked,
+    const nsACString& aTrackingOrigin,
+    const nsTArray<nsCString>& aTrackingFullHashes,
+    const Maybe<ContentBlockingNotifier::StorageAccessPermissionGrantedReason>&
+        aReason) {
+  MOZ_ASSERT(NS_IsMainThread());
+  DebugOnly<bool> isCookiesBlocked =
+      aEvent == nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
+      aEvent == nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER ||
+      (aEvent == nsIWebProgressListener::STATE_COOKIES_BLOCKED_FOREIGN &&
+       StaticPrefs::network_cookie_rejectForeignWithExceptions_enabled());
+  MOZ_ASSERT_IF(aBlocked, aReason.isNothing());
+  MOZ_ASSERT_IF(!isCookiesBlocked, aReason.isNothing());
+  MOZ_ASSERT_IF(isCookiesBlocked && !aBlocked, aReason.isSome());
+  MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess());
+  // TODO: temporarily remove this until we find the root case of Bug 1609144
+  // MOZ_DIAGNOSTIC_ASSERT_IF(XRE_IsE10sParentProcess(), !IsInProcess());
+
+  // Return early if this WindowGlobalParent is in process.
+  if (IsInProcess()) {
+    return;
+  }
+
+  Maybe<uint32_t> event = GetContentBlockingLog()->RecordLogParent(
+      aTrackingOrigin, aEvent, aBlocked, aReason, aTrackingFullHashes);
+
+  // Notify the OnContentBlockingEvent if necessary.
+  if (event) {
+    if (auto* webProgress = GetBrowsingContext()->GetWebProgress()) {
+      webProgress->OnContentBlockingEvent(webProgress, aRequest, event.value());
+    }
+  }
+}
+
+already_AddRefed<JSWindowActorParent> WindowGlobalParent::GetActor(
+    JSContext* aCx, const nsACString& aName, ErrorResult& aRv) {
+  return JSActorManager::GetActor(aCx, aName, aRv)
+      .downcast<JSWindowActorParent>();
+}
+
+already_AddRefed<JSWindowActorParent> WindowGlobalParent::GetExistingActor(
+    const nsACString& aName) {
+  return JSActorManager::GetExistingActor(aName)
+      .downcast<JSWindowActorParent>();
+}
+
+already_AddRefed<JSActor> WindowGlobalParent::InitJSActor(
+    JS::Handle<JSObject*> aMaybeActor, const nsACString& aName,
+    ErrorResult& aRv) {
+  RefPtr<JSWindowActorParent> actor;
+  if (aMaybeActor.get()) {
+    aRv = UNWRAP_OBJECT(JSWindowActorParent, aMaybeActor.get(), actor);
+    if (aRv.Failed()) {
+      return nullptr;
+    }
+  } else {
+    actor = new JSWindowActorParent();
+  }
+
+  MOZ_RELEASE_ASSERT(!actor->GetManager(),
+                     "mManager was already initialized once!");
+  actor->Init(aName, this);
+  return actor.forget();
+}
+
+bool WindowGlobalParent::IsCurrentGlobal() {
+  if (mozilla::SessionHistoryInParent() && BrowsingContext() &&
+      BrowsingContext()->IsInBFCache()) {
+    return false;
+  }
+
+  return CanSend() && BrowsingContext()->GetCurrentWindowGlobal() == this;
+}
+
+namespace {
+
+class ShareHandler final : public PromiseNativeHandler {
+ public:
+  explicit ShareHandler(
+      mozilla::dom::WindowGlobalParent::ShareResolver&& aResolver)
+      : mResolver(std::move(aResolver)) {}
+
+  NS_DECL_ISUPPORTS
+
+ public:
+  virtual void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue,
+                                ErrorResult& aRv) override {
+    mResolver(NS_OK);
+  }
+
+  virtual void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue,
+                                ErrorResult& aRv) override {
+    if (NS_WARN_IF(!aValue.isObject())) {
+      mResolver(NS_ERROR_FAILURE);
+      return;
+    }
+
+    // nsresult is stored as Exception internally in Promise
+    JS::Rooted<JSObject*> obj(aCx, &aValue.toObject());
+    RefPtr<DOMException> unwrapped;
+    nsresult rv = UNWRAP_OBJECT(DOMException, &obj, unwrapped);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      mResolver(NS_ERROR_FAILURE);
+      return;
+    }
+
+    mResolver(unwrapped->GetResult());
+  }
+
+ private:
+  ~ShareHandler() = default;
+
+  mozilla::dom::WindowGlobalParent::ShareResolver mResolver;
+};
+
+NS_IMPL_ISUPPORTS0(ShareHandler)
+
+}  // namespace
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvGetContentBlockingEvents(
+    WindowGlobalParent::GetContentBlockingEventsResolver&& aResolver) {
+  uint32_t events = GetContentBlockingLog()->GetContentBlockingEventsInLog();
+  aResolver(events);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvUpdateCookieJarSettings(
+    const CookieJarSettingsArgs& aCookieJarSettingsArgs) {
+  net::CookieJarSettings::Deserialize(aCookieJarSettingsArgs,
+                                      getter_AddRefs(mCookieJarSettings));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvUpdateDocumentSecurityInfo(
+    nsITransportSecurityInfo* aSecurityInfo) {
+  mSecurityInfo = aSecurityInfo;
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvShare(
+    IPCWebShareData&& aData, WindowGlobalParent::ShareResolver&& aResolver) {
+  // Widget Layer handoff...
+  nsCOMPtr<nsISharePicker> sharePicker =
+      do_GetService("@mozilla.org/sharepicker;1");
+  if (!sharePicker) {
+    aResolver(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+    return IPC_OK();
+  }
+
+  // Initialize the ShareWidget
+  RefPtr<BrowserParent> parent = GetBrowserParent();
+  nsCOMPtr<mozIDOMWindowProxy> openerWindow;
+  if (parent) {
+    openerWindow = parent->GetParentWindowOuter();
+    if (!openerWindow) {
+      aResolver(NS_ERROR_FAILURE);
+      return IPC_OK();
+    }
+  }
+  sharePicker->Init(openerWindow);
+
+  // And finally share the data...
+  RefPtr<Promise> promise;
+  nsresult rv = sharePicker->Share(aData.title(), aData.text(), aData.url(),
+                                   getter_AddRefs(promise));
+  if (NS_FAILED(rv)) {
+    aResolver(rv);
+    return IPC_OK();
+  }
+
+  // Handler finally awaits response...
+  RefPtr<ShareHandler> handler = new ShareHandler(std::move(aResolver));
+  promise->AppendNativeHandler(handler);
+
+  return IPC_OK();
+}
+
+namespace {
+
+class CheckPermitUnloadRequest final : public PromiseNativeHandler,
+                                       public nsITimerCallback {
+ public:
+  CheckPermitUnloadRequest(WindowGlobalParent* aWGP, bool aHasInProcessBlocker,
+                           nsIContentViewer::PermitUnloadAction aAction,
+                           std::function<void(bool)>&& aResolver)
+      : mResolver(std::move(aResolver)),
+        mWGP(aWGP),
+        mAction(aAction),
+        mFoundBlocker(aHasInProcessBlocker) {}
+
+  void Run(ContentParent* aIgnoreProcess = nullptr, uint32_t aTimeout = 0) {
+    MOZ_ASSERT(mState == State::UNINITIALIZED);
+    mState = State::WAITING;
+
+    RefPtr<CheckPermitUnloadRequest> self(this);
+
+    AutoTArray<ContentParent*, 8> seen;
+    if (aIgnoreProcess) {
+      seen.AppendElement(aIgnoreProcess);
+    }
+
+    BrowsingContext* bc = mWGP->GetBrowsingContext();
+    bc->PreOrderWalk([&](dom::BrowsingContext* aBC) {
+      if (WindowGlobalParent* wgp =
+              aBC->Canonical()->GetCurrentWindowGlobal()) {
+        ContentParent* cp = wgp->GetContentParent();
+        if (wgp->HasBeforeUnload() && !seen.ContainsSorted(cp)) {
+          seen.InsertElementSorted(cp);
+          mPendingRequests++;
+          auto resolve = [self](bool blockNavigation) {
+            if (blockNavigation) {
+              self->mFoundBlocker = true;
+            }
+            self->ResolveRequest();
+          };
+          if (cp) {
+            cp->SendDispatchBeforeUnloadToSubtree(
+                bc, resolve, [self](auto) { self->ResolveRequest(); });
+          } else {
+            ContentChild::DispatchBeforeUnloadToSubtree(bc, resolve);
+          }
+        }
+      }
+    });
+
+    if (mPendingRequests && aTimeout) {
+      Unused << NS_NewTimerWithCallback(getter_AddRefs(mTimer), this, aTimeout,
+                                        nsITimer::TYPE_ONE_SHOT);
+    }
+
+    CheckDoneWaiting();
+  }
+
+  void ResolveRequest() {
+    mPendingRequests--;
+    CheckDoneWaiting();
+  }
+
+  NS_IMETHODIMP Notify(nsITimer* aTimer) override {
+    MOZ_ASSERT(aTimer == mTimer);
+    if (mState == State::WAITING) {
+      mState = State::TIMED_OUT;
+      CheckDoneWaiting();
+    }
+    return NS_OK;
+  }
+
+  void CheckDoneWaiting() {
+    // If we've found a blocker, we prompt immediately without waiting for
+    // further responses. The user's response applies to the entire navigation
+    // attempt, regardless of how many "beforeunload" listeners we call.
+    if (mState != State::TIMED_OUT &&
+        (mState != State::WAITING || (mPendingRequests && !mFoundBlocker))) {
+      return;
+    }
+
+    mState = State::PROMPTING;
+
+    // Clearing our reference to the timer will automatically cancel it if it's
+    // still running.
+    mTimer = nullptr;
+
+    if (!mFoundBlocker) {
+      SendReply(true);
+      return;
+    }
+
+    auto action = mAction;
+    if (StaticPrefs::dom_disable_beforeunload()) {
+      action = nsIContentViewer::eDontPromptAndUnload;
+    }
+    if (action != nsIContentViewer::ePrompt) {
+      SendReply(action == nsIContentViewer::eDontPromptAndUnload);
+      return;
+    }
+
+    // Handle any failure in prompting by aborting the navigation. See comment
+    // in nsContentViewer::PermitUnload for reasoning.
+    auto cleanup = MakeScopeExit([&]() { SendReply(false); });
+
+    if (nsCOMPtr<nsIPromptCollection> prompt =
+            do_GetService("@mozilla.org/embedcomp/prompt-collection;1")) {
+      RefPtr<Promise> promise;
+      prompt->AsyncBeforeUnloadCheck(mWGP->GetBrowsingContext(),
+                                     getter_AddRefs(promise));
+
+      if (!promise) {
+        return;
+      }
+
+      promise->AppendNativeHandler(this);
+      cleanup.release();
+    }
+  }
+
+  void SendReply(bool aAllow) {
+    MOZ_ASSERT(mState != State::REPLIED);
+    mResolver(aAllow);
+    mState = State::REPLIED;
+  }
+
+  void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue,
+                        ErrorResult& aRv) override {
+    MOZ_ASSERT(mState == State::PROMPTING);
+
+    SendReply(JS::ToBoolean(aValue));
+  }
+
+  void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue,
+                        ErrorResult& aRv) override {
+    MOZ_ASSERT(mState == State::PROMPTING);
+
+    SendReply(false);
+  }
+
+  NS_DECL_ISUPPORTS
+
+ private:
+  ~CheckPermitUnloadRequest() {
+    // We may get here without having sent a reply if the promise we're waiting
+    // on is destroyed without being resolved or rejected.
+    if (mState != State::REPLIED) {
+      SendReply(false);
+    }
+  }
+
+  enum class State : uint8_t {
+    UNINITIALIZED,
+    WAITING,
+    TIMED_OUT,
+    PROMPTING,
+    REPLIED,
+  };
+
+  std::function<void(bool)> mResolver;
+
+  RefPtr<WindowGlobalParent> mWGP;
+  nsCOMPtr<nsITimer> mTimer;
+
+  uint32_t mPendingRequests = 0;
+
+  nsIContentViewer::PermitUnloadAction mAction;
+
+  State mState = State::UNINITIALIZED;
+
+  bool mFoundBlocker = false;
+};
+
+NS_IMPL_ISUPPORTS(CheckPermitUnloadRequest, nsITimerCallback)
+
+}  // namespace
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvCheckPermitUnload(
+    bool aHasInProcessBlocker, XPCOMPermitUnloadAction aAction,
+    CheckPermitUnloadResolver&& aResolver) {
+  if (!IsCurrentGlobal()) {
+    aResolver(false);
+    return IPC_OK();
+  }
+
+  auto request = MakeRefPtr<CheckPermitUnloadRequest>(
+      this, aHasInProcessBlocker, aAction, std::move(aResolver));
+  request->Run(/* aIgnoreProcess */ GetContentParent());
+
+  return IPC_OK();
+}
+
+already_AddRefed<Promise> WindowGlobalParent::PermitUnload(
+    PermitUnloadAction aAction, uint32_t aTimeout, mozilla::ErrorResult& aRv) {
+  nsIGlobalObject* global = GetParentObject();
+  RefPtr<Promise> promise = Promise::Create(global, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  auto request = MakeRefPtr<CheckPermitUnloadRequest>(
+      this, /* aHasInProcessBlocker */ false,
+      nsIContentViewer::PermitUnloadAction(aAction),
+      [promise](bool aAllow) { promise->MaybeResolve(aAllow); });
+  request->Run(/* aIgnoreProcess */ nullptr, aTimeout);
+
+  return promise.forget();
+}
+
+void WindowGlobalParent::PermitUnload(std::function<void(bool)>&& aResolver) {
+  RefPtr<CheckPermitUnloadRequest> request = new CheckPermitUnloadRequest(
+      this, /* aHasInProcessBlocker */ false,
+      nsIContentViewer::PermitUnloadAction::ePrompt, std::move(aResolver));
+  request->Run();
+}
+
+already_AddRefed<mozilla::dom::Promise> WindowGlobalParent::DrawSnapshot(
+    const DOMRect* aRect, double aScale, const nsACString& aBackgroundColor,
+    bool aResetScrollPosition, mozilla::ErrorResult& aRv) {
+  nsIGlobalObject* global = GetParentObject();
+  RefPtr<Promise> promise = Promise::Create(global, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  nscolor color;
+  if (NS_WARN_IF(!ServoCSSParser::ComputeColor(nullptr, NS_RGB(0, 0, 0),
+                                               aBackgroundColor, &color,
+                                               nullptr, nullptr))) {
+    aRv = NS_ERROR_FAILURE;
+    return nullptr;
+  }
+
+  gfx::CrossProcessPaintFlags flags =
+      gfx::CrossProcessPaintFlags::UseHighQualityScaling;
+  if (!aRect) {
+    // If no explicit Rect was passed, we want the currently visible viewport.
+    flags |= gfx::CrossProcessPaintFlags::DrawView;
+  } else if (aResetScrollPosition) {
+    flags |= gfx::CrossProcessPaintFlags::ResetScrollPosition;
+  }
+
+  if (!gfx::CrossProcessPaint::Start(this, aRect, (float)aScale, color, flags,
+                                     promise)) {
+    aRv = NS_ERROR_FAILURE;
+    return nullptr;
+  }
+  return promise.forget();
+}
+
+void WindowGlobalParent::DrawSnapshotInternal(gfx::CrossProcessPaint* aPaint,
+                                              const Maybe<IntRect>& aRect,
+                                              float aScale,
+                                              nscolor aBackgroundColor,
+                                              uint32_t aFlags) {
+  auto promise = SendDrawSnapshot(aRect, aScale, aBackgroundColor, aFlags);
+
+  RefPtr<gfx::CrossProcessPaint> paint(aPaint);
+  RefPtr<WindowGlobalParent> wgp(this);
+  promise->Then(
+      GetMainThreadSerialEventTarget(), __func__,
+      [paint, wgp](PaintFragment&& aFragment) {
+        paint->ReceiveFragment(wgp, std::move(aFragment));
+      },
+      [paint, wgp](ResponseRejectReason&& aReason) {
+        paint->LostFragment(wgp);
+      });
+}
+
+/**
+ * Accumulated page use counter data for a given top-level content document.
+ */
+struct PageUseCounters {
+  // The number of page use counter data messages we are still waiting for.
+  uint32_t mWaiting = 0;
+
+  // Whether we have received any page use counter data.
+  bool mReceivedAny = false;
+
+  // The accumulated page use counters.
+  UseCounters mUseCounters;
+};
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvExpectPageUseCounters(
+    const MaybeDiscarded<WindowContext>& aTop) {
+  if (aTop.IsNull()) {
+    return IPC_FAIL(this, "aTop must not be null");
+  }
+
+  MOZ_LOG(gUseCountersLog, LogLevel::Debug,
+          ("Expect page use counters: WindowContext %" PRIu64 " -> %" PRIu64,
+           InnerWindowId(), aTop.ContextId()));
+
+  // We've been called to indicate that the document in our window intends
+  // to send use counter data to accumulate towards the top-level document's
+  // page use counters.  This causes us to wait for this window to go away
+  // (in WindowGlobalParent::ActorDestroy) before reporting the page use
+  // counters via Telemetry.
+  RefPtr<WindowGlobalParent> page =
+      static_cast<WindowGlobalParent*>(aTop.GetMaybeDiscarded());
+  if (!page || page->mSentPageUseCounters) {
+    MOZ_LOG(gUseCountersLog, LogLevel::Debug,
+            (" > too late, won't report page use counters for this straggler"));
+    return IPC_OK();
+  }
+
+  if (mPageUseCountersWindow) {
+    if (mPageUseCountersWindow != page) {
+      return IPC_FAIL(this,
+                      "ExpectPageUseCounters called on the same "
+                      "WindowContext with a different aTop value");
+    }
+
+    // We can get called with the same aTop value more than once, e.g. for
+    // initial about:blank documents and then subsequent "real" documents loaded
+    // into the same window.  We must note each source window only once.
+    return IPC_OK();
+  }
+
+  // Note that the top-level document must wait for one more window's use
+  // counters before reporting via Telemetry.
+  mPageUseCountersWindow = page;
+  if (!page->mPageUseCounters) {
+    page->mPageUseCounters = MakeUnique<PageUseCounters>();
+  }
+  ++page->mPageUseCounters->mWaiting;
+
+  MOZ_LOG(
+      gUseCountersLog, LogLevel::Debug,
+      (" > top-level now waiting on %d\n", page->mPageUseCounters->mWaiting));
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvAccumulatePageUseCounters(
+    const UseCounters& aUseCounters) {
+  // We've been called to accumulate use counter data into the page use counters
+  // for the document in mPageUseCountersWindow.
+
+  MOZ_LOG(
+      gUseCountersLog, LogLevel::Debug,
+      ("Accumulate page use counters: WindowContext %" PRIu64 " -> %" PRIu64,
+       InnerWindowId(),
+       mPageUseCountersWindow ? mPageUseCountersWindow->InnerWindowId() : 0));
+
+  if (!mPageUseCountersWindow || mPageUseCountersWindow->mSentPageUseCounters) {
+    MOZ_LOG(gUseCountersLog, LogLevel::Debug,
+            (" > too late, won't report page use counters for this straggler"));
+    return IPC_OK();
+  }
+
+  MOZ_ASSERT(mPageUseCountersWindow->mPageUseCounters);
+  MOZ_ASSERT(mPageUseCountersWindow->mPageUseCounters->mWaiting > 0);
+
+  mPageUseCountersWindow->mPageUseCounters->mUseCounters |= aUseCounters;
+  mPageUseCountersWindow->mPageUseCounters->mReceivedAny = true;
+  return IPC_OK();
+}
+
+// This is called on the top-level WindowGlobal, i.e. the one that is
+// accumulating the page use counters, not the (potentially descendant) window
+// that has finished providing use counter data.
+void WindowGlobalParent::FinishAccumulatingPageUseCounters() {
+  MOZ_LOG(gUseCountersLog, LogLevel::Debug,
+          ("Stop expecting page use counters: -> WindowContext %" PRIu64,
+           InnerWindowId()));
+
+  if (!mPageUseCounters) {
+    MOZ_ASSERT_UNREACHABLE("Not expecting page use counter data");
+    MOZ_LOG(gUseCountersLog, LogLevel::Debug,
+            (" > not expecting page use counter data"));
+    return;
+  }
+
+  MOZ_ASSERT(mPageUseCounters->mWaiting > 0);
+  --mPageUseCounters->mWaiting;
+
+  if (mPageUseCounters->mWaiting > 0) {
+    MOZ_LOG(gUseCountersLog, LogLevel::Debug,
+            (" > now waiting on %d", mPageUseCounters->mWaiting));
+    return;
+  }
+
+  if (mPageUseCounters->mReceivedAny) {
+    MOZ_LOG(gUseCountersLog, LogLevel::Debug,
+            (" > reporting [%s]",
+             nsContentUtils::TruncatedURLForDisplay(mDocumentURI).get()));
+
+    Maybe<nsCString> urlForLogging;
+    const bool dumpCounters = StaticPrefs::dom_use_counters_dump_page();
+    if (dumpCounters) {
+      urlForLogging.emplace(
+          nsContentUtils::TruncatedURLForDisplay(mDocumentURI));
+    }
+
+    Telemetry::Accumulate(Telemetry::TOP_LEVEL_CONTENT_DOCUMENTS_DESTROYED, 1);
+
+    for (int32_t c = 0; c < eUseCounter_Count; ++c) {
+      auto uc = static_cast<UseCounter>(c);
+      if (!mPageUseCounters->mUseCounters[uc]) {
+        continue;
+      }
+
+      auto id = static_cast<Telemetry::HistogramID>(
+          Telemetry::HistogramFirstUseCounter + uc * 2 + 1);
+      if (dumpCounters) {
+        printf_stderr("USE_COUNTER_PAGE: %s - %s\n",
+                      Telemetry::GetHistogramName(id), urlForLogging->get());
+      }
+      Telemetry::Accumulate(id, 1);
+    }
+  } else {
+    MOZ_LOG(gUseCountersLog, LogLevel::Debug,
+            (" > no page use counter data was received"));
+  }
+
+  mSentPageUseCounters = true;
+  mPageUseCounters = nullptr;
+}
+
+Element* WindowGlobalParent::GetRootOwnerElement() {
+  WindowGlobalParent* top = TopWindowContext();
+  if (!top) {
+    return nullptr;
+  }
+
+  if (IsInProcess()) {
+    return top->BrowsingContext()->GetEmbedderElement();
+  }
+
+  if (BrowserParent* parent = top->GetBrowserParent()) {
+    return parent->GetOwnerElement();
+  }
+
+  return nullptr;
+}
+
+void WindowGlobalParent::NotifySessionStoreUpdatesComplete(Element* aEmbedder) {
+  if (!aEmbedder) {
+    aEmbedder = GetRootOwnerElement();
+  }
+  if (aEmbedder) {
+    if (nsCOMPtr<nsIObserverService> obs = services::GetObserverService()) {
+      obs->NotifyWhenScriptSafe(ToSupports(aEmbedder),
+                                "browser-shutdown-tabstate-updated", nullptr);
+    }
+  }
+}
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvRequestRestoreTabContent() {
+  CanonicalBrowsingContext* bc = BrowsingContext();
+  if (bc && bc->AncestorsAreCurrent()) {
+    bc->Top()->RequestRestoreTabContent(this);
+  }
+  return IPC_OK();
+}
+
+nsCString BFCacheStatusToString(uint32_t aFlags) {
+  if (aFlags == 0) {
+    return "0"_ns;
+  }
+
+  nsCString flags;
+#define ADD_BFCACHESTATUS_TO_STRING(_flag) \
+  if (aFlags & BFCacheStatus::_flag) {     \
+    if (!flags.IsEmpty()) {                \
+      flags.Append('|');                   \
+    }                                      \
+    flags.AppendLiteral(#_flag);           \
+    aFlags &= ~BFCacheStatus::_flag;       \
+  }
+
+  ADD_BFCACHESTATUS_TO_STRING(NOT_ALLOWED);
+  ADD_BFCACHESTATUS_TO_STRING(EVENT_HANDLING_SUPPRESSED);
+  ADD_BFCACHESTATUS_TO_STRING(SUSPENDED);
+  ADD_BFCACHESTATUS_TO_STRING(UNLOAD_LISTENER);
+  ADD_BFCACHESTATUS_TO_STRING(REQUEST);
+  ADD_BFCACHESTATUS_TO_STRING(ACTIVE_GET_USER_MEDIA);
+  ADD_BFCACHESTATUS_TO_STRING(ACTIVE_PEER_CONNECTION);
+  ADD_BFCACHESTATUS_TO_STRING(CONTAINS_EME_CONTENT);
+  ADD_BFCACHESTATUS_TO_STRING(CONTAINS_MSE_CONTENT);
+  ADD_BFCACHESTATUS_TO_STRING(HAS_ACTIVE_SPEECH_SYNTHESIS);
+  ADD_BFCACHESTATUS_TO_STRING(HAS_USED_VR);
+  ADD_BFCACHESTATUS_TO_STRING(CONTAINS_REMOTE_SUBFRAMES);
+  ADD_BFCACHESTATUS_TO_STRING(NOT_ONLY_TOPLEVEL_IN_BCG);
+  ADD_BFCACHESTATUS_TO_STRING(BEFOREUNLOAD_LISTENER);
+  ADD_BFCACHESTATUS_TO_STRING(ACTIVE_LOCK);
+
+#undef ADD_BFCACHESTATUS_TO_STRING
+
+  MOZ_ASSERT(aFlags == 0,
+             "Missing stringification for enum value in BFCacheStatus.");
+  return flags;
+}
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvUpdateBFCacheStatus(
+    const uint32_t& aOnFlags, const uint32_t& aOffFlags) {
+  if (MOZ_UNLIKELY(MOZ_LOG_TEST(gSHIPBFCacheLog, LogLevel::Debug))) {
+    nsAutoCString uri("[no uri]");
+    if (mDocumentURI) {
+      uri = mDocumentURI->GetSpecOrDefault();
+    }
+    MOZ_LOG(gSHIPBFCacheLog, LogLevel::Debug,
+            ("Setting BFCache flags for %s +(%s) -(%s)", uri.get(),
+             BFCacheStatusToString(aOnFlags).get(),
+             BFCacheStatusToString(aOffFlags).get()));
+  }
+  mBFCacheStatus |= aOnFlags;
+  mBFCacheStatus &= ~aOffFlags;
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+WindowGlobalParent::RecvUpdateActivePeerConnectionStatus(bool aIsAdded) {
+  if (aIsAdded) {
+    RecvUpdateBFCacheStatus(BFCacheStatus::ACTIVE_PEER_CONNECTION, 0);
+  } else {
+    RecvUpdateBFCacheStatus(0, BFCacheStatus::ACTIVE_PEER_CONNECTION);
+  }
+
+  if (WindowGlobalParent* top = TopWindowContext()) {
+    CheckedUint32 newValue(top->mNumOfProcessesWithActivePeerConnections);
+    if (aIsAdded) {
+      ++newValue;
+    } else {
+      --newValue;
+    }
+    if (!newValue.isValid()) {
+      return IPC_FAIL(this,
+                      "mNumOfProcessesWithActivePeerConnections overflowed");
+    }
+
+    top->mNumOfProcessesWithActivePeerConnections = newValue.value();
+    Unused << top->SetHasActivePeerConnections(newValue.value() > 0);
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvSetSingleChannelId(
+    const Maybe<uint64_t>& aSingleChannelId) {
+  mSingleChannelId = aSingleChannelId;
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvSetDocumentDomain(
+    nsIURI* aDomain) {
+  if (mSandboxFlags & SANDBOXED_DOMAIN) {
+    // We're sandboxed; disallow setting domain
+    return IPC_FAIL(this, "Sandbox disallows domain setting.");
+  }
+
+  // Might need to do a featurepolicy check here, like we currently do in the
+  // child process?
+
+  nsCOMPtr<nsIURI> uri;
+  mDocumentPrincipal->GetDomain(getter_AddRefs(uri));
+  if (!uri) {
+    uri = mDocumentPrincipal->GetURI();
+    if (!uri) {
+      return IPC_OK();
+    }
+  }
+
+  if (!aDomain || !Document::IsValidDomain(uri, aDomain)) {
+    // Error: illegal domain
+    return IPC_FAIL(
+        this, "Setting domain that's not a suffix of existing domain value.");
+  }
+
+  if (Group()->IsPotentiallyCrossOriginIsolated()) {
+    return IPC_FAIL(this, "Setting domain in a cross-origin isolated BC.");
+  }
+
+  mDocumentPrincipal->SetDomain(aDomain);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult WindowGlobalParent::RecvReloadWithHttpsOnlyException() {
+  nsresult rv;
+  nsCOMPtr<nsIURI> currentUri = BrowsingContext()->Top()->GetCurrentURI();
+
+  bool isViewSource = currentUri->SchemeIs("view-source");
+
+  nsCOMPtr<nsINestedURI> nestedURI = do_QueryInterface(currentUri);
+  nsCOMPtr<nsIURI> innerURI;
+  if (isViewSource) {
+    nestedURI->GetInnerURI(getter_AddRefs(innerURI));
+  } else {
+    innerURI = currentUri;
+  }
+
+  if (!innerURI->SchemeIs("https") && !innerURI->SchemeIs("http")) {
+    return IPC_FAIL(this, "HTTPS-only mode: Illegal state");
+  }
+
+  // If the error page is within an iFrame, we create an exception for whatever
+  // scheme the top-level site is currently on, because the user wants to
+  // unbreak the iFrame and not the top-level page. When the error page shows up
+  // on a top-level request, then we replace the scheme with http, because the
+  // user wants to unbreak the whole page.
+  nsCOMPtr<nsIURI> newURI;
+  if (!BrowsingContext()->IsTop()) {
+    newURI = innerURI;
+  } else {
+    Unused << NS_MutateURI(innerURI).SetScheme("http"_ns).Finalize(
+        getter_AddRefs(newURI));
+  }
+
+  OriginAttributes originAttributes =
+      TopWindowContext()->DocumentPrincipal()->OriginAttributesRef();
+
+  originAttributes.SetFirstPartyDomain(true, newURI);
+
+  nsCOMPtr<nsIPermissionManager> permMgr =
+      components::PermissionManager::Service();
+  if (!permMgr) {
+    return IPC_FAIL(
+        this, "HTTPS-only mode: Failed to get Permission Manager service");
+  }
+
+  nsCOMPtr<nsIPrincipal> principal =
+      BasePrincipal::CreateContentPrincipal(newURI, originAttributes);
+
+  rv = permMgr->AddFromPrincipal(
+      principal, "https-only-load-insecure"_ns,
+      nsIHttpsOnlyModePermission::LOAD_INSECURE_ALLOW_SESSION,
+      nsIPermissionManager::EXPIRE_SESSION, 0);
+
+  if (NS_FAILED(rv)) {
+    return IPC_FAIL(
+        this, "HTTPS-only mode: Failed to add permission to the principal");
+  }
+
+  nsCOMPtr<nsIURI> insecureURI = newURI;
+  if (isViewSource) {
+    nsAutoCString spec;
+    MOZ_ALWAYS_SUCCEEDS(newURI->GetSpec(spec));
+    if (NS_FAILED(
+            NS_NewURI(getter_AddRefs(insecureURI), "view-source:"_ns + spec))) {
+      return IPC_FAIL(
+          this, "HTTPS-only mode: Failed to re-construct view-source URI");
+    }
+  }
+
+  RefPtr<nsDocShellLoadState> loadState = new nsDocShellLoadState(insecureURI);
+  loadState->SetTriggeringPrincipal(nsContentUtils::GetSystemPrincipal());
+  loadState->SetLoadType(LOAD_NORMAL_REPLACE);
+
+  RefPtr<CanonicalBrowsingContext> topBC = BrowsingContext()->Top();
+  topBC->LoadURI(loadState, /* setNavigating */ true);
+
+  return IPC_OK();
+}
+
+IPCResult WindowGlobalParent::RecvDiscoverIdentityCredentialFromExternalSource(
+    const IdentityCredentialRequestOptions& aOptions,
+    const DiscoverIdentityCredentialFromExternalSourceResolver& aResolver) {
+  IdentityCredential::DiscoverFromExternalSourceInMainProcess(
+      DocumentPrincipal(), this->BrowsingContext(), aOptions)
+      ->Then(
+          GetCurrentSerialEventTarget(), __func__,
+          [aResolver](const IPCIdentityCredential& aResult) {
+            return aResolver(Some(aResult));
+          },
+          [aResolver](nsresult aErr) { aResolver(Nothing()); });
+  return IPC_OK();
+}
+
+void WindowGlobalParent::ActorDestroy(ActorDestroyReason aWhy) {
+  if (GetBrowsingContext()->IsTopContent()) {
+    Telemetry::Accumulate(Telemetry::ORB_DID_EVER_BLOCK_RESPONSE,
+                          mShouldReportHasBlockedOpaqueResponse);
+  }
+
+  if (mPageUseCountersWindow) {
+    mPageUseCountersWindow->FinishAccumulatingPageUseCounters();
+    mPageUseCountersWindow = nullptr;
+  }
+
+  if (GetBrowsingContext()->IsTopContent() &&
+      !mDocumentPrincipal->SchemeIs("about")) {
+    // Record the page load
+    uint32_t pageLoaded = 1;
+    Accumulate(Telemetry::MIXED_CONTENT_UNBLOCK_COUNTER, pageLoaded);
+
+    // Record the mixed content status of the docshell in Telemetry
+    enum {
+      NO_MIXED_CONTENT = 0,  // There is no Mixed Content on the page
+      MIXED_DISPLAY_CONTENT =
+          1,  // The page attempted to load Mixed Display Content
+      MIXED_ACTIVE_CONTENT =
+          2,  // The page attempted to load Mixed Active Content
+      MIXED_DISPLAY_AND_ACTIVE_CONTENT = 3  // The page attempted to load Mixed
+                                            // Display & Mixed Active Content
+    };
+
+    bool hasMixedDisplay =
+        mSecurityState &
+        (nsIWebProgressListener::STATE_LOADED_MIXED_DISPLAY_CONTENT |
+         nsIWebProgressListener::STATE_BLOCKED_MIXED_DISPLAY_CONTENT);
+    bool hasMixedActive =
+        mSecurityState &
+        (nsIWebProgressListener::STATE_LOADED_MIXED_ACTIVE_CONTENT |
+         nsIWebProgressListener::STATE_BLOCKED_MIXED_ACTIVE_CONTENT);
+
+    uint32_t mixedContentLevel = NO_MIXED_CONTENT;
+    if (hasMixedDisplay && hasMixedActive) {
+      mixedContentLevel = MIXED_DISPLAY_AND_ACTIVE_CONTENT;
+    } else if (hasMixedActive) {
+      mixedContentLevel = MIXED_ACTIVE_CONTENT;
+    } else if (hasMixedDisplay) {
+      mixedContentLevel = MIXED_DISPLAY_CONTENT;
+    }
+    Accumulate(Telemetry::MIXED_CONTENT_PAGE_LOAD, mixedContentLevel);
+
+    if (GetDocTreeHadMedia()) {
+      ScalarAdd(Telemetry::ScalarID::MEDIA_ELEMENT_IN_PAGE_COUNT, 1);
+    }
+  }
+
+  ContentParent* cp = nullptr;
+  if (!IsInProcess()) {
+    cp = static_cast<ContentParent*>(Manager()->Manager());
+  }
+
+  Group()->EachOtherParent(cp, [&](ContentParent* otherContent) {
+    // Keep the WindowContext and our BrowsingContextGroup alive until other
+    // processes have acknowledged it has been discarded.
+    Group()->AddKeepAlive();
+    auto callback = [self = RefPtr{this}](auto) {
+      self->Group()->RemoveKeepAlive();
+    };
+    otherContent->SendDiscardWindowContext(InnerWindowId(), callback, callback);
+  });
+
+  // Note that our WindowContext has become discarded.
+  WindowContext::Discard();
+
+  // Report content blocking log when destroyed.
+  // There shouldn't have any content blocking log when a document is loaded in
+  // the parent process(See NotifyContentBlockingEvent), so we could skip
+  // reporting log when it is in-process.
+  if (!IsInProcess()) {
+    RefPtr<BrowserParent> browserParent =
+        static_cast<BrowserParent*>(Manager());
+    if (browserParent) {
+      nsCOMPtr<nsILoadContext> loadContext = browserParent->GetLoadContext();
+      if (loadContext && !loadContext->UsePrivateBrowsing() &&
+          BrowsingContext()->IsTopContent()) {
+        GetContentBlockingLog()->ReportLog(DocumentPrincipal());
+
+        if (mDocumentURI && (net::SchemeIsHTTP(mDocumentURI) ||
+                             net::SchemeIsHTTPS(mDocumentURI))) {
+          GetContentBlockingLog()->ReportEmailTrackingLog(DocumentPrincipal());
+        }
+      }
+    }
+  }
+
+  // Destroy our JSWindowActors, and reject any pending queries.
+  JSActorDidDestroy();
+
+  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
+  if (obs) {
+    obs->NotifyObservers(ToSupports(this), "window-global-destroyed", nullptr);
+  }
+
+  if (mOriginCounter) {
+    mOriginCounter->Accumulate();
+  }
+}
+
+WindowGlobalParent::~WindowGlobalParent() = default;
+
+JSObject* WindowGlobalParent::WrapObject(JSContext* aCx,
+                                         JS::Handle<JSObject*> aGivenProto) {
+  return WindowGlobalParent_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+nsIGlobalObject* WindowGlobalParent::GetParentObject() {
+  return xpc::NativeGlobal(xpc::PrivilegedJunkScope());
+}
+
+nsIDOMProcessParent* WindowGlobalParent::GetDomProcess() {
+  if (RefPtr<BrowserParent> browserParent = GetBrowserParent()) {
+    return browserParent->Manager();
+  }
+  return InProcessParent::Singleton();
+}
+
+void WindowGlobalParent::DidBecomeCurrentWindowGlobal(bool aCurrent) {
+  WindowGlobalParent* top = BrowsingContext()->GetTopWindowContext();
+  if (top && top->mOriginCounter) {
+    top->mOriginCounter->UpdateSiteOriginsFrom(this,
+                                               /* aIncrease = */ aCurrent);
+  }
+
+  if (!aCurrent && Fullscreen()) {
+    ExitTopChromeDocumentFullscreen();
+  }
+}
+
+bool WindowGlobalParent::ShouldTrackSiteOriginTelemetry() {
+  CanonicalBrowsingContext* bc = BrowsingContext();
+
+  if (!bc->IsTopContent()) {
+    return false;
+  }
+
+  RefPtr<BrowserParent> browserParent = GetBrowserParent();
+  if (!browserParent ||
+      !IsWebRemoteType(browserParent->Manager()->GetRemoteType())) {
+    return false;
+  }
+
+  return DocumentPrincipal()->GetIsContentPrincipal();
+}
+
+void WindowGlobalParent::AddSecurityState(uint32_t aStateFlags) {
+  MOZ_ASSERT(TopWindowContext() == this);
+  MOZ_ASSERT((aStateFlags &
+              (nsIWebProgressListener::STATE_LOADED_MIXED_DISPLAY_CONTENT |
+               nsIWebProgressListener::STATE_LOADED_MIXED_ACTIVE_CONTENT |
+               nsIWebProgressListener::STATE_BLOCKED_MIXED_DISPLAY_CONTENT |
+               nsIWebProgressListener::STATE_BLOCKED_MIXED_ACTIVE_CONTENT |
+               nsIWebProgressListener::STATE_HTTPS_ONLY_MODE_UPGRADED |
+               nsIWebProgressListener::STATE_HTTPS_ONLY_MODE_UPGRADE_FAILED)) ==
+                 aStateFlags,
+             "Invalid flags specified!");
+
+  if ((mSecurityState & aStateFlags) == aStateFlags) {
+    return;
+  }
+
+  mSecurityState |= aStateFlags;
+
+  if (GetBrowsingContext()->GetCurrentWindowGlobal() == this) {
+    GetBrowsingContext()->UpdateSecurityState();
+  }
+}
+
+bool WindowGlobalParent::HasActivePeerConnections() {
+  MOZ_ASSERT(TopWindowContext() == this,
+             "mNumOfProcessesWithActivePeerConnections is set only "
+             "in the top window context");
+  return mNumOfProcessesWithActivePeerConnections > 0;
+}
+
+void WindowGlobalParent::ExitTopChromeDocumentFullscreen() {
+  RefPtr<CanonicalBrowsingContext> chromeTop =
+      BrowsingContext()->TopCrossChromeBoundary();
+  if (Document* chromeDoc = chromeTop->GetDocument()) {
+    Document::ClearPendingFullscreenRequests(chromeDoc);
+    if (chromeDoc->Fullscreen()) {
+      // This only clears the DOM fullscreen, will not exit from browser UI
+      // fullscreen mode.
+      Document::AsyncExitFullscreen(chromeDoc);
+    }
+  }
+}
+
+void WindowGlobalParent::SetShouldReportHasBlockedOpaqueResponse(
+    nsContentPolicyType aContentPolicy) {
+  // It's always okay to block TYPE_BEACON, TYPE_PING and TYPE_CSP_REPORT in
+  // the parent process because content processes can do nothing to their
+  // responses. Hence excluding them from the telemetry as blocking
+  // them have no webcompat concerns.
+  if (aContentPolicy != nsIContentPolicy::TYPE_BEACON &&
+      aContentPolicy != nsIContentPolicy::TYPE_PING &&
+      aContentPolicy != nsIContentPolicy::TYPE_CSP_REPORT) {
+    if (IsTop()) {
+      mShouldReportHasBlockedOpaqueResponse = true;
+    }
+  }
+}
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(WindowGlobalParent, WindowContext,
+                                   mPageUseCountersWindow)
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(WindowGlobalParent,
+                                               WindowContext)
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WindowGlobalParent)
+NS_INTERFACE_MAP_END_INHERITING(WindowContext)
+
+NS_IMPL_ADDREF_INHERITED(WindowGlobalParent, WindowContext)
+NS_IMPL_RELEASE_INHERITED(WindowGlobalParent, WindowContext)
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/WindowGlobalParent.h b/dom/ipc/WindowGlobalParent.h
new file mode 100644
index 0000000000..de96207d0c
--- /dev/null
+++ b/dom/ipc/WindowGlobalParent.h
@@ -0,0 +1,425 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=2 ts=8 et tw=80 ft=cpp : */
+/* 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/. */
+
+#ifndef mozilla_dom_WindowGlobalParent_h
+#define mozilla_dom_WindowGlobalParent_h
+
+#include "mozilla/ContentBlockingLog.h"
+#include "mozilla/ContentBlockingNotifier.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/dom/ClientInfo.h"
+#include "mozilla/dom/ClientIPCTypes.h"
+#include "mozilla/dom/DOMRect.h"
+#include "mozilla/dom/PWindowGlobalParent.h"
+#include "mozilla/dom/WindowContext.h"
+#include "mozilla/dom/WindowGlobalActorsBinding.h"
+#include "nsTHashMap.h"
+#include "nsRefPtrHashtable.h"
+#include "nsWrapperCache.h"
+#include "nsISupports.h"
+#include "nsIDOMProcessParent.h"
+#include "mozilla/dom/WindowGlobalActor.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/net/CookieJarSettings.h"
+
+class nsIPrincipal;
+class nsIURI;
+class nsFrameLoader;
+
+namespace mozilla {
+
+namespace gfx {
+class CrossProcessPaint;
+}  // namespace gfx
+
+namespace dom {
+
+class BrowserParent;
+class WindowGlobalChild;
+class JSWindowActorParent;
+class JSActorMessageMeta;
+struct PageUseCounters;
+class WindowSessionStoreState;
+struct WindowSessionStoreUpdate;
+class SSCacheQueryResult;
+
+/**
+ * A handle in the parent process to a specific nsGlobalWindowInner object.
+ */
+class WindowGlobalParent final : public WindowContext,
+                                 public WindowGlobalActor,
+                                 public PWindowGlobalParent {
+  friend class gfx::CrossProcessPaint;
+  friend class PWindowGlobalParent;
+
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(WindowGlobalParent,
+                                                         WindowContext)
+
+  static already_AddRefed<WindowGlobalParent> GetByInnerWindowId(
+      uint64_t aInnerWindowId);
+
+  static already_AddRefed<WindowGlobalParent> GetByInnerWindowId(
+      const GlobalObject& aGlobal, uint64_t aInnerWindowId) {
+    return GetByInnerWindowId(aInnerWindowId);
+  }
+
+  // The same as the corresponding methods on `WindowContext`, except that the
+  // return types are already cast to their parent-process type variants, such
+  // as `WindowGlobalParent` or `CanonicalBrowsingContext`.
+  WindowGlobalParent* GetParentWindowContext() {
+    return static_cast<WindowGlobalParent*>(
+        WindowContext::GetParentWindowContext());
+  }
+  WindowGlobalParent* TopWindowContext() {
+    return static_cast<WindowGlobalParent*>(WindowContext::TopWindowContext());
+  }
+  CanonicalBrowsingContext* GetBrowsingContext() const {
+    return CanonicalBrowsingContext::Cast(WindowContext::GetBrowsingContext());
+  }
+
+  Element* GetRootOwnerElement();
+
+  // Has this actor been shut down
+  bool IsClosed() { return !CanSend(); }
+
+  // Get the other side of this actor if it is an in-process actor. Returns
+  // |nullptr| if the actor has been torn down, or is not in-process.
+  already_AddRefed<WindowGlobalChild> GetChildActor();
+
+  // Get a JS actor object by name.
+  already_AddRefed<JSWindowActorParent> GetActor(JSContext* aCx,
+                                                 const nsACString& aName,
+                                                 ErrorResult& aRv);
+  already_AddRefed<JSWindowActorParent> GetExistingActor(
+      const nsACString& aName);
+
+  // Get this actor's manager if it is not an in-process actor. Returns
+  // |nullptr| if the actor has been torn down, or is in-process.
+  BrowserParent* GetBrowserParent();
+
+  ContentParent* GetContentParent();
+
+  // The principal of this WindowGlobal. This value will not change over the
+  // lifetime of the WindowGlobal object, even to reflect changes in
+  // |document.domain|.
+  nsIPrincipal* DocumentPrincipal() { return mDocumentPrincipal; }
+
+  nsIPrincipal* DocumentStoragePrincipal() { return mDocumentStoragePrincipal; }
+
+  // The BrowsingContext which this WindowGlobal has been loaded into.
+  // FIXME: It's quite awkward that this method has a slightly different name
+  // than the one on WindowContext.
+  CanonicalBrowsingContext* BrowsingContext() override {
+    return GetBrowsingContext();
+  }
+
+  // Get the root nsFrameLoader object for the tree of BrowsingContext nodes
+  // which this WindowGlobal is a part of. This will be the nsFrameLoader
+  // holding the BrowserParent for remote tabs, and the root content frameloader
+  // for non-remote tabs.
+  already_AddRefed<nsFrameLoader> GetRootFrameLoader();
+
+  // The current URI which loaded in the document.
+  nsIURI* GetDocumentURI() override { return mDocumentURI; }
+
+  void GetDocumentTitle(nsAString& aTitle) const {
+    aTitle = mDocumentTitle.valueOr(nsString());
+  }
+
+  nsIPrincipal* GetContentBlockingAllowListPrincipal() const {
+    return mDocContentBlockingAllowListPrincipal;
+  }
+
+  Maybe<ClientInfo> GetClientInfo() { return mClientInfo; }
+
+  uint64_t ContentParentId();
+
+  int32_t OsPid();
+
+  bool IsCurrentGlobal();
+
+  bool IsProcessRoot();
+
+  uint32_t ContentBlockingEvents();
+
+  void GetContentBlockingLog(nsAString& aLog);
+
+  bool IsInitialDocument() { return mIsInitialDocument; }
+
+  already_AddRefed<mozilla::dom::Promise> PermitUnload(
+      PermitUnloadAction aAction, uint32_t aTimeout, mozilla::ErrorResult& aRv);
+
+  void PermitUnload(std::function<void(bool)>&& aResolver);
+
+  already_AddRefed<mozilla::dom::Promise> DrawSnapshot(
+      const DOMRect* aRect, double aScale, const nsACString& aBackgroundColor,
+      bool aResetScrollPosition, mozilla::ErrorResult& aRv);
+
+  static already_AddRefed<WindowGlobalParent> CreateDisconnected(
+      const WindowGlobalInit& aInit);
+
+  // Initialize the mFrameLoader fields for a created WindowGlobalParent. Must
+  // be called after setting the Manager actor.
+  void Init() final;
+
+  nsIGlobalObject* GetParentObject();
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override;
+
+  void NotifyContentBlockingEvent(
+      uint32_t aEvent, nsIRequest* aRequest, bool aBlocked,
+      const nsACString& aTrackingOrigin,
+      const nsTArray<nsCString>& aTrackingFullHashes,
+      const Maybe<
+          ContentBlockingNotifier::StorageAccessPermissionGrantedReason>&
+          aReason = Nothing());
+
+  ContentBlockingLog* GetContentBlockingLog() { return &mContentBlockingLog; }
+
+  nsIDOMProcessParent* GetDomProcess();
+
+  nsICookieJarSettings* CookieJarSettings() { return mCookieJarSettings; }
+
+  nsICookieJarSettings* GetCookieJarSettings() const {
+    return mCookieJarSettings;
+  }
+
+  bool DocumentHasLoaded() { return mDocumentHasLoaded; }
+
+  bool DocumentHasUserInteracted() { return mDocumentHasUserInteracted; }
+
+  uint32_t SandboxFlags() { return mSandboxFlags; }
+
+  bool GetDocumentBlockAllMixedContent() { return mBlockAllMixedContent; }
+
+  bool GetDocumentUpgradeInsecureRequests() { return mUpgradeInsecureRequests; }
+
+  void DidBecomeCurrentWindowGlobal(bool aCurrent);
+
+  uint32_t HttpsOnlyStatus() { return mHttpsOnlyStatus; }
+
+  void AddSecurityState(uint32_t aStateFlags);
+  uint32_t GetSecurityFlags() { return mSecurityState; }
+
+  nsITransportSecurityInfo* GetSecurityInfo() { return mSecurityInfo; }
+
+  const nsACString& GetRemoteType() override;
+
+  void NotifySessionStoreUpdatesComplete(Element* aEmbedder);
+
+  Maybe<uint64_t> GetSingleChannelId() { return mSingleChannelId; }
+
+  uint32_t GetBFCacheStatus() { return mBFCacheStatus; }
+
+  bool HasActivePeerConnections();
+
+  bool Fullscreen() { return mFullscreen; }
+  void SetFullscreen(bool aFullscreen) { mFullscreen = aFullscreen; }
+
+  void ExitTopChromeDocumentFullscreen();
+
+  void SetShouldReportHasBlockedOpaqueResponse(
+      nsContentPolicyType aContentPolicy);
+
+ protected:
+  already_AddRefed<JSActor> InitJSActor(JS::Handle<JSObject*> aMaybeActor,
+                                        const nsACString& aName,
+                                        ErrorResult& aRv) override;
+  mozilla::ipc::IProtocol* AsNativeActor() override { return this; }
+
+  // IPC messages
+  mozilla::ipc::IPCResult RecvLoadURI(
+      const MaybeDiscarded<dom::BrowsingContext>& aTargetBC,
+      nsDocShellLoadState* aLoadState, bool aSetNavigating);
+  mozilla::ipc::IPCResult RecvInternalLoad(nsDocShellLoadState* aLoadState);
+  mozilla::ipc::IPCResult RecvUpdateDocumentURI(nsIURI* aURI);
+  mozilla::ipc::IPCResult RecvUpdateDocumentPrincipal(
+      nsIPrincipal* aNewDocumentPrincipal,
+      nsIPrincipal* aNewDocumentStoragePrincipal);
+  mozilla::ipc::IPCResult RecvUpdateDocumentHasLoaded(bool aDocumentHasLoaded);
+  mozilla::ipc::IPCResult RecvUpdateDocumentHasUserInteracted(
+      bool aDocumentHasUserInteracted);
+  mozilla::ipc::IPCResult RecvUpdateSandboxFlags(uint32_t aSandboxFlags);
+  mozilla::ipc::IPCResult RecvUpdateDocumentCspSettings(
+      bool aBlockAllMixedContent, bool aUpgradeInsecureRequests);
+  mozilla::ipc::IPCResult RecvUpdateDocumentTitle(const nsString& aTitle);
+  mozilla::ipc::IPCResult RecvUpdateHttpsOnlyStatus(uint32_t aHttpsOnlyStatus);
+  mozilla::ipc::IPCResult RecvSetIsInitialDocument(bool aIsInitialDocument) {
+    mIsInitialDocument = aIsInitialDocument;
+    return IPC_OK();
+  }
+  mozilla::ipc::IPCResult RecvUpdateDocumentSecurityInfo(
+      nsITransportSecurityInfo* aSecurityInfo);
+  mozilla::ipc::IPCResult RecvSetClientInfo(
+      const IPCClientInfo& aIPCClientInfo);
+  mozilla::ipc::IPCResult RecvDestroy();
+  mozilla::ipc::IPCResult RecvRawMessage(
+      const JSActorMessageMeta& aMeta, const Maybe<ClonedMessageData>& aData,
+      const Maybe<ClonedMessageData>& aStack);
+
+  mozilla::ipc::IPCResult RecvGetContentBlockingEvents(
+      GetContentBlockingEventsResolver&& aResolver);
+  mozilla::ipc::IPCResult RecvUpdateCookieJarSettings(
+      const CookieJarSettingsArgs& aCookieJarSettingsArgs);
+
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  void DrawSnapshotInternal(gfx::CrossProcessPaint* aPaint,
+                            const Maybe<IntRect>& aRect, float aScale,
+                            nscolor aBackgroundColor, uint32_t aFlags);
+
+  // WebShare API - try to share
+  mozilla::ipc::IPCResult RecvShare(IPCWebShareData&& aData,
+                                    ShareResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvCheckPermitUnload(
+      bool aHasInProcessBlocker, XPCOMPermitUnloadAction aAction,
+      CheckPermitUnloadResolver&& aResolver);
+
+  mozilla::ipc::IPCResult RecvExpectPageUseCounters(
+      const MaybeDiscarded<dom::WindowContext>& aTop);
+  mozilla::ipc::IPCResult RecvAccumulatePageUseCounters(
+      const UseCounters& aUseCounters);
+
+  mozilla::ipc::IPCResult RecvRequestRestoreTabContent();
+
+  mozilla::ipc::IPCResult RecvUpdateBFCacheStatus(const uint32_t& aOnFlags,
+                                                  const uint32_t& aOffFlags);
+
+  // This IPC method is to notify the parent process that the caller process
+  // creates the first active peer connection (aIsAdded = true) or closes the
+  // last active peer connection (aIsAdded = false).
+  mozilla::ipc::IPCResult RecvUpdateActivePeerConnectionStatus(bool aIsAdded);
+
+ public:
+  mozilla::ipc::IPCResult RecvSetSingleChannelId(
+      const Maybe<uint64_t>& aSingleChannelId);
+
+  mozilla::ipc::IPCResult RecvSetDocumentDomain(nsIURI* aDomain);
+
+  mozilla::ipc::IPCResult RecvReloadWithHttpsOnlyException();
+
+  mozilla::ipc::IPCResult RecvDiscoverIdentityCredentialFromExternalSource(
+      const IdentityCredentialRequestOptions& aOptions,
+      const DiscoverIdentityCredentialFromExternalSourceResolver& aResolver);
+
+ private:
+  WindowGlobalParent(CanonicalBrowsingContext* aBrowsingContext,
+                     uint64_t aInnerWindowId, uint64_t aOuterWindowId,
+                     FieldValues&& aInit);
+
+  ~WindowGlobalParent();
+
+  bool ShouldTrackSiteOriginTelemetry();
+  void FinishAccumulatingPageUseCounters();
+
+  // Returns failure if the new storage principal cannot be validated
+  // against the current document principle.
+  nsresult SetDocumentStoragePrincipal(
+      nsIPrincipal* aNewDocumentStoragePrincipal);
+
+  // NOTE: Neither this document principal nor the document storage
+  // principal doesn't reflect possible |document.domain| mutations
+  // which may have been made in the actual document.
+  nsCOMPtr<nsIPrincipal> mDocumentPrincipal;
+  nsCOMPtr<nsIPrincipal> mDocumentStoragePrincipal;
+
+  // The principal to use for the content blocking allow list.
+  nsCOMPtr<nsIPrincipal> mDocContentBlockingAllowListPrincipal;
+
+  nsCOMPtr<nsIURI> mDocumentURI;
+  Maybe<nsString> mDocumentTitle;
+
+  bool mIsInitialDocument;
+
+  // True if this window has a "beforeunload" event listener.
+  bool mHasBeforeUnload;
+
+  // The log of all content blocking actions taken on the document related to
+  // this WindowGlobalParent. This is only stored on top-level documents and
+  // includes the activity log for all of the nested subdocuments as well.
+  ContentBlockingLog mContentBlockingLog;
+
+  uint32_t mSecurityState = 0;
+
+  Maybe<ClientInfo> mClientInfo;
+  // Fields being mirrored from the corresponding document
+  nsCOMPtr<nsICookieJarSettings> mCookieJarSettings;
+  nsCOMPtr<nsITransportSecurityInfo> mSecurityInfo;
+
+  uint32_t mSandboxFlags;
+
+  struct OriginCounter {
+    void UpdateSiteOriginsFrom(WindowGlobalParent* aParent, bool aIncrease);
+    void Accumulate();
+
+    nsTHashMap<nsCStringHashKey, int32_t> mOriginMap;
+    uint32_t mMaxOrigins = 0;
+  };
+
+  // Used to collect unique site origin telemetry.
+  //
+  // Is only Some() on top-level content windows.
+  Maybe<OriginCounter> mOriginCounter;
+
+  bool mDocumentHasLoaded;
+  bool mDocumentHasUserInteracted;
+  bool mDocumentTreeWouldPreloadResources = false;
+  bool mBlockAllMixedContent;
+  bool mUpgradeInsecureRequests;
+
+  // HTTPS-Only Mode flags
+  uint32_t mHttpsOnlyStatus;
+
+  // The window of the document whose page use counters our document's use
+  // counters will contribute to.  (If we are a top-level document, this
+  // will point to ourselves.)
+  RefPtr<WindowGlobalParent> mPageUseCountersWindow;
+
+  // Our page use counters, if we are a top-level document.
+  UniquePtr<PageUseCounters> mPageUseCounters;
+
+  // Whether we have sent our page use counters, and so should ignore any
+  // subsequent ExpectPageUseCounters calls.
+  bool mSentPageUseCounters = false;
+
+  uint32_t mBFCacheStatus = 0;
+
+  // If this WindowGlobalParent is a top window, this field indicates how many
+  // child processes have active peer connections for this window and its
+  // descendants.
+  uint32_t mNumOfProcessesWithActivePeerConnections = 0;
+
+  // mSingleChannelId records whether the loadgroup contains a single request
+  // with an id. If there is one channel in the loadgroup and it has an id then
+  // mSingleChannelId is set to Some(id) (ids are non-zero). If there is one
+  // request in the loadgroup and it's not a channel or it doesn't have an id,
+  // or there are multiple requests in the loadgroup, then mSingleChannelId is
+  // set to Some(0). If there are no requests in the loadgroup then
+  // mSingleChannelId is set to Nothing().
+  // Note: We ignore favicon loads when considering the requests in the
+  // loadgroup.
+  Maybe<uint64_t> mSingleChannelId;
+
+  // True if the current loaded document is in fullscreen.
+  bool mFullscreen = false;
+
+  bool mShouldReportHasBlockedOpaqueResponse = false;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+inline nsISupports* ToSupports(
+    mozilla::dom::WindowGlobalParent* aWindowGlobal) {
+  return static_cast<mozilla::dom::WindowContext*>(aWindowGlobal);
+}
+
+#endif  // !defined(mozilla_dom_WindowGlobalParent_h)
diff --git a/dom/ipc/WindowGlobalTypes.ipdlh b/dom/ipc/WindowGlobalTypes.ipdlh
new file mode 100644
index 0000000000..d669aa44f6
--- /dev/null
+++ b/dom/ipc/WindowGlobalTypes.ipdlh
@@ -0,0 +1,40 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */
+/* 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 "mozilla/dom/PermissionMessageUtils.h";
+include "mozilla/ipc/TransportSecurityInfoUtils.h";
+include "mozilla/ipc/URIUtils.h";
+
+include NeckoChannelParams;
+include DOMTypes;
+
+using mozilla::dom::WindowContextInitializer from "mozilla/dom/WindowContext.h";
+[RefCounted] using class nsITransportSecurityInfo from "nsITransportSecurityInfo.h";
+
+namespace mozilla {
+namespace dom {
+
+struct WindowGlobalInit
+{
+  // Fields which are synchronized to other processes are found here.
+  WindowContextInitializer context;
+
+  // Private fields only shared with the parent process.
+  nullable nsIPrincipal principal;
+  nullable nsIPrincipal storagePrincipal;
+  nullable nsIURI documentURI;
+
+  bool isInitialDocument;
+  bool blockAllMixedContent;
+  bool upgradeInsecureRequests;
+  uint32_t sandboxFlags;
+  CookieJarSettingsArgs cookieJarSettings;
+  uint32_t httpsOnlyStatus;
+  nullable nsITransportSecurityInfo securityInfo;
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/ipc/components.conf b/dom/ipc/components.conf
new file mode 100644
index 0000000000..c027392f4b
--- /dev/null
+++ b/dom/ipc/components.conf
@@ -0,0 +1,17 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+Classes = [
+    {
+        'cid': '{91fdaa4e-eba4-4ed3-831c-ce05c142822d}',
+        'contract_ids': ['@mozilla.org/login-detection-service;1'],
+        'type': 'mozilla::dom::LoginDetectionService',
+        'singleton': True,
+        'headers': ['/dom/ipc/LoginDetectionService.h'],
+        'constructor': 'mozilla::dom::LoginDetectionService::GetSingleton',
+        'processes': ProcessSelector.MAIN_PROCESS_ONLY,
+    },
+]
diff --git a/dom/ipc/jar.mn b/dom/ipc/jar.mn
new file mode 100644
index 0000000000..6c43857aea
--- /dev/null
+++ b/dom/ipc/jar.mn
@@ -0,0 +1,7 @@
+# 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/.
+
+toolkit.jar:
+        content/global/BrowserElementChild.js (../browser-element/BrowserElementChild.js)
+        content/global/BrowserElementChildPreload.js (../browser-element/BrowserElementChildPreload.js)
diff --git a/dom/ipc/jsactor/JSActor.cpp b/dom/ipc/jsactor/JSActor.cpp
new file mode 100644
index 0000000000..8ac0442a35
--- /dev/null
+++ b/dom/ipc/jsactor/JSActor.cpp
@@ -0,0 +1,503 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "mozilla/dom/JSActor.h"
+#include "mozilla/dom/JSActorBinding.h"
+
+#include "chrome/common/ipc_channel.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/FunctionRef.h"
+#include "mozilla/dom/AutoEntryScript.h"
+#include "mozilla/dom/ClonedErrorHolder.h"
+#include "mozilla/dom/ClonedErrorHolderBinding.h"
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/DOMExceptionBinding.h"
+#include "mozilla/dom/JSActorManager.h"
+#include "mozilla/dom/MessageManagerBinding.h"
+#include "mozilla/dom/PWindowGlobal.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/RootedDictionary.h"
+#include "mozilla/dom/ipc/StructuredCloneData.h"
+#include "mozilla/ProfilerMarkers.h"
+#include "js/Promise.h"
+#include "xpcprivate.h"
+#include "nsFrameMessageManager.h"
+#include "nsICrashReporter.h"
+
+namespace mozilla::dom {
+
+struct JSActorMessageMarker {
+  static constexpr Span<const char> MarkerTypeName() {
+    return MakeStringSpan("JSActorMessage");
+  }
+  static void StreamJSONMarkerData(baseprofiler::SpliceableJSONWriter& aWriter,
+                                   const ProfilerString8View& aActorName,
+                                   const ProfilerString16View& aMessageName) {
+    aWriter.StringProperty("actor", aActorName);
+    aWriter.StringProperty("name", NS_ConvertUTF16toUTF8(aMessageName));
+  }
+  static MarkerSchema MarkerTypeDisplay() {
+    using MS = MarkerSchema;
+    MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable};
+    schema.AddKeyLabelFormatSearchable(
+        "actor", "Actor Name", MS::Format::String, MS::Searchable::Searchable);
+    schema.AddKeyLabelFormatSearchable(
+        "name", "Message Name", MS::Format::String, MS::Searchable::Searchable);
+    schema.SetTooltipLabel("JSActor - {marker.name}");
+    schema.SetTableLabel(
+        "{marker.name} - [{marker.data.actor}] {marker.data.name}");
+    return schema;
+  }
+};
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(JSActor)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(JSActor)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(JSActor)
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(JSActor)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(JSActor)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mGlobal)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mWrappedJS)
+  tmp->mPendingQueries.Clear();
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(JSActor)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGlobal)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWrappedJS)
+  for (const auto& query : tmp->mPendingQueries.Values()) {
+    CycleCollectionNoteChild(cb, query.mPromise.get(), "Pending Query Promise");
+  }
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+JSActor::JSActor(nsISupports* aGlobal) {
+  mGlobal = do_QueryInterface(aGlobal);
+  if (!mGlobal) {
+    mGlobal = xpc::NativeGlobal(xpc::PrivilegedJunkScope());
+  }
+}
+
+void JSActor::StartDestroy() { mCanSend = false; }
+
+void JSActor::AfterDestroy() {
+  mCanSend = false;
+
+  // Take our queries out, in case somehow rejecting promises can trigger
+  // additions or removals.
+  const nsTHashMap<nsUint64HashKey, PendingQuery> pendingQueries =
+      std::move(mPendingQueries);
+  for (const auto& entry : pendingQueries.Values()) {
+    nsPrintfCString message(
+        "Actor '%s' destroyed before query '%s' was resolved", mName.get(),
+        NS_LossyConvertUTF16toASCII(entry.mMessageName).get());
+    entry.mPromise->MaybeRejectWithAbortError(message);
+  }
+
+  InvokeCallback(CallbackFunction::DidDestroy);
+  ClearManager();
+}
+
+void JSActor::InvokeCallback(CallbackFunction callback) {
+  MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
+
+  AutoEntryScript aes(GetParentObject(), "JSActor destroy callback");
+  JSContext* cx = aes.cx();
+  MozJSActorCallbacks callbacksHolder;
+  JS::Rooted<JS::Value> val(cx, JS::ObjectOrNullValue(GetWrapper()));
+  if (NS_WARN_IF(!callbacksHolder.Init(cx, val))) {
+    return;
+  }
+
+  // Destroy callback is optional.
+  if (callback == CallbackFunction::DidDestroy) {
+    if (callbacksHolder.mDidDestroy.WasPassed()) {
+      callbacksHolder.mDidDestroy.Value()->Call(this);
+    }
+  } else {
+    if (callbacksHolder.mActorCreated.WasPassed()) {
+      callbacksHolder.mActorCreated.Value()->Call(this);
+    }
+  }
+}
+
+nsresult JSActor::QueryInterfaceActor(const nsIID& aIID, void** aPtr) {
+  MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
+  if (!GetWrapperPreserveColor()) {
+    // If we have no preserved wrapper, we won't implement any interfaces.
+    return NS_NOINTERFACE;
+  }
+
+  if (!mWrappedJS) {
+    AutoEntryScript aes(GetParentObject(), "JSActor query interface");
+    JSContext* cx = aes.cx();
+
+    JS::Rooted<JSObject*> self(cx, GetWrapper());
+    JSAutoRealm ar(cx, self);
+
+    RefPtr<nsXPCWrappedJS> wrappedJS;
+    nsresult rv = nsXPCWrappedJS::GetNewOrUsed(
+        cx, self, NS_GET_IID(nsISupports), getter_AddRefs(wrappedJS));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    mWrappedJS = do_QueryInterface(wrappedJS);
+    MOZ_ASSERT(mWrappedJS);
+  }
+
+  return mWrappedJS->QueryInterface(aIID, aPtr);
+}
+
+void JSActor::SetName(const nsACString& aName) {
+  MOZ_ASSERT(mName.IsEmpty(), "Cannot set name twice!");
+  mName = aName;
+}
+
+void JSActor::ThrowStateErrorForGetter(const char* aName,
+                                       ErrorResult& aRv) const {
+  if (mName.IsEmpty()) {
+    aRv.ThrowInvalidStateError(nsPrintfCString(
+        "Cannot access property '%s' before actor is initialized", aName));
+  } else {
+    aRv.ThrowInvalidStateError(nsPrintfCString(
+        "Cannot access property '%s' after actor '%s' has been destroyed",
+        aName, mName.get()));
+  }
+}
+
+static Maybe<ipc::StructuredCloneData> TryClone(JSContext* aCx,
+                                                JS::Handle<JS::Value> aValue) {
+  Maybe<ipc::StructuredCloneData> data{std::in_place};
+
+  // Try to directly serialize the passed-in data, and return it to our caller.
+  IgnoredErrorResult rv;
+  data->Write(aCx, aValue, rv);
+  if (rv.Failed()) {
+    // Serialization failed, return `Nothing()` instead.
+    JS_ClearPendingException(aCx);
+    data.reset();
+  }
+  return data;
+}
+
+static Maybe<ipc::StructuredCloneData> CloneJSStack(
+    JSContext* aCx, JS::Handle<JSObject*> aStack) {
+  JS::Rooted<JS::Value> stackVal(aCx, JS::ObjectOrNullValue(aStack));
+  return TryClone(aCx, stackVal);
+}
+
+static Maybe<ipc::StructuredCloneData> CaptureJSStack(JSContext* aCx) {
+  JS::Rooted<JSObject*> stack(aCx, nullptr);
+  if (JS::IsAsyncStackCaptureEnabledForRealm(aCx) &&
+      !JS::CaptureCurrentStack(aCx, &stack)) {
+    JS_ClearPendingException(aCx);
+  }
+
+  return CloneJSStack(aCx, stack);
+}
+
+void JSActor::SendAsyncMessage(JSContext* aCx, const nsAString& aMessageName,
+                               JS::Handle<JS::Value> aObj, ErrorResult& aRv) {
+  profiler_add_marker("SendAsyncMessage", geckoprofiler::category::IPC, {},
+                      JSActorMessageMarker{}, mName, aMessageName);
+  Maybe<ipc::StructuredCloneData> data{std::in_place};
+  if (!nsFrameMessageManager::GetParamsForMessage(
+          aCx, aObj, JS::UndefinedHandleValue, *data)) {
+    aRv.ThrowDataCloneError(nsPrintfCString(
+        "Failed to serialize message '%s::%s'",
+        NS_LossyConvertUTF16toASCII(aMessageName).get(), mName.get()));
+    return;
+  }
+
+  JSActorMessageMeta meta;
+  meta.actorName() = mName;
+  meta.messageName() = aMessageName;
+  meta.kind() = JSActorMessageKind::Message;
+
+  SendRawMessage(meta, std::move(data), CaptureJSStack(aCx), aRv);
+}
+
+already_AddRefed<Promise> JSActor::SendQuery(JSContext* aCx,
+                                             const nsAString& aMessageName,
+                                             JS::Handle<JS::Value> aObj,
+                                             ErrorResult& aRv) {
+  profiler_add_marker("SendQuery", geckoprofiler::category::IPC, {},
+                      JSActorMessageMarker{}, mName, aMessageName);
+  Maybe<ipc::StructuredCloneData> data{std::in_place};
+  if (!nsFrameMessageManager::GetParamsForMessage(
+          aCx, aObj, JS::UndefinedHandleValue, *data)) {
+    aRv.ThrowDataCloneError(nsPrintfCString(
+        "Failed to serialize message '%s::%s'",
+        NS_LossyConvertUTF16toASCII(aMessageName).get(), mName.get()));
+    return nullptr;
+  }
+
+  nsIGlobalObject* global = xpc::CurrentNativeGlobal(aCx);
+  if (NS_WARN_IF(!global)) {
+    aRv.ThrowUnknownError("Unable to get current native global");
+    return nullptr;
+  }
+
+  RefPtr<Promise> promise = Promise::Create(global, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  JSActorMessageMeta meta;
+  meta.actorName() = mName;
+  meta.messageName() = aMessageName;
+  meta.queryId() = mNextQueryId++;
+  meta.kind() = JSActorMessageKind::Query;
+
+  mPendingQueries.InsertOrUpdate(meta.queryId(),
+                                 PendingQuery{promise, meta.messageName()});
+
+  SendRawMessage(meta, std::move(data), CaptureJSStack(aCx), aRv);
+  return promise.forget();
+}
+
+void JSActor::CallReceiveMessage(JSContext* aCx,
+                                 const JSActorMessageMeta& aMetadata,
+                                 JS::Handle<JS::Value> aData,
+                                 JS::MutableHandle<JS::Value> aRetVal,
+                                 ErrorResult& aRv) {
+  // The argument which we want to pass to IPC.
+  RootedDictionary<ReceiveMessageArgument> argument(aCx);
+  argument.mTarget = this;
+  argument.mName = aMetadata.messageName();
+  argument.mData = aData;
+  argument.mJson = aData;
+  argument.mSync = false;
+
+  if (GetWrapperPreserveColor()) {
+    // Invoke the actual callback.
+    JS::Rooted<JSObject*> global(aCx, JS::GetNonCCWObjectGlobal(GetWrapper()));
+    RefPtr<MessageListener> messageListener =
+        new MessageListener(GetWrapper(), global, nullptr, nullptr);
+    messageListener->ReceiveMessage(argument, aRetVal, aRv,
+                                    "JSActor receive message",
+                                    MessageListener::eRethrowExceptions);
+  } else {
+    aRv.ThrowTypeError<MSG_NOT_CALLABLE>("Property 'receiveMessage'");
+  }
+}
+
+void JSActor::ReceiveMessage(JSContext* aCx,
+                             const JSActorMessageMeta& aMetadata,
+                             JS::Handle<JS::Value> aData, ErrorResult& aRv) {
+  MOZ_ASSERT(aMetadata.kind() == JSActorMessageKind::Message);
+  profiler_add_marker("ReceiveMessage", geckoprofiler::category::IPC, {},
+                      JSActorMessageMarker{}, mName, aMetadata.messageName());
+
+  JS::Rooted<JS::Value> retval(aCx);
+  CallReceiveMessage(aCx, aMetadata, aData, &retval, aRv);
+}
+
+void JSActor::ReceiveQuery(JSContext* aCx, const JSActorMessageMeta& aMetadata,
+                           JS::Handle<JS::Value> aData, ErrorResult& aRv) {
+  MOZ_ASSERT(aMetadata.kind() == JSActorMessageKind::Query);
+  profiler_add_marker("ReceiveQuery", geckoprofiler::category::IPC, {},
+                      JSActorMessageMarker{}, mName, aMetadata.messageName());
+
+  // This promise will be resolved or rejected once the listener has been
+  // called. Our listener on this promise will then send the reply.
+  RefPtr<Promise> promise = Promise::Create(GetParentObject(), aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  RefPtr<QueryHandler> handler = new QueryHandler(this, aMetadata, promise);
+  promise->AppendNativeHandler(handler);
+
+  ErrorResult error;
+  JS::Rooted<JS::Value> retval(aCx);
+  CallReceiveMessage(aCx, aMetadata, aData, &retval, error);
+
+  // If we have a promise, resolve or reject it respectively.
+  if (error.Failed()) {
+    if (error.IsUncatchableException()) {
+      promise->MaybeRejectWithTimeoutError(
+          "Message handler threw uncatchable exception");
+    } else {
+      promise->MaybeReject(std::move(error));
+    }
+  } else {
+    promise->MaybeResolve(retval);
+  }
+  error.SuppressException();
+}
+
+void JSActor::ReceiveQueryReply(JSContext* aCx,
+                                const JSActorMessageMeta& aMetadata,
+                                JS::Handle<JS::Value> aData, ErrorResult& aRv) {
+  if (NS_WARN_IF(aMetadata.actorName() != mName)) {
+    aRv.ThrowUnknownError("Mismatched actor name for query reply");
+    return;
+  }
+
+  Maybe<PendingQuery> query = mPendingQueries.Extract(aMetadata.queryId());
+  if (NS_WARN_IF(!query)) {
+    aRv.ThrowUnknownError("Received reply for non-pending query");
+    return;
+  }
+
+  profiler_add_marker("ReceiveQueryReply", geckoprofiler::category::IPC, {},
+                      JSActorMessageMarker{}, mName, aMetadata.messageName());
+
+  Promise* promise = query->mPromise;
+  JSAutoRealm ar(aCx, promise->PromiseObj());
+  JS::RootedValue data(aCx, aData);
+  if (NS_WARN_IF(!JS_WrapValue(aCx, &data))) {
+    aRv.NoteJSContextException(aCx);
+    return;
+  }
+
+  if (aMetadata.kind() == JSActorMessageKind::QueryResolve) {
+    promise->MaybeResolve(data);
+  } else {
+    promise->MaybeReject(data);
+  }
+}
+
+void JSActor::SendRawMessageInProcess(const JSActorMessageMeta& aMeta,
+                                      Maybe<ipc::StructuredCloneData>&& aData,
+                                      Maybe<ipc::StructuredCloneData>&& aStack,
+                                      OtherSideCallback&& aGetOtherSide) {
+  MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess());
+  NS_DispatchToMainThread(NS_NewRunnableFunction(
+      "JSActor Async Message",
+      [aMeta, data{std::move(aData)}, stack{std::move(aStack)},
+       getOtherSide{std::move(aGetOtherSide)}]() mutable {
+        if (RefPtr<JSActorManager> otherSide = getOtherSide()) {
+          otherSide->ReceiveRawMessage(aMeta, std::move(data),
+                                       std::move(stack));
+        }
+      }));
+}
+
+// Native handler for our generated promise which is used to handle Queries and
+// send the reply when their promises have been resolved.
+JSActor::QueryHandler::QueryHandler(JSActor* aActor,
+                                    const JSActorMessageMeta& aMetadata,
+                                    Promise* aPromise)
+    : mActor(aActor),
+      mPromise(aPromise),
+      mMessageName(aMetadata.messageName()),
+      mQueryId(aMetadata.queryId()) {}
+
+void JSActor::QueryHandler::RejectedCallback(JSContext* aCx,
+                                             JS::Handle<JS::Value> aValue,
+                                             ErrorResult& aRv) {
+  if (!mActor) {
+    // Make sure that this rejection is reported. See comment below.
+    if (!JS::CallOriginalPromiseReject(aCx, aValue)) {
+      JS_ClearPendingException(aCx);
+    }
+    return;
+  }
+
+  JS::Rooted<JS::Value> value(aCx, aValue);
+  if (value.isObject()) {
+    JS::Rooted<JSObject*> error(aCx, &value.toObject());
+    if (RefPtr<ClonedErrorHolder> ceh =
+            ClonedErrorHolder::Create(aCx, error, IgnoreErrors())) {
+      JS::RootedObject obj(aCx);
+      // Note: We can't use `ToJSValue` here because ClonedErrorHolder isn't
+      // wrapper cached.
+      if (ceh->WrapObject(aCx, nullptr, &obj)) {
+        value.setObject(*obj);
+      } else {
+        JS_ClearPendingException(aCx);
+      }
+    } else {
+      JS_ClearPendingException(aCx);
+    }
+  }
+
+  Maybe<ipc::StructuredCloneData> data = TryClone(aCx, value);
+  if (!data) {
+    // Failed to clone the rejection value. Make sure that this
+    // rejection is reported, despite being "handled". This is done by
+    // creating a new promise in the rejected state, and throwing it
+    // away. This will be reported as an unhandled rejected promise.
+    if (!JS::CallOriginalPromiseReject(aCx, aValue)) {
+      JS_ClearPendingException(aCx);
+    }
+  }
+
+  SendReply(aCx, JSActorMessageKind::QueryReject, std::move(data));
+}
+
+void JSActor::QueryHandler::ResolvedCallback(JSContext* aCx,
+                                             JS::Handle<JS::Value> aValue,
+                                             ErrorResult& aRv) {
+  if (!mActor) {
+    return;
+  }
+
+  Maybe<ipc::StructuredCloneData> data{std::in_place};
+  data->InitScope(JS::StructuredCloneScope::DifferentProcess);
+
+  IgnoredErrorResult error;
+  data->Write(aCx, aValue, error);
+  if (NS_WARN_IF(error.Failed())) {
+    JS_ClearPendingException(aCx);
+
+    nsAutoCString msg;
+    msg.Append(mActor->Name());
+    msg.Append(':');
+    msg.Append(NS_LossyConvertUTF16toASCII(mMessageName));
+    msg.AppendLiteral(": message reply cannot be cloned.");
+
+    auto exc = MakeRefPtr<Exception>(msg, NS_ERROR_FAILURE, "DataCloneError"_ns,
+                                     nullptr, nullptr);
+
+    JS::Rooted<JS::Value> val(aCx);
+    if (ToJSValue(aCx, exc, &val)) {
+      RejectedCallback(aCx, val, aRv);
+    } else {
+      JS_ClearPendingException(aCx);
+    }
+    return;
+  }
+
+  SendReply(aCx, JSActorMessageKind::QueryResolve, std::move(data));
+}
+
+void JSActor::QueryHandler::SendReply(JSContext* aCx, JSActorMessageKind aKind,
+                                      Maybe<ipc::StructuredCloneData>&& aData) {
+  MOZ_ASSERT(mActor);
+  profiler_add_marker("SendQueryReply", geckoprofiler::category::IPC, {},
+                      JSActorMessageMarker{}, mActor->Name(), mMessageName);
+
+  JSActorMessageMeta meta;
+  meta.actorName() = mActor->Name();
+  meta.messageName() = mMessageName;
+  meta.queryId() = mQueryId;
+  meta.kind() = aKind;
+
+  JS::Rooted<JSObject*> promise(aCx, mPromise->PromiseObj());
+  JS::Rooted<JSObject*> stack(aCx, JS::GetPromiseResolutionSite(promise));
+
+  mActor->SendRawMessage(meta, std::move(aData), CloneJSStack(aCx, stack),
+                         IgnoreErrors());
+  mActor = nullptr;
+  mPromise = nullptr;
+}
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(JSActor::QueryHandler)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(JSActor::QueryHandler)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(JSActor::QueryHandler)
+
+NS_IMPL_CYCLE_COLLECTION(JSActor::QueryHandler, mActor, mPromise)
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/jsactor/JSActor.h b/dom/ipc/jsactor/JSActor.h
new file mode 100644
index 0000000000..54af93d1ce
--- /dev/null
+++ b/dom/ipc/jsactor/JSActor.h
@@ -0,0 +1,173 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef mozilla_dom_JSActor_h
+#define mozilla_dom_JSActor_h
+
+#include "js/TypeDecls.h"
+#include "ipc/EnumSerializer.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/PromiseNativeHandler.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsTHashMap.h"
+#include "nsWrapperCache.h"
+
+class nsIGlobalObject;
+class nsQueryJSActor;
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+namespace ipc {
+class StructuredCloneData;
+}
+
+class JSActorManager;
+class JSActorMessageMeta;
+class QueryPromiseHandler;
+
+enum class JSActorMessageKind {
+  Message,
+  Query,
+  QueryResolve,
+  QueryReject,
+  EndGuard_,
+};
+
+// Common base class for JSWindowActor{Parent,Child}.
+class JSActor : public nsISupports, public nsWrapperCache {
+ public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(JSActor)
+
+  explicit JSActor(nsISupports* aGlobal = nullptr);
+
+  const nsCString& Name() const { return mName; }
+  void GetName(nsCString& aName) { aName = Name(); }
+
+  void SendAsyncMessage(JSContext* aCx, const nsAString& aMessageName,
+                        JS::Handle<JS::Value> aObj, ErrorResult& aRv);
+
+  already_AddRefed<Promise> SendQuery(JSContext* aCx,
+                                      const nsAString& aMessageName,
+                                      JS::Handle<JS::Value> aObj,
+                                      ErrorResult& aRv);
+
+  nsIGlobalObject* GetParentObject() const { return mGlobal; };
+
+ protected:
+  // Send the message described by the structured clone data |aData|, and the
+  // message metadata |aMetadata|. The underlying transport should call the
+  // |ReceiveMessage| method on the other side asynchronously.
+  virtual void SendRawMessage(const JSActorMessageMeta& aMetadata,
+                              Maybe<ipc::StructuredCloneData>&& aData,
+                              Maybe<ipc::StructuredCloneData>&& aStack,
+                              ErrorResult& aRv) = 0;
+
+  // Helper method to send an in-process raw message.
+  using OtherSideCallback = std::function<already_AddRefed<JSActorManager>()>;
+  static void SendRawMessageInProcess(const JSActorMessageMeta& aMeta,
+                                      Maybe<ipc::StructuredCloneData>&& aData,
+                                      Maybe<ipc::StructuredCloneData>&& aStack,
+                                      OtherSideCallback&& aGetOtherSide);
+
+  virtual ~JSActor() = default;
+
+  void SetName(const nsACString& aName);
+
+  bool CanSend() const { return mCanSend; }
+
+  void ThrowStateErrorForGetter(const char* aName, ErrorResult& aRv) const;
+
+  void StartDestroy();
+  void AfterDestroy();
+
+  enum class CallbackFunction { DidDestroy, ActorCreated };
+  void InvokeCallback(CallbackFunction callback);
+
+  virtual void ClearManager() = 0;
+
+ private:
+  friend class JSActorManager;
+  friend class ::nsQueryJSActor;  // for QueryInterfaceActor
+
+  nsresult QueryInterfaceActor(const nsIID& aIID, void** aPtr);
+
+  // Called by JSActorManager when they receive raw message data destined for
+  // this actor.
+  void ReceiveMessage(JSContext* aCx, const JSActorMessageMeta& aMetadata,
+                      JS::Handle<JS::Value> aData, ErrorResult& aRv);
+  void ReceiveQuery(JSContext* aCx, const JSActorMessageMeta& aMetadata,
+                    JS::Handle<JS::Value> aData, ErrorResult& aRv);
+  void ReceiveQueryReply(JSContext* aCx, const JSActorMessageMeta& aMetadata,
+                         JS::Handle<JS::Value> aData, ErrorResult& aRv);
+
+  // Call the actual `ReceiveMessage` method, and get the return value.
+  void CallReceiveMessage(JSContext* aCx, const JSActorMessageMeta& aMetadata,
+                          JS::Handle<JS::Value> aData,
+                          JS::MutableHandle<JS::Value> aRetVal,
+                          ErrorResult& aRv);
+
+  // Helper object used while processing query messages to send the final reply
+  // message.
+  class QueryHandler final : public PromiseNativeHandler {
+   public:
+    NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+    NS_DECL_CYCLE_COLLECTION_CLASS(QueryHandler)
+
+    QueryHandler(JSActor* aActor, const JSActorMessageMeta& aMetadata,
+                 Promise* aPromise);
+
+    void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue,
+                          ErrorResult& aRv) override;
+
+    void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue,
+                          ErrorResult& aRv) override;
+
+   private:
+    ~QueryHandler() = default;
+
+    void SendReply(JSContext* aCx, JSActorMessageKind aKind,
+                   Maybe<ipc::StructuredCloneData>&& aData);
+
+    RefPtr<JSActor> mActor;
+    RefPtr<Promise> mPromise;
+    nsString mMessageName;
+    uint64_t mQueryId;
+  };
+
+  // A query which hasn't been resolved yet, along with metadata about what
+  // query the promise is for.
+  struct PendingQuery {
+    RefPtr<Promise> mPromise;
+    nsString mMessageName;
+  };
+
+  nsCOMPtr<nsIGlobalObject> mGlobal;
+  nsCOMPtr<nsISupports> mWrappedJS;
+  nsCString mName;
+  nsTHashMap<nsUint64HashKey, PendingQuery> mPendingQueries;
+  uint64_t mNextQueryId = 0;
+  bool mCanSend = true;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+namespace IPC {
+
+template <>
+struct ParamTraits<mozilla::dom::JSActorMessageKind>
+    : public ContiguousEnumSerializer<
+          mozilla::dom::JSActorMessageKind,
+          mozilla::dom::JSActorMessageKind::Message,
+          mozilla::dom::JSActorMessageKind::EndGuard_> {};
+
+}  // namespace IPC
+
+#endif  // !defined(mozilla_dom_JSActor_h)
diff --git a/dom/ipc/jsactor/JSActorManager.cpp b/dom/ipc/jsactor/JSActorManager.cpp
new file mode 100644
index 0000000000..237c00f3a4
--- /dev/null
+++ b/dom/ipc/jsactor/JSActorManager.cpp
@@ -0,0 +1,250 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "mozilla/dom/JSActorManager.h"
+
+#include "mozilla/dom/AutoEntryScript.h"
+#include "mozilla/dom/JSActorService.h"
+#include "mozilla/dom/PWindowGlobal.h"
+#include "mozilla/ipc/ProtocolUtils.h"
+#include "mozilla/AppShutdown.h"
+#include "mozilla/CycleCollectedJSRuntime.h"
+#include "mozilla/ScopeExit.h"
+#include "mozJSModuleLoader.h"
+#include "jsapi.h"
+#include "js/CallAndConstruct.h"    // JS::Construct
+#include "js/PropertyAndElement.h"  // JS_GetProperty
+#include "nsContentUtils.h"
+
+namespace mozilla::dom {
+
+already_AddRefed<JSActor> JSActorManager::GetActor(JSContext* aCx,
+                                                   const nsACString& aName,
+                                                   ErrorResult& aRv) {
+  MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
+
+  // If our connection has been closed, return an error.
+  mozilla::ipc::IProtocol* nativeActor = AsNativeActor();
+  if (!nativeActor->CanSend()) {
+    aRv.ThrowInvalidStateError(nsPrintfCString(
+        "Cannot get actor '%s'. Native '%s' actor is destroyed.",
+        PromiseFlatCString(aName).get(), nativeActor->GetProtocolName()));
+    return nullptr;
+  }
+
+  // Check if this actor has already been created, and return it if it has.
+  if (RefPtr<JSActor> actor = mJSActors.Get(aName)) {
+    return actor.forget();
+  }
+
+  RefPtr<JSActorService> actorSvc = JSActorService::GetSingleton();
+  if (!actorSvc) {
+    aRv.ThrowInvalidStateError("JSActorService hasn't been initialized");
+    return nullptr;
+  }
+
+  // Check if this actor satisfies the requirements of the protocol
+  // corresponding to `aName`, and get the module which implements it.
+  RefPtr<JSActorProtocol> protocol =
+      MatchingJSActorProtocol(actorSvc, aName, aRv);
+  if (!protocol) {
+    return nullptr;
+  }
+
+  bool isParent = nativeActor->GetSide() == mozilla::ipc::ParentSide;
+  auto& side = isParent ? protocol->Parent() : protocol->Child();
+
+  // We're about to construct the actor, so make sure we're in the JSM realm
+  // while importing etc.
+  JSAutoRealm ar(aCx, xpc::PrivilegedJunkScope());
+
+  // Load the module using mozJSModuleLoader.
+  RefPtr loader = mozJSModuleLoader::Get();
+  MOZ_ASSERT(loader);
+
+  // If a module URI was provided, use it to construct an instance of the actor.
+  JS::Rooted<JSObject*> actorObj(aCx);
+  if (side.mModuleURI || side.mESModuleURI) {
+    JS::Rooted<JSObject*> exports(aCx);
+    if (side.mModuleURI) {
+      JS::Rooted<JSObject*> global(aCx);
+      aRv = loader->Import(aCx, side.mModuleURI.ref(), &global, &exports);
+      if (aRv.Failed()) {
+        return nullptr;
+      }
+    } else {
+      aRv = loader->ImportESModule(aCx, side.mESModuleURI.ref(), &exports);
+      if (aRv.Failed()) {
+        return nullptr;
+      }
+    }
+    MOZ_ASSERT(exports, "null exports!");
+
+    // Load the specific property from our module.
+    JS::Rooted<JS::Value> ctor(aCx);
+    nsAutoCString ctorName(aName);
+    ctorName.Append(isParent ? "Parent"_ns : "Child"_ns);
+    if (!JS_GetProperty(aCx, exports, ctorName.get(), &ctor)) {
+      aRv.NoteJSContextException(aCx);
+      return nullptr;
+    }
+
+    if (NS_WARN_IF(!ctor.isObject())) {
+      aRv.ThrowNotFoundError(nsPrintfCString(
+          "Could not find actor constructor '%s'", ctorName.get()));
+      return nullptr;
+    }
+
+    // Invoke the constructor loaded from the module.
+    if (!JS::Construct(aCx, ctor, JS::HandleValueArray::empty(), &actorObj)) {
+      aRv.NoteJSContextException(aCx);
+      return nullptr;
+    }
+  }
+
+  // Initialize our newly-constructed actor, and return it.
+  RefPtr<JSActor> actor = InitJSActor(actorObj, aName, aRv);
+  if (aRv.Failed()) {
+    return nullptr;
+  }
+  mJSActors.InsertOrUpdate(aName, RefPtr{actor});
+  return actor.forget();
+}
+
+already_AddRefed<JSActor> JSActorManager::GetExistingActor(
+    const nsACString& aName) {
+  if (!AsNativeActor()->CanSend()) {
+    return nullptr;
+  }
+  return mJSActors.Get(aName);
+}
+
+#define CHILD_DIAGNOSTIC_ASSERT(test, msg) \
+  do {                                     \
+    if (XRE_IsParentProcess()) {           \
+      MOZ_ASSERT(test, msg);               \
+    } else {                               \
+      MOZ_DIAGNOSTIC_ASSERT(test, msg);    \
+    }                                      \
+  } while (0)
+
+void JSActorManager::ReceiveRawMessage(
+    const JSActorMessageMeta& aMetadata,
+    Maybe<ipc::StructuredCloneData>&& aData,
+    Maybe<ipc::StructuredCloneData>&& aStack) {
+  MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
+
+  CrashReporter::AutoAnnotateCrashReport autoActorName(
+      CrashReporter::Annotation::JSActorName, aMetadata.actorName());
+  CrashReporter::AutoAnnotateCrashReport autoMessageName(
+      CrashReporter::Annotation::JSActorMessage,
+      NS_LossyConvertUTF16toASCII(aMetadata.messageName()));
+
+  // We're going to be running JS. Enter the privileged junk realm so we can set
+  // up our JS state correctly.
+  AutoEntryScript aes(xpc::PrivilegedJunkScope(), "JSActor message handler");
+  JSContext* cx = aes.cx();
+
+  // Ensure any errors reported to `error` are set on the scope, so they're
+  // reported.
+  ErrorResult error;
+  auto autoSetException =
+      MakeScopeExit([&] { Unused << error.MaybeSetPendingException(cx); });
+
+  // If an async stack was provided, set up our async stack state.
+  JS::Rooted<JSObject*> stack(cx);
+  Maybe<JS::AutoSetAsyncStackForNewCalls> stackSetter;
+  {
+    JS::Rooted<JS::Value> stackVal(cx);
+    if (aStack) {
+      aStack->Read(cx, &stackVal, error);
+      if (error.Failed()) {
+        error.SuppressException();
+        JS_ClearPendingException(cx);
+        stackVal.setUndefined();
+      }
+    }
+
+    if (stackVal.isObject()) {
+      stack = &stackVal.toObject();
+      if (!js::IsSavedFrame(stack)) {
+        CHILD_DIAGNOSTIC_ASSERT(false, "Stack must be a SavedFrame object");
+        error.ThrowDataError("Actor async stack must be a SavedFrame object");
+        return;
+      }
+      stackSetter.emplace(cx, stack, "JSActor query");
+    }
+  }
+
+  RefPtr<JSActor> actor = GetActor(cx, aMetadata.actorName(), error);
+  if (error.Failed()) {
+    return;
+  }
+
+  JS::Rooted<JS::Value> data(cx);
+  if (aData) {
+    aData->Read(cx, &data, error);
+    if (error.Failed()) {
+      CHILD_DIAGNOSTIC_ASSERT(CycleCollectedJSRuntime::Get()->OOMReported(),
+                              "Should not receive non-decodable data");
+      return;
+    }
+  }
+
+  switch (aMetadata.kind()) {
+    case JSActorMessageKind::QueryResolve:
+    case JSActorMessageKind::QueryReject:
+      actor->ReceiveQueryReply(cx, aMetadata, data, error);
+      break;
+
+    case JSActorMessageKind::Message:
+      actor->ReceiveMessage(cx, aMetadata, data, error);
+      break;
+
+    case JSActorMessageKind::Query:
+      actor->ReceiveQuery(cx, aMetadata, data, error);
+      break;
+
+    default:
+      MOZ_ASSERT_UNREACHABLE();
+  }
+}
+
+void JSActorManager::JSActorWillDestroy() {
+  for (const auto& entry : mJSActors.Values()) {
+    entry->StartDestroy();
+  }
+}
+
+void JSActorManager::JSActorDidDestroy() {
+  MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
+  CrashReporter::AutoAnnotateCrashReport autoMessageName(
+      CrashReporter::Annotation::JSActorMessage, "<DidDestroy>"_ns);
+
+  // Swap the table with `mJSActors` so that we don't invalidate it while
+  // iterating.
+  const nsRefPtrHashtable<nsCStringHashKey, JSActor> actors =
+      std::move(mJSActors);
+  for (const auto& entry : actors.Values()) {
+    CrashReporter::AutoAnnotateCrashReport autoActorName(
+        CrashReporter::Annotation::JSActorName, entry->Name());
+    // Do not risk to run script very late in shutdown
+    if (!AppShutdown::IsInOrBeyond(ShutdownPhase::XPCOMShutdownFinal)) {
+      entry->AfterDestroy();
+    }
+  }
+}
+
+void JSActorManager::JSActorUnregister(const nsACString& aName) {
+  MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
+
+  RefPtr<JSActor> actor;
+  if (mJSActors.Remove(aName, getter_AddRefs(actor))) {
+    actor->AfterDestroy();
+  }
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/jsactor/JSActorManager.h b/dom/ipc/jsactor/JSActorManager.h
new file mode 100644
index 0000000000..86efa9d7af
--- /dev/null
+++ b/dom/ipc/jsactor/JSActorManager.h
@@ -0,0 +1,100 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_JSActorManager_h
+#define mozilla_dom_JSActorManager_h
+
+#include "js/TypeDecls.h"
+#include "mozilla/dom/JSActor.h"
+#include "nsRefPtrHashtable.h"
+#include "nsString.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace ipc {
+class IProtocol;
+}
+
+namespace dom {
+
+class JSActorProtocol;
+class JSActorService;
+
+class JSActorManager : public nsISupports {
+ public:
+  /**
+   * Get or create an actor by its name.
+   *
+   * Will set an error on |aRv| if the actor fails to be constructed.
+   */
+  already_AddRefed<JSActor> GetActor(JSContext* aCx, const nsACString& aName,
+                                     ErrorResult& aRv);
+
+  /**
+   * Look up an existing actor by its name, returning nullptr if it doesn't
+   * already exist. Will not attempt to create the actor.
+   */
+  already_AddRefed<JSActor> GetExistingActor(const nsACString& aName);
+
+  /**
+   * Handle receiving a raw message from the other side.
+   */
+  void ReceiveRawMessage(const JSActorMessageMeta& aMetadata,
+                         Maybe<ipc::StructuredCloneData>&& aData,
+                         Maybe<ipc::StructuredCloneData>&& aStack);
+
+ protected:
+  /**
+   * The actor is about to be destroyed so prevent it from sending any
+   * more messages.
+   */
+  void JSActorWillDestroy();
+
+  /**
+   * Lifecycle method which will fire the `didDestroy` methods on relevant
+   * actors.
+   */
+  void JSActorDidDestroy();
+
+  /**
+   * Return the protocol with the given name, if it is supported by the current
+   * actor.
+   */
+  virtual already_AddRefed<JSActorProtocol> MatchingJSActorProtocol(
+      JSActorService* aActorSvc, const nsACString& aName, ErrorResult& aRv) = 0;
+
+  /**
+   * Initialize a JSActor instance given the constructed JS object.
+   * `aMaybeActor` may be `nullptr`, which should construct the default empty
+   * actor.
+   */
+  virtual already_AddRefed<JSActor> InitJSActor(
+      JS::Handle<JSObject*> aMaybeActor, const nsACString& aName,
+      ErrorResult& aRv) = 0;
+
+  /**
+   * Return this native actor. This should be the same object which is
+   * implementing `JSActorManager`.
+   */
+  virtual mozilla::ipc::IProtocol* AsNativeActor() = 0;
+
+ private:
+  friend class JSActorService;
+
+  /**
+   * Note that a particular actor name has been unregistered, and fire the
+   * `didDestroy` method on the actor, if it's been initialized.
+   */
+  void JSActorUnregister(const nsACString& aName);
+
+  nsRefPtrHashtable<nsCStringHashKey, JSActor> mJSActors;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_JSActorManager_h
diff --git a/dom/ipc/jsactor/JSActorProtocolUtils.h b/dom/ipc/jsactor/JSActorProtocolUtils.h
new file mode 100644
index 0000000000..b1fb4d461c
--- /dev/null
+++ b/dom/ipc/jsactor/JSActorProtocolUtils.h
@@ -0,0 +1,117 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_JSActorProtocolUtils_h
+#define mozilla_dom_JSActorProtocolUtils_h
+
+#include "mozilla/Assertions.h"   // MOZ_ASSERT
+#include "mozilla/ErrorResult.h"  // ErrorResult
+
+namespace mozilla {
+
+namespace dom {
+
+class JSActorProtocolUtils {
+ public:
+  template <typename ProtoT, typename ActorInfoT>
+  static void FromIPCShared(ProtoT& aProto, const ActorInfoT& aInfo) {
+    aProto->mRemoteTypes = aInfo.remoteTypes().Clone();
+
+    if (aInfo.isESModule()) {
+      aProto->mChild.mESModuleURI = aInfo.url();
+    } else {
+      aProto->mChild.mModuleURI = aInfo.url();
+    }
+
+    aProto->mChild.mObservers = aInfo.observers().Clone();
+  }
+
+  template <typename ProtoT, typename ActorInfoT>
+  static void ToIPCShared(ActorInfoT& aInfo, const ProtoT& aProto) {
+    aInfo.name() = aProto->mName;
+
+    aInfo.remoteTypes() = aProto->mRemoteTypes.Clone();
+
+    if (aProto->mChild.mModuleURI) {
+      aInfo.url() = aProto->mChild.mModuleURI;
+      aInfo.isESModule() = false;
+    } else {
+      aInfo.url() = aProto->mChild.mESModuleURI;
+      aInfo.isESModule() = true;
+    }
+
+    aInfo.observers() = aProto->mChild.mObservers.Clone();
+  }
+
+  template <typename ProtoT, typename ActorOptionsT>
+  static bool FromWebIDLOptionsShared(ProtoT& aProto,
+                                      const ActorOptionsT& aOptions,
+                                      ErrorResult& aRv) {
+    if (aOptions.mRemoteTypes.WasPassed()) {
+      MOZ_ASSERT(aOptions.mRemoteTypes.Value().Length());
+      aProto->mRemoteTypes = aOptions.mRemoteTypes.Value();
+    }
+
+    if (aOptions.mParent.WasPassed()) {
+      const auto& parentOptions = aOptions.mParent.Value();
+
+      if (parentOptions.mModuleURI.WasPassed()) {
+        if (parentOptions.mEsModuleURI.WasPassed()) {
+          aRv.ThrowNotSupportedError(
+              "moduleURI and esModuleURI are mutually exclusive.");
+          return false;
+        }
+
+        aProto->mParent.mModuleURI.emplace(parentOptions.mModuleURI.Value());
+      } else if (parentOptions.mEsModuleURI.WasPassed()) {
+        aProto->mParent.mESModuleURI.emplace(
+            parentOptions.mEsModuleURI.Value());
+      } else {
+        aRv.ThrowNotSupportedError(
+            "Either moduleURI or esModuleURI is required.");
+        return false;
+      }
+    }
+    if (aOptions.mChild.WasPassed()) {
+      const auto& childOptions = aOptions.mChild.Value();
+
+      if (childOptions.mModuleURI.WasPassed()) {
+        if (childOptions.mEsModuleURI.WasPassed()) {
+          aRv.ThrowNotSupportedError(
+              "moduleURI and esModuleURI are exclusive.");
+          return false;
+        }
+
+        aProto->mChild.mModuleURI.emplace(childOptions.mModuleURI.Value());
+      } else if (childOptions.mEsModuleURI.WasPassed()) {
+        aProto->mChild.mESModuleURI.emplace(childOptions.mEsModuleURI.Value());
+      } else {
+        aRv.ThrowNotSupportedError(
+            "Either moduleURI or esModuleURI is required.");
+        return false;
+      }
+    }
+
+    if (!aOptions.mChild.WasPassed() && !aOptions.mParent.WasPassed()) {
+      aRv.ThrowNotSupportedError(
+          "No point registering an actor with neither child nor parent "
+          "specifications.");
+      return false;
+    }
+
+    if (aOptions.mChild.WasPassed() &&
+        aOptions.mChild.Value().mObservers.WasPassed()) {
+      aProto->mChild.mObservers = aOptions.mChild.Value().mObservers.Value();
+    }
+
+    return true;
+  }
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_JSActorProtocolUtils_h
diff --git a/dom/ipc/jsactor/JSActorService.cpp b/dom/ipc/jsactor/JSActorService.cpp
new file mode 100644
index 0000000000..3fde76a206
--- /dev/null
+++ b/dom/ipc/jsactor/JSActorService.cpp
@@ -0,0 +1,322 @@
+/* -*- 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 "mozilla/dom/JSActorService.h"
+#include "mozilla/dom/ChromeUtilsBinding.h"
+#include "mozilla/dom/BrowserChild.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/dom/EventListenerBinding.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/EventTargetBinding.h"
+#include "mozilla/dom/EventTarget.h"
+#include "mozilla/dom/InProcessChild.h"
+#include "mozilla/dom/InProcessParent.h"
+#include "mozilla/dom/JSActorManager.h"
+#include "mozilla/dom/JSProcessActorBinding.h"
+#include "mozilla/dom/JSProcessActorChild.h"
+#include "mozilla/dom/JSProcessActorProtocol.h"
+#include "mozilla/dom/JSWindowActorBinding.h"
+#include "mozilla/dom/JSWindowActorChild.h"
+#include "mozilla/dom/JSWindowActorProtocol.h"
+#include "mozilla/dom/MessageManagerBinding.h"
+#include "mozilla/dom/PContent.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/WindowGlobalChild.h"
+#include "mozilla/dom/WindowGlobalParent.h"
+#include "mozilla/ArrayAlgorithm.h"
+#include "mozilla/Services.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/Logging.h"
+#include "nsIObserverService.h"
+
+namespace mozilla::dom {
+namespace {
+StaticRefPtr<JSActorService> gJSActorService;
+}
+
+JSActorService::JSActorService() { MOZ_ASSERT(NS_IsMainThread()); }
+
+JSActorService::~JSActorService() { MOZ_ASSERT(NS_IsMainThread()); }
+
+/* static */
+already_AddRefed<JSActorService> JSActorService::GetSingleton() {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (!gJSActorService) {
+    gJSActorService = new JSActorService();
+    ClearOnShutdown(&gJSActorService);
+  }
+
+  RefPtr<JSActorService> service = gJSActorService.get();
+  return service.forget();
+}
+
+void JSActorService::RegisterWindowActor(const nsACString& aName,
+                                         const WindowActorOptions& aOptions,
+                                         ErrorResult& aRv) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(XRE_IsParentProcess());
+
+  const auto proto = mWindowActorDescriptors.WithEntryHandle(
+      aName, [&](auto&& entry) -> RefPtr<JSWindowActorProtocol> {
+        if (entry) {
+          aRv.ThrowNotSupportedError(
+              nsPrintfCString("'%s' actor is already registered.",
+                              PromiseFlatCString(aName).get()));
+          return nullptr;
+        }
+
+        // Insert a new entry for the protocol.
+        RefPtr<JSWindowActorProtocol> protocol =
+            JSWindowActorProtocol::FromWebIDLOptions(aName, aOptions, aRv);
+        if (NS_WARN_IF(aRv.Failed())) {
+          return nullptr;
+        }
+
+        entry.Insert(protocol);
+
+        return protocol;
+      });
+
+  if (!proto) {
+    MOZ_ASSERT(aRv.Failed());
+    return;
+  }
+
+  // Send information about the newly added entry to every existing content
+  // process.
+  AutoTArray<JSWindowActorInfo, 1> windowInfos{proto->ToIPC()};
+  nsTArray<JSProcessActorInfo> contentInfos{};
+  for (auto* cp : ContentParent::AllProcesses(ContentParent::eLive)) {
+    Unused << cp->SendInitJSActorInfos(contentInfos, windowInfos);
+  }
+
+  // Register event listeners for any existing chrome targets.
+  for (EventTarget* target : mChromeEventTargets) {
+    proto->RegisterListenersFor(target);
+  }
+
+  // Add observers to the protocol.
+  proto->AddObservers();
+}
+
+void JSActorService::UnregisterWindowActor(const nsACString& aName) {
+  MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
+  CrashReporter::AutoAnnotateCrashReport autoActorName(
+      CrashReporter::Annotation::JSActorName, aName);
+  CrashReporter::AutoAnnotateCrashReport autoMessageName(
+      CrashReporter::Annotation::JSActorMessage, "<Unregister>"_ns);
+
+  nsAutoCString name(aName);
+  RefPtr<JSWindowActorProtocol> proto;
+  if (mWindowActorDescriptors.Remove(name, getter_AddRefs(proto))) {
+    // Remove listeners for this actor from each of our chrome targets.
+    for (EventTarget* target : mChromeEventTargets) {
+      proto->UnregisterListenersFor(target);
+    }
+
+    // Remove observers for this actor from observer serivce.
+    proto->RemoveObservers();
+
+    // Tell every content process to also unregister, and accumulate the set of
+    // potential managers, to have the actor disabled.
+    nsTArray<RefPtr<JSActorManager>> managers;
+    if (XRE_IsParentProcess()) {
+      for (auto* cp : ContentParent::AllProcesses(ContentParent::eLive)) {
+        Unused << cp->SendUnregisterJSWindowActor(name);
+        for (const auto& bp : cp->ManagedPBrowserParent()) {
+          for (const auto& wgp : bp->ManagedPWindowGlobalParent()) {
+            managers.AppendElement(static_cast<WindowGlobalParent*>(wgp));
+          }
+        }
+      }
+
+      for (const auto& wgp :
+           InProcessParent::Singleton()->ManagedPWindowGlobalParent()) {
+        managers.AppendElement(static_cast<WindowGlobalParent*>(wgp));
+      }
+      for (const auto& wgc :
+           InProcessChild::Singleton()->ManagedPWindowGlobalChild()) {
+        managers.AppendElement(static_cast<WindowGlobalChild*>(wgc));
+      }
+    } else {
+      for (const auto& bc :
+           ContentChild::GetSingleton()->ManagedPBrowserChild()) {
+        for (const auto& wgc : bc->ManagedPWindowGlobalChild()) {
+          managers.AppendElement(static_cast<WindowGlobalChild*>(wgc));
+        }
+      }
+    }
+
+    for (auto& mgr : managers) {
+      mgr->JSActorUnregister(name);
+    }
+  }
+}
+
+void JSActorService::LoadJSActorInfos(nsTArray<JSProcessActorInfo>& aProcess,
+                                      nsTArray<JSWindowActorInfo>& aWindow) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(XRE_IsContentProcess());
+
+  for (auto& info : aProcess) {
+    // Create our JSProcessActorProtocol, register it in
+    // mProcessActorDescriptors.
+    auto name = info.name();
+    RefPtr<JSProcessActorProtocol> proto =
+        JSProcessActorProtocol::FromIPC(std::move(info));
+    mProcessActorDescriptors.InsertOrUpdate(std::move(name), RefPtr{proto});
+
+    // Add observers for each actor.
+    proto->AddObservers();
+  }
+
+  for (auto& info : aWindow) {
+    auto name = info.name();
+    RefPtr<JSWindowActorProtocol> proto =
+        JSWindowActorProtocol::FromIPC(std::move(info));
+    mWindowActorDescriptors.InsertOrUpdate(std::move(name), RefPtr{proto});
+
+    // Register listeners for each chrome target.
+    for (EventTarget* target : mChromeEventTargets) {
+      proto->RegisterListenersFor(target);
+    }
+
+    // Add observers for each actor.
+    proto->AddObservers();
+  }
+}
+
+void JSActorService::GetJSWindowActorInfos(
+    nsTArray<JSWindowActorInfo>& aInfos) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(XRE_IsParentProcess());
+
+  for (const auto& data : mWindowActorDescriptors.Values()) {
+    aInfos.AppendElement(data->ToIPC());
+  }
+}
+
+void JSActorService::RegisterChromeEventTarget(EventTarget* aTarget) {
+  MOZ_ASSERT(!mChromeEventTargets.Contains(aTarget));
+  mChromeEventTargets.AppendElement(aTarget);
+
+  // Register event listeners on the newly added Window Root.
+  for (const auto& data : mWindowActorDescriptors.Values()) {
+    data->RegisterListenersFor(aTarget);
+  }
+
+  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
+  obs->NotifyObservers(aTarget, "chrome-event-target-created", nullptr);
+}
+
+/* static */
+void JSActorService::UnregisterChromeEventTarget(EventTarget* aTarget) {
+  if (gJSActorService) {
+    // NOTE: No need to unregister listeners here, as the target is going away.
+    gJSActorService->mChromeEventTargets.RemoveElement(aTarget);
+  }
+}
+
+void JSActorService::RegisterProcessActor(const nsACString& aName,
+                                          const ProcessActorOptions& aOptions,
+                                          ErrorResult& aRv) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(XRE_IsParentProcess());
+
+  const auto proto = mProcessActorDescriptors.WithEntryHandle(
+      aName, [&](auto&& entry) -> RefPtr<JSProcessActorProtocol> {
+        if (entry) {
+          aRv.ThrowNotSupportedError(
+              nsPrintfCString("'%s' actor is already registered.",
+                              PromiseFlatCString(aName).get()));
+          return nullptr;
+        }
+
+        // Insert a new entry for the protocol.
+        RefPtr<JSProcessActorProtocol> protocol =
+            JSProcessActorProtocol::FromWebIDLOptions(aName, aOptions, aRv);
+        if (NS_WARN_IF(aRv.Failed())) {
+          return nullptr;
+        }
+
+        entry.Insert(protocol);
+
+        return protocol;
+      });
+
+  if (!proto) {
+    MOZ_ASSERT(aRv.Failed());
+    return;
+  }
+
+  // Send information about the newly added entry to every existing content
+  // process.
+  AutoTArray<JSProcessActorInfo, 1> contentInfos{proto->ToIPC()};
+  nsTArray<JSWindowActorInfo> windowInfos{};
+  for (auto* cp : ContentParent::AllProcesses(ContentParent::eLive)) {
+    Unused << cp->SendInitJSActorInfos(contentInfos, windowInfos);
+  }
+
+  // Add observers to the protocol.
+  proto->AddObservers();
+}
+
+void JSActorService::UnregisterProcessActor(const nsACString& aName) {
+  MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
+  CrashReporter::AutoAnnotateCrashReport autoActorName(
+      CrashReporter::Annotation::JSActorName, aName);
+  CrashReporter::AutoAnnotateCrashReport autoMessageName(
+      CrashReporter::Annotation::JSActorMessage, "<Unregister>"_ns);
+
+  nsAutoCString name(aName);
+  RefPtr<JSProcessActorProtocol> proto;
+  if (mProcessActorDescriptors.Remove(name, getter_AddRefs(proto))) {
+    // Remove observers for this actor from observer serivce.
+    proto->RemoveObservers();
+
+    // Tell every content process to also unregister, and accumulate the set of
+    // potential managers, to have the actor disabled.
+    nsTArray<RefPtr<JSActorManager>> managers;
+    if (XRE_IsParentProcess()) {
+      for (auto* cp : ContentParent::AllProcesses(ContentParent::eLive)) {
+        Unused << cp->SendUnregisterJSProcessActor(name);
+        managers.AppendElement(cp);
+      }
+      managers.AppendElement(InProcessChild::Singleton());
+      managers.AppendElement(InProcessParent::Singleton());
+    } else {
+      managers.AppendElement(ContentChild::GetSingleton());
+    }
+
+    for (auto& mgr : managers) {
+      mgr->JSActorUnregister(name);
+    }
+  }
+}
+
+void JSActorService::GetJSProcessActorInfos(
+    nsTArray<JSProcessActorInfo>& aInfos) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(XRE_IsParentProcess());
+
+  for (const auto& data : mProcessActorDescriptors.Values()) {
+    aInfos.AppendElement(data->ToIPC());
+  }
+}
+
+already_AddRefed<JSProcessActorProtocol>
+JSActorService::GetJSProcessActorProtocol(const nsACString& aName) {
+  return mProcessActorDescriptors.Get(aName);
+}
+
+already_AddRefed<JSWindowActorProtocol>
+JSActorService::GetJSWindowActorProtocol(const nsACString& aName) {
+  return mWindowActorDescriptors.Get(aName);
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/jsactor/JSActorService.h b/dom/ipc/jsactor/JSActorService.h
new file mode 100644
index 0000000000..e3296e1934
--- /dev/null
+++ b/dom/ipc/jsactor/JSActorService.h
@@ -0,0 +1,112 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_JSActorService_h
+#define mozilla_dom_JSActorService_h
+
+#include "mozilla/dom/BrowsingContext.h"
+#include "nsIURI.h"
+#include "nsRefPtrHashtable.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "mozilla/dom/JSActor.h"
+#include "nsIObserver.h"
+#include "nsIDOMEventListener.h"
+#include "mozilla/EventListenerManager.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+struct ProcessActorOptions;
+struct WindowActorOptions;
+class JSProcessActorInfo;
+class JSWindowActorInfo;
+class EventTarget;
+class JSWindowActorProtocol;
+class JSProcessActorProtocol;
+
+class JSActorService final {
+ public:
+  NS_INLINE_DECL_REFCOUNTING(JSActorService)
+
+  static already_AddRefed<JSActorService> GetSingleton();
+
+  // Register or unregister a chrome event target.
+  void RegisterChromeEventTarget(EventTarget* aTarget);
+
+  // NOTE: This method is static, as it may be called during shutdown.
+  static void UnregisterChromeEventTarget(EventTarget* aTarget);
+
+  // Register child's Actor for content process.
+  void LoadJSActorInfos(nsTArray<JSProcessActorInfo>& aProcess,
+                        nsTArray<JSWindowActorInfo>& aWindow);
+
+  // --- Window Actor
+
+  void RegisterWindowActor(const nsACString& aName,
+                           const WindowActorOptions& aOptions,
+                           ErrorResult& aRv);
+
+  void UnregisterWindowActor(const nsACString& aName);
+
+  // Get the named of Window Actor and the child's WindowActorOptions
+  // from mDescriptors to JSWindowActorInfos.
+  void GetJSWindowActorInfos(nsTArray<JSWindowActorInfo>& aInfos);
+
+  already_AddRefed<JSWindowActorProtocol> GetJSWindowActorProtocol(
+      const nsACString& aName);
+
+  // -- Content Actor
+
+  void RegisterProcessActor(const nsACString& aName,
+                            const ProcessActorOptions& aOptions,
+                            ErrorResult& aRv);
+
+  void UnregisterProcessActor(const nsACString& aName);
+
+  // Get the named of Content Actor and the child's ProcessActorOptions
+  // from mDescriptors to JSProcessActorInfos.
+  void GetJSProcessActorInfos(nsTArray<JSProcessActorInfo>& aInfos);
+
+  already_AddRefed<JSProcessActorProtocol> GetJSProcessActorProtocol(
+      const nsACString& aName);
+
+ private:
+  JSActorService();
+  ~JSActorService();
+
+  nsTArray<EventTarget*> mChromeEventTargets;
+
+  // -- Window Actor
+  nsRefPtrHashtable<nsCStringHashKey, JSWindowActorProtocol>
+      mWindowActorDescriptors;
+
+  // -- Process Actor
+  nsRefPtrHashtable<nsCStringHashKey, JSProcessActorProtocol>
+      mProcessActorDescriptors;
+};
+
+/**
+ * Base clsas for both `JSWindowActorProtocol` and `JSProcessActorProtocol`
+ * which can be used by generic code.
+ */
+class JSActorProtocol : public nsISupports {
+ public:
+  struct Sided {
+    Maybe<nsCString> mModuleURI;
+    Maybe<nsCString> mESModuleURI;
+  };
+
+  virtual const Sided& Parent() const = 0;
+  virtual const Sided& Child() const = 0;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_JSActorService_h
diff --git a/dom/ipc/jsactor/JSProcessActorChild.cpp b/dom/ipc/jsactor/JSProcessActorChild.cpp
new file mode 100644
index 0000000000..a9379838cf
--- /dev/null
+++ b/dom/ipc/jsactor/JSProcessActorChild.cpp
@@ -0,0 +1,86 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/JSProcessActorBinding.h"
+#include "mozilla/dom/JSProcessActorChild.h"
+#include "mozilla/dom/InProcessChild.h"
+#include "mozilla/dom/InProcessParent.h"
+
+namespace mozilla::dom {
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(JSProcessActorChild, JSActor, mManager)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(JSProcessActorChild)
+NS_INTERFACE_MAP_END_INHERITING(JSActor)
+
+NS_IMPL_ADDREF_INHERITED(JSProcessActorChild, JSActor)
+NS_IMPL_RELEASE_INHERITED(JSProcessActorChild, JSActor)
+
+JSObject* JSProcessActorChild::WrapObject(JSContext* aCx,
+                                          JS::Handle<JSObject*> aGivenProto) {
+  return JSProcessActorChild_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void JSProcessActorChild::SendRawMessage(
+    const JSActorMessageMeta& aMeta, Maybe<ipc::StructuredCloneData>&& aData,
+    Maybe<ipc::StructuredCloneData>&& aStack, ErrorResult& aRv) {
+  if (NS_WARN_IF(!CanSend() || !mManager || !mManager->GetCanSend())) {
+    aRv.ThrowInvalidStateError("JSProcessActorChild cannot send at the moment");
+    return;
+  }
+
+  // If the parent side is in the same process, we have a PInProcess manager,
+  // and can dispatch the message directly to the event loop.
+  ContentChild* contentChild = mManager->AsContentChild();
+  if (!contentChild) {
+    SendRawMessageInProcess(aMeta, std::move(aData), std::move(aStack), []() {
+      return do_AddRef(InProcessParent::Singleton());
+    });
+    return;
+  }
+
+  // Cross-process case - send data over ContentChild to other side.
+  Maybe<ClonedMessageData> msgData;
+  if (aData) {
+    msgData.emplace();
+    if (NS_WARN_IF(!aData->BuildClonedMessageData(*msgData))) {
+      aRv.ThrowDataCloneError(
+          nsPrintfCString("JSProcessActorChild serialization error: cannot "
+                          "clone, in actor '%s'",
+                          PromiseFlatCString(aMeta.actorName()).get()));
+      return;
+    }
+  }
+
+  Maybe<ClonedMessageData> stackData;
+  if (aStack) {
+    stackData.emplace();
+    if (!aStack->BuildClonedMessageData(*stackData)) {
+      stackData.reset();
+    }
+  }
+
+  if (NS_WARN_IF(!contentChild->SendRawMessage(aMeta, msgData, stackData))) {
+    aRv.ThrowOperationError(
+        nsPrintfCString("JSProcessActorChild send error in actor '%s'",
+                        PromiseFlatCString(aMeta.actorName()).get()));
+    return;
+  }
+}
+
+void JSProcessActorChild::Init(const nsACString& aName,
+                               nsIDOMProcessChild* aManager) {
+  MOZ_ASSERT(!mManager, "Cannot Init() a JSProcessActorChild twice!");
+  SetName(aName);
+  mManager = aManager;
+
+  InvokeCallback(CallbackFunction::ActorCreated);
+}
+
+void JSProcessActorChild::ClearManager() { mManager = nullptr; }
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/jsactor/JSProcessActorChild.h b/dom/ipc/jsactor/JSProcessActorChild.h
new file mode 100644
index 0000000000..a8be65211c
--- /dev/null
+++ b/dom/ipc/jsactor/JSProcessActorChild.h
@@ -0,0 +1,54 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_JSProcessActorChild_h
+#define mozilla_dom_JSProcessActorChild_h
+
+#include "mozilla/dom/JSActor.h"
+#include "nsIDOMProcessChild.h"
+
+namespace mozilla::dom {
+
+// Placeholder implementation.
+class JSProcessActorChild final : public JSActor {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(JSProcessActorChild, JSActor)
+
+  explicit JSProcessActorChild(nsISupports* aGlobal = nullptr)
+      : JSActor(aGlobal) {}
+
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override;
+
+  static already_AddRefed<JSProcessActorChild> Constructor(
+      GlobalObject& aGlobal) {
+    return MakeAndAddRef<JSProcessActorChild>(aGlobal.GetAsSupports());
+  }
+
+  nsIDOMProcessChild* Manager() const { return mManager; }
+
+  void Init(const nsACString& aName, nsIDOMProcessChild* aManager);
+  void ClearManager() override;
+
+ protected:
+  // Send the message described by the structured clone data |aData|, and the
+  // message metadata |aMetadata|. The underlying transport should call the
+  // |ReceiveMessage| method on the other side asynchronously.
+  virtual void SendRawMessage(const JSActorMessageMeta& aMetadata,
+                              Maybe<ipc::StructuredCloneData>&& aData,
+                              Maybe<ipc::StructuredCloneData>&& aStack,
+                              ErrorResult& aRv) override;
+
+ private:
+  ~JSProcessActorChild() { MOZ_ASSERT(!mManager); }
+
+  nsCOMPtr<nsIDOMProcessChild> mManager;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_JSProcessActorChild_h
diff --git a/dom/ipc/jsactor/JSProcessActorParent.cpp b/dom/ipc/jsactor/JSProcessActorParent.cpp
new file mode 100644
index 0000000000..eec8ad17c7
--- /dev/null
+++ b/dom/ipc/jsactor/JSProcessActorParent.cpp
@@ -0,0 +1,90 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "mozilla/dom/JSProcessActorBinding.h"
+#include "mozilla/dom/JSProcessActorParent.h"
+#include "mozilla/dom/InProcessChild.h"
+#include "mozilla/dom/InProcessParent.h"
+
+namespace mozilla::dom {
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(JSProcessActorParent, JSActor, mManager)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(JSProcessActorParent)
+NS_INTERFACE_MAP_END_INHERITING(JSActor)
+
+NS_IMPL_ADDREF_INHERITED(JSProcessActorParent, JSActor)
+NS_IMPL_RELEASE_INHERITED(JSProcessActorParent, JSActor)
+
+JSObject* JSProcessActorParent::WrapObject(JSContext* aCx,
+                                           JS::Handle<JSObject*> aGivenProto) {
+  return JSProcessActorParent_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void JSProcessActorParent::Init(const nsACString& aName,
+                                nsIDOMProcessParent* aManager) {
+  MOZ_ASSERT(!mManager, "Cannot Init() a JSProcessActorParent twice!");
+  SetName(aName);
+  mManager = aManager;
+
+  InvokeCallback(CallbackFunction::ActorCreated);
+}
+
+JSProcessActorParent::~JSProcessActorParent() { MOZ_ASSERT(!mManager); }
+
+void JSProcessActorParent::SendRawMessage(
+    const JSActorMessageMeta& aMeta, Maybe<ipc::StructuredCloneData>&& aData,
+    Maybe<ipc::StructuredCloneData>&& aStack, ErrorResult& aRv) {
+  if (NS_WARN_IF(!CanSend() || !mManager || !mManager->GetCanSend())) {
+    aRv.ThrowInvalidStateError(
+        nsPrintfCString("Actor '%s' cannot send message '%s' during shutdown.",
+                        PromiseFlatCString(aMeta.actorName()).get(),
+                        NS_ConvertUTF16toUTF8(aMeta.messageName()).get()));
+    return;
+  }
+
+  // If the parent side is in the same process, we have a PInProcess manager,
+  // and can dispatch the message directly to the event loop.
+  ContentParent* contentParent = mManager->AsContentParent();
+  if (!contentParent) {
+    SendRawMessageInProcess(aMeta, std::move(aData), std::move(aStack), []() {
+      return do_AddRef(InProcessChild::Singleton());
+    });
+    return;
+  }
+
+  // Cross-process case - send data over ContentParent to other side.
+  Maybe<ClonedMessageData> msgData;
+  if (aData) {
+    msgData.emplace();
+    if (NS_WARN_IF(!aData->BuildClonedMessageData(*msgData))) {
+      aRv.ThrowDataCloneError(
+          nsPrintfCString("Actor '%s' cannot send message '%s': cannot clone.",
+                          PromiseFlatCString(aMeta.actorName()).get(),
+                          NS_ConvertUTF16toUTF8(aMeta.messageName()).get()));
+      return;
+    }
+  }
+
+  Maybe<ClonedMessageData> stackData;
+  if (aStack) {
+    stackData.emplace();
+    if (!aStack->BuildClonedMessageData(*stackData)) {
+      stackData.reset();
+    }
+  }
+
+  if (NS_WARN_IF(!contentParent->SendRawMessage(aMeta, msgData, stackData))) {
+    aRv.ThrowOperationError(
+        nsPrintfCString("JSProcessActorParent send error in actor '%s'",
+                        PromiseFlatCString(aMeta.actorName()).get()));
+    return;
+  }
+}
+
+void JSProcessActorParent::ClearManager() { mManager = nullptr; }
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/jsactor/JSProcessActorParent.h b/dom/ipc/jsactor/JSProcessActorParent.h
new file mode 100644
index 0000000000..7b2a1535f9
--- /dev/null
+++ b/dom/ipc/jsactor/JSProcessActorParent.h
@@ -0,0 +1,63 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_JSProcessActorParent_h
+#define mozilla_dom_JSProcessActorParent_h
+
+#include "js/TypeDecls.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/JSActor.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIDOMProcessParent.h"
+#include "nsWrapperCache.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class JSProcessActorParent final : public JSActor {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(JSProcessActorParent, JSActor)
+
+  explicit JSProcessActorParent(nsISupports* aGlobal = nullptr)
+      : JSActor(aGlobal) {}
+
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override;
+
+  static already_AddRefed<JSProcessActorParent> Constructor(
+      GlobalObject& aGlobal) {
+    return MakeAndAddRef<JSProcessActorParent>(aGlobal.GetAsSupports());
+  }
+
+  nsIDOMProcessParent* Manager() const { return mManager; }
+
+  void Init(const nsACString& aName, nsIDOMProcessParent* aManager);
+  void ClearManager() override;
+
+ protected:
+  // Send the message described by the structured clone data |aData|, and the
+  // message metadata |aMetadata|. The underlying transport should call the
+  // |ReceiveMessage| method on the other side asynchronously.
+  virtual void SendRawMessage(const JSActorMessageMeta& aMetadata,
+                              Maybe<ipc::StructuredCloneData>&& aData,
+                              Maybe<ipc::StructuredCloneData>&& aStack,
+                              ErrorResult& aRv) override;
+
+ private:
+  ~JSProcessActorParent();
+
+  nsCOMPtr<nsIDOMProcessParent> mManager;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_JSProcessActorParent_h
diff --git a/dom/ipc/jsactor/JSProcessActorProtocol.cpp b/dom/ipc/jsactor/JSProcessActorProtocol.cpp
new file mode 100644
index 0000000000..367db5305b
--- /dev/null
+++ b/dom/ipc/jsactor/JSProcessActorProtocol.cpp
@@ -0,0 +1,147 @@
+/* -*- 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 "mozilla/dom/JSProcessActorProtocol.h"
+#include "mozilla/dom/InProcessChild.h"
+#include "mozilla/dom/JSProcessActorBinding.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/JSActorBinding.h"
+#include "mozilla/dom/PContent.h"
+
+#include "nsContentUtils.h"
+#include "JSActorProtocolUtils.h"
+
+namespace mozilla::dom {
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(JSProcessActorProtocol)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(JSProcessActorProtocol)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(JSProcessActorProtocol)
+  NS_INTERFACE_MAP_ENTRY(nsIObserver)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTION(JSProcessActorProtocol)
+
+/* static */ already_AddRefed<JSProcessActorProtocol>
+JSProcessActorProtocol::FromIPC(const JSProcessActorInfo& aInfo) {
+  MOZ_DIAGNOSTIC_ASSERT(XRE_IsContentProcess());
+
+  RefPtr<JSProcessActorProtocol> proto =
+      new JSProcessActorProtocol(aInfo.name());
+  JSActorProtocolUtils::FromIPCShared(proto, aInfo);
+
+  // Content processes aren't the parent process, so this flag is irrelevant and
+  // not propagated.
+  proto->mIncludeParent = false;
+
+  return proto.forget();
+}
+
+JSProcessActorInfo JSProcessActorProtocol::ToIPC() {
+  MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess());
+
+  JSProcessActorInfo info;
+  JSActorProtocolUtils::ToIPCShared(info, this);
+
+  return info;
+}
+
+already_AddRefed<JSProcessActorProtocol>
+JSProcessActorProtocol::FromWebIDLOptions(const nsACString& aName,
+                                          const ProcessActorOptions& aOptions,
+                                          ErrorResult& aRv) {
+  MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess());
+
+  RefPtr<JSProcessActorProtocol> proto = new JSProcessActorProtocol(aName);
+  if (!JSActorProtocolUtils::FromWebIDLOptionsShared(proto, aOptions, aRv)) {
+    return nullptr;
+  }
+
+  proto->mIncludeParent = aOptions.mIncludeParent;
+
+  return proto.forget();
+}
+
+NS_IMETHODIMP JSProcessActorProtocol::Observe(nsISupports* aSubject,
+                                              const char* aTopic,
+                                              const char16_t* aData) {
+  MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
+
+  RefPtr<JSActorManager> manager;
+  if (XRE_IsParentProcess()) {
+    manager = InProcessChild::Singleton();
+  } else {
+    manager = ContentChild::GetSingleton();
+  }
+
+  // Ensure our actor is present.
+  AutoJSAPI jsapi;
+  jsapi.Init();
+  RefPtr<JSActor> actor = manager->GetActor(jsapi.cx(), mName, IgnoreErrors());
+  if (!actor || NS_WARN_IF(!actor->GetWrapperPreserveColor())) {
+    return NS_OK;
+  }
+
+  // Build a observer callback.
+  JS::Rooted<JSObject*> global(jsapi.cx(),
+                               JS::GetNonCCWObjectGlobal(actor->GetWrapper()));
+  RefPtr<MozObserverCallback> observerCallback =
+      new MozObserverCallback(actor->GetWrapper(), global, nullptr, nullptr);
+  observerCallback->Observe(aSubject, nsDependentCString(aTopic),
+                            aData ? nsDependentString(aData) : VoidString());
+  return NS_OK;
+}
+
+void JSProcessActorProtocol::AddObservers() {
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  for (auto& topic : mChild.mObservers) {
+    // This makes the observer service hold an owning reference to the
+    // JSProcessActorProtocol. The JSWindowActorProtocol objects will be living
+    // for the full lifetime of the content process, thus the extra strong
+    // referencec doesn't have a negative impact.
+    os->AddObserver(this, topic.get(), false);
+  }
+}
+
+void JSProcessActorProtocol::RemoveObservers() {
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  for (auto& topic : mChild.mObservers) {
+    os->RemoveObserver(this, topic.get());
+  }
+}
+
+bool JSProcessActorProtocol::RemoteTypePrefixMatches(
+    const nsDependentCSubstring& aRemoteType) {
+  for (auto& remoteType : mRemoteTypes) {
+    if (StringBeginsWith(aRemoteType, remoteType)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool JSProcessActorProtocol::Matches(const nsACString& aRemoteType,
+                                     ErrorResult& aRv) {
+  if (!mIncludeParent && aRemoteType.IsEmpty()) {
+    aRv.ThrowNotSupportedError(nsPrintfCString(
+        "Process protocol '%s' doesn't match the parent process", mName.get()));
+    return false;
+  }
+
+  if (!mRemoteTypes.IsEmpty() &&
+      !RemoteTypePrefixMatches(RemoteTypePrefix(aRemoteType))) {
+    aRv.ThrowNotSupportedError(nsPrintfCString(
+        "Process protocol '%s' doesn't support remote type '%s'", mName.get(),
+        PromiseFlatCString(aRemoteType).get()));
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/jsactor/JSProcessActorProtocol.h b/dom/ipc/jsactor/JSProcessActorProtocol.h
new file mode 100644
index 0000000000..eab8876c35
--- /dev/null
+++ b/dom/ipc/jsactor/JSProcessActorProtocol.h
@@ -0,0 +1,79 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_JSProcessActorProtocol_h
+#define mozilla_dom_JSProcessActorProtocol_h
+
+#include "mozilla/dom/BrowsingContext.h"
+#include "mozilla/dom/JSActorService.h"
+#include "nsIURI.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "nsIObserver.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+struct ProcessActorOptions;
+class JSProcessActorInfo;
+class EventTarget;
+class JSActorProtocolUtils;
+
+/**
+ * Object corresponding to a single process actor protocol
+ *
+ * This object also can act as a carrier for methods and other state related to
+ * a single protocol managed by the JSActorService.
+ */
+class JSProcessActorProtocol final : public JSActorProtocol,
+                                     public nsIObserver {
+ public:
+  NS_DECL_NSIOBSERVER
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(JSProcessActorProtocol, nsIObserver)
+
+  static already_AddRefed<JSProcessActorProtocol> FromIPC(
+      const JSProcessActorInfo& aInfo);
+  JSProcessActorInfo ToIPC();
+
+  static already_AddRefed<JSProcessActorProtocol> FromWebIDLOptions(
+      const nsACString& aName, const ProcessActorOptions& aOptions,
+      ErrorResult& aRv);
+
+  struct ParentSide : public Sided {};
+
+  struct ChildSide : public Sided {
+    nsTArray<nsCString> mObservers;
+  };
+
+  const ParentSide& Parent() const override { return mParent; }
+  const ChildSide& Child() const override { return mChild; }
+
+  void AddObservers();
+  void RemoveObservers();
+  bool Matches(const nsACString& aRemoteType, ErrorResult& aRv);
+
+ private:
+  explicit JSProcessActorProtocol(const nsACString& aName) : mName(aName) {}
+  bool RemoteTypePrefixMatches(const nsDependentCSubstring& aRemoteType);
+  ~JSProcessActorProtocol() = default;
+
+  nsCString mName;
+  nsTArray<nsCString> mRemoteTypes;
+  bool mIncludeParent = false;
+
+  friend class JSActorProtocolUtils;
+
+  ParentSide mParent;
+  ChildSide mChild;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_JSProcessActorProtocol_h
diff --git a/dom/ipc/jsactor/JSWindowActorChild.cpp b/dom/ipc/jsactor/JSWindowActorChild.cpp
new file mode 100644
index 0000000000..4d028a0789
--- /dev/null
+++ b/dom/ipc/jsactor/JSWindowActorChild.cpp
@@ -0,0 +1,160 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "mozilla/dom/JSWindowActorBinding.h"
+#include "mozilla/dom/JSWindowActorChild.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/WindowGlobalChild.h"
+#include "mozilla/dom/WindowGlobalParent.h"
+#include "mozilla/dom/WindowProxyHolder.h"
+#include "mozilla/dom/MessageManagerBinding.h"
+#include "mozilla/dom/BrowsingContext.h"
+#include "nsGlobalWindowInner.h"
+
+namespace mozilla::dom {
+
+JSWindowActorChild::~JSWindowActorChild() { MOZ_ASSERT(!mManager); }
+
+JSObject* JSWindowActorChild::WrapObject(JSContext* aCx,
+                                         JS::Handle<JSObject*> aGivenProto) {
+  return JSWindowActorChild_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+WindowGlobalChild* JSWindowActorChild::GetManager() const { return mManager; }
+
+WindowContext* JSWindowActorChild::GetWindowContext() const {
+  return mManager ? mManager->WindowContext() : nullptr;
+}
+
+void JSWindowActorChild::Init(const nsACString& aName,
+                              WindowGlobalChild* aManager) {
+  MOZ_ASSERT(!mManager, "Cannot Init() a JSWindowActorChild twice!");
+  SetName(aName);
+  mManager = aManager;
+
+  InvokeCallback(CallbackFunction::ActorCreated);
+}
+
+#ifdef DEBUG
+#  define DEBUG_WARN_MESSAGE_UNSENT(aMeta, aWarning)                    \
+    NS_DebugBreak(                                                      \
+        NS_DEBUG_WARNING,                                               \
+        nsPrintfCString(                                                \
+            "JSWindowActorChild::SendRawMessage (%s, %s) not sent: %s", \
+            (aMeta).actorName().get(),                                  \
+            NS_LossyConvertUTF16toASCII((aMeta).messageName()).get(),   \
+            (aWarning))                                                 \
+            .get(),                                                     \
+        nullptr, __FILE__, __LINE__)
+#else
+#  define DEBUG_WARN_MESSAGE_UNSENT(aMeta, aWarning)
+#endif
+
+void JSWindowActorChild::SendRawMessage(
+    const JSActorMessageMeta& aMeta, Maybe<ipc::StructuredCloneData>&& aData,
+    Maybe<ipc::StructuredCloneData>&& aStack, ErrorResult& aRv) {
+  if (!CanSend() || !mManager || !mManager->CanSend()) {
+    DEBUG_WARN_MESSAGE_UNSENT(
+        aMeta, "!CanSend() || !mManager || !mManager->CanSend()");
+    aRv.ThrowInvalidStateError("JSWindowActorChild cannot send at the moment");
+    return;
+  }
+
+  if (mManager->IsInProcess()) {
+    SendRawMessageInProcess(
+        aMeta, std::move(aData), std::move(aStack),
+        [manager{mManager}]() { return manager->GetParentActor(); });
+    return;
+  }
+
+  // Cross-process case - send data over WindowGlobalChild to other side.
+  Maybe<ClonedMessageData> msgData;
+  if (aData) {
+    msgData.emplace();
+    if (!aData->BuildClonedMessageData(*msgData)) {
+      DEBUG_WARN_MESSAGE_UNSENT(aMeta,
+                                "!aData->BuildClonedMessageData(*msgData)");
+      aRv.ThrowDataCloneError(
+          nsPrintfCString("JSWindowActorChild serialization error: cannot "
+                          "clone, in actor '%s'",
+                          PromiseFlatCString(aMeta.actorName()).get()));
+      return;
+    }
+  }
+
+  Maybe<ClonedMessageData> stackData;
+  if (aStack) {
+    stackData.emplace();
+    if (!aStack->BuildClonedMessageData(*stackData)) {
+      stackData.reset();
+    }
+  }
+
+  if (!mManager->SendRawMessage(aMeta, msgData, stackData)) {
+    DEBUG_WARN_MESSAGE_UNSENT(
+        aMeta, "!mManager->SendRawMessage(aMeta, msgData, stackData)");
+    aRv.ThrowOperationError(
+        nsPrintfCString("JSWindowActorChild send error in actor '%s'",
+                        PromiseFlatCString(aMeta.actorName()).get()));
+    return;
+  }
+}
+
+Document* JSWindowActorChild::GetDocument(ErrorResult& aRv) {
+  if (!mManager) {
+    ThrowStateErrorForGetter("document", aRv);
+    return nullptr;
+  }
+
+  nsGlobalWindowInner* window = mManager->GetWindowGlobal();
+  return window ? window->GetDocument() : nullptr;
+}
+
+BrowsingContext* JSWindowActorChild::GetBrowsingContext(ErrorResult& aRv) {
+  if (!mManager) {
+    ThrowStateErrorForGetter("browsingContext", aRv);
+    return nullptr;
+  }
+
+  return mManager->BrowsingContext();
+}
+
+nsIDocShell* JSWindowActorChild::GetDocShell(ErrorResult& aRv) {
+  if (!mManager) {
+    ThrowStateErrorForGetter("docShell", aRv);
+    return nullptr;
+  }
+
+  return mManager->BrowsingContext()->GetDocShell();
+}
+
+Nullable<WindowProxyHolder> JSWindowActorChild::GetContentWindow(
+    ErrorResult& aRv) {
+  if (!mManager) {
+    ThrowStateErrorForGetter("contentWindow", aRv);
+    return nullptr;
+  }
+
+  if (nsGlobalWindowInner* window = mManager->GetWindowGlobal()) {
+    if (window->IsCurrentInnerWindow()) {
+      return WindowProxyHolder(window->GetBrowsingContext());
+    }
+  }
+
+  return nullptr;
+}
+
+void JSWindowActorChild::ClearManager() { mManager = nullptr; }
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(JSWindowActorChild, JSActor, mManager)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(JSWindowActorChild)
+NS_INTERFACE_MAP_END_INHERITING(JSActor)
+
+NS_IMPL_ADDREF_INHERITED(JSWindowActorChild, JSActor)
+NS_IMPL_RELEASE_INHERITED(JSWindowActorChild, JSActor)
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/jsactor/JSWindowActorChild.h b/dom/ipc/jsactor/JSWindowActorChild.h
new file mode 100644
index 0000000000..8e43d6a6c7
--- /dev/null
+++ b/dom/ipc/jsactor/JSWindowActorChild.h
@@ -0,0 +1,82 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_JSWindowActorChild_h
+#define mozilla_dom_JSWindowActorChild_h
+
+#include "js/RootingAPI.h"
+#include "mozilla/AlreadyAddRefed.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/JSActor.h"
+#include "mozilla/dom/WindowGlobalChild.h"
+#include "nsCOMPtr.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIGlobalObject.h"
+#include "nsISupports.h"
+#include "nsStringFwd.h"
+
+class nsIDocShell;
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+template <typename>
+struct Nullable;
+
+class BrowsingContext;
+class Document;
+class WindowProxyHolder;
+
+}  // namespace dom
+}  // namespace mozilla
+
+namespace mozilla::dom {
+
+class JSWindowActorChild final : public JSActor {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(JSWindowActorChild, JSActor)
+
+  explicit JSWindowActorChild(nsISupports* aGlobal = nullptr)
+      : JSActor(aGlobal) {}
+
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override;
+
+  static already_AddRefed<JSWindowActorChild> Constructor(
+      GlobalObject& aGlobal) {
+    return MakeAndAddRef<JSWindowActorChild>(aGlobal.GetAsSupports());
+  }
+
+  WindowGlobalChild* GetManager() const;
+  WindowContext* GetWindowContext() const;
+  void Init(const nsACString& aName, WindowGlobalChild* aManager);
+  void ClearManager() override;
+  Document* GetDocument(ErrorResult& aRv);
+  BrowsingContext* GetBrowsingContext(ErrorResult& aRv);
+  nsIDocShell* GetDocShell(ErrorResult& aRv);
+  Nullable<WindowProxyHolder> GetContentWindow(ErrorResult& aRv);
+
+ protected:
+  void SendRawMessage(const JSActorMessageMeta& aMeta,
+                      Maybe<ipc::StructuredCloneData>&& aData,
+                      Maybe<ipc::StructuredCloneData>&& aStack,
+                      ErrorResult& aRv) override;
+
+ private:
+  ~JSWindowActorChild();
+
+  RefPtr<WindowGlobalChild> mManager;
+
+  nsCOMPtr<nsIGlobalObject> mGlobal;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_JSWindowActorChild_h
diff --git a/dom/ipc/jsactor/JSWindowActorParent.cpp b/dom/ipc/jsactor/JSWindowActorParent.cpp
new file mode 100644
index 0000000000..0bb82a9b8e
--- /dev/null
+++ b/dom/ipc/jsactor/JSWindowActorParent.cpp
@@ -0,0 +1,102 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "mozilla/dom/JSWindowActorBinding.h"
+#include "mozilla/dom/JSWindowActorParent.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/WindowGlobalChild.h"
+#include "mozilla/dom/WindowGlobalParent.h"
+#include "mozilla/dom/MessageManagerBinding.h"
+
+namespace mozilla::dom {
+
+JSWindowActorParent::~JSWindowActorParent() { MOZ_ASSERT(!mManager); }
+
+JSObject* JSWindowActorParent::WrapObject(JSContext* aCx,
+                                          JS::Handle<JSObject*> aGivenProto) {
+  return JSWindowActorParent_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+WindowGlobalParent* JSWindowActorParent::GetManager() const { return mManager; }
+
+WindowContext* JSWindowActorParent::GetWindowContext() const {
+  return mManager;
+}
+
+void JSWindowActorParent::Init(const nsACString& aName,
+                               WindowGlobalParent* aManager) {
+  MOZ_ASSERT(!mManager, "Cannot Init() a JSWindowActorParent twice!");
+  SetName(aName);
+  mManager = aManager;
+
+  InvokeCallback(CallbackFunction::ActorCreated);
+}
+
+void JSWindowActorParent::SendRawMessage(
+    const JSActorMessageMeta& aMeta, Maybe<ipc::StructuredCloneData>&& aData,
+    Maybe<ipc::StructuredCloneData>&& aStack, ErrorResult& aRv) {
+  if (NS_WARN_IF(!CanSend() || !mManager || !mManager->CanSend())) {
+    aRv.ThrowInvalidStateError("JSWindowActorParent cannot send at the moment");
+    return;
+  }
+
+  if (mManager->IsInProcess()) {
+    SendRawMessageInProcess(
+        aMeta, std::move(aData), std::move(aStack),
+        [manager{mManager}]() { return manager->GetChildActor(); });
+    return;
+  }
+
+  Maybe<ClonedMessageData> msgData;
+  if (aData) {
+    msgData.emplace();
+    if (NS_WARN_IF(!aData->BuildClonedMessageData(*msgData))) {
+      aRv.ThrowDataCloneError(
+          nsPrintfCString("JSWindowActorParent serialization error: cannot "
+                          "clone, in actor '%s'",
+                          PromiseFlatCString(aMeta.actorName()).get()));
+      return;
+    }
+  }
+
+  Maybe<ClonedMessageData> stackData;
+  if (aStack) {
+    stackData.emplace();
+    if (!aStack->BuildClonedMessageData(*stackData)) {
+      stackData.reset();
+    }
+  }
+
+  if (NS_WARN_IF(!mManager->SendRawMessage(aMeta, msgData, stackData))) {
+    aRv.ThrowOperationError(
+        nsPrintfCString("JSWindowActorParent send error in actor '%s'",
+                        PromiseFlatCString(aMeta.actorName()).get()));
+    return;
+  }
+}
+
+CanonicalBrowsingContext* JSWindowActorParent::GetBrowsingContext(
+    ErrorResult& aRv) {
+  if (!mManager) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return nullptr;
+  }
+
+  return mManager->BrowsingContext();
+}
+
+void JSWindowActorParent::ClearManager() { mManager = nullptr; }
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(JSWindowActorParent, JSActor, mManager)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(JSWindowActorParent)
+NS_INTERFACE_MAP_END_INHERITING(JSActor)
+
+NS_IMPL_ADDREF_INHERITED(JSWindowActorParent, JSActor)
+NS_IMPL_RELEASE_INHERITED(JSWindowActorParent, JSActor)
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/jsactor/JSWindowActorParent.h b/dom/ipc/jsactor/JSWindowActorParent.h
new file mode 100644
index 0000000000..05fb88f8ac
--- /dev/null
+++ b/dom/ipc/jsactor/JSWindowActorParent.h
@@ -0,0 +1,66 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef mozilla_dom_JSWindowActorParent_h
+#define mozilla_dom_JSWindowActorParent_h
+
+#include "js/TypeDecls.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/JSActor.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsWrapperCache.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class WindowGlobalParent;
+
+}  // namespace dom
+}  // namespace mozilla
+
+namespace mozilla::dom {
+
+class JSWindowActorParent final : public JSActor {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(JSWindowActorParent, JSActor)
+
+  explicit JSWindowActorParent(nsISupports* aGlobal = nullptr)
+      : JSActor(aGlobal) {}
+
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override;
+
+  static already_AddRefed<JSWindowActorParent> Constructor(
+      GlobalObject& aGlobal) {
+    return MakeAndAddRef<JSWindowActorParent>(aGlobal.GetAsSupports());
+  }
+
+  WindowGlobalParent* GetManager() const;
+  WindowContext* GetWindowContext() const;
+  void Init(const nsACString& aName, WindowGlobalParent* aManager);
+  void ClearManager() override;
+  CanonicalBrowsingContext* GetBrowsingContext(ErrorResult& aRv);
+
+ protected:
+  void SendRawMessage(const JSActorMessageMeta& aMeta,
+                      Maybe<ipc::StructuredCloneData>&& aData,
+                      Maybe<ipc::StructuredCloneData>&& aStack,
+                      ErrorResult& aRv) override;
+
+ private:
+  ~JSWindowActorParent();
+
+  RefPtr<WindowGlobalParent> mManager;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_JSWindowActorParent_h
diff --git a/dom/ipc/jsactor/JSWindowActorProtocol.cpp b/dom/ipc/jsactor/JSWindowActorProtocol.cpp
new file mode 100644
index 0000000000..a459d94204
--- /dev/null
+++ b/dom/ipc/jsactor/JSWindowActorProtocol.cpp
@@ -0,0 +1,380 @@
+/* -*- 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 "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/JSActorBinding.h"
+#include "mozilla/dom/JSActorService.h"
+#include "mozilla/dom/JSWindowActorBinding.h"
+#include "mozilla/dom/JSWindowActorChild.h"
+#include "mozilla/dom/JSWindowActorProtocol.h"
+#include "mozilla/dom/PContent.h"
+#include "mozilla/dom/WindowGlobalChild.h"
+
+#include "mozilla/extensions/MatchPattern.h"
+#include "nsContentUtils.h"
+#include "JSActorProtocolUtils.h"
+
+namespace mozilla::dom {
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(JSWindowActorProtocol)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(JSWindowActorProtocol)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(JSWindowActorProtocol)
+  NS_INTERFACE_MAP_ENTRY(nsIObserver)
+  NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTION(JSWindowActorProtocol)
+
+/* static */ already_AddRefed<JSWindowActorProtocol>
+JSWindowActorProtocol::FromIPC(const JSWindowActorInfo& aInfo) {
+  MOZ_DIAGNOSTIC_ASSERT(XRE_IsContentProcess());
+
+  RefPtr<JSWindowActorProtocol> proto = new JSWindowActorProtocol(aInfo.name());
+  JSActorProtocolUtils::FromIPCShared(proto, aInfo);
+
+  // Content processes cannot load chrome browsing contexts, so this flag is
+  // irrelevant and not propagated.
+  proto->mIncludeChrome = false;
+  proto->mAllFrames = aInfo.allFrames();
+  proto->mMatches = aInfo.matches().Clone();
+  proto->mMessageManagerGroups = aInfo.messageManagerGroups().Clone();
+
+  proto->mChild.mEvents.SetCapacity(aInfo.events().Length());
+  for (auto& ipc : aInfo.events()) {
+    auto event = proto->mChild.mEvents.AppendElement();
+    event->mName.Assign(ipc.name());
+    event->mFlags.mCapture = ipc.capture();
+    event->mFlags.mInSystemGroup = ipc.systemGroup();
+    event->mFlags.mAllowUntrustedEvents = ipc.allowUntrusted();
+    if (ipc.passive()) {
+      event->mPassive.Construct(ipc.passive().value());
+    }
+    event->mCreateActor = ipc.createActor();
+  }
+
+  return proto.forget();
+}
+
+JSWindowActorInfo JSWindowActorProtocol::ToIPC() {
+  MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess());
+
+  JSWindowActorInfo info;
+  JSActorProtocolUtils::ToIPCShared(info, this);
+
+  info.allFrames() = mAllFrames;
+  info.matches() = mMatches.Clone();
+  info.messageManagerGroups() = mMessageManagerGroups.Clone();
+
+  info.events().SetCapacity(mChild.mEvents.Length());
+  for (auto& event : mChild.mEvents) {
+    auto ipc = info.events().AppendElement();
+    ipc->name().Assign(event.mName);
+    ipc->capture() = event.mFlags.mCapture;
+    ipc->systemGroup() = event.mFlags.mInSystemGroup;
+    ipc->allowUntrusted() = event.mFlags.mAllowUntrustedEvents;
+    if (event.mPassive.WasPassed()) {
+      ipc->passive() = Some(event.mPassive.Value());
+    }
+    ipc->createActor() = event.mCreateActor;
+  }
+
+  return info;
+}
+
+already_AddRefed<JSWindowActorProtocol>
+JSWindowActorProtocol::FromWebIDLOptions(const nsACString& aName,
+                                         const WindowActorOptions& aOptions,
+                                         ErrorResult& aRv) {
+  MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess());
+
+  RefPtr<JSWindowActorProtocol> proto = new JSWindowActorProtocol(aName);
+  if (!JSActorProtocolUtils::FromWebIDLOptionsShared(proto, aOptions, aRv)) {
+    return nullptr;
+  }
+
+  proto->mAllFrames = aOptions.mAllFrames;
+  proto->mIncludeChrome = aOptions.mIncludeChrome;
+
+  if (aOptions.mMatches.WasPassed()) {
+    MOZ_ASSERT(aOptions.mMatches.Value().Length());
+    proto->mMatches = aOptions.mMatches.Value();
+  }
+
+  if (aOptions.mMessageManagerGroups.WasPassed()) {
+    proto->mMessageManagerGroups = aOptions.mMessageManagerGroups.Value();
+  }
+
+  // For each event declared in the source dictionary, initialize the
+  // corresponding event declaration entry in the JSWindowActorProtocol.
+  if (aOptions.mChild.WasPassed() &&
+      aOptions.mChild.Value().mEvents.WasPassed()) {
+    auto& entries = aOptions.mChild.Value().mEvents.Value().Entries();
+    proto->mChild.mEvents.SetCapacity(entries.Length());
+
+    for (auto& entry : entries) {
+      // We don't support the mOnce field, as it doesn't work well in this
+      // environment. For now, throw an error in that case.
+      if (entry.mValue.mOnce) {
+        aRv.ThrowNotSupportedError("mOnce is not supported");
+        return nullptr;
+      }
+
+      // Add the EventDecl to our list of events.
+      EventDecl* evt = proto->mChild.mEvents.AppendElement();
+      evt->mName = entry.mKey;
+      evt->mFlags.mCapture = entry.mValue.mCapture;
+      evt->mFlags.mInSystemGroup = entry.mValue.mMozSystemGroup;
+      evt->mFlags.mAllowUntrustedEvents =
+          entry.mValue.mWantUntrusted.WasPassed()
+              ? entry.mValue.mWantUntrusted.Value()
+              : false;
+      if (entry.mValue.mPassive.WasPassed()) {
+        evt->mPassive.Construct(entry.mValue.mPassive.Value());
+      }
+      evt->mCreateActor = entry.mValue.mCreateActor;
+    }
+  }
+
+  return proto.forget();
+}
+
+/**
+ * This listener only listens for events for the child side of the protocol.
+ * This will work in both content and parent processes.
+ */
+NS_IMETHODIMP JSWindowActorProtocol::HandleEvent(Event* aEvent) {
+  MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
+
+  // Determine which inner window we're associated with, and get its
+  // WindowGlobalChild actor.
+  EventTarget* target = aEvent->GetOriginalTarget();
+  if (NS_WARN_IF(!target)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsPIDOMWindowInner> inner =
+      do_QueryInterface(target->GetOwnerGlobal());
+  if (NS_WARN_IF(!inner)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  RefPtr<WindowGlobalChild> wgc = inner->GetWindowGlobalChild();
+  if (NS_WARN_IF(!wgc)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (aEvent->ShouldIgnoreChromeEventTargetListener()) {
+    return NS_OK;
+  }
+
+  // Ensure our actor is present.
+  RefPtr<JSActor> actor = wgc->GetExistingActor(mName);
+  if (!actor) {
+    // Check if we're supposed to create the actor when this event is fired.
+    bool createActor = true;
+    nsAutoString typeStr;
+    aEvent->GetType(typeStr);
+    for (auto& event : mChild.mEvents) {
+      if (event.mName == typeStr) {
+        createActor = event.mCreateActor;
+        break;
+      }
+    }
+
+    // If we're supposed to create the actor, call GetActor to cause it to be
+    // created.
+    if (createActor) {
+      AutoJSAPI jsapi;
+      jsapi.Init();
+      actor = wgc->GetActor(jsapi.cx(), mName, IgnoreErrors());
+    }
+  }
+  if (!actor || NS_WARN_IF(!actor->GetWrapperPreserveColor())) {
+    return NS_OK;
+  }
+
+  // Build our event listener & call it.
+  JS::Rooted<JSObject*> global(RootingCx(),
+                               JS::GetNonCCWObjectGlobal(actor->GetWrapper()));
+  RefPtr<EventListener> eventListener =
+      new EventListener(actor->GetWrapper(), global, nullptr, nullptr);
+  eventListener->HandleEvent(*aEvent, "JSWindowActorProtocol::HandleEvent");
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSWindowActorProtocol::Observe(nsISupports* aSubject,
+                                             const char* aTopic,
+                                             const char16_t* aData) {
+  MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
+
+  nsCOMPtr<nsPIDOMWindowInner> inner = do_QueryInterface(aSubject);
+  RefPtr<WindowGlobalChild> wgc;
+
+  if (!inner) {
+    nsCOMPtr<nsPIDOMWindowOuter> outer = do_QueryInterface(aSubject);
+    if (NS_WARN_IF(!outer)) {
+      nsContentUtils::LogSimpleConsoleError(
+          NS_ConvertUTF8toUTF16(nsPrintfCString(
+              "JSWindowActor %s: expected window subject for topic '%s'.",
+              mName.get(), aTopic)),
+          "JSActor"_ns,
+          /* aFromPrivateWindow */ false,
+          /* aFromChromeContext */ true);
+      return NS_ERROR_FAILURE;
+    }
+    if (NS_WARN_IF(!outer->GetCurrentInnerWindow())) {
+      return NS_ERROR_FAILURE;
+    }
+    wgc = outer->GetCurrentInnerWindow()->GetWindowGlobalChild();
+  } else {
+    wgc = inner->GetWindowGlobalChild();
+  }
+
+  if (NS_WARN_IF(!wgc)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Ensure our actor is present.
+  AutoJSAPI jsapi;
+  jsapi.Init();
+  RefPtr<JSActor> actor = wgc->GetActor(jsapi.cx(), mName, IgnoreErrors());
+  if (!actor || NS_WARN_IF(!actor->GetWrapperPreserveColor())) {
+    return NS_OK;
+  }
+
+  // Build a observer callback.
+  JS::Rooted<JSObject*> global(jsapi.cx(),
+                               JS::GetNonCCWObjectGlobal(actor->GetWrapper()));
+  RefPtr<MozObserverCallback> observerCallback =
+      new MozObserverCallback(actor->GetWrapper(), global, nullptr, nullptr);
+  observerCallback->Observe(aSubject, nsDependentCString(aTopic),
+                            aData ? nsDependentString(aData) : VoidString());
+  return NS_OK;
+}
+
+void JSWindowActorProtocol::RegisterListenersFor(EventTarget* aTarget) {
+  EventListenerManager* elm = aTarget->GetOrCreateListenerManager();
+
+  for (auto& event : mChild.mEvents) {
+    elm->AddEventListenerByType(EventListenerHolder(this), event.mName,
+                                event.mFlags, event.mPassive);
+  }
+}
+
+void JSWindowActorProtocol::UnregisterListenersFor(EventTarget* aTarget) {
+  EventListenerManager* elm = aTarget->GetOrCreateListenerManager();
+
+  for (auto& event : mChild.mEvents) {
+    elm->RemoveEventListenerByType(EventListenerHolder(this), event.mName,
+                                   event.mFlags);
+  }
+}
+
+void JSWindowActorProtocol::AddObservers() {
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  for (auto& topic : mChild.mObservers) {
+    // This makes the observer service hold an owning reference to the
+    // JSWindowActorProtocol. The JSWindowActorProtocol objects will be living
+    // for the full lifetime of the content process, thus the extra strong
+    // referencec doesn't have a negative impact.
+    os->AddObserver(this, topic.get(), false);
+  }
+}
+
+void JSWindowActorProtocol::RemoveObservers() {
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  for (auto& topic : mChild.mObservers) {
+    os->RemoveObserver(this, topic.get());
+  }
+}
+
+extensions::MatchPatternSetCore* JSWindowActorProtocol::GetURIMatcher() {
+  // If we've already created the pattern set, return it.
+  if (mURIMatcher || mMatches.IsEmpty()) {
+    return mURIMatcher;
+  }
+
+  nsTArray<RefPtr<extensions::MatchPatternCore>> patterns(mMatches.Length());
+  for (const nsString& pattern : mMatches) {
+    patterns.AppendElement(new extensions::MatchPatternCore(
+        pattern, false, false, IgnoreErrors()));
+  }
+  mURIMatcher = new extensions::MatchPatternSetCore(std::move(patterns));
+  return mURIMatcher;
+}
+
+bool JSWindowActorProtocol::RemoteTypePrefixMatches(
+    const nsDependentCSubstring& aRemoteType) {
+  for (auto& remoteType : mRemoteTypes) {
+    if (StringBeginsWith(aRemoteType, remoteType)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool JSWindowActorProtocol::MessageManagerGroupMatches(
+    BrowsingContext* aBrowsingContext) {
+  BrowsingContext* top = aBrowsingContext->Top();
+  for (auto& group : mMessageManagerGroups) {
+    if (group == top->GetMessageManagerGroup()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool JSWindowActorProtocol::Matches(BrowsingContext* aBrowsingContext,
+                                    nsIURI* aURI, const nsACString& aRemoteType,
+                                    ErrorResult& aRv) {
+  MOZ_ASSERT(aBrowsingContext, "DocShell without a BrowsingContext!");
+  MOZ_ASSERT(aURI, "Must have URI!");
+
+  if (!mAllFrames && aBrowsingContext->GetParent()) {
+    aRv.ThrowNotSupportedError(nsPrintfCString(
+        "Window protocol '%s' doesn't match subframes", mName.get()));
+    return false;
+  }
+
+  if (!mIncludeChrome && !aBrowsingContext->IsContent()) {
+    aRv.ThrowNotSupportedError(nsPrintfCString(
+        "Window protocol '%s' doesn't match chrome browsing contexts",
+        mName.get()));
+    return false;
+  }
+
+  if (!mRemoteTypes.IsEmpty() &&
+      !RemoteTypePrefixMatches(RemoteTypePrefix(aRemoteType))) {
+    aRv.ThrowNotSupportedError(
+        nsPrintfCString("Window protocol '%s' doesn't match remote type '%s'",
+                        mName.get(), PromiseFlatCString(aRemoteType).get()));
+    return false;
+  }
+
+  if (!mMessageManagerGroups.IsEmpty() &&
+      !MessageManagerGroupMatches(aBrowsingContext)) {
+    aRv.ThrowNotSupportedError(nsPrintfCString(
+        "Window protocol '%s' doesn't match message manager group",
+        mName.get()));
+    return false;
+  }
+
+  if (extensions::MatchPatternSetCore* uriMatcher = GetURIMatcher()) {
+    if (!uriMatcher->Matches(aURI)) {
+      aRv.ThrowNotSupportedError(nsPrintfCString(
+          "Window protocol '%s' doesn't match uri %s", mName.get(),
+          nsContentUtils::TruncatedURLForDisplay(aURI).get()));
+      return false;
+    }
+  }
+
+  return true;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/ipc/jsactor/JSWindowActorProtocol.h b/dom/ipc/jsactor/JSWindowActorProtocol.h
new file mode 100644
index 0000000000..b0128d9307
--- /dev/null
+++ b/dom/ipc/jsactor/JSWindowActorProtocol.h
@@ -0,0 +1,103 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_JSWindowActorProtocol_h
+#define mozilla_dom_JSWindowActorProtocol_h
+
+#include "mozilla/dom/BrowsingContext.h"
+#include "mozilla/dom/JSActorService.h"
+#include "mozilla/extensions/MatchPattern.h"
+#include "nsIURI.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "nsIObserver.h"
+#include "nsIDOMEventListener.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+struct WindowActorOptions;
+class JSWindowActorInfo;
+class EventTarget;
+class JSActorProtocolUtils;
+
+/**
+ * Object corresponding to a single window actor protocol. This object acts as
+ * an Event listener for the actor which is called for events which would
+ * trigger actor creation.
+ *
+ * This object also can act as a carrier for methods and other state related to
+ * a single protocol managed by the JSActorService.
+ */
+class JSWindowActorProtocol final : public JSActorProtocol,
+                                    public nsIObserver,
+                                    public nsIDOMEventListener {
+ public:
+  NS_DECL_NSIOBSERVER
+  NS_DECL_NSIDOMEVENTLISTENER
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(JSWindowActorProtocol, nsIObserver)
+
+  static already_AddRefed<JSWindowActorProtocol> FromIPC(
+      const JSWindowActorInfo& aInfo);
+  JSWindowActorInfo ToIPC();
+
+  static already_AddRefed<JSWindowActorProtocol> FromWebIDLOptions(
+      const nsACString& aName, const WindowActorOptions& aOptions,
+      ErrorResult& aRv);
+
+  struct ParentSide : public Sided {};
+
+  struct EventDecl {
+    nsString mName;
+    EventListenerFlags mFlags;
+    Optional<bool> mPassive;
+    bool mCreateActor = true;
+  };
+
+  struct ChildSide : public Sided {
+    nsTArray<EventDecl> mEvents;
+    nsTArray<nsCString> mObservers;
+  };
+
+  const ParentSide& Parent() const override { return mParent; }
+  const ChildSide& Child() const override { return mChild; }
+
+  void RegisterListenersFor(EventTarget* aTarget);
+  void UnregisterListenersFor(EventTarget* aTarget);
+  void AddObservers();
+  void RemoveObservers();
+  bool Matches(BrowsingContext* aBrowsingContext, nsIURI* aURI,
+               const nsACString& aRemoteType, ErrorResult& aRv);
+
+ private:
+  explicit JSWindowActorProtocol(const nsACString& aName) : mName(aName) {}
+  extensions::MatchPatternSetCore* GetURIMatcher();
+  bool RemoteTypePrefixMatches(const nsDependentCSubstring& aRemoteType);
+  bool MessageManagerGroupMatches(BrowsingContext* aBrowsingContext);
+  ~JSWindowActorProtocol() = default;
+
+  nsCString mName;
+  bool mAllFrames = false;
+  bool mIncludeChrome = false;
+  nsTArray<nsString> mMatches;
+  nsTArray<nsCString> mRemoteTypes;
+  nsTArray<nsString> mMessageManagerGroups;
+
+  friend class JSActorProtocolUtils;
+
+  ParentSide mParent;
+  ChildSide mChild;
+
+  RefPtr<extensions::MatchPatternSetCore> mURIMatcher;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_JSWindowActorProtocol_h
diff --git a/dom/ipc/jsactor/moz.build b/dom/ipc/jsactor/moz.build
new file mode 100644
index 0000000000..6bc66df923
--- /dev/null
+++ b/dom/ipc/jsactor/moz.build
@@ -0,0 +1,42 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+EXPORTS.mozilla.dom += [
+    "JSActor.h",
+    "JSActorManager.h",
+    "JSActorService.h",
+    "JSProcessActorChild.h",
+    "JSProcessActorParent.h",
+    "JSProcessActorProtocol.h",
+    "JSWindowActorChild.h",
+    "JSWindowActorParent.h",
+    "JSWindowActorProtocol.h",
+]
+
+EXPORTS += [
+    "nsQueryActor.h",
+]
+
+UNIFIED_SOURCES += [
+    "JSActor.cpp",
+    "JSActorManager.cpp",
+    "JSActorService.cpp",
+    "JSProcessActorChild.cpp",
+    "JSProcessActorParent.cpp",
+    "JSProcessActorProtocol.cpp",
+    "JSWindowActorChild.cpp",
+    "JSWindowActorParent.cpp",
+    "JSWindowActorProtocol.cpp",
+]
+
+LOCAL_INCLUDES += [
+    "/js/xpconnect/loader",
+    "/js/xpconnect/src",
+]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+FINAL_LIBRARY = "xul"
diff --git a/dom/ipc/jsactor/nsQueryActor.h b/dom/ipc/jsactor/nsQueryActor.h
new file mode 100644
index 0000000000..cbbda7e473
--- /dev/null
+++ b/dom/ipc/jsactor/nsQueryActor.h
@@ -0,0 +1,90 @@
+/* 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/. */
+
+#ifndef nsQueryActor_h
+#define nsQueryActor_h
+
+#include <type_traits>
+
+#include "nsCOMPtr.h"
+#include "nsPIDOMWindow.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/JSActor.h"
+#include "mozilla/dom/JSActorManager.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/dom/WindowGlobalChild.h"
+
+class nsIDOMProcessChild;
+class nsIDOMProcessParent;
+
+// This type is used to get an XPCOM interface implemented by a JSActor from its
+// native manager.
+class MOZ_STACK_CLASS nsQueryJSActor final : public nsCOMPtr_helper {
+ public:
+  nsQueryJSActor(const nsLiteralCString aActorName,
+                 mozilla::dom::JSActorManager* aManager)
+      : mActorName(aActorName), mManager(aManager) {}
+
+  nsresult NS_FASTCALL operator()(const nsIID& aIID,
+                                  void** aResult) const override {
+    if (!mManager) {
+      return NS_ERROR_NO_INTERFACE;
+    }
+
+    mozilla::dom::AutoJSAPI jsapi;
+    jsapi.Init();
+
+    RefPtr<mozilla::dom::JSActor> actor =
+        mManager->GetActor(jsapi.cx(), mActorName, mozilla::IgnoreErrors());
+    if (!actor) {
+      return NS_ERROR_NO_INTERFACE;
+    }
+
+    return actor->QueryInterfaceActor(aIID, aResult);
+  }
+
+ private:
+  const nsLiteralCString mActorName;
+  mozilla::dom::JSActorManager* mManager;
+};
+
+// Request an XPCOM interface from a JSActor managed by `aManager`.
+//
+// These APIs will work with both JSWindowActors and JSProcessActors.
+template <size_t length>
+inline nsQueryJSActor do_QueryActor(const char (&aActorName)[length],
+                                    mozilla::dom::JSActorManager* aManager) {
+  return nsQueryJSActor(nsLiteralCString(aActorName), aManager);
+}
+
+// Overload for directly querying a JSWindowActorChild from an inner window.
+template <size_t length>
+inline nsQueryJSActor do_QueryActor(const char (&aActorName)[length],
+                                    nsPIDOMWindowInner* aWindow) {
+  return nsQueryJSActor(nsLiteralCString(aActorName),
+                        aWindow ? aWindow->GetWindowGlobalChild() : nullptr);
+}
+
+// Overload for directly querying a JSWindowActorChild from a document.
+template <size_t length>
+inline nsQueryJSActor do_QueryActor(const char (&aActorName)[length],
+                                    mozilla::dom::Document* aDoc) {
+  return nsQueryJSActor(nsLiteralCString(aActorName),
+                        aDoc ? aDoc->GetWindowGlobalChild() : nullptr);
+}
+
+// Overload for directly querying from a nsIDOMProcess{Parent,Child} without
+// confusing overload selection for types inheriting from both
+// nsIDOMProcess{Parent,Child} and JSActorManager.
+template <size_t length, typename T,
+          typename = std::enable_if_t<std::is_same_v<T, nsIDOMProcessParent> ||
+                                      std::is_same_v<T, nsIDOMProcessChild>>>
+inline nsQueryJSActor do_QueryActor(const char (&aActorName)[length],
+                                    T* aManager) {
+  return nsQueryJSActor(nsLiteralCString(aActorName),
+                        aManager ? aManager->AsJSActorManager() : nullptr);
+}
+
+#endif  // defined nsQueryActor_h
diff --git a/dom/ipc/moz.build b/dom/ipc/moz.build
new file mode 100644
index 0000000000..79f8bbc6d8
--- /dev/null
+++ b/dom/ipc/moz.build
@@ -0,0 +1,274 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+with Files("**"):
+    BUG_COMPONENT = ("Core", "DOM: Content Processes")
+
+DIRS += ["jsactor"]
+
+XPIDL_SOURCES += [
+    "nsIDOMProcessChild.idl",
+    "nsIDOMProcessParent.idl",
+    "nsIHangReport.idl",
+    "nsILoginDetectionService.idl",
+]
+
+XPIDL_MODULE = "dom"
+
+XPCOM_MANIFESTS += [
+    "components.conf",
+]
+
+EXTRA_JS_MODULES += [
+    "ManifestMessagesChild.sys.mjs",
+]
+
+EXPORTS.mozilla.dom.ipc += [
+    "IdType.h",
+    "MemMapSnapshot.h",
+    "SharedMap.h",
+    "SharedMapChangeEvent.h",
+    "SharedStringMap.h",
+    "StringTable.h",
+    "StructuredCloneData.h",
+]
+
+EXPORTS.mozilla.dom += [
+    "BrowserBridgeChild.h",
+    "BrowserBridgeHost.h",
+    "BrowserBridgeParent.h",
+    "BrowserChild.h",
+    "BrowserHost.h",
+    "BrowserParent.h",
+    "ClonedErrorHolder.h",
+    "CoalescedInputData.h",
+    "CoalescedMouseData.h",
+    "CoalescedTouchData.h",
+    "CoalescedWheelData.h",
+    "ContentChild.h",
+    "ContentParent.h",
+    "ContentProcess.h",
+    "ContentProcessManager.h",
+    "CSPMessageUtils.h",
+    "DocShellMessageUtils.h",
+    "EffectsInfo.h",
+    "FilePickerMessageUtils.h",
+    "FilePickerParent.h",
+    "InProcessChild.h",
+    "InProcessParent.h",
+    "JSOracleChild.h",
+    "JSOracleParent.h",
+    "JSValidatorChild.h",
+    "JSValidatorParent.h",
+    "JSValidatorUtils.h",
+    "LoginDetectionService.h",
+    "MaybeDiscarded.h",
+    "MemoryReportRequest.h",
+    "NativeThreadId.h",
+    "PageLoadEventUtils.h",
+    "PermissionMessageUtils.h",
+    "ProcessActor.h",
+    "ProcessIsolation.h",
+    "PropertyBagUtils.h",
+    "ReferrerInfoUtils.h",
+    "RefMessageBodyService.h",
+    "RemoteBrowser.h",
+    "RemoteType.h",
+    "RemoteWebProgressRequest.h",
+    "SharedMessageBody.h",
+    "TabContext.h",
+    "TabMessageTypes.h",
+    "TabMessageUtils.h",
+    "URLClassifierChild.h",
+    "URLClassifierParent.h",
+    "UserActivationIPCUtils.h",
+    "VsyncChild.h",
+    "VsyncMainChild.h",
+    "VsyncParent.h",
+    "VsyncWorkerChild.h",
+    "WindowGlobalActor.h",
+    "WindowGlobalChild.h",
+    "WindowGlobalParent.h",
+]
+
+EXPORTS.mozilla += [
+    "PreallocatedProcessManager.h",
+    "ProcessHangMonitor.h",
+    "ProcessHangMonitorIPC.h",
+    "ProcessPriorityManager.h",
+]
+
+UNIFIED_SOURCES += [
+    "BrowserBridgeChild.cpp",
+    "BrowserBridgeHost.cpp",
+    "BrowserBridgeParent.cpp",
+    "BrowserChild.cpp",
+    "BrowserHost.cpp",
+    "BrowserParent.cpp",
+    "ClonedErrorHolder.cpp",
+    "CoalescedInputData.cpp",
+    "CoalescedMouseData.cpp",
+    "CoalescedTouchData.cpp",
+    "CoalescedWheelData.cpp",
+    "ColorPickerParent.cpp",
+    "ContentParent.cpp",
+    "ContentProcess.cpp",
+    "ContentProcessManager.cpp",
+    "CSPMessageUtils.cpp",
+    "DocShellMessageUtils.cpp",
+    "FilePickerParent.cpp",
+    "InProcessImpl.cpp",
+    "JSOracleChild.cpp",
+    "JSOracleParent.cpp",
+    "JSValidatorChild.cpp",
+    "JSValidatorParent.cpp",
+    "JSValidatorUtils.cpp",
+    "LoginDetectionService.cpp",
+    "MemMapSnapshot.cpp",
+    "MemoryReportRequest.cpp",
+    "MMPrinter.cpp",
+    "PermissionMessageUtils.cpp",
+    "PreallocatedProcessManager.cpp",
+    "ProcessActor.cpp",
+    "ProcessIsolation.cpp",
+    "ProcessPriorityManager.cpp",
+    "PropertyBagUtils.cpp",
+    "ReferrerInfoUtils.cpp",
+    "RefMessageBodyService.cpp",
+    "RemoteBrowser.cpp",
+    "RemoteWebProgressRequest.cpp",
+    "SharedMap.cpp",
+    "SharedMessageBody.cpp",
+    "SharedStringMap.cpp",
+    "StructuredCloneData.cpp",
+    "TabContext.cpp",
+    "URLClassifierParent.cpp",
+    "WindowGlobalActor.cpp",
+    "WindowGlobalChild.cpp",
+    "WindowGlobalParent.cpp",
+]
+
+# ContentChild.cpp cannot be compiled in unified mode on  linux due to Time conflict
+SOURCES += [
+    "ContentChild.cpp",
+    "ProcessHangMonitor.cpp",
+    "VsyncMainChild.cpp",
+    "VsyncParent.cpp",
+    "VsyncWorkerChild.cpp",
+]
+
+PREPROCESSED_IPDL_SOURCES += [
+    "PBrowser.ipdl",
+    "PBrowserBridge.ipdl",
+    "PContent.ipdl",
+]
+
+IPDL_SOURCES += [
+    "DOMTypes.ipdlh",
+    "IPCTransferable.ipdlh",
+    "MemoryReportTypes.ipdlh",
+    "PColorPicker.ipdl",
+    "PContentPermission.ipdlh",
+    "PContentPermissionRequest.ipdl",
+    "PCycleCollectWithLogs.ipdl",
+    "PFilePicker.ipdl",
+    "PInProcess.ipdl",
+    "PJSOracle.ipdl",
+    "PJSValidator.ipdl",
+    "PLoginReputation.ipdl",
+    "PProcessHangMonitor.ipdl",
+    "PrefsTypes.ipdlh",
+    "PTabContext.ipdlh",
+    "PURLClassifier.ipdl",
+    "PURLClassifierInfo.ipdlh",
+    "PURLClassifierLocal.ipdl",
+    "PVsync.ipdl",
+    "PWindowGlobal.ipdl",
+    "ServiceWorkerConfiguration.ipdlh",
+    "WindowGlobalTypes.ipdlh",
+]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+FINAL_LIBRARY = "xul"
+
+if CONFIG["MOZ_SANDBOX"] and (CONFIG["OS_TARGET"] in ["Darwin", "Linux"]):
+    USE_LIBS += [
+        "mozsandbox",
+    ]
+
+LOCAL_INCLUDES += [
+    "/caps",
+    "/chrome",
+    "/docshell/base",
+    "/dom/base",
+    "/dom/bindings",
+    "/dom/events",
+    "/dom/filesystem",
+    "/dom/geolocation",
+    "/dom/media/webrtc",
+    "/dom/media/webspeech/synth/ipc",
+    "/dom/security",
+    "/dom/storage",
+    "/extensions/spellcheck/src",
+    "/gfx/2d",
+    "/hal/sandbox",
+    "/js/xpconnect/loader",
+    "/js/xpconnect/src",
+    "/layout/base",
+    "/media/webrtc",
+    "/netwerk/base",
+    "/netwerk/dns",
+    "/netwerk/protocol/http",
+    "/toolkit/components/printingui/ipc",
+    "/toolkit/crashreporter",
+    "/toolkit/xre",
+    "/uriloader/exthandler",
+    "/widget",
+    "/xpcom/base",
+    "/xpcom/threads",
+]
+
+if CONFIG["MOZ_SANDBOX"] and CONFIG["OS_ARCH"] == "WINNT":
+    LOCAL_INCLUDES += [
+        "/security/sandbox/chromium",
+        "/security/sandbox/chromium-shim",
+    ]
+
+if CONFIG["MOZ_SANDBOX"] and CONFIG["OS_ARCH"] == "OpenBSD":
+    LOCAL_INCLUDES += [
+        "/xpcom/build",
+    ]
+
+if CONFIG["OS_ARCH"] != "WINNT":
+    LOCAL_INCLUDES += [
+        "/modules/libjar",
+    ]
+
+DEFINES["BIN_SUFFIX"] = '"%s"' % CONFIG["BIN_SUFFIX"]
+
+DEFINES["MOZ_APP_NAME"] = '"%s"' % CONFIG["MOZ_APP_NAME"]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"] == "android":
+    DEFINES["MOZ_ENABLE_FREETYPE"] = True
+
+JAR_MANIFESTS += ["jar.mn"]
+
+BROWSER_CHROME_MANIFESTS += [
+    "tests/browser.ini",
+    "tests/JSProcessActor/browser.ini",
+    "tests/JSWindowActor/browser.ini",
+]
+
+MOCHITEST_CHROME_MANIFESTS += ["tests/chrome.ini"]
+MOCHITEST_MANIFESTS += ["tests/mochitest.ini"]
+XPCSHELL_TESTS_MANIFESTS += ["tests/xpcshell.ini"]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"] == "gtk":
+    CXXFLAGS += CONFIG["MOZ_GTK3_CFLAGS"]
+
+# Add libFuzzer configuration directives
+include("/tools/fuzzing/libfuzzer-config.mozbuild")
diff --git a/dom/ipc/nsIDOMProcessChild.idl b/dom/ipc/nsIDOMProcessChild.idl
new file mode 100644
index 0000000000..ff6875f395
--- /dev/null
+++ b/dom/ipc/nsIDOMProcessChild.idl
@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "nsISupports.idl"
+
+%{C++
+namespace mozilla {
+namespace dom {
+class ContentChild;
+class JSActorManager;
+} // namespace dom
+} // namespace mozilla
+%}
+[ptr] native ContentChildPtr(mozilla::dom::ContentChild);
+[ptr] native JSActorManagerPtr(mozilla::dom::JSActorManager);
+
+webidl JSProcessActorChild;
+
+/**
+ * Child actor interface for a process which can host DOM content.
+ *
+ * Implemented by either `InProcessChild` for the parent process, or
+ * `ContentChild` for a content process.
+ */
+[scriptable, builtinclass, uuid(b0c6e5f3-02f1-4f11-a0af-336fc231f3bf)]
+interface nsIDOMProcessChild: nsISupports {
+  %{C++
+  /**
+   * Get the nsIDOMProcessChild singleton for this content process. This will
+   * either be an InProcessChild in the parent process, or ContentChild in the
+   * child process.
+   *
+   * Implemented in ContentChild.cpp
+   */
+  static nsIDOMProcessChild* GetSingleton();
+  %}
+
+  /**
+   * Internal child process ID. `0` is reserved for the parent process.
+   */
+  [infallible] readonly attribute unsigned long long childID;
+
+  /**
+   * Lookup a JSProcessActorChild managed by this interface by name.
+   */
+  [implicit_jscontext] JSProcessActorChild getActor(in ACString name);
+  JSProcessActorChild getExistingActor(in ACString name);
+
+  /** Can the actor still send messages? */
+  [infallible] readonly attribute boolean canSend;
+
+  [notxpcom, nostdcall] ContentChildPtr AsContentChild();
+
+  /** Cast this nsIDOMProcessChild to a JSActorManager */
+  [notxpcom, nostdcall] JSActorManagerPtr AsJSActorManager();
+};
diff --git a/dom/ipc/nsIDOMProcessParent.idl b/dom/ipc/nsIDOMProcessParent.idl
new file mode 100644
index 0000000000..daa11deddf
--- /dev/null
+++ b/dom/ipc/nsIDOMProcessParent.idl
@@ -0,0 +1,58 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "nsISupports.idl"
+
+%{C++
+namespace mozilla {
+namespace dom {
+class ContentParent;
+class JSActorManager;
+} // namespace dom
+} // namespace mozilla
+%}
+[ptr] native ContentParentPtr(mozilla::dom::ContentParent);
+[ptr] native JSActorManagerPtr(mozilla::dom::JSActorManager);
+
+webidl JSProcessActorParent;
+
+/**
+ * Parent actor interface for a process which can host DOM content.
+ *
+ * Implemented by either `InProcessParent` for the parent process, or
+ * `ContentParent` for a content process.
+ */
+[scriptable, builtinclass, uuid(81fc08b9-c901-471f-ab0d-876362eba770)]
+interface nsIDOMProcessParent: nsISupports {
+  /**
+   * Internal child process ID. `0` is reserved for the parent process.
+   */
+  [infallible] readonly attribute unsigned long long childID;
+
+  /**
+   * OS ID of the process.
+   */
+  [infallible] readonly attribute long osPid;
+
+  /**
+   * Lookup a JSProcessActorParent managed by this interface by name.
+   */
+  [implicit_jscontext] JSProcessActorParent getActor(in ACString name);
+  JSProcessActorParent getExistingActor(in ACString name);
+
+  /** Can the actor still send messages? */
+  [infallible] readonly attribute boolean canSend;
+
+  [notxpcom, nostdcall] ContentParentPtr AsContentParent();
+
+  /** Cast this nsIDOMProcessParent to a JSActorManager */
+  [notxpcom, nostdcall] JSActorManagerPtr AsJSActorManager();
+
+  /**
+   * Remote type of the process.
+   */
+  readonly attribute ACString remoteType;
+};
diff --git a/dom/ipc/nsIHangReport.idl b/dom/ipc/nsIHangReport.idl
new file mode 100644
index 0000000000..ff01d7f51a
--- /dev/null
+++ b/dom/ipc/nsIHangReport.idl
@@ -0,0 +1,51 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "nsISupports.idl"
+
+webidl FrameLoader;
+webidl Element;
+
+/**
+ * When a content process hangs, Gecko notifies "process-hang-report" observers
+ * and passes an nsIHangReport for the subject parameter. There is at most one
+ * nsIHangReport associated with a given content process. As long as the content
+ * process stays stuck, the "process-hang-report" observer will continue to be
+ * notified at regular intervals (approximately once per second). The content
+ * process will continue to run uninhibitedly during this time.
+ */
+
+[scriptable, uuid(5fcffbb9-be62-49b1-b8a1-36e820787a74)]
+interface nsIHangReport : nsISupports
+{
+  readonly attribute Element scriptBrowser;
+  readonly attribute ACString scriptFileName;
+  // Duration of the hang so far.
+  readonly attribute double hangDuration;
+  readonly attribute AString addonId;
+
+  // The child id of the process in which the hang happened.
+  readonly attribute unsigned long long childID;
+
+  // Called by front end code when user ignores or cancels
+  // the notification.
+  void userCanceled();
+
+  // Terminate the slow script if it is still running.
+  void terminateScript();
+
+  // Ask the content process to start up the slow script debugger.
+  void beginStartingDebugger();
+
+  // Inform the content process that the slow script debugger has finished
+  // spinning up. The content process will run a nested event loop until this
+  // method is called.
+  void endStartingDebugger();
+
+  // Inquire whether the report is for a content process loaded by the given
+  // frameloader, or any descendents in its BrowsingContext tree.
+  bool isReportForBrowserOrChildren(in FrameLoader aFrameLoader);
+};
diff --git a/dom/ipc/nsILoginDetectionService.idl b/dom/ipc/nsILoginDetectionService.idl
new file mode 100644
index 0000000000..a0b1ae90a7
--- /dev/null
+++ b/dom/ipc/nsILoginDetectionService.idl
@@ -0,0 +1,22 @@
+/* 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 "nsISupports.idl"
+
+interface nsIURI;
+
+[scriptable, uuid(4c3c9a82-722a-4b0b-9c7d-36ef90135537)]
+interface nsILoginDetectionService : nsISupports
+{
+  /**
+   * called to initialize the login detection service.
+   */
+  void init();
+
+  /**
+   * Returns true if we have loaded logins from the password manager.
+   * This is now used by testcase only.
+   */
+  bool isLoginsLoaded();
+};
diff --git a/dom/ipc/tests/JSProcessActor/browser.ini b/dom/ipc/tests/JSProcessActor/browser.ini
new file mode 100644
index 0000000000..021b8d84d9
--- /dev/null
+++ b/dom/ipc/tests/JSProcessActor/browser.ini
@@ -0,0 +1,11 @@
+[DEFAULT]
+support-files =
+  head.js
+
+[browser_getActor.js]
+[browser_getActor_filter.js]
+[browser_observer_notification.js]
+[browser_registerProcessActor.js]
+[browser_sendAsyncMessage.js]
+[browser_sendQuery.js]
+[browser_uri_combination.js]
\ No newline at end of file
diff --git a/dom/ipc/tests/JSProcessActor/browser_getActor.js b/dom/ipc/tests/JSProcessActor/browser_getActor.js
new file mode 100644
index 0000000000..e111f1a274
--- /dev/null
+++ b/dom/ipc/tests/JSProcessActor/browser_getActor.js
@@ -0,0 +1,47 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+declTest("getActor on both sides", {
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal.domProcess;
+    ok(parent, "WindowGlobalParent should have value.");
+    let actorParent = parent.getActor("TestProcessActor");
+    is(
+      actorParent.show(),
+      "TestProcessActorParent",
+      "actor `show` should have value."
+    );
+    is(
+      actorParent.manager,
+      parent,
+      "manager should match WindowGlobalParent.domProcess"
+    );
+
+    ok(
+      actorParent.sawActorCreated,
+      "Checking that we can observe parent creation"
+    );
+
+    await SpecialPowers.spawn(browser, [], async function () {
+      let child = ChromeUtils.domProcessChild;
+      ok(child, "WindowGlobalChild should have value.");
+      let actorChild = child.getActor("TestProcessActor");
+      is(
+        actorChild.show(),
+        "TestProcessActorChild",
+        "actor show should have vaule."
+      );
+      is(
+        actorChild.manager,
+        child,
+        "manager should match ChromeUtils.domProcessChild."
+      );
+
+      ok(
+        actorChild.sawActorCreated,
+        "Checking that we can observe child creation"
+      );
+    });
+  },
+});
diff --git a/dom/ipc/tests/JSProcessActor/browser_getActor_filter.js b/dom/ipc/tests/JSProcessActor/browser_getActor_filter.js
new file mode 100644
index 0000000000..f79340fd89
--- /dev/null
+++ b/dom/ipc/tests/JSProcessActor/browser_getActor_filter.js
@@ -0,0 +1,80 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+declTest("getActor with remoteType match", {
+  remoteTypes: ["web"],
+
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal.domProcess;
+    ok(
+      parent.getActor("TestProcessActor"),
+      "JSProcessActorParent should have value."
+    );
+
+    await SpecialPowers.spawn(browser, [], async function () {
+      let child = ChromeUtils.domProcessChild;
+      ok(child, "DOMProcessChild should have value.");
+      ok(
+        child.getActor("TestProcessActor"),
+        "JSProcessActorChild should have value."
+      );
+    });
+  },
+});
+
+declTest("getActor with remoteType mismatch", {
+  remoteTypes: ["privilegedabout"],
+  url: TEST_URL,
+
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal.domProcess;
+    Assert.throws(
+      () => parent.getActor("TestProcessActor"),
+      /NotSupportedError/,
+      "Should throw if its remoteTypes don't match."
+    );
+
+    await SpecialPowers.spawn(browser, [], async function () {
+      let child = ChromeUtils.domProcessChild;
+      ok(child, "DOMProcessChild should have value.");
+      Assert.throws(
+        () => child.getActor("TestProcessActor"),
+        /NotSupportedError/,
+        "Should throw if its remoteTypes don't match."
+      );
+    });
+  },
+});
+
+declTest("getActor without includeParent", {
+  includeParent: false,
+
+  async test(_browser, win) {
+    let parent = win.docShell.browsingContext.currentWindowGlobal.domProcess;
+    SimpleTest.doesThrow(
+      () => parent.getActor("TestProcessActor"),
+      "Should throw if includeParent is false."
+    );
+
+    let child = ChromeUtils.domProcessChild;
+    SimpleTest.doesThrow(
+      () => child.getActor("TestProcessActor"),
+      "Should throw if includeParent is false."
+    );
+  },
+});
+
+declTest("getActor with includeParent", {
+  includeParent: true,
+
+  async test(_browser, win) {
+    let parent = win.docShell.browsingContext.currentWindowGlobal.domProcess;
+    let actorParent = parent.getActor("TestProcessActor");
+    ok(actorParent, "JSProcessActorParent should have value.");
+
+    let child = ChromeUtils.domProcessChild;
+    let actorChild = child.getActor("TestProcessActor");
+    ok(actorChild, "JSProcessActorChild should have value.");
+  },
+});
diff --git a/dom/ipc/tests/JSProcessActor/browser_observer_notification.js b/dom/ipc/tests/JSProcessActor/browser_observer_notification.js
new file mode 100644
index 0000000000..28dfa16481
--- /dev/null
+++ b/dom/ipc/tests/JSProcessActor/browser_observer_notification.js
@@ -0,0 +1,41 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+/* eslint-disable no-unused-vars */
+declTest("test observer triggering actor creation", {
+  async test(browser) {
+    await SpecialPowers.spawn(browser, [], async function () {
+      const TOPIC = "test-js-content-actor-child-observer";
+      Services.obs.notifyObservers(content.window, TOPIC, "dataString");
+
+      let child = ChromeUtils.domProcessChild;
+      let actorChild = child.getActor("TestProcessActor");
+      ok(actorChild, "JSProcessActorChild should have value.");
+      ok(
+        actorChild.lastObserved,
+        "JSProcessActorChild lastObserved should have value."
+      );
+      let { subject, topic, data } = actorChild.lastObserved;
+      is(topic, TOPIC, "Topic matches");
+      is(data, "dataString", "Data matches");
+    });
+  },
+});
+
+declTest("test observers with null data", {
+  async test(browser) {
+    await SpecialPowers.spawn(browser, [], async function () {
+      const TOPIC = "test-js-content-actor-child-observer";
+      Services.obs.notifyObservers(content.window, TOPIC);
+
+      let child = ChromeUtils.domProcessChild;
+      let actorChild = child.getActor("TestProcessActor");
+      ok(actorChild, "JSProcessActorChild should have value.");
+      let { subject, topic, data } = actorChild.lastObserved;
+
+      is(topic, TOPIC, "Topic matches");
+      is(data, null, "Data matches");
+    });
+  },
+});
diff --git a/dom/ipc/tests/JSProcessActor/browser_registerProcessActor.js b/dom/ipc/tests/JSProcessActor/browser_registerProcessActor.js
new file mode 100644
index 0000000000..1fa4e1c17c
--- /dev/null
+++ b/dom/ipc/tests/JSProcessActor/browser_registerProcessActor.js
@@ -0,0 +1,16 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+declTest("double register", {
+  async test(_browser, _window, fileExt) {
+    SimpleTest.doesThrow(
+      () =>
+        ChromeUtils.registerContentActor(
+          "TestProcessActor",
+          processActorOptions[fileExt]
+        ),
+      "Should throw if register has duplicate name."
+    );
+  },
+});
diff --git a/dom/ipc/tests/JSProcessActor/browser_sendAsyncMessage.js b/dom/ipc/tests/JSProcessActor/browser_sendAsyncMessage.js
new file mode 100644
index 0000000000..02ad64ee8b
--- /dev/null
+++ b/dom/ipc/tests/JSProcessActor/browser_sendAsyncMessage.js
@@ -0,0 +1,51 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+declTest("asyncMessage testing", {
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal.domProcess;
+    let actorParent = parent.getActor("TestProcessActor");
+    ok(actorParent, "JSProcessActorParent should have value.");
+
+    await ContentTask.spawn(browser, {}, async function () {
+      let child = ChromeUtils.domProcessChild;
+      let actorChild = child.getActor("TestProcessActor");
+      ok(actorChild, "JSProcessActorChild should have value.");
+
+      let promise = new Promise(resolve => {
+        actorChild.sendAsyncMessage("init", {});
+        actorChild.done = data => resolve(data);
+      }).then(data => {
+        ok(data.initial, "Initial should be true.");
+        ok(data.toParent, "ToParent should be true.");
+        ok(data.toChild, "ToChild should be true.");
+      });
+
+      await promise;
+    });
+  },
+});
+
+declTest("asyncMessage without both sides", {
+  async test(browser) {
+    // If we don't create a parent actor, make sure the parent actor
+    // gets created by having sent the message.
+    await ContentTask.spawn(browser, {}, async function () {
+      let child = ChromeUtils.domProcessChild;
+      let actorChild = child.getActor("TestProcessActor");
+      ok(actorChild, "JSProcessActorChild should have value.");
+
+      let promise = new Promise(resolve => {
+        actorChild.sendAsyncMessage("init", {});
+        actorChild.done = data => resolve(data);
+      }).then(data => {
+        ok(data.initial, "Initial should be true.");
+        ok(data.toParent, "ToParent should be true.");
+        ok(data.toChild, "ToChild should be true.");
+      });
+
+      await promise;
+    });
+  },
+});
diff --git a/dom/ipc/tests/JSProcessActor/browser_sendQuery.js b/dom/ipc/tests/JSProcessActor/browser_sendQuery.js
new file mode 100644
index 0000000000..5a9767bf3a
--- /dev/null
+++ b/dom/ipc/tests/JSProcessActor/browser_sendQuery.js
@@ -0,0 +1,99 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+const ERROR_LINE_NUMBERS = {
+  jsm: 31,
+  "sys.mjs": 28,
+};
+const EXCEPTION_LINE_NUMBERS = {
+  jsm: ERROR_LINE_NUMBERS.jsm + 3,
+  "sys.mjs": ERROR_LINE_NUMBERS["sys.mjs"] + 3,
+};
+const ERROR_COLUMN_NUMBERS = {
+  jsm: 31,
+  "sys.mjs": 31,
+};
+const EXCEPTION_COLUMN_NUMBERS = {
+  jsm: 22,
+  "sys.mjs": 22,
+};
+
+function maybeAsyncStack(offset, column) {
+  if (
+    Services.prefs.getBoolPref(
+      "javascript.options.asyncstack_capture_debuggee_only"
+    )
+  ) {
+    return "";
+  }
+
+  let stack = Error().stack.replace(/^.*?\n/, "");
+  return (
+    "JSActor query*" +
+    stack.replace(
+      /^([^\n]+?):(\d+):\d+/,
+      (m0, m1, m2) => `${m1}:${+m2 + offset}:${column}`
+    )
+  );
+}
+
+declTest("sendQuery Error", {
+  async test(browser, _window, fileExt) {
+    let parent = browser.browsingContext.currentWindowGlobal.domProcess;
+    let actorParent = parent.getActor("TestProcessActor");
+
+    let asyncStack = maybeAsyncStack(2, 8);
+    let error = await actorParent
+      .sendQuery("error", { message: "foo" })
+      .catch(e => e);
+
+    is(error.message, "foo", "Error should have the correct message");
+    is(error.name, "SyntaxError", "Error should have the correct name");
+    is(
+      error.stack,
+      `receiveMessage@resource://testing-common/TestProcessActorChild.${fileExt}:${ERROR_LINE_NUMBERS[fileExt]}:${ERROR_COLUMN_NUMBERS[fileExt]}\n` +
+        asyncStack,
+      "Error should have the correct stack"
+    );
+  },
+});
+
+declTest("sendQuery Exception", {
+  async test(browser, _window, fileExt) {
+    let parent = browser.browsingContext.currentWindowGlobal.domProcess;
+    let actorParent = parent.getActor("TestProcessActor");
+
+    let asyncStack = maybeAsyncStack(2, 8);
+    let error = await actorParent
+      .sendQuery("exception", {
+        message: "foo",
+        result: Cr.NS_ERROR_INVALID_ARG,
+      })
+      .catch(e => e);
+
+    is(error.message, "foo", "Error should have the correct message");
+    is(
+      error.result,
+      Cr.NS_ERROR_INVALID_ARG,
+      "Error should have the correct result code"
+    );
+    is(
+      error.stack,
+      `receiveMessage@resource://testing-common/TestProcessActorChild.${fileExt}:${EXCEPTION_LINE_NUMBERS[fileExt]}:${EXCEPTION_COLUMN_NUMBERS[fileExt]}\n` +
+        asyncStack,
+      "Error should have the correct stack"
+    );
+  },
+});
+
+declTest("sendQuery testing", {
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal.domProcess;
+    let actorParent = parent.getActor("TestProcessActor");
+    ok(actorParent, "JSWindowActorParent should have value.");
+
+    let { result } = await actorParent.sendQuery("asyncAdd", { a: 10, b: 20 });
+    is(result, 30);
+  },
+});
diff --git a/dom/ipc/tests/JSProcessActor/browser_uri_combination.js b/dom/ipc/tests/JSProcessActor/browser_uri_combination.js
new file mode 100644
index 0000000000..33394cf54a
--- /dev/null
+++ b/dom/ipc/tests/JSProcessActor/browser_uri_combination.js
@@ -0,0 +1,81 @@
+add_task(function specify_both() {
+  // Specifying both should throw.
+
+  SimpleTest.doesThrow(() => {
+    ChromeUtils.registerProcessActor("TestProcessActor", {
+      parent: {
+        moduleURI: "resource://testing-common/TestProcessActorParent.jsm",
+      },
+      child: {
+        moduleURI: "resource://testing-common/TestProcessActorChild.jsm",
+        esModuleURI: "resource://testing-common/TestProcessActorChild.sys.mjs",
+      },
+    });
+  }, "Should throw if both moduleURI and esModuleURI are specified.");
+
+  SimpleTest.doesThrow(() => {
+    ChromeUtils.registerProcessActor("TestProcessActor", {
+      parent: {
+        esModuleURI: "resource://testing-common/TestProcessActorParent.sys.mjs",
+      },
+      child: {
+        moduleURI: "resource://testing-common/TestProcessActorChild.jsm",
+        esModuleURI: "resource://testing-common/TestProcessActorChild.sys.mjs",
+      },
+    });
+  }, "Should throw if both moduleURI and esModuleURI are specified.");
+
+  SimpleTest.doesThrow(() => {
+    ChromeUtils.registerProcessActor("TestProcessActor", {
+      parent: {
+        moduleURI: "resource://testing-common/TestProcessActorParent.jsm",
+        esModuleURI: "resource://testing-common/TestProcessActorParent.sys.mjs",
+      },
+      child: {
+        moduleURI: "resource://testing-common/TestProcessActorChild.jsm",
+      },
+    });
+  }, "Should throw if both moduleURI and esModuleURI are specified.");
+
+  SimpleTest.doesThrow(() => {
+    ChromeUtils.registerProcessActor("TestProcessActor", {
+      parent: {
+        moduleURI: "resource://testing-common/TestProcessActorParent.jsm",
+        esModuleURI: "resource://testing-common/TestProcessActorParent.sys.mjs",
+      },
+      child: {
+        esModuleURI: "resource://testing-common/TestProcessActorChild.sys.mjs",
+      },
+    });
+  }, "Should throw if both moduleURI and esModuleURI are specified.");
+});
+
+add_task(function specify_mixed() {
+  // Mixing JSM and ESM should work.
+
+  try {
+    ChromeUtils.registerProcessActor("TestProcessActor", {
+      parent: {
+        moduleURI: "resource://testing-common/TestProcessActorParent.jsm",
+      },
+      child: {
+        esModuleURI: "resource://testing-common/TestProcessActorChild.sys.mjs",
+      },
+    });
+  } finally {
+    ChromeUtils.unregisterProcessActor("TestProcessActor");
+  }
+
+  try {
+    ChromeUtils.registerProcessActor("TestProcessActor", {
+      parent: {
+        esModuleURI: "resource://testing-common/TestProcessActorParent.sys.mjs",
+      },
+      child: {
+        moduleURI: "resource://testing-common/TestProcessActorChild.jsm",
+      },
+    });
+  } finally {
+    ChromeUtils.unregisterProcessActor("TestProcessActor");
+  }
+});
diff --git a/dom/ipc/tests/JSProcessActor/head.js b/dom/ipc/tests/JSProcessActor/head.js
new file mode 100644
index 0000000000..e19e9d5ff4
--- /dev/null
+++ b/dom/ipc/tests/JSProcessActor/head.js
@@ -0,0 +1,79 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Provide infrastructure for JSProcessActor tests.
+ */
+
+const URL = "about:blank";
+const TEST_URL = "http://test2.example.org/";
+let processActorOptions = {
+  jsm: {
+    parent: {
+      moduleURI: "resource://testing-common/TestProcessActorParent.jsm",
+    },
+    child: {
+      moduleURI: "resource://testing-common/TestProcessActorChild.jsm",
+      observers: ["test-js-content-actor-child-observer"],
+    },
+  },
+  "sys.mjs": {
+    parent: {
+      esModuleURI: "resource://testing-common/TestProcessActorParent.sys.mjs",
+    },
+    child: {
+      esModuleURI: "resource://testing-common/TestProcessActorChild.sys.mjs",
+      observers: ["test-js-content-actor-child-observer"],
+    },
+  },
+};
+
+function promiseNotification(aNotification) {
+  let notificationResolve;
+  let notificationObserver = function observer() {
+    notificationResolve();
+    Services.obs.removeObserver(notificationObserver, aNotification);
+  };
+  return new Promise(resolve => {
+    notificationResolve = resolve;
+    Services.obs.addObserver(notificationObserver, aNotification);
+  });
+}
+
+function declTest(name, cfg) {
+  declTestWithOptions(name, cfg, "jsm");
+  declTestWithOptions(name, cfg, "sys.mjs");
+}
+
+function declTestWithOptions(name, cfg, fileExt) {
+  let { url = "about:blank", includeParent = false, remoteTypes, test } = cfg;
+
+  // Build the actor options object which will be used to register & unregister
+  // our process actor.
+  let actorOptions = {
+    parent: Object.assign({}, processActorOptions[fileExt].parent),
+    child: Object.assign({}, processActorOptions[fileExt].child),
+  };
+  actorOptions.includeParent = includeParent;
+  if (remoteTypes !== undefined) {
+    actorOptions.remoteTypes = remoteTypes;
+  }
+
+  // Add a new task for the actor test declared here.
+  add_task(async function () {
+    info("Entering test: " + name);
+
+    // Register our actor, and load a new tab with the provided URL
+    ChromeUtils.registerProcessActor("TestProcessActor", actorOptions);
+    try {
+      await BrowserTestUtils.withNewTab(url, async browser => {
+        info("browser ready");
+        await Promise.resolve(test(browser, window, fileExt));
+      });
+    } finally {
+      // Unregister the actor after the test is complete.
+      ChromeUtils.unregisterProcessActor("TestProcessActor");
+      info("Exiting test: " + name);
+    }
+  });
+}
diff --git a/dom/ipc/tests/JSWindowActor/audio.ogg b/dom/ipc/tests/JSWindowActor/audio.ogg
new file mode 100644
index 0000000000..bed764fbf1
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/audio.ogg
diff --git a/dom/ipc/tests/JSWindowActor/browser.ini b/dom/ipc/tests/JSWindowActor/browser.ini
new file mode 100644
index 0000000000..d7c8ad71ab
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/browser.ini
@@ -0,0 +1,22 @@
+[DEFAULT]
+support-files =
+  head.js
+
+[browser_contentWindow.js]
+[browser_crash_report.js]
+[browser_destroy_callbacks.js]
+skip-if = !debug && (os == 'mac') #Bug 1604538
+[browser_event_listener.js]
+support-files =
+  file_dummyChromePage.html
+[browser_getActor.js]
+[browser_getActor_filter.js]
+[browser_observer_notification.js]
+support-files=
+  file_mediaPlayback.html
+  audio.ogg
+[browser_process_childid.js]
+[browser_registerWindowActor.js]
+[browser_sendAsyncMessage.js]
+[browser_sendQuery.js]
+[browser_uri_combination.js]
diff --git a/dom/ipc/tests/JSWindowActor/browser_contentWindow.js b/dom/ipc/tests/JSWindowActor/browser_contentWindow.js
new file mode 100644
index 0000000000..7706a20934
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/browser_contentWindow.js
@@ -0,0 +1,35 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+const CONTENT_WINDOW_URL = "https://example.com/";
+
+declTest("contentWindow null when inner window inactive", {
+  matches: [CONTENT_WINDOW_URL + "*"],
+  url: CONTENT_WINDOW_URL + "?1",
+
+  async test(browser) {
+    // If Fission is disabled, the pref is no-op.
+    await SpecialPowers.pushPrefEnv({
+      set: [["fission.bfcacheInParent", true]],
+    });
+
+    let parent = browser.browsingContext.currentWindowGlobal;
+    let actorParent = parent.getActor("TestWindow");
+
+    await actorParent.sendQuery("storeActor");
+
+    let url = CONTENT_WINDOW_URL + "?2";
+    let loaded = BrowserTestUtils.browserLoaded(browser, false, url);
+    await BrowserTestUtils.loadURIString(browser, url);
+    await loaded;
+
+    let result = await actorParent.sendQuery("checkActor");
+
+    is(result.status, "success", "Should succeed when bfcache is enabled");
+    ok(
+      result.valueIsNull,
+      "Should get a null contentWindow when inner window is inactive"
+    );
+  },
+});
diff --git a/dom/ipc/tests/JSWindowActor/browser_crash_report.js b/dom/ipc/tests/JSWindowActor/browser_crash_report.js
new file mode 100644
index 0000000000..f029f1a85a
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/browser_crash_report.js
@@ -0,0 +1,114 @@
+/* Any copyright is dedicated to the Public Domain.
+http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+declTest("crash actor", {
+  allFrames: true,
+
+  async test(browser) {
+    if (!("@mozilla.org/toolkit/crash-reporter;1" in Cc)) {
+      ok(true, "Cannot test crash annotations without a crash reporter");
+      return;
+    }
+
+    {
+      info("Creating a new tab.");
+      let newTab = await BrowserTestUtils.openNewForegroundTab(gBrowser, URL);
+      let newTabBrowser = newTab.linkedBrowser;
+
+      let parent =
+        newTabBrowser.browsingContext.currentWindowGlobal.getActor(
+          "TestWindow"
+        );
+      ok(parent, "JSWindowActorParent should have value.");
+
+      await SpecialPowers.spawn(newTabBrowser, [], async function () {
+        let child = content.windowGlobalChild;
+        ok(child, "WindowGlobalChild should have value.");
+        is(
+          child.isInProcess,
+          false,
+          "Actor should be loaded in the content process."
+        );
+        // Make sure that the actor is loaded.
+        let actorChild = child.getActor("TestWindow");
+        is(
+          actorChild.show(),
+          "TestWindowChild",
+          "actor show should have value."
+        );
+        is(
+          actorChild.manager,
+          child,
+          "manager should match WindowGlobalChild."
+        );
+      });
+
+      info(
+        "Crashing from withing an actor. We should have an actor name and a message name."
+      );
+      let report = await BrowserTestUtils.crashFrame(
+        newTabBrowser,
+        /* shouldShowTabCrashPage = */ false,
+        /* shouldClearMinidumps =  */ true,
+        /* browsingContext = */ null,
+        { asyncCrash: false }
+      );
+
+      is(report.JSActorName, "BrowserTestUtils");
+      is(report.JSActorMessage, "BrowserTestUtils:CrashFrame");
+
+      BrowserTestUtils.removeTab(newTab);
+    }
+
+    {
+      info("Creating a new tab for async crash");
+      let newTab = await BrowserTestUtils.openNewForegroundTab(gBrowser, URL);
+      let newTabBrowser = newTab.linkedBrowser;
+
+      let parent =
+        newTabBrowser.browsingContext.currentWindowGlobal.getActor(
+          "TestWindow"
+        );
+      ok(parent, "JSWindowActorParent should have value.");
+
+      await SpecialPowers.spawn(newTabBrowser, [], async function () {
+        let child = content.windowGlobalChild;
+        ok(child, "WindowGlobalChild should have value.");
+        is(
+          child.isInProcess,
+          false,
+          "Actor should be loaded in the content process."
+        );
+        // Make sure that the actor is loaded.
+        let actorChild = child.getActor("TestWindow");
+        is(
+          actorChild.show(),
+          "TestWindowChild",
+          "actor show should have value."
+        );
+        is(
+          actorChild.manager,
+          child,
+          "manager should match WindowGlobalChild."
+        );
+      });
+
+      info(
+        "Crashing from without an actor. We should have neither an actor name nor a message name."
+      );
+      let report = await BrowserTestUtils.crashFrame(
+        newTabBrowser,
+        /* shouldShowTabCrashPage = */ false,
+        /* shouldClearMinidumps =  */ true,
+        /* browsingContext = */ null,
+        { asyncCrash: true }
+      );
+
+      ok(!report.JSActorName);
+      ok(!report.JSActorMessage);
+
+      BrowserTestUtils.removeTab(newTab);
+    }
+  },
+});
diff --git a/dom/ipc/tests/JSWindowActor/browser_destroy_callbacks.js b/dom/ipc/tests/JSWindowActor/browser_destroy_callbacks.js
new file mode 100644
index 0000000000..74cbae9415
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/browser_destroy_callbacks.js
@@ -0,0 +1,193 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+declTest("destroy actor by iframe remove", {
+  allFrames: true,
+
+  async test(browser) {
+    await SpecialPowers.spawn(browser, [], async function () {
+      // Create and append an iframe into the window's document.
+      let frame = content.document.createElement("iframe");
+      frame.id = "frame";
+      content.document.body.appendChild(frame);
+      await ContentTaskUtils.waitForEvent(frame, "load");
+      is(content.window.frames.length, 1, "There should be an iframe.");
+      let child = frame.contentWindow.windowGlobalChild;
+      let actorChild = child.getActor("TestWindow");
+      ok(actorChild, "JSWindowActorChild should have value.");
+
+      {
+        let error = actorChild.uninitializedGetterError;
+        const prop = "contentWindow";
+        Assert.ok(
+          error,
+          `Should get error accessing '${prop}' before actor initialization`
+        );
+        if (error) {
+          Assert.equal(
+            error.name,
+            "InvalidStateError",
+            "Error should be an InvalidStateError"
+          );
+          Assert.equal(
+            error.message,
+            `JSWindowActorChild.${prop} getter: Cannot access property '${prop}' before actor is initialized`,
+            "Error should have informative message"
+          );
+        }
+      }
+
+      let didDestroyPromise = new Promise(resolve => {
+        const TOPIC = "test-js-window-actor-diddestroy";
+        Services.obs.addObserver(function obs(subject, topic, data) {
+          ok(data, "didDestroyCallback data should be true.");
+          is(subject, actorChild, "Should have this value");
+
+          Services.obs.removeObserver(obs, TOPIC);
+          // Make a trip through the event loop to ensure that the
+          // actor's manager has been cleared before running remaining
+          // checks.
+          Services.tm.dispatchToMainThread(resolve);
+        }, TOPIC);
+      });
+
+      info("Remove frame");
+      content.document.getElementById("frame").remove();
+      await didDestroyPromise;
+
+      Assert.throws(
+        () => child.getActor("TestWindow"),
+        /InvalidStateError/,
+        "Should throw if frame destroy."
+      );
+
+      for (let prop of [
+        "document",
+        "browsingContext",
+        "docShell",
+        "contentWindow",
+      ]) {
+        let error;
+        try {
+          void actorChild[prop];
+        } catch (e) {
+          error = e;
+        }
+        Assert.ok(
+          error,
+          `Should get error accessing '${prop}' after actor destruction`
+        );
+        if (error) {
+          Assert.equal(
+            error.name,
+            "InvalidStateError",
+            "Error should be an InvalidStateError"
+          );
+          Assert.equal(
+            error.message,
+            `JSWindowActorChild.${prop} getter: Cannot access property '${prop}' after actor 'TestWindow' has been destroyed`,
+            "Error should have informative message"
+          );
+        }
+      }
+    });
+  },
+});
+
+declTest("destroy actor by page navigates", {
+  allFrames: true,
+
+  async test(browser) {
+    info("creating an in-process frame");
+    await SpecialPowers.spawn(browser, [URL], async function (url) {
+      let frame = content.document.createElement("iframe");
+      frame.src = url;
+      content.document.body.appendChild(frame);
+    });
+
+    info("navigating page");
+    await SpecialPowers.spawn(browser, [TEST_URL], async function (url) {
+      let frame = content.document.querySelector("iframe");
+      frame.contentWindow.location = url;
+      let child = frame.contentWindow.windowGlobalChild;
+      let actorChild = child.getActor("TestWindow");
+      ok(actorChild, "JSWindowActorChild should have value.");
+
+      let didDestroyPromise = new Promise(resolve => {
+        const TOPIC = "test-js-window-actor-diddestroy";
+        Services.obs.addObserver(function obs(subject, topic, data) {
+          ok(data, "didDestroyCallback data should be true.");
+          is(subject, actorChild, "Should have this value");
+
+          Services.obs.removeObserver(obs, TOPIC);
+          resolve();
+        }, TOPIC);
+      });
+
+      await Promise.all([
+        didDestroyPromise,
+        ContentTaskUtils.waitForEvent(frame, "load"),
+      ]);
+
+      Assert.throws(
+        () => child.getActor("TestWindow"),
+        /InvalidStateError/,
+        "Should throw if frame destroy."
+      );
+    });
+  },
+});
+
+declTest("destroy actor by tab being closed", {
+  allFrames: true,
+
+  async test(browser) {
+    info("creating a new tab");
+    let newTab = await BrowserTestUtils.openNewForegroundTab(gBrowser, URL);
+    let newTabBrowser = newTab.linkedBrowser;
+
+    let parent =
+      newTabBrowser.browsingContext.currentWindowGlobal.getActor("TestWindow");
+    ok(parent, "JSWindowActorParent should have value.");
+
+    // We can't depend on `SpecialPowers.spawn` to resolve our promise, as the
+    // frame message manager will be being shut down at the same time. Instead
+    // send messages over the per-process message manager which should still be
+    // active.
+    let didDestroyPromise = new Promise(resolve => {
+      Services.ppmm.addMessageListener(
+        "test-jswindowactor-diddestroy",
+        function onmessage(msg) {
+          Services.ppmm.removeMessageListener(
+            "test-jswindowactor-diddestroy",
+            onmessage
+          );
+          resolve();
+        }
+      );
+    });
+
+    info("setting up destroy listeners");
+    await SpecialPowers.spawn(newTabBrowser, [], () => {
+      let child = content.windowGlobalChild;
+      let actorChild = child.getActor("TestWindow");
+      ok(actorChild, "JSWindowActorChild should have value.");
+
+      Services.obs.addObserver(function obs(subject, topic, data) {
+        if (subject != actorChild) {
+          return;
+        }
+        dump("DidDestroy called\n");
+        Services.obs.removeObserver(obs, "test-js-window-actor-diddestroy");
+        Services.cpmm.sendAsyncMessage("test-jswindowactor-diddestroy", data);
+      }, "test-js-window-actor-diddestroy");
+    });
+
+    info("removing new tab");
+    await BrowserTestUtils.removeTab(newTab);
+    info("waiting for destroy callbacks to fire");
+    await didDestroyPromise;
+    info("got didDestroy callback");
+  },
+});
diff --git a/dom/ipc/tests/JSWindowActor/browser_event_listener.js b/dom/ipc/tests/JSWindowActor/browser_event_listener.js
new file mode 100644
index 0000000000..725c2c3753
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/browser_event_listener.js
@@ -0,0 +1,171 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+async function createAndShowDropdown(browser) {
+  // Add a select element to the DOM of the loaded document.
+  await SpecialPowers.spawn(browser, [], async function () {
+    content.document.body.innerHTML += `
+      <select id="testSelect">
+        <option>A</option>
+        <option>B</option>
+      </select>`;
+  });
+
+  // Click on the select to show the dropdown.
+  await BrowserTestUtils.synthesizeMouseAtCenter("#testSelect", {}, browser);
+}
+
+declTest("test event triggering actor creation", {
+  events: { mozshowdropdown: {} },
+
+  async test(browser) {
+    // Wait for the observer notification.
+    let observePromise = TestUtils.topicObserved(
+      "test-js-window-actor-parent-event"
+    );
+
+    await createAndShowDropdown(browser);
+
+    // Wait for the observer notification to fire, and inspect the results.
+    let [subject, data] = await observePromise;
+    is(data, "mozshowdropdown");
+
+    let parent = browser.browsingContext.currentWindowGlobal;
+    let actorParent = parent.getActor("TestWindow");
+    ok(actorParent, "JSWindowActorParent should have value.");
+    is(
+      subject.wrappedJSObject,
+      actorParent,
+      "Should have been recieved on the right actor"
+    );
+  },
+});
+
+declTest("test createActor:false not triggering actor creation", {
+  events: { mozshowdropdown: { createActor: false } },
+
+  async test(browser) {
+    info("before actor has been created");
+    const TOPIC = "test-js-window-actor-parent-event";
+    function obs() {
+      ok(false, "actor should not be created");
+    }
+    Services.obs.addObserver(obs, TOPIC);
+
+    await createAndShowDropdown(browser);
+
+    // Bounce into the content process & create the actor after showing the
+    // dropdown, in order to be sure that if an event was going to be
+    // delivered, it already would've been.
+    await SpecialPowers.spawn(browser, [], async () => {
+      content.windowGlobalChild.getActor("TestWindow");
+    });
+    ok(true, "observer notification should not have fired");
+    Services.obs.removeObserver(obs, TOPIC);
+
+    // ----------------------------------------------------
+    info("after actor has been created");
+    let observePromise = TestUtils.topicObserved(
+      "test-js-window-actor-parent-event"
+    );
+    await createAndShowDropdown(browser);
+
+    // Wait for the observer notification to fire, and inspect the results.
+    let [subject, data] = await observePromise;
+    is(data, "mozshowdropdown");
+
+    let parent = browser.browsingContext.currentWindowGlobal;
+    let actorParent = parent.getActor("TestWindow");
+    ok(actorParent, "JSWindowActorParent should have value.");
+    is(
+      subject.wrappedJSObject,
+      actorParent,
+      "Should have been recieved on the right actor"
+    );
+  },
+});
+
+async function testEventProcessedOnce(browser, waitForUrl) {
+  let notificationCount = 0;
+  let firstNotificationResolve;
+  let firstNotification = new Promise(resolve => {
+    firstNotificationResolve = resolve;
+  });
+
+  const TOPIC = "test-js-window-actor-parent-event";
+  function obs(subject, topic, data) {
+    is(data, "mozwindowactortestevent");
+    notificationCount++;
+    if (firstNotificationResolve) {
+      firstNotificationResolve();
+      firstNotificationResolve = null;
+    }
+  }
+  Services.obs.addObserver(obs, TOPIC);
+
+  if (waitForUrl) {
+    info("Waiting for URI to be alright");
+    await TestUtils.waitForCondition(() => {
+      if (!browser.browsingContext?.currentWindowGlobal) {
+        info("No CWG yet");
+        return false;
+      }
+      return SpecialPowers.spawn(browser, [waitForUrl], async function (url) {
+        info(content.document.documentURI);
+        return content.document.documentURI.includes(url);
+      });
+    });
+  }
+
+  info("Dispatching event");
+  await SpecialPowers.spawn(browser, [], async function () {
+    content.document.dispatchEvent(
+      new content.CustomEvent("mozwindowactortestevent", { bubbles: true })
+    );
+  });
+
+  info("Waiting for notification");
+  await firstNotification;
+
+  await new Promise(r => setTimeout(r, 0));
+
+  is(notificationCount, 1, "Should get only one notification");
+
+  Services.obs.removeObserver(obs, TOPIC);
+}
+
+declTest("test in-process content events are not processed twice", {
+  url: "about:preferences",
+  events: { mozwindowactortestevent: { wantUntrusted: true } },
+  async test(browser) {
+    is(
+      browser.getAttribute("type"),
+      "content",
+      "Should be a content <browser>"
+    );
+    is(browser.getAttribute("remotetype"), "", "Should not be remote");
+    await testEventProcessedOnce(browser);
+  },
+});
+
+declTest("test in-process chrome events are processed correctly", {
+  url: "about:blank",
+  events: { mozwindowactortestevent: { wantUntrusted: true } },
+  allFrames: true,
+  includeChrome: true,
+  async test(browser) {
+    let dialogBox = gBrowser.getTabDialogBox(browser);
+    let { dialogClosed, dialog } = dialogBox.open(
+      "chrome://mochitests/content/browser/dom/ipc/tests/JSWindowActor/file_dummyChromePage.html"
+    );
+    let chromeBrowser = dialog._frame;
+    is(chromeBrowser.getAttribute("type"), "", "Should be a chrome <browser>");
+    is(chromeBrowser.getAttribute("remotetype"), "", "Should not be remote");
+
+    await testEventProcessedOnce(chromeBrowser, "dummyChromePage.html");
+
+    dialog.close();
+    await dialogClosed;
+  },
+});
diff --git a/dom/ipc/tests/JSWindowActor/browser_getActor.js b/dom/ipc/tests/JSWindowActor/browser_getActor.js
new file mode 100644
index 0000000000..8d002daf99
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/browser_getActor.js
@@ -0,0 +1,36 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+declTest("getActor on both sides", {
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal;
+    ok(parent, "WindowGlobalParent should have value.");
+    let actorParent = parent.getActor("TestWindow");
+    is(actorParent.show(), "TestWindowParent", "actor show should have vaule.");
+    is(actorParent.manager, parent, "manager should match WindowGlobalParent.");
+
+    ok(
+      actorParent.sawActorCreated,
+      "Checking that we can observe parent creation"
+    );
+
+    await SpecialPowers.spawn(browser, [], async function () {
+      let child = content.windowGlobalChild;
+      ok(child, "WindowGlobalChild should have value.");
+      is(
+        child.isInProcess,
+        false,
+        "Actor should be loaded in the content process."
+      );
+      let actorChild = child.getActor("TestWindow");
+      is(actorChild.show(), "TestWindowChild", "actor show should have vaule.");
+      is(actorChild.manager, child, "manager should match WindowGlobalChild.");
+
+      ok(
+        actorChild.sawActorCreated,
+        "Checking that we can observe child creation"
+      );
+    });
+  },
+});
diff --git a/dom/ipc/tests/JSWindowActor/browser_getActor_filter.js b/dom/ipc/tests/JSWindowActor/browser_getActor_filter.js
new file mode 100644
index 0000000000..a10697c989
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/browser_getActor_filter.js
@@ -0,0 +1,259 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+requestLongerTimeout(2);
+
+declTest("getActor with mismatch", {
+  matches: ["*://*/*"],
+
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal;
+    ok(parent, "WindowGlobalParent should have value.");
+    Assert.throws(
+      () => parent.getActor("TestWindow"),
+      /NotSupportedError/,
+      "Should throw if it doesn't match."
+    );
+
+    await SpecialPowers.spawn(browser, [], async function () {
+      let child = content.windowGlobalChild;
+      ok(child, "WindowGlobalChild should have value.");
+
+      Assert.throws(
+        () => child.getActor("TestWindow"),
+        /NotSupportedError/,
+        "Should throw if it doesn't match."
+      );
+    });
+  },
+});
+
+declTest("getActor with matches", {
+  matches: ["*://*/*"],
+  url: TEST_URL,
+
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal;
+    ok(parent.getActor("TestWindow"), "JSWindowActorParent should have value.");
+
+    await SpecialPowers.spawn(browser, [], async function () {
+      let child = content.windowGlobalChild;
+      ok(child, "WindowGlobalChild should have value.");
+      ok(child.getActor("TestWindow"), "JSWindowActorChild should have value.");
+    });
+  },
+});
+
+declTest("getActor with iframe matches", {
+  allFrames: true,
+  matches: ["*://*/*"],
+
+  async test(browser) {
+    await SpecialPowers.spawn(browser, [TEST_URL], async function (url) {
+      // Create and append an iframe into the window's document.
+      let frame = content.document.createElement("iframe");
+      frame.src = url;
+      content.document.body.appendChild(frame);
+      await ContentTaskUtils.waitForEvent(frame, "load");
+
+      is(content.frames.length, 1, "There should be an iframe.");
+      await content.SpecialPowers.spawn(frame, [], () => {
+        let child = content.windowGlobalChild;
+        Assert.ok(
+          child.getActor("TestWindow"),
+          "JSWindowActorChild should have value."
+        );
+      });
+    });
+  },
+});
+
+declTest("getActor with iframe mismatch", {
+  allFrames: true,
+  matches: ["about:home"],
+
+  async test(browser) {
+    await SpecialPowers.spawn(browser, [TEST_URL], async function (url) {
+      // Create and append an iframe into the window's document.
+      let frame = content.document.createElement("iframe");
+      frame.src = url;
+      content.document.body.appendChild(frame);
+      await ContentTaskUtils.waitForEvent(frame, "load");
+
+      is(content.frames.length, 1, "There should be an iframe.");
+      await content.SpecialPowers.spawn(frame, [], () => {
+        let child = content.windowGlobalChild;
+        Assert.throws(
+          () => child.getActor("TestWindow"),
+          /NotSupportedError/,
+          "Should throw if it doesn't match."
+        );
+      });
+    });
+  },
+});
+
+declTest("getActor with remoteType match", {
+  remoteTypes: ["web"],
+
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal;
+    ok(parent.getActor("TestWindow"), "JSWindowActorParent should have value.");
+
+    await SpecialPowers.spawn(browser, [], async function () {
+      let child = content.windowGlobalChild;
+      ok(child, "WindowGlobalChild should have value.");
+      ok(child.getActor("TestWindow"), "JSWindowActorChild should have value.");
+    });
+  },
+});
+
+declTest("getActor with iframe remoteType match", {
+  allFrames: true,
+  remoteTypes: ["web"],
+
+  async test(browser) {
+    await SpecialPowers.spawn(browser, [TEST_URL], async function (url) {
+      let child = content.windowGlobalChild;
+      ok(child, "WindowGlobalChild should have value.");
+      ok(child.getActor("TestWindow"), "JSWindowActorChild should have value.");
+
+      // Create and append an iframe into the window's document.
+      let frame = content.document.createElement("iframe");
+      frame.src = url;
+      content.document.body.appendChild(frame);
+      await ContentTaskUtils.waitForEvent(frame, "load");
+
+      is(content.frames.length, 1, "There should be an iframe.");
+      await content.SpecialPowers.spawn(frame, [], () => {
+        child = content.windowGlobalChild;
+        Assert.ok(
+          child.getActor("TestWindow"),
+          "JSWindowActorChild should have value."
+        );
+      });
+    });
+  },
+});
+
+declTest("getActor with remoteType mismatch", {
+  remoteTypes: ["privilegedabout"],
+  url: TEST_URL,
+
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal;
+    Assert.throws(
+      () => parent.getActor("TestWindow"),
+      /NotSupportedError/,
+      "Should throw if its remoteTypes don't match."
+    );
+
+    await SpecialPowers.spawn(browser, [], async function () {
+      let child = content.windowGlobalChild;
+      ok(child, "WindowGlobalChild should have value.");
+      Assert.throws(
+        () => child.getActor("TestWindow"),
+        /NotSupportedError/,
+        "Should throw if its remoteTypes don't match."
+      );
+    });
+  },
+});
+
+declTest("getActor with iframe messageManagerGroups match", {
+  allFrames: true,
+  messageManagerGroups: ["browsers"],
+
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal;
+    ok(parent.getActor("TestWindow"), "JSWindowActorParent should have value.");
+
+    await SpecialPowers.spawn(browser, [TEST_URL], async function (url) {
+      let child = content.windowGlobalChild;
+      ok(child, "WindowGlobalChild should have value.");
+      ok(child.getActor("TestWindow"), "JSWindowActorChild should have value.");
+    });
+  },
+});
+
+declTest("getActor with iframe messageManagerGroups mismatch", {
+  allFrames: true,
+  messageManagerGroups: ["sidebars"],
+
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal;
+    Assert.throws(
+      () => parent.getActor("TestWindow"),
+      /NotSupportedError/,
+      "Should throw if its messageManagerGroups doesn't match."
+    );
+
+    await SpecialPowers.spawn(browser, [TEST_URL], async function (url) {
+      let child = content.windowGlobalChild;
+      ok(child, "WindowGlobalChild should have value.");
+      Assert.throws(
+        () => child.getActor("TestWindow"),
+        /NotSupportedError/,
+        "Should throw if its messageManagerGroups doesn't match."
+      );
+    });
+  },
+});
+
+declTest("getActor without allFrames", {
+  allFrames: false,
+
+  async test(browser) {
+    await SpecialPowers.spawn(browser, [], async function () {
+      // Create and append an iframe into the window's document.
+      let frame = content.document.createElement("iframe");
+      content.document.body.appendChild(frame);
+      is(content.frames.length, 1, "There should be an iframe.");
+      let child = frame.contentWindow.windowGlobalChild;
+      Assert.throws(
+        () => child.getActor("TestWindow"),
+        /NotSupportedError/,
+        "Should throw if allFrames is false."
+      );
+    });
+  },
+});
+
+declTest("getActor with allFrames", {
+  allFrames: true,
+
+  async test(browser) {
+    await SpecialPowers.spawn(browser, [], async function () {
+      // Create and append an iframe into the window's document.
+      let frame = content.document.createElement("iframe");
+      content.document.body.appendChild(frame);
+      is(content.frames.length, 1, "There should be an iframe.");
+      let child = frame.contentWindow.windowGlobalChild;
+      let actorChild = child.getActor("TestWindow");
+      ok(actorChild, "JSWindowActorChild should have value.");
+    });
+  },
+});
+
+declTest("getActor without includeChrome", {
+  includeChrome: false,
+
+  async test(_browser, win) {
+    let parent = win.docShell.browsingContext.currentWindowGlobal;
+    SimpleTest.doesThrow(
+      () => parent.getActor("TestWindow"),
+      "Should throw if includeChrome is false."
+    );
+  },
+});
+
+declTest("getActor with includeChrome", {
+  includeChrome: true,
+
+  async test(_browser, win) {
+    let parent = win.docShell.browsingContext.currentWindowGlobal;
+    let actorParent = parent.getActor("TestWindow");
+    ok(actorParent, "JSWindowActorParent should have value.");
+  },
+});
diff --git a/dom/ipc/tests/JSWindowActor/browser_observer_notification.js b/dom/ipc/tests/JSWindowActor/browser_observer_notification.js
new file mode 100644
index 0000000000..c0fe2249e8
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/browser_observer_notification.js
@@ -0,0 +1,118 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+/* eslint-disable no-unused-vars */
+declTest("test observer triggering actor creation", {
+  observers: ["test-js-window-actor-child-observer"],
+
+  async test(browser) {
+    await SpecialPowers.spawn(browser, [], async function () {
+      const TOPIC = "test-js-window-actor-child-observer";
+      Services.obs.notifyObservers(content.window, TOPIC, "dataString");
+
+      let child = content.windowGlobalChild;
+      let actorChild = child.getActor("TestWindow");
+      ok(actorChild, "JSWindowActorChild should have value.");
+      let { subject, topic, data } = actorChild.lastObserved;
+
+      is(
+        subject.windowGlobalChild.getActor("TestWindow"),
+        actorChild,
+        "Should have been recieved on the right actor"
+      );
+      is(topic, TOPIC, "Topic matches");
+      is(data, "dataString", "Data matches");
+    });
+  },
+});
+
+declTest("test observers with null data", {
+  observers: ["test-js-window-actor-child-observer"],
+
+  async test(browser) {
+    await SpecialPowers.spawn(browser, [], async function () {
+      const TOPIC = "test-js-window-actor-child-observer";
+      Services.obs.notifyObservers(content.window, TOPIC);
+
+      let child = content.windowGlobalChild;
+      let actorChild = child.getActor("TestWindow");
+      ok(actorChild, "JSWindowActorChild should have value.");
+      let { subject, topic, data } = actorChild.lastObserved;
+
+      is(
+        subject.windowGlobalChild.getActor("TestWindow"),
+        actorChild,
+        "Should have been recieved on the right actor"
+      );
+      is(topic, TOPIC, "Topic matches");
+      is(data, null, "Data matches");
+    });
+  },
+});
+
+declTest("observers don't notify with wrong window", {
+  observers: ["test-js-window-actor-child-observer"],
+
+  async test(browser) {
+    const MSG_RE =
+      /JSWindowActor TestWindow: expected window subject for topic 'test-js-window-actor-child-observer'/;
+    let expectMessage = new Promise(resolve => {
+      Services.console.registerListener(function consoleListener(msg) {
+        // Run everything async in order to avoid logging messages from the
+        // console listener.
+        Cu.dispatch(() => {
+          if (!MSG_RE.test(msg.message)) {
+            info("ignoring non-matching console message: " + msg.message);
+            return;
+          }
+          info("received console message: " + msg.message);
+          is(msg.logLevel, Ci.nsIConsoleMessage.error, "should be an error");
+
+          Services.console.unregisterListener(consoleListener);
+          resolve();
+        });
+      });
+    });
+
+    await SpecialPowers.spawn(browser, [], async function () {
+      const TOPIC = "test-js-window-actor-child-observer";
+      Services.obs.notifyObservers(null, TOPIC);
+      let child = content.windowGlobalChild;
+      let actorChild = child.getActor("TestWindow");
+      ok(actorChild, "JSWindowActorChild should have value.");
+      is(
+        actorChild.lastObserved,
+        undefined,
+        "Should not receive wrong window's observer notification!"
+      );
+    });
+
+    await expectMessage;
+  },
+});
+
+declTest("observers notify with audio-playback", {
+  observers: ["audio-playback"],
+  url: "http://example.com/browser/dom/ipc/tests/JSWindowActor/file_mediaPlayback.html",
+
+  async test(browser) {
+    await SpecialPowers.spawn(browser, [], async function () {
+      let audio = content.document.querySelector("audio");
+      audio.play();
+
+      let child = content.windowGlobalChild;
+      let actorChild = child.getActor("TestWindow");
+      ok(actorChild, "JSWindowActorChild should have value.");
+
+      let observePromise = new Promise(resolve => {
+        actorChild.done = ({ subject, topic, data }) =>
+          resolve({ subject, topic, data });
+      });
+
+      let { subject, topic, data } = await observePromise;
+      is(topic, "audio-playback", "Topic matches");
+      is(data, "active", "Data matches");
+    });
+  },
+});
diff --git a/dom/ipc/tests/JSWindowActor/browser_process_childid.js b/dom/ipc/tests/JSWindowActor/browser_process_childid.js
new file mode 100644
index 0000000000..ba6db1dabb
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/browser_process_childid.js
@@ -0,0 +1,27 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+// Test that `process.childID` is defined.
+
+declTest("test childid", {
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal;
+    ok(
+      parent.domProcess.childID,
+      "parent domProcess.childID should have a value."
+    );
+    await SpecialPowers.spawn(
+      browser,
+      [parent.domProcess.childID],
+      async function (parentChildID) {
+        ok(
+          ChromeUtils.domProcessChild.childID,
+          "child process.childID should have a value."
+        );
+        let childID = ChromeUtils.domProcessChild.childID;
+        is(parentChildID, childID);
+      }
+    );
+  },
+});
diff --git a/dom/ipc/tests/JSWindowActor/browser_registerWindowActor.js b/dom/ipc/tests/JSWindowActor/browser_registerWindowActor.js
new file mode 100644
index 0000000000..edaa99d2ed
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/browser_registerWindowActor.js
@@ -0,0 +1,16 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+declTest("double register", {
+  async test(_browser, _window, fileExt) {
+    SimpleTest.doesThrow(
+      () =>
+        ChromeUtils.registerWindowActor(
+          "TestWindow",
+          windowActorOptions[fileExt]
+        ),
+      "Should throw if register has duplicate name."
+    );
+  },
+});
diff --git a/dom/ipc/tests/JSWindowActor/browser_sendAsyncMessage.js b/dom/ipc/tests/JSWindowActor/browser_sendAsyncMessage.js
new file mode 100644
index 0000000000..eedc5072d1
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/browser_sendAsyncMessage.js
@@ -0,0 +1,51 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+declTest("asyncMessage testing", {
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal;
+    let actorParent = parent.getActor("TestWindow");
+    ok(actorParent, "JSWindowActorParent should have value.");
+
+    await ContentTask.spawn(browser, {}, async function () {
+      let child = content.windowGlobalChild;
+      let actorChild = child.getActor("TestWindow");
+      ok(actorChild, "JSWindowActorChild should have value.");
+
+      let promise = new Promise(resolve => {
+        actorChild.sendAsyncMessage("init", {});
+        actorChild.done = data => resolve(data);
+      }).then(data => {
+        ok(data.initial, "Initial should be true.");
+        ok(data.toParent, "ToParent should be true.");
+        ok(data.toChild, "ToChild should be true.");
+      });
+
+      await promise;
+    });
+  },
+});
+
+declTest("asyncMessage without both sides", {
+  async test(browser) {
+    // If we don't create a parent actor, make sure the parent actor
+    // gets created by having sent the message.
+    await ContentTask.spawn(browser, {}, async function () {
+      let child = content.windowGlobalChild;
+      let actorChild = child.getActor("TestWindow");
+      ok(actorChild, "JSWindowActorChild should have value.");
+
+      let promise = new Promise(resolve => {
+        actorChild.sendAsyncMessage("init", {});
+        actorChild.done = data => resolve(data);
+      }).then(data => {
+        ok(data.initial, "Initial should be true.");
+        ok(data.toParent, "ToParent should be true.");
+        ok(data.toChild, "ToChild should be true.");
+      });
+
+      await promise;
+    });
+  },
+});
diff --git a/dom/ipc/tests/JSWindowActor/browser_sendQuery.js b/dom/ipc/tests/JSWindowActor/browser_sendQuery.js
new file mode 100644
index 0000000000..0d1a845949
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/browser_sendQuery.js
@@ -0,0 +1,131 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+const ERROR_LINE_NUMBERS = {
+  jsm: 39,
+  "sys.mjs": 36,
+};
+const EXCEPTION_LINE_NUMBERS = {
+  jsm: ERROR_LINE_NUMBERS.jsm + 3,
+  "sys.mjs": ERROR_LINE_NUMBERS["sys.mjs"] + 3,
+};
+const ERROR_COLUMN_NUMBERS = {
+  jsm: 31,
+  "sys.mjs": 31,
+};
+const EXCEPTION_COLUMN_NUMBERS = {
+  jsm: 22,
+  "sys.mjs": 22,
+};
+
+function maybeAsyncStack(offset, column) {
+  if (
+    Services.prefs.getBoolPref(
+      "javascript.options.asyncstack_capture_debuggee_only"
+    )
+  ) {
+    return "";
+  }
+
+  let stack = Error().stack.replace(/^.*?\n/, "");
+  return (
+    "JSActor query*" +
+    stack.replace(
+      /^([^\n]+?):(\d+):\d+/,
+      (m0, m1, m2) => `${m1}:${+m2 + offset}:${column}`
+    )
+  );
+}
+
+declTest("sendQuery Error", {
+  async test(browser, _window, fileExt) {
+    let parent = browser.browsingContext.currentWindowGlobal;
+    let actorParent = parent.getActor("TestWindow");
+
+    let asyncStack = maybeAsyncStack(2, 8);
+    let error = await actorParent
+      .sendQuery("error", { message: "foo" })
+      .catch(e => e);
+
+    is(error.message, "foo", "Error should have the correct message");
+    is(error.name, "SyntaxError", "Error should have the correct name");
+    is(
+      error.stack,
+      `receiveMessage@resource://testing-common/TestWindowChild.${fileExt}:${ERROR_LINE_NUMBERS[fileExt]}:${ERROR_COLUMN_NUMBERS[fileExt]}\n` +
+        asyncStack,
+      "Error should have the correct stack"
+    );
+  },
+});
+
+declTest("sendQuery Exception", {
+  async test(browser, _window, fileExt) {
+    let parent = browser.browsingContext.currentWindowGlobal;
+    let actorParent = parent.getActor("TestWindow");
+
+    let asyncStack = maybeAsyncStack(2, 8);
+    let error = await actorParent
+      .sendQuery("exception", {
+        message: "foo",
+        result: Cr.NS_ERROR_INVALID_ARG,
+      })
+      .catch(e => e);
+
+    is(error.message, "foo", "Error should have the correct message");
+    is(
+      error.result,
+      Cr.NS_ERROR_INVALID_ARG,
+      "Error should have the correct result code"
+    );
+    is(
+      error.stack,
+      `receiveMessage@resource://testing-common/TestWindowChild.${fileExt}:${EXCEPTION_LINE_NUMBERS[fileExt]}:${EXCEPTION_COLUMN_NUMBERS[fileExt]}\n` +
+        asyncStack,
+      "Error should have the correct stack"
+    );
+  },
+});
+
+declTest("sendQuery testing", {
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal;
+    let actorParent = parent.getActor("TestWindow");
+    ok(actorParent, "JSWindowActorParent should have value.");
+
+    let { result } = await actorParent.sendQuery("asyncAdd", { a: 10, b: 20 });
+    is(result, 30);
+  },
+});
+
+declTest("sendQuery in-process early lifetime", {
+  url: "about:mozilla",
+  allFrames: true,
+
+  async test(browser) {
+    let iframe = browser.contentDocument.createElement("iframe");
+    browser.contentDocument.body.appendChild(iframe);
+    let wgc = iframe.contentWindow.windowGlobalChild;
+    let actorChild = wgc.getActor("TestWindow");
+    let { result } = await actorChild.sendQuery("asyncMul", { a: 10, b: 20 });
+    is(result, 200);
+  },
+});
+
+declTest("sendQuery unserializable reply", {
+  async test(browser) {
+    let parent = browser.browsingContext.currentWindowGlobal;
+    let actorParent = parent.getActor("TestWindow");
+    ok(actorParent, "JSWindowActorParent should have value");
+
+    try {
+      await actorParent.sendQuery("noncloneReply", {});
+      ok(false, "expected noncloneReply to be rejected");
+    } catch (error) {
+      ok(
+        error.message.includes("message reply cannot be cloned"),
+        "Error should have the correct message"
+      );
+    }
+  },
+});
diff --git a/dom/ipc/tests/JSWindowActor/browser_uri_combination.js b/dom/ipc/tests/JSWindowActor/browser_uri_combination.js
new file mode 100644
index 0000000000..ce46a3e3b6
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/browser_uri_combination.js
@@ -0,0 +1,81 @@
+add_task(function specify_both() {
+  // Specifying both should throw.
+
+  SimpleTest.doesThrow(() => {
+    ChromeUtils.registerWindowActor("TestWindow", {
+      parent: {
+        moduleURI: "resource://testing-common/TestWindowParent.jsm",
+      },
+      child: {
+        moduleURI: "resource://testing-common/TestWindowChild.jsm",
+        esModuleURI: "resource://testing-common/TestWindowChild.sys.mjs",
+      },
+    });
+  }, "Should throw if both moduleURI and esModuleURI are specified.");
+
+  SimpleTest.doesThrow(() => {
+    ChromeUtils.registerWindowActor("TestWindow", {
+      parent: {
+        esModuleURI: "resource://testing-common/TestWindowParent.sys.mjs",
+      },
+      child: {
+        moduleURI: "resource://testing-common/TestWindowChild.jsm",
+        esModuleURI: "resource://testing-common/TestWindowChild.sys.mjs",
+      },
+    });
+  }, "Should throw if both moduleURI and esModuleURI are specified.");
+
+  SimpleTest.doesThrow(() => {
+    ChromeUtils.registerWindowActor("TestWindow", {
+      parent: {
+        moduleURI: "resource://testing-common/TestWindowParent.jsm",
+        esModuleURI: "resource://testing-common/TestWindowParent.sys.mjs",
+      },
+      child: {
+        moduleURI: "resource://testing-common/TestWindowChild.jsm",
+      },
+    });
+  }, "Should throw if both moduleURI and esModuleURI are specified.");
+
+  SimpleTest.doesThrow(() => {
+    ChromeUtils.registerWindowActor("TestWindow", {
+      parent: {
+        moduleURI: "resource://testing-common/TestWindowParent.jsm",
+        esModuleURI: "resource://testing-common/TestWindowParent.sys.mjs",
+      },
+      child: {
+        esModuleURI: "resource://testing-common/TestWindowChild.sys.mjs",
+      },
+    });
+  }, "Should throw if both moduleURI and esModuleURI are specified.");
+});
+
+add_task(function specify_mixed() {
+  // Mixing JSM and ESM should work.
+
+  try {
+    ChromeUtils.registerWindowActor("TestWindow", {
+      parent: {
+        moduleURI: "resource://testing-common/TestWindowParent.jsm",
+      },
+      child: {
+        esModuleURI: "resource://testing-common/TestWindowChild.sys.mjs",
+      },
+    });
+  } finally {
+    ChromeUtils.unregisterWindowActor("TestWindow");
+  }
+
+  try {
+    ChromeUtils.registerWindowActor("TestWindow", {
+      parent: {
+        esModuleURI: "resource://testing-common/TestWindowParent.sys.mjs",
+      },
+      child: {
+        moduleURI: "resource://testing-common/TestWindowChild.jsm",
+      },
+    });
+  } finally {
+    ChromeUtils.unregisterWindowActor("TestWindow");
+  }
+});
diff --git a/dom/ipc/tests/JSWindowActor/file_dummyChromePage.html b/dom/ipc/tests/JSWindowActor/file_dummyChromePage.html
new file mode 100644
index 0000000000..c50eddd41f
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/file_dummyChromePage.html
@@ -0,0 +1 @@
+<!doctype html>
diff --git a/dom/ipc/tests/JSWindowActor/file_mediaPlayback.html b/dom/ipc/tests/JSWindowActor/file_mediaPlayback.html
new file mode 100644
index 0000000000..a6979287e2
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/file_mediaPlayback.html
@@ -0,0 +1,2 @@
+<!DOCTYPE html>
+<audio src="audio.ogg" controls loop>
diff --git a/dom/ipc/tests/JSWindowActor/head.js b/dom/ipc/tests/JSWindowActor/head.js
new file mode 100644
index 0000000000..cfabd40aac
--- /dev/null
+++ b/dom/ipc/tests/JSWindowActor/head.js
@@ -0,0 +1,82 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Provide infrastructure for JSWindowActor tests.
+ */
+
+const URL = "about:blank";
+const TEST_URL = "http://test2.example.org/";
+let windowActorOptions = {
+  jsm: {
+    parent: {
+      moduleURI: "resource://testing-common/TestWindowParent.jsm",
+    },
+    child: {
+      moduleURI: "resource://testing-common/TestWindowChild.jsm",
+    },
+  },
+  "sys.mjs": {
+    parent: {
+      esModuleURI: "resource://testing-common/TestWindowParent.sys.mjs",
+    },
+    child: {
+      esModuleURI: "resource://testing-common/TestWindowChild.sys.mjs",
+    },
+  },
+};
+
+function declTest(name, cfg) {
+  declTestWithOptions(name, cfg, "jsm");
+  declTestWithOptions(name, cfg, "sys.mjs");
+}
+
+function declTestWithOptions(name, cfg, fileExt) {
+  let {
+    url = "about:blank",
+    allFrames = false,
+    includeChrome = false,
+    matches,
+    remoteTypes,
+    messageManagerGroups,
+    events,
+    observers,
+    test,
+  } = cfg;
+
+  // Build the actor options object which will be used to register & unregister
+  // our window actor.
+  let actorOptions = {
+    parent: { ...windowActorOptions[fileExt].parent },
+    child: { ...windowActorOptions[fileExt].child, events, observers },
+  };
+  actorOptions.allFrames = allFrames;
+  actorOptions.includeChrome = includeChrome;
+  if (matches !== undefined) {
+    actorOptions.matches = matches;
+  }
+  if (remoteTypes !== undefined) {
+    actorOptions.remoteTypes = remoteTypes;
+  }
+  if (messageManagerGroups !== undefined) {
+    actorOptions.messageManagerGroups = messageManagerGroups;
+  }
+
+  // Add a new task for the actor test declared here.
+  add_task(async function () {
+    info("Entering test: " + name);
+
+    // Register our actor, and load a new tab with the relevant URL
+    ChromeUtils.registerWindowActor("TestWindow", actorOptions);
+    try {
+      await BrowserTestUtils.withNewTab(url, async browser => {
+        info("browser ready");
+        await Promise.resolve(test(browser, window, fileExt));
+      });
+    } finally {
+      // Unregister the actor after the test is complete.
+      ChromeUtils.unregisterWindowActor("TestWindow");
+      info("Exiting test: " + name);
+    }
+  });
+}
diff --git a/dom/ipc/tests/blob_verify.sjs b/dom/ipc/tests/blob_verify.sjs
new file mode 100644
index 0000000000..c979192bf0
--- /dev/null
+++ b/dom/ipc/tests/blob_verify.sjs
@@ -0,0 +1,26 @@
+const CC = Components.Constructor;
+const BinaryInputStream = CC(
+  "@mozilla.org/binaryinputstream;1",
+  "nsIBinaryInputStream",
+  "setInputStream"
+);
+const BinaryOutputStream = CC(
+  "@mozilla.org/binaryoutputstream;1",
+  "nsIBinaryOutputStream",
+  "setOutputStream"
+);
+
+function handleRequest(request, response) {
+  var bodyStream = new BinaryInputStream(request.bodyInputStream);
+  var bodyBytes = [];
+  let bodyAvail;
+  while ((bodyAvail = bodyStream.available()) > 0) {
+    Array.prototype.push.apply(bodyBytes, bodyStream.readByteArray(bodyAvail));
+  }
+
+  var bos = new BinaryOutputStream(response.bodyOutputStream);
+
+  response.processAsync();
+  bos.writeByteArray(bodyBytes);
+  response.finish();
+}
diff --git a/dom/ipc/tests/browser.ini b/dom/ipc/tests/browser.ini
new file mode 100644
index 0000000000..b411eb76de
--- /dev/null
+++ b/dom/ipc/tests/browser.ini
@@ -0,0 +1,75 @@
+[DEFAULT]
+support-files =
+  file_disableScript.html
+  file_domainPolicy_base.html
+  file_cancel_content_js.html
+  ../../media/test/short.mp4
+  ../../media/test/owl.mp3
+
+[browser_CrashService_crash.js]
+skip-if = !crashreporter
+[browser_ProcessPriorityManager.js]
+skip-if = (os != "win") || (os != "linux") || (os != "mac")
+# The Process Priority Manager is only enabled for Windows, Linux, and MacOS so far.
+# Bug 1522879.
+# However, you can still run browser_ProcessPriorityManager.js locally on other
+# OSes. This will test the priority manager infrastructure but not actually
+# change the priority.
+support-files =
+  file_cross_frame.html
+  file_dummy.html
+  ../../tests/browser/file_coop_coep.html
+  ../../tests/browser/file_coop_coep.html^headers^
+[browser_crash_oopiframe.js]
+skip-if =
+  !fission
+  !crashreporter
+  verify
+  os == "win" # Bug 1775837
+  os == "linux" # Bug 1775837
+[browser_domainPolicy.js]
+[browser_hide_tooltip.js]
+[browser_memory_distribution_telemetry.js]
+skip-if = true
+[browser_cancel_content_js.js]
+[browser_bug1646088.js]
+support-files = file_dummy.html
+[browser_bug1686194.js]
+support-files = file_dummy.html
+[browser_gc_schedule.js]
+# This test is timing sensitive, timing changes due to asan/tsan/debugging
+# can upset it.
+skip-if =
+  verify
+  asan
+  tsan
+  debug
+  os != 'linux'
+  bits != 64
+[browser_very_fission.js]
+support-files = file_dummy.html
+run-if = widget == "gtk"
+[browser_subframesPreferUsed.js]
+skip-if = !fission # Test doesn't make sense without fission
+[browser_wpi_isolate_nothing.js]
+skip-if =
+  !fission # Only relevant for fission
+  apple_catalina && debug # Bug 1741763; high frequency intermittent; leaked 2 windows
+support-files =
+  browser_wpi_base.js
+[browser_wpi_isolate_everything.js]
+skip-if = !fission # Only relevant for fission
+support-files =
+  browser_wpi_base.js
+[browser_wpi_isolate_high_value.js]
+skip-if = !fission # Only relevant for fission
+support-files =
+  browser_wpi_base.js
+[browser_pbrowser_creation_failure.js]
+skip-if = !fission
+[browser_content_shutdown_with_endless_js.js]
+support-files =
+  file_endless_js.html
+  file_dummy.html
+[browser_child_clipboard_restricted.js]
+[browser_layers_unloaded_while_interruptingJS.js]
diff --git a/dom/ipc/tests/browser_CrashService_crash.js b/dom/ipc/tests/browser_CrashService_crash.js
new file mode 100644
index 0000000000..0bcbf95410
--- /dev/null
+++ b/dom/ipc/tests/browser_CrashService_crash.js
@@ -0,0 +1,72 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+// Ensures that content crashes are reported to the crash service
+// (nsICrashService and CrashManager.sys.mjs).
+
+/* eslint-disable mozilla/no-arbitrary-setTimeout */
+SimpleTest.requestFlakyTimeout("untriaged");
+SimpleTest.requestCompleteLog();
+
+add_task(async function () {
+  let tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    forceNewProcess: true,
+  });
+
+  SimpleTest.expectChildProcessCrash();
+
+  let crashMan = Services.crashmanager;
+
+  // First, clear the crash record store.
+  info("Waiting for pruneOldCrashes");
+  var future = new Date(Date.now() + 1000 * 60 * 60 * 24);
+  await crashMan.pruneOldCrashes(future);
+
+  var crashDateMS = Date.now();
+
+  let crashPromise = BrowserTestUtils.crashFrame(tab.linkedBrowser);
+
+  // Finally, poll for the new crash record.
+  await new Promise((resolve, reject) => {
+    function tryGetCrash() {
+      info("Waiting for getCrashes");
+      crashMan.getCrashes().then(
+        function (crashes) {
+          if (crashes.length) {
+            is(crashes.length, 1, "There should be only one record");
+            var crash = crashes[0];
+            ok(
+              crash.isOfType(
+                crashMan.processTypes[Ci.nsIXULRuntime.PROCESS_TYPE_CONTENT],
+                crashMan.CRASH_TYPE_CRASH
+              ),
+              "Record should be a content crash"
+            );
+            ok(!!crash.id, "Record should have an ID");
+            ok(!!crash.crashDate, "Record should have a crash date");
+            var dateMS = crash.crashDate.valueOf();
+            var twoMin = 1000 * 60 * 2;
+            ok(
+              crashDateMS - twoMin <= dateMS && dateMS <= crashDateMS + twoMin,
+              `Record's crash date should be nowish: ` +
+                `now=${crashDateMS} recordDate=${dateMS}`
+            );
+            resolve();
+          } else {
+            setTimeout(tryGetCrash, 1000);
+          }
+        },
+        function (err) {
+          reject(err);
+        }
+      );
+    }
+    setTimeout(tryGetCrash, 1000);
+  });
+
+  await crashPromise;
+
+  await BrowserTestUtils.removeTab(tab);
+});
diff --git a/dom/ipc/tests/browser_ProcessPriorityManager.js b/dom/ipc/tests/browser_ProcessPriorityManager.js
new file mode 100644
index 0000000000..f32306e174
--- /dev/null
+++ b/dom/ipc/tests/browser_ProcessPriorityManager.js
@@ -0,0 +1,894 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const PRIORITY_SET_TOPIC =
+  "process-priority-manager:TEST-ONLY:process-priority-set";
+
+// Copied from Hal.cpp
+const PROCESS_PRIORITY_FOREGROUND = "FOREGROUND";
+const PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE = "BACKGROUND_PERCEIVABLE";
+const PROCESS_PRIORITY_BACKGROUND = "BACKGROUND";
+
+// This is how many milliseconds we'll wait for a process priority
+// change before we assume that it's just not happening.
+const WAIT_FOR_CHANGE_TIME_MS = 2000;
+
+// A convenience function for getting the child ID from a browsing context.
+function browsingContextChildID(bc) {
+  return bc.currentWindowGlobal?.domProcess.childID;
+}
+
+/**
+ * This class is responsible for watching process priority changes, and
+ * mapping them to tabs in a single window.
+ */
+class TabPriorityWatcher {
+  /**
+   * Constructing a TabPriorityWatcher should happen before any tests
+   * start when there's only a single tab in the window.
+   *
+   * Callers must call `destroy()` on any instance that is constructed
+   * when the test is completed.
+   *
+   * @param tabbrowser (<tabbrowser>)
+   *   The tabbrowser (gBrowser) for the window to be tested.
+   */
+  constructor(tabbrowser) {
+    this.tabbrowser = tabbrowser;
+    Assert.equal(
+      tabbrowser.tabs.length,
+      1,
+      "TabPriorityWatcher must be constructed in a window " +
+        "with a single tab to start."
+    );
+
+    // This maps from childIDs to process priorities.
+    this.priorityMap = new Map();
+
+    // The keys in this map are childIDs we're not expecting to change.
+    // Each value is either null (if no change has been seen) or the
+    // priority that the process changed to.
+    this.noChangeChildIDs = new Map();
+
+    Services.obs.addObserver(this, PRIORITY_SET_TOPIC);
+  }
+
+  /**
+   * Cleans up lingering references for an instance of
+   * TabPriorityWatcher to avoid leaks. This should be called when
+   * finishing the test.
+   */
+  destroy() {
+    Services.obs.removeObserver(this, PRIORITY_SET_TOPIC);
+  }
+
+  /**
+   * This returns a Promise that resolves when the process with
+   * the given childID reaches the given priority.
+   * This will eventually time out if that priority is never reached.
+   *
+   * @param childID
+   *   The childID of the process to wait on.
+   * @param expectedPriority (String)
+   *   One of the PROCESS_PRIORITY_ constants defined at the
+   *   top of this file.
+   * @return Promise
+   * @resolves undefined
+   *   Once the browser reaches the expected priority.
+   */
+  async waitForPriorityChange(childID, expectedPriority) {
+    await TestUtils.waitForCondition(() => {
+      let currentPriority = this.priorityMap.get(childID);
+      if (currentPriority == expectedPriority) {
+        Assert.ok(
+          true,
+          `Process with child ID ${childID} reached expected ` +
+            `priority: ${currentPriority}`
+        );
+        return true;
+      }
+      return false;
+    }, `Waiting for process with child ID ${childID} to reach priority ${expectedPriority}`);
+  }
+
+  /**
+   * Returns a Promise that resolves after a duration of
+   * WAIT_FOR_CHANGE_TIME_MS. During that time, if the process
+   * with the passed in child ID changes priority, a test
+   * failure will be registered.
+   *
+   * @param childID
+   *   The childID of the process that we expect to not change priority.
+   * @return Promise
+   * @resolves undefined
+   *   Once the WAIT_FOR_CHANGE_TIME_MS duration has passed.
+   */
+  async ensureNoPriorityChange(childID) {
+    this.noChangeChildIDs.set(childID, null);
+    // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+    await new Promise(resolve => setTimeout(resolve, WAIT_FOR_CHANGE_TIME_MS));
+    let priority = this.noChangeChildIDs.get(childID);
+    Assert.equal(
+      priority,
+      null,
+      `Should have seen no process priority change for child ID ${childID}`
+    );
+    this.noChangeChildIDs.delete(childID);
+  }
+
+  /**
+   * This returns a Promise that resolves when all of the processes
+   * of the browsing contexts in the browsing context tree
+   * of a particular <browser> have reached a particular priority.
+   * This will eventually time out if that priority is never reached.
+   *
+   * @param browser (<browser>)
+   *   The <browser> to get the BC tree from.
+   * @param expectedPriority (String)
+   *   One of the PROCESS_PRIORITY_ constants defined at the
+   *   top of this file.
+   * @return Promise
+   * @resolves undefined
+   *   Once the browser reaches the expected priority.
+   */
+  async waitForBrowserTreePriority(browser, expectedPriority) {
+    let childIDs = new Set(
+      browser.browsingContext
+        .getAllBrowsingContextsInSubtree()
+        .map(browsingContextChildID)
+    );
+    let promises = [];
+    for (let childID of childIDs) {
+      let currentPriority = this.priorityMap.get(childID);
+
+      promises.push(
+        currentPriority == expectedPriority
+          ? this.ensureNoPriorityChange(childID)
+          : this.waitForPriorityChange(childID, expectedPriority)
+      );
+    }
+
+    await Promise.all(promises);
+  }
+
+  /**
+   * Synchronously returns the priority of a particular child ID.
+   *
+   * @param childID
+   *   The childID to get the content process priority for.
+   * @return String
+   *   The priority of the child ID's process.
+   */
+  currentPriority(childID) {
+    return this.priorityMap.get(childID);
+  }
+
+  /**
+   * A utility function that takes a string passed via the
+   * PRIORITY_SET_TOPIC observer notification and extracts the
+   * childID and priority string.
+   *
+   * @param ppmDataString (String)
+   *   The string data passed through the PRIORITY_SET_TOPIC observer
+   *   notification.
+   * @return Object
+   *   An object with the following properties:
+   *
+   *   childID (Number)
+   *     The ID of the content process that changed priority.
+   *
+   *   priority (String)
+   *     The priority that the content process was set to.
+   */
+  parsePPMData(ppmDataString) {
+    let [childIDStr, priority] = ppmDataString.split(":");
+    return {
+      childID: parseInt(childIDStr, 10),
+      priority,
+    };
+  }
+
+  /** nsIObserver **/
+  observe(subject, topic, data) {
+    if (topic != PRIORITY_SET_TOPIC) {
+      Assert.ok(false, "TabPriorityWatcher is observing the wrong topic");
+      return;
+    }
+
+    let { childID, priority } = this.parsePPMData(data);
+    if (this.noChangeChildIDs.has(childID)) {
+      this.noChangeChildIDs.set(childID, priority);
+    }
+    this.priorityMap.set(childID, priority);
+  }
+}
+
+let gTabPriorityWatcher;
+
+add_setup(async function () {
+  // We need to turn on testMode for the process priority manager in
+  // order to receive the observer notifications that this test relies on.
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["dom.ipc.processPriorityManager.testMode", true],
+      ["dom.ipc.processPriorityManager.enabled", true],
+    ],
+  });
+  gTabPriorityWatcher = new TabPriorityWatcher(gBrowser);
+});
+
+registerCleanupFunction(() => {
+  gTabPriorityWatcher.destroy();
+  gTabPriorityWatcher = null;
+});
+
+/**
+ * Utility function that switches the current tabbrowser from one
+ * tab to another, and ensures that the tab that goes into the background
+ * has (or reaches) a particular content process priority.
+ *
+ * It is expected that the fromTab and toTab belong to two separate content
+ * processes.
+ *
+ * @param Object
+ *   An object with the following properties:
+ *
+ *   fromTab (<tab>)
+ *     The tab that will be switched from to the toTab. The fromTab
+ *     is the one that will be going into the background.
+ *
+ *   toTab (<tab>)
+ *     The tab that will be switched to from the fromTab. The toTab
+ *     is presumed to start in the background, and will enter the
+ *     foreground.
+ *
+ *   fromTabExpectedPriority (String)
+ *     The priority that the content process for the fromTab is
+ *     expected to be (or reach) after the tab goes into the background.
+ *     This should be one of the PROCESS_PRIORITY_ strings defined at the
+ *     top of the file.
+ *
+ * @return Promise
+ * @resolves undefined
+ *   Once the tab switch is complete, and the two content processes for the
+ *   tabs have reached the expected priority levels.
+ */
+async function assertPriorityChangeOnBackground({
+  fromTab,
+  toTab,
+  fromTabExpectedPriority,
+}) {
+  let fromBrowser = fromTab.linkedBrowser;
+  let toBrowser = toTab.linkedBrowser;
+
+  // If the tabs aren't running in separate processes, none of the
+  // rest of this is going to work.
+  Assert.notEqual(
+    toBrowser.frameLoader.remoteTab.osPid,
+    fromBrowser.frameLoader.remoteTab.osPid,
+    "Tabs should be running in separate processes."
+  );
+
+  let fromPromise = gTabPriorityWatcher.waitForBrowserTreePriority(
+    fromBrowser,
+    fromTabExpectedPriority
+  );
+  let toPromise = gTabPriorityWatcher.waitForBrowserTreePriority(
+    toBrowser,
+    PROCESS_PRIORITY_FOREGROUND
+  );
+
+  await BrowserTestUtils.switchTab(gBrowser, toTab);
+  await Promise.all([fromPromise, toPromise]);
+}
+
+/**
+ * Test that if a normal tab goes into the background,
+ * it has its process priority lowered to PROCESS_PRIORITY_BACKGROUND.
+ * Additionally, test priorityHint flag sets the process priority
+ * appropriately to PROCESS_PRIORITY_BACKGROUND and PROCESS_PRIORITY_FOREGROUND.
+ */
+add_task(async function test_normal_background_tab() {
+  let originalTab = gBrowser.selectedTab;
+
+  await BrowserTestUtils.withNewTab(
+    "https://example.com/browser/dom/ipc/tests/file_cross_frame.html",
+    async browser => {
+      let tab = gBrowser.getTabForBrowser(browser);
+      await assertPriorityChangeOnBackground({
+        fromTab: tab,
+        toTab: originalTab,
+        fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND,
+      });
+
+      await assertPriorityChangeOnBackground({
+        fromTab: originalTab,
+        toTab: tab,
+        fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND,
+      });
+
+      let origtabID = browsingContextChildID(
+        originalTab.linkedBrowser.browsingContext
+      );
+
+      Assert.equal(
+        originalTab.linkedBrowser.frameLoader.remoteTab.priorityHint,
+        false,
+        "PriorityHint of the original tab should be false by default"
+      );
+
+      // Changing renderLayers doesn't change priority of the background tab.
+      originalTab.linkedBrowser.preserveLayers(true);
+      originalTab.linkedBrowser.renderLayers = true;
+      await new Promise(resolve =>
+        // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+        setTimeout(resolve, WAIT_FOR_CHANGE_TIME_MS)
+      );
+      Assert.equal(
+        gTabPriorityWatcher.currentPriority(origtabID),
+        PROCESS_PRIORITY_BACKGROUND,
+        "Tab didn't get prioritized only due to renderLayers"
+      );
+
+      // Test when priorityHint is true, the original tab priority
+      // becomes PROCESS_PRIORITY_FOREGROUND.
+      originalTab.linkedBrowser.frameLoader.remoteTab.priorityHint = true;
+      Assert.equal(
+        gTabPriorityWatcher.currentPriority(origtabID),
+        PROCESS_PRIORITY_FOREGROUND,
+        "Setting priorityHint to true should set the original tab to foreground priority"
+      );
+
+      // Test when priorityHint is false, the original tab priority
+      // becomes PROCESS_PRIORITY_BACKGROUND.
+      originalTab.linkedBrowser.frameLoader.remoteTab.priorityHint = false;
+      await new Promise(resolve =>
+        // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+        setTimeout(resolve, WAIT_FOR_CHANGE_TIME_MS)
+      );
+      Assert.equal(
+        gTabPriorityWatcher.currentPriority(origtabID),
+        PROCESS_PRIORITY_BACKGROUND,
+        "Setting priorityHint to false should set the original tab to background priority"
+      );
+
+      let tabID = browsingContextChildID(tab.linkedBrowser.browsingContext);
+
+      // Test when priorityHint is true, the process priority of the
+      // active tab remains PROCESS_PRIORITY_FOREGROUND.
+      tab.linkedBrowser.frameLoader.remoteTab.priorityHint = true;
+      Assert.equal(
+        gTabPriorityWatcher.currentPriority(tabID),
+        PROCESS_PRIORITY_FOREGROUND,
+        "Setting priorityHint to true should maintain the new tab priority as foreground"
+      );
+
+      // Test when priorityHint is false, the process priority of the
+      // active tab remains PROCESS_PRIORITY_FOREGROUND.
+      tab.linkedBrowser.frameLoader.remoteTab.priorityHint = false;
+      Assert.equal(
+        gTabPriorityWatcher.currentPriority(tabID),
+        PROCESS_PRIORITY_FOREGROUND,
+        "Setting priorityHint to false should maintain the new tab priority as foreground"
+      );
+
+      originalTab.linkedBrowser.preserveLayers(false);
+      originalTab.linkedBrowser.renderLayers = false;
+    }
+  );
+});
+
+// Load a simple page on the given host into a new tab.
+async function loadKeepAliveTab(host) {
+  let tab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    host + "/browser/dom/ipc/tests/file_dummy.html"
+  );
+  let childID = browsingContextChildID(
+    gBrowser.selectedBrowser.browsingContext
+  );
+
+  Assert.equal(
+    gTabPriorityWatcher.currentPriority(childID),
+    PROCESS_PRIORITY_FOREGROUND,
+    "Loading a new tab should make it prioritized"
+  );
+
+  if (SpecialPowers.useRemoteSubframes) {
+    // There must be only one process with a remote type for the tab we loaded
+    // to ensure that when we load a new page into the iframe with that host
+    // that it will end up in the same process as the initial tab.
+    let remoteType = gBrowser.selectedBrowser.remoteType;
+    await TestUtils.waitForCondition(() => {
+      return (
+        ChromeUtils.getAllDOMProcesses().filter(
+          process => process.remoteType == remoteType
+        ).length == 1
+      );
+    }, `Waiting for there to be only one process with remote type ${remoteType}`);
+  }
+
+  return { tab, childID };
+}
+
+/**
+ * If an iframe in a foreground tab is navigated to a new page for
+ * a different site, then the process of the new iframe page should
+ * have priority PROCESS_PRIORITY_FOREGROUND. Additionally, if Fission
+ * is enabled, then the old iframe page's process's priority should be
+ * lowered to PROCESS_PRIORITY_BACKGROUND.
+ */
+add_task(async function test_iframe_navigate() {
+  // This test (eventually) loads a page from the host topHost that has an
+  // iframe from iframe1Host. It then navigates the iframe to iframe2Host.
+  let topHost = "https://example.com";
+  let iframe1Host = "https://example.org";
+  let iframe2Host = "https://example.net";
+
+  // Before we load the final test page into a tab, we need to load pages
+  // from both iframe hosts into tabs. This is needed so that we are testing
+  // the "load a new page" part of prioritization and not the "initial
+  // process load" part. Additionally, it ensures that the process for the
+  // initial iframe page doesn't shut down once we navigate away from it,
+  // which will also affect its prioritization.
+  let { tab: iframe1Tab, childID: iframe1TabChildID } = await loadKeepAliveTab(
+    iframe1Host
+  );
+  let { tab: iframe2Tab, childID: iframe2TabChildID } = await loadKeepAliveTab(
+    iframe2Host
+  );
+
+  await BrowserTestUtils.withNewTab(
+    topHost + "/browser/dom/ipc/tests/file_cross_frame.html",
+    async browser => {
+      Assert.equal(
+        gTabPriorityWatcher.currentPriority(iframe2TabChildID),
+        PROCESS_PRIORITY_BACKGROUND,
+        "Switching to another new tab should deprioritize the old one"
+      );
+
+      let topChildID = browsingContextChildID(browser.browsingContext);
+      let iframe = browser.browsingContext.children[0];
+      let iframe1ChildID = browsingContextChildID(iframe);
+
+      Assert.equal(
+        gTabPriorityWatcher.currentPriority(topChildID),
+        PROCESS_PRIORITY_FOREGROUND,
+        "The top level page in the new tab should be prioritized"
+      );
+
+      Assert.equal(
+        gTabPriorityWatcher.currentPriority(iframe1ChildID),
+        PROCESS_PRIORITY_FOREGROUND,
+        "The iframe in the new tab should be prioritized"
+      );
+
+      if (SpecialPowers.useRemoteSubframes) {
+        // Basic process uniqueness checks for the state after all three tabs
+        // are initially loaded.
+        Assert.notEqual(
+          topChildID,
+          iframe1ChildID,
+          "file_cross_frame.html should be loaded into a different process " +
+            "than its initial iframe"
+        );
+
+        Assert.notEqual(
+          topChildID,
+          iframe2TabChildID,
+          "file_cross_frame.html should be loaded into a different process " +
+            "than the tab containing iframe2Host"
+        );
+
+        Assert.notEqual(
+          iframe1ChildID,
+          iframe2TabChildID,
+          "The initial iframe loaded by file_cross_frame.html should be " +
+            "loaded into a different process than the tab containing " +
+            "iframe2Host"
+        );
+
+        // Note: this assertion depends on our process selection logic.
+        // Specifically, that we reuse an existing process for an iframe if
+        // possible.
+        Assert.equal(
+          iframe1TabChildID,
+          iframe1ChildID,
+          "Both pages loaded in iframe1Host should be in the same process"
+        );
+      }
+
+      // Do a cross-origin navigation in the iframe in the foreground tab.
+      let iframe2URI = iframe2Host + "/browser/dom/ipc/tests/file_dummy.html";
+      let loaded = BrowserTestUtils.browserLoaded(browser, true, iframe2URI);
+      await SpecialPowers.spawn(
+        iframe,
+        [iframe2URI],
+        async function (_iframe2URI) {
+          content.location = _iframe2URI;
+        }
+      );
+      await loaded;
+
+      let iframe2ChildID = browsingContextChildID(iframe);
+      let iframe1Priority = gTabPriorityWatcher.currentPriority(iframe1ChildID);
+      let iframe2Priority = gTabPriorityWatcher.currentPriority(iframe2ChildID);
+
+      if (SpecialPowers.useRemoteSubframes) {
+        // Basic process uniqueness check for the state after navigating the
+        // iframe. There's no need to check the top level pages because they
+        // have not navigated.
+        //
+        // iframe1ChildID != iframe2ChildID is implied by:
+        //   iframe1ChildID != iframe2TabChildID
+        //   iframe2TabChildID == iframe2ChildID
+        //
+        // iframe2ChildID != topChildID is implied by:
+        //   topChildID != iframe2TabChildID
+        //   iframe2TabChildID == iframe2ChildID
+
+        // Note: this assertion depends on our process selection logic.
+        // Specifically, that we reuse an existing process for an iframe if
+        // possible. If that changes, this test may need to be carefully
+        // rewritten, as the whole point of the test is to check what happens
+        // with the priority manager when an iframe shares a process with
+        // a page in another tab.
+        Assert.equal(
+          iframe2TabChildID,
+          iframe2ChildID,
+          "Both pages loaded in iframe2Host should be in the same process"
+        );
+
+        // Now that we've established the relationship between the various
+        // processes, we can finally check that the priority manager is doing
+        // the right thing.
+        Assert.equal(
+          iframe1Priority,
+          PROCESS_PRIORITY_BACKGROUND,
+          "The old iframe process should have been deprioritized"
+        );
+      } else {
+        Assert.equal(
+          iframe1ChildID,
+          iframe2ChildID,
+          "Navigation should not have switched processes"
+        );
+      }
+
+      Assert.equal(
+        iframe2Priority,
+        PROCESS_PRIORITY_FOREGROUND,
+        "The new iframe process should be prioritized"
+      );
+    }
+  );
+
+  await BrowserTestUtils.removeTab(iframe2Tab);
+  await BrowserTestUtils.removeTab(iframe1Tab);
+});
+
+/**
+ * Test that a cross-group navigation properly preserves the process priority.
+ * The goal of this test is to check that the code related to mPriorityActive in
+ * CanonicalBrowsingContext::ReplacedBy works correctly, but in practice the
+ * prioritization code in SetRenderLayers will also make this test pass, though
+ * that prioritization happens slightly later.
+ */
+add_task(async function test_cross_group_navigate() {
+  // This page is same-site with the page we're going to cross-group navigate to.
+  let coopPage =
+    "https://example.com/browser/dom/tests/browser/file_coop_coep.html";
+
+  // Load it as a top level tab so that we don't accidentally get the initial
+  // load prioritization.
+  let backgroundTab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    coopPage
+  );
+  let backgroundTabChildID = browsingContextChildID(
+    gBrowser.selectedBrowser.browsingContext
+  );
+
+  Assert.equal(
+    gTabPriorityWatcher.currentPriority(backgroundTabChildID),
+    PROCESS_PRIORITY_FOREGROUND,
+    "Loading a new tab should make it prioritized"
+  );
+
+  await BrowserTestUtils.withNewTab(
+    "https://example.org/browser/dom/ipc/tests/file_cross_frame.html",
+    async browser => {
+      Assert.equal(
+        gTabPriorityWatcher.currentPriority(backgroundTabChildID),
+        PROCESS_PRIORITY_BACKGROUND,
+        "Switching to a new tab should deprioritize the old one"
+      );
+
+      let dotOrgChildID = browsingContextChildID(browser.browsingContext);
+
+      // Do a cross-group navigation.
+      BrowserTestUtils.loadURIString(browser, coopPage);
+      await BrowserTestUtils.browserLoaded(browser);
+
+      let coopChildID = browsingContextChildID(browser.browsingContext);
+      let coopPriority = gTabPriorityWatcher.currentPriority(coopChildID);
+      let dotOrgPriority = gTabPriorityWatcher.currentPriority(dotOrgChildID);
+
+      Assert.equal(
+        backgroundTabChildID,
+        coopChildID,
+        "The same site should get loaded into the same process"
+      );
+      Assert.notEqual(
+        dotOrgChildID,
+        coopChildID,
+        "Navigation should have switched processes"
+      );
+      Assert.equal(
+        dotOrgPriority,
+        PROCESS_PRIORITY_BACKGROUND,
+        "The old page process should have been deprioritized"
+      );
+      Assert.equal(
+        coopPriority,
+        PROCESS_PRIORITY_FOREGROUND,
+        "The new page process should be prioritized"
+      );
+    }
+  );
+
+  await BrowserTestUtils.removeTab(backgroundTab);
+});
+
+/**
+ * Test that if a tab with video goes into the background,
+ * it has its process priority lowered to
+ * PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE if it has no audio,
+ * and that it has its priority remain at
+ * PROCESS_PRIORITY_FOREGROUND if it does have audio.
+ */
+add_task(async function test_video_background_tab() {
+  let originalTab = gBrowser.selectedTab;
+
+  await BrowserTestUtils.withNewTab("https://example.com", async browser => {
+    // Let's load up a video in the tab, but mute it, so that this tab should
+    // reach PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE.
+    await SpecialPowers.spawn(browser, [], async () => {
+      let video = content.document.createElement("video");
+      video.src = "https://example.net/browser/dom/ipc/tests/short.mp4";
+      video.muted = true;
+      content.document.body.appendChild(video);
+      // We'll loop the video to avoid it ending before the test is done.
+      video.loop = true;
+      await video.play();
+    });
+
+    let tab = gBrowser.getTabForBrowser(browser);
+
+    // The tab with the muted video should reach
+    // PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE when backgrounded.
+    await assertPriorityChangeOnBackground({
+      fromTab: tab,
+      toTab: originalTab,
+      fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE,
+    });
+
+    // Now switch back. The initial blank tab should reach
+    // PROCESS_PRIORITY_BACKGROUND when backgrounded.
+    await assertPriorityChangeOnBackground({
+      fromTab: originalTab,
+      toTab: tab,
+      fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND,
+    });
+
+    // Let's unmute the video now.
+    await SpecialPowers.spawn(browser, [], async () => {
+      let video = content.document.querySelector("video");
+      video.muted = false;
+    });
+
+    // The tab with the unmuted video should stay at
+    // PROCESS_PRIORITY_FOREGROUND when backgrounded.
+    await assertPriorityChangeOnBackground({
+      fromTab: tab,
+      toTab: originalTab,
+      fromTabExpectedPriority: PROCESS_PRIORITY_FOREGROUND,
+    });
+
+    // Now switch back. The initial blank tab should reach
+    // PROCESS_PRIORITY_BACKGROUND when backgrounded.
+    await assertPriorityChangeOnBackground({
+      fromTab: originalTab,
+      toTab: tab,
+      fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND,
+    });
+  });
+});
+
+/**
+ * Test that if a tab with a playing <audio> element goes into
+ * the background, the process priority does not change, unless
+ * that audio is muted (in which case, it reaches
+ * PROCESS_PRIORITY_BACKGROUND).
+ */
+add_task(async function test_audio_background_tab() {
+  let originalTab = gBrowser.selectedTab;
+
+  await BrowserTestUtils.withNewTab("https://example.com", async browser => {
+    // Let's load up some audio in the tab, but mute it, so that this tab should
+    // reach PROCESS_PRIORITY_BACKGROUND.
+    await SpecialPowers.spawn(browser, [], async () => {
+      let audio = content.document.createElement("audio");
+      audio.src = "https://example.net/browser/dom/ipc/tests/owl.mp3";
+      audio.muted = true;
+      content.document.body.appendChild(audio);
+      // We'll loop the audio to avoid it ending before the test is done.
+      audio.loop = true;
+      await audio.play();
+    });
+
+    let tab = gBrowser.getTabForBrowser(browser);
+
+    // The tab with the muted audio should reach
+    // PROCESS_PRIORITY_BACKGROUND when backgrounded.
+    await assertPriorityChangeOnBackground({
+      fromTab: tab,
+      toTab: originalTab,
+      fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND,
+    });
+
+    // Now switch back. The initial blank tab should reach
+    // PROCESS_PRIORITY_BACKGROUND when backgrounded.
+    await assertPriorityChangeOnBackground({
+      fromTab: originalTab,
+      toTab: tab,
+      fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND,
+    });
+
+    // Now unmute the audio. Unfortuntely, there's a bit of a race here,
+    // since the wakelock on the audio element is released and then
+    // re-acquired if the audio reaches its end and loops around. This
+    // will cause an unexpected priority change on the content process.
+    //
+    // To avoid this race, we'll seek the audio back to the beginning,
+    // and lower its playback rate to the minimum to increase the
+    // likelihood that the check completes before the audio loops around.
+    await SpecialPowers.spawn(browser, [], async () => {
+      let audio = content.document.querySelector("audio");
+      let seeked = ContentTaskUtils.waitForEvent(audio, "seeked");
+      audio.muted = false;
+      // 0.25 is the minimum playback rate that still keeps the audio audible.
+      audio.playbackRate = 0.25;
+      audio.currentTime = 0;
+      await seeked;
+    });
+
+    // The tab with the unmuted audio should stay at
+    // PROCESS_PRIORITY_FOREGROUND when backgrounded.
+    await assertPriorityChangeOnBackground({
+      fromTab: tab,
+      toTab: originalTab,
+      fromTabExpectedPriority: PROCESS_PRIORITY_FOREGROUND,
+    });
+
+    // Now switch back. The initial blank tab should reach
+    // PROCESS_PRIORITY_BACKGROUND when backgrounded.
+    await assertPriorityChangeOnBackground({
+      fromTab: originalTab,
+      toTab: tab,
+      fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND,
+    });
+  });
+});
+
+/**
+ * Test that if a tab with a WebAudio playing goes into the background,
+ * the process priority does not change, unless that WebAudio context is
+ * suspended.
+ */
+add_task(async function test_web_audio_background_tab() {
+  let originalTab = gBrowser.selectedTab;
+
+  await BrowserTestUtils.withNewTab("https://example.com", async browser => {
+    // Let's synthesize a basic square wave as WebAudio.
+    await SpecialPowers.spawn(browser, [], async () => {
+      let audioCtx = new content.AudioContext();
+      let oscillator = audioCtx.createOscillator();
+      oscillator.type = "square";
+      oscillator.frequency.setValueAtTime(440, audioCtx.currentTime);
+      oscillator.connect(audioCtx.destination);
+      oscillator.start();
+      while (audioCtx.state != "running") {
+        info(`wait until AudioContext starts running`);
+        await new Promise(r => (audioCtx.onstatechange = r));
+      }
+      // we'll stash the AudioContext away so that it's easier to access
+      // in the next SpecialPowers.spawn.
+      content.audioCtx = audioCtx;
+    });
+
+    let tab = gBrowser.getTabForBrowser(browser);
+
+    // The tab with the WebAudio should stay at
+    // PROCESS_PRIORITY_FOREGROUND when backgrounded.
+    await assertPriorityChangeOnBackground({
+      fromTab: tab,
+      toTab: originalTab,
+      fromTabExpectedPriority: PROCESS_PRIORITY_FOREGROUND,
+    });
+
+    // Now switch back. The initial blank tab should reach
+    // PROCESS_PRIORITY_BACKGROUND when backgrounded.
+    await assertPriorityChangeOnBackground({
+      fromTab: originalTab,
+      toTab: tab,
+      fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND,
+    });
+
+    // Now suspend the WebAudio. This will cause it to stop
+    // playing.
+    await SpecialPowers.spawn(browser, [], async () => {
+      content.audioCtx.suspend();
+    });
+
+    // The tab with the suspended WebAudio should reach
+    // PROCESS_PRIORITY_BACKGROUND when backgrounded.
+    await assertPriorityChangeOnBackground({
+      fromTab: tab,
+      toTab: originalTab,
+      fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND,
+    });
+
+    // Now switch back. The initial blank tab should reach
+    // PROCESS_PRIORITY_BACKGROUND when backgrounded.
+    await assertPriorityChangeOnBackground({
+      fromTab: originalTab,
+      toTab: tab,
+      fromTabExpectedPriority: PROCESS_PRIORITY_BACKGROUND,
+    });
+  });
+});
+
+/**
+ * Test that foreground tab's process priority isn't changed when going back to
+ * a bfcached session history entry.
+ */
+add_task(async function test_audio_background_tab() {
+  let page1 = "https://example.com";
+  let page2 = page1 + "/?2";
+
+  await BrowserTestUtils.withNewTab(page1, async browser => {
+    let childID = browsingContextChildID(browser.browsingContext);
+    Assert.equal(
+      gTabPriorityWatcher.currentPriority(childID),
+      PROCESS_PRIORITY_FOREGROUND,
+      "Loading a new tab should make it prioritized."
+    );
+    let loaded = BrowserTestUtils.browserLoaded(browser, false, page2);
+    BrowserTestUtils.loadURIString(browser, page2);
+    await loaded;
+
+    childID = browsingContextChildID(browser.browsingContext);
+    Assert.equal(
+      gTabPriorityWatcher.currentPriority(childID),
+      PROCESS_PRIORITY_FOREGROUND,
+      "Loading a new page should keep the tab prioritized."
+    );
+
+    let pageShowPromise = BrowserTestUtils.waitForContentEvent(
+      browser,
+      "pageshow"
+    );
+    browser.goBack();
+    await pageShowPromise;
+
+    childID = browsingContextChildID(browser.browsingContext);
+    Assert.equal(
+      gTabPriorityWatcher.currentPriority(childID),
+      PROCESS_PRIORITY_FOREGROUND,
+      "Loading a page from the bfcache should keep the tab prioritized."
+    );
+  });
+});
diff --git a/dom/ipc/tests/browser_bug1646088.js b/dom/ipc/tests/browser_bug1646088.js
new file mode 100644
index 0000000000..1e5db3d748
--- /dev/null
+++ b/dom/ipc/tests/browser_bug1646088.js
@@ -0,0 +1,71 @@
+let dir = getChromeDir(getResolvedURI(gTestPath));
+dir.append("file_dummy.html");
+const uriString = Services.io.newFileURI(dir).spec;
+
+add_task(async function () {
+  await BrowserTestUtils.withNewTab(
+    "https://example.com",
+    async function (browser) {
+      // Override the browser's `prepareToChangeRemoteness` so that we can delay
+      // the process switch for an indefinite amount of time. This will allow us
+      // to control the timing of the resolve call to trigger the bug.
+      let prepareToChangeCalled = PromiseUtils.defer();
+      let finishSwitch = PromiseUtils.defer();
+      let oldPrepare = browser.prepareToChangeRemoteness;
+      browser.prepareToChangeRemoteness = async () => {
+        prepareToChangeCalled.resolve();
+        await oldPrepare.call(browser);
+        await finishSwitch.promise;
+      };
+
+      // Begin a process switch, which should cause `prepareToChangeRemoteness` to
+      // be called.
+      // NOTE: This used to avoid BrowserTestUtils.loadURI, as that call would
+      // previously eagerly perform a process switch meaning that the interesting
+      // codepath wouldn't be triggered. Nowadays the process switch codepath
+      // always happens during navigation as required by this test.
+      info("Beginning process switch into file URI process");
+      let browserLoaded = BrowserTestUtils.browserLoaded(browser);
+      BrowserTestUtils.loadURIString(browser, uriString);
+      await prepareToChangeCalled.promise;
+
+      // The tab we opened is now midway through process switching. Open another
+      // browser within the same tab, and immediately close it after the load
+      // finishes.
+      info("Creating new tab loaded in file URI process");
+      let fileProcess;
+      let browserParentDestroyed = PromiseUtils.defer();
+      await BrowserTestUtils.withNewTab(
+        uriString,
+        async function (otherBrowser) {
+          let remoteTab = otherBrowser.frameLoader.remoteTab;
+          fileProcess = remoteTab.contentProcessId;
+          info("Loaded test URI in pid: " + fileProcess);
+
+          browserParentDestroyed.resolve(
+            TestUtils.topicObserved(
+              "ipc:browser-destroyed",
+              subject => subject === remoteTab
+            )
+          );
+        }
+      );
+      await browserParentDestroyed.promise;
+
+      // This browser has now been closed, which could cause the file content
+      // process to begin shutting down, despite us process switching into it.
+      // We can now allow the process switch to finish, and wait for the load to
+      // finish as well.
+      info("BrowserParent has been destroyed, finishing process switch");
+      finishSwitch.resolve();
+      await browserLoaded;
+
+      info("Load complete");
+      is(
+        browser.frameLoader.remoteTab.contentProcessId,
+        fileProcess,
+        "Should have loaded in the same file URI process"
+      );
+    }
+  );
+});
diff --git a/dom/ipc/tests/browser_bug1686194.js b/dom/ipc/tests/browser_bug1686194.js
new file mode 100644
index 0000000000..f6acefa2f2
--- /dev/null
+++ b/dom/ipc/tests/browser_bug1686194.js
@@ -0,0 +1,47 @@
+/* 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/. */
+
+"use strict";
+
+const TEST_PAGE =
+  "http://mochi.test:8888/browser/dom/ipc/tests/file_dummy.html";
+
+function untilPageTitleChanged() {
+  return new Promise(resolve =>
+    gBrowser.addEventListener("pagetitlechanged", resolve, { once: true })
+  );
+}
+
+add_task(async () => {
+  const tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    opening: TEST_PAGE,
+  });
+
+  const { linkedBrowser } = tab;
+  ok(
+    tab.getAttribute("label").includes("file_dummy.html"),
+    "The title should be the raw path"
+  );
+
+  await Promise.all([
+    SpecialPowers.spawn(linkedBrowser, [], function () {
+      content.document.title = "Title";
+    }),
+    untilPageTitleChanged(),
+  ]);
+
+  is(tab.getAttribute("label"), "Title", "The title should change");
+
+  linkedBrowser.reload();
+
+  await untilPageTitleChanged();
+
+  ok(
+    tab.getAttribute("label").includes("file_dummy.html"),
+    "The title should be the raw path again"
+  );
+
+  BrowserTestUtils.removeTab(tab);
+});
diff --git a/dom/ipc/tests/browser_cancel_content_js.js b/dom/ipc/tests/browser_cancel_content_js.js
new file mode 100644
index 0000000000..e33d59792c
--- /dev/null
+++ b/dom/ipc/tests/browser_cancel_content_js.js
@@ -0,0 +1,72 @@
+/* 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/. */
+
+"use strict";
+
+requestLongerTimeout(10);
+
+const TEST_PAGE =
+  "http://mochi.test:8888/browser/dom/ipc/tests/file_cancel_content_js.html";
+const NEXT_PAGE = "http://mochi.test:8888/browser/dom/ipc/tests/";
+const JS_URI = "javascript:void(document.title = 'foo')";
+
+async function test_navigation(nextPage, cancelContentJSPref, shouldCancel) {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["dom.ipc.cancel_content_js_when_navigating", cancelContentJSPref],
+      ["dom.max_script_run_time", 20],
+      // Force a single process so that the navigation will complete in the same
+      // process as the previous page which is running the long-running script.
+      ["dom.ipc.processCount", 1],
+      ["dom.ipc.processCount.webIsolated", 1],
+    ],
+  });
+  let tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    opening: TEST_PAGE,
+  });
+
+  const loopEnded = ContentTask.spawn(tab.linkedBrowser, [], async function () {
+    await new Promise(resolve => {
+      content.addEventListener("LongLoopEnded", resolve, {
+        once: true,
+      });
+    });
+  });
+
+  // Wait for the test page's long-running JS loop to start.
+  await ContentTask.spawn(tab.linkedBrowser, [], function () {
+    content.dispatchEvent(new content.Event("StartLongLoop"));
+  });
+
+  info(
+    `navigating to ${nextPage} with cancel content JS ${
+      cancelContentJSPref ? "enabled" : "disabled"
+    }`
+  );
+  const nextPageLoaded = BrowserTestUtils.waitForContentEvent(
+    tab.linkedBrowser,
+    "DOMTitleChanged"
+  );
+  BrowserTestUtils.loadURIString(gBrowser, nextPage);
+
+  const result = await Promise.race([
+    nextPageLoaded,
+    loopEnded.then(() => "timeout"),
+  ]);
+
+  const timedOut = result === "timeout";
+  if (shouldCancel) {
+    ok(timedOut === false, "expected next page to be loaded");
+  } else {
+    ok(timedOut === true, "expected timeout");
+  }
+
+  BrowserTestUtils.removeTab(tab);
+}
+
+add_task(async () => test_navigation(NEXT_PAGE, true, true));
+add_task(async () => test_navigation(NEXT_PAGE, false, false));
+add_task(async () => test_navigation(JS_URI, true, false));
+add_task(async () => test_navigation(JS_URI, false, false));
diff --git a/dom/ipc/tests/browser_child_clipboard_restricted.js b/dom/ipc/tests/browser_child_clipboard_restricted.js
new file mode 100644
index 0000000000..cafed732d1
--- /dev/null
+++ b/dom/ipc/tests/browser_child_clipboard_restricted.js
@@ -0,0 +1,89 @@
+/* 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/. */
+add_task(async function () {
+  // Create a new content tab to make sure the paste is cross-process.
+  let tab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    "data:text/html,<br>"
+  );
+  let browser = tab.linkedBrowser;
+
+  await SpecialPowers.spawn(browser, [], async function (arg) {
+    const trans = Cc["@mozilla.org/widget/transferable;1"].createInstance(
+      Ci.nsITransferable
+    );
+    trans.init(null);
+
+    const string = Cc["@mozilla.org/supports-string;1"].createInstance(
+      Ci.nsISupportsString
+    );
+    string.data = "blablabla";
+
+    trans.addDataFlavor("text/unknown");
+    trans.setTransferData("text/unknown", string);
+
+    trans.addDataFlavor("text/plain");
+    trans.setTransferData("text/plain", string);
+
+    // Write to clipboard.
+    Services.clipboard.setData(trans, null, Ci.nsIClipboard.kGlobalClipboard);
+  });
+
+  // Wait for known.
+  for (var i = 0; i < 20; i++) {
+    if (
+      Services.clipboard.hasDataMatchingFlavors(
+        ["text/plain"],
+        Services.clipboard.kGlobalClipboard
+      )
+    ) {
+      break;
+    }
+  }
+
+  function readClipboard(flavor) {
+    const trans = Cc["@mozilla.org/widget/transferable;1"].createInstance(
+      Ci.nsITransferable
+    );
+    trans.init(null);
+    trans.addDataFlavor(flavor);
+    Services.clipboard.getData(trans, Services.clipboard.kGlobalClipboard);
+
+    let data = {};
+    trans.getTransferData(flavor, data);
+    return data.value.QueryInterface(Ci.nsISupportsString).data;
+  }
+
+  ok(
+    Services.clipboard.hasDataMatchingFlavors(
+      ["text/plain"],
+      Services.clipboard.kGlobalClipboard
+    ),
+    "clipboard should have text/plain"
+  );
+
+  is(
+    readClipboard("text/plain"),
+    "blablabla",
+    "matching string for text/plain"
+  );
+
+  ok(
+    !Services.clipboard.hasDataMatchingFlavors(
+      ["text/unknown"],
+      Services.clipboard.kGlobalClipboard
+    ),
+    "clipboard should not have text/unknown"
+  );
+
+  let error = undefined;
+  try {
+    readClipboard("text/unknown");
+  } catch (e) {
+    error = e;
+  }
+  is(typeof error, "object", "reading text/unknown should fail");
+
+  BrowserTestUtils.removeTab(tab);
+});
diff --git a/dom/ipc/tests/browser_content_shutdown_with_endless_js.js b/dom/ipc/tests/browser_content_shutdown_with_endless_js.js
new file mode 100644
index 0000000000..c97e22f633
--- /dev/null
+++ b/dom/ipc/tests/browser_content_shutdown_with_endless_js.js
@@ -0,0 +1,86 @@
+/* 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/. */
+
+"use strict";
+
+const EMPTY_PAGE =
+  "http://mochi.test:8888/browser/dom/ipc/tests/file_dummy.html";
+
+const HANG_PAGE =
+  "http://mochi.test:8888/browser/dom/ipc/tests/file_endless_js.html";
+
+function pushPref(name, val) {
+  return SpecialPowers.pushPrefEnv({ set: [[name, val]] });
+}
+
+async function createAndShutdownContentProcess(url) {
+  info("Create and shutdown a content process for " + url);
+
+  // Launch a new process and load url. Sets up a promise that will resolve
+  // on shutdown.
+  let browserDestroyed = PromiseUtils.defer();
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      opening: url,
+      waitForLoad: true,
+      forceNewProcess: true,
+    },
+    async function (otherBrowser) {
+      let remoteTab = otherBrowser.frameLoader.remoteTab;
+
+      ok(true, "Content process created.");
+
+      browserDestroyed.resolve(
+        TestUtils.topicObserved(
+          "ipc:browser-destroyed",
+          subject => subject === remoteTab
+        )
+      );
+
+      // Trigger onmessage in the content browser
+      await SpecialPowers.spawn(otherBrowser, [], function () {
+        content.postMessage("LoadedMessage", "*");
+      });
+
+      // Give the content process some extra time before we start its shutdown.
+      // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      // withNewTab will start the shutdown of the child process for us
+    }
+  );
+
+  // Now wait for it to really shut down.
+  // If the HANG_PAGE JS is not canceled we will hang here.
+  await browserDestroyed.promise;
+
+  // If we do not hang and get here, we are fine.
+  ok(true, "Shutdown of content process.");
+}
+
+add_task(async () => {
+  // This test is only relevant in e10s.
+  if (!gMultiProcessBrowser) {
+    ok(true, "We are not in multiprocess mode, skipping test.");
+    return;
+  }
+
+  await pushPref("dom.abort_script_on_child_shutdown", true);
+
+  // Ensure the process cache cannot interfere.
+  pushPref("dom.ipc.processPreload.enabled", false);
+  // Ensure we have no cached processes from previous tests.
+  Services.ppmm.releaseCachedProcesses();
+
+  // First let's do a dry run that should always succeed.
+  await createAndShutdownContentProcess(EMPTY_PAGE);
+
+  // Now we will start a shutdown of our content process while our content
+  // script is running an endless loop.
+  //
+  // If the JS does not get interrupted on shutdown, it will cause this test
+  // to hang.
+  await createAndShutdownContentProcess(HANG_PAGE);
+});
diff --git a/dom/ipc/tests/browser_crash_oopiframe.js b/dom/ipc/tests/browser_crash_oopiframe.js
new file mode 100644
index 0000000000..3066d7bf88
--- /dev/null
+++ b/dom/ipc/tests/browser_crash_oopiframe.js
@@ -0,0 +1,235 @@
+"use strict";
+
+/**
+ * Opens a number of tabs containing an out-of-process iframe.
+ *
+ * @param numTabs the number of tabs to open.
+ * @returns the browsing context of the iframe in the last tab opened.
+ */
+async function openTestTabs(numTabs) {
+  let iframeBC = null;
+
+  for (let count = 0; count < numTabs; count++) {
+    let tab = await BrowserTestUtils.openNewForegroundTab({
+      gBrowser,
+      url: "about:blank",
+    });
+
+    // If we load example.com in an injected subframe, we assume that this
+    // will load in its own subprocess, which we can then crash.
+    iframeBC = await SpecialPowers.spawn(tab.linkedBrowser, [], async () => {
+      let iframe = content.document.createElement("iframe");
+      iframe.setAttribute("src", "http://example.com");
+
+      content.document.body.appendChild(iframe);
+      await ContentTaskUtils.waitForEvent(iframe, "load");
+      return iframe.frameLoader.browsingContext;
+    });
+  }
+
+  return iframeBC;
+}
+
+/**
+ * Helper function for testing frame crashing. Some tabs are opened
+ * containing frames from example.com and then the process for
+ * example.com is crashed. Notifications should apply to each tab
+ * and all should close when one of the notifications is closed.
+ *
+ * @param numTabs the number of tabs to open.
+ */
+async function testFrameCrash(numTabs) {
+  let iframeBC = await openTestTabs(numTabs);
+  let browser = gBrowser.selectedBrowser;
+  let rootBC = browser.browsingContext;
+
+  is(iframeBC.parent, rootBC, "oop frame has root as parent");
+
+  let eventFiredPromise = BrowserTestUtils.waitForEvent(
+    browser,
+    "oop-browser-crashed"
+  );
+
+  BrowserTestUtils.crashFrame(
+    browser,
+    true /* shouldShowTabCrashPage */,
+    true /* shouldClearMinidumps */,
+    iframeBC
+  );
+
+  let notificationPromise = BrowserTestUtils.waitForNotificationBar(
+    gBrowser,
+    browser,
+    "subframe-crashed"
+  );
+
+  info("Waiting for oop-browser-crashed event.");
+  await eventFiredPromise.then(event => {
+    ok(!event.isTopFrame, "should not be reporting top-level frame crash");
+    ok(event.childID != 0, "childID is non-zero");
+
+    isnot(
+      event.browsingContextId,
+      rootBC,
+      "top frame browsing context id not expected."
+    );
+
+    is(
+      event.browsingContextId,
+      iframeBC.id,
+      "oop frame browsing context id expected."
+    );
+  });
+
+  if (numTabs == 1) {
+    // The BrowsingContext is re-used, but the window global might still be
+    // getting set up at this point, so wait until it's been initialized.
+    let { subject: windowGlobal } = await BrowserUtils.promiseObserved(
+      "window-global-created",
+      wgp => wgp.documentURI.spec.startsWith("about:framecrashed")
+    );
+
+    is(
+      windowGlobal,
+      iframeBC.currentWindowGlobal,
+      "Resolved on expected window global"
+    );
+
+    let newIframeURI = await SpecialPowers.spawn(iframeBC, [], async () => {
+      return content.document.documentURI;
+    });
+
+    ok(
+      newIframeURI.startsWith("about:framecrashed"),
+      "The iframe is now pointing at about:framecrashed"
+    );
+
+    let title = await SpecialPowers.spawn(iframeBC, [], async () => {
+      await content.document.l10n.ready;
+      return content.document.documentElement.getAttribute("title");
+    });
+    ok(title, "The iframe has a non-empty tooltip.");
+  }
+
+  // Next, check that the crash notification bar has appeared.
+  await notificationPromise;
+
+  for (let count = 1; count <= numTabs; count++) {
+    let notificationBox = gBrowser.getNotificationBox(gBrowser.browsers[count]);
+    let notification = notificationBox.currentNotification;
+    ok(notification, "Notification " + count + " should be visible");
+    is(
+      notification.getAttribute("value"),
+      "subframe-crashed",
+      "Should be showing the right notification" + count
+    );
+
+    let buttons = notification.buttonContainer.querySelectorAll(
+      ".notification-button"
+    );
+    is(
+      buttons.length,
+      1,
+      "Notification " + count + " should have only one button."
+    );
+    let links = notification.messageText.querySelectorAll(".text-link");
+    is(
+      links.length,
+      1,
+      "Notification " + count + " should have only one link."
+    );
+    let msgs = notification.messageText.querySelectorAll(
+      "span[data-l10n-id='crashed-subframe-message']"
+    );
+    is(msgs.length, 1, "Notification " + count + " should have one crash msg.");
+  }
+
+  // Press the ignore button on the visible notification.
+  let notificationBox = gBrowser.getNotificationBox(gBrowser.selectedBrowser);
+  let notification = notificationBox.currentNotification;
+
+  // Make sure all of the notifications were closed when one of them was closed.
+  let closedPromises = [];
+  for (let count = 1; count <= numTabs; count++) {
+    let nb = gBrowser.getNotificationBox(gBrowser.browsers[count]);
+    closedPromises.push(
+      BrowserTestUtils.waitForMutationCondition(
+        nb.stack,
+        { childList: true },
+        () => !nb.currentNotification
+      )
+    );
+  }
+
+  notification.dismiss();
+  await Promise.all(closedPromises);
+
+  for (let count = 1; count <= numTabs; count++) {
+    BrowserTestUtils.removeTab(gBrowser.selectedTab);
+  }
+}
+
+/**
+ * In this test, we crash an out-of-process iframe and
+ * verify that :
+ *  1. the "oop-browser-crashed" event is dispatched with
+ *     the browsing context of the crashed oop subframe.
+ *  2. the crashed subframe is now pointing at "about:framecrashed"
+ *     page.
+ */
+add_task(async function test_crashframe() {
+  // Open a new window with fission enabled.
+  ok(
+    SpecialPowers.useRemoteSubframes,
+    "This test only makes sense of we can use OOP iframes."
+  );
+
+  // Create the crash reporting directory if it doesn't yet exist, otherwise, a failure
+  // sometimes occurs. See bug 1687855 for fixing this.
+  const uAppDataPath = Services.dirsvc.get("UAppData", Ci.nsIFile).path;
+  let path = PathUtils.join(uAppDataPath, "Crash Reports", "pending");
+  await IOUtils.makeDirectory(path, { ignoreExisting: true });
+
+  // Test both one tab and when four tabs are opened.
+  await testFrameCrash(1);
+  await testFrameCrash(4);
+});
+
+// This test checks that no notification shows when there is no minidump available. It
+// simulates the steps that occur during a crash, once with a dumpID and once without.
+add_task(async function test_nominidump() {
+  for (let dumpID of [null, "8888"]) {
+    let iframeBC = await openTestTabs(1);
+
+    let childID = iframeBC.currentWindowGlobal.domProcess.childID;
+
+    gBrowser.selectedBrowser.dispatchEvent(
+      new FrameCrashedEvent("oop-browser-crashed", {
+        browsingContextID: iframeBC,
+        childID,
+        isTopFrame: false,
+        bubbles: true,
+      })
+    );
+
+    let bag = Cc["@mozilla.org/hash-property-bag;1"].createInstance(
+      Ci.nsIWritablePropertyBag
+    );
+    bag.setProperty("abnormal", "true");
+    bag.setProperty("childID", iframeBC.currentWindowGlobal.domProcess.childID);
+    if (dumpID) {
+      bag.setProperty("dumpID", dumpID);
+    }
+
+    Services.obs.notifyObservers(bag, "ipc:content-shutdown");
+
+    let notificationBox = gBrowser.getNotificationBox(gBrowser.selectedBrowser);
+    let notification = notificationBox.currentNotification;
+    ok(
+      dumpID ? notification : !notification,
+      "notification shown for browser with no minidump"
+    );
+
+    BrowserTestUtils.removeTab(gBrowser.selectedTab);
+  }
+});
diff --git a/dom/ipc/tests/browser_domainPolicy.js b/dom/ipc/tests/browser_domainPolicy.js
new file mode 100644
index 0000000000..988288f950
--- /dev/null
+++ b/dom/ipc/tests/browser_domainPolicy.js
@@ -0,0 +1,187 @@
+// This test waits for a lot of subframe loads, causing it to take a long time,
+// especially with Fission enabled.
+requestLongerTimeout(2);
+
+const BASE_FILE =
+  "http://mochi.test:8888/browser/dom/ipc/tests/file_domainPolicy_base.html";
+const SCRIPT_PATH = "/browser/dom/ipc/tests/file_disableScript.html";
+
+const TEST_POLICY = {
+  exceptions: ["http://test1.example.com", "http://example.com"],
+  superExceptions: ["http://test2.example.org", "https://test1.example.com"],
+  exempt: [
+    "http://test1.example.com",
+    "http://example.com",
+    "http://test2.example.org",
+    "http://sub1.test2.example.org",
+    "https://sub1.test1.example.com",
+  ],
+  notExempt: [
+    "http://test2.example.com",
+    "http://sub1.test1.example.com",
+    "http://www.example.com",
+    "https://test2.example.com",
+    "https://example.com",
+    "http://test1.example.org",
+  ],
+};
+
+// To make sure we never leave up an activated domain policy after a failed
+// test, let's make this global.
+var policy;
+
+function activateDomainPolicy(isBlock) {
+  policy = Services.scriptSecurityManager.activateDomainPolicy();
+
+  if (isBlock === undefined) {
+    return;
+  }
+
+  let set = isBlock ? policy.blocklist : policy.allowlist;
+  for (let e of TEST_POLICY.exceptions) {
+    set.add(makeURI(e));
+  }
+
+  let superSet = isBlock ? policy.superBlocklist : policy.superAllowlist;
+  for (let e of TEST_POLICY.superExceptions) {
+    superSet.add(makeURI(e));
+  }
+}
+
+function deactivateDomainPolicy() {
+  if (policy) {
+    policy.deactivate();
+    policy = null;
+  }
+}
+
+add_setup(async function () {
+  await SpecialPowers.pushPrefEnv({
+    set: [["browser.pagethumbnails.capturing_disabled", false]],
+  });
+
+  registerCleanupFunction(() => {
+    deactivateDomainPolicy();
+  });
+});
+
+add_task(async function test_domainPolicy() {
+  function test(testFunc, { activateFirst, isBlock }) {
+    if (activateFirst) {
+      activateDomainPolicy(isBlock);
+    }
+    return BrowserTestUtils.withNewTab(
+      {
+        gBrowser,
+        opening: BASE_FILE,
+        forceNewProcess: true,
+      },
+      async browser => {
+        if (!activateFirst) {
+          activateDomainPolicy(isBlock);
+        }
+        await testFunc(browser);
+        deactivateDomainPolicy();
+      }
+    );
+  }
+
+  async function testDomain(browser, domain, expectEnabled = false) {
+    function navigateFrame() {
+      let url = domain + SCRIPT_PATH;
+      return SpecialPowers.spawn(browser, [url], async src => {
+        let iframe = content.document.getElementById("root");
+        await new Promise(resolve => {
+          iframe.addEventListener("load", resolve, { once: true });
+          iframe.src = src;
+        });
+        return iframe.browsingContext;
+      });
+    }
+
+    function checkScriptEnabled(bc) {
+      return SpecialPowers.spawn(bc, [expectEnabled], enabled => {
+        content.wrappedJSObject.gFiredOnclick = false;
+        content.document.body.dispatchEvent(new content.Event("click"));
+        Assert.equal(
+          content.wrappedJSObject.gFiredOnclick,
+          enabled,
+          `Checking script-enabled for ${content.name} (${content.location})`
+        );
+      });
+    }
+
+    let browsingContext = await navigateFrame();
+    return checkScriptEnabled(browsingContext);
+  }
+
+  async function testList(browser, list, expectEnabled) {
+    // Run these sequentially to avoid navigating multiple domains at once.
+    for (let domain of list) {
+      await testDomain(browser, domain, expectEnabled);
+    }
+  }
+
+  info("1. Testing simple blocklist policy");
+
+  info("1A. Creating child process first, activating domainPolicy after");
+  await test(
+    async browser => {
+      policy.blocklist.add(Services.io.newURI("http://example.com"));
+      await testDomain(browser, "http://example.com");
+    },
+    { activateFirst: false }
+  );
+
+  info("1B. Activating domainPolicy first, creating child process after");
+  await test(
+    async browser => {
+      policy.blocklist.add(Services.io.newURI("http://example.com"));
+      await testDomain(browser, "http://example.com");
+    },
+    { activateFirst: true }
+  );
+
+  info("2. Testing Blocklist-style Domain Policy");
+
+  info("2A. Activating domainPolicy first, creating child process after");
+  await test(
+    async browser => {
+      await testList(browser, TEST_POLICY.notExempt, true);
+      await testList(browser, TEST_POLICY.exempt, false);
+    },
+    { activateFirst: true, isBlock: true }
+  );
+
+  info("2B. Creating child process first, activating domainPolicy after");
+  await test(
+    async browser => {
+      await testList(browser, TEST_POLICY.notExempt, true);
+      await testList(browser, TEST_POLICY.exempt, false);
+    },
+    { activateFirst: false, isBlock: true }
+  );
+
+  info("3. Testing Allowlist-style Domain Policy");
+  await SpecialPowers.pushPrefEnv({ set: [["javascript.enabled", false]] });
+
+  info("3A. Activating domainPolicy first, creating child process after");
+  await test(
+    async browser => {
+      await testList(browser, TEST_POLICY.notExempt, false);
+      await testList(browser, TEST_POLICY.exempt, true);
+    },
+    { activateFirst: true, isBlock: false }
+  );
+
+  info("3B. Creating child process first, activating domainPolicy after");
+  await test(
+    async browser => {
+      await testList(browser, TEST_POLICY.notExempt, false);
+      await testList(browser, TEST_POLICY.exempt, true);
+    },
+    { activateFirst: false, isBlock: false }
+  );
+
+  finish();
+});
diff --git a/dom/ipc/tests/browser_gc_schedule.js b/dom/ipc/tests/browser_gc_schedule.js
new file mode 100644
index 0000000000..53f8a70ab2
--- /dev/null
+++ b/dom/ipc/tests/browser_gc_schedule.js
@@ -0,0 +1,366 @@
+/* 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/. */
+
+"use strict";
+
+const TEST_PAGE =
+  "http://mochi.test:8888/browser/dom/ipc/tests/file_dummy.html";
+
+async function waitForGCBegin() {
+  var waitTopic = "garbage-collector-begin";
+  var observer = {};
+
+  info("Waiting for " + waitTopic);
+  // This fixes a ReferenceError for Date, it's weird.
+  ok(Date.now(), "Date.now()");
+  var when = await new Promise(resolve => {
+    observer.observe = function (subject, topic, data) {
+      resolve(Date.now());
+    };
+
+    Services.obs.addObserver(observer, waitTopic);
+  });
+
+  Services.obs.removeObserver(observer, waitTopic);
+
+  // This delay attempts to make the time stamps unique.
+  do {
+    var now = Date.now();
+  } while (when + 5 > now);
+
+  return when;
+}
+
+async function waitForGCEnd() {
+  var waitTopic = "garbage-collector-end";
+  var observer = {};
+
+  info("Waiting for " + waitTopic);
+  // This fixes a ReferenceError for Date, it's weird.
+  ok(Date.now(), "Date.now()");
+  let when = await new Promise(resolve => {
+    observer.observe = function (subject, topic, data) {
+      resolve(Date.now());
+    };
+
+    Services.obs.addObserver(observer, waitTopic);
+  });
+
+  Services.obs.removeObserver(observer, waitTopic);
+
+  do {
+    var now = Date.now();
+  } while (when + 5 > now);
+
+  return when;
+}
+
+function getProcessID() {
+  return Services.appinfo.processID;
+}
+
+async function resolveInOrder(promisesAndStates) {
+  var order = [];
+  var promises = [];
+
+  for (let p of promisesAndStates) {
+    promises.push(
+      p.promise.then(when => {
+        info(`Tab: ${p.tab} did ${p.state}`);
+        order.push({ tab: p.tab, state: p.state, when });
+      })
+    );
+  }
+
+  await Promise.all(promises);
+
+  return order;
+}
+
+// Check that the list of events returned by resolveInOrder are in a
+// sensible order.
+function checkOneAtATime(events) {
+  var cur = null;
+  var lastWhen = null;
+
+  info("Checking order of events");
+  for (const e of events) {
+    ok(e.state === "begin" || e.state === "end", "event.state is good");
+    ok(e.tab !== undefined, "event.tab exists");
+
+    if (lastWhen) {
+      // We need these in sorted order so that the other checks here make
+      // sense.
+      ok(
+        lastWhen <= e.when,
+        `Unsorted events, last: ${lastWhen}, this: ${e.when}`
+      );
+    }
+    lastWhen = e.when;
+
+    if (e.state === "begin") {
+      is(cur, null, `GC can begin on tab ${e.tab}`);
+      cur = e.tab;
+    } else {
+      is(e.tab, cur, `GC can end on tab ${e.tab}`);
+      cur = null;
+    }
+  }
+
+  is(cur, null, "No GC left running");
+}
+
+function checkAllCompleted(events, expectTabsCompleted) {
+  var tabsCompleted = events.filter(e => e.state === "end").map(e => e.tab);
+
+  for (var t of expectTabsCompleted) {
+    ok(tabsCompleted.includes(t), `Tab ${t} did a GC`);
+  }
+}
+
+async function setupTabs(num_tabs) {
+  var pids = [];
+
+  const parent_pid = getProcessID();
+  info("Parent process PID is " + parent_pid);
+
+  const tabs = await Promise.all(
+    Array(num_tabs)
+      .fill()
+      .map(_ => {
+        return BrowserTestUtils.openNewForegroundTab({
+          gBrowser,
+          opening: TEST_PAGE,
+          forceNewProcess: true,
+        });
+      })
+  );
+
+  for (const [i, tab] of Object.entries(tabs)) {
+    const tab_pid = await SpecialPowers.spawn(
+      tab.linkedBrowser,
+      [],
+      getProcessID
+    );
+
+    info(`Tab ${i} pid is ${tab_pid}`);
+    isnot(parent_pid, tab_pid, `Tab ${i} is in content process`);
+    ok(!pids.includes(tab_pid), `Tab ${i} is in a distinct process`);
+
+    pids.push(tab_pid);
+  }
+
+  return tabs;
+}
+
+function doContentRunNextCollectionTimer() {
+  content.windowUtils.pokeGC("PAGE_HIDE");
+  content.windowUtils.runNextCollectorTimer("PAGE_HIDE");
+}
+
+function startNextCollection(
+  tab,
+  tab_num,
+  waits,
+  fn = doContentRunNextCollectionTimer
+) {
+  var browser = tab.linkedBrowser;
+
+  // Finish any currently running GC.
+  SpecialPowers.spawn(browser, [], () => {
+    SpecialPowers.Cu.getJSTestingFunctions().finishgc();
+  });
+
+  var waitBegin = SpecialPowers.spawn(browser, [], waitForGCBegin);
+  var waitEnd = SpecialPowers.spawn(browser, [], waitForGCEnd);
+  waits.push({ promise: waitBegin, tab: tab_num, state: "begin" });
+  waits.push({ promise: waitEnd, tab: tab_num, state: "end" });
+
+  SpecialPowers.spawn(browser, [], fn);
+
+  // Return these so that the abort GC test can wait for the begin.
+  return { waitBegin, waitEnd };
+}
+
+add_task(async function gcOneAtATime() {
+  SpecialPowers.pushPrefEnv({
+    set: [["javascript.options.concurrent_multiprocess_gcs.max", 1]],
+  });
+
+  const num_tabs = 12;
+  var tabs = await setupTabs(num_tabs);
+
+  info("Tabs ready, Asking for GCs");
+  var waits = [];
+  for (var i = 0; i < num_tabs; i++) {
+    startNextCollection(tabs[i], i, waits);
+  }
+
+  let order = await resolveInOrder(waits);
+  // We need these in the order they actually occurred, so far that's how
+  // they're returned, but we'll sort them to be sure.
+  order.sort((e1, e2) => e1.when - e2.when);
+  checkOneAtATime(order);
+  checkAllCompleted(
+    order,
+    Array.from({ length: num_tabs }, (_, n) => n)
+  );
+
+  for (var tab of tabs) {
+    BrowserTestUtils.removeTab(tab);
+  }
+
+  SpecialPowers.popPrefEnv();
+});
+
+add_task(async function gcAbort() {
+  SpecialPowers.pushPrefEnv({
+    set: [["javascript.options.concurrent_multiprocess_gcs.max", 1]],
+  });
+
+  const num_tabs = 2;
+  var tabs = await setupTabs(num_tabs);
+
+  info("Tabs ready, Asking for GCs");
+  var waits = [];
+
+  var tab0Waits = startNextCollection(tabs[0], 0, waits, () => {
+    SpecialPowers.Cu.getJSTestingFunctions().gcslice(1);
+  });
+  await tab0Waits.waitBegin;
+
+  // Tab 0 has started a GC. Now we schedule a GC in tab one.  It must not
+  // begin yet (but we don't check that, gcOneAtATime is assumed to check
+  // this.
+  startNextCollection(tabs[1], 1, waits);
+
+  // Request that tab 0 abort, this test checks that tab 1 can now begin.
+  SpecialPowers.spawn(tabs[0].linkedBrowser, [], () => {
+    SpecialPowers.Cu.getJSTestingFunctions().abortgc();
+  });
+
+  let order = await resolveInOrder(waits);
+  // We need these in the order they actually occurred, so far that's how
+  // they're returned, but we'll sort them to be sure.
+  order.sort((e1, e2) => e1.when - e2.when);
+  checkOneAtATime(order);
+  checkAllCompleted(
+    order,
+    Array.from({ length: num_tabs }, (_, n) => n)
+  );
+
+  for (var tab of tabs) {
+    BrowserTestUtils.removeTab(tab);
+  }
+
+  SpecialPowers.popPrefEnv();
+});
+
+add_task(async function gcJSInitiatedDuring() {
+  SpecialPowers.pushPrefEnv({
+    set: [["javascript.options.concurrent_multiprocess_gcs.max", 1]],
+  });
+
+  const num_tabs = 3;
+  var tabs = await setupTabs(num_tabs);
+
+  info("Tabs ready, Asking for GCs");
+  var waits = [];
+
+  // Start a GC on tab 0 to consume the scheduler's "token".  Zeal mode 10
+  // will cause it to run in many slices.
+  var tab0Waits = startNextCollection(tabs[0], 0, waits, () => {
+    if (SpecialPowers.Cu.getJSTestingFunctions().gczeal) {
+      SpecialPowers.Cu.getJSTestingFunctions().gczeal(10);
+    }
+    SpecialPowers.Cu.getJSTestingFunctions().gcslice(1);
+  });
+  await tab0Waits.waitBegin;
+  info("GC on tab 0 has begun");
+
+  // Request a GC in tab 1, this will be blocked by the ongoing GC in tab 0.
+  var tab1Waits = startNextCollection(tabs[1], 1, waits);
+
+  // Force a GC to start in tab 1.  This won't wait for tab 0.
+  SpecialPowers.spawn(tabs[1].linkedBrowser, [], () => {
+    SpecialPowers.Cu.getJSTestingFunctions().gcslice(1);
+  });
+
+  await tab1Waits.waitBegin;
+  info("GC on tab 1 has begun");
+
+  // The GC in tab 0 should still be running.
+  var state = await SpecialPowers.spawn(tabs[0].linkedBrowser, [], () => {
+    return SpecialPowers.Cu.getJSTestingFunctions().gcstate();
+  });
+  info("State of Tab 0 GC is " + state);
+  isnot(state, "NotActive", "GC is active in tab 0");
+
+  // Let the GCs complete, verify that a GC in a 3rd tab can acquire a token.
+  startNextCollection(tabs[2], 2, waits);
+
+  let order = await resolveInOrder(waits);
+  info("All GCs finished");
+  checkAllCompleted(
+    order,
+    Array.from({ length: num_tabs }, (_, n) => n)
+  );
+
+  for (var tab of tabs) {
+    BrowserTestUtils.removeTab(tab);
+  }
+
+  SpecialPowers.popPrefEnv();
+});
+
+add_task(async function gcJSInitiatedBefore() {
+  SpecialPowers.pushPrefEnv({
+    set: [["javascript.options.concurrent_multiprocess_gcs.max", 1]],
+  });
+
+  const num_tabs = 8;
+  var tabs = await setupTabs(num_tabs);
+
+  info("Tabs ready");
+  var waits = [];
+
+  // Start a GC on tab 0 to consume the scheduler's first "token".  Zeal mode 10
+  // will cause it to run in many slices.
+  info("Force a JS-initiated GC in tab 0");
+  var tab0Waits = startNextCollection(tabs[0], 0, waits, () => {
+    if (SpecialPowers.Cu.getJSTestingFunctions().gczeal) {
+      SpecialPowers.Cu.getJSTestingFunctions().gczeal(10);
+    }
+    SpecialPowers.Cu.getJSTestingFunctions().gcslice(1);
+  });
+  await tab0Waits.waitBegin;
+
+  info("Request GCs in remaining tabs");
+  for (var i = 1; i < num_tabs; i++) {
+    startNextCollection(tabs[i], i, waits);
+  }
+
+  // The GC in tab 0 should still be running.
+  var state = await SpecialPowers.spawn(tabs[0].linkedBrowser, [], () => {
+    return SpecialPowers.Cu.getJSTestingFunctions().gcstate();
+  });
+  info("State is " + state);
+  isnot(state, "NotActive", "GC is active in tab 0");
+
+  let order = await resolveInOrder(waits);
+  // We need these in the order they actually occurred, so far that's how
+  // they're returned, but we'll sort them to be sure.
+  order.sort((e1, e2) => e1.when - e2.when);
+  checkOneAtATime(order);
+  checkAllCompleted(
+    order,
+    Array.from({ length: num_tabs }, (_, n) => n)
+  );
+
+  for (var tab of tabs) {
+    BrowserTestUtils.removeTab(tab);
+  }
+
+  SpecialPowers.popPrefEnv();
+});
diff --git a/dom/ipc/tests/browser_hide_tooltip.js b/dom/ipc/tests/browser_hide_tooltip.js
new file mode 100644
index 0000000000..6a7cd12f24
--- /dev/null
+++ b/dom/ipc/tests/browser_hide_tooltip.js
@@ -0,0 +1,38 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function test_hiding_tooltip() {
+  let page1 = "data:text/html,<html title='title'><body>page 1<body></html>";
+  let page2 = "data:text/html,<html><body>page 2</body></html>";
+
+  let tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    opening: page1,
+  });
+
+  let popup = new Promise(function (resolve) {
+    window.addEventListener("popupshown", resolve, { once: true });
+  });
+  // Fire a mousemove to trigger the tooltip.
+  EventUtils.synthesizeMouseAtCenter(gBrowser.selectedBrowser, {
+    type: "mousemove",
+  });
+  await popup;
+
+  let hiding = new Promise(function (resolve) {
+    window.addEventListener("popuphiding", resolve, { once: true });
+  });
+  let loaded = BrowserTestUtils.browserLoaded(
+    gBrowser.selectedBrowser,
+    false,
+    page2
+  );
+  BrowserTestUtils.loadURIString(gBrowser, page2);
+  await loaded;
+  await hiding;
+
+  ok(true, "Should have hidden the tooltip");
+  BrowserTestUtils.removeTab(tab);
+});
diff --git a/dom/ipc/tests/browser_layers_unloaded_while_interruptingJS.js b/dom/ipc/tests/browser_layers_unloaded_while_interruptingJS.js
new file mode 100644
index 0000000000..be176dd101
--- /dev/null
+++ b/dom/ipc/tests/browser_layers_unloaded_while_interruptingJS.js
@@ -0,0 +1,31 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function test_check_layers_cleared() {
+  let initialTab = gBrowser.selectedTab;
+  await BrowserTestUtils.withNewTab("about:blank", async browser => {
+    await ContentTask.spawn(browser, null, () => {
+      return new Promise(resolve => {
+        content.requestAnimationFrame(() => {
+          content.setTimeout(
+            "let start = performance.now(); while (performance.now() < start + 5000);"
+          );
+          resolve();
+        });
+      });
+    });
+    let layersCleared = BrowserTestUtils.waitForEvent(
+      window,
+      "MozLayerTreeCleared"
+    );
+    let startWaiting = performance.now();
+    await BrowserTestUtils.switchTab(gBrowser, initialTab);
+    await layersCleared;
+    ok(
+      performance.now() < startWaiting + 2000,
+      "MozLayerTreeCleared should be dispatched while the script is still running"
+    );
+  });
+});
diff --git a/dom/ipc/tests/browser_memory_distribution_telemetry.js b/dom/ipc/tests/browser_memory_distribution_telemetry.js
new file mode 100644
index 0000000000..793d0f122f
--- /dev/null
+++ b/dom/ipc/tests/browser_memory_distribution_telemetry.js
@@ -0,0 +1,91 @@
+"use strict";
+
+const { TelemetrySession } = ChromeUtils.importESModule(
+  "resource://gre/modules/TelemetrySession.sys.mjs"
+);
+
+const DUMMY_PAGE_DATA_URI = `data:text/html,
+    <html>
+      <head>
+        <meta charset="utf-8"/>
+        <title>Dummy</title>
+      </head>
+      <body>
+        <h1 id='header'>Just a regular everyday normal page.</h1>
+      </body>
+    </html>`;
+
+/**
+ * Tests the MEMORY_DISTRIBUTION_AMONG_CONTENT probe by opening a few tabs, then triggering
+ * the memory probes and waiting for the "gather-memory-telemetry-finished" notification.
+ */
+add_task(async function test_memory_distribution() {
+  waitForExplicitFinish();
+
+  if (SpecialPowers.getIntPref("dom.ipc.processCount", 1) < 2) {
+    ok(true, "Skip this test if e10s-multi is disabled.");
+    finish();
+    return;
+  }
+
+  Services.telemetry.canRecordExtended = true;
+
+  let histogram = Services.telemetry.getKeyedHistogramById(
+    "MEMORY_DISTRIBUTION_AMONG_CONTENT"
+  );
+  histogram.clear();
+
+  let tab1 = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    DUMMY_PAGE_DATA_URI
+  );
+  let tab2 = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    DUMMY_PAGE_DATA_URI
+  );
+  let tab3 = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    DUMMY_PAGE_DATA_URI
+  );
+
+  let finishedGathering = new Promise(resolve => {
+    let obs = function () {
+      Services.obs.removeObserver(obs, "gather-memory-telemetry-finished");
+      resolve();
+    };
+    Services.obs.addObserver(obs, "gather-memory-telemetry-finished");
+  });
+
+  TelemetrySession.getPayload();
+
+  await finishedGathering;
+
+  let s = histogram.snapshot();
+  ok("0 - 10 tabs" in s, "We should have some samples by now in this bucket.");
+  for (var key in s) {
+    is(key, "0 - 10 tabs");
+    let fewTabsSnapshot = s[key];
+    ok(
+      fewTabsSnapshot.sum > 0,
+      "Zero difference between all the content processes is unlikely, what happened?"
+    );
+    ok(
+      fewTabsSnapshot.sum < 80,
+      "20 percentage difference on average is unlikely, what happened?"
+    );
+    let values = fewTabsSnapshot.values;
+    for (let [bucket, value] of Object.entries(values)) {
+      if (bucket >= 10) {
+        // If this check fails it means that one of the content processes uses at least 20% more or 20% less than the mean.
+        is(value, 0, "All the buckets above 10 should be empty");
+      }
+    }
+  }
+
+  histogram.clear();
+
+  BrowserTestUtils.removeTab(tab3);
+  BrowserTestUtils.removeTab(tab2);
+  BrowserTestUtils.removeTab(tab1);
+  finish();
+});
diff --git a/dom/ipc/tests/browser_pbrowser_creation_failure.js b/dom/ipc/tests/browser_pbrowser_creation_failure.js
new file mode 100644
index 0000000000..fd4a45d523
--- /dev/null
+++ b/dom/ipc/tests/browser_pbrowser_creation_failure.js
@@ -0,0 +1,56 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function test_subframe_pbrowser_creation_failure() {
+  await BrowserTestUtils.withNewTab(
+    "https://example.com/document-builder.sjs?html=<iframe></iframe>",
+    async browser => {
+      let bcid = await SpecialPowers.spawn(browser, [], () => {
+        return content.document.body.querySelector("iframe").browsingContext.id;
+      });
+
+      // We currently have no known way to trigger PBrowser creation failure,
+      // other than to use this custom pref for the purpose.
+      info(`enabling failPBrowserCreation for browsingContext: ${bcid}`);
+      await SpecialPowers.pushPrefEnv({
+        set: [
+          ["browser.tabs.remote.testOnly.failPBrowserCreation.enabled", true],
+          [
+            "browser.tabs.remote.testOnly.failPBrowserCreation.browsingContext",
+            `${bcid}`,
+          ],
+        ],
+      });
+
+      let eventFiredPromise = BrowserTestUtils.waitForEvent(
+        browser,
+        "oop-browser-crashed"
+      );
+
+      info("triggering navigation which will fail pbrowser creation");
+      await SpecialPowers.spawn(browser, [], () => {
+        content.document.body.querySelector("iframe").src =
+          "https://example.org/document-builder.sjs?html=frame";
+      });
+
+      info("Waiting for oop-browser-crashed event.");
+      let event = await eventFiredPromise;
+      ok(!event.isTopFrame, "should be reporting subframe crash");
+      ok(
+        event.childID == 0,
+        "childID should be zero, as no process actually crashed"
+      );
+      is(event.browsingContextId, bcid, "bcid should match");
+
+      let { subject: windowGlobal } = await BrowserUtils.promiseObserved(
+        "window-global-created",
+        wgp => wgp.documentURI.spec.startsWith("about:framecrashed")
+      );
+      is(windowGlobal.browsingContext.id, bcid, "bcid is correct");
+
+      await SpecialPowers.popPrefEnv();
+    }
+  );
+});
diff --git a/dom/ipc/tests/browser_subframesPreferUsed.js b/dom/ipc/tests/browser_subframesPreferUsed.js
new file mode 100644
index 0000000000..f2f9ed2593
--- /dev/null
+++ b/dom/ipc/tests/browser_subframesPreferUsed.js
@@ -0,0 +1,82 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+ok(
+  Services.appinfo.fissionAutostart,
+  "this test requires fission to function!"
+);
+
+function documentURL(origin, html) {
+  let params = new URLSearchParams();
+  params.append("html", html.trim());
+  return `${origin}/document-builder.sjs?${params.toString()}`;
+}
+
+async function singleTest(preferUsed) {
+  info(`running test with preferUsed=${preferUsed}`);
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["dom.ipc.processCount.webIsolated", 4],
+      ["browser.tabs.remote.subframesPreferUsed", preferUsed],
+    ],
+  });
+
+  const TEST_URL = documentURL(
+    "https://example.com",
+    `<iframe src=${JSON.stringify(
+      documentURL("https://example.org", `<h1>iframe</h1>`)
+    )}></iframe>`
+  );
+
+  await BrowserTestUtils.withNewTab(TEST_URL, async browser1 => {
+    is(browser1.browsingContext.children.length, 1);
+    let topProc1 = browser1.browsingContext.currentWindowGlobal.domProcess;
+    let frameProc1 =
+      browser1.browsingContext.children[0].currentWindowGlobal.domProcess;
+    isnot(
+      topProc1.childID,
+      frameProc1.childID,
+      "the frame should be in a separate process"
+    );
+
+    await BrowserTestUtils.withNewTab(TEST_URL, async browser2 => {
+      is(browser2.browsingContext.children.length, 1);
+      let topProc2 = browser2.browsingContext.currentWindowGlobal.domProcess;
+      let frameProc2 =
+        browser2.browsingContext.children[0].currentWindowGlobal.domProcess;
+      isnot(
+        topProc2.childID,
+        frameProc2.childID,
+        "the frame should be in a separate process"
+      );
+
+      // Compare processes used for the two tabs.
+      isnot(
+        topProc1.childID,
+        topProc2.childID,
+        "the toplevel windows should be loaded in separate processes"
+      );
+      if (preferUsed) {
+        is(
+          frameProc1.childID,
+          frameProc2.childID,
+          "the iframes should load in the same process with subframesPreferUsed"
+        );
+      } else {
+        isnot(
+          frameProc1.childID,
+          frameProc2.childID,
+          "the iframes should load in different processes without subframesPreferUsed"
+        );
+      }
+    });
+  });
+}
+
+add_task(async function test_preferUsed() {
+  await singleTest(true);
+});
+
+add_task(async function test_noPreferUsed() {
+  await singleTest(false);
+});
diff --git a/dom/ipc/tests/browser_very_fission.js b/dom/ipc/tests/browser_very_fission.js
new file mode 100644
index 0000000000..582fe00133
--- /dev/null
+++ b/dom/ipc/tests/browser_very_fission.js
@@ -0,0 +1,38 @@
+/* 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/. */
+
+"use strict";
+
+// This test creates a large number of content processes as a
+// regression test for bug 1635451.
+
+const TEST_PAGE =
+  "http://mochi.test:8888/browser/dom/ipc/tests/file_dummy.html";
+
+const NUM_TABS = 256;
+
+add_task(async () => {
+  let promises = [];
+  for (let i = 0; i < NUM_TABS; ++i) {
+    promises.push(
+      BrowserTestUtils.openNewForegroundTab({
+        gBrowser,
+        opening: TEST_PAGE,
+        waitForLoad: true,
+        forceNewProcess: true,
+      })
+    );
+  }
+
+  let tabs = [];
+  for (const p of promises) {
+    tabs.push(await p);
+  }
+
+  ok(true, "All of the tabs loaded");
+
+  for (const t of tabs) {
+    BrowserTestUtils.removeTab(t);
+  }
+});
diff --git a/dom/ipc/tests/browser_wpi_base.js b/dom/ipc/tests/browser_wpi_base.js
new file mode 100644
index 0000000000..7a01c9a161
--- /dev/null
+++ b/dom/ipc/tests/browser_wpi_base.js
@@ -0,0 +1,305 @@
+// This test is fission-only! Make that clear before continuing, to avoid
+// confusing failures.
+ok(
+  Services.appinfo.fissionAutostart,
+  "this test requires fission to function!"
+);
+
+requestLongerTimeout(2);
+
+const WebContentIsolationStrategy = {
+  IsolateNothing: 0,
+  IsolateEverything: 1,
+  IsolateHighValue: 2,
+};
+
+const COM_ORIGIN = "https://example.com";
+const ORG_ORIGIN = "https://example.org";
+const MOZ_ORIGIN = "https://www.mozilla.org";
+
+// Helper for building document-builder.sjs URLs which have specific headers &
+// HTML content.
+function documentURL(origin, headers, html) {
+  let params = new URLSearchParams();
+  params.append("html", html.trim());
+  for (const [key, value] of Object.entries(headers)) {
+    params.append("headers", `${key}:${value}`);
+  }
+  return `${origin}/document-builder.sjs?${params.toString()}`;
+}
+
+async function testTreeRemoteTypes(name, testpage) {
+  // Use document-builder.sjs to build up the expected document tree.
+  function buildURL(path, page) {
+    let html = `<h1>${path}</h1>`;
+    for (let i = 0; i < page.children.length; ++i) {
+      const inner = buildURL(`${path}[${i}]`, page.children[i]);
+      html += `<iframe src=${JSON.stringify(inner)}></iframe>`;
+    }
+    return documentURL(page.origin, page.headers, html);
+  }
+  const url = buildURL(name, testpage);
+
+  // Load the tab and confirm that properties of the loaded documents match
+  // expectation.
+  await BrowserTestUtils.withNewTab(url, async browser => {
+    let stack = [
+      {
+        path: name,
+        bc: browser.browsingContext,
+        ...testpage,
+      },
+    ];
+
+    while (stack.length) {
+      const { path, bc, remoteType, children, origin } = stack.pop();
+      is(
+        Services.scriptSecurityManager.createContentPrincipal(
+          bc.currentWindowGlobal.documentURI,
+          {}
+        ).originNoSuffix,
+        origin,
+        `Frame ${path} has expected originNoSuffix`
+      );
+      is(
+        bc.currentWindowGlobal.domProcess.remoteType,
+        remoteType,
+        `Frame ${path} has expected remote type`
+      );
+      is(
+        bc.children.length,
+        children.length,
+        `Frame ${path} has the expected number of children`
+      );
+      for (let i = 0; i < bc.children.length; ++i) {
+        stack.push({
+          path: `${path}[${i}]`,
+          bc: bc.children[i],
+          ...children[i],
+        });
+      }
+    }
+  });
+}
+
+function mkTestPage({
+  comRemoteType,
+  orgRemoteType,
+  mozRemoteType,
+  topOrigin,
+  topHeaders = {},
+  frameHeaders = {},
+}) {
+  const topRemoteType = {
+    [COM_ORIGIN]: comRemoteType,
+    [ORG_ORIGIN]: orgRemoteType,
+    [MOZ_ORIGIN]: mozRemoteType,
+  }[topOrigin];
+
+  const innerChildren = [
+    {
+      origin: COM_ORIGIN,
+      headers: frameHeaders,
+      remoteType: comRemoteType,
+      children: [],
+    },
+    {
+      origin: ORG_ORIGIN,
+      headers: frameHeaders,
+      remoteType: orgRemoteType,
+      children: [],
+    },
+    {
+      origin: MOZ_ORIGIN,
+      headers: frameHeaders,
+      remoteType: mozRemoteType,
+      children: [],
+    },
+  ];
+
+  return {
+    origin: topOrigin,
+    headers: topHeaders,
+    remoteType: topRemoteType,
+    children: [
+      {
+        origin: COM_ORIGIN,
+        headers: frameHeaders,
+        remoteType: comRemoteType,
+        children: [...innerChildren],
+      },
+      {
+        origin: ORG_ORIGIN,
+        headers: frameHeaders,
+        remoteType: orgRemoteType,
+        children: [...innerChildren],
+      },
+      {
+        origin: MOZ_ORIGIN,
+        headers: frameHeaders,
+        remoteType: mozRemoteType,
+        children: [...innerChildren],
+      },
+    ],
+  };
+}
+
+const heuristics = [
+  {
+    name: "coop",
+    setup_com: async expected => {
+      // Set the COOP header, and load
+      await testTreeRemoteTypes(
+        "com_set_coop",
+        mkTestPage({
+          topOrigin: COM_ORIGIN,
+          topHeaders: { "Cross-Origin-Opener-Policy": "same-origin" },
+          comRemoteType: expected.com_high,
+          orgRemoteType: expected.org_normal,
+          mozRemoteType: expected.moz_normal,
+        })
+      );
+    },
+    run_extra_test: async expected => {
+      // Load with both the COOP and COEP headers set.
+      await testTreeRemoteTypes(
+        "com_coop_coep",
+        mkTestPage({
+          topOrigin: COM_ORIGIN,
+          topHeaders: {
+            "Cross-Origin-Opener-Policy": "same-origin",
+            "Cross-Origin-Embedder-Policy": "require-corp",
+          },
+          frameHeaders: {
+            "Cross-Origin-Embedder-Policy": "require-corp",
+            "Cross-Origin-Resource-Policy": "cross-origin",
+          },
+          comRemoteType: expected.com_coop_coep,
+          orgRemoteType: expected.org_coop_coep,
+          mozRemoteType: expected.moz_coop_coep,
+        })
+      );
+    },
+  },
+  {
+    name: "hasSavedLogin",
+    setup_com: async expected => {
+      // add .com to the password manager
+      let LoginInfo = new Components.Constructor(
+        "@mozilla.org/login-manager/loginInfo;1",
+        Ci.nsILoginInfo,
+        "init"
+      );
+      await Services.logins.addLoginAsync(
+        new LoginInfo(COM_ORIGIN, "", null, "username", "password", "", "")
+      );
+
+      // Init login detection service to trigger fetching logins
+      let loginDetection = Cc[
+        "@mozilla.org/login-detection-service;1"
+      ].createInstance(Ci.nsILoginDetectionService);
+      loginDetection.init();
+
+      await TestUtils.waitForCondition(() => {
+        let x = loginDetection.isLoginsLoaded();
+        return x;
+      }, "waiting for loading logins from the password manager");
+    },
+  },
+  {
+    name: "isLoggedIn",
+    setup_com: async expected => {
+      let p = new Promise(resolve => {
+        Services.obs.addObserver(function obs() {
+          Services.obs.removeObserver(
+            obs,
+            "passwordmgr-form-submission-detected"
+          );
+          resolve();
+        }, "passwordmgr-form-submission-detected");
+      });
+
+      const TEST_URL = documentURL(
+        COM_ORIGIN,
+        {},
+        `<form>
+          <input value="username">
+          <input type="password" value="password">
+          <input type="submit">
+        </form>`
+      );
+
+      // submit the form to simulate the login behavior
+      await BrowserTestUtils.withNewTab(TEST_URL, async browser => {
+        await SpecialPowers.spawn(browser, [], async () => {
+          content.document.querySelector("form").submit();
+        });
+      });
+      await p;
+    },
+  },
+];
+
+async function do_tests(expected) {
+  for (let heuristic of heuristics) {
+    info(`Starting ${heuristic.name} test`);
+    // Clear all site-specific data, as we don't want to have any high-value site
+    // permissions from any previous iterations.
+    await new Promise(resolve =>
+      Services.clearData.deleteData(Ci.nsIClearDataService.CLEAR_ALL, resolve)
+    );
+
+    // Loads for basic URLs with no special headers set.
+    await testTreeRemoteTypes(
+      "basic_com",
+      mkTestPage({
+        topOrigin: COM_ORIGIN,
+        comRemoteType: expected.com_normal,
+        orgRemoteType: expected.org_normal,
+        mozRemoteType: expected.moz_normal,
+      })
+    );
+
+    await testTreeRemoteTypes(
+      "basic_org",
+      mkTestPage({
+        topOrigin: ORG_ORIGIN,
+        comRemoteType: expected.com_normal,
+        orgRemoteType: expected.org_normal,
+        mozRemoteType: expected.moz_normal,
+      })
+    );
+
+    info(`Setting up ${heuristic.name} test`);
+    await heuristic.setup_com(expected);
+
+    // Load again after the heuristic is triggered
+    info(`Running ${heuristic.name} tests after setup`);
+    await testTreeRemoteTypes(
+      `com_after_${heuristic.name}`,
+      mkTestPage({
+        topOrigin: COM_ORIGIN,
+        comRemoteType: expected.com_high,
+        orgRemoteType: expected.org_normal,
+        mozRemoteType: expected.moz_normal,
+      })
+    );
+
+    // Load again with a .org toplevel
+    await testTreeRemoteTypes(
+      `org_after_${heuristic.name}`,
+      mkTestPage({
+        topOrigin: ORG_ORIGIN,
+        comRemoteType: expected.com_high,
+        orgRemoteType: expected.org_normal,
+        mozRemoteType: expected.moz_normal,
+      })
+    );
+
+    // Run heuristic dependent tests
+    if (heuristic.run_extra_test) {
+      info(`Running extra tests for ${heuristic.name}`);
+      await heuristic.run_extra_test(expected);
+    }
+  }
+}
diff --git a/dom/ipc/tests/browser_wpi_isolate_everything.js b/dom/ipc/tests/browser_wpi_isolate_everything.js
new file mode 100644
index 0000000000..e902fec9d0
--- /dev/null
+++ b/dom/ipc/tests/browser_wpi_isolate_everything.js
@@ -0,0 +1,27 @@
+// Import this in order to use `do_tests()`.
+Services.scriptloader.loadSubScript(
+  "chrome://mochitests/content/browser/dom/ipc/tests/browser_wpi_base.js",
+  this
+);
+
+add_task(async function test_isolate_everything() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["browser.tabs.remote.separatedMozillaDomains", "mozilla.org"],
+      [
+        "fission.webContentIsolationStrategy",
+        WebContentIsolationStrategy.IsolateEverything,
+      ],
+    ],
+  });
+
+  await do_tests({
+    com_normal: "webIsolated=https://example.com",
+    org_normal: "webIsolated=https://example.org",
+    moz_normal: "privilegedmozilla",
+    com_high: "webIsolated=https://example.com",
+    com_coop_coep: "webCOOP+COEP=https://example.com",
+    org_coop_coep: "webCOOP+COEP=https://example.org",
+    moz_coop_coep: "privilegedmozilla",
+  });
+});
diff --git a/dom/ipc/tests/browser_wpi_isolate_high_value.js b/dom/ipc/tests/browser_wpi_isolate_high_value.js
new file mode 100644
index 0000000000..bf6b99d5f5
--- /dev/null
+++ b/dom/ipc/tests/browser_wpi_isolate_high_value.js
@@ -0,0 +1,27 @@
+// Import this in order to use `do_tests()`.
+Services.scriptloader.loadSubScript(
+  "chrome://mochitests/content/browser/dom/ipc/tests/browser_wpi_base.js",
+  this
+);
+
+add_task(async function test_isolate_high_value() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["browser.tabs.remote.separatedMozillaDomains", "mozilla.org"],
+      [
+        "fission.webContentIsolationStrategy",
+        WebContentIsolationStrategy.IsolateHighValue,
+      ],
+    ],
+  });
+
+  await do_tests({
+    com_normal: "web",
+    org_normal: "web",
+    moz_normal: "privilegedmozilla",
+    com_high: "webIsolated=https://example.com",
+    com_coop_coep: "webCOOP+COEP=https://example.com",
+    org_coop_coep: "webCOOP+COEP=https://example.org",
+    moz_coop_coep: "privilegedmozilla",
+  });
+});
diff --git a/dom/ipc/tests/browser_wpi_isolate_nothing.js b/dom/ipc/tests/browser_wpi_isolate_nothing.js
new file mode 100644
index 0000000000..afd5e51640
--- /dev/null
+++ b/dom/ipc/tests/browser_wpi_isolate_nothing.js
@@ -0,0 +1,27 @@
+// Import this in order to use `do_tests()`.
+Services.scriptloader.loadSubScript(
+  "chrome://mochitests/content/browser/dom/ipc/tests/browser_wpi_base.js",
+  this
+);
+
+add_task(async function test_isolate_nothing() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["browser.tabs.remote.separatedMozillaDomains", "mozilla.org"],
+      [
+        "fission.webContentIsolationStrategy",
+        WebContentIsolationStrategy.IsolateNothing,
+      ],
+    ],
+  });
+
+  await do_tests({
+    com_normal: "web",
+    org_normal: "web",
+    moz_normal: "privilegedmozilla",
+    com_high: "web",
+    com_coop_coep: "webCOOP+COEP=https://example.com",
+    org_coop_coep: "webCOOP+COEP=https://example.org",
+    moz_coop_coep: "privilegedmozilla",
+  });
+});
diff --git a/dom/ipc/tests/chrome.ini b/dom/ipc/tests/chrome.ini
new file mode 100644
index 0000000000..1f0bc29954
--- /dev/null
+++ b/dom/ipc/tests/chrome.ini
@@ -0,0 +1,7 @@
+[DEFAULT]
+skip-if = os == 'android'
+support-files =
+  process_error.xhtml
+
+[test_process_error.xhtml]
+skip-if = !crashreporter
diff --git a/dom/ipc/tests/file_broadcast_currenturi_onload.html b/dom/ipc/tests/file_broadcast_currenturi_onload.html
new file mode 100644
index 0000000000..b92c46c944
--- /dev/null
+++ b/dom/ipc/tests/file_broadcast_currenturi_onload.html
@@ -0,0 +1,66 @@
+
+<!doctype html>
+<body>
+<script>
+
+const url = new URL(location.href);
+
+// Create a popup to broadcast the load's completion to the test document.
+//
+// NOTE: We're using a popup to ensure that the new document has the same origin
+// (http://mochi.test:8888/) as the original test document, so that we can use a
+// BroadcastChannel to communicate with the test page. We can't use an iframe as
+// the mixed content blocker will prevent embedding this URL in https://
+// documents.
+function sendPayload(payload) {
+  let broadcastURL = new URL(url.pathname, "http://mochi.test:8888/");
+  broadcastURL.search = "?payload=" + encodeURIComponent(JSON.stringify(payload));
+  window.open(broadcastURL.href);
+}
+
+async function getURIs() {
+  // Run the test and fetch the relevant information.
+  const browsingContext = SpecialPowers.wrap(window).browsingContext;
+  let [docURI, curURI] = await SpecialPowers.spawnChrome(
+    [browsingContext.id], async id => {
+      let bc = BrowsingContext.get(id);
+      return [
+        bc.currentWindowGlobal.documentURI.spec,
+        bc.currentURI.spec,
+      ];
+    }
+  );
+  return { location: location.href, docURI, curURI };
+}
+
+addEventListener("load", async e => {
+  // If a payload parameter was included, just send the message.
+  const payloadStr = url.searchParams.get("payload");
+  if (payloadStr) {
+    const chan = new BroadcastChannel("test_broadcast_onload");
+    chan.postMessage(JSON.parse(payloadStr));
+    window.close();
+    return;
+  }
+
+  // collect the initial set of URIs
+  const result1 = await getURIs();
+
+  const pushstateURL = new URL("after_pushstate", url.href);
+  history.pushState({}, "After PushState!", pushstateURL.href);
+  await new Promise(resolve => setTimeout(resolve, 0));
+
+  // Collect the set of URIs after pushstate
+  const result2 = await getURIs();
+
+  window.location.hash = "#after_hashchange";
+  await new Promise(resolve => setTimeout(resolve, 0));
+
+  // Collect the set of URIs after a hash change
+  const result3 = await getURIs();
+
+  sendPayload([result1, result2, result3]);
+  window.close();
+});
+</script>
+</body>
diff --git a/dom/ipc/tests/file_cancel_content_js.html b/dom/ipc/tests/file_cancel_content_js.html
new file mode 100644
index 0000000000..d2caf03c6a
--- /dev/null
+++ b/dom/ipc/tests/file_cancel_content_js.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Wait for it...</title>
+  </head>
+  <body>
+  Try to go to another page.
+  <script>
+    addEventListener("StartLongLoop", function() {
+      setTimeout(() => {
+        const start = Date.now();
+        while (Date.now() - start < 7500);
+        window.dispatchEvent(new CustomEvent("LongLoopEnded"));
+      });
+    });
+  </script>
+  </body>
+</html>
diff --git a/dom/ipc/tests/file_cross_frame.html b/dom/ipc/tests/file_cross_frame.html
new file mode 100644
index 0000000000..b52d920dd0
--- /dev/null
+++ b/dom/ipc/tests/file_cross_frame.html
@@ -0,0 +1,12 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Different-origin iframe</title>
+</head>
+<body>
+<iframe id="testIFrame" src="https://example.org/browser/dom/ipc/tests/file_dummy.html"></iframe>
+<i>I am a web page</i>
+</div>
+</body>
+</html>
diff --git a/dom/ipc/tests/file_disableScript.html b/dom/ipc/tests/file_disableScript.html
new file mode 100644
index 0000000000..f4888cd586
--- /dev/null
+++ b/dom/ipc/tests/file_disableScript.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+<script>
+var gFiredOnload = false;
+var gFiredOnclick = false;
+</script>
+</head>
+<body onload="gFiredOnload = true;" onclick="gFiredOnclick = true;">
+</body>
+</html>
diff --git a/dom/ipc/tests/file_domainPolicy_base.html b/dom/ipc/tests/file_domainPolicy_base.html
new file mode 100644
index 0000000000..6e3ec7aec4
--- /dev/null
+++ b/dom/ipc/tests/file_domainPolicy_base.html
@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+<html>
+<head>
+</head>
+<body>
+<iframe id="root" name="root"/>
+</body>
+</html>
diff --git a/dom/ipc/tests/file_dummy.html b/dom/ipc/tests/file_dummy.html
new file mode 100644
index 0000000000..c8701dae7d
--- /dev/null
+++ b/dom/ipc/tests/file_dummy.html
@@ -0,0 +1,7 @@
+<!doctype html>
+<html>
+<head><meta charset="utf-8"></head>
+<body>
+  <h1>This is a dummy file</h1>
+</body>
+</html>
diff --git a/dom/ipc/tests/file_endless_js.html b/dom/ipc/tests/file_endless_js.html
new file mode 100644
index 0000000000..926fb1d8ab
--- /dev/null
+++ b/dom/ipc/tests/file_endless_js.html
@@ -0,0 +1,17 @@
+<!doctype html>
+<html>
+<head><meta charset="utf-8"></head>
+<script>
+  function hang(m) {
+    let i = 1;
+    while (i > 0) {
+      i = Date.now();
+    }
+  }
+
+  onmessage = hang;
+</script>
+<body>
+  <h1>This is an endless JS loop</h1>
+</body>
+</html>
diff --git a/dom/ipc/tests/mochitest.ini b/dom/ipc/tests/mochitest.ini
new file mode 100644
index 0000000000..d77532a7fd
--- /dev/null
+++ b/dom/ipc/tests/mochitest.ini
@@ -0,0 +1,23 @@
+[DEFAULT]
+
+[test_temporaryfile_stream.html]
+skip-if =
+  toolkit == 'android'
+  (os == "win" && processor == "aarch64") # Bug 1525959, aarch64 due to 1531150
+support-files =
+  blob_verify.sjs
+  !/dom/canvas/test/captureStream_common.js
+[test_Preallocated.html]
+skip-if =
+  toolkit == 'android'
+  tsan # Bug 1525959. tsan: Bug 1683730
+[test_window_open_discarded_bc.html]
+skip-if = toolkit == 'android'
+[test_bcg_processes.html]
+skip-if =
+  http3
+[test_browsingcontext_currenturi.html]
+support-files =
+  file_broadcast_currenturi_onload.html
+skip-if =
+  http3
diff --git a/dom/ipc/tests/process_error.xhtml b/dom/ipc/tests/process_error.xhtml
new file mode 100644
index 0000000000..7760b3e516
--- /dev/null
+++ b/dom/ipc/tests/process_error.xhtml
@@ -0,0 +1,58 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+
+<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+	orient="vertical">
+
+  <browser id="thebrowser" type="content" remote="true" />
+  <script type="application/javascript"><![CDATA[
+    const {BrowserTestUtils} = ChromeUtils.import("resource://testing-common/BrowserTestUtils.jsm");
+
+    const ok = window.arguments[0].ok;
+    const is = window.arguments[0].is;
+    const done = window.arguments[0].done;
+    const SimpleTest = window.arguments[0].SimpleTest;
+
+    // Parse test options.
+    const url = new URL(document.location);
+    const crashType = url.searchParams.get("crashType");
+
+    // Allow the browser to get connected before using the messageManager to cause
+    // a crash:
+    addEventListener("DOMContentLoaded", () => {
+      let browser = document.getElementById('thebrowser');
+
+      let observerPromise = new Promise(resolve => {
+        let crashObserver = (subject, topic, data) => {
+          is(topic, 'ipc:content-shutdown', 'Received correct observer topic.');
+          ok(subject instanceof Ci.nsIPropertyBag2,
+             'Subject implements nsIPropertyBag2.');
+
+          var dumpID;
+          if ('nsICrashReporter' in Ci) {
+            dumpID = subject.getPropertyAsAString('dumpID');
+            ok(dumpID, "dumpID is present and not an empty string");
+          }
+
+          Services.obs.removeObserver(crashObserver, 'ipc:content-shutdown');
+          resolve();
+        }
+
+        Services.obs.addObserver(crashObserver, 'ipc:content-shutdown');
+      });
+
+      let browsingContextId = browser.frameLoader.browsingContext.id;
+
+      let eventFiredPromise = BrowserTestUtils.waitForEvent(browser, "oop-browser-crashed");
+      let eventPromise = eventFiredPromise.then(event => {
+        is(event.browsingContextId, browsingContextId,
+           "Expected the right browsing context id on the oop-browser-crashed event.");
+      })
+
+      BrowserTestUtils.crashFrame(browser, true, false, /* Default browsing context */ null, { crashType });
+
+      Promise.all([observerPromise, eventPromise]).then(done);
+    });
+  ]]></script>
+
+</window>
diff --git a/dom/ipc/tests/test_Preallocated.html b/dom/ipc/tests/test_Preallocated.html
new file mode 100644
index 0000000000..fb719995f5
--- /dev/null
+++ b/dom/ipc/tests/test_Preallocated.html
@@ -0,0 +1,51 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+Test that the preallocated process starts up.
+-->
+<head>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="../browserElementTestHelpers.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+
+<script type="application/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+function expectProcessCreated() {
+  /* eslint-env mozilla/chrome-script */
+  return new Promise(resolve => {
+    function parentExpectProcessCreated() {
+      let topic = "ipc:content-initializing";
+      let obs = { observe() {
+        Services.obs.removeObserver(obs, topic);
+        sendAsyncMessage("process-created");
+      }};
+      Services.obs.addObserver(obs, topic);
+    }
+
+    let helper = SpecialPowers.loadChromeScript(parentExpectProcessCreated);
+    SimpleTest.registerCleanupFunction(function() { helper.destroy(); });
+    helper.addMessageListener("process-created", resolve);
+  });
+}
+
+expectProcessCreated().then(() => {
+  ok(true, "Process creation detected.");
+  SimpleTest.finish();
+});
+
+// Kill existing preallocated process.
+SpecialPowers.pushPrefEnv({"set": [["dom.ipc.processPrelaunch.enabled", false]]}).then(() => {
+  // Make sure we have the capacity to launch preallocated process.
+  SpecialPowers.pushPrefEnv({"set": [["dom.ipc.processCount", 100]]}).then(() => {
+    // Enable preallocated process and run the test.
+    SpecialPowers.pushPrefEnv({"set": [["dom.ipc.processPrelaunch.enabled", true]]});
+  });
+});
+</script>
+</body>
+</html>
diff --git a/dom/ipc/tests/test_bcg_processes.html b/dom/ipc/tests/test_bcg_processes.html
new file mode 100644
index 0000000000..8f68aa4a89
--- /dev/null
+++ b/dom/ipc/tests/test_bcg_processes.html
@@ -0,0 +1,45 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+
+<script type="application/javascript">
+"use strict";
+
+add_task(async function main_test() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["dom.ipc.processCount.webIsolated", 10]],
+  });
+
+  let frame1 = document.createElement("iframe");
+  frame1.src = "http://example.com";
+  document.body.appendChild(frame1);
+  await new Promise(resolve => {
+    frame1.addEventListener("load", resolve, { once: true })
+  });
+  info("frame 1 loaded");
+
+  let frame2 = document.createElement("iframe");
+  frame2.src = "http://example.com";
+  document.body.appendChild(frame2);
+  await new Promise(resolve => {
+    frame2.addEventListener("load", resolve, { once: true })
+  });
+  info("frame 2 loaded");
+
+  let id1 = await SpecialPowers.spawn(frame1, [], () => {
+    return ChromeUtils.domProcessChild.childId;
+  });
+  let id2 = await SpecialPowers.spawn(frame2, [], () => {
+    return ChromeUtils.domProcessChild.childId;
+  });
+
+  is(id1, id2, "childID for example.com subframes should match");
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/ipc/tests/test_blob_sliced_from_child_process.js b/dom/ipc/tests/test_blob_sliced_from_child_process.js
new file mode 100644
index 0000000000..8a7a56088d
--- /dev/null
+++ b/dom/ipc/tests/test_blob_sliced_from_child_process.js
@@ -0,0 +1,140 @@
+"use strict";
+
+const { XPCShellContentUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/XPCShellContentUtils.sys.mjs"
+);
+
+XPCShellContentUtils.init(this);
+
+function childFrameScript() {
+  /* eslint-env mozilla/frame-script */
+  "use strict";
+
+  const messageName = "test:blob-slice-test";
+  const blobData = ["So", " ", "many", " ", "blobs!"];
+  const blobType = "text/plain";
+
+  let blob = new Blob(blobData, { type: blobType });
+
+  let firstSliceStart = blobData[0].length + blobData[1].length;
+  let firstSliceEnd = firstSliceStart + blobData[2].length;
+
+  let slice = blob.slice(firstSliceStart, firstSliceEnd, blobType);
+
+  let secondSliceStart = blobData[2].indexOf("a");
+  let secondSliceEnd = secondSliceStart + 2;
+
+  slice = slice.slice(secondSliceStart, secondSliceEnd, blobType);
+
+  sendAsyncMessage(messageName, { blob });
+  sendAsyncMessage(messageName, { slice });
+}
+
+add_task(async function test() {
+  let page = await XPCShellContentUtils.loadContentPage(
+    "data:text/html,<!DOCTYPE HTML><html><body></body></html>",
+    {
+      remote: true,
+    }
+  );
+
+  page.loadFrameScript(childFrameScript);
+
+  const messageName = "test:blob-slice-test";
+  const blobData = ["So", " ", "many", " ", "blobs!"];
+  const blobText = blobData.join("");
+  const blobType = "text/plain";
+
+  const sliceText = "an";
+
+  let receivedBlob = false;
+  let receivedSlice = false;
+
+  let resolveBlob, resolveSlice;
+  let blobPromise = new Promise(resolve => {
+    resolveBlob = resolve;
+  });
+  let slicePromise = new Promise(resolve => {
+    resolveSlice = resolve;
+  });
+
+  let mm = page.browser.messageManager;
+  mm.addMessageListener(messageName, function (message) {
+    if ("blob" in message.data) {
+      equal(receivedBlob, false, "Have not yet received Blob");
+      equal(receivedSlice, false, "Have not yet received Slice");
+
+      receivedBlob = true;
+
+      let blob = message.data.blob;
+
+      ok(Blob.isInstance(blob), "Received a Blob");
+      equal(blob.size, blobText.length, "Blob has correct size");
+      equal(blob.type, blobType, "Blob has correct type");
+
+      let slice = blob.slice(
+        blobText.length - blobData[blobData.length - 1].length,
+        blob.size,
+        blobType
+      );
+
+      ok(Blob.isInstance(slice), "Slice returned a Blob");
+      equal(
+        slice.size,
+        blobData[blobData.length - 1].length,
+        "Slice has correct size"
+      );
+      equal(slice.type, blobType, "Slice has correct type");
+
+      let reader = new FileReader();
+      reader.onload = function () {
+        equal(
+          reader.result,
+          blobData[blobData.length - 1],
+          "Slice has correct data"
+        );
+
+        resolveBlob();
+      };
+      reader.readAsText(slice);
+    } else if ("slice" in message.data) {
+      equal(receivedBlob, true, "Already received Blob");
+      equal(receivedSlice, false, "Have not yet received Slice");
+
+      receivedSlice = true;
+
+      let slice = message.data.slice;
+
+      ok(Blob.isInstance(slice), "Received a Blob for slice");
+      equal(slice.size, sliceText.length, "Slice has correct size");
+      equal(slice.type, blobType, "Slice has correct type");
+
+      let reader = new FileReader();
+      reader.onload = function () {
+        equal(reader.result, sliceText, "Slice has correct data");
+
+        let slice2 = slice.slice(1, 2, blobType);
+
+        ok(Blob.isInstance(slice2), "Slice returned a Blob");
+        equal(slice2.size, 1, "Slice has correct size");
+        equal(slice2.type, blobType, "Slice has correct type");
+
+        let reader2 = new FileReader();
+        reader2.onload = function () {
+          equal(reader2.result, sliceText[1], "Slice has correct data");
+
+          resolveSlice();
+        };
+        reader2.readAsText(slice2);
+      };
+      reader.readAsText(slice);
+    } else {
+      ok(false, "Received a bad message: " + JSON.stringify(message.data));
+    }
+  });
+
+  await blobPromise;
+  await slicePromise;
+
+  await page.close();
+});
diff --git a/dom/ipc/tests/test_blob_sliced_from_parent_process.js b/dom/ipc/tests/test_blob_sliced_from_parent_process.js
new file mode 100644
index 0000000000..e196a6986c
--- /dev/null
+++ b/dom/ipc/tests/test_blob_sliced_from_parent_process.js
@@ -0,0 +1,167 @@
+"use strict";
+
+const { XPCShellContentUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/XPCShellContentUtils.sys.mjs"
+);
+
+XPCShellContentUtils.init(this);
+
+function childFrameScript() {
+  /* eslint-env mozilla/frame-script */
+  const messageName = "test:blob-slice-test";
+  const blobData = ["So", " ", "many", " ", "blobs!"];
+  const blobText = blobData.join("");
+  const blobType = "text/plain";
+
+  const sliceText = "an";
+
+  function info(msg) {
+    sendAsyncMessage(messageName, { op: "info", msg });
+  }
+
+  function ok(condition, name, diag) {
+    sendAsyncMessage(messageName, { op: "ok", condition, name, diag });
+  }
+
+  function is(a, b, name) {
+    let pass = a == b;
+    let diag = pass ? "" : "got " + a + ", expected " + b;
+    ok(pass, name, diag);
+  }
+
+  function finish(result) {
+    sendAsyncMessage(messageName, { op: "done", result });
+  }
+
+  function grabAndContinue(arg) {
+    testGenerator.next(arg);
+  }
+
+  function* testSteps() {
+    addMessageListener(messageName, grabAndContinue);
+    let message = yield undefined;
+
+    let blob = message.data;
+
+    ok(Blob.isInstance(blob), "Received a Blob");
+    is(blob.size, blobText.length, "Blob has correct length");
+    is(blob.type, blobType, "Blob has correct type");
+
+    info("Reading blob");
+
+    let reader = new FileReader();
+    reader.addEventListener("load", grabAndContinue);
+    reader.readAsText(blob);
+
+    yield undefined;
+
+    is(reader.result, blobText, "Blob has correct data");
+
+    let firstSliceStart = blobData[0].length + blobData[1].length;
+    let firstSliceEnd = firstSliceStart + blobData[2].length;
+
+    let slice = blob.slice(firstSliceStart, firstSliceEnd, blobType);
+
+    ok(Blob.isInstance(slice), "Slice returned a Blob");
+    is(slice.size, blobData[2].length, "Slice has correct length");
+    is(slice.type, blobType, "Slice has correct type");
+
+    info("Reading slice");
+
+    reader = new FileReader();
+    reader.addEventListener("load", grabAndContinue);
+    reader.readAsText(slice);
+
+    yield undefined;
+
+    is(reader.result, blobData[2], "Slice has correct data");
+
+    let secondSliceStart = blobData[2].indexOf("a");
+    let secondSliceEnd = secondSliceStart + sliceText.length;
+
+    slice = slice.slice(secondSliceStart, secondSliceEnd, blobType);
+
+    ok(Blob.isInstance(slice), "Second slice returned a Blob");
+    is(slice.size, sliceText.length, "Second slice has correct length");
+    is(slice.type, blobType, "Second slice has correct type");
+
+    info("Sending second slice");
+    finish(slice);
+  }
+
+  let testGenerator = testSteps();
+  testGenerator.next();
+}
+
+add_task(async function test() {
+  let page = await XPCShellContentUtils.loadContentPage(
+    "data:text/html,<!DOCTYPE HTML><html><body></body></html>",
+    {
+      remote: true,
+    }
+  );
+
+  page.loadFrameScript(childFrameScript);
+
+  const messageName = "test:blob-slice-test";
+  const blobData = ["So", " ", "many", " ", "blobs!"];
+  const blobType = "text/plain";
+
+  const sliceText = "an";
+
+  await new Promise(resolve => {
+    function grabAndContinue(arg) {
+      testGenerator.next(arg);
+    }
+
+    function* testSteps() {
+      let slice = yield undefined;
+
+      ok(Blob.isInstance(slice), "Received a Blob");
+      equal(slice.size, sliceText.length, "Slice has correct size");
+      equal(slice.type, blobType, "Slice has correct type");
+
+      let reader = new FileReader();
+      reader.onload = grabAndContinue;
+      reader.readAsText(slice);
+      yield undefined;
+
+      equal(reader.result, sliceText, "Slice has correct data");
+      resolve();
+    }
+
+    let testGenerator = testSteps();
+    testGenerator.next();
+
+    let mm = page.browser.messageManager;
+    mm.addMessageListener(messageName, function (message) {
+      let data = message.data;
+      switch (data.op) {
+        case "info": {
+          info(data.msg);
+          break;
+        }
+
+        case "ok": {
+          ok(data.condition, data.name + " - " + data.diag);
+          break;
+        }
+
+        case "done": {
+          testGenerator.next(data.result);
+          break;
+        }
+
+        default: {
+          ok(false, "Unknown op: " + data.op);
+          resolve();
+        }
+      }
+    });
+
+    let blob = new Blob(blobData, { type: blobType });
+    mm.sendAsyncMessage(messageName, blob);
+  });
+
+  await page.close();
+});
diff --git a/dom/ipc/tests/test_browsingcontext_currenturi.html b/dom/ipc/tests/test_browsingcontext_currenturi.html
new file mode 100644
index 0000000000..c7faafdb0c
--- /dev/null
+++ b/dom/ipc/tests/test_browsingcontext_currenturi.html
@@ -0,0 +1,131 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+
+<iframe id="tls1frame" src="https://tls1.example.com/"></iframe>
+
+<script>
+"use strict";
+
+add_task(async function test_frame() {
+  let win = SpecialPowers.wrap(window);
+  info(`id=${win.browsingContext.id}`);
+  let [docURI, curURI] = await SpecialPowers.spawnChrome([win.browsingContext.id], async id => {
+    let bc = BrowsingContext.get(id);
+    return [
+      bc.currentWindowGlobal.documentURI.spec,
+      bc.currentURI.spec,
+    ];
+  });
+  info(`docURI=${docURI}, curURI=${curURI}`);
+  is(window.location.href, curURI, "curURI has the expected value");
+  is(window.location.href, docURI, "documentURI has the expected value");
+});
+
+add_task(async function test_tls1_frame() {
+  let expframe = SpecialPowers.wrap(document.getElementById("tls1frame"));
+  let [docURI, curURI] = await SpecialPowers.spawnChrome(
+    [expframe.browsingContext.id], async id => {
+      const { TestUtils } = ChromeUtils.import(
+        "resource://testing-common/TestUtils.jsm"
+      );
+
+      let bc = BrowsingContext.get(id);
+
+      // awkwardly wait for the current window global to update to the error page.
+      // would be nice to do just about anything else here...
+      await TestUtils.waitForCondition(
+        () =>
+          bc.currentURI && bc.currentURI.spec != "about:blank" &&
+          bc.currentWindowGlobal && bc.currentWindowGlobal.documentURI.spec != "about:blank",
+        "waiting for current window global to be non-initial");
+
+      info(`currentWindowGlobal has updated in the parent!`);
+      return [
+        bc.currentWindowGlobal.documentURI.spec,
+        bc.currentURI.spec,
+      ];
+    });
+
+  info(`docURI=${docURI}, curURI=${curURI}`);
+  is(curURI, "https://tls1.example.com/", "curURI has expected value");
+  ok(docURI.startsWith("about:neterror"), "documentURI starts with about:neterror");
+});
+
+let BROADCAST_ONLOAD_URL =
+    new URL("file_broadcast_currenturi_onload.html", location.href);
+
+async function broadcastLoadTest(baseURI, callback) {
+  // Bug 1746646: Make mochitests work with TCP enabled (cookieBehavior = 5)
+  // Acquire storage access permission here so that the BroadcastChannel used to
+  // communicate with the opened windows works in xorigin tests. Otherwise,
+  // the iframe containing this page is isolated from first-party storage access,
+  // which isolates BroadcastChannel communication.
+  if (isXOrigin) {
+    await SpecialPowers.pushPrefEnv({
+      set: [["privacy.partition.always_partition_third_party_non_cookie_storage", false]],
+    });
+    SpecialPowers.wrap(document).notifyUserGestureActivation();
+    await SpecialPowers.addPermission(
+      "storageAccessAPI",
+      true,
+      window.location.href
+     );
+    await SpecialPowers.wrap(document).requestStorageAccess();
+  }
+  let loaded = new Promise(resolve => {
+    let chan = new BroadcastChannel("test_broadcast_onload");
+    chan.onmessage = event => {
+      resolve(event.data);
+    };
+  });
+  let srcURL = new URL(BROADCAST_ONLOAD_URL.pathname, baseURI);
+  callback(srcURL.href);
+
+  let results = await loaded;
+  for (let { location, curURI, docURI } of results) {
+    info(`location=${location}, docURI=${docURI}, curURI=${curURI}`);
+    is(location, curURI, "curURI has expected value");
+    is(location, docURI, "documentURI has expected value");
+  }
+}
+
+async function normalFrameLoadTest(base) {
+  await broadcastLoadTest(base, src => {
+    let frame = document.createElement("iframe");
+    frame.src = src;
+    document.body.appendChild(frame);
+  });
+}
+
+async function normalPopupLoadTest(base, flags = "") {
+  await broadcastLoadTest(base, src => {
+    window.open(src, null, flags);
+  });
+}
+
+add_task(async function test_sameorigin_frame() {
+  await normalFrameLoadTest(location.href);
+})
+
+add_task(async function test_crossorigin_frame() {
+  await normalFrameLoadTest("https://example.com");
+});
+
+add_task(async function test_sameorigin_popup() {
+  await normalPopupLoadTest(location.href);
+  await normalPopupLoadTest(location.href, "noopener");
+});
+
+add_task(async function test_crossorigin_popup() {
+  await normalPopupLoadTest("https://example.com");
+  await normalPopupLoadTest("https://example.com", "noopener");
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/ipc/tests/test_bug1086684.js b/dom/ipc/tests/test_bug1086684.js
new file mode 100644
index 0000000000..8a34906686
--- /dev/null
+++ b/dom/ipc/tests/test_bug1086684.js
@@ -0,0 +1,99 @@
+"use strict";
+
+const { XPCShellContentUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/XPCShellContentUtils.sys.mjs"
+);
+
+XPCShellContentUtils.init(this);
+
+const childFramePath = "/file_bug1086684.html";
+const childFrameURL = "http://example.com" + childFramePath;
+
+const childFrameContents = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+</head>
+<body>
+<div id="content">
+    <input type="file" id="f">
+</div>
+</body>
+</html>`;
+
+const server = XPCShellContentUtils.createHttpServer({
+  hosts: ["example.com"],
+});
+server.registerPathHandler(childFramePath, (request, response) => {
+  response.write(childFrameContents);
+});
+
+function childFrameScript() {
+  /* eslint-env mozilla/frame-script */
+  "use strict";
+
+  let { MockFilePicker } = ChromeUtils.importESModule(
+    "resource://testing-common/MockFilePicker.sys.mjs"
+  );
+
+  function parentReady(message) {
+    MockFilePicker.init(content);
+    MockFilePicker.setFiles([message.data.file]);
+    MockFilePicker.returnValue = MockFilePicker.returnOK;
+
+    let input = content.document.getElementById("f");
+    input.addEventListener("change", () => {
+      MockFilePicker.cleanup();
+      let value = input.value;
+      message.target.sendAsyncMessage("testBug1086684:childDone", { value });
+    });
+
+    input.focus();
+    input.click();
+  }
+
+  addMessageListener("testBug1086684:parentReady", function (message) {
+    parentReady(message);
+  });
+}
+
+add_task(async function () {
+  Services.prefs.setBoolPref("dom.security.https_first", false);
+  let page = await XPCShellContentUtils.loadContentPage(childFrameURL, {
+    remote: true,
+  });
+
+  page.loadFrameScript(childFrameScript);
+
+  await new Promise(resolve => {
+    let test;
+    function* testStructure(mm) {
+      let value;
+
+      function testDone(msg) {
+        test.next(msg.data.value);
+      }
+
+      mm.addMessageListener("testBug1086684:childDone", testDone);
+
+      let blob = new Blob([]);
+      let file = new File([blob], "helloworld.txt", { type: "text/plain" });
+
+      mm.sendAsyncMessage("testBug1086684:parentReady", { file });
+      value = yield;
+
+      // Note that the "helloworld.txt" passed in above doesn't affect the
+      // 'value' getter. Because we're mocking a file using a blob, we ask the
+      // blob for its path, which is the empty string.
+      equal(value, "", "got the right answer and didn't crash");
+
+      resolve();
+    }
+
+    test = testStructure(page.browser.messageManager);
+    test.next();
+  });
+
+  await page.close();
+  Services.prefs.clearUserPref("dom.security.https_first");
+});
diff --git a/dom/ipc/tests/test_child_docshell.js b/dom/ipc/tests/test_child_docshell.js
new file mode 100644
index 0000000000..ee79a509dc
--- /dev/null
+++ b/dom/ipc/tests/test_child_docshell.js
@@ -0,0 +1,90 @@
+"use strict";
+
+const { XPCShellContentUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/XPCShellContentUtils.sys.mjs"
+);
+
+XPCShellContentUtils.init(this);
+
+add_task(async function test() {
+  let page = await XPCShellContentUtils.loadContentPage("about:blank", {
+    remote: true,
+  });
+
+  await new Promise(resolve => {
+    let mm = page.browser.messageManager;
+    mm.addMessageListener("chromeEventHandler", function (msg) {
+      var result = msg.json;
+      equal(
+        result.processType,
+        Ci.nsIXULRuntime.PROCESS_TYPE_CONTENT,
+        "The frame script is running in a real distinct child process"
+      );
+      ok(
+        result.hasCorrectInterface,
+        "docshell.chromeEventHandler has EventTarget interface"
+      );
+    });
+
+    mm.addMessageListener("DOMWindowCreatedReceived", function (msg) {
+      ok(true, "the chrome event handler looks functional");
+      var result = msg.json;
+      ok(
+        result.stableChromeEventHandler,
+        "docShell.chromeEventHandler is stable"
+      );
+      ok(result.iframeHasNewDocShell, "iframe spawns a new docShell");
+      ok(
+        result.iframeHasSameChromeEventHandler,
+        "but iframe has the same chrome event handler"
+      );
+      resolve();
+    });
+
+    // Inject a frame script in the child process:
+    page.loadFrameScript(async function () {
+      /* eslint-env mozilla/frame-script */
+      var chromeEventHandler = docShell.chromeEventHandler;
+      sendAsyncMessage("chromeEventHandler", {
+        processType: Services.appinfo.processType,
+        hasCorrectInterface:
+          chromeEventHandler && EventTarget.isInstance(chromeEventHandler),
+      });
+
+      /*
+        Ensure that this chromeEventHandler actually works,
+        by creating a new window and listening for its DOMWindowCreated event
+      */
+      chromeEventHandler.addEventListener(
+        "DOMWindowCreated",
+        function listener(evt) {
+          if (evt.target == content.document) {
+            return;
+          }
+          chromeEventHandler.removeEventListener("DOMWindowCreated", listener);
+          let new_win = evt.target.defaultView;
+          let new_docShell = new_win.docShell;
+          sendAsyncMessage("DOMWindowCreatedReceived", {
+            stableChromeEventHandler:
+              chromeEventHandler === docShell.chromeEventHandler,
+            iframeHasNewDocShell: new_docShell !== docShell,
+            iframeHasSameChromeEventHandler:
+              new_docShell.chromeEventHandler === chromeEventHandler,
+          });
+        }
+      );
+
+      if (content.document.readyState != "complete") {
+        await new Promise(res =>
+          addEventListener("load", res, { once: true, capture: true })
+        );
+      }
+
+      let iframe = content.document.createElement("iframe");
+      iframe.setAttribute("src", "data:text/html,foo");
+      content.document.documentElement.appendChild(iframe);
+    });
+  });
+
+  await page.close();
+});
diff --git a/dom/ipc/tests/test_process_error.xhtml b/dom/ipc/tests/test_process_error.xhtml
new file mode 100644
index 0000000000..d122e7fedd
--- /dev/null
+++ b/dom/ipc/tests/test_process_error.xhtml
@@ -0,0 +1,22 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?>
+<?xml-stylesheet href="chrome://mochikit/content/tests/SimpleTest/test.css" type="text/css"?>
+
+<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js" />
+
+  <script>
+  SimpleTest.waitForExplicitFinish();
+  SimpleTest.expectChildProcessCrash();
+
+  var w = window.browsingContext.topChromeWindow.openDialog('process_error.xhtml', '_blank', 'chrome,resizable=yes,width=400,height=600', window);
+
+  function done()
+  {
+    w.close();
+    SimpleTest.finish();
+  }
+  </script>
+
+  <body xmlns="http://www.w3.org/1999/xhtml" style="height: 300px; overflow: auto;" />
+</window>
diff --git a/dom/ipc/tests/test_sharedMap.js b/dom/ipc/tests/test_sharedMap.js
new file mode 100644
index 0000000000..2a6c3a7142
--- /dev/null
+++ b/dom/ipc/tests/test_sharedMap.js
@@ -0,0 +1,377 @@
+"use strict";
+
+const { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+const { XPCShellContentUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/XPCShellContentUtils.sys.mjs"
+);
+
+const PROCESS_COUNT_PREF = "dom.ipc.processCount";
+
+const remote = AppConstants.platform !== "android";
+
+XPCShellContentUtils.init(this);
+
+let contentPage;
+
+async function readBlob(key, sharedData = Services.cpmm.sharedData) {
+  const { ExtensionUtils } = ChromeUtils.importESModule(
+    "resource://gre/modules/ExtensionUtils.sys.mjs"
+  );
+
+  let reader = new FileReader();
+  reader.readAsText(sharedData.get(key));
+  await ExtensionUtils.promiseEvent(reader, "loadend");
+  return reader.result;
+}
+
+function getKey(key, sharedData = Services.cpmm.sharedData) {
+  return sharedData.get(key);
+}
+
+function hasKey(key, sharedData = Services.cpmm.sharedData) {
+  return sharedData.has(key);
+}
+
+function getContents(sharedMap = Services.cpmm.sharedData) {
+  return {
+    keys: Array.from(sharedMap.keys()),
+    values: Array.from(sharedMap.values()),
+    entries: Array.from(sharedMap.entries()),
+    getValues: Array.from(sharedMap.keys(), key => sharedMap.get(key)),
+  };
+}
+
+function checkMap(contents, expected) {
+  expected = Array.from(expected);
+
+  equal(contents.keys.length, expected.length, "Got correct number of keys");
+  equal(
+    contents.values.length,
+    expected.length,
+    "Got correct number of values"
+  );
+  equal(
+    contents.entries.length,
+    expected.length,
+    "Got correct number of entries"
+  );
+
+  for (let [i, [key, val]] of contents.entries.entries()) {
+    equal(key, contents.keys[i], `keys()[${i}] matches entries()[${i}]`);
+    deepEqual(
+      val,
+      contents.values[i],
+      `values()[${i}] matches entries()[${i}]`
+    );
+  }
+
+  expected.sort(([a], [b]) => a.localeCompare(b));
+  contents.entries.sort(([a], [b]) => a.localeCompare(b));
+
+  for (let [i, [key, val]] of contents.entries.entries()) {
+    equal(
+      key,
+      expected[i][0],
+      `expected[${i}].key matches entries()[${i}].key`
+    );
+    deepEqual(
+      val,
+      expected[i][1],
+      `expected[${i}].value matches entries()[${i}].value`
+    );
+  }
+}
+
+function checkParentMap(expected) {
+  info("Checking parent map");
+  checkMap(getContents(Services.ppmm.sharedData), expected);
+}
+
+async function checkContentMaps(expected, parentOnly = false) {
+  info("Checking in-process content map");
+  checkMap(getContents(Services.cpmm.sharedData), expected);
+
+  if (!parentOnly) {
+    info("Checking out-of-process content map");
+    let contents = await contentPage.spawn([], getContents);
+    checkMap(contents, expected);
+  }
+}
+
+async function loadContentPage() {
+  let page = await XPCShellContentUtils.loadContentPage("data:text/html,", {
+    remote,
+  });
+  registerCleanupFunction(() => page.close());
+  return page;
+}
+
+add_setup(async function () {
+  // Start with one content process so that we can increase the number
+  // later and test the behavior of a fresh content process.
+  Services.prefs.setIntPref(PROCESS_COUNT_PREF, 1);
+
+  contentPage = await loadContentPage();
+});
+
+add_task(async function test_sharedMap() {
+  let { sharedData } = Services.ppmm;
+
+  info("Check that parent and child maps are both initially empty");
+
+  checkParentMap([]);
+  await checkContentMaps([]);
+
+  let expected = [
+    ["foo-a", { foo: "a" }],
+    ["foo-b", { foo: "b" }],
+    ["bar-c", null],
+    ["bar-d", 42],
+  ];
+
+  function setKey(key, val) {
+    sharedData.set(key, val);
+    expected = expected.filter(([k]) => k != key);
+    expected.push([key, val]);
+  }
+  function deleteKey(key) {
+    sharedData.delete(key);
+    expected = expected.filter(([k]) => k != key);
+  }
+
+  for (let [key, val] of expected) {
+    sharedData.set(key, val);
+  }
+
+  info(
+    "Add some entries, test that they are initially only available in the parent"
+  );
+
+  checkParentMap(expected);
+  await checkContentMaps([]);
+
+  info("Flush. Check that changes are visible in both parent and children");
+
+  sharedData.flush();
+
+  checkParentMap(expected);
+  await checkContentMaps(expected);
+
+  info(
+    "Add another entry. Check that it is initially only available in the parent"
+  );
+
+  let oldExpected = Array.from(expected);
+
+  setKey("baz-a", { meh: "meh" });
+
+  // When we do several checks in a row, we can't check the values in
+  // the content process, since the async checks may allow the idle
+  // flush task to run, and update it before we're ready.
+
+  checkParentMap(expected);
+  checkContentMaps(oldExpected, true);
+
+  info(
+    "Add another entry. Check that both new entries are only available in the parent"
+  );
+
+  setKey("baz-a", { meh: 12 });
+
+  checkParentMap(expected);
+  checkContentMaps(oldExpected, true);
+
+  info(
+    "Delete an entry. Check that all changes are only visible in the parent"
+  );
+
+  deleteKey("foo-b");
+
+  checkParentMap(expected);
+  checkContentMaps(oldExpected, true);
+
+  info(
+    "Flush. Check that all entries are available in both parent and children"
+  );
+
+  sharedData.flush();
+
+  checkParentMap(expected);
+  await checkContentMaps(expected);
+
+  info("Test that entries are automatically flushed on idle:");
+
+  info(
+    "Add a new entry. Check that it is initially only available in the parent"
+  );
+
+  // Test the idle flush task.
+  oldExpected = Array.from(expected);
+
+  setKey("thing", "stuff");
+
+  checkParentMap(expected);
+  checkContentMaps(oldExpected, true);
+
+  info(
+    "Wait for an idle timeout. Check that changes are now visible in all children"
+  );
+
+  await new Promise(resolve => ChromeUtils.idleDispatch(resolve));
+
+  checkParentMap(expected);
+  await checkContentMaps(expected);
+
+  // Test that has() rebuilds map after a flush.
+  sharedData.set("grick", true);
+  sharedData.flush();
+  equal(
+    await contentPage.spawn(["grick"], hasKey),
+    true,
+    "has() should see key after flush"
+  );
+
+  sharedData.set("grack", true);
+  sharedData.flush();
+  equal(
+    await contentPage.spawn(["gruck"], hasKey),
+    false,
+    "has() should return false for nonexistent key"
+  );
+});
+
+add_task(async function test_blobs() {
+  let { sharedData } = Services.ppmm;
+
+  let text = [
+    "The quick brown fox jumps over the lazy dog",
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
+    "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
+  ];
+  let blobs = text.map(str => new Blob([str]));
+
+  let data = { foo: { bar: "baz" } };
+
+  sharedData.set("blob0", blobs[0]);
+  sharedData.set("blob1", blobs[1]);
+  sharedData.set("data", data);
+
+  equal(
+    await readBlob("blob0", sharedData),
+    text[0],
+    "Expected text for blob0 in parent ppmm"
+  );
+
+  sharedData.flush();
+
+  equal(
+    await readBlob("blob0", sharedData),
+    text[0],
+    "Expected text for blob0 in parent ppmm"
+  );
+  equal(
+    await readBlob("blob1", sharedData),
+    text[1],
+    "Expected text for blob1 in parent ppmm"
+  );
+
+  equal(
+    await readBlob("blob0"),
+    text[0],
+    "Expected text for blob0 in parent cpmm"
+  );
+  equal(
+    await readBlob("blob1"),
+    text[1],
+    "Expected text for blob1 in parent cpmm"
+  );
+
+  equal(
+    await contentPage.spawn(["blob0"], readBlob),
+    text[0],
+    "Expected text for blob0 in child 1 cpmm"
+  );
+  equal(
+    await contentPage.spawn(["blob1"], readBlob),
+    text[1],
+    "Expected text for blob1 in child 1 cpmm"
+  );
+
+  // Start a second child process
+  Services.prefs.setIntPref(PROCESS_COUNT_PREF, 2);
+
+  let page2 = await loadContentPage();
+
+  equal(
+    await page2.spawn(["blob0"], readBlob),
+    text[0],
+    "Expected text for blob0 in child 2 cpmm"
+  );
+  equal(
+    await page2.spawn(["blob1"], readBlob),
+    text[1],
+    "Expected text for blob1 in child 2 cpmm"
+  );
+
+  sharedData.set("blob0", blobs[2]);
+
+  equal(
+    await readBlob("blob0", sharedData),
+    text[2],
+    "Expected text for blob0 in parent ppmm"
+  );
+
+  sharedData.flush();
+
+  equal(
+    await readBlob("blob0", sharedData),
+    text[2],
+    "Expected text for blob0 in parent ppmm"
+  );
+  equal(
+    await readBlob("blob1", sharedData),
+    text[1],
+    "Expected text for blob1 in parent ppmm"
+  );
+
+  equal(
+    await readBlob("blob0"),
+    text[2],
+    "Expected text for blob0 in parent cpmm"
+  );
+  equal(
+    await readBlob("blob1"),
+    text[1],
+    "Expected text for blob1 in parent cpmm"
+  );
+
+  equal(
+    await contentPage.spawn(["blob0"], readBlob),
+    text[2],
+    "Expected text for blob0 in child 1 cpmm"
+  );
+  equal(
+    await contentPage.spawn(["blob1"], readBlob),
+    text[1],
+    "Expected text for blob1 in child 1 cpmm"
+  );
+
+  equal(
+    await page2.spawn(["blob0"], readBlob),
+    text[2],
+    "Expected text for blob0 in child 2 cpmm"
+  );
+  equal(
+    await page2.spawn(["blob1"], readBlob),
+    text[1],
+    "Expected text for blob1 in child 2 cpmm"
+  );
+
+  deepEqual(
+    await page2.spawn(["data"], getKey),
+    data,
+    "Expected data for data key in child 2 cpmm"
+  );
+});
diff --git a/dom/ipc/tests/test_temporaryfile_stream.html b/dom/ipc/tests/test_temporaryfile_stream.html
new file mode 100644
index 0000000000..9fa76a2155
--- /dev/null
+++ b/dom/ipc/tests/test_temporaryfile_stream.html
@@ -0,0 +1,84 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Send an nsTemporaryFileInputStream cross-process</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script src="/tests/dom/canvas/test/captureStream_common.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<pre id="test">
+<div id="content">
+</div>
+<script class="testbody" type="text/javascript">
+function startTest() {
+  var canvas = document.createElement("canvas");
+  canvas.width = canvas.height = 100;
+  document.getElementById("content").appendChild(canvas);
+
+
+  // eslint-disable-next-line no-undef
+  var helper = new CaptureStreamTestHelper2D(100, 100);
+  helper.drawColor(canvas, helper.red);
+
+  var stream = canvas.captureStream(0);
+
+  var blob;
+
+  let mediaRecorder = new MediaRecorder(stream);
+  is(mediaRecorder.stream, stream,
+     "Media recorder stream = canvas stream at the start of recording");
+
+  mediaRecorder.onwarning = () => ok(false, "warning unexpectedly fired");
+
+  mediaRecorder.onerror = () => ok(false, "Recording failed");
+
+  mediaRecorder.ondataavailable = ev => {
+    is(blob, undefined, "Should only get one dataavailable event");
+    blob = ev.data;
+  };
+
+  mediaRecorder.onstart = () => {
+    info("Got 'start' event");
+    // We just want one frame encoded, to see that the recorder produces something readable.
+    mediaRecorder.stop();
+  };
+
+  mediaRecorder.onstop = () => {
+    info("Got 'stop' event");
+    ok(blob, "Should have gotten a data blob");
+    var xhr = new XMLHttpRequest();
+    xhr.open("POST", "blob_verify.sjs", true);
+    xhr.onload = () => {
+      var video = document.createElement("video");
+      video.id = "recorded-video";
+      video.src = URL.createObjectURL(xhr.response);
+      video.play();
+      video.onerror = err => {
+        ok(false, "Should be able to play the recording. Got error. code=" + video.error.code);
+        SimpleTest.finish();
+      };
+      document.getElementById("content").appendChild(video);
+      helper.pixelMustBecome(video, helper.red, {
+        threshold: 128,
+        infoString: "Should become red",
+      }).then(SimpleTest.finish);
+    };
+    xhr.onerror = () => {
+      ok(false, "XHR error");
+      SimpleTest.finish();
+    };
+    xhr.responseType = "blob";
+    xhr.send(blob);
+  };
+
+  mediaRecorder.start();
+  is(mediaRecorder.state, "recording", "Media recorder should be recording");
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPrefEnv({set: [["media.recorder.max_memory", 1]]}, startTest);
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/ipc/tests/test_window_open_discarded_bc.html b/dom/ipc/tests/test_window_open_discarded_bc.html
new file mode 100644
index 0000000000..4cd81463e0
--- /dev/null
+++ b/dom/ipc/tests/test_window_open_discarded_bc.html
@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Discard a new BrowsingContext during window.open nested event loop</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<script>
+add_task(async function() {
+  const TOPIC = "dangerous:test-only:new-browser-child-ready";
+
+  let found = false;
+  function observer(subject, topic, data) {
+    let win = SpecialPowers.wrap(subject);
+    if (SpecialPowers.compare(win.opener, window)) {
+      found = true;
+      SpecialPowers.removeObserver(observer, TOPIC);
+
+      win.close();
+      // window.close() is not synchronous, so we need to wait for the
+      // BrowsingContext to actually become discarded after we call it, to
+      // make sure that the window provider actually has a discarded BC at the
+      // end of its own nested event loop.
+      SpecialPowers.Services.tm.spinEventLoopUntil(
+        "Test(test_window_open_discarded_bc.html:add_task)",
+        () => !win.opener
+      );
+    }
+  }
+  SpecialPowers.addObserver(observer, TOPIC);
+
+  let win = window.open();
+
+  is(found, true, "Our observer should have fired for the new window");
+  is(win, null, "window.open() should return null when new window is already closed");
+});
+</script>
+</body>
+</html>
diff --git a/dom/ipc/tests/xpcshell.ini b/dom/ipc/tests/xpcshell.ini
new file mode 100644
index 0000000000..a93537c9b6
--- /dev/null
+++ b/dom/ipc/tests/xpcshell.ini
@@ -0,0 +1,10 @@
+[test_sharedMap.js]
+skip-if = os == "android" && processor == "x86_64"
+[test_blob_sliced_from_child_process.js]
+skip-if = os == "android" && processor == "x86_64"
+[test_blob_sliced_from_parent_process.js]
+skip-if = os == "android" && processor == "x86_64"
+[test_bug1086684.js]
+skip-if = os == "android" && processor == "x86_64"
+[test_child_docshell.js]
+skip-if = os == "android" && processor == "x86_64"