Bug 1531528 - Rename CrossProcessCompositorBridgeParent to ContentCompositorBridgeParent. r=mattwoodrow
authorRyan Hunt <rhunt@eqrion.net>
Sun, 03 Mar 2019 21:02:25 +0000
changeset 523152 774a5ee90bae16072134941ebefab18f203ffe74
parent 523151 fa641ad0f4b8aeb31237ab51ef5ce5797ac56b82
child 523153 031a1548a83cfcef87cc0d0834f8a2d8c6ea4c6c
push id2032
push userffxbld-merge
push dateMon, 13 May 2019 09:36:57 +0000
treeherdermozilla-release@455c1065dcbe [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmattwoodrow
bugs1531528
milestone67.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1531528 - Rename CrossProcessCompositorBridgeParent to ContentCompositorBridgeParent. r=mattwoodrow Differential Revision: https://phabricator.services.mozilla.com/D21714
gfx/layers/ipc/CompositorBridgeParent.cpp
gfx/layers/ipc/CompositorBridgeParent.h
gfx/layers/ipc/CompositorManagerParent.cpp
gfx/layers/ipc/ContentCompositorBridgeParent.cpp
gfx/layers/ipc/ContentCompositorBridgeParent.h
gfx/layers/ipc/CrossProcessCompositorBridgeParent.cpp
gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
gfx/layers/ipc/LayerTransactionParent.h
gfx/layers/moz.build
gfx/layers/wr/WebRenderBridgeParent.cpp
--- a/gfx/layers/ipc/CompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CompositorBridgeParent.cpp
@@ -46,17 +46,17 @@
 #include "mozilla/layers/AsyncCompositionManager.h"
 #include "mozilla/layers/BasicCompositor.h"          // for BasicCompositor
 #include "mozilla/layers/Compositor.h"               // for Compositor
 #include "mozilla/layers/CompositorManagerParent.h"  // for CompositorManagerParent
 #include "mozilla/layers/CompositorOGL.h"            // for CompositorOGL
 #include "mozilla/layers/CompositorThread.h"
 #include "mozilla/layers/CompositorTypes.h"
 #include "mozilla/layers/CompositorVsyncScheduler.h"
-#include "mozilla/layers/CrossProcessCompositorBridgeParent.h"
+#include "mozilla/layers/ContentCompositorBridgeParent.h"
 #include "mozilla/layers/FrameUniformityData.h"
 #include "mozilla/layers/ImageBridgeParent.h"
 #include "mozilla/layers/LayerManagerComposite.h"
 #include "mozilla/layers/LayerManagerMLGPU.h"
 #include "mozilla/layers/LayerTreeOwnerTracker.h"
 #include "mozilla/layers/LayersTypes.h"
 #include "mozilla/layers/PLayerTransactionParent.h"
 #include "mozilla/layers/RemoteContentController.h"
@@ -1647,17 +1647,17 @@ mozilla::ipc::IPCResult CompositorBridge
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult CompositorBridgeParent::RecvAdoptChild(
     const LayersId& child) {
   RefPtr<APZUpdater> oldApzUpdater;
   APZCTreeManagerParent* parent;
   bool scheduleComposition = false;
-  RefPtr<CrossProcessCompositorBridgeParent> cpcp;
+  RefPtr<ContentCompositorBridgeParent> cpcp;
   RefPtr<WebRenderBridgeParent> childWrBridge;
 
   {  // scope lock
     MonitorAutoLock lock(*sIndirectLayerTreesLock);
     // If child is already belong to this CompositorBridgeParent,
     // no need to handle adopting child.
     if (sIndirectLayerTrees[child].mParent == this) {
       return IPC_OK();
@@ -2116,32 +2116,32 @@ void CompositorBridgeParent::NotifyDidCo
       Unused << ImageBridgeParent::NotifyImageComposites(notifications);
     }
   }
 
   MonitorAutoLock lock(*sIndirectLayerTreesLock);
   ForEachIndirectLayerTree([&](LayerTreeState* lts,
                                const LayersId& aLayersId) -> void {
     if (lts->mCrossProcessParent && lts->mParent == this) {
-      CrossProcessCompositorBridgeParent* cpcp = lts->mCrossProcessParent;
+      ContentCompositorBridgeParent* cpcp = lts->mCrossProcessParent;
       cpcp->DidCompositeLocked(aLayersId, aId, aCompositeStart, aCompositeEnd);
     }
   });
 }
 
 void CompositorBridgeParent::InvalidateRemoteLayers() {
   MOZ_ASSERT(CompositorLoop() == MessageLoop::current());
 
   Unused << PCompositorBridgeParent::SendInvalidateLayers(LayersId{0});
 
   MonitorAutoLock lock(*sIndirectLayerTreesLock);
   ForEachIndirectLayerTree(
       [](LayerTreeState* lts, const LayersId& aLayersId) -> void {
         if (lts->mCrossProcessParent) {
-          CrossProcessCompositorBridgeParent* cpcp = lts->mCrossProcessParent;
+          ContentCompositorBridgeParent* cpcp = lts->mCrossProcessParent;
           Unused << cpcp->SendInvalidateLayers(aLayersId);
         }
       });
 }
 
 static void UpdateIndirectTree(LayersId aId, Layer* aRoot,
                                const TargetConfig& aTargetConfig) {
   MonitorAutoLock lock(*sIndirectLayerTreesLock);
--- a/gfx/layers/ipc/CompositorBridgeParent.h
+++ b/gfx/layers/ipc/CompositorBridgeParent.h
@@ -76,17 +76,17 @@ class Compositor;
 class CompositorAnimationStorage;
 class CompositorBridgeParent;
 class CompositorManagerParent;
 class CompositorVsyncScheduler;
 class HostLayerManager;
 class IAPZCTreeManager;
 class LayerTransactionParent;
 class PAPZParent;
-class CrossProcessCompositorBridgeParent;
+class ContentCompositorBridgeParent;
 class CompositorThreadHolder;
 class InProcessCompositorSession;
 class WebRenderBridgeParent;
 
 struct ScopedLayerTreeRegistration {
   ScopedLayerTreeRegistration(APZCTreeManager* aApzctm, LayersId aLayersId,
                               Layer* aRoot,
                               GeckoContentController* aController);
@@ -332,17 +332,17 @@ class CompositorBridgeParent final : pub
       const uint32_t& aStartIndex, InfallibleTArray<float>* intervals) override;
 
   mozilla::ipc::IPCResult RecvCheckContentOnlyTDR(
       const uint32_t& sequenceNum, bool* isContentOnlyTDR) override {
     return IPC_OK();
   }
 
   // Unused for chrome <-> compositor communication (which this class does).
-  // @see CrossProcessCompositorBridgeParent::RecvRequestNotifyAfterRemotePaint
+  // @see ContentCompositorBridgeParent::RecvRequestNotifyAfterRemotePaint
   mozilla::ipc::IPCResult RecvRequestNotifyAfterRemotePaint() override {
     return IPC_OK();
   };
 
   mozilla::ipc::IPCResult RecvAllPluginsCaptured() override;
 
   virtual void NotifyMemoryPressure() override;
   virtual void AccumulateMemoryReport(wr::MemoryReport*) override;
@@ -488,20 +488,20 @@ class CompositorBridgeParent final : pub
     LayerTreeState();
     ~LayerTreeState();
     RefPtr<Layer> mRoot;
     RefPtr<GeckoContentController> mController;
     APZCTreeManagerParent* mApzcTreeManagerParent;
     RefPtr<CompositorBridgeParent> mParent;
     HostLayerManager* mLayerManager;
     RefPtr<WebRenderBridgeParent> mWrBridge;
-    // Pointer to the CrossProcessCompositorBridgeParent. Used by APZCs to share
+    // Pointer to the ContentCompositorBridgeParent. Used by APZCs to share
     // their FrameMetrics with the corresponding child process that holds
     // the PCompositorBridgeChild
-    CrossProcessCompositorBridgeParent* mCrossProcessParent;
+    ContentCompositorBridgeParent* mCrossProcessParent;
     TargetConfig mTargetConfig;
     LayerTransactionParent* mLayerTree;
     nsTArray<PluginWindowData> mPluginData;
     bool mUpdatedPluginDataAvailable;
 
     CompositorController* GetCompositorController() const;
     MetricsSharingController* CrossProcessSharingController() const;
     MetricsSharingController* InProcessSharingController() const;
@@ -576,17 +576,17 @@ class CompositorBridgeParent final : pub
   virtual void ForceComposeToTarget(
       gfx::DrawTarget* aTarget, const gfx::IntRect* aRect = nullptr) override;
 
   PAPZCTreeManagerParent* AllocPAPZCTreeManagerParent(
       const LayersId& aLayersId) override;
   bool DeallocPAPZCTreeManagerParent(PAPZCTreeManagerParent* aActor) override;
 
   // Helper method so that we don't have to expose mApzcTreeManager to
-  // CrossProcessCompositorBridgeParent.
+  // ContentCompositorBridgeParent.
   void AllocateAPZCTreeManagerParent(
       const MonitorAutoLock& aProofOfLayerTreeStateLock,
       const LayersId& aLayersId, LayerTreeState& aLayerTreeStateToUpdate);
 
   PAPZParent* AllocPAPZParent(const LayersId& aLayersId) override;
   bool DeallocPAPZParent(PAPZParent* aActor) override;
 
 #if defined(MOZ_WIDGET_ANDROID)
--- a/gfx/layers/ipc/CompositorManagerParent.cpp
+++ b/gfx/layers/ipc/CompositorManagerParent.cpp
@@ -3,17 +3,17 @@
 /* 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/layers/CompositorManagerParent.h"
 #include "mozilla/gfx/GPUParent.h"
 #include "mozilla/webrender/RenderThread.h"
 #include "mozilla/layers/CompositorBridgeParent.h"
-#include "mozilla/layers/CrossProcessCompositorBridgeParent.h"
+#include "mozilla/layers/ContentCompositorBridgeParent.h"
 #include "mozilla/layers/CompositorThread.h"
 #include "mozilla/layers/SharedSurfacesParent.h"
 #include "nsAutoPtr.h"
 #include "VsyncSource.h"
 
 namespace mozilla {
 namespace layers {
 
@@ -197,18 +197,18 @@ void CompositorManagerParent::Shutdown()
       []() -> void { CompositorManagerParent::ShutdownInternal(); }));
 #endif
 }
 
 PCompositorBridgeParent* CompositorManagerParent::AllocPCompositorBridgeParent(
     const CompositorBridgeOptions& aOpt) {
   switch (aOpt.type()) {
     case CompositorBridgeOptions::TContentCompositorOptions: {
-      CrossProcessCompositorBridgeParent* bridge =
-          new CrossProcessCompositorBridgeParent(this);
+      ContentCompositorBridgeParent* bridge =
+          new ContentCompositorBridgeParent(this);
       bridge->AddRef();
       return bridge;
     }
     case CompositorBridgeOptions::TWidgetCompositorOptions: {
       // Only the UI process is allowed to create widget compositors in the
       // compositor process.
       gfx::GPUParent* gpu = gfx::GPUParent::GetSingleton();
       if (NS_WARN_IF(!gpu || OtherPid() != gpu->OtherPid())) {
rename from gfx/layers/ipc/CrossProcessCompositorBridgeParent.cpp
rename to gfx/layers/ipc/ContentCompositorBridgeParent.cpp
--- a/gfx/layers/ipc/CrossProcessCompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/ContentCompositorBridgeParent.cpp
@@ -1,15 +1,15 @@
 /* -*- 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/layers/CrossProcessCompositorBridgeParent.h"
+#include "mozilla/layers/ContentCompositorBridgeParent.h"
 
 #include <stdint.h>  // for uint64_t
 
 #include "LayerTransactionParent.h"   // for LayerTransactionParent
 #include "apz/src/APZCTreeManager.h"  // for APZCTreeManager
 #include "base/message_loop.h"        // for MessageLoop
 #include "base/task.h"                // for CancelableTask, etc
 #include "base/thread.h"              // for Thread
@@ -46,33 +46,33 @@ namespace layers {
 typedef map<LayersId, CompositorBridgeParent::LayerTreeState> LayerTreeMap;
 extern LayerTreeMap sIndirectLayerTrees;
 extern StaticAutoPtr<mozilla::Monitor> sIndirectLayerTreesLock;
 void UpdateIndirectTree(LayersId aId, Layer* aRoot,
                         const TargetConfig& aTargetConfig);
 void EraseLayerState(LayersId aId);
 
 mozilla::ipc::IPCResult
-CrossProcessCompositorBridgeParent::RecvRequestNotifyAfterRemotePaint() {
+ContentCompositorBridgeParent::RecvRequestNotifyAfterRemotePaint() {
   mNotifyAfterRemotePaint = true;
   return IPC_OK();
 }
 
-void CrossProcessCompositorBridgeParent::ActorDestroy(ActorDestroyReason aWhy) {
+void ContentCompositorBridgeParent::ActorDestroy(ActorDestroyReason aWhy) {
   mCanSend = false;
 
   // We must keep this object alive untill the code handling message
   // reception is finished on this thread.
   MessageLoop::current()->PostTask(NewRunnableMethod(
-      "layers::CrossProcessCompositorBridgeParent::DeferredDestroy", this,
-      &CrossProcessCompositorBridgeParent::DeferredDestroy));
+      "layers::ContentCompositorBridgeParent::DeferredDestroy", this,
+      &ContentCompositorBridgeParent::DeferredDestroy));
 }
 
 PLayerTransactionParent*
-CrossProcessCompositorBridgeParent::AllocPLayerTransactionParent(
+ContentCompositorBridgeParent::AllocPLayerTransactionParent(
     const nsTArray<LayersBackend>&, const LayersId& aId) {
   MOZ_ASSERT(aId.IsValid());
 
   // Check to see if this child process has access to this layer tree.
   if (!LayerTreeOwnerTracker::Get()->IsMapped(aId, OtherPid())) {
     NS_ERROR(
         "Unexpected layers id in AllocPLayerTransactionParent; dropping "
         "message...");
@@ -104,26 +104,26 @@ CrossProcessCompositorBridgeParent::Allo
   NS_WARNING("Created child without a matching parent?");
   LayerTransactionParent* p = new LayerTransactionParent(
       /* aManager */ nullptr, this, /* aAnimStorage */ nullptr, aId,
       TimeDuration());
   p->AddIPDLReference();
   return p;
 }
 
-bool CrossProcessCompositorBridgeParent::DeallocPLayerTransactionParent(
+bool ContentCompositorBridgeParent::DeallocPLayerTransactionParent(
     PLayerTransactionParent* aLayers) {
   LayerTransactionParent* slp = static_cast<LayerTransactionParent*>(aLayers);
   EraseLayerState(slp->GetId());
   static_cast<LayerTransactionParent*>(aLayers)->ReleaseIPDLReference();
   return true;
 }
 
 PAPZCTreeManagerParent*
-CrossProcessCompositorBridgeParent::AllocPAPZCTreeManagerParent(
+ContentCompositorBridgeParent::AllocPAPZCTreeManagerParent(
     const LayersId& aLayersId) {
   // Check to see if this child process has access to this layer tree.
   if (!LayerTreeOwnerTracker::Get()->IsMapped(aLayersId, OtherPid())) {
     NS_ERROR(
         "Unexpected layers id in AllocPAPZCTreeManagerParent; dropping "
         "message...");
     return nullptr;
   }
@@ -143,34 +143,34 @@ CrossProcessCompositorBridgeParent::Allo
     RefPtr<APZUpdater> tempUpdater = new APZUpdater(temp, false);
     tempUpdater->ClearTree(dummyId);
     return new APZCTreeManagerParent(aLayersId, temp, tempUpdater);
   }
 
   state.mParent->AllocateAPZCTreeManagerParent(lock, aLayersId, state);
   return state.mApzcTreeManagerParent;
 }
-bool CrossProcessCompositorBridgeParent::DeallocPAPZCTreeManagerParent(
+bool ContentCompositorBridgeParent::DeallocPAPZCTreeManagerParent(
     PAPZCTreeManagerParent* aActor) {
   APZCTreeManagerParent* parent = static_cast<APZCTreeManagerParent*>(aActor);
 
   MonitorAutoLock lock(*sIndirectLayerTreesLock);
   auto iter = sIndirectLayerTrees.find(parent->GetLayersId());
   if (iter != sIndirectLayerTrees.end()) {
     CompositorBridgeParent::LayerTreeState& state = iter->second;
     MOZ_ASSERT(state.mApzcTreeManagerParent == parent);
     state.mApzcTreeManagerParent = nullptr;
   }
 
   delete parent;
 
   return true;
 }
 
-PAPZParent* CrossProcessCompositorBridgeParent::AllocPAPZParent(
+PAPZParent* ContentCompositorBridgeParent::AllocPAPZParent(
     const LayersId& aLayersId) {
   // Check to see if this child process has access to this layer tree.
   if (!LayerTreeOwnerTracker::Get()->IsMapped(aLayersId, OtherPid())) {
     NS_ERROR("Unexpected layers id in AllocPAPZParent; dropping message...");
     return nullptr;
   }
 
   RemoteContentController* controller = new RemoteContentController();
@@ -183,25 +183,25 @@ PAPZParent* CrossProcessCompositorBridge
   CompositorBridgeParent::LayerTreeState& state =
       sIndirectLayerTrees[aLayersId];
   MOZ_ASSERT(!state.mController);
   state.mController = controller;
 
   return controller;
 }
 
-bool CrossProcessCompositorBridgeParent::DeallocPAPZParent(PAPZParent* aActor) {
+bool ContentCompositorBridgeParent::DeallocPAPZParent(PAPZParent* aActor) {
   RemoteContentController* controller =
       static_cast<RemoteContentController*>(aActor);
   controller->Release();
   return true;
 }
 
 PWebRenderBridgeParent*
-CrossProcessCompositorBridgeParent::AllocPWebRenderBridgeParent(
+ContentCompositorBridgeParent::AllocPWebRenderBridgeParent(
     const wr::PipelineId& aPipelineId, const LayoutDeviceIntSize& aSize) {
 #ifndef MOZ_BUILD_WEBRENDER
   // Extra guard since this in the parent process and we don't want a malicious
   // child process invoking this codepath before it's ready
   MOZ_RELEASE_ASSERT(false);
 #endif
   LayersId layersId = wr::AsLayersId(aPipelineId);
   // Check to see if this child process has access to this layer tree.
@@ -256,56 +256,54 @@ CrossProcessCompositorBridgeParent::Allo
     MonitorAutoLock lock(*sIndirectLayerTreesLock);
     sIndirectLayerTrees[layersId].mCrossProcessParent = this;
     sIndirectLayerTrees[layersId].mWrBridge = parent;
   }
 
   return parent;
 }
 
-bool CrossProcessCompositorBridgeParent::DeallocPWebRenderBridgeParent(
+bool ContentCompositorBridgeParent::DeallocPWebRenderBridgeParent(
     PWebRenderBridgeParent* aActor) {
 #ifndef MOZ_BUILD_WEBRENDER
   // Extra guard since this in the parent process and we don't want a malicious
   // child process invoking this codepath before it's ready
   MOZ_RELEASE_ASSERT(false);
 #endif
   WebRenderBridgeParent* parent = static_cast<WebRenderBridgeParent*>(aActor);
   EraseLayerState(wr::AsLayersId(parent->PipelineId()));
   parent->Release();  // IPDL reference
   return true;
 }
 
-mozilla::ipc::IPCResult
-CrossProcessCompositorBridgeParent::RecvNotifyChildCreated(
+mozilla::ipc::IPCResult ContentCompositorBridgeParent::RecvNotifyChildCreated(
     const LayersId& child, CompositorOptions* aOptions) {
   MonitorAutoLock lock(*sIndirectLayerTreesLock);
   for (LayerTreeMap::iterator it = sIndirectLayerTrees.begin();
        it != sIndirectLayerTrees.end(); it++) {
     CompositorBridgeParent::LayerTreeState* lts = &it->second;
     if (lts->mParent && lts->mCrossProcessParent == this) {
       lts->mParent->NotifyChildCreated(child);
       *aOptions = lts->mParent->GetOptions();
       return IPC_OK();
     }
   }
   return IPC_FAIL_NO_REASON(this);
 }
 
 mozilla::ipc::IPCResult
-CrossProcessCompositorBridgeParent::RecvMapAndNotifyChildCreated(
+ContentCompositorBridgeParent::RecvMapAndNotifyChildCreated(
     const LayersId& child, const base::ProcessId& pid,
     CompositorOptions* aOptions) {
   // This can only be called from the browser process, as the mapping
   // ensures proper window ownership of layer trees.
   return IPC_FAIL_NO_REASON(this);
 }
 
-mozilla::ipc::IPCResult
-CrossProcessCompositorBridgeParent::RecvCheckContentOnlyTDR(
+mozilla::ipc::IPCResult ContentCompositorBridgeParent::RecvCheckContentOnlyTDR(
     const uint32_t& sequenceNum, bool* isContentOnlyTDR) {
   *isContentOnlyTDR = false;
 #ifdef XP_WIN
   ContentDeviceData compositor;
 
   DeviceManagerDx* dm = DeviceManagerDx::Get();
 
   // Check that the D3D11 device sequence numbers match.
@@ -315,17 +313,17 @@ CrossProcessCompositorBridgeParent::Recv
   if (sequenceNum == status.sequenceNumber() && !dm->HasDeviceReset()) {
     *isContentOnlyTDR = true;
   }
 
 #endif
   return IPC_OK();
 };
 
-void CrossProcessCompositorBridgeParent::ShadowLayersUpdated(
+void ContentCompositorBridgeParent::ShadowLayersUpdated(
     LayerTransactionParent* aLayerTree, const TransactionInfo& aInfo,
     bool aHitTestUpdate) {
   LayersId id = aLayerTree->GetId();
 
   MOZ_ASSERT(id.IsValid());
 
   CompositorBridgeParent::LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(id);
@@ -393,188 +391,185 @@ void CrossProcessCompositorBridgeParent:
   RegisterPayload(aLayerTree, aInfo.payload());
 
   aLayerTree->SetPendingTransactionId(
       aInfo.id(), aInfo.vsyncId(), aInfo.vsyncStart(), aInfo.refreshStart(),
       aInfo.transactionStart(), endTime, aInfo.containsSVG(), aInfo.url(),
       aInfo.fwdTime());
 }
 
-void CrossProcessCompositorBridgeParent::DidCompositeLocked(
+void ContentCompositorBridgeParent::DidCompositeLocked(
     LayersId aId, const VsyncId& aVsyncId, TimeStamp& aCompositeStart,
     TimeStamp& aCompositeEnd) {
   sIndirectLayerTreesLock->AssertCurrentThreadOwns();
   if (LayerTransactionParent* layerTree = sIndirectLayerTrees[aId].mLayerTree) {
     TransactionId transactionId =
         layerTree->FlushTransactionId(aVsyncId, aCompositeEnd);
     if (transactionId.IsValid()) {
       Unused << SendDidComposite(aId, transactionId, aCompositeStart,
                                  aCompositeEnd);
     }
   } else if (sIndirectLayerTrees[aId].mWrBridge) {
     MOZ_ASSERT(false);  // this should never get called for a WR compositor
   }
 }
 
-void CrossProcessCompositorBridgeParent::ScheduleComposite(
+void ContentCompositorBridgeParent::ScheduleComposite(
     LayerTransactionParent* aLayerTree) {
   LayersId id = aLayerTree->GetId();
   MOZ_ASSERT(id.IsValid());
   CompositorBridgeParent* parent;
   {  // scope lock
     MonitorAutoLock lock(*sIndirectLayerTreesLock);
     parent = sIndirectLayerTrees[id].mParent;
   }
   if (parent) {
     parent->ScheduleComposite(aLayerTree);
   }
 }
 
-void CrossProcessCompositorBridgeParent::NotifyClearCachedResources(
+void ContentCompositorBridgeParent::NotifyClearCachedResources(
     LayerTransactionParent* aLayerTree) {
   LayersId id = aLayerTree->GetId();
   MOZ_ASSERT(id.IsValid());
 
   const CompositorBridgeParent::LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(id);
   if (state && state->mParent) {
     // Note that we send this through the window compositor, since this needs
     // to reach the widget owning the tab.
     Unused << state->mParent->SendObserveLayersUpdate(
         id, aLayerTree->GetChildEpoch(), false);
   }
 }
 
-bool CrossProcessCompositorBridgeParent::SetTestSampleTime(
-    const LayersId& aId, const TimeStamp& aTime) {
+bool ContentCompositorBridgeParent::SetTestSampleTime(const LayersId& aId,
+                                                      const TimeStamp& aTime) {
   MOZ_ASSERT(aId.IsValid());
   const CompositorBridgeParent::LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(aId);
   if (!state) {
     return false;
   }
 
   MOZ_ASSERT(state->mParent);
   return state->mParent->SetTestSampleTime(aId, aTime);
 }
 
-void CrossProcessCompositorBridgeParent::LeaveTestMode(const LayersId& aId) {
+void ContentCompositorBridgeParent::LeaveTestMode(const LayersId& aId) {
   MOZ_ASSERT(aId.IsValid());
   const CompositorBridgeParent::LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(aId);
   if (!state) {
     return;
   }
 
   MOZ_ASSERT(state->mParent);
   state->mParent->LeaveTestMode(aId);
 }
 
-void CrossProcessCompositorBridgeParent::ApplyAsyncProperties(
+void ContentCompositorBridgeParent::ApplyAsyncProperties(
     LayerTransactionParent* aLayerTree, TransformsToSkip aSkip) {
   LayersId id = aLayerTree->GetId();
   MOZ_ASSERT(id.IsValid());
   const CompositorBridgeParent::LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(id);
   if (!state) {
     return;
   }
 
   MOZ_ASSERT(state->mParent);
   state->mParent->ApplyAsyncProperties(aLayerTree, aSkip);
 }
 
-void CrossProcessCompositorBridgeParent::SetTestAsyncScrollOffset(
+void ContentCompositorBridgeParent::SetTestAsyncScrollOffset(
     const LayersId& aLayersId, const ScrollableLayerGuid::ViewID& aScrollId,
     const CSSPoint& aPoint) {
   MOZ_ASSERT(aLayersId.IsValid());
   const CompositorBridgeParent::LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(aLayersId);
   if (!state) {
     return;
   }
 
   MOZ_ASSERT(state->mParent);
   state->mParent->SetTestAsyncScrollOffset(aLayersId, aScrollId, aPoint);
 }
 
-void CrossProcessCompositorBridgeParent::SetTestAsyncZoom(
+void ContentCompositorBridgeParent::SetTestAsyncZoom(
     const LayersId& aLayersId, const ScrollableLayerGuid::ViewID& aScrollId,
     const LayerToParentLayerScale& aZoom) {
   MOZ_ASSERT(aLayersId.IsValid());
   const CompositorBridgeParent::LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(aLayersId);
   if (!state) {
     return;
   }
 
   MOZ_ASSERT(state->mParent);
   state->mParent->SetTestAsyncZoom(aLayersId, aScrollId, aZoom);
 }
 
-void CrossProcessCompositorBridgeParent::FlushApzRepaints(
+void ContentCompositorBridgeParent::FlushApzRepaints(
     const LayersId& aLayersId) {
   MOZ_ASSERT(aLayersId.IsValid());
   const CompositorBridgeParent::LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(aLayersId);
   if (!state || !state->mParent) {
     return;
   }
 
   state->mParent->FlushApzRepaints(aLayersId);
 }
 
-void CrossProcessCompositorBridgeParent::GetAPZTestData(
-    const LayersId& aLayersId, APZTestData* aOutData) {
+void ContentCompositorBridgeParent::GetAPZTestData(const LayersId& aLayersId,
+                                                   APZTestData* aOutData) {
   MOZ_ASSERT(aLayersId.IsValid());
   const CompositorBridgeParent::LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(aLayersId);
   if (!state || !state->mParent) {
     return;
   }
 
   state->mParent->GetAPZTestData(aLayersId, aOutData);
 }
 
-void CrossProcessCompositorBridgeParent::SetConfirmedTargetAPZC(
+void ContentCompositorBridgeParent::SetConfirmedTargetAPZC(
     const LayersId& aLayersId, const uint64_t& aInputBlockId,
     const nsTArray<ScrollableLayerGuid>& aTargets) {
   MOZ_ASSERT(aLayersId.IsValid());
   const CompositorBridgeParent::LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(aLayersId);
   if (!state || !state->mParent) {
     return;
   }
 
   state->mParent->SetConfirmedTargetAPZC(aLayersId, aInputBlockId, aTargets);
 }
 
-AsyncCompositionManager*
-CrossProcessCompositorBridgeParent::GetCompositionManager(
+AsyncCompositionManager* ContentCompositorBridgeParent::GetCompositionManager(
     LayerTransactionParent* aLayerTree) {
   LayersId id = aLayerTree->GetId();
   const CompositorBridgeParent::LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(id);
   if (!state) {
     return nullptr;
   }
 
   MOZ_ASSERT(state->mParent);
   return state->mParent->GetCompositionManager(aLayerTree);
 }
 
-void CrossProcessCompositorBridgeParent::DeferredDestroy() {
-  mSelfRef = nullptr;
-}
+void ContentCompositorBridgeParent::DeferredDestroy() { mSelfRef = nullptr; }
 
-CrossProcessCompositorBridgeParent::~CrossProcessCompositorBridgeParent() {
+ContentCompositorBridgeParent::~ContentCompositorBridgeParent() {
   MOZ_ASSERT(XRE_GetIOMessageLoop());
 }
 
-PTextureParent* CrossProcessCompositorBridgeParent::AllocPTextureParent(
+PTextureParent* ContentCompositorBridgeParent::AllocPTextureParent(
     const SurfaceDescriptor& aSharedData, const ReadLockDescriptor& aReadLock,
     const LayersBackend& aLayersBackend, const TextureFlags& aFlags,
     const LayersId& aId, const uint64_t& aSerial,
     const wr::MaybeExternalImageId& aExternalImageId) {
   CompositorBridgeParent::LayerTreeState* state = nullptr;
 
   LayerTreeMap::iterator itr = sIndirectLayerTrees.find(aId);
   if (sIndirectLayerTrees.end() != itr) {
@@ -601,55 +596,55 @@ PTextureParent* CrossProcessCompositorBr
         << "Texture backend is wrong";
   }
 
   return TextureHost::CreateIPDLActor(this, aSharedData, aReadLock,
                                       aLayersBackend, aFlags, aSerial,
                                       aExternalImageId);
 }
 
-bool CrossProcessCompositorBridgeParent::DeallocPTextureParent(
+bool ContentCompositorBridgeParent::DeallocPTextureParent(
     PTextureParent* actor) {
   return TextureHost::DestroyIPDLActor(actor);
 }
 
-bool CrossProcessCompositorBridgeParent::IsSameProcess() const {
+bool ContentCompositorBridgeParent::IsSameProcess() const {
   return OtherPid() == base::GetCurrentProcId();
 }
 
-void CrossProcessCompositorBridgeParent::UpdatePaintTime(
+void ContentCompositorBridgeParent::UpdatePaintTime(
     LayerTransactionParent* aLayerTree, const TimeDuration& aPaintTime) {
   LayersId id = aLayerTree->GetId();
   MOZ_ASSERT(id.IsValid());
 
   CompositorBridgeParent::LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(id);
   if (!state || !state->mParent) {
     return;
   }
 
   state->mParent->UpdatePaintTime(aLayerTree, aPaintTime);
 }
 
-void CrossProcessCompositorBridgeParent::RegisterPayload(
+void ContentCompositorBridgeParent::RegisterPayload(
     LayerTransactionParent* aLayerTree,
     const InfallibleTArray<CompositionPayload>& aPayload) {
   LayersId id = aLayerTree->GetId();
   MOZ_ASSERT(id.IsValid());
 
   CompositorBridgeParent::LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(id);
   if (!state || !state->mParent) {
     return;
   }
 
   state->mParent->RegisterPayload(aLayerTree, aPayload);
 }
 
-void CrossProcessCompositorBridgeParent::ObserveLayersUpdate(
+void ContentCompositorBridgeParent::ObserveLayersUpdate(
     LayersId aLayersId, LayersObserverEpoch aEpoch, bool aActive) {
   MOZ_ASSERT(aLayersId.IsValid());
 
   CompositorBridgeParent::LayerTreeState* state =
       CompositorBridgeParent::GetIndirectShadowTree(aLayersId);
   if (!state || !state->mParent) {
     return;
   }
rename from gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
rename to gfx/layers/ipc/ContentCompositorBridgeParent.h
--- a/gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
+++ b/gfx/layers/ipc/ContentCompositorBridgeParent.h
@@ -1,38 +1,37 @@
 /* -*- 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_layers_CrossProcessCompositorBridgeParent_h
-#define mozilla_layers_CrossProcessCompositorBridgeParent_h
+#ifndef mozilla_layers_ContentCompositorBridgeParent_h
+#define mozilla_layers_ContentCompositorBridgeParent_h
 
 #include "mozilla/layers/CompositorBridgeParent.h"
 #include "mozilla/layers/CompositorThread.h"
 
 namespace mozilla {
 namespace layers {
 
 class CompositorOptions;
 
 /**
  * This class handles layer updates pushed directly from child processes to
  * the compositor thread. It's associated with a CompositorBridgeParent on the
  * compositor thread. While it uses the PCompositorBridge protocol to manage
  * these updates, it doesn't actually drive compositing itself. For that it
  * hands off work to the CompositorBridgeParent it's associated with.
  */
-class CrossProcessCompositorBridgeParent final
-    : public CompositorBridgeParentBase {
+class ContentCompositorBridgeParent final : public CompositorBridgeParentBase {
   friend class CompositorBridgeParent;
 
  public:
-  explicit CrossProcessCompositorBridgeParent(CompositorManagerParent* aManager)
+  explicit ContentCompositorBridgeParent(CompositorManagerParent* aManager)
       : CompositorBridgeParentBase(aManager),
         mNotifyAfterRemotePaint(false),
         mDestroyCalled(false) {}
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
   // FIXME/bug 774388: work out what shutdown protocol we need.
   mozilla::ipc::IPCResult RecvInitialize(
@@ -181,27 +180,27 @@ class CrossProcessCompositorBridgeParent
 
   void ObserveLayersUpdate(LayersId aLayersId, LayersObserverEpoch aEpoch,
                            bool aActive) override;
 
   bool IsRemote() const override { return true; }
 
  private:
   // Private destructor, to discourage deletion outside of Release():
-  virtual ~CrossProcessCompositorBridgeParent();
+  virtual ~ContentCompositorBridgeParent();
 
   void DeferredDestroy();
 
   // There can be many CPCPs, and IPDL-generated code doesn't hold a
   // reference to top-level actors.  So we hold a reference to
   // ourself.  This is released (deferred) in ActorDestroy().
-  RefPtr<CrossProcessCompositorBridgeParent> mSelfRef;
+  RefPtr<ContentCompositorBridgeParent> mSelfRef;
 
   // If true, we should send a RemotePaintIsReady message when the layer
   // transaction is received
   bool mNotifyAfterRemotePaint;
   bool mDestroyCalled;
 };
 
 }  // namespace layers
 }  // namespace mozilla
 
-#endif  // mozilla_layers_CrossProcessCompositorBridgeParent_h
+#endif  // mozilla_layers_ContentCompositorBridgeParent_h
--- a/gfx/layers/ipc/LayerTransactionParent.h
+++ b/gfx/layers/ipc/LayerTransactionParent.h
@@ -157,17 +157,17 @@ class LayerTransactionParent final : pub
     AddRef();
   }
   void ReleaseIPDLReference() {
     MOZ_ASSERT(mIPCOpen == true);
     mIPCOpen = false;
     Release();
   }
   friend class CompositorBridgeParent;
-  friend class CrossProcessCompositorBridgeParent;
+  friend class ContentCompositorBridgeParent;
 
  private:
   // This is a function so we can log or breakpoint on why hit
   // testing tree changes are made.
   void UpdateHitTestingTree(Layer* aLayer, const char* aWhy) {
     mUpdateHitTestingTree = true;
   }
 
--- a/gfx/layers/moz.build
+++ b/gfx/layers/moz.build
@@ -177,17 +177,17 @@ EXPORTS.mozilla.layers += [
     'ipc/CompositableTransactionParent.h',
     'ipc/CompositorBridgeChild.h',
     'ipc/CompositorBridgeParent.h',
     'ipc/CompositorManagerChild.h',
     'ipc/CompositorManagerParent.h',
     'ipc/CompositorThread.h',
     'ipc/CompositorVsyncScheduler.h',
     'ipc/CompositorVsyncSchedulerOwner.h',
-    'ipc/CrossProcessCompositorBridgeParent.h',
+    'ipc/ContentCompositorBridgeParent.h',
     'ipc/ImageBridgeChild.h',
     'ipc/ImageBridgeParent.h',
     'ipc/ISurfaceAllocator.h',
     'ipc/KnowsCompositor.h',
     'ipc/LayerAnimationUtils.h',
     'ipc/LayersMessageUtils.h',
     'ipc/LayerTransactionChild.h',
     'ipc/LayerTransactionParent.h',
@@ -420,17 +420,17 @@ UNIFIED_SOURCES += [
     'ipc/CompositableTransactionParent.cpp',
     'ipc/CompositorBench.cpp',
     'ipc/CompositorBridgeChild.cpp',
     'ipc/CompositorBridgeParent.cpp',
     'ipc/CompositorManagerChild.cpp',
     'ipc/CompositorManagerParent.cpp',
     'ipc/CompositorThread.cpp',
     'ipc/CompositorVsyncScheduler.cpp',
-    'ipc/CrossProcessCompositorBridgeParent.cpp',
+    'ipc/ContentCompositorBridgeParent.cpp',
     'ipc/ImageBridgeChild.cpp',
     'ipc/ImageBridgeParent.cpp',
     'ipc/ISurfaceAllocator.cpp',
     'ipc/LayerAnimationUtils.cpp',
     'ipc/LayerTransactionChild.cpp',
     'ipc/LayerTransactionParent.cpp',
     'ipc/LayerTreeOwnerTracker.cpp',
     'ipc/RefCountedShmem.cpp',
--- a/gfx/layers/wr/WebRenderBridgeParent.cpp
+++ b/gfx/layers/wr/WebRenderBridgeParent.cpp
@@ -775,17 +775,17 @@ CompositorBridgeParent* WebRenderBridgeP
 
   if (IsRootWebRenderBridgeParent()) {
     // This WebRenderBridgeParent is attached to the root
     // CompositorBridgeParent.
     return static_cast<CompositorBridgeParent*>(mCompositorBridge);
   }
 
   // Otherwise, this WebRenderBridgeParent is attached to a
-  // CrossProcessCompositorBridgeParent so we have an extra level of
+  // ContentCompositorBridgeParent so we have an extra level of
   // indirection to unravel.
   CompositorBridgeParent::LayerTreeState* lts =
       CompositorBridgeParent::GetIndirectShadowTree(GetLayersId());
   if (!lts) {
     return nullptr;
   }
   return lts->mParent;
 }