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
|
/* -*- 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_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 "nsRefPtrHashtable.h"
#include "nsTArrayForwardDeclare.h" // for nsTArray
namespace mozilla {
namespace ipc {
class Shmem;
} // namespace ipc
namespace layers {
class Layer;
class HostLayerManager;
class ShadowLayerParent;
class CompositableParent;
class CompositorAnimationStorage;
class CompositorBridgeParentBase;
class LayerTransactionParent final : public PLayerTransactionParent,
public CompositableParentManager,
public mozilla::ipc::IShmemAllocator {
typedef nsTArray<Edit> EditArray;
typedef nsTArray<OpDestroy> OpDestroyArray;
typedef nsTArray<PluginWindowData> PluginsArray;
friend class PLayerTransactionParent;
public:
LayerTransactionParent(HostLayerManager* aManager,
CompositorBridgeParentBase* aBridge,
CompositorAnimationStorage* aAnimStorage, LayersId aId,
TimeDuration aVsyncRate);
protected:
virtual ~LayerTransactionParent();
public:
void Destroy();
void SetLayerManager(HostLayerManager* aLayerManager,
CompositorAnimationStorage* aAnimStorage);
LayersId GetId() const { return mId; }
Layer* GetRoot() const { return mRoot; }
LayersObserverEpoch GetChildEpoch() const { return mChildEpoch; }
bool ShouldParentObserveEpoch();
IShmemAllocator* AsShmemAllocator() override { return this; }
bool AllocShmem(size_t aSize, ipc::SharedMemory::SharedMemoryType aType,
ipc::Shmem* aShmem) override;
bool AllocUnsafeShmem(size_t aSize, ipc::SharedMemory::SharedMemoryType aType,
ipc::Shmem* aShmem) override;
bool DeallocShmem(ipc::Shmem& aShmem) override;
bool IsSameProcess() const override;
void SetPendingTransactionId(TransactionId aId, const VsyncId& aVsyncId,
const TimeStamp& aVsyncStartTime,
const TimeStamp& aRefreshStartTime,
const TimeStamp& aTxnStartTime,
const TimeStamp& aTxnEndTime, bool aContainsSVG,
const nsCString& aURL,
const TimeStamp& aFwdTime);
TransactionId FlushTransactionId(const VsyncId& aId,
TimeStamp& aCompositeEnd);
// CompositableParentManager
void SendAsyncMessage(
const nsTArray<AsyncParentMessageData>& aMessage) override;
void SendPendingAsyncMessages() override;
void SetAboutToSendAsyncMessages() override;
void NotifyNotUsed(PTextureParent* aTexture,
uint64_t aTransactionId) override;
base::ProcessId GetChildProcessId() override { return OtherPid(); }
protected:
mozilla::ipc::IPCResult RecvShutdown();
mozilla::ipc::IPCResult RecvShutdownSync();
mozilla::ipc::IPCResult RecvPaintTime(const TransactionId& aTransactionId,
const TimeDuration& aPaintTime);
mozilla::ipc::IPCResult RecvUpdate(const TransactionInfo& aInfo);
mozilla::ipc::IPCResult RecvSetLayersObserverEpoch(
const LayersObserverEpoch& aChildEpoch);
mozilla::ipc::IPCResult RecvNewCompositable(const CompositableHandle& aHandle,
const TextureInfo& aInfo);
mozilla::ipc::IPCResult RecvReleaseLayer(const LayerHandle& aHandle);
mozilla::ipc::IPCResult RecvReleaseCompositable(
const CompositableHandle& aHandle);
mozilla::ipc::IPCResult RecvClearCachedResources();
mozilla::ipc::IPCResult RecvScheduleComposite();
mozilla::ipc::IPCResult RecvSetTestSampleTime(const TimeStamp& aTime);
mozilla::ipc::IPCResult RecvLeaveTestMode();
mozilla::ipc::IPCResult RecvGetAnimationValue(
const uint64_t& aCompositorAnimationsId, OMTAValue* aValue);
mozilla::ipc::IPCResult RecvGetTransform(const LayerHandle& aHandle,
Maybe<Matrix4x4>* aTransform);
mozilla::ipc::IPCResult RecvSetAsyncScrollOffset(
const ScrollableLayerGuid::ViewID& aId, const float& aX, const float& aY);
mozilla::ipc::IPCResult RecvSetAsyncZoom(
const ScrollableLayerGuid::ViewID& aId, const float& aValue);
mozilla::ipc::IPCResult RecvFlushApzRepaints();
mozilla::ipc::IPCResult RecvGetAPZTestData(APZTestData* aOutData);
mozilla::ipc::IPCResult RecvGetFrameUniformity(FrameUniformityData* aOutData);
mozilla::ipc::IPCResult RecvRequestProperty(const nsString& aProperty,
float* aValue);
mozilla::ipc::IPCResult RecvSetConfirmedTargetAPZC(
const uint64_t& aBlockId, nsTArray<ScrollableLayerGuid>&& aTargets);
mozilla::ipc::IPCResult RecvRecordPaintTimes(const PaintTiming& aTiming);
mozilla::ipc::IPCResult RecvGetTextureFactoryIdentifier(
TextureFactoryIdentifier* aIdentifier);
bool SetLayerAttributes(const OpSetLayerAttributes& aOp);
void ActorDestroy(ActorDestroyReason why) override;
template <typename T>
bool BindLayer(const RefPtr<Layer>& aLayer, const T& aCreateOp) {
return BindLayerToHandle(aLayer, aCreateOp.layer());
}
bool BindLayerToHandle(RefPtr<Layer> aLayer, const LayerHandle& aHandle);
Layer* AsLayer(const LayerHandle& aLayer);
bool Attach(Layer* aLayer, 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 ContentCompositorBridgeParent;
private:
// This is a function so we can log or breakpoint on why hit
// testing tree changes are made.
void UpdateHitTestingTree(Layer* aLayer, const char* aWhy) {
mUpdateHitTestingTree = true;
}
private:
RefPtr<HostLayerManager> mLayerManager;
CompositorBridgeParentBase* mCompositorBridge;
RefPtr<CompositorAnimationStorage> mAnimStorage;
// Hold the root because it might be grafted under various
// containers in the "real" layer tree
RefPtr<Layer> mRoot;
// Mapping from LayerHandles to Layers.
nsRefPtrHashtable<nsUint64HashKey, Layer> mLayerMap;
LayersId 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 BrowserParent
// about (via ObserveLayerUpdate).
LayersObserverEpoch mChildEpoch;
LayersObserverEpoch mParentEpoch;
TimeDuration mVsyncRate;
struct PendingTransaction {
TransactionId mId;
VsyncId mTxnVsyncId;
TimeStamp mVsyncStartTime;
TimeStamp mRefreshStartTime;
TimeStamp mTxnStartTime;
TimeStamp mTxnEndTime;
TimeStamp mFwdTime;
nsCString mTxnURL;
bool mContainsSVG;
};
AutoTArray<PendingTransaction, 2> mPendingTransactions;
// 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;
// This is set during RecvUpdate to track whether we'll need to update
// APZ's hit test regions.
bool mUpdateHitTestingTree;
};
} // namespace layers
} // namespace mozilla
#endif // MOZILLA_LAYERS_LAYERTRANSACTIONPARENT_H
|
