1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
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
|
