gecko-dev/dom/ipc/ContentBridgeParent.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mozilla/dom/ContentBridgeParent.h"
#include "mozilla/dom/ProcessMessageManager.h"
#include "mozilla/dom/TabParent.h"
#include "mozilla/jsipc/CrossProcessObjectWrappers.h"
#include "nsXULAppAPI.h"
#include "nsIObserverService.h"
#include "base/task.h"

using namespace mozilla::ipc;
using namespace mozilla::jsipc;

namespace mozilla {
namespace dom {

NS_IMPL_ISUPPORTS(ContentBridgeParent, nsIContentParent, nsIObserver)

ContentBridgeParent::ContentBridgeParent()
    : mIsForBrowser(false), mIsForJSPlugin(false) {}

ContentBridgeParent::~ContentBridgeParent() {}

void ContentBridgeParent::ActorDestroy(ActorDestroyReason aWhy) {
  nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
  if (os) {
    os->RemoveObserver(this, "content-child-shutdown");
  }
  MessageLoop::current()->PostTask(
      NewRunnableMethod("dom::ContentBridgeParent::DeferredDestroy", this,
                        &ContentBridgeParent::DeferredDestroy));
}

/*static*/ ContentBridgeParent* ContentBridgeParent::Create(
    Endpoint<PContentBridgeParent>&& aEndpoint) {
  RefPtr<ContentBridgeParent> bridge = new ContentBridgeParent();
  bridge->mSelfRef = bridge;

  DebugOnly<bool> ok = aEndpoint.Bind(bridge);
  MOZ_ASSERT(ok);

  nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
  if (os) {
    os->AddObserver(bridge, "content-child-shutdown", false);
  }

  // Initialize the message manager (and load delayed scripts) now that we
  // have established communications with the child.
  bridge->mMessageManager->InitWithCallback(bridge);

  return bridge.get();
}

void ContentBridgeParent::DeferredDestroy() {
  mSelfRef = nullptr;
  // |this| was just destroyed, hands off
}

mozilla::ipc::IPCResult ContentBridgeParent::RecvSyncMessage(
    const nsString& aMsg, const ClonedMessageData& aData,
    InfallibleTArray<jsipc::CpowEntry>&& aCpows,
    const IPC::Principal& aPrincipal, nsTArray<StructuredCloneData>* aRetvals) {
  return nsIContentParent::RecvSyncMessage(aMsg, aData, std::move(aCpows),
                                           aPrincipal, aRetvals);
}

mozilla::ipc::IPCResult ContentBridgeParent::RecvAsyncMessage(
    const nsString& aMsg, InfallibleTArray<jsipc::CpowEntry>&& aCpows,
    const IPC::Principal& aPrincipal, const ClonedMessageData& aData) {
  return nsIContentParent::RecvAsyncMessage(aMsg, std::move(aCpows), aPrincipal,
                                            aData);
}

PBrowserParent* ContentBridgeParent::SendPBrowserConstructor(
    PBrowserParent* aActor, const TabId& aTabId, const TabId& aSameTabGroupAs,
    const IPCTabContext& aContext, const uint32_t& aChromeFlags,
    const ContentParentId& aCpID, const bool& aIsForBrowser) {
  return PContentBridgeParent::SendPBrowserConstructor(
      aActor, aTabId, aSameTabGroupAs, aContext, aChromeFlags, aCpID,
      aIsForBrowser);
}

PParentToChildStreamParent*
ContentBridgeParent::SendPParentToChildStreamConstructor(
    PParentToChildStreamParent* aActor) {
  return PContentBridgeParent::SendPParentToChildStreamConstructor(aActor);
}

PIPCBlobInputStreamParent*
ContentBridgeParent::SendPIPCBlobInputStreamConstructor(
    PIPCBlobInputStreamParent* aActor, const nsID& aID, const uint64_t& aSize) {
  return PContentBridgeParent::SendPIPCBlobInputStreamConstructor(aActor, aID,
                                                                  aSize);
}

PIPCBlobInputStreamParent* ContentBridgeParent::AllocPIPCBlobInputStreamParent(
    const nsID& aID, const uint64_t& aSize) {
  return nsIContentParent::AllocPIPCBlobInputStreamParent(aID, aSize);
}

bool ContentBridgeParent::DeallocPIPCBlobInputStreamParent(
    PIPCBlobInputStreamParent* aActor) {
  return nsIContentParent::DeallocPIPCBlobInputStreamParent(aActor);
}

mozilla::jsipc::PJavaScriptParent*
ContentBridgeParent::AllocPJavaScriptParent() {
  return nsIContentParent::AllocPJavaScriptParent();
}

bool ContentBridgeParent::DeallocPJavaScriptParent(PJavaScriptParent* parent) {
  return nsIContentParent::DeallocPJavaScriptParent(parent);
}

PBrowserParent* ContentBridgeParent::AllocPBrowserParent(
    const TabId& aTabId, const TabId& aSameTabGroupAs,
    const IPCTabContext& aContext, const uint32_t& aChromeFlags,
    const ContentParentId& aCpID, const bool& aIsForBrowser) {
  return nsIContentParent::AllocPBrowserParent(
      aTabId, aSameTabGroupAs, aContext, aChromeFlags, aCpID, aIsForBrowser);
}

bool ContentBridgeParent::DeallocPBrowserParent(PBrowserParent* aParent) {
  return nsIContentParent::DeallocPBrowserParent(aParent);
}

mozilla::ipc::IPCResult ContentBridgeParent::RecvPBrowserConstructor(
    PBrowserParent* actor, const TabId& tabId, const TabId& sameTabGroupAs,
    const IPCTabContext& context, const uint32_t& chromeFlags,
    const ContentParentId& cpId, const bool& isForBrowser) {
  return nsIContentParent::RecvPBrowserConstructor(
      actor, tabId, sameTabGroupAs, context, chromeFlags, cpId, isForBrowser);
}

void ContentBridgeParent::NotifyTabDestroyed() {
  int32_t numLiveTabs = ManagedPBrowserParent().Count();
  if (numLiveTabs == 1) {
    MessageLoop::current()->PostTask(NewRunnableMethod(
        "dom::ContentBridgeParent::Close", this, &ContentBridgeParent::Close));
  }
}

// This implementation is identical to ContentParent::GetCPOWManager but we
// can't move it to nsIContentParent because it calls ManagedPJavaScriptParent()
// which only exists in PContentParent and PContentBridgeParent.
jsipc::CPOWManager* ContentBridgeParent::GetCPOWManager() {
  if (PJavaScriptParent* p =
          LoneManagedOrNullAsserts(ManagedPJavaScriptParent())) {
    return CPOWManagerFor(p);
  }
  return nullptr;
}

NS_IMETHODIMP
ContentBridgeParent::Observe(nsISupports* aSubject, const char* aTopic,
                             const char16_t* aData) {
  if (!strcmp(aTopic, "content-child-shutdown")) {
    Close();
  }
  return NS_OK;
}

PFileDescriptorSetParent*
ContentBridgeParent::SendPFileDescriptorSetConstructor(
    const FileDescriptor& aFD) {
  return PContentBridgeParent::SendPFileDescriptorSetConstructor(aFD);
}

PFileDescriptorSetParent* ContentBridgeParent::AllocPFileDescriptorSetParent(
    const FileDescriptor& aFD) {
  return nsIContentParent::AllocPFileDescriptorSetParent(aFD);
}

bool ContentBridgeParent::DeallocPFileDescriptorSetParent(
    PFileDescriptorSetParent* aActor) {
  return nsIContentParent::DeallocPFileDescriptorSetParent(aActor);
}

PChildToParentStreamParent*
ContentBridgeParent::AllocPChildToParentStreamParent() {
  return nsIContentParent::AllocPChildToParentStreamParent();
}

bool ContentBridgeParent::DeallocPChildToParentStreamParent(
    PChildToParentStreamParent* aActor) {
  return nsIContentParent::DeallocPChildToParentStreamParent(aActor);
}

PParentToChildStreamParent*
ContentBridgeParent::AllocPParentToChildStreamParent() {
  return nsIContentParent::AllocPParentToChildStreamParent();
}

bool ContentBridgeParent::DeallocPParentToChildStreamParent(
    PParentToChildStreamParent* aActor) {
  return nsIContentParent::DeallocPParentToChildStreamParent(aActor);
}

}  // namespace dom
}  // namespace mozilla