Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 187 insertions, 0 deletions

diff --git a/gfx/layers/ipc/ContentCompositorBridgeParent.h b/gfx/layers/ipc/ContentCompositorBridgeParent.h
new file mode 100644
index 0000000000..77836eac55
--- /dev/null
+++ b/gfx/layers/ipc/ContentCompositorBridgeParent.h
@@ -0,0 +1,187 @@
+/* -*- 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_ContentCompositorBridgeParent_h
+#define mozilla_layers_ContentCompositorBridgeParent_h
+
+#include "mozilla/layers/CanvasTranslator.h"
+#include "mozilla/layers/CompositorBridgeParent.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/UniquePtr.h"
+
+namespace mozilla::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 ContentCompositorBridgeParent final : public CompositorBridgeParentBase {
+  friend class CompositorBridgeParent;
+
+ public:
+  explicit ContentCompositorBridgeParent(CompositorManagerParent* aManager)
+      : CompositorBridgeParentBase(aManager), mDestroyCalled(false) {}
+
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  // FIXME/bug 774388: work out what shutdown protocol we need.
+  mozilla::ipc::IPCResult RecvInitialize(
+      const LayersId& aRootLayerTreeId) override {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  mozilla::ipc::IPCResult RecvWillClose() override { return IPC_OK(); }
+  mozilla::ipc::IPCResult RecvPause() override { return IPC_OK(); }
+  mozilla::ipc::IPCResult RecvRequestFxrOutput() override {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  mozilla::ipc::IPCResult RecvResume() override { return IPC_OK(); }
+  mozilla::ipc::IPCResult RecvResumeAsync() override { return IPC_OK(); }
+  mozilla::ipc::IPCResult RecvNotifyChildCreated(
+      const LayersId& child, CompositorOptions* aOptions) override;
+  mozilla::ipc::IPCResult RecvMapAndNotifyChildCreated(
+      const LayersId& child, const base::ProcessId& pid,
+      CompositorOptions* aOptions) override;
+  mozilla::ipc::IPCResult RecvNotifyChildRecreated(
+      const LayersId& child, CompositorOptions* aOptions) override {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  mozilla::ipc::IPCResult RecvAdoptChild(const LayersId& child) override {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  mozilla::ipc::IPCResult RecvFlushRendering(
+      const wr::RenderReasons&) override {
+    return IPC_OK();
+  }
+  mozilla::ipc::IPCResult RecvFlushRenderingAsync(
+      const wr::RenderReasons&) override {
+    return IPC_OK();
+  }
+  mozilla::ipc::IPCResult RecvForcePresent(const wr::RenderReasons&) override {
+    return IPC_OK();
+  }
+  mozilla::ipc::IPCResult RecvWaitOnTransactionProcessed() override {
+    return IPC_OK();
+  }
+  mozilla::ipc::IPCResult RecvStartFrameTimeRecording(
+      const int32_t& aBufferSize, uint32_t* aOutStartIndex) override {
+    return IPC_OK();
+  }
+  mozilla::ipc::IPCResult RecvStopFrameTimeRecording(
+      const uint32_t& aStartIndex, nsTArray<float>* intervals) override {
+    return IPC_OK();
+  }
+
+  mozilla::ipc::IPCResult RecvNotifyMemoryPressure() override;
+
+  mozilla::ipc::IPCResult RecvCheckContentOnlyTDR(
+      const uint32_t& sequenceNum, bool* isContentOnlyTDR) override;
+
+  mozilla::ipc::IPCResult RecvBeginRecording(
+      const TimeStamp& aRecordingStart,
+      BeginRecordingResolver&& aResolve) override {
+    aResolve(false);
+    return IPC_OK();
+  }
+
+  mozilla::ipc::IPCResult RecvEndRecording(
+      EndRecordingResolver&& aResolve) override {
+    aResolve(Nothing());
+    return IPC_OK();
+  }
+
+  bool SetTestSampleTime(const LayersId& aId, const TimeStamp& aTime) override;
+  void LeaveTestMode(const LayersId& aId) override;
+  void SetTestAsyncScrollOffset(const LayersId& aLayersId,
+                                const ScrollableLayerGuid::ViewID& aScrollId,
+                                const CSSPoint& aPoint) override;
+  void SetTestAsyncZoom(const LayersId& aLayersId,
+                        const ScrollableLayerGuid::ViewID& aScrollId,
+                        const LayerToParentLayerScale& aZoom) override;
+  void FlushApzRepaints(const LayersId& aLayersId) override;
+  void GetAPZTestData(const LayersId& aLayersId,
+                      APZTestData* aOutData) override;
+  void GetFrameUniformity(const LayersId& aLayersId,
+                          FrameUniformityData* aOutData) override;
+  void SetConfirmedTargetAPZC(
+      const LayersId& aLayersId, const uint64_t& aInputBlockId,
+      nsTArray<ScrollableLayerGuid>&& aTargets) override;
+
+  // Use DidCompositeLocked if you already hold a lock on
+  // sIndirectLayerTreesLock; Otherwise use DidComposite, which would request
+  // the lock automatically.
+  void DidCompositeLocked(LayersId aId, const VsyncId& aVsyncId,
+                          TimeStamp& aCompositeStart, TimeStamp& aCompositeEnd);
+
+  PTextureParent* AllocPTextureParent(
+      const SurfaceDescriptor& aSharedData, ReadLockDescriptor& aReadLock,
+      const LayersBackend& aLayersBackend, const TextureFlags& aFlags,
+      const LayersId& aId, const uint64_t& aSerial,
+      const wr::MaybeExternalImageId& aExternalImageId) override;
+
+  bool DeallocPTextureParent(PTextureParent* actor) override;
+
+  mozilla::ipc::IPCResult RecvInitPCanvasParent(
+      Endpoint<PCanvasParent>&& aEndpoint) final;
+
+  mozilla::ipc::IPCResult RecvReleasePCanvasParent() final;
+
+  bool IsSameProcess() const override;
+
+  PCompositorWidgetParent* AllocPCompositorWidgetParent(
+      const CompositorWidgetInitData& aInitData) override {
+    // Not allowed.
+    return nullptr;
+  }
+  bool DeallocPCompositorWidgetParent(
+      PCompositorWidgetParent* aActor) override {
+    // Not allowed.
+    return false;
+  }
+
+  PAPZCTreeManagerParent* AllocPAPZCTreeManagerParent(
+      const LayersId& aLayersId) override;
+  bool DeallocPAPZCTreeManagerParent(PAPZCTreeManagerParent* aActor) override;
+
+  PAPZParent* AllocPAPZParent(const LayersId& aLayersId) override;
+  bool DeallocPAPZParent(PAPZParent* aActor) override;
+
+  PWebRenderBridgeParent* AllocPWebRenderBridgeParent(
+      const wr::PipelineId& aPipelineId, const LayoutDeviceIntSize& aSize,
+      const WindowKind& aWindowKind) override;
+  bool DeallocPWebRenderBridgeParent(PWebRenderBridgeParent* aActor) override;
+
+  void ObserveLayersUpdate(LayersId aLayersId, LayersObserverEpoch aEpoch,
+                           bool aActive) override;
+
+  bool IsRemote() const override { return true; }
+
+  UniquePtr<SurfaceDescriptor> LookupSurfaceDescriptorForClientTexture(
+      const int64_t aTextureId) final;
+
+ private:
+  // Private destructor, to discourage deletion outside of Release():
+  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<ContentCompositorBridgeParent> mSelfRef;
+
+  bool mDestroyCalled;
+
+  RefPtr<CanvasTranslator> mCanvasTranslator;
+};
+
+}  // namespace mozilla::layers
+
+#endif  // mozilla_layers_ContentCompositorBridgeParent_h