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
|
/* -*- 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 RecvEndRecordingToDisk(
EndRecordingToDiskResolver&& aResolve) override {
aResolve(false);
return IPC_OK();
}
mozilla::ipc::IPCResult RecvEndRecordingToMemory(
EndRecordingToMemoryResolver&& 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
|
