Other Tools

1
//
2
// Automatically generated by ipdlc.
3
// Edit at your own risk
4
//
5
6
7
#include "mozilla/layers/PCompositorBridgeParent.h"
8
#include "ipc/IPCMessageUtils.h"
9
#include "mozilla/TimeStamp.h"
10
#include "mozilla/layers/CompositorBridgeParent.h"
11
#include "mozilla/layers/CompositorTypes.h"
12
#include "mozilla/layers/FrameUniformityData.h"
13
#include "mozilla/layers/LayersTypes.h"
14
#include "mozilla/layers/ScrollableLayerGuid.h"
15
16
#include "mozilla/layers/PAPZParent.h"
17
#include "mozilla/layers/PAPZCTreeManagerParent.h"
18
#include "mozilla/dom/PBrowserParent.h"
19
#include "mozilla/layers/PCanvasParent.h"
20
#include "mozilla/layers/PCompositorManagerParent.h"
21
#include "mozilla/widget/PCompositorWidgetParent.h"
22
#include "mozilla/layers/PLayerTransactionParent.h"
23
#include "mozilla/layers/PTextureParent.h"
24
#include "mozilla/layers/PWebRenderBridgeParent.h"
25
26
#include "nsIFile.h"
27
#include "GeckoProfiler.h"
28
29
namespace mozilla {
30
namespace layers {
31
32
33
auto PCompositorBridgeParent::Recv__delete__() -> mozilla::ipc::IPCResult
34
{
35
return IPC_OK();
36
}
37
38
auto PCompositorBridgeParent::RecvPCompositorWidgetConstructor(
39
PCompositorWidgetParent* actor,
40
const CompositorWidgetInitData& aInitData) -> mozilla::ipc::IPCResult
41
{
42
return IPC_OK();
43
}
44
45
auto PCompositorBridgeParent::RecvPAPZConstructor(
46
PAPZParent* actor,
47
const LayersId& layersId) -> mozilla::ipc::IPCResult
48
{
49
return IPC_OK();
50
}
51
52
auto PCompositorBridgeParent::RecvPAPZCTreeManagerConstructor(
53
PAPZCTreeManagerParent* actor,
54
const LayersId& layersId) -> mozilla::ipc::IPCResult
55
{
56
return IPC_OK();
57
}
58
59
auto PCompositorBridgeParent::RecvPLayerTransactionConstructor(
60
PLayerTransactionParent* actor,
61
nsTArray<LayersBackend>&& layersBackendHints,
62
const LayersId& id) -> mozilla::ipc::IPCResult
63
{
64
return IPC_OK();
65
}
66
67
auto PCompositorBridgeParent::RecvPTextureConstructor(
68
PTextureParent* actor,
69
const SurfaceDescriptor& aSharedData,
70
const ReadLockDescriptor& aReadLock,
71
const LayersBackend& aBackend,
72
const TextureFlags& aTextureFlags,
73
const LayersId& id,
74
const uint64_t& aSerial,
75
const MaybeExternalImageId& aExternalImageId) -> mozilla::ipc::IPCResult
76
{
77
return IPC_OK();
78
}
79
80
auto PCompositorBridgeParent::RecvPWebRenderBridgeConstructor(
81
PWebRenderBridgeParent* actor,
82
const PipelineId& pipelineId,
83
const LayoutDeviceIntSize& aSize) -> mozilla::ipc::IPCResult
84
{
85
return IPC_OK();
86
}
87
88
MOZ_IMPLICIT PCompositorBridgeParent::PCompositorBridgeParent() :
89
mozilla::ipc::IProtocol(PCompositorBridgeMsgStart, mozilla::ipc::ParentSide)
90
{
91
MOZ_COUNT_CTOR(PCompositorBridgeParent);
92
}
93
94
PCompositorBridgeParent::~PCompositorBridgeParent()
95
{
96
MOZ_COUNT_DTOR(PCompositorBridgeParent);
97
}
98
99
auto PCompositorBridgeParent::Manager() const -> PCompositorManagerParent*
100
{
101
return static_cast<PCompositorManagerParent*>(IProtocol::Manager());
102
}
103
104
auto PCompositorBridgeParent::ManagedPAPZParent(nsTArray<PAPZParent*>& aArr) const -> void
105
{
106
mManagedPAPZParent.ToArray(aArr);
107
}
108
109
auto PCompositorBridgeParent::ManagedPAPZParent() const -> const ManagedContainer<PAPZParent>&
110
{
111
return mManagedPAPZParent;
112
}
113
114
auto PCompositorBridgeParent::ManagedPAPZCTreeManagerParent(nsTArray<PAPZCTreeManagerParent*>& aArr) const -> void
115
{
116
mManagedPAPZCTreeManagerParent.ToArray(aArr);
117
}
118
119
auto PCompositorBridgeParent::ManagedPAPZCTreeManagerParent() const -> const ManagedContainer<PAPZCTreeManagerParent>&
120
{
121
return mManagedPAPZCTreeManagerParent;
122
}
123
124
auto PCompositorBridgeParent::ManagedPLayerTransactionParent(nsTArray<PLayerTransactionParent*>& aArr) const -> void
125
{
126
mManagedPLayerTransactionParent.ToArray(aArr);
127
}
128
129
auto PCompositorBridgeParent::ManagedPLayerTransactionParent() const -> const ManagedContainer<PLayerTransactionParent>&
130
{
131
return mManagedPLayerTransactionParent;
132
}
133
134
auto PCompositorBridgeParent::ManagedPTextureParent(nsTArray<PTextureParent*>& aArr) const -> void
135
{
136
mManagedPTextureParent.ToArray(aArr);
137
}
138
139
auto PCompositorBridgeParent::ManagedPTextureParent() const -> const ManagedContainer<PTextureParent>&
140
{
141
return mManagedPTextureParent;
142
}
143
144
auto PCompositorBridgeParent::ManagedPCompositorWidgetParent(nsTArray<PCompositorWidgetParent*>& aArr) const -> void
145
{
146
mManagedPCompositorWidgetParent.ToArray(aArr);
147
}
148
149
auto PCompositorBridgeParent::ManagedPCompositorWidgetParent() const -> const ManagedContainer<PCompositorWidgetParent>&
150
{
151
return mManagedPCompositorWidgetParent;
152
}
153
154
auto PCompositorBridgeParent::ManagedPWebRenderBridgeParent(nsTArray<PWebRenderBridgeParent*>& aArr) const -> void
155
{
156
mManagedPWebRenderBridgeParent.ToArray(aArr);
157
}
158
159
auto PCompositorBridgeParent::ManagedPWebRenderBridgeParent() const -> const ManagedContainer<PWebRenderBridgeParent>&
160
{
161
return mManagedPWebRenderBridgeParent;
162
}
163
164
auto PCompositorBridgeParent::AllManagedActors(nsTArray<RefPtr<mozilla::ipc::ActorLifecycleProxy>>& arr__) const -> void
165
{
166
uint32_t total = 0;
167
total += mManagedPAPZParent.Count();
168
total += mManagedPAPZCTreeManagerParent.Count();
169
total += mManagedPLayerTransactionParent.Count();
170
total += mManagedPTextureParent.Count();
171
total += mManagedPCompositorWidgetParent.Count();
172
total += mManagedPWebRenderBridgeParent.Count();
173
arr__.SetCapacity(total);
174
175
for (auto it = mManagedPAPZParent.ConstIter(); !it.Done(); it.Next()) {
176
arr__.AppendElement(it.Get()->GetKey()->GetLifecycleProxy());
177
}
178
179
for (auto it = mManagedPAPZCTreeManagerParent.ConstIter(); !it.Done(); it.Next()) {
180
arr__.AppendElement(it.Get()->GetKey()->GetLifecycleProxy());
181
}
182
183
for (auto it = mManagedPLayerTransactionParent.ConstIter(); !it.Done(); it.Next()) {
184
arr__.AppendElement(it.Get()->GetKey()->GetLifecycleProxy());
185
}
186
187
for (auto it = mManagedPTextureParent.ConstIter(); !it.Done(); it.Next()) {
188
arr__.AppendElement(it.Get()->GetKey()->GetLifecycleProxy());
189
}
190
191
for (auto it = mManagedPCompositorWidgetParent.ConstIter(); !it.Done(); it.Next()) {
192
arr__.AppendElement(it.Get()->GetKey()->GetLifecycleProxy());
193
}
194
195
for (auto it = mManagedPWebRenderBridgeParent.ConstIter(); !it.Done(); it.Next()) {
196
arr__.AppendElement(it.Get()->GetKey()->GetLifecycleProxy());
197
}
198
199
}
200
201
auto PCompositorBridgeParent::OpenPAPZEndpoint(PAPZParent* aActor) -> ManagedEndpoint<PAPZChild>
202
{
203
if (!aActor) {
204
NS_WARNING("Error constructing actor PAPZParent");
205
return ManagedEndpoint<PAPZChild>();
206
}
207
208
aActor->SetManagerAndRegister(this);
209
mManagedPAPZParent.PutEntry(aActor);
210
211
return ManagedEndpoint<PAPZChild>(mozilla::ipc::PrivateIPDLInterface(), aActor->Id());
212
}
213
214
auto PCompositorBridgeParent::BindPAPZEndpoint(
215
ManagedEndpoint<PAPZParent> aEndpoint,
216
PAPZParent* aActor) -> bool
217
{
218
MOZ_RELEASE_ASSERT(aEndpoint.ActorId(), "Invalid Endpoint!");
219
if (!aActor) {
220
NS_WARNING("Error constructing actor PAPZParent");
221
return false;
222
}
223
224
aActor->SetManagerAndRegister(this, *aEndpoint.ActorId());
225
mManagedPAPZParent.PutEntry(aActor);
226
227
return true;
228
}
229
230
auto PCompositorBridgeParent::OpenPAPZCTreeManagerEndpoint(PAPZCTreeManagerParent* aActor) -> ManagedEndpoint<PAPZCTreeManagerChild>
231
{
232
if (!aActor) {
233
NS_WARNING("Error constructing actor PAPZCTreeManagerParent");
234
return ManagedEndpoint<PAPZCTreeManagerChild>();
235
}
236
237
aActor->SetManagerAndRegister(this);
238
mManagedPAPZCTreeManagerParent.PutEntry(aActor);
239
240
return ManagedEndpoint<PAPZCTreeManagerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor->Id());
241
}
242
243
auto PCompositorBridgeParent::BindPAPZCTreeManagerEndpoint(
244
ManagedEndpoint<PAPZCTreeManagerParent> aEndpoint,
245
PAPZCTreeManagerParent* aActor) -> bool
246
{
247
MOZ_RELEASE_ASSERT(aEndpoint.ActorId(), "Invalid Endpoint!");
248
if (!aActor) {
249
NS_WARNING("Error constructing actor PAPZCTreeManagerParent");
250
return false;
251
}
252
253
aActor->SetManagerAndRegister(this, *aEndpoint.ActorId());
254
mManagedPAPZCTreeManagerParent.PutEntry(aActor);
255
256
return true;
257
}
258
259
auto PCompositorBridgeParent::OpenPLayerTransactionEndpoint(PLayerTransactionParent* aActor) -> ManagedEndpoint<PLayerTransactionChild>
260
{
261
if (!aActor) {
262
NS_WARNING("Error constructing actor PLayerTransactionParent");
263
return ManagedEndpoint<PLayerTransactionChild>();
264
}
265
266
aActor->SetManagerAndRegister(this);
267
mManagedPLayerTransactionParent.PutEntry(aActor);
268
269
return ManagedEndpoint<PLayerTransactionChild>(mozilla::ipc::PrivateIPDLInterface(), aActor->Id());
270
}
271
272
auto PCompositorBridgeParent::BindPLayerTransactionEndpoint(
273
ManagedEndpoint<PLayerTransactionParent> aEndpoint,
274
PLayerTransactionParent* aActor) -> bool
275
{
276
MOZ_RELEASE_ASSERT(aEndpoint.ActorId(), "Invalid Endpoint!");
277
if (!aActor) {
278
NS_WARNING("Error constructing actor PLayerTransactionParent");
279
return false;
280
}
281
282
aActor->SetManagerAndRegister(this, *aEndpoint.ActorId());
283
mManagedPLayerTransactionParent.PutEntry(aActor);
284
285
return true;
286
}
287
288
auto PCompositorBridgeParent::OpenPTextureEndpoint(PTextureParent* aActor) -> ManagedEndpoint<PTextureChild>
289
{
290
if (!aActor) {
291
NS_WARNING("Error constructing actor PTextureParent");
292
return ManagedEndpoint<PTextureChild>();
293
}
294
295
aActor->SetManagerAndRegister(this);
296
mManagedPTextureParent.PutEntry(aActor);
297
298
return ManagedEndpoint<PTextureChild>(mozilla::ipc::PrivateIPDLInterface(), aActor->Id());
299
}
300
301
auto PCompositorBridgeParent::BindPTextureEndpoint(
302
ManagedEndpoint<PTextureParent> aEndpoint,
303
PTextureParent* aActor) -> bool
304
{
305
MOZ_RELEASE_ASSERT(aEndpoint.ActorId(), "Invalid Endpoint!");
306
if (!aActor) {
307
NS_WARNING("Error constructing actor PTextureParent");
308
return false;
309
}
310
311
aActor->SetManagerAndRegister(this, *aEndpoint.ActorId());
312
mManagedPTextureParent.PutEntry(aActor);
313
314
return true;
315
}
316
317
auto PCompositorBridgeParent::OpenPCompositorWidgetEndpoint(PCompositorWidgetParent* aActor) -> ManagedEndpoint<PCompositorWidgetChild>
318
{
319
if (!aActor) {
320
NS_WARNING("Error constructing actor PCompositorWidgetParent");
321
return ManagedEndpoint<PCompositorWidgetChild>();
322
}
323
324
aActor->SetManagerAndRegister(this);
325
mManagedPCompositorWidgetParent.PutEntry(aActor);
326
327
return ManagedEndpoint<PCompositorWidgetChild>(mozilla::ipc::PrivateIPDLInterface(), aActor->Id());
328
}
329
330
auto PCompositorBridgeParent::BindPCompositorWidgetEndpoint(
331
ManagedEndpoint<PCompositorWidgetParent> aEndpoint,
332
PCompositorWidgetParent* aActor) -> bool
333
{
334
MOZ_RELEASE_ASSERT(aEndpoint.ActorId(), "Invalid Endpoint!");
335
if (!aActor) {
336
NS_WARNING("Error constructing actor PCompositorWidgetParent");
337
return false;
338
}
339
340
aActor->SetManagerAndRegister(this, *aEndpoint.ActorId());
341
mManagedPCompositorWidgetParent.PutEntry(aActor);
342
343
return true;
344
}
345
346
auto PCompositorBridgeParent::OpenPWebRenderBridgeEndpoint(PWebRenderBridgeParent* aActor) -> ManagedEndpoint<PWebRenderBridgeChild>
347
{
348
if (!aActor) {
349
NS_WARNING("Error constructing actor PWebRenderBridgeParent");
350
return ManagedEndpoint<PWebRenderBridgeChild>();
351
}
352
353
aActor->SetManagerAndRegister(this);
354
mManagedPWebRenderBridgeParent.PutEntry(aActor);
355
356
return ManagedEndpoint<PWebRenderBridgeChild>(mozilla::ipc::PrivateIPDLInterface(), aActor->Id());
357
}
358
359
auto PCompositorBridgeParent::BindPWebRenderBridgeEndpoint(
360
ManagedEndpoint<PWebRenderBridgeParent> aEndpoint,
361
PWebRenderBridgeParent* aActor) -> bool
362
{
363
MOZ_RELEASE_ASSERT(aEndpoint.ActorId(), "Invalid Endpoint!");
364
if (!aActor) {
365
NS_WARNING("Error constructing actor PWebRenderBridgeParent");
366
return false;
367
}
368
369
aActor->SetManagerAndRegister(this, *aEndpoint.ActorId());
370
mManagedPWebRenderBridgeParent.PutEntry(aActor);
371
372
return true;
373
}
374
375
auto PCompositorBridgeParent::SendInvalidateLayers(const LayersId& layersId) -> bool
376
{
377
IPC::Message* msg__ = PCompositorBridge::Msg_InvalidateLayers(Id());
378
379
WriteIPDLParam(msg__, this, layersId);
380
// Sentinel = 'layersId'
381
(msg__)->WriteSentinel(2382073245);
382
383
384
385
386
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
387
mozilla::ipc::LogMessageForProtocol(
388
"PCompositorBridgeParent",
389
OtherPid(),
390
"Sending ",
391
msg__->type(),
392
mozilla::ipc::MessageDirection::eSending);
393
}
394
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_InvalidateLayers", OTHER);
395
396
bool sendok__ = ChannelSend(msg__);
397
return sendok__;
398
}
399
400
auto PCompositorBridgeParent::SendDidComposite(
401
const LayersId& id,
402
const TransactionId& transactionId,
403
const TimeStamp& compositeStart,
404
const TimeStamp& compositeEnd) -> bool
405
{
406
IPC::Message* msg__ = PCompositorBridge::Msg_DidComposite(Id());
407
408
WriteIPDLParam(msg__, this, id);
409
// Sentinel = 'id'
410
(msg__)->WriteSentinel(2794505629);
411
WriteIPDLParam(msg__, this, transactionId);
412
// Sentinel = 'transactionId'
413
(msg__)->WriteSentinel(3330976378);
414
WriteIPDLParam(msg__, this, compositeStart);
415
// Sentinel = 'compositeStart'
416
(msg__)->WriteSentinel(2314271973);
417
WriteIPDLParam(msg__, this, compositeEnd);
418
// Sentinel = 'compositeEnd'
419
(msg__)->WriteSentinel(3871762396);
420
421
422
423
424
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
425
mozilla::ipc::LogMessageForProtocol(
426
"PCompositorBridgeParent",
427
OtherPid(),
428
"Sending ",
429
msg__->type(),
430
mozilla::ipc::MessageDirection::eSending);
431
}
432
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_DidComposite", OTHER);
433
434
bool sendok__ = ChannelSend(msg__);
435
return sendok__;
436
}
437
438
auto PCompositorBridgeParent::SendNotifyFrameStats(const nsTArray<FrameStats>& aFrameStats) -> bool
439
{
440
IPC::Message* msg__ = PCompositorBridge::Msg_NotifyFrameStats(Id());
441
442
WriteIPDLParam(msg__, this, aFrameStats);
443
// Sentinel = 'aFrameStats'
444
(msg__)->WriteSentinel(1201339250);
445
446
447
448
449
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
450
mozilla::ipc::LogMessageForProtocol(
451
"PCompositorBridgeParent",
452
OtherPid(),
453
"Sending ",
454
msg__->type(),
455
mozilla::ipc::MessageDirection::eSending);
456
}
457
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_NotifyFrameStats", OTHER);
458
459
bool sendok__ = ChannelSend(msg__);
460
return sendok__;
461
}
462
463
auto PCompositorBridgeParent::SendRemotePaintIsReady() -> bool
464
{
465
IPC::Message* msg__ = PCompositorBridge::Msg_RemotePaintIsReady(Id());
466
467
468
469
470
471
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
472
mozilla::ipc::LogMessageForProtocol(
473
"PCompositorBridgeParent",
474
OtherPid(),
475
"Sending ",
476
msg__->type(),
477
mozilla::ipc::MessageDirection::eSending);
478
}
479
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_RemotePaintIsReady", OTHER);
480
481
bool sendok__ = ChannelSend(msg__);
482
return sendok__;
483
}
484
485
auto PCompositorBridgeParent::SendUpdatePluginConfigurations(
486
const LayoutDeviceIntPoint& aContentOffset,
487
const LayoutDeviceIntRegion& aVisibleRegion,
488
const nsTArray<PluginWindowData>& aPlugins) -> bool
489
{
490
IPC::Message* msg__ = PCompositorBridge::Msg_UpdatePluginConfigurations(Id());
491
492
WriteIPDLParam(msg__, this, aContentOffset);
493
// Sentinel = 'aContentOffset'
494
(msg__)->WriteSentinel(2149079995);
495
WriteIPDLParam(msg__, this, aVisibleRegion);
496
// Sentinel = 'aVisibleRegion'
497
(msg__)->WriteSentinel(24324155);
498
WriteIPDLParam(msg__, this, aPlugins);
499
// Sentinel = 'aPlugins'
500
(msg__)->WriteSentinel(1444186915);
501
502
503
504
505
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
506
mozilla::ipc::LogMessageForProtocol(
507
"PCompositorBridgeParent",
508
OtherPid(),
509
"Sending ",
510
msg__->type(),
511
mozilla::ipc::MessageDirection::eSending);
512
}
513
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_UpdatePluginConfigurations", OTHER);
514
515
bool sendok__ = ChannelSend(msg__);
516
return sendok__;
517
}
518
519
auto PCompositorBridgeParent::SendCaptureAllPlugins(const uintptr_t& aParentWidget) -> bool
520
{
521
IPC::Message* msg__ = PCompositorBridge::Msg_CaptureAllPlugins(Id());
522
523
WriteIPDLParam(msg__, this, aParentWidget);
524
// Sentinel = 'aParentWidget'
525
(msg__)->WriteSentinel(2198235748);
526
527
528
529
530
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
531
mozilla::ipc::LogMessageForProtocol(
532
"PCompositorBridgeParent",
533
OtherPid(),
534
"Sending ",
535
msg__->type(),
536
mozilla::ipc::MessageDirection::eSending);
537
}
538
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_CaptureAllPlugins", OTHER);
539
540
bool sendok__ = ChannelSend(msg__);
541
return sendok__;
542
}
543
544
auto PCompositorBridgeParent::SendHideAllPlugins(const uintptr_t& aParentWidget) -> bool
545
{
546
IPC::Message* msg__ = PCompositorBridge::Msg_HideAllPlugins(Id());
547
548
WriteIPDLParam(msg__, this, aParentWidget);
549
// Sentinel = 'aParentWidget'
550
(msg__)->WriteSentinel(2198235748);
551
552
553
554
555
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
556
mozilla::ipc::LogMessageForProtocol(
557
"PCompositorBridgeParent",
558
OtherPid(),
559
"Sending ",
560
msg__->type(),
561
mozilla::ipc::MessageDirection::eSending);
562
}
563
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_HideAllPlugins", OTHER);
564
565
bool sendok__ = ChannelSend(msg__);
566
return sendok__;
567
}
568
569
auto PCompositorBridgeParent::SendParentAsyncMessages(const nsTArray<AsyncParentMessageData>& aMessages) -> bool
570
{
571
IPC::Message* msg__ = PCompositorBridge::Msg_ParentAsyncMessages(Id());
572
573
WriteIPDLParam(msg__, this, aMessages);
574
// Sentinel = 'aMessages'
575
(msg__)->WriteSentinel(1923086976);
576
577
578
579
580
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
581
mozilla::ipc::LogMessageForProtocol(
582
"PCompositorBridgeParent",
583
OtherPid(),
584
"Sending ",
585
msg__->type(),
586
mozilla::ipc::MessageDirection::eSending);
587
}
588
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_ParentAsyncMessages", OTHER);
589
590
bool sendok__ = ChannelSend(msg__);
591
return sendok__;
592
}
593
594
auto PCompositorBridgeParent::SendObserveLayersUpdate(
595
const LayersId& aLayersId,
596
const LayersObserverEpoch& aEpoch,
597
const bool& aActive) -> bool
598
{
599
IPC::Message* msg__ = PCompositorBridge::Msg_ObserveLayersUpdate(Id());
600
601
WriteIPDLParam(msg__, this, aLayersId);
602
// Sentinel = 'aLayersId'
603
(msg__)->WriteSentinel(1401196721);
604
WriteIPDLParam(msg__, this, aEpoch);
605
// Sentinel = 'aEpoch'
606
(msg__)->WriteSentinel(2333012390);
607
WriteIPDLParam(msg__, this, aActive);
608
// Sentinel = 'aActive'
609
(msg__)->WriteSentinel(1215369048);
610
611
612
613
614
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
615
mozilla::ipc::LogMessageForProtocol(
616
"PCompositorBridgeParent",
617
OtherPid(),
618
"Sending ",
619
msg__->type(),
620
mozilla::ipc::MessageDirection::eSending);
621
}
622
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_ObserveLayersUpdate", OTHER);
623
624
bool sendok__ = ChannelSend(msg__);
625
return sendok__;
626
}
627
628
auto PCompositorBridgeParent::SendSharedCompositorFrameMetrics(
629
const Handle& metrics,
630
const CrossProcessMutexHandle& mutex,
631
const LayersId& aLayersId,
632
const uint32_t& aAPZCId) -> bool
633
{
634
IPC::Message* msg__ = PCompositorBridge::Msg_SharedCompositorFrameMetrics(Id());
635
636
WriteIPDLParam(msg__, this, metrics);
637
// Sentinel = 'metrics'
638
(msg__)->WriteSentinel(293471184);
639
WriteIPDLParam(msg__, this, mutex);
640
// Sentinel = 'mutex'
641
(msg__)->WriteSentinel(4247164084);
642
WriteIPDLParam(msg__, this, aLayersId);
643
// Sentinel = 'aLayersId'
644
(msg__)->WriteSentinel(1401196721);
645
WriteIPDLParam(msg__, this, aAPZCId);
646
// Sentinel = 'aAPZCId'
647
(msg__)->WriteSentinel(1661101435);
648
649
650
651
652
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
653
mozilla::ipc::LogMessageForProtocol(
654
"PCompositorBridgeParent",
655
OtherPid(),
656
"Sending ",
657
msg__->type(),
658
mozilla::ipc::MessageDirection::eSending);
659
}
660
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_SharedCompositorFrameMetrics", OTHER);
661
662
bool sendok__ = ChannelSend(msg__);
663
return sendok__;
664
}
665
666
auto PCompositorBridgeParent::SendReleaseSharedCompositorFrameMetrics(
667
const ViewID& aId,
668
const uint32_t& aAPZCId) -> bool
669
{
670
IPC::Message* msg__ = PCompositorBridge::Msg_ReleaseSharedCompositorFrameMetrics(Id());
671
672
WriteIPDLParam(msg__, this, aId);
673
// Sentinel = 'aId'
674
(msg__)->WriteSentinel(2735041817);
675
WriteIPDLParam(msg__, this, aAPZCId);
676
// Sentinel = 'aAPZCId'
677
(msg__)->WriteSentinel(1661101435);
678
679
680
681
682
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
683
mozilla::ipc::LogMessageForProtocol(
684
"PCompositorBridgeParent",
685
OtherPid(),
686
"Sending ",
687
msg__->type(),
688
mozilla::ipc::MessageDirection::eSending);
689
}
690
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_ReleaseSharedCompositorFrameMetrics", OTHER);
691
692
bool sendok__ = ChannelSend(msg__);
693
return sendok__;
694
}
695
696
auto PCompositorBridgeParent::RemoveManagee(
697
int32_t aProtocolId,
698
IProtocol* aListener) -> void
699
{
700
switch (aProtocolId) {
701
case PAPZMsgStart:
702
{
703
PAPZParent* actor = static_cast<PAPZParent*>(aListener);
704
auto& container = mManagedPAPZParent;
705
706
// Use a temporary variable here so all the assertion expressions
707
// in the MOZ_RELEASE_ASSERT call below are textually identical;
708
// the linker can then merge the strings from the assertion macro(s).
709
MOZ_RELEASE_ASSERT(container.Contains(actor),
710
"actor not managed by this!");
711
container.RemoveEntry(actor);
712
713
auto* proxy = actor->GetLifecycleProxy();
714
NS_IF_RELEASE(proxy);
715
return;
716
} case PAPZCTreeManagerMsgStart:
717
{
718
PAPZCTreeManagerParent* actor = static_cast<PAPZCTreeManagerParent*>(aListener);
719
auto& container = mManagedPAPZCTreeManagerParent;
720
721
// Use a temporary variable here so all the assertion expressions
722
// in the MOZ_RELEASE_ASSERT call below are textually identical;
723
// the linker can then merge the strings from the assertion macro(s).
724
MOZ_RELEASE_ASSERT(container.Contains(actor),
725
"actor not managed by this!");
726
container.RemoveEntry(actor);
727
728
auto* proxy = actor->GetLifecycleProxy();
729
NS_IF_RELEASE(proxy);
730
return;
731
} case PLayerTransactionMsgStart:
732
{
733
PLayerTransactionParent* actor = static_cast<PLayerTransactionParent*>(aListener);
734
auto& container = mManagedPLayerTransactionParent;
735
736
// Use a temporary variable here so all the assertion expressions
737
// in the MOZ_RELEASE_ASSERT call below are textually identical;
738
// the linker can then merge the strings from the assertion macro(s).
739
MOZ_RELEASE_ASSERT(container.Contains(actor),
740
"actor not managed by this!");
741
container.RemoveEntry(actor);
742
743
auto* proxy = actor->GetLifecycleProxy();
744
NS_IF_RELEASE(proxy);
745
return;
746
} case PTextureMsgStart:
747
{
748
PTextureParent* actor = static_cast<PTextureParent*>(aListener);
749
auto& container = mManagedPTextureParent;
750
751
// Use a temporary variable here so all the assertion expressions
752
// in the MOZ_RELEASE_ASSERT call below are textually identical;
753
// the linker can then merge the strings from the assertion macro(s).
754
MOZ_RELEASE_ASSERT(container.Contains(actor),
755
"actor not managed by this!");
756
container.RemoveEntry(actor);
757
758
auto* proxy = actor->GetLifecycleProxy();
759
NS_IF_RELEASE(proxy);
760
return;
761
} case PCompositorWidgetMsgStart:
762
{
763
PCompositorWidgetParent* actor = static_cast<PCompositorWidgetParent*>(aListener);
764
auto& container = mManagedPCompositorWidgetParent;
765
766
// Use a temporary variable here so all the assertion expressions
767
// in the MOZ_RELEASE_ASSERT call below are textually identical;
768
// the linker can then merge the strings from the assertion macro(s).
769
MOZ_RELEASE_ASSERT(container.Contains(actor),
770
"actor not managed by this!");
771
container.RemoveEntry(actor);
772
773
auto* proxy = actor->GetLifecycleProxy();
774
NS_IF_RELEASE(proxy);
775
return;
776
} case PWebRenderBridgeMsgStart:
777
{
778
PWebRenderBridgeParent* actor = static_cast<PWebRenderBridgeParent*>(aListener);
779
auto& container = mManagedPWebRenderBridgeParent;
780
781
// Use a temporary variable here so all the assertion expressions
782
// in the MOZ_RELEASE_ASSERT call below are textually identical;
783
// the linker can then merge the strings from the assertion macro(s).
784
MOZ_RELEASE_ASSERT(container.Contains(actor),
785
"actor not managed by this!");
786
container.RemoveEntry(actor);
787
788
auto* proxy = actor->GetLifecycleProxy();
789
NS_IF_RELEASE(proxy);
790
return;
791
} default:
792
FatalError("unreached");
793
return; }
794
}
795
796
auto PCompositorBridgeParent::DeallocManagee(
797
int32_t aProtocolId,
798
IProtocol* aListener) -> void
799
{
800
switch (aProtocolId) {
801
case PAPZMsgStart:
802
static_cast<CompositorBridgeParentBase*>(this)->DeallocPAPZParent(static_cast<PAPZParent*>(aListener));
803
return;
804
case PAPZCTreeManagerMsgStart:
805
static_cast<CompositorBridgeParentBase*>(this)->DeallocPAPZCTreeManagerParent(static_cast<PAPZCTreeManagerParent*>(aListener));
806
return;
807
case PLayerTransactionMsgStart:
808
static_cast<CompositorBridgeParentBase*>(this)->DeallocPLayerTransactionParent(static_cast<PLayerTransactionParent*>(aListener));
809
return;
810
case PTextureMsgStart:
811
static_cast<CompositorBridgeParentBase*>(this)->DeallocPTextureParent(static_cast<PTextureParent*>(aListener));
812
return;
813
case PCompositorWidgetMsgStart:
814
static_cast<CompositorBridgeParentBase*>(this)->DeallocPCompositorWidgetParent(static_cast<PCompositorWidgetParent*>(aListener));
815
return;
816
case PWebRenderBridgeMsgStart:
817
static_cast<CompositorBridgeParentBase*>(this)->DeallocPWebRenderBridgeParent(static_cast<PWebRenderBridgeParent*>(aListener));
818
return;
819
default:
820
FatalError("unreached");
821
return;
822
}
823
}
824
825
auto PCompositorBridgeParent::OnMessageReceived(const Message& msg__) -> PCompositorBridgeParent::Result
826
{
827
switch (msg__.type()) {
828
case PCompositorBridge::Msg___delete____ID:
829
{
830
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
831
mozilla::ipc::LogMessageForProtocol(
832
"PCompositorBridgeParent",
833
OtherPid(),
834
"Received ",
835
(&(msg__))->type(),
836
mozilla::ipc::MessageDirection::eReceiving);
837
}
838
AUTO_PROFILER_LABEL("PCompositorBridge::Msg___delete__", OTHER);
839
840
PickleIterator iter__(msg__);
841
PCompositorBridgeParent* actor;
842
843
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(actor)))))) {
844
FatalError("Error deserializing 'PCompositorBridge'");
845
return MsgValueError;
846
}
847
if ((!((*((&(actor))))))) {
848
FatalError("Error deserializing 'PCompositorBridge'");
849
return MsgValueError;
850
}
851
// Sentinel = 'actor'
852
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
853
mozilla::ipc::SentinelReadError("Error deserializing 'PCompositorBridge'");
854
return MsgValueError;
855
}
856
msg__.EndRead(iter__, msg__.type());
857
if ((!((static_cast<CompositorBridgeParentBase*>(this))->Recv__delete__()))) {
858
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
859
// Error handled in mozilla::ipc::IPCResult
860
return MsgProcessingError;
861
}
862
863
864
IProtocol* mgr = actor->Manager();
865
actor->DestroySubtree(Deletion);
866
actor->ClearSubtree();
867
mgr->RemoveManagee(PCompositorBridgeMsgStart, actor);
868
869
return MsgProcessed;
870
}
871
case PCompositorBridge::Msg_PCompositorWidgetConstructor__ID:
872
{
873
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
874
mozilla::ipc::LogMessageForProtocol(
875
"PCompositorBridgeParent",
876
OtherPid(),
877
"Received ",
878
(&(msg__))->type(),
879
mozilla::ipc::MessageDirection::eReceiving);
880
}
881
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PCompositorWidgetConstructor", OTHER);
882
883
PickleIterator iter__(msg__);
884
ActorHandle handle__;
885
PCompositorWidgetParent* actor;
886
CompositorWidgetInitData aInitData;
887
888
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
889
FatalError("Error deserializing 'ActorHandle'");
890
return MsgValueError;
891
}
892
// Sentinel = 'actor'
893
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
894
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
895
return MsgValueError;
896
}
897
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aInitData)))))) {
898
FatalError("Error deserializing 'CompositorWidgetInitData'");
899
return MsgValueError;
900
}
901
// Sentinel = 'aInitData'
902
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 897514454)))) {
903
mozilla::ipc::SentinelReadError("Error deserializing 'CompositorWidgetInitData'");
904
return MsgValueError;
905
}
906
msg__.EndRead(iter__, msg__.type());
907
actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPCompositorWidgetParent(aInitData);
908
if (!actor) {
909
NS_WARNING("Error constructing actor PCompositorWidgetParent");
910
return MsgValueError;
911
}
912
913
actor->SetManagerAndRegister(this, (handle__).mId);
914
mManagedPCompositorWidgetParent.PutEntry(actor);
915
916
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPCompositorWidgetConstructor(std::move(actor), std::move(aInitData))))) {
917
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
918
// Error handled in mozilla::ipc::IPCResult
919
return MsgProcessingError;
920
}
921
922
return MsgProcessed;
923
}
924
case PCompositorBridge::Msg_PAPZConstructor__ID:
925
{
926
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
927
mozilla::ipc::LogMessageForProtocol(
928
"PCompositorBridgeParent",
929
OtherPid(),
930
"Received ",
931
(&(msg__))->type(),
932
mozilla::ipc::MessageDirection::eReceiving);
933
}
934
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PAPZConstructor", OTHER);
935
936
PickleIterator iter__(msg__);
937
ActorHandle handle__;
938
PAPZParent* actor;
939
LayersId layersId;
940
941
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
942
FatalError("Error deserializing 'ActorHandle'");
943
return MsgValueError;
944
}
945
// Sentinel = 'actor'
946
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
947
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
948
return MsgValueError;
949
}
950
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(layersId)))))) {
951
FatalError("Error deserializing 'LayersId'");
952
return MsgValueError;
953
}
954
// Sentinel = 'layersId'
955
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2382073245)))) {
956
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
957
return MsgValueError;
958
}
959
msg__.EndRead(iter__, msg__.type());
960
actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPAPZParent(layersId);
961
if (!actor) {
962
NS_WARNING("Error constructing actor PAPZParent");
963
return MsgValueError;
964
}
965
966
actor->SetManagerAndRegister(this, (handle__).mId);
967
mManagedPAPZParent.PutEntry(actor);
968
969
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPAPZConstructor(std::move(actor), std::move(layersId))))) {
970
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
971
// Error handled in mozilla::ipc::IPCResult
972
return MsgProcessingError;
973
}
974
975
return MsgProcessed;
976
}
977
case PCompositorBridge::Msg_PAPZCTreeManagerConstructor__ID:
978
{
979
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
980
mozilla::ipc::LogMessageForProtocol(
981
"PCompositorBridgeParent",
982
OtherPid(),
983
"Received ",
984
(&(msg__))->type(),
985
mozilla::ipc::MessageDirection::eReceiving);
986
}
987
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PAPZCTreeManagerConstructor", OTHER);
988
989
PickleIterator iter__(msg__);
990
ActorHandle handle__;
991
PAPZCTreeManagerParent* actor;
992
LayersId layersId;
993
994
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
995
FatalError("Error deserializing 'ActorHandle'");
996
return MsgValueError;
997
}
998
// Sentinel = 'actor'
999
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
1000
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
1001
return MsgValueError;
1002
}
1003
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(layersId)))))) {
1004
FatalError("Error deserializing 'LayersId'");
1005
return MsgValueError;
1006
}
1007
// Sentinel = 'layersId'
1008
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2382073245)))) {
1009
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
1010
return MsgValueError;
1011
}
1012
msg__.EndRead(iter__, msg__.type());
1013
actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPAPZCTreeManagerParent(layersId);
1014
if (!actor) {
1015
NS_WARNING("Error constructing actor PAPZCTreeManagerParent");
1016
return MsgValueError;
1017
}
1018
1019
actor->SetManagerAndRegister(this, (handle__).mId);
1020
mManagedPAPZCTreeManagerParent.PutEntry(actor);
1021
1022
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPAPZCTreeManagerConstructor(std::move(actor), std::move(layersId))))) {
1023
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1024
// Error handled in mozilla::ipc::IPCResult
1025
return MsgProcessingError;
1026
}
1027
1028
return MsgProcessed;
1029
}
1030
case PCompositorBridge::Msg_RemotePluginsReady__ID:
1031
{
1032
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1033
mozilla::ipc::LogMessageForProtocol(
1034
"PCompositorBridgeParent",
1035
OtherPid(),
1036
"Received ",
1037
(&(msg__))->type(),
1038
mozilla::ipc::MessageDirection::eReceiving);
1039
}
1040
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_RemotePluginsReady", OTHER);
1041
1042
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvRemotePluginsReady()))) {
1043
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1044
// Error handled in mozilla::ipc::IPCResult
1045
return MsgProcessingError;
1046
}
1047
1048
return MsgProcessed;
1049
}
1050
case PCompositorBridge::Msg_AdoptChild__ID:
1051
{
1052
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1053
mozilla::ipc::LogMessageForProtocol(
1054
"PCompositorBridgeParent",
1055
OtherPid(),
1056
"Received ",
1057
(&(msg__))->type(),
1058
mozilla::ipc::MessageDirection::eReceiving);
1059
}
1060
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_AdoptChild", OTHER);
1061
1062
PickleIterator iter__(msg__);
1063
LayersId id;
1064
1065
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(id)))))) {
1066
FatalError("Error deserializing 'LayersId'");
1067
return MsgValueError;
1068
}
1069
// Sentinel = 'id'
1070
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2794505629)))) {
1071
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
1072
return MsgValueError;
1073
}
1074
msg__.EndRead(iter__, msg__.type());
1075
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvAdoptChild(std::move(id))))) {
1076
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1077
// Error handled in mozilla::ipc::IPCResult
1078
return MsgProcessingError;
1079
}
1080
1081
return MsgProcessed;
1082
}
1083
case PCompositorBridge::Msg_FlushRenderingAsync__ID:
1084
{
1085
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1086
mozilla::ipc::LogMessageForProtocol(
1087
"PCompositorBridgeParent",
1088
OtherPid(),
1089
"Received ",
1090
(&(msg__))->type(),
1091
mozilla::ipc::MessageDirection::eReceiving);
1092
}
1093
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_FlushRenderingAsync", OTHER);
1094
1095
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvFlushRenderingAsync()))) {
1096
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1097
// Error handled in mozilla::ipc::IPCResult
1098
return MsgProcessingError;
1099
}
1100
1101
return MsgProcessed;
1102
}
1103
case PCompositorBridge::Msg_ForcePresent__ID:
1104
{
1105
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1106
mozilla::ipc::LogMessageForProtocol(
1107
"PCompositorBridgeParent",
1108
OtherPid(),
1109
"Received ",
1110
(&(msg__))->type(),
1111
mozilla::ipc::MessageDirection::eReceiving);
1112
}
1113
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_ForcePresent", OTHER);
1114
1115
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvForcePresent()))) {
1116
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1117
// Error handled in mozilla::ipc::IPCResult
1118
return MsgProcessingError;
1119
}
1120
1121
return MsgProcessed;
1122
}
1123
case PCompositorBridge::Msg_PLayerTransactionConstructor__ID:
1124
{
1125
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1126
mozilla::ipc::LogMessageForProtocol(
1127
"PCompositorBridgeParent",
1128
OtherPid(),
1129
"Received ",
1130
(&(msg__))->type(),
1131
mozilla::ipc::MessageDirection::eReceiving);
1132
}
1133
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PLayerTransactionConstructor", OTHER);
1134
1135
PickleIterator iter__(msg__);
1136
ActorHandle handle__;
1137
PLayerTransactionParent* actor;
1138
nsTArray<LayersBackend> layersBackendHints;
1139
LayersId id;
1140
1141
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
1142
FatalError("Error deserializing 'ActorHandle'");
1143
return MsgValueError;
1144
}
1145
// Sentinel = 'actor'
1146
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
1147
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
1148
return MsgValueError;
1149
}
1150
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(layersBackendHints)))))) {
1151
FatalError("Error deserializing 'LayersBackend[]'");
1152
return MsgValueError;
1153
}
1154
// Sentinel = 'layersBackendHints'
1155
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3491646450)))) {
1156
mozilla::ipc::SentinelReadError("Error deserializing 'LayersBackend[]'");
1157
return MsgValueError;
1158
}
1159
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(id)))))) {
1160
FatalError("Error deserializing 'LayersId'");
1161
return MsgValueError;
1162
}
1163
// Sentinel = 'id'
1164
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2794505629)))) {
1165
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
1166
return MsgValueError;
1167
}
1168
msg__.EndRead(iter__, msg__.type());
1169
actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPLayerTransactionParent(layersBackendHints, id);
1170
if (!actor) {
1171
NS_WARNING("Error constructing actor PLayerTransactionParent");
1172
return MsgValueError;
1173
}
1174
1175
actor->SetManagerAndRegister(this, (handle__).mId);
1176
mManagedPLayerTransactionParent.PutEntry(actor);
1177
1178
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPLayerTransactionConstructor(std::move(actor), std::move(layersBackendHints), std::move(id))))) {
1179
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1180
// Error handled in mozilla::ipc::IPCResult
1181
return MsgProcessingError;
1182
}
1183
1184
return MsgProcessed;
1185
}
1186
case PCompositorBridge::Msg_NotifyRegionInvalidated__ID:
1187
{
1188
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1189
mozilla::ipc::LogMessageForProtocol(
1190
"PCompositorBridgeParent",
1191
OtherPid(),
1192
"Received ",
1193
(&(msg__))->type(),
1194
mozilla::ipc::MessageDirection::eReceiving);
1195
}
1196
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_NotifyRegionInvalidated", OTHER);
1197
1198
PickleIterator iter__(msg__);
1199
nsIntRegion region;
1200
1201
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(region)))))) {
1202
FatalError("Error deserializing 'nsIntRegion'");
1203
return MsgValueError;
1204
}
1205
// Sentinel = 'region'
1206
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 688844010)))) {
1207
mozilla::ipc::SentinelReadError("Error deserializing 'nsIntRegion'");
1208
return MsgValueError;
1209
}
1210
msg__.EndRead(iter__, msg__.type());
1211
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvNotifyRegionInvalidated(std::move(region))))) {
1212
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1213
// Error handled in mozilla::ipc::IPCResult
1214
return MsgProcessingError;
1215
}
1216
1217
return MsgProcessed;
1218
}
1219
case PCompositorBridge::Msg_RequestNotifyAfterRemotePaint__ID:
1220
{
1221
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1222
mozilla::ipc::LogMessageForProtocol(
1223
"PCompositorBridgeParent",
1224
OtherPid(),
1225
"Received ",
1226
(&(msg__))->type(),
1227
mozilla::ipc::MessageDirection::eReceiving);
1228
}
1229
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_RequestNotifyAfterRemotePaint", OTHER);
1230
1231
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvRequestNotifyAfterRemotePaint()))) {
1232
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1233
// Error handled in mozilla::ipc::IPCResult
1234
return MsgProcessingError;
1235
}
1236
1237
return MsgProcessed;
1238
}
1239
case PCompositorBridge::Msg_AllPluginsCaptured__ID:
1240
{
1241
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1242
mozilla::ipc::LogMessageForProtocol(
1243
"PCompositorBridgeParent",
1244
OtherPid(),
1245
"Received ",
1246
(&(msg__))->type(),
1247
mozilla::ipc::MessageDirection::eReceiving);
1248
}
1249
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_AllPluginsCaptured", OTHER);
1250
1251
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvAllPluginsCaptured()))) {
1252
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1253
// Error handled in mozilla::ipc::IPCResult
1254
return MsgProcessingError;
1255
}
1256
1257
return MsgProcessed;
1258
}
1259
case PCompositorBridge::Msg_PTextureConstructor__ID:
1260
{
1261
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1262
mozilla::ipc::LogMessageForProtocol(
1263
"PCompositorBridgeParent",
1264
OtherPid(),
1265
"Received ",
1266
(&(msg__))->type(),
1267
mozilla::ipc::MessageDirection::eReceiving);
1268
}
1269
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PTextureConstructor", OTHER);
1270
1271
PickleIterator iter__(msg__);
1272
ActorHandle handle__;
1273
PTextureParent* actor;
1274
SurfaceDescriptor aSharedData;
1275
ReadLockDescriptor aReadLock;
1276
LayersBackend aBackend;
1277
TextureFlags aTextureFlags;
1278
LayersId id;
1279
uint64_t aSerial;
1280
MaybeExternalImageId aExternalImageId;
1281
1282
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
1283
FatalError("Error deserializing 'ActorHandle'");
1284
return MsgValueError;
1285
}
1286
// Sentinel = 'actor'
1287
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
1288
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
1289
return MsgValueError;
1290
}
1291
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aSharedData)))))) {
1292
FatalError("Error deserializing 'SurfaceDescriptor'");
1293
return MsgValueError;
1294
}
1295
// Sentinel = 'aSharedData'
1296
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3013593029)))) {
1297
mozilla::ipc::SentinelReadError("Error deserializing 'SurfaceDescriptor'");
1298
return MsgValueError;
1299
}
1300
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aReadLock)))))) {
1301
FatalError("Error deserializing 'ReadLockDescriptor'");
1302
return MsgValueError;
1303
}
1304
// Sentinel = 'aReadLock'
1305
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1208527801)))) {
1306
mozilla::ipc::SentinelReadError("Error deserializing 'ReadLockDescriptor'");
1307
return MsgValueError;
1308
}
1309
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aBackend)))))) {
1310
FatalError("Error deserializing 'LayersBackend'");
1311
return MsgValueError;
1312
}
1313
// Sentinel = 'aBackend'
1314
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2878499283)))) {
1315
mozilla::ipc::SentinelReadError("Error deserializing 'LayersBackend'");
1316
return MsgValueError;
1317
}
1318
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aTextureFlags)))))) {
1319
FatalError("Error deserializing 'TextureFlags'");
1320
return MsgValueError;
1321
}
1322
// Sentinel = 'aTextureFlags'
1323
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3005687826)))) {
1324
mozilla::ipc::SentinelReadError("Error deserializing 'TextureFlags'");
1325
return MsgValueError;
1326
}
1327
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(id)))))) {
1328
FatalError("Error deserializing 'LayersId'");
1329
return MsgValueError;
1330
}
1331
// Sentinel = 'id'
1332
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2794505629)))) {
1333
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
1334
return MsgValueError;
1335
}
1336
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aSerial)))))) {
1337
FatalError("Error deserializing 'uint64_t'");
1338
return MsgValueError;
1339
}
1340
// Sentinel = 'aSerial'
1341
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1247987114)))) {
1342
mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
1343
return MsgValueError;
1344
}
1345
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aExternalImageId)))))) {
1346
FatalError("Error deserializing 'MaybeExternalImageId'");
1347
return MsgValueError;
1348
}
1349
// Sentinel = 'aExternalImageId'
1350
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2889998824)))) {
1351
mozilla::ipc::SentinelReadError("Error deserializing 'MaybeExternalImageId'");
1352
return MsgValueError;
1353
}
1354
msg__.EndRead(iter__, msg__.type());
1355
actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPTextureParent(aSharedData, aReadLock, aBackend, aTextureFlags, id, aSerial, aExternalImageId);
1356
if (!actor) {
1357
NS_WARNING("Error constructing actor PTextureParent");
1358
return MsgValueError;
1359
}
1360
1361
actor->SetManagerAndRegister(this, (handle__).mId);
1362
mManagedPTextureParent.PutEntry(actor);
1363
1364
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPTextureConstructor(std::move(actor), std::move(aSharedData), std::move(aReadLock), std::move(aBackend), std::move(aTextureFlags), std::move(id), std::move(aSerial), std::move(aExternalImageId))))) {
1365
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1366
// Error handled in mozilla::ipc::IPCResult
1367
return MsgProcessingError;
1368
}
1369
1370
return MsgProcessed;
1371
}
1372
case PCompositorBridge::Msg_InitPCanvasParent__ID:
1373
{
1374
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1375
mozilla::ipc::LogMessageForProtocol(
1376
"PCompositorBridgeParent",
1377
OtherPid(),
1378
"Received ",
1379
(&(msg__))->type(),
1380
mozilla::ipc::MessageDirection::eReceiving);
1381
}
1382
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_InitPCanvasParent", OTHER);
1383
1384
PickleIterator iter__(msg__);
1385
Endpoint<mozilla::layers::PCanvasParent> aEndpoint;
1386
1387
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aEndpoint)))))) {
1388
FatalError("Error deserializing 'Endpoint<mozilla::layers::PCanvasParent>'");
1389
return MsgValueError;
1390
}
1391
// Sentinel = 'aEndpoint'
1392
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2457438235)))) {
1393
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<mozilla::layers::PCanvasParent>'");
1394
return MsgValueError;
1395
}
1396
msg__.EndRead(iter__, msg__.type());
1397
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvInitPCanvasParent(std::move(aEndpoint))))) {
1398
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1399
// Error handled in mozilla::ipc::IPCResult
1400
return MsgProcessingError;
1401
}
1402
1403
return MsgProcessed;
1404
}
1405
case PCompositorBridge::Msg_PWebRenderBridgeConstructor__ID:
1406
{
1407
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1408
mozilla::ipc::LogMessageForProtocol(
1409
"PCompositorBridgeParent",
1410
OtherPid(),
1411
"Received ",
1412
(&(msg__))->type(),
1413
mozilla::ipc::MessageDirection::eReceiving);
1414
}
1415
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PWebRenderBridgeConstructor", OTHER);
1416
1417
PickleIterator iter__(msg__);
1418
ActorHandle handle__;
1419
PWebRenderBridgeParent* actor;
1420
PipelineId pipelineId;
1421
LayoutDeviceIntSize aSize;
1422
1423
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
1424
FatalError("Error deserializing 'ActorHandle'");
1425
return MsgValueError;
1426
}
1427
// Sentinel = 'actor'
1428
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
1429
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
1430
return MsgValueError;
1431
}
1432
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(pipelineId)))))) {
1433
FatalError("Error deserializing 'PipelineId'");
1434
return MsgValueError;
1435
}
1436
// Sentinel = 'pipelineId'
1437
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4067092043)))) {
1438
mozilla::ipc::SentinelReadError("Error deserializing 'PipelineId'");
1439
return MsgValueError;
1440
}
1441
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aSize)))))) {
1442
FatalError("Error deserializing 'LayoutDeviceIntSize'");
1443
return MsgValueError;
1444
}
1445
// Sentinel = 'aSize'
1446
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2556665555)))) {
1447
mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntSize'");
1448
return MsgValueError;
1449
}
1450
msg__.EndRead(iter__, msg__.type());
1451
actor = (static_cast<CompositorBridgeParentBase*>(this))->AllocPWebRenderBridgeParent(pipelineId, aSize);
1452
if (!actor) {
1453
NS_WARNING("Error constructing actor PWebRenderBridgeParent");
1454
return MsgValueError;
1455
}
1456
1457
actor->SetManagerAndRegister(this, (handle__).mId);
1458
mManagedPWebRenderBridgeParent.PutEntry(actor);
1459
1460
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPWebRenderBridgeConstructor(std::move(actor), std::move(pipelineId), std::move(aSize))))) {
1461
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1462
// Error handled in mozilla::ipc::IPCResult
1463
return MsgProcessingError;
1464
}
1465
1466
return MsgProcessed;
1467
}
1468
case PCompositorBridge::Msg_BeginRecording__ID:
1469
{
1470
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1471
mozilla::ipc::LogMessageForProtocol(
1472
"PCompositorBridgeParent",
1473
OtherPid(),
1474
"Received ",
1475
(&(msg__))->type(),
1476
mozilla::ipc::MessageDirection::eReceiving);
1477
}
1478
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_BeginRecording", OTHER);
1479
1480
PickleIterator iter__(msg__);
1481
TimeStamp aRecordingStart;
1482
1483
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aRecordingStart)))))) {
1484
FatalError("Error deserializing 'TimeStamp'");
1485
return MsgValueError;
1486
}
1487
// Sentinel = 'aRecordingStart'
1488
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4062761061)))) {
1489
mozilla::ipc::SentinelReadError("Error deserializing 'TimeStamp'");
1490
return MsgValueError;
1491
}
1492
msg__.EndRead(iter__, msg__.type());
1493
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvBeginRecording(std::move(aRecordingStart))))) {
1494
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1495
// Error handled in mozilla::ipc::IPCResult
1496
return MsgProcessingError;
1497
}
1498
1499
return MsgProcessed;
1500
}
1501
default:
1502
return MsgNotKnown;
1503
}
1504
}
1505
1506
auto PCompositorBridgeParent::OnMessageReceived(
1507
const Message& msg__,
1508
Message*& reply__) -> PCompositorBridgeParent::Result
1509
{
1510
switch (msg__.type()) {
1511
case PCompositorBridge::Msg_Initialize__ID:
1512
{
1513
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1514
mozilla::ipc::LogMessageForProtocol(
1515
"PCompositorBridgeParent",
1516
OtherPid(),
1517
"Received ",
1518
(&(msg__))->type(),
1519
mozilla::ipc::MessageDirection::eReceiving);
1520
}
1521
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_Initialize", OTHER);
1522
1523
PickleIterator iter__(msg__);
1524
LayersId rootLayerTreeId;
1525
1526
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(rootLayerTreeId)))))) {
1527
FatalError("Error deserializing 'LayersId'");
1528
return MsgValueError;
1529
}
1530
// Sentinel = 'rootLayerTreeId'
1531
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 191972583)))) {
1532
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
1533
return MsgValueError;
1534
}
1535
msg__.EndRead(iter__, msg__.type());
1536
int32_t id__ = Id();
1537
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvInitialize(std::move(rootLayerTreeId))))) {
1538
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1539
// Error handled in mozilla::ipc::IPCResult
1540
return MsgProcessingError;
1541
}
1542
1543
reply__ = PCompositorBridge::Reply_Initialize(id__);
1544
1545
1546
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1547
mozilla::ipc::LogMessageForProtocol(
1548
"PCompositorBridgeParent",
1549
OtherPid(),
1550
"Sending reply ",
1551
reply__->type(),
1552
mozilla::ipc::MessageDirection::eSending);
1553
}
1554
return MsgProcessed;
1555
}
1556
case PCompositorBridge::Msg_GetFrameUniformity__ID:
1557
{
1558
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1559
mozilla::ipc::LogMessageForProtocol(
1560
"PCompositorBridgeParent",
1561
OtherPid(),
1562
"Received ",
1563
(&(msg__))->type(),
1564
mozilla::ipc::MessageDirection::eReceiving);
1565
}
1566
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_GetFrameUniformity", OTHER);
1567
1568
int32_t id__ = Id();
1569
FrameUniformityData data;
1570
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvGetFrameUniformity((&(data)))))) {
1571
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1572
// Error handled in mozilla::ipc::IPCResult
1573
return MsgProcessingError;
1574
}
1575
1576
reply__ = PCompositorBridge::Reply_GetFrameUniformity(id__);
1577
1578
WriteIPDLParam(reply__, this, data);
1579
// Sentinel = 'data'
1580
(reply__)->WriteSentinel(843352540);
1581
1582
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1583
mozilla::ipc::LogMessageForProtocol(
1584
"PCompositorBridgeParent",
1585
OtherPid(),
1586
"Sending reply ",
1587
reply__->type(),
1588
mozilla::ipc::MessageDirection::eSending);
1589
}
1590
return MsgProcessed;
1591
}
1592
case PCompositorBridge::Msg_WillClose__ID:
1593
{
1594
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1595
mozilla::ipc::LogMessageForProtocol(
1596
"PCompositorBridgeParent",
1597
OtherPid(),
1598
"Received ",
1599
(&(msg__))->type(),
1600
mozilla::ipc::MessageDirection::eReceiving);
1601
}
1602
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_WillClose", OTHER);
1603
1604
int32_t id__ = Id();
1605
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvWillClose()))) {
1606
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1607
// Error handled in mozilla::ipc::IPCResult
1608
return MsgProcessingError;
1609
}
1610
1611
reply__ = PCompositorBridge::Reply_WillClose(id__);
1612
1613
1614
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1615
mozilla::ipc::LogMessageForProtocol(
1616
"PCompositorBridgeParent",
1617
OtherPid(),
1618
"Sending reply ",
1619
reply__->type(),
1620
mozilla::ipc::MessageDirection::eSending);
1621
}
1622
return MsgProcessed;
1623
}
1624
case PCompositorBridge::Msg_Pause__ID:
1625
{
1626
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1627
mozilla::ipc::LogMessageForProtocol(
1628
"PCompositorBridgeParent",
1629
OtherPid(),
1630
"Received ",
1631
(&(msg__))->type(),
1632
mozilla::ipc::MessageDirection::eReceiving);
1633
}
1634
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_Pause", OTHER);
1635
1636
int32_t id__ = Id();
1637
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvPause()))) {
1638
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1639
// Error handled in mozilla::ipc::IPCResult
1640
return MsgProcessingError;
1641
}
1642
1643
reply__ = PCompositorBridge::Reply_Pause(id__);
1644
1645
1646
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1647
mozilla::ipc::LogMessageForProtocol(
1648
"PCompositorBridgeParent",
1649
OtherPid(),
1650
"Sending reply ",
1651
reply__->type(),
1652
mozilla::ipc::MessageDirection::eSending);
1653
}
1654
return MsgProcessed;
1655
}
1656
case PCompositorBridge::Msg_Resume__ID:
1657
{
1658
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1659
mozilla::ipc::LogMessageForProtocol(
1660
"PCompositorBridgeParent",
1661
OtherPid(),
1662
"Received ",
1663
(&(msg__))->type(),
1664
mozilla::ipc::MessageDirection::eReceiving);
1665
}
1666
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_Resume", OTHER);
1667
1668
int32_t id__ = Id();
1669
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvResume()))) {
1670
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1671
// Error handled in mozilla::ipc::IPCResult
1672
return MsgProcessingError;
1673
}
1674
1675
reply__ = PCompositorBridge::Reply_Resume(id__);
1676
1677
1678
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1679
mozilla::ipc::LogMessageForProtocol(
1680
"PCompositorBridgeParent",
1681
OtherPid(),
1682
"Sending reply ",
1683
reply__->type(),
1684
mozilla::ipc::MessageDirection::eSending);
1685
}
1686
return MsgProcessed;
1687
}
1688
case PCompositorBridge::Msg_NotifyChildCreated__ID:
1689
{
1690
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1691
mozilla::ipc::LogMessageForProtocol(
1692
"PCompositorBridgeParent",
1693
OtherPid(),
1694
"Received ",
1695
(&(msg__))->type(),
1696
mozilla::ipc::MessageDirection::eReceiving);
1697
}
1698
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_NotifyChildCreated", OTHER);
1699
1700
PickleIterator iter__(msg__);
1701
LayersId id;
1702
1703
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(id)))))) {
1704
FatalError("Error deserializing 'LayersId'");
1705
return MsgValueError;
1706
}
1707
// Sentinel = 'id'
1708
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2794505629)))) {
1709
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
1710
return MsgValueError;
1711
}
1712
msg__.EndRead(iter__, msg__.type());
1713
int32_t id__ = Id();
1714
CompositorOptions compositorOptions;
1715
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvNotifyChildCreated(std::move(id), (&(compositorOptions)))))) {
1716
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1717
// Error handled in mozilla::ipc::IPCResult
1718
return MsgProcessingError;
1719
}
1720
1721
reply__ = PCompositorBridge::Reply_NotifyChildCreated(id__);
1722
1723
WriteIPDLParam(reply__, this, compositorOptions);
1724
// Sentinel = 'compositorOptions'
1725
(reply__)->WriteSentinel(1905928698);
1726
1727
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1728
mozilla::ipc::LogMessageForProtocol(
1729
"PCompositorBridgeParent",
1730
OtherPid(),
1731
"Sending reply ",
1732
reply__->type(),
1733
mozilla::ipc::MessageDirection::eSending);
1734
}
1735
return MsgProcessed;
1736
}
1737
case PCompositorBridge::Msg_MapAndNotifyChildCreated__ID:
1738
{
1739
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1740
mozilla::ipc::LogMessageForProtocol(
1741
"PCompositorBridgeParent",
1742
OtherPid(),
1743
"Received ",
1744
(&(msg__))->type(),
1745
mozilla::ipc::MessageDirection::eReceiving);
1746
}
1747
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_MapAndNotifyChildCreated", OTHER);
1748
1749
PickleIterator iter__(msg__);
1750
LayersId id;
1751
ProcessId owner;
1752
1753
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(id)))))) {
1754
FatalError("Error deserializing 'LayersId'");
1755
return MsgValueError;
1756
}
1757
// Sentinel = 'id'
1758
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2794505629)))) {
1759
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
1760
return MsgValueError;
1761
}
1762
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(owner)))))) {
1763
FatalError("Error deserializing 'ProcessId'");
1764
return MsgValueError;
1765
}
1766
// Sentinel = 'owner'
1767
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 622631704)))) {
1768
mozilla::ipc::SentinelReadError("Error deserializing 'ProcessId'");
1769
return MsgValueError;
1770
}
1771
msg__.EndRead(iter__, msg__.type());
1772
int32_t id__ = Id();
1773
CompositorOptions compositorOptions;
1774
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvMapAndNotifyChildCreated(std::move(id), std::move(owner), (&(compositorOptions)))))) {
1775
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1776
// Error handled in mozilla::ipc::IPCResult
1777
return MsgProcessingError;
1778
}
1779
1780
reply__ = PCompositorBridge::Reply_MapAndNotifyChildCreated(id__);
1781
1782
WriteIPDLParam(reply__, this, compositorOptions);
1783
// Sentinel = 'compositorOptions'
1784
(reply__)->WriteSentinel(1905928698);
1785
1786
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1787
mozilla::ipc::LogMessageForProtocol(
1788
"PCompositorBridgeParent",
1789
OtherPid(),
1790
"Sending reply ",
1791
reply__->type(),
1792
mozilla::ipc::MessageDirection::eSending);
1793
}
1794
return MsgProcessed;
1795
}
1796
case PCompositorBridge::Msg_NotifyChildRecreated__ID:
1797
{
1798
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1799
mozilla::ipc::LogMessageForProtocol(
1800
"PCompositorBridgeParent",
1801
OtherPid(),
1802
"Received ",
1803
(&(msg__))->type(),
1804
mozilla::ipc::MessageDirection::eReceiving);
1805
}
1806
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_NotifyChildRecreated", OTHER);
1807
1808
PickleIterator iter__(msg__);
1809
LayersId id;
1810
1811
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(id)))))) {
1812
FatalError("Error deserializing 'LayersId'");
1813
return MsgValueError;
1814
}
1815
// Sentinel = 'id'
1816
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2794505629)))) {
1817
mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
1818
return MsgValueError;
1819
}
1820
msg__.EndRead(iter__, msg__.type());
1821
int32_t id__ = Id();
1822
CompositorOptions compositorOptions;
1823
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvNotifyChildRecreated(std::move(id), (&(compositorOptions)))))) {
1824
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1825
// Error handled in mozilla::ipc::IPCResult
1826
return MsgProcessingError;
1827
}
1828
1829
reply__ = PCompositorBridge::Reply_NotifyChildRecreated(id__);
1830
1831
WriteIPDLParam(reply__, this, compositorOptions);
1832
// Sentinel = 'compositorOptions'
1833
(reply__)->WriteSentinel(1905928698);
1834
1835
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1836
mozilla::ipc::LogMessageForProtocol(
1837
"PCompositorBridgeParent",
1838
OtherPid(),
1839
"Sending reply ",
1840
reply__->type(),
1841
mozilla::ipc::MessageDirection::eSending);
1842
}
1843
return MsgProcessed;
1844
}
1845
case PCompositorBridge::Msg_MakeSnapshot__ID:
1846
{
1847
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1848
mozilla::ipc::LogMessageForProtocol(
1849
"PCompositorBridgeParent",
1850
OtherPid(),
1851
"Received ",
1852
(&(msg__))->type(),
1853
mozilla::ipc::MessageDirection::eReceiving);
1854
}
1855
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_MakeSnapshot", OTHER);
1856
1857
PickleIterator iter__(msg__);
1858
SurfaceDescriptor inSnapshot;
1859
IntRect dirtyRect;
1860
1861
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(inSnapshot)))))) {
1862
FatalError("Error deserializing 'SurfaceDescriptor'");
1863
return MsgValueError;
1864
}
1865
// Sentinel = 'inSnapshot'
1866
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1570595367)))) {
1867
mozilla::ipc::SentinelReadError("Error deserializing 'SurfaceDescriptor'");
1868
return MsgValueError;
1869
}
1870
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(dirtyRect)))))) {
1871
FatalError("Error deserializing 'IntRect'");
1872
return MsgValueError;
1873
}
1874
// Sentinel = 'dirtyRect'
1875
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1726016483)))) {
1876
mozilla::ipc::SentinelReadError("Error deserializing 'IntRect'");
1877
return MsgValueError;
1878
}
1879
msg__.EndRead(iter__, msg__.type());
1880
int32_t id__ = Id();
1881
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvMakeSnapshot(std::move(inSnapshot), std::move(dirtyRect))))) {
1882
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1883
// Error handled in mozilla::ipc::IPCResult
1884
return MsgProcessingError;
1885
}
1886
1887
reply__ = PCompositorBridge::Reply_MakeSnapshot(id__);
1888
1889
1890
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1891
mozilla::ipc::LogMessageForProtocol(
1892
"PCompositorBridgeParent",
1893
OtherPid(),
1894
"Sending reply ",
1895
reply__->type(),
1896
mozilla::ipc::MessageDirection::eSending);
1897
}
1898
return MsgProcessed;
1899
}
1900
case PCompositorBridge::Msg_FlushRendering__ID:
1901
{
1902
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1903
mozilla::ipc::LogMessageForProtocol(
1904
"PCompositorBridgeParent",
1905
OtherPid(),
1906
"Received ",
1907
(&(msg__))->type(),
1908
mozilla::ipc::MessageDirection::eReceiving);
1909
}
1910
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_FlushRendering", OTHER);
1911
1912
int32_t id__ = Id();
1913
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvFlushRendering()))) {
1914
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1915
// Error handled in mozilla::ipc::IPCResult
1916
return MsgProcessingError;
1917
}
1918
1919
reply__ = PCompositorBridge::Reply_FlushRendering(id__);
1920
1921
1922
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1923
mozilla::ipc::LogMessageForProtocol(
1924
"PCompositorBridgeParent",
1925
OtherPid(),
1926
"Sending reply ",
1927
reply__->type(),
1928
mozilla::ipc::MessageDirection::eSending);
1929
}
1930
return MsgProcessed;
1931
}
1932
case PCompositorBridge::Msg_WaitOnTransactionProcessed__ID:
1933
{
1934
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1935
mozilla::ipc::LogMessageForProtocol(
1936
"PCompositorBridgeParent",
1937
OtherPid(),
1938
"Received ",
1939
(&(msg__))->type(),
1940
mozilla::ipc::MessageDirection::eReceiving);
1941
}
1942
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_WaitOnTransactionProcessed", OTHER);
1943
1944
int32_t id__ = Id();
1945
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvWaitOnTransactionProcessed()))) {
1946
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1947
// Error handled in mozilla::ipc::IPCResult
1948
return MsgProcessingError;
1949
}
1950
1951
reply__ = PCompositorBridge::Reply_WaitOnTransactionProcessed(id__);
1952
1953
1954
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1955
mozilla::ipc::LogMessageForProtocol(
1956
"PCompositorBridgeParent",
1957
OtherPid(),
1958
"Sending reply ",
1959
reply__->type(),
1960
mozilla::ipc::MessageDirection::eSending);
1961
}
1962
return MsgProcessed;
1963
}
1964
case PCompositorBridge::Msg_StartFrameTimeRecording__ID:
1965
{
1966
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
1967
mozilla::ipc::LogMessageForProtocol(
1968
"PCompositorBridgeParent",
1969
OtherPid(),
1970
"Received ",
1971
(&(msg__))->type(),
1972
mozilla::ipc::MessageDirection::eReceiving);
1973
}
1974
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_StartFrameTimeRecording", OTHER);
1975
1976
PickleIterator iter__(msg__);
1977
int32_t bufferSize;
1978
1979
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(bufferSize)))))) {
1980
FatalError("Error deserializing 'int32_t'");
1981
return MsgValueError;
1982
}
1983
// Sentinel = 'bufferSize'
1984
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3444538779)))) {
1985
mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
1986
return MsgValueError;
1987
}
1988
msg__.EndRead(iter__, msg__.type());
1989
int32_t id__ = Id();
1990
uint32_t startIndex;
1991
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvStartFrameTimeRecording(std::move(bufferSize), (&(startIndex)))))) {
1992
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1993
// Error handled in mozilla::ipc::IPCResult
1994
return MsgProcessingError;
1995
}
1996
1997
reply__ = PCompositorBridge::Reply_StartFrameTimeRecording(id__);
1998
1999
WriteIPDLParam(reply__, this, startIndex);
2000
// Sentinel = 'startIndex'
2001
(reply__)->WriteSentinel(4220530450);
2002
2003
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
2004
mozilla::ipc::LogMessageForProtocol(
2005
"PCompositorBridgeParent",
2006
OtherPid(),
2007
"Sending reply ",
2008
reply__->type(),
2009
mozilla::ipc::MessageDirection::eSending);
2010
}
2011
return MsgProcessed;
2012
}
2013
case PCompositorBridge::Msg_StopFrameTimeRecording__ID:
2014
{
2015
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
2016
mozilla::ipc::LogMessageForProtocol(
2017
"PCompositorBridgeParent",
2018
OtherPid(),
2019
"Received ",
2020
(&(msg__))->type(),
2021
mozilla::ipc::MessageDirection::eReceiving);
2022
}
2023
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_StopFrameTimeRecording", OTHER);
2024
2025
PickleIterator iter__(msg__);
2026
uint32_t startIndex;
2027
2028
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(startIndex)))))) {
2029
FatalError("Error deserializing 'uint32_t'");
2030
return MsgValueError;
2031
}
2032
// Sentinel = 'startIndex'
2033
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4220530450)))) {
2034
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
2035
return MsgValueError;
2036
}
2037
msg__.EndRead(iter__, msg__.type());
2038
int32_t id__ = Id();
2039
nsTArray<float> intervals;
2040
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvStopFrameTimeRecording(std::move(startIndex), (&(intervals)))))) {
2041
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
2042
// Error handled in mozilla::ipc::IPCResult
2043
return MsgProcessingError;
2044
}
2045
2046
reply__ = PCompositorBridge::Reply_StopFrameTimeRecording(id__);
2047
2048
WriteIPDLParam(reply__, this, intervals);
2049
// Sentinel = 'intervals'
2050
(reply__)->WriteSentinel(470677011);
2051
2052
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
2053
mozilla::ipc::LogMessageForProtocol(
2054
"PCompositorBridgeParent",
2055
OtherPid(),
2056
"Sending reply ",
2057
reply__->type(),
2058
mozilla::ipc::MessageDirection::eSending);
2059
}
2060
return MsgProcessed;
2061
}
2062
case PCompositorBridge::Msg_SyncWithCompositor__ID:
2063
{
2064
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
2065
mozilla::ipc::LogMessageForProtocol(
2066
"PCompositorBridgeParent",
2067
OtherPid(),
2068
"Received ",
2069
(&(msg__))->type(),
2070
mozilla::ipc::MessageDirection::eReceiving);
2071
}
2072
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_SyncWithCompositor", OTHER);
2073
2074
int32_t id__ = Id();
2075
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvSyncWithCompositor()))) {
2076
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
2077
// Error handled in mozilla::ipc::IPCResult
2078
return MsgProcessingError;
2079
}
2080
2081
reply__ = PCompositorBridge::Reply_SyncWithCompositor(id__);
2082
2083
2084
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
2085
mozilla::ipc::LogMessageForProtocol(
2086
"PCompositorBridgeParent",
2087
OtherPid(),
2088
"Sending reply ",
2089
reply__->type(),
2090
mozilla::ipc::MessageDirection::eSending);
2091
}
2092
return MsgProcessed;
2093
}
2094
case PCompositorBridge::Msg_CheckContentOnlyTDR__ID:
2095
{
2096
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
2097
mozilla::ipc::LogMessageForProtocol(
2098
"PCompositorBridgeParent",
2099
OtherPid(),
2100
"Received ",
2101
(&(msg__))->type(),
2102
mozilla::ipc::MessageDirection::eReceiving);
2103
}
2104
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_CheckContentOnlyTDR", OTHER);
2105
2106
PickleIterator iter__(msg__);
2107
uint32_t sequenceNum;
2108
2109
if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(sequenceNum)))))) {
2110
FatalError("Error deserializing 'uint32_t'");
2111
return MsgValueError;
2112
}
2113
// Sentinel = 'sequenceNum'
2114
if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1222681202)))) {
2115
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
2116
return MsgValueError;
2117
}
2118
msg__.EndRead(iter__, msg__.type());
2119
int32_t id__ = Id();
2120
bool isContentOnlyTDR;
2121
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvCheckContentOnlyTDR(std::move(sequenceNum), (&(isContentOnlyTDR)))))) {
2122
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
2123
// Error handled in mozilla::ipc::IPCResult
2124
return MsgProcessingError;
2125
}
2126
2127
reply__ = PCompositorBridge::Reply_CheckContentOnlyTDR(id__);
2128
2129
WriteIPDLParam(reply__, this, isContentOnlyTDR);
2130
// Sentinel = 'isContentOnlyTDR'
2131
(reply__)->WriteSentinel(1577543213);
2132
2133
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
2134
mozilla::ipc::LogMessageForProtocol(
2135
"PCompositorBridgeParent",
2136
OtherPid(),
2137
"Sending reply ",
2138
reply__->type(),
2139
mozilla::ipc::MessageDirection::eSending);
2140
}
2141
return MsgProcessed;
2142
}
2143
case PCompositorBridge::Msg_EndRecording__ID:
2144
{
2145
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
2146
mozilla::ipc::LogMessageForProtocol(
2147
"PCompositorBridgeParent",
2148
OtherPid(),
2149
"Received ",
2150
(&(msg__))->type(),
2151
mozilla::ipc::MessageDirection::eReceiving);
2152
}
2153
AUTO_PROFILER_LABEL("PCompositorBridge::Msg_EndRecording", OTHER);
2154
2155
int32_t id__ = Id();
2156
if ((!((static_cast<CompositorBridgeParentBase*>(this))->RecvEndRecording()))) {
2157
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
2158
// Error handled in mozilla::ipc::IPCResult
2159
return MsgProcessingError;
2160
}
2161
2162
reply__ = PCompositorBridge::Reply_EndRecording(id__);
2163
2164
2165
if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
2166
mozilla::ipc::LogMessageForProtocol(
2167
"PCompositorBridgeParent",
2168
OtherPid(),
2169
"Sending reply ",
2170
reply__->type(),
2171
mozilla::ipc::MessageDirection::eSending);