gecko-dev/dom/ipc/ContentBridgeChild.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/ContentBridgeChild.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/File.h"
#include "mozilla/dom/TabChild.h"
#include "mozilla/dom/TabGroup.h"
#include "mozilla/jsipc/CrossProcessObjectWrappers.h"
#include "mozilla/ipc/InputStreamUtils.h"
#include "base/task.h"

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

namespace mozilla {
namespace dom {

NS_IMPL_ISUPPORTS(ContentBridgeChild, nsIContentChild)

ContentBridgeChild::ContentBridgeChild() {}

ContentBridgeChild::~ContentBridgeChild() {}

void ContentBridgeChild::ActorDestroy(ActorDestroyReason aWhy) {
  MessageLoop::current()->PostTask(
      NewRunnableMethod("dom::ContentBridgeChild::DeferredDestroy", this,
                        &ContentBridgeChild::DeferredDestroy));
}

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

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

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

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

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

PFileDescriptorSetChild* ContentBridgeChild::SendPFileDescriptorSetConstructor(
    const FileDescriptor& aFD) {
  return PContentBridgeChild::SendPFileDescriptorSetConstructor(aFD);
}

PChildToParentStreamChild*
ContentBridgeChild::SendPChildToParentStreamConstructor(
    PChildToParentStreamChild* aActor) {
  return PContentBridgeChild::SendPChildToParentStreamConstructor(aActor);
}

// This implementation is identical to ContentChild::GetCPOWManager but we can't
// move it to nsIContentChild because it calls ManagedPJavaScriptChild() which
// only exists in PContentChild and PContentBridgeChild.
jsipc::CPOWManager* ContentBridgeChild::GetCPOWManager() {
  if (PJavaScriptChild* c =
          LoneManagedOrNullAsserts(ManagedPJavaScriptChild())) {
    return CPOWManagerFor(c);
  }
  return CPOWManagerFor(SendPJavaScriptConstructor());
}

mozilla::jsipc::PJavaScriptChild* ContentBridgeChild::AllocPJavaScriptChild() {
  return nsIContentChild::AllocPJavaScriptChild();
}

bool ContentBridgeChild::DeallocPJavaScriptChild(PJavaScriptChild* child) {
  return nsIContentChild::DeallocPJavaScriptChild(child);
}

PBrowserChild* ContentBridgeChild::AllocPBrowserChild(
    const TabId& aTabId, const TabId& aSameTabGroupAs,
    const IPCTabContext& aContext, const uint32_t& aChromeFlags,
    const ContentParentId& aCpID, const bool& aIsForBrowser) {
  return nsIContentChild::AllocPBrowserChild(
      aTabId, aSameTabGroupAs, aContext, aChromeFlags, aCpID, aIsForBrowser);
}

bool ContentBridgeChild::DeallocPBrowserChild(PBrowserChild* aChild) {
  return nsIContentChild::DeallocPBrowserChild(aChild);
}

mozilla::ipc::IPCResult ContentBridgeChild::RecvPBrowserConstructor(
    PBrowserChild* aActor, const TabId& aTabId, const TabId& aSameTabGroupAs,
    const IPCTabContext& aContext, const uint32_t& aChromeFlags,
    const ContentParentId& aCpID, const bool& aIsForBrowser) {
  return nsIContentChild::RecvPBrowserConstructor(
      aActor, aTabId, aSameTabGroupAs, aContext, aChromeFlags, aCpID,
      aIsForBrowser);
}

PIPCBlobInputStreamChild* ContentBridgeChild::AllocPIPCBlobInputStreamChild(
    const nsID& aID, const uint64_t& aSize) {
  return nsIContentChild::AllocPIPCBlobInputStreamChild(aID, aSize);
}

bool ContentBridgeChild::DeallocPIPCBlobInputStreamChild(
    PIPCBlobInputStreamChild* aActor) {
  return nsIContentChild::DeallocPIPCBlobInputStreamChild(aActor);
}

PChildToParentStreamChild*
ContentBridgeChild::AllocPChildToParentStreamChild() {
  return nsIContentChild::AllocPChildToParentStreamChild();
}

bool ContentBridgeChild::DeallocPChildToParentStreamChild(
    PChildToParentStreamChild* aActor) {
  return nsIContentChild::DeallocPChildToParentStreamChild(aActor);
}

PParentToChildStreamChild*
ContentBridgeChild::AllocPParentToChildStreamChild() {
  return nsIContentChild::AllocPParentToChildStreamChild();
}

bool ContentBridgeChild::DeallocPParentToChildStreamChild(
    PParentToChildStreamChild* aActor) {
  return nsIContentChild::DeallocPParentToChildStreamChild(aActor);
}

PFileDescriptorSetChild* ContentBridgeChild::AllocPFileDescriptorSetChild(
    const FileDescriptor& aFD) {
  return nsIContentChild::AllocPFileDescriptorSetChild(aFD);
}

bool ContentBridgeChild::DeallocPFileDescriptorSetChild(
    PFileDescriptorSetChild* aActor) {
  return nsIContentChild::DeallocPFileDescriptorSetChild(aActor);
}

mozilla::ipc::IPCResult ContentBridgeChild::RecvActivate(PBrowserChild* aTab) {
  TabChild* tab = static_cast<TabChild*>(aTab);
  return tab->RecvActivate();
}

mozilla::ipc::IPCResult ContentBridgeChild::RecvDeactivate(
    PBrowserChild* aTab) {
  TabChild* tab = static_cast<TabChild*>(aTab);
  return tab->RecvDeactivate();
}

already_AddRefed<nsIEventTarget> ContentBridgeChild::GetConstructedEventTarget(
    const Message& aMsg) {
  // Currently we only set targets for PBrowser.
  if (aMsg.type() != PContentBridge::Msg_PBrowserConstructor__ID) {
    return nullptr;
  }

  return nsIContentChild::GetConstructedEventTarget(aMsg);
}

already_AddRefed<nsIEventTarget> ContentBridgeChild::GetEventTargetFor(
    TabChild* aTabChild) {
  return IToplevelProtocol::GetActorEventTarget(aTabChild);
}

}  // namespace dom
}  // namespace mozilla