mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-20 08:45:46 +00:00
265e672179
# ignore-this-changeset --HG-- extra : amend_source : 4d301d3b0b8711c4692392aa76088ba7fd7d1022
205 lines
7.3 KiB
C++
205 lines
7.3 KiB
C++
/* -*- 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
|