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
|
/* -*- 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/. */
include LayersSurfaces;
include LayersMessages;
include PlatformWidgetTypes;
include protocol PAPZ;
include protocol PAPZCTreeManager;
include protocol PBrowser;
include protocol PCompositable;
include protocol PCompositorWidget;
include protocol PImageContainer;
include protocol PLayer;
include protocol PLayerTransaction;
include protocol PTexture;
include "mozilla/GfxMessageUtils.h";
using struct mozilla::null_t from "ipc/IPCMessageUtils.h";
using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h";
using struct mozilla::layers::FrameMetrics from "FrameMetrics.h";
using mozilla::layers::FrameMetrics::ViewID from "FrameMetrics.h";
using mozilla::layers::MaybeZoomConstraints from "FrameMetrics.h";
using struct mozilla::layers::ScrollableLayerGuid from "FrameMetrics.h";
using mozilla::layers::LayersBackend from "mozilla/layers/LayersTypes.h";
using mozilla::layers::TouchBehaviorFlags from "mozilla/layers/APZUtils.h";
using mozilla::CrossProcessMutexHandle from "mozilla/ipc/CrossProcessMutex.h";
using mozilla::ipc::SharedMemoryBasic::Handle from "mozilla/ipc/SharedMemoryBasic.h";
using mozilla::CSSIntRegion from "Units.h";
using mozilla::LayoutDeviceIntPoint from "Units.h";
using mozilla::LayoutDeviceIntRegion from "Units.h";
using class mozilla::TimeStamp from "mozilla/TimeStamp.h";
using class mozilla::layers::FrameUniformityData from "mozilla/layers/FrameUniformityData.h";
using mozilla::layers::TextureFlags from "mozilla/layers/CompositorTypes.h";
namespace mozilla {
namespace layers {
/**
* The PCompositorBridge protocol is used to manage communication between
* the main thread and the compositor thread context. It's primary
* purpose is to manage the PLayerTransaction sub protocol.
*/
sync protocol PCompositorBridge
{
manages PAPZ;
manages PAPZCTreeManager;
// A Compositor manages a single Layer Manager (PLayerTransaction)
manages PLayerTransaction;
manages PTexture;
manages PCompositorWidget;
child:
// The child should invalidate retained layers. This is used for local
// compositor device resets, such as in CompositorD3D9, and ensures that
// TextureSources are recreated.
async InvalidateLayers(uint64_t layersId);
// The compositor type or device has changed, and a new texture factory
// identifier is available. Layers must be invalidated and the new identifier
// must be propagated.
async CompositorUpdated(uint64_t layersId, TextureFactoryIdentifier newIdentifier);
// The compositor completed a layers transaction. id is the layers id
// of the child layer tree that was composited (or 0 when notifying
// the root layer tree).
// transactionId is the id of the transaction before this composite, or 0
// if there was no transaction since the last composite.
async DidComposite(uint64_t id, uint64_t transactionId,
TimeStamp compositeStart, TimeStamp compositeEnd);
// The parent sends the child the requested fill ratio numbers.
async Overfill(uint32_t aOverfill);
/**
* Parent informs the child that the graphics objects are ready for
* compositing. This usually means that the graphics objects (textures
* and the like) are available on the GPU. This is used for chrome UI.
* @see RequestNotifyAfterRemotePaint
* @see PBrowser
*/
async RemotePaintIsReady();
/**
* Bounce plugin widget configurations over to the main thread for
* application on the widgets. Used on Windows and Linux in managing
* plugin widgets.
*/
async UpdatePluginConfigurations(LayoutDeviceIntPoint aContentOffset,
LayoutDeviceIntRegion aVisibleRegion,
PluginWindowData[] aPlugins);
/**
* Captures an image for all visible child plugins of a given widget for use
* during scrolling.
* @param aParentWidget parent of widgets to be captured
*/
async CaptureAllPlugins(uintptr_t aParentWidget);
/**
* Hides all registered plugin widgets associated with a particular chrome
* widget.
*/
async HideAllPlugins(uintptr_t aParentWidget);
/**
* Drop any buffers that might be retained on the child compositor
* side.
*/
async ClearCachedResources(uint64_t id);
async ParentAsyncMessages(AsyncParentMessageData[] aMessages);
async ObserveLayerUpdate(uint64_t aLayersId, uint64_t aEpoch, bool aActive);
parent:
// Must be called before Initialize().
async PCompositorWidget(CompositorWidgetInitData aInitData);
// When out-of-process, this must be called to finish initialization.
sync Initialize(uint64_t rootLayerTreeId);
sync Reset(LayersBackend[] aBackendHints) returns (bool aResult, TextureFactoryIdentifier aOutIdentifier);
// Returns whether this Compositor has APZ enabled or not.
sync AsyncPanZoomEnabled(uint64_t layersId) returns (bool aHasAPZ);
// Must be called after Initialize(), and only succeeds if AsyncPanZoomEnabled() is true.
async PAPZ(uint64_t layersId);
async PAPZCTreeManager(uint64_t layersId);
/**
* Confirmation callback for UpdatePluginConfigurations and HideAllPlugins.
*/
async RemotePluginsReady();
// Confirmation that the child has invalidated all its layers, and will not
// request layers against an old compositor.
async AcknowledgeCompositorUpdate(uint64_t id);
// Child sends the parent a request for fill ratio numbers.
async RequestOverfill();
// Child requests frame uniformity measurements
sync GetFrameUniformity() returns (FrameUniformityData data);
// The child is about to be destroyed, so perform any necessary cleanup.
sync WillClose();
// Pause/resume the compositor. These are intended to be used on mobile, when
// the compositor needs to pause/resume in lockstep with the application.
sync Pause();
sync Resume();
// See bug 1316632 comment #33 for why this has to be sync. Otherwise,
// there are ordering issues with SendPLayerTransactionConstructor.
sync NotifyChildCreated(uint64_t id);
async AdoptChild(uint64_t id);
// Same as NotifyChildCreated, but used when child processes need to
// reassociate layers. This must be synchronous to ensure that the
// association happens before PLayerTransactions are sent over the
// cross-process bridge.
sync NotifyChildRecreated(uint64_t id);
// Make a snapshot of the content that would have been drawn to our
// render target at the time this message is received. If the size
// or format of |inSnapshot| doesn't match our render target,
// results are undefined.
//
// NB: this message will result in animations, transforms, effects,
// and so forth being interpolated. That's what we want to happen.
sync MakeSnapshot(SurfaceDescriptor inSnapshot, IntRect dirtyRect);
// Make sure any pending composites are started immediately and
// block until they are completed.
sync FlushRendering();
// Force an additional frame presentation to be executed. This is used to
// work around a windows presentation bug (See Bug 1232042)
async ForcePresent();
sync StartFrameTimeRecording(int32_t bufferSize)
returns (uint32_t startIndex);
sync StopFrameTimeRecording(uint32_t startIndex)
returns (float[] intervals);
// layersBackendHints is an ordered list of preffered backends where
// layersBackendHints[0] is the best backend. If any hints are LayersBackend::LAYERS_NONE
// that hint is ignored.
sync PLayerTransaction(LayersBackend[] layersBackendHints, uint64_t id)
returns (TextureFactoryIdentifier textureFactoryIdentifier, bool success);
// Notify the compositor that a region of the screen has been invalidated.
async NotifyRegionInvalidated(nsIntRegion region);
/**
* The child (content/chrome thread) requests that the parent inform it when
* the graphics objects are ready to display.
* @see PBrowser
* @see RemotePaintIsReady
*/
async RequestNotifyAfterRemotePaint();
// The child clears the 'approximately visible' regions associated with the
// provided layers ID and pres shell ID (i.e., the regions for all view IDs
// associated with those IDs).
async ClearApproximatelyVisibleRegions(uint64_t layersId, uint32_t presShellId);
// The child sends a region containing rects associated with the provided
// scrollable layer GUID that the child considers 'approximately visible'.
// We visualize this information in the APZ minimap.
async NotifyApproximatelyVisibleRegion(ScrollableLayerGuid guid, CSSIntRegion region);
/**
* Sent when the child has finished CaptureAllPlugins.
*/
async AllPluginsCaptured();
async PTexture(SurfaceDescriptor aSharedData, LayersBackend aBackend, TextureFlags aTextureFlags, uint64_t id, uint64_t aSerial);
sync SyncWithCompositor();
child:
// Send back Compositor Frame Metrics from APZCs so tiled layers can
// update progressively.
async SharedCompositorFrameMetrics(Handle metrics, CrossProcessMutexHandle mutex, uint64_t aLayersId, uint32_t aAPZCId);
async ReleaseSharedCompositorFrameMetrics(ViewID aId, uint32_t aAPZCId);
};
} // layers
} // mozilla
|
