summaryrefslogtreecommitdiffstats
path: root/gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'gfx/layers/ipc/CrossProcessCompositorBridgeParent.h')
-rw-r--r--gfx/layers/ipc/CrossProcessCompositorBridgeParent.h177
1 files changed, 177 insertions, 0 deletions
diff --git a/gfx/layers/ipc/CrossProcessCompositorBridgeParent.h b/gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
new file mode 100644
index 000000000..399969950
--- /dev/null
+++ b/gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
@@ -0,0 +1,177 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=2 et 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
+
+#include "mozilla/layers/CompositorBridgeParent.h"
+
+namespace mozilla {
+namespace layers {
+
+/**
+ * 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
+{
+ friend class CompositorBridgeParent;
+
+public:
+ explicit CrossProcessCompositorBridgeParent()
+ : mNotifyAfterRemotePaint(false)
+ , mDestroyCalled(false)
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ }
+
+ void Bind(Endpoint<PCompositorBridgeParent>&& aEndpoint) {
+ if (!aEndpoint.Bind(this)) {
+ return;
+ }
+ mSelfRef = this;
+ }
+
+ virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+
+ // FIXME/bug 774388: work out what shutdown protocol we need.
+ virtual bool RecvInitialize(const uint64_t& aRootLayerTreeId) override { return false; }
+ virtual bool RecvReset(nsTArray<LayersBackend>&& aBackendHints, bool* aResult, TextureFactoryIdentifier* aOutIdentifier) override { return false; }
+ virtual bool RecvRequestOverfill() override { return true; }
+ virtual bool RecvWillClose() override { return true; }
+ virtual bool RecvPause() override { return true; }
+ virtual bool RecvResume() override { return true; }
+ virtual bool RecvNotifyChildCreated(const uint64_t& child) override;
+ virtual bool RecvNotifyChildRecreated(const uint64_t& child) override { return false; }
+ virtual bool RecvAdoptChild(const uint64_t& child) override { return false; }
+ virtual bool RecvMakeSnapshot(const SurfaceDescriptor& aInSnapshot,
+ const gfx::IntRect& aRect) override
+ { return true; }
+ virtual bool RecvFlushRendering() override { return true; }
+ virtual bool RecvForcePresent() override { return true; }
+ virtual bool RecvNotifyRegionInvalidated(const nsIntRegion& aRegion) override { return true; }
+ virtual bool RecvStartFrameTimeRecording(const int32_t& aBufferSize, uint32_t* aOutStartIndex) override { return true; }
+ virtual bool RecvStopFrameTimeRecording(const uint32_t& aStartIndex, InfallibleTArray<float>* intervals) override { return true; }
+
+ virtual bool RecvClearApproximatelyVisibleRegions(const uint64_t& aLayersId,
+ const uint32_t& aPresShellId) override;
+
+ virtual bool RecvNotifyApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid,
+ const CSSIntRegion& aRegion) override;
+
+ virtual bool RecvAllPluginsCaptured() override { return true; }
+
+ virtual bool RecvGetFrameUniformity(FrameUniformityData* aOutData) override
+ {
+ // Don't support calculating frame uniformity on the child process and
+ // this is just a stub for now.
+ MOZ_ASSERT(false);
+ return true;
+ }
+
+ /**
+ * Tells this CompositorBridgeParent to send a message when the compositor has received the transaction.
+ */
+ virtual bool RecvRequestNotifyAfterRemotePaint() override;
+
+ virtual PLayerTransactionParent*
+ AllocPLayerTransactionParent(const nsTArray<LayersBackend>& aBackendHints,
+ const uint64_t& aId,
+ TextureFactoryIdentifier* aTextureFactoryIdentifier,
+ bool *aSuccess) override;
+
+ virtual bool DeallocPLayerTransactionParent(PLayerTransactionParent* aLayers) override;
+
+ virtual void ShadowLayersUpdated(LayerTransactionParent* aLayerTree,
+ const uint64_t& aTransactionId,
+ const TargetConfig& aTargetConfig,
+ const InfallibleTArray<PluginWindowData>& aPlugins,
+ bool aIsFirstPaint,
+ bool aScheduleComposite,
+ uint32_t aPaintSequenceNumber,
+ bool aIsRepeatTransaction,
+ int32_t /*aPaintSyncId: unused*/,
+ bool aHitTestUpdate) override;
+ virtual void ForceComposite(LayerTransactionParent* aLayerTree) override;
+ virtual void NotifyClearCachedResources(LayerTransactionParent* aLayerTree) override;
+ virtual bool SetTestSampleTime(LayerTransactionParent* aLayerTree,
+ const TimeStamp& aTime) override;
+ virtual void LeaveTestMode(LayerTransactionParent* aLayerTree) override;
+ virtual void ApplyAsyncProperties(LayerTransactionParent* aLayerTree)
+ override;
+ virtual void FlushApzRepaints(const LayerTransactionParent* aLayerTree) override;
+ virtual void GetAPZTestData(const LayerTransactionParent* aLayerTree,
+ APZTestData* aOutData) override;
+ virtual void SetConfirmedTargetAPZC(const LayerTransactionParent* aLayerTree,
+ const uint64_t& aInputBlockId,
+ const nsTArray<ScrollableLayerGuid>& aTargets) override;
+
+ virtual AsyncCompositionManager* GetCompositionManager(LayerTransactionParent* aParent) override;
+ virtual bool RecvRemotePluginsReady() override { return false; }
+ virtual bool RecvAcknowledgeCompositorUpdate(const uint64_t& aLayersId) override;
+
+ void DidComposite(uint64_t aId,
+ TimeStamp& aCompositeStart,
+ TimeStamp& aCompositeEnd);
+
+ virtual PTextureParent* AllocPTextureParent(const SurfaceDescriptor& aSharedData,
+ const LayersBackend& aLayersBackend,
+ const TextureFlags& aFlags,
+ const uint64_t& aId,
+ const uint64_t& aSerial) override;
+
+ virtual bool DeallocPTextureParent(PTextureParent* actor) override;
+
+ virtual bool IsSameProcess() const override;
+
+ PCompositorWidgetParent* AllocPCompositorWidgetParent(const CompositorWidgetInitData& aInitData) override {
+ // Not allowed.
+ return nullptr;
+ }
+ bool DeallocPCompositorWidgetParent(PCompositorWidgetParent* aActor) override {
+ // Not allowed.
+ return false;
+ }
+
+ virtual bool RecvAsyncPanZoomEnabled(const uint64_t& aLayersId, bool* aHasAPZ) override;
+
+ virtual PAPZCTreeManagerParent* AllocPAPZCTreeManagerParent(const uint64_t& aLayersId) override;
+ virtual bool DeallocPAPZCTreeManagerParent(PAPZCTreeManagerParent* aActor) override;
+
+ virtual PAPZParent* AllocPAPZParent(const uint64_t& aLayersId) override;
+ virtual bool DeallocPAPZParent(PAPZParent* aActor) override;
+
+ virtual void UpdatePaintTime(LayerTransactionParent* aLayerTree, const TimeDuration& aPaintTime) override;
+
+protected:
+ void OnChannelConnected(int32_t pid) override {
+ mCompositorThreadHolder = CompositorThreadHolder::GetSingleton();
+ }
+private:
+ // Private destructor, to discourage deletion outside of Release():
+ virtual ~CrossProcessCompositorBridgeParent();
+
+ 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<CompositorThreadHolder> mCompositorThreadHolder;
+ // 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