Commit f3274c2f authored by Nika Layzell's avatar Nika Layzell
Browse files

Bug 1522579 - Part 1: Remove PContentBridge, r=mccr8 

This actor won't be being used anymore, and acts only as a maintenance burden
for people working on this code (which we're doing pretty often these days!).

Differential Revision: https://phabricator.services.mozilla.com/D20549

--HG--
extra : moz-landing-system : lando
parent 68b57502

dom/base/nsContentUtils.cpp

+1 −0
Original line number Diff line number Diff line
@@ -44,6 +44,7 @@ 
#include "mozilla/DebugOnly.h"

#include "mozilla/LoadInfo.h"

#include "mozilla/dom/BlobURLProtocolHandler.h"

#include "mozilla/dom/ContentParent.h"

#include "mozilla/dom/ContentChild.h"

#include "mozilla/dom/CustomElementRegistry.h"

#include "mozilla/dom/Document.h"

dom/file/ipc/PIPCBlobInputStream.ipdl

+1 −2
Original line number Diff line number Diff line
@@ -5,7 +5,6 @@ 
include protocol PBackground;

include protocol PChildToParentStream;

include protocol PContent;

include protocol PContentBridge;

include protocol PFileDescriptorSet;

include protocol PParentToChildStream;
@@ -16,7 +15,7 @@ namespace ipc { 


protocol PIPCBlobInputStream

{

  manager PBackground or PContent or PContentBridge;

  manager PBackground or PContent;



parent:

  async StreamNeeded();

dom/ipc/ContentBridgeChild.cpp

deleted100644 → 0
+0 −182
Original line number Diff line number Diff line 
/* -*- 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

dom/ipc/ContentBridgeChild.h

deleted100644 → 0
+0 −114
Original line number Diff line number Diff line 
/* -*- 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_ContentBridgeChild_h

#define mozilla_dom_ContentBridgeChild_h



#include "mozilla/dom/PContentBridgeChild.h"

#include "mozilla/dom/nsIContentChild.h"



namespace mozilla {

namespace dom {



class ContentBridgeChild final : public PContentBridgeChild,

                                 public nsIContentChild {

  friend class PContentBridgeChild;



 public:

  explicit ContentBridgeChild();



  NS_DECL_ISUPPORTS



  static void Create(Endpoint<PContentBridgeChild>&& aEndpoint);



  virtual void ActorDestroy(ActorDestroyReason aWhy) override;

  void DeferredDestroy();



  virtual mozilla::ipc::IPCResult RecvAsyncMessage(

      const nsString& aMsg, InfallibleTArray<jsipc::CpowEntry>&& aCpows,

      const IPC::Principal& aPrincipal,

      const ClonedMessageData& aData) override;



  jsipc::CPOWManager* GetCPOWManager() override;



  virtual bool SendPBrowserConstructor(

      PBrowserChild* aActor, const TabId& aTabId, const TabId& aSameTabGroupAs,

      const IPCTabContext& aContext, const uint32_t& aChromeFlags,

      const ContentParentId& aCpID, const bool& aIsForBrowser) override;



  virtual mozilla::ipc::PFileDescriptorSetChild*

  SendPFileDescriptorSetConstructor(

      const mozilla::ipc::FileDescriptor&) override;



  virtual mozilla::ipc::PChildToParentStreamChild*

  SendPChildToParentStreamConstructor(

      mozilla::ipc::PChildToParentStreamChild*) override;



  mozilla::ipc::IPCResult RecvActivate(PBrowserChild* aTab);



  mozilla::ipc::IPCResult RecvDeactivate(PBrowserChild* aTab);



  virtual already_AddRefed<nsIEventTarget> GetEventTargetFor(

      TabChild* aTabChild) override;



  FORWARD_SHMEM_ALLOCATOR_TO(PContentBridgeChild)



 protected:

  virtual ~ContentBridgeChild();



  virtual PBrowserChild* AllocPBrowserChild(const TabId& aTabId,

                                            const TabId& aSameTabGroupAs,

                                            const IPCTabContext& aContext,

                                            const uint32_t& aChromeFlags,

                                            const ContentParentId& aCpID,

                                            const bool& aIsForBrowser) override;

  virtual bool DeallocPBrowserChild(PBrowserChild*) override;

  virtual mozilla::ipc::IPCResult RecvPBrowserConstructor(

      PBrowserChild* aCctor, const TabId& aTabId, const TabId& aSameTabGroupAs,

      const IPCTabContext& aContext, const uint32_t& aChromeFlags,

      const ContentParentId& aCpID, const bool& aIsForBrowser) override;



  virtual mozilla::jsipc::PJavaScriptChild* AllocPJavaScriptChild() override;

  virtual bool DeallocPJavaScriptChild(

      mozilla::jsipc::PJavaScriptChild*) override;



  virtual PIPCBlobInputStreamChild* AllocPIPCBlobInputStreamChild(

      const nsID& aID, const uint64_t& aSize) override;



  virtual bool DeallocPIPCBlobInputStreamChild(

      PIPCBlobInputStreamChild*) override;



  virtual mozilla::ipc::PChildToParentStreamChild*

  AllocPChildToParentStreamChild() override;



  virtual bool DeallocPChildToParentStreamChild(

      mozilla::ipc::PChildToParentStreamChild* aActor) override;



  virtual PParentToChildStreamChild* AllocPParentToChildStreamChild() override;



  virtual bool DeallocPParentToChildStreamChild(

      PParentToChildStreamChild* aActor) override;



  virtual PFileDescriptorSetChild* AllocPFileDescriptorSetChild(

      const mozilla::ipc::FileDescriptor& aFD) override;



  virtual bool DeallocPFileDescriptorSetChild(

      mozilla::ipc::PFileDescriptorSetChild* aActor) override;



  DISALLOW_EVIL_CONSTRUCTORS(ContentBridgeChild);



 private:

  virtual already_AddRefed<nsIEventTarget> GetConstructedEventTarget(

      const Message& aMsg) override;



 protected:  // members

  RefPtr<ContentBridgeChild> mSelfRef;

};



}  // namespace dom

}  // namespace mozilla



#endif  // mozilla_dom_ContentBridgeChild_h

dom/ipc/ContentBridgeParent.cpp

deleted100644 → 0
+0 −204
Original line number Diff line number Diff line 
/* -*- 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