3 files changed, 253 insertions, 0 deletions
diff --git a/layout/ipc/RemoteLayerTreeOwner.cpp b/layout/ipc/RemoteLayerTreeOwner.cpp
new file mode 100644
index 0000000000..0ab05c8000
--- /dev/null
+++ b/layout/ipc/RemoteLayerTreeOwner.cpp
@@ -0,0 +1,138 @@
+/* -*- 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 "base/basictypes.h"
+
+#include "mozilla/PresShell.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/layers/CompositorBridgeParent.h"
+#include "mozilla/layers/CompositorTypes.h"
+#include "nsFrameLoader.h"
+#include "nsStyleStructInlines.h"
+#include "nsSubDocumentFrame.h"
+#include "RemoteLayerTreeOwner.h"
+#include "mozilla/gfx/GPUProcessManager.h"
+#include "mozilla/layers/CompositorBridgeChild.h"
+#include "mozilla/layers/WebRenderLayerManager.h"
+#include "mozilla/layers/WebRenderScrollData.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "mozilla/dom/EffectsInfo.h"
+
+using namespace mozilla::dom;
+using namespace mozilla::gfx;
+using namespace mozilla::layers;
+
+namespace mozilla {
+namespace layout {
+
+static already_AddRefed<WindowRenderer> GetWindowRenderer(
+    BrowserParent* aBrowserParent) {
+  RefPtr<WindowRenderer> renderer;
+  if (Element* element = aBrowserParent->GetOwnerElement()) {
+    renderer = nsContentUtils::WindowRendererForContent(element);
+    if (renderer) {
+      return renderer.forget();
+    }
+    renderer = nsContentUtils::WindowRendererForDocument(element->OwnerDoc());
+    if (renderer) {
+      return renderer.forget();
+    }
+  }
+  return nullptr;
+}
+
+RemoteLayerTreeOwner::RemoteLayerTreeOwner()
+    : mLayersId{0},
+      mBrowserParent(nullptr),
+      mInitialized(false),
+      mLayersConnected(false) {}
+
+RemoteLayerTreeOwner::~RemoteLayerTreeOwner() = default;
+
+bool RemoteLayerTreeOwner::Initialize(BrowserParent* aBrowserParent) {
+  if (mInitialized || !aBrowserParent) {
+    return false;
+  }
+
+  mBrowserParent = aBrowserParent;
+  RefPtr<WindowRenderer> renderer = GetWindowRenderer(mBrowserParent);
+  PCompositorBridgeChild* compositor =
+      renderer ? renderer->GetCompositorBridgeChild() : nullptr;
+  mTabProcessId = mBrowserParent->Manager()->OtherPid();
+
+  // Our remote frame will push layers updates to the compositor,
+  // and we'll keep an indirect reference to that tree.
+  GPUProcessManager* gpm = GPUProcessManager::Get();
+  mLayersConnected = gpm->AllocateAndConnectLayerTreeId(
+      compositor, mTabProcessId, &mLayersId, &mCompositorOptions);
+
+  mInitialized = true;
+  return true;
+}
+
+void RemoteLayerTreeOwner::Destroy() {
+  if (mLayersId.IsValid()) {
+    GPUProcessManager::Get()->UnmapLayerTreeId(mLayersId, mTabProcessId);
+  }
+
+  mBrowserParent = nullptr;
+  mWindowRenderer = nullptr;
+}
+
+void RemoteLayerTreeOwner::EnsureLayersConnected(
+    CompositorOptions* aCompositorOptions) {
+  RefPtr<WindowRenderer> renderer = GetWindowRenderer(mBrowserParent);
+  if (!renderer) {
+    return;
+  }
+
+  if (!renderer->GetCompositorBridgeChild()) {
+    return;
+  }
+
+  mLayersConnected =
+      renderer->GetCompositorBridgeChild()->SendNotifyChildRecreated(
+          mLayersId, &mCompositorOptions);
+  *aCompositorOptions = mCompositorOptions;
+}
+
+bool RemoteLayerTreeOwner::AttachWindowRenderer() {
+  RefPtr<WindowRenderer> renderer;
+  if (mBrowserParent) {
+    renderer = GetWindowRenderer(mBrowserParent);
+  }
+
+  // Perhaps the document containing this frame currently has no presentation?
+  if (renderer && renderer->GetCompositorBridgeChild() &&
+      renderer != mWindowRenderer) {
+    mLayersConnected =
+        renderer->GetCompositorBridgeChild()->SendAdoptChild(mLayersId);
+  }
+
+  mWindowRenderer = std::move(renderer);
+  return !!mWindowRenderer;
+}
+
+void RemoteLayerTreeOwner::OwnerContentChanged() {
+  Unused << AttachWindowRenderer();
+}
+
+void RemoteLayerTreeOwner::GetTextureFactoryIdentifier(
+    TextureFactoryIdentifier* aTextureFactoryIdentifier) const {
+  RefPtr<WindowRenderer> renderer =
+      mBrowserParent ? GetWindowRenderer(mBrowserParent) : nullptr;
+  // Perhaps the document containing this frame currently has no presentation?
+  if (renderer && renderer->AsWebRender()) {
+    *aTextureFactoryIdentifier =
+        renderer->AsWebRender()->GetTextureFactoryIdentifier();
+  } else {
+    *aTextureFactoryIdentifier = TextureFactoryIdentifier();
+  }
+}
+
+}  // namespace layout
+}  // namespace mozilla
diff --git a/layout/ipc/RemoteLayerTreeOwner.h b/layout/ipc/RemoteLayerTreeOwner.h
new file mode 100644
index 0000000000..6a19dc293e
--- /dev/null
+++ b/layout/ipc/RemoteLayerTreeOwner.h
@@ -0,0 +1,88 @@
+/* -*- 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_layout_RemoteLayerTreeOwner_h
+#define mozilla_layout_RemoteLayerTreeOwner_h
+
+#include "base/process.h"
+
+#include "mozilla/Attributes.h"
+
+#include "mozilla/dom/ipc/IdType.h"
+#include "mozilla/layers/CompositorOptions.h"
+#include "mozilla/layers/LayersTypes.h"
+#include "nsDisplayList.h"
+
+class nsFrameLoader;
+class nsSubDocumentFrame;
+
+namespace mozilla {
+
+namespace dom {
+class BrowserParent;
+}  // namespace dom
+
+namespace layers {
+struct TextureFactoryIdentifier;
+}  // namespace layers
+
+namespace layout {
+
+/**
+ * RemoteLayerTreeOwner connects and manages layer trees for remote frames. It
+ * is directly owned by a BrowserParent and always lives in the parent process.
+ */
+class RemoteLayerTreeOwner final {
+  typedef mozilla::layers::CompositorOptions CompositorOptions;
+  typedef mozilla::layers::LayerManager LayerManager;
+  typedef mozilla::layers::LayersId LayersId;
+  typedef mozilla::layers::TextureFactoryIdentifier TextureFactoryIdentifier;
+
+ public:
+  RemoteLayerTreeOwner();
+  virtual ~RemoteLayerTreeOwner();
+
+  bool Initialize(dom::BrowserParent* aBrowserParent);
+  void Destroy();
+
+  void EnsureLayersConnected(CompositorOptions* aCompositorOptions);
+  bool AttachWindowRenderer();
+  void OwnerContentChanged();
+
+  LayersId GetLayersId() const { return mLayersId; }
+  CompositorOptions GetCompositorOptions() const { return mCompositorOptions; }
+
+  void GetTextureFactoryIdentifier(
+      TextureFactoryIdentifier* aTextureFactoryIdentifier) const;
+
+  bool IsInitialized() const { return mInitialized; }
+  bool IsLayersConnected() const { return mLayersConnected; }
+
+ private:
+  // The process id of the remote frame. This is used by the compositor to
+  // do security checks on incoming layer transactions.
+  base::ProcessId mTabProcessId;
+  // The layers id of the remote frame.
+  LayersId mLayersId;
+  // The compositor options for this layers id. This is only meaningful if
+  // the compositor actually knows about this layers id (i.e. when
+  // mLayersConnected is true).
+  CompositorOptions mCompositorOptions;
+
+  dom::BrowserParent* mBrowserParent;
+  RefPtr<WindowRenderer> mWindowRenderer;
+
+  bool mInitialized;
+  // A flag that indicates whether or not the compositor knows about the
+  // layers id. In some cases this RemoteLayerTreeOwner is not connected to the
+  // compositor and so this flag is false.
+  bool mLayersConnected;
+};
+
+}  // namespace layout
+}  // namespace mozilla
+
+#endif  // mozilla_layout_RemoteLayerTreeOwner_h
diff --git a/layout/ipc/moz.build b/layout/ipc/moz.build
new file mode 100644
index 0000000000..fcb6b477b1
--- /dev/null
+++ b/layout/ipc/moz.build
@@ -0,0 +1,27 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+with Files("**"):
+    BUG_COMPONENT = ("Core", "Web Painting")
+
+EXPORTS.mozilla.layout += [
+    "RemoteLayerTreeOwner.h",
+]
+
+UNIFIED_SOURCES += [
+    "RemoteLayerTreeOwner.cpp",
+]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+FINAL_LIBRARY = "xul"
+
+LOCAL_INCLUDES += [
+    "/dom/base",
+    "/layout/base",
+    "/layout/generic",
+    "/layout/xul",
+]