gecko-dev/dom/ipc/nsIContentChild.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 "nsIContentChild.h"

#include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/ChildProcessMessageManager.h"
#include "mozilla/dom/DOMTypes.h"
#include "mozilla/dom/File.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/TabChild.h"
#include "mozilla/dom/TabGroup.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"
#include "mozilla/ipc/FileDescriptorSetChild.h"
#include "mozilla/ipc/InputStreamUtils.h"
#include "mozilla/ipc/IPCStreamAlloc.h"
#include "mozilla/ipc/IPCStreamDestination.h"
#include "mozilla/ipc/IPCStreamSource.h"
#include "mozilla/ipc/PChildToParentStreamChild.h"
#include "mozilla/ipc/PParentToChildStreamChild.h"
#include "mozilla/dom/ipc/IPCBlobInputStreamChild.h"

#include "MMPrinter.h"
#include "nsPrintfCString.h"
#include "xpcpublic.h"

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

namespace mozilla {
namespace dom {

PJavaScriptChild* nsIContentChild::AllocPJavaScriptChild() {
  return NewJavaScriptChild();
}

bool nsIContentChild::DeallocPJavaScriptChild(PJavaScriptChild* aChild) {
  ReleaseJavaScriptChild(aChild);
  return true;
}

PBrowserChild* nsIContentChild::AllocPBrowserChild(
    const TabId& aTabId, const TabId& aSameTabGroupAs,
    const IPCTabContext& aContext, const uint32_t& aChromeFlags,
    const ContentParentId& aCpID, const bool& aIsForBrowser) {
  // 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<TabChild> child = TabChild::Create(this, aTabId, aSameTabGroupAs,
                                            tc.GetTabContext(), aChromeFlags);

  // The ref here is released in DeallocPBrowserChild.
  return child.forget().take();
}

bool nsIContentChild::DeallocPBrowserChild(PBrowserChild* aIframe) {
  TabChild* child = static_cast<TabChild*>(aIframe);
  NS_RELEASE(child);
  return true;
}

mozilla::ipc::IPCResult nsIContentChild::RecvPBrowserConstructor(
    PBrowserChild* aActor, const TabId& aTabId, const TabId& aSameTabGroupAs,
    const IPCTabContext& aContext, const uint32_t& aChromeFlags,
    const ContentParentId& aCpID, const bool& aIsForBrowser) {
  // This runs after AllocPBrowserChild() returns and the IPC machinery for this
  // PBrowserChild has been set up.

  auto tabChild = static_cast<TabChild*>(static_cast<TabChild*>(aActor));

  if (NS_WARN_IF(NS_FAILED(tabChild->Init(/* aOpener */ nullptr)))) {
    return IPC_FAIL(tabChild, "TabChild::Init failed");
  }

  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
  if (os) {
    os->NotifyObservers(static_cast<nsITabChild*>(tabChild),
                        "tab-child-created", nullptr);
  }
  // Notify parent that we are ready to handle input events.
  tabChild->SendRemoteIsReadyToHandleInputEvents();
  return IPC_OK();
}

PIPCBlobInputStreamChild* nsIContentChild::AllocPIPCBlobInputStreamChild(
    const nsID& aID, const uint64_t& aSize) {
  // IPCBlobInputStreamChild is refcounted. Here it's created and in
  // DeallocPIPCBlobInputStreamChild is released.

  RefPtr<IPCBlobInputStreamChild> actor =
      new IPCBlobInputStreamChild(aID, aSize);
  return actor.forget().take();
}

bool nsIContentChild::DeallocPIPCBlobInputStreamChild(
    PIPCBlobInputStreamChild* aActor) {
  RefPtr<IPCBlobInputStreamChild> actor =
      dont_AddRef(static_cast<IPCBlobInputStreamChild*>(aActor));
  return true;
}

PChildToParentStreamChild* nsIContentChild::AllocPChildToParentStreamChild() {
  MOZ_CRASH("PChildToParentStreamChild actors should be manually constructed!");
}

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

PParentToChildStreamChild* nsIContentChild::AllocPParentToChildStreamChild() {
  return mozilla::ipc::AllocPParentToChildStreamChild();
}

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

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

bool nsIContentChild::DeallocPFileDescriptorSetChild(
    PFileDescriptorSetChild* aActor) {
  delete static_cast<FileDescriptorSetChild*>(aActor);
  return true;
}

mozilla::ipc::IPCResult nsIContentChild::RecvAsyncMessage(
    const nsString& aMsg, InfallibleTArray<CpowEntry>&& aCpows,
    const IPC::Principal& aPrincipal, const ClonedMessageData& aData) {
  AUTO_PROFILER_LABEL_DYNAMIC_LOSSY_NSSTRING(
      "nsIContentChild::RecvAsyncMessage", OTHER, aMsg);
  MMPrinter::Print("nsIContentChild::RecvAsyncMessage", aMsg, aData);

  CrossProcessCpowHolder cpows(this, aCpows);
  RefPtr<nsFrameMessageManager> cpm =
      nsFrameMessageManager::GetChildProcessManager();
  if (cpm) {
    ipc::StructuredCloneData data;
    ipc::UnpackClonedMessageDataForChild(aData, data);

    cpm->ReceiveMessage(cpm, nullptr, aMsg, false, &data, &cpows, aPrincipal,
                        nullptr, IgnoreErrors());
  }
  return IPC_OK();
}

/* static */
already_AddRefed<nsIEventTarget> nsIContentChild::GetConstructedEventTarget(
    const IPC::Message& aMsg) {
  ActorHandle handle;
  TabId tabId, sameTabGroupAs;
  PickleIterator iter(aMsg);
  if (!IPC::ReadParam(&aMsg, &iter, &handle)) {
    return nullptr;
  }
  aMsg.IgnoreSentinel(&iter);
  if (!IPC::ReadParam(&aMsg, &iter, &tabId)) {
    return nullptr;
  }
  aMsg.IgnoreSentinel(&iter);
  if (!IPC::ReadParam(&aMsg, &iter, &sameTabGroupAs)) {
    return nullptr;
  }

  // If sameTabGroupAs is non-zero, then the new tab will be in the same
  // TabGroup as a previously created tab. Rather than try to find the
  // previously created tab (whose constructor message may not even have been
  // processed yet, in theory) and look up its event target, we just use the
  // default event target. This means that runnables for this tab will not be
  // labeled. However, this path is only taken for print preview and view
  // source, which are not performance-sensitive.
  if (sameTabGroupAs) {
    return nullptr;
  }

  // If the request for a new TabChild is coming from the parent process, then
  // there is no opener. Therefore, we create a fresh TabGroup.
  RefPtr<TabGroup> tabGroup = new TabGroup();
  nsCOMPtr<nsIEventTarget> target =
      tabGroup->EventTargetFor(TaskCategory::Other);
  return target.forget();
}

}  // namespace dom
}  // namespace mozilla