summaryrefslogtreecommitdiffstats
path: root/gfx/layers/ipc/LayerTransactionParent.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/LayerTransactionParent.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/LayerTransactionParent.h')
-rw-r--r--gfx/layers/ipc/LayerTransactionParent.h240
1 files changed, 240 insertions, 0 deletions
diff --git a/gfx/layers/ipc/LayerTransactionParent.h b/gfx/layers/ipc/LayerTransactionParent.h
new file mode 100644
index 000000000..d92aa0358
--- /dev/null
+++ b/gfx/layers/ipc/LayerTransactionParent.h
@@ -0,0 +1,240 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=8 et :
+ */
+/* 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_LAYERTRANSACTIONPARENT_H
+#define MOZILLA_LAYERS_LAYERTRANSACTIONPARENT_H
+
+#include <stddef.h> // for size_t
+#include <stdint.h> // for uint64_t, uint32_t
+#include "CompositableTransactionParent.h"
+#include "mozilla/Attributes.h" // for override
+#include "mozilla/ipc/SharedMemory.h" // for SharedMemory, etc
+#include "mozilla/layers/PLayerTransactionParent.h"
+#include "nsTArrayForwardDeclare.h" // for InfallibleTArray
+
+namespace mozilla {
+
+namespace ipc {
+class Shmem;
+} // namespace ipc
+
+namespace layout {
+class RenderFrameParent;
+} // namespace layout
+
+namespace layers {
+
+class Layer;
+class LayerManagerComposite;
+class ShadowLayerParent;
+class CompositableParent;
+class CompositorBridgeParentBase;
+
+class LayerTransactionParent final : public PLayerTransactionParent,
+ public CompositableParentManager,
+ public ShmemAllocator
+{
+ typedef mozilla::layout::RenderFrameParent RenderFrameParent;
+ typedef InfallibleTArray<Edit> EditArray;
+ typedef InfallibleTArray<OpDestroy> OpDestroyArray;
+ typedef InfallibleTArray<EditReply> EditReplyArray;
+ typedef InfallibleTArray<PluginWindowData> PluginsArray;
+
+public:
+ LayerTransactionParent(LayerManagerComposite* aManager,
+ CompositorBridgeParentBase* aBridge,
+ uint64_t aId);
+
+protected:
+ ~LayerTransactionParent();
+
+public:
+ void Destroy();
+
+ LayerManagerComposite* layer_manager() const { return mLayerManager; }
+
+ void SetLayerManager(LayerManagerComposite* aLayerManager);
+
+ uint64_t GetId() const { return mId; }
+ Layer* GetRoot() const { return mRoot; }
+
+ uint64_t GetChildEpoch() const { return mChildEpoch; }
+ bool ShouldParentObserveEpoch();
+
+ virtual ShmemAllocator* AsShmemAllocator() override { return this; }
+
+ virtual bool AllocShmem(size_t aSize,
+ ipc::SharedMemory::SharedMemoryType aType,
+ ipc::Shmem* aShmem) override;
+
+ virtual bool AllocUnsafeShmem(size_t aSize,
+ ipc::SharedMemory::SharedMemoryType aType,
+ ipc::Shmem* aShmem) override;
+
+ virtual void DeallocShmem(ipc::Shmem& aShmem) override;
+
+ virtual bool IsSameProcess() const override;
+
+ const uint64_t& GetPendingTransactionId() { return mPendingTransaction; }
+ void SetPendingTransactionId(uint64_t aId) { mPendingTransaction = aId; }
+
+ // CompositableParentManager
+ virtual void SendAsyncMessage(const InfallibleTArray<AsyncParentMessageData>& aMessage) override;
+
+ virtual void SendPendingAsyncMessages() override;
+
+ virtual void SetAboutToSendAsyncMessages() override;
+
+ virtual void NotifyNotUsed(PTextureParent* aTexture, uint64_t aTransactionId) override;
+
+ virtual base::ProcessId GetChildProcessId() override
+ {
+ return OtherPid();
+ }
+
+ void AddPendingCompositorUpdate() {
+ mPendingCompositorUpdates++;
+ }
+ void SetPendingCompositorUpdates(uint32_t aCount) {
+ // Only called after construction.
+ MOZ_ASSERT(mPendingCompositorUpdates == 0);
+ mPendingCompositorUpdates = aCount;
+ }
+ void AcknowledgeCompositorUpdate() {
+ MOZ_ASSERT(mPendingCompositorUpdates > 0);
+ mPendingCompositorUpdates--;
+ }
+
+protected:
+ virtual bool RecvShutdown() override;
+
+ virtual bool RecvPaintTime(const uint64_t& aTransactionId,
+ const TimeDuration& aPaintTime) override;
+
+ virtual bool RecvUpdate(EditArray&& cset,
+ OpDestroyArray&& aToDestroy,
+ const uint64_t& aFwdTransactionId,
+ const uint64_t& aTransactionId,
+ const TargetConfig& targetConfig,
+ PluginsArray&& aPlugins,
+ const bool& isFirstPaint,
+ const bool& scheduleComposite,
+ const uint32_t& paintSequenceNumber,
+ const bool& isRepeatTransaction,
+ const mozilla::TimeStamp& aTransactionStart,
+ const int32_t& aPaintSyncId,
+ EditReplyArray* reply) override;
+
+ virtual bool RecvUpdateNoSwap(EditArray&& cset,
+ OpDestroyArray&& aToDestroy,
+ const uint64_t& aFwdTransactionId,
+ const uint64_t& aTransactionId,
+ const TargetConfig& targetConfig,
+ PluginsArray&& aPlugins,
+ const bool& isFirstPaint,
+ const bool& scheduleComposite,
+ const uint32_t& paintSequenceNumber,
+ const bool& isRepeatTransaction,
+ const mozilla::TimeStamp& aTransactionStart,
+ const int32_t& aPaintSyncId) override;
+
+ virtual bool RecvSetLayerObserverEpoch(const uint64_t& aLayerObserverEpoch) override;
+
+ virtual bool RecvClearCachedResources() override;
+ virtual bool RecvForceComposite() override;
+ virtual bool RecvSetTestSampleTime(const TimeStamp& aTime) override;
+ virtual bool RecvLeaveTestMode() override;
+ virtual bool RecvGetAnimationOpacity(PLayerParent* aParent,
+ float* aOpacity,
+ bool* aHasAnimationOpacity) override;
+ virtual bool RecvGetAnimationTransform(PLayerParent* aParent,
+ MaybeTransform* aTransform)
+ override;
+ virtual bool RecvSetAsyncScrollOffset(const FrameMetrics::ViewID& aId,
+ const float& aX, const float& aY) override;
+ virtual bool RecvSetAsyncZoom(const FrameMetrics::ViewID& aId,
+ const float& aValue) override;
+ virtual bool RecvFlushApzRepaints() override;
+ virtual bool RecvGetAPZTestData(APZTestData* aOutData) override;
+ virtual bool RecvRequestProperty(const nsString& aProperty, float* aValue) override;
+ virtual bool RecvSetConfirmedTargetAPZC(const uint64_t& aBlockId,
+ nsTArray<ScrollableLayerGuid>&& aTargets) override;
+
+ virtual PLayerParent* AllocPLayerParent() override;
+ virtual bool DeallocPLayerParent(PLayerParent* actor) override;
+
+ virtual PCompositableParent* AllocPCompositableParent(const TextureInfo& aInfo) override;
+ virtual bool DeallocPCompositableParent(PCompositableParent* actor) override;
+
+ virtual void ActorDestroy(ActorDestroyReason why) override;
+
+ bool Attach(ShadowLayerParent* aLayerParent,
+ CompositableHost* aCompositable,
+ bool aIsAsyncVideo);
+
+ void AddIPDLReference() {
+ MOZ_ASSERT(mIPCOpen == false);
+ mIPCOpen = true;
+ AddRef();
+ }
+ void ReleaseIPDLReference() {
+ MOZ_ASSERT(mIPCOpen == true);
+ mIPCOpen = false;
+ Release();
+ }
+ friend class CompositorBridgeParent;
+ friend class CrossProcessCompositorBridgeParent;
+ friend class layout::RenderFrameParent;
+
+private:
+ RefPtr<LayerManagerComposite> mLayerManager;
+ CompositorBridgeParentBase* mCompositorBridge;
+ // Hold the root because it might be grafted under various
+ // containers in the "real" layer tree
+ RefPtr<Layer> mRoot;
+ // When this is nonzero, it refers to a layer tree owned by the
+ // compositor thread. It is always true that
+ // mId != 0 => mRoot == null
+ // because the "real tree" is owned by the compositor.
+ uint64_t mId;
+
+ // These fields keep track of the latest epoch values in the child and the
+ // parent. mChildEpoch is the latest epoch value received from the child.
+ // mParentEpoch is the latest epoch value that we have told TabParent about
+ // (via ObserveLayerUpdate).
+ uint64_t mChildEpoch;
+ uint64_t mParentEpoch;
+
+ uint64_t mPendingTransaction;
+
+ // Number of compositor updates we're waiting for the child to
+ // acknowledge.
+ uint32_t mPendingCompositorUpdates;
+
+ // When the widget/frame/browser stuff in this process begins its
+ // destruction process, we need to Disconnect() all the currently
+ // live shadow layers, because some of them might be orphaned from
+ // the layer tree. This happens in Destroy() above. After we
+ // Destroy() ourself, there's a window in which that information
+ // hasn't yet propagated back to the child side and it might still
+ // send us layer transactions. We want to ignore those transactions
+ // because they refer to "zombie layers" on this side. So, we track
+ // that state with |mDestroyed|. This is similar to, but separate
+ // from, |mLayerManager->IsDestroyed()|; we might have had Destroy()
+ // called on us but the mLayerManager might not be destroyed, or
+ // vice versa. In both cases though, we want to ignore shadow-layer
+ // transactions posted by the child.
+
+ bool mDestroyed;
+
+ bool mIPCOpen;
+};
+
+} // namespace layers
+} // namespace mozilla
+
+#endif // MOZILLA_LAYERS_LAYERTRANSACTIONPARENT_H