Line data Source code
1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 :
7 : #include "mozilla/ipc/PBackgroundChild.h"
8 : #ifdef MOZ_CRASHREPORTER
9 : # include "nsXULAppAPI.h"
10 : #endif
11 :
12 : #include "mozilla/dom/asmjscache/PAsmJSCacheEntryChild.h"
13 : #include "mozilla/dom/indexedDB/PBackgroundIDBFactoryChild.h"
14 : #include "mozilla/dom/indexedDB/PBackgroundIndexedDBUtilsChild.h"
15 : #include "mozilla/ipc/PBackgroundTestChild.h"
16 : #include "mozilla/dom/PBroadcastChannelChild.h"
17 : #include "mozilla/dom/cache/PCacheChild.h"
18 : #include "mozilla/dom/cache/PCacheStorageChild.h"
19 : #include "mozilla/dom/cache/PCacheStreamControlChild.h"
20 : #include "mozilla/ipc/PFileDescriptorSetChild.h"
21 : #include "mozilla/dom/PFileSystemRequestChild.h"
22 : #include "mozilla/dom/PGamepadEventChannelChild.h"
23 : #include "mozilla/dom/PGamepadTestChannelChild.h"
24 : #include "mozilla/net/PHttpBackgroundChannelChild.h"
25 : #include "mozilla/ipc/PIPCBlobInputStreamChild.h"
26 : #include "mozilla/ipc/PPendingIPCBlobChild.h"
27 : #include "mozilla/dom/PMessagePortChild.h"
28 : #include "mozilla/camera/PCamerasChild.h"
29 : #include "mozilla/dom/quota/PQuotaChild.h"
30 : #include "mozilla/ipc/PChildToParentStreamChild.h"
31 : #include "mozilla/ipc/PParentToChildStreamChild.h"
32 : #include "mozilla/dom/PServiceWorkerManagerChild.h"
33 : #include "mozilla/dom/PWebAuthnTransactionChild.h"
34 : #include "mozilla/net/PUDPSocketChild.h"
35 : #include "mozilla/layout/PVsyncChild.h"
36 :
37 : #include "nsIFile.h"
38 : #include "GeckoProfiler.h"
39 :
40 : namespace mozilla {
41 : namespace ipc {
42 :
43 :
44 0 : auto PBackgroundChild::RecvPCacheConstructor(PCacheChild* actor) -> mozilla::ipc::IPCResult
45 : {
46 0 : return IPC_OK();
47 : }
48 :
49 0 : auto PBackgroundChild::RecvPCacheStreamControlConstructor(PCacheStreamControlChild* actor) -> mozilla::ipc::IPCResult
50 : {
51 0 : return IPC_OK();
52 : }
53 :
54 0 : auto PBackgroundChild::RecvPParentToChildStreamConstructor(PParentToChildStreamChild* actor) -> mozilla::ipc::IPCResult
55 : {
56 0 : return IPC_OK();
57 : }
58 :
59 0 : auto PBackgroundChild::RecvPPendingIPCBlobConstructor(
60 : PPendingIPCBlobChild* actor,
61 : const IPCBlob& blob) -> mozilla::ipc::IPCResult
62 : {
63 0 : return IPC_OK();
64 : }
65 :
66 0 : auto PBackgroundChild::RecvPIPCBlobInputStreamConstructor(
67 : PIPCBlobInputStreamChild* actor,
68 : const nsID& aID,
69 : const uint64_t& aSize) -> mozilla::ipc::IPCResult
70 : {
71 0 : return IPC_OK();
72 : }
73 :
74 0 : auto PBackgroundChild::RecvPFileDescriptorSetConstructor(
75 : PFileDescriptorSetChild* actor,
76 : const FileDescriptor& fd) -> mozilla::ipc::IPCResult
77 : {
78 0 : return IPC_OK();
79 : }
80 :
81 0 : auto PBackgroundChild::ActorDestroy(ActorDestroyReason aWhy) -> void
82 : {
83 0 : }
84 :
85 0 : auto PBackgroundChild::ProcessingError(
86 : Result aCode,
87 : const char* aReason) -> void
88 : {
89 0 : }
90 :
91 0 : auto PBackgroundChild::ShouldContinueFromReplyTimeout() -> bool
92 : {
93 0 : return true;
94 : }
95 :
96 31 : auto PBackgroundChild::EnteredCxxStack() -> void
97 : {
98 31 : }
99 :
100 31 : auto PBackgroundChild::ExitedCxxStack() -> void
101 : {
102 31 : }
103 :
104 0 : auto PBackgroundChild::EnteredCall() -> void
105 : {
106 0 : }
107 :
108 0 : auto PBackgroundChild::ExitedCall() -> void
109 : {
110 0 : }
111 :
112 5 : MOZ_IMPLICIT PBackgroundChild::PBackgroundChild() :
113 : mozilla::ipc::IToplevelProtocol(PBackgroundMsgStart, mozilla::ipc::ChildSide),
114 : mChannel("PBackgroundChild", ALLOW_THIS_IN_INITIALIZER_LIST(this)),
115 5 : mState(PBackground::__Start)
116 : {
117 5 : MOZ_COUNT_CTOR(PBackgroundChild);
118 5 : }
119 :
120 0 : PBackgroundChild::~PBackgroundChild()
121 : {
122 0 : MOZ_COUNT_DTOR(PBackgroundChild);
123 0 : }
124 :
125 0 : auto PBackgroundChild::ManagedPAsmJSCacheEntryChild(nsTArray<PAsmJSCacheEntryChild*>& aArr) const -> void
126 : {
127 0 : (mManagedPAsmJSCacheEntryChild).ToArray(aArr);
128 0 : }
129 :
130 0 : auto PBackgroundChild::ManagedPAsmJSCacheEntryChild() const -> const ManagedContainer<PAsmJSCacheEntryChild>&
131 : {
132 0 : return mManagedPAsmJSCacheEntryChild;
133 : }
134 :
135 0 : auto PBackgroundChild::ManagedPBackgroundIDBFactoryChild(nsTArray<PBackgroundIDBFactoryChild*>& aArr) const -> void
136 : {
137 0 : (mManagedPBackgroundIDBFactoryChild).ToArray(aArr);
138 0 : }
139 :
140 0 : auto PBackgroundChild::ManagedPBackgroundIDBFactoryChild() const -> const ManagedContainer<PBackgroundIDBFactoryChild>&
141 : {
142 0 : return mManagedPBackgroundIDBFactoryChild;
143 : }
144 :
145 0 : auto PBackgroundChild::ManagedPBackgroundIndexedDBUtilsChild(nsTArray<PBackgroundIndexedDBUtilsChild*>& aArr) const -> void
146 : {
147 0 : (mManagedPBackgroundIndexedDBUtilsChild).ToArray(aArr);
148 0 : }
149 :
150 0 : auto PBackgroundChild::ManagedPBackgroundIndexedDBUtilsChild() const -> const ManagedContainer<PBackgroundIndexedDBUtilsChild>&
151 : {
152 0 : return mManagedPBackgroundIndexedDBUtilsChild;
153 : }
154 :
155 0 : auto PBackgroundChild::ManagedPBackgroundTestChild(nsTArray<PBackgroundTestChild*>& aArr) const -> void
156 : {
157 0 : (mManagedPBackgroundTestChild).ToArray(aArr);
158 0 : }
159 :
160 0 : auto PBackgroundChild::ManagedPBackgroundTestChild() const -> const ManagedContainer<PBackgroundTestChild>&
161 : {
162 0 : return mManagedPBackgroundTestChild;
163 : }
164 :
165 0 : auto PBackgroundChild::ManagedPBroadcastChannelChild(nsTArray<PBroadcastChannelChild*>& aArr) const -> void
166 : {
167 0 : (mManagedPBroadcastChannelChild).ToArray(aArr);
168 0 : }
169 :
170 0 : auto PBackgroundChild::ManagedPBroadcastChannelChild() const -> const ManagedContainer<PBroadcastChannelChild>&
171 : {
172 0 : return mManagedPBroadcastChannelChild;
173 : }
174 :
175 0 : auto PBackgroundChild::ManagedPCacheChild(nsTArray<PCacheChild*>& aArr) const -> void
176 : {
177 0 : (mManagedPCacheChild).ToArray(aArr);
178 0 : }
179 :
180 0 : auto PBackgroundChild::ManagedPCacheChild() const -> const ManagedContainer<PCacheChild>&
181 : {
182 0 : return mManagedPCacheChild;
183 : }
184 :
185 0 : auto PBackgroundChild::ManagedPCacheStorageChild(nsTArray<PCacheStorageChild*>& aArr) const -> void
186 : {
187 0 : (mManagedPCacheStorageChild).ToArray(aArr);
188 0 : }
189 :
190 0 : auto PBackgroundChild::ManagedPCacheStorageChild() const -> const ManagedContainer<PCacheStorageChild>&
191 : {
192 0 : return mManagedPCacheStorageChild;
193 : }
194 :
195 0 : auto PBackgroundChild::ManagedPCacheStreamControlChild(nsTArray<PCacheStreamControlChild*>& aArr) const -> void
196 : {
197 0 : (mManagedPCacheStreamControlChild).ToArray(aArr);
198 0 : }
199 :
200 0 : auto PBackgroundChild::ManagedPCacheStreamControlChild() const -> const ManagedContainer<PCacheStreamControlChild>&
201 : {
202 0 : return mManagedPCacheStreamControlChild;
203 : }
204 :
205 0 : auto PBackgroundChild::ManagedPFileDescriptorSetChild(nsTArray<PFileDescriptorSetChild*>& aArr) const -> void
206 : {
207 0 : (mManagedPFileDescriptorSetChild).ToArray(aArr);
208 0 : }
209 :
210 0 : auto PBackgroundChild::ManagedPFileDescriptorSetChild() const -> const ManagedContainer<PFileDescriptorSetChild>&
211 : {
212 0 : return mManagedPFileDescriptorSetChild;
213 : }
214 :
215 0 : auto PBackgroundChild::ManagedPFileSystemRequestChild(nsTArray<PFileSystemRequestChild*>& aArr) const -> void
216 : {
217 0 : (mManagedPFileSystemRequestChild).ToArray(aArr);
218 0 : }
219 :
220 0 : auto PBackgroundChild::ManagedPFileSystemRequestChild() const -> const ManagedContainer<PFileSystemRequestChild>&
221 : {
222 0 : return mManagedPFileSystemRequestChild;
223 : }
224 :
225 0 : auto PBackgroundChild::ManagedPGamepadEventChannelChild(nsTArray<PGamepadEventChannelChild*>& aArr) const -> void
226 : {
227 0 : (mManagedPGamepadEventChannelChild).ToArray(aArr);
228 0 : }
229 :
230 0 : auto PBackgroundChild::ManagedPGamepadEventChannelChild() const -> const ManagedContainer<PGamepadEventChannelChild>&
231 : {
232 0 : return mManagedPGamepadEventChannelChild;
233 : }
234 :
235 0 : auto PBackgroundChild::ManagedPGamepadTestChannelChild(nsTArray<PGamepadTestChannelChild*>& aArr) const -> void
236 : {
237 0 : (mManagedPGamepadTestChannelChild).ToArray(aArr);
238 0 : }
239 :
240 0 : auto PBackgroundChild::ManagedPGamepadTestChannelChild() const -> const ManagedContainer<PGamepadTestChannelChild>&
241 : {
242 0 : return mManagedPGamepadTestChannelChild;
243 : }
244 :
245 0 : auto PBackgroundChild::ManagedPHttpBackgroundChannelChild(nsTArray<PHttpBackgroundChannelChild*>& aArr) const -> void
246 : {
247 0 : (mManagedPHttpBackgroundChannelChild).ToArray(aArr);
248 0 : }
249 :
250 0 : auto PBackgroundChild::ManagedPHttpBackgroundChannelChild() const -> const ManagedContainer<PHttpBackgroundChannelChild>&
251 : {
252 0 : return mManagedPHttpBackgroundChannelChild;
253 : }
254 :
255 0 : auto PBackgroundChild::ManagedPIPCBlobInputStreamChild(nsTArray<PIPCBlobInputStreamChild*>& aArr) const -> void
256 : {
257 0 : (mManagedPIPCBlobInputStreamChild).ToArray(aArr);
258 0 : }
259 :
260 0 : auto PBackgroundChild::ManagedPIPCBlobInputStreamChild() const -> const ManagedContainer<PIPCBlobInputStreamChild>&
261 : {
262 0 : return mManagedPIPCBlobInputStreamChild;
263 : }
264 :
265 0 : auto PBackgroundChild::ManagedPPendingIPCBlobChild(nsTArray<PPendingIPCBlobChild*>& aArr) const -> void
266 : {
267 0 : (mManagedPPendingIPCBlobChild).ToArray(aArr);
268 0 : }
269 :
270 0 : auto PBackgroundChild::ManagedPPendingIPCBlobChild() const -> const ManagedContainer<PPendingIPCBlobChild>&
271 : {
272 0 : return mManagedPPendingIPCBlobChild;
273 : }
274 :
275 0 : auto PBackgroundChild::ManagedPMessagePortChild(nsTArray<PMessagePortChild*>& aArr) const -> void
276 : {
277 0 : (mManagedPMessagePortChild).ToArray(aArr);
278 0 : }
279 :
280 0 : auto PBackgroundChild::ManagedPMessagePortChild() const -> const ManagedContainer<PMessagePortChild>&
281 : {
282 0 : return mManagedPMessagePortChild;
283 : }
284 :
285 0 : auto PBackgroundChild::ManagedPCamerasChild(nsTArray<PCamerasChild*>& aArr) const -> void
286 : {
287 0 : (mManagedPCamerasChild).ToArray(aArr);
288 0 : }
289 :
290 0 : auto PBackgroundChild::ManagedPCamerasChild() const -> const ManagedContainer<PCamerasChild>&
291 : {
292 0 : return mManagedPCamerasChild;
293 : }
294 :
295 0 : auto PBackgroundChild::ManagedPQuotaChild(nsTArray<PQuotaChild*>& aArr) const -> void
296 : {
297 0 : (mManagedPQuotaChild).ToArray(aArr);
298 0 : }
299 :
300 0 : auto PBackgroundChild::ManagedPQuotaChild() const -> const ManagedContainer<PQuotaChild>&
301 : {
302 0 : return mManagedPQuotaChild;
303 : }
304 :
305 0 : auto PBackgroundChild::ManagedPChildToParentStreamChild(nsTArray<PChildToParentStreamChild*>& aArr) const -> void
306 : {
307 0 : (mManagedPChildToParentStreamChild).ToArray(aArr);
308 0 : }
309 :
310 0 : auto PBackgroundChild::ManagedPChildToParentStreamChild() const -> const ManagedContainer<PChildToParentStreamChild>&
311 : {
312 0 : return mManagedPChildToParentStreamChild;
313 : }
314 :
315 0 : auto PBackgroundChild::ManagedPParentToChildStreamChild(nsTArray<PParentToChildStreamChild*>& aArr) const -> void
316 : {
317 0 : (mManagedPParentToChildStreamChild).ToArray(aArr);
318 0 : }
319 :
320 0 : auto PBackgroundChild::ManagedPParentToChildStreamChild() const -> const ManagedContainer<PParentToChildStreamChild>&
321 : {
322 0 : return mManagedPParentToChildStreamChild;
323 : }
324 :
325 0 : auto PBackgroundChild::ManagedPServiceWorkerManagerChild(nsTArray<PServiceWorkerManagerChild*>& aArr) const -> void
326 : {
327 0 : (mManagedPServiceWorkerManagerChild).ToArray(aArr);
328 0 : }
329 :
330 0 : auto PBackgroundChild::ManagedPServiceWorkerManagerChild() const -> const ManagedContainer<PServiceWorkerManagerChild>&
331 : {
332 0 : return mManagedPServiceWorkerManagerChild;
333 : }
334 :
335 0 : auto PBackgroundChild::ManagedPWebAuthnTransactionChild(nsTArray<PWebAuthnTransactionChild*>& aArr) const -> void
336 : {
337 0 : (mManagedPWebAuthnTransactionChild).ToArray(aArr);
338 0 : }
339 :
340 0 : auto PBackgroundChild::ManagedPWebAuthnTransactionChild() const -> const ManagedContainer<PWebAuthnTransactionChild>&
341 : {
342 0 : return mManagedPWebAuthnTransactionChild;
343 : }
344 :
345 0 : auto PBackgroundChild::ManagedPUDPSocketChild(nsTArray<PUDPSocketChild*>& aArr) const -> void
346 : {
347 0 : (mManagedPUDPSocketChild).ToArray(aArr);
348 0 : }
349 :
350 0 : auto PBackgroundChild::ManagedPUDPSocketChild() const -> const ManagedContainer<PUDPSocketChild>&
351 : {
352 0 : return mManagedPUDPSocketChild;
353 : }
354 :
355 0 : auto PBackgroundChild::ManagedPVsyncChild(nsTArray<PVsyncChild*>& aArr) const -> void
356 : {
357 0 : (mManagedPVsyncChild).ToArray(aArr);
358 0 : }
359 :
360 0 : auto PBackgroundChild::ManagedPVsyncChild() const -> const ManagedContainer<PVsyncChild>&
361 : {
362 0 : return mManagedPVsyncChild;
363 : }
364 :
365 0 : auto PBackgroundChild::SendPBackgroundTestConstructor(const nsCString& testArg) -> PBackgroundTestChild*
366 : {
367 0 : return SendPBackgroundTestConstructor(AllocPBackgroundTestChild(testArg), testArg);
368 : }
369 :
370 0 : auto PBackgroundChild::SendPBackgroundTestConstructor(
371 : PBackgroundTestChild* actor,
372 : const nsCString& testArg) -> PBackgroundTestChild*
373 : {
374 0 : if ((!(actor))) {
375 0 : NS_WARNING("Error constructing actor PBackgroundTestChild");
376 0 : return nullptr;
377 : }
378 0 : (actor)->SetManager(this);
379 0 : Register(actor);
380 0 : (actor)->SetIPCChannel(GetIPCChannel());
381 0 : (mManagedPBackgroundTestChild).PutEntry(actor);
382 0 : (actor)->mState = mozilla::ipc::PBackgroundTest::__Start;
383 :
384 0 : IPC::Message* msg__ = PBackground::Msg_PBackgroundTestConstructor(MSG_ROUTING_CONTROL);
385 :
386 0 : Write(actor, msg__, false);
387 : // Sentinel = 'actor'
388 0 : (msg__)->WriteSentinel(875202478);
389 0 : Write(testArg, msg__);
390 : // Sentinel = 'testArg'
391 0 : (msg__)->WriteSentinel(2144009831);
392 :
393 0 : (msg__)->set_constructor();
394 :
395 :
396 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
397 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
398 : }
399 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundTestConstructor", OTHER);
400 0 : PBackground::Transition(PBackground::Msg_PBackgroundTestConstructor__ID, (&(mState)));
401 :
402 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
403 0 : if ((!(sendok__))) {
404 0 : FatalError("constructor for actor failed");
405 0 : return nullptr;
406 : }
407 0 : return actor;
408 : }
409 :
410 0 : auto PBackgroundChild::SendPBackgroundIDBFactoryConstructor(const LoggingInfo& loggingInfo) -> PBackgroundIDBFactoryChild*
411 : {
412 0 : return SendPBackgroundIDBFactoryConstructor(AllocPBackgroundIDBFactoryChild(loggingInfo), loggingInfo);
413 : }
414 :
415 0 : auto PBackgroundChild::SendPBackgroundIDBFactoryConstructor(
416 : PBackgroundIDBFactoryChild* actor,
417 : const LoggingInfo& loggingInfo) -> PBackgroundIDBFactoryChild*
418 : {
419 0 : if ((!(actor))) {
420 0 : NS_WARNING("Error constructing actor PBackgroundIDBFactoryChild");
421 0 : return nullptr;
422 : }
423 0 : (actor)->SetManager(this);
424 0 : Register(actor);
425 0 : (actor)->SetIPCChannel(GetIPCChannel());
426 0 : (mManagedPBackgroundIDBFactoryChild).PutEntry(actor);
427 0 : (actor)->mState = mozilla::dom::indexedDB::PBackgroundIDBFactory::__Start;
428 :
429 0 : IPC::Message* msg__ = PBackground::Msg_PBackgroundIDBFactoryConstructor(MSG_ROUTING_CONTROL);
430 :
431 0 : Write(actor, msg__, false);
432 : // Sentinel = 'actor'
433 0 : (msg__)->WriteSentinel(875202478);
434 0 : Write(loggingInfo, msg__);
435 : // Sentinel = 'loggingInfo'
436 0 : (msg__)->WriteSentinel(753102592);
437 :
438 0 : (msg__)->set_constructor();
439 :
440 :
441 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
442 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
443 : }
444 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundIDBFactoryConstructor", OTHER);
445 0 : PBackground::Transition(PBackground::Msg_PBackgroundIDBFactoryConstructor__ID, (&(mState)));
446 :
447 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
448 0 : if ((!(sendok__))) {
449 0 : FatalError("constructor for actor failed");
450 0 : return nullptr;
451 : }
452 0 : return actor;
453 : }
454 :
455 0 : auto PBackgroundChild::SendPBackgroundIndexedDBUtilsConstructor() -> PBackgroundIndexedDBUtilsChild*
456 : {
457 0 : return SendPBackgroundIndexedDBUtilsConstructor(AllocPBackgroundIndexedDBUtilsChild());
458 : }
459 :
460 0 : auto PBackgroundChild::SendPBackgroundIndexedDBUtilsConstructor(PBackgroundIndexedDBUtilsChild* actor) -> PBackgroundIndexedDBUtilsChild*
461 : {
462 0 : if ((!(actor))) {
463 0 : NS_WARNING("Error constructing actor PBackgroundIndexedDBUtilsChild");
464 0 : return nullptr;
465 : }
466 0 : (actor)->SetManager(this);
467 0 : Register(actor);
468 0 : (actor)->SetIPCChannel(GetIPCChannel());
469 0 : (mManagedPBackgroundIndexedDBUtilsChild).PutEntry(actor);
470 0 : (actor)->mState = mozilla::dom::indexedDB::PBackgroundIndexedDBUtils::__Start;
471 :
472 0 : IPC::Message* msg__ = PBackground::Msg_PBackgroundIndexedDBUtilsConstructor(MSG_ROUTING_CONTROL);
473 :
474 0 : Write(actor, msg__, false);
475 : // Sentinel = 'actor'
476 0 : (msg__)->WriteSentinel(875202478);
477 :
478 0 : (msg__)->set_constructor();
479 :
480 :
481 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
482 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
483 : }
484 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PBackgroundIndexedDBUtilsConstructor", OTHER);
485 0 : PBackground::Transition(PBackground::Msg_PBackgroundIndexedDBUtilsConstructor__ID, (&(mState)));
486 :
487 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
488 0 : if ((!(sendok__))) {
489 0 : FatalError("constructor for actor failed");
490 0 : return nullptr;
491 : }
492 0 : return actor;
493 : }
494 :
495 0 : auto PBackgroundChild::SendFlushPendingFileDeletions() -> bool
496 : {
497 0 : IPC::Message* msg__ = PBackground::Msg_FlushPendingFileDeletions(MSG_ROUTING_CONTROL);
498 :
499 :
500 :
501 :
502 :
503 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
504 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
505 : }
506 0 : AUTO_PROFILER_LABEL("PBackground::Msg_FlushPendingFileDeletions", OTHER);
507 0 : PBackground::Transition(PBackground::Msg_FlushPendingFileDeletions__ID, (&(mState)));
508 :
509 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
510 0 : return sendok__;
511 : }
512 :
513 1 : auto PBackgroundChild::SendPVsyncConstructor() -> PVsyncChild*
514 : {
515 1 : return SendPVsyncConstructor(AllocPVsyncChild());
516 : }
517 :
518 1 : auto PBackgroundChild::SendPVsyncConstructor(PVsyncChild* actor) -> PVsyncChild*
519 : {
520 1 : if ((!(actor))) {
521 0 : NS_WARNING("Error constructing actor PVsyncChild");
522 0 : return nullptr;
523 : }
524 1 : (actor)->SetManager(this);
525 1 : Register(actor);
526 1 : (actor)->SetIPCChannel(GetIPCChannel());
527 1 : (mManagedPVsyncChild).PutEntry(actor);
528 1 : (actor)->mState = mozilla::layout::PVsync::__Start;
529 :
530 1 : IPC::Message* msg__ = PBackground::Msg_PVsyncConstructor(MSG_ROUTING_CONTROL);
531 :
532 1 : Write(actor, msg__, false);
533 : // Sentinel = 'actor'
534 1 : (msg__)->WriteSentinel(875202478);
535 :
536 1 : (msg__)->set_constructor();
537 :
538 :
539 1 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
540 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
541 : }
542 2 : AUTO_PROFILER_LABEL("PBackground::Msg_PVsyncConstructor", OTHER);
543 1 : PBackground::Transition(PBackground::Msg_PVsyncConstructor__ID, (&(mState)));
544 :
545 1 : bool sendok__ = (GetIPCChannel())->Send(msg__);
546 1 : if ((!(sendok__))) {
547 0 : FatalError("constructor for actor failed");
548 0 : return nullptr;
549 : }
550 1 : return actor;
551 : }
552 :
553 0 : auto PBackgroundChild::SendPCamerasConstructor() -> PCamerasChild*
554 : {
555 0 : return SendPCamerasConstructor(AllocPCamerasChild());
556 : }
557 :
558 0 : auto PBackgroundChild::SendPCamerasConstructor(PCamerasChild* actor) -> PCamerasChild*
559 : {
560 0 : if ((!(actor))) {
561 0 : NS_WARNING("Error constructing actor PCamerasChild");
562 0 : return nullptr;
563 : }
564 0 : (actor)->SetManager(this);
565 0 : Register(actor);
566 0 : (actor)->SetIPCChannel(GetIPCChannel());
567 0 : (mManagedPCamerasChild).PutEntry(actor);
568 0 : (actor)->mState = mozilla::camera::PCameras::__Start;
569 :
570 0 : IPC::Message* msg__ = PBackground::Msg_PCamerasConstructor(MSG_ROUTING_CONTROL);
571 :
572 0 : Write(actor, msg__, false);
573 : // Sentinel = 'actor'
574 0 : (msg__)->WriteSentinel(875202478);
575 :
576 0 : (msg__)->set_constructor();
577 :
578 :
579 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
580 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
581 : }
582 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PCamerasConstructor", OTHER);
583 0 : PBackground::Transition(PBackground::Msg_PCamerasConstructor__ID, (&(mState)));
584 :
585 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
586 0 : if ((!(sendok__))) {
587 0 : FatalError("constructor for actor failed");
588 0 : return nullptr;
589 : }
590 0 : return actor;
591 : }
592 :
593 0 : auto PBackgroundChild::SendPUDPSocketConstructor(
594 : const OptionalPrincipalInfo& pInfo,
595 : const nsCString& filter) -> PUDPSocketChild*
596 : {
597 0 : return SendPUDPSocketConstructor(AllocPUDPSocketChild(pInfo, filter), pInfo, filter);
598 : }
599 :
600 0 : auto PBackgroundChild::SendPUDPSocketConstructor(
601 : PUDPSocketChild* actor,
602 : const OptionalPrincipalInfo& pInfo,
603 : const nsCString& filter) -> PUDPSocketChild*
604 : {
605 0 : if ((!(actor))) {
606 0 : NS_WARNING("Error constructing actor PUDPSocketChild");
607 0 : return nullptr;
608 : }
609 0 : (actor)->SetManager(this);
610 0 : Register(actor);
611 0 : (actor)->SetIPCChannel(GetIPCChannel());
612 0 : (mManagedPUDPSocketChild).PutEntry(actor);
613 0 : (actor)->mState = mozilla::net::PUDPSocket::__Start;
614 :
615 0 : IPC::Message* msg__ = PBackground::Msg_PUDPSocketConstructor(MSG_ROUTING_CONTROL);
616 :
617 0 : Write(actor, msg__, false);
618 : // Sentinel = 'actor'
619 0 : (msg__)->WriteSentinel(875202478);
620 0 : Write(pInfo, msg__);
621 : // Sentinel = 'pInfo'
622 0 : (msg__)->WriteSentinel(3256439729);
623 0 : Write(filter, msg__);
624 : // Sentinel = 'filter'
625 0 : (msg__)->WriteSentinel(2236769008);
626 :
627 0 : (msg__)->set_constructor();
628 :
629 :
630 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
631 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
632 : }
633 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PUDPSocketConstructor", OTHER);
634 0 : PBackground::Transition(PBackground::Msg_PUDPSocketConstructor__ID, (&(mState)));
635 :
636 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
637 0 : if ((!(sendok__))) {
638 0 : FatalError("constructor for actor failed");
639 0 : return nullptr;
640 : }
641 0 : return actor;
642 : }
643 :
644 0 : auto PBackgroundChild::SendPBroadcastChannelConstructor(
645 : const PrincipalInfo& pInfo,
646 : const nsCString& origin,
647 : const nsString& channel) -> PBroadcastChannelChild*
648 : {
649 0 : return SendPBroadcastChannelConstructor(AllocPBroadcastChannelChild(pInfo, origin, channel), pInfo, origin, channel);
650 : }
651 :
652 0 : auto PBackgroundChild::SendPBroadcastChannelConstructor(
653 : PBroadcastChannelChild* actor,
654 : const PrincipalInfo& pInfo,
655 : const nsCString& origin,
656 : const nsString& channel) -> PBroadcastChannelChild*
657 : {
658 0 : if ((!(actor))) {
659 0 : NS_WARNING("Error constructing actor PBroadcastChannelChild");
660 0 : return nullptr;
661 : }
662 0 : (actor)->SetManager(this);
663 0 : Register(actor);
664 0 : (actor)->SetIPCChannel(GetIPCChannel());
665 0 : (mManagedPBroadcastChannelChild).PutEntry(actor);
666 0 : (actor)->mState = mozilla::dom::PBroadcastChannel::__Start;
667 :
668 0 : IPC::Message* msg__ = PBackground::Msg_PBroadcastChannelConstructor(MSG_ROUTING_CONTROL);
669 :
670 0 : Write(actor, msg__, false);
671 : // Sentinel = 'actor'
672 0 : (msg__)->WriteSentinel(875202478);
673 0 : Write(pInfo, msg__);
674 : // Sentinel = 'pInfo'
675 0 : (msg__)->WriteSentinel(3256439729);
676 0 : Write(origin, msg__);
677 : // Sentinel = 'origin'
678 0 : (msg__)->WriteSentinel(1429924608);
679 0 : Write(channel, msg__);
680 : // Sentinel = 'channel'
681 0 : (msg__)->WriteSentinel(452840382);
682 :
683 0 : (msg__)->set_constructor();
684 :
685 :
686 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
687 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
688 : }
689 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PBroadcastChannelConstructor", OTHER);
690 0 : PBackground::Transition(PBackground::Msg_PBroadcastChannelConstructor__ID, (&(mState)));
691 :
692 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
693 0 : if ((!(sendok__))) {
694 0 : FatalError("constructor for actor failed");
695 0 : return nullptr;
696 : }
697 0 : return actor;
698 : }
699 :
700 2 : auto PBackgroundChild::SendPServiceWorkerManagerConstructor() -> PServiceWorkerManagerChild*
701 : {
702 2 : return SendPServiceWorkerManagerConstructor(AllocPServiceWorkerManagerChild());
703 : }
704 :
705 2 : auto PBackgroundChild::SendPServiceWorkerManagerConstructor(PServiceWorkerManagerChild* actor) -> PServiceWorkerManagerChild*
706 : {
707 2 : if ((!(actor))) {
708 0 : NS_WARNING("Error constructing actor PServiceWorkerManagerChild");
709 0 : return nullptr;
710 : }
711 2 : (actor)->SetManager(this);
712 2 : Register(actor);
713 2 : (actor)->SetIPCChannel(GetIPCChannel());
714 2 : (mManagedPServiceWorkerManagerChild).PutEntry(actor);
715 2 : (actor)->mState = mozilla::dom::PServiceWorkerManager::__Start;
716 :
717 2 : IPC::Message* msg__ = PBackground::Msg_PServiceWorkerManagerConstructor(MSG_ROUTING_CONTROL);
718 :
719 2 : Write(actor, msg__, false);
720 : // Sentinel = 'actor'
721 2 : (msg__)->WriteSentinel(875202478);
722 :
723 2 : (msg__)->set_constructor();
724 :
725 :
726 2 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
727 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
728 : }
729 4 : AUTO_PROFILER_LABEL("PBackground::Msg_PServiceWorkerManagerConstructor", OTHER);
730 2 : PBackground::Transition(PBackground::Msg_PServiceWorkerManagerConstructor__ID, (&(mState)));
731 :
732 2 : bool sendok__ = (GetIPCChannel())->Send(msg__);
733 2 : if ((!(sendok__))) {
734 0 : FatalError("constructor for actor failed");
735 0 : return nullptr;
736 : }
737 2 : return actor;
738 : }
739 :
740 0 : auto PBackgroundChild::SendShutdownServiceWorkerRegistrar() -> bool
741 : {
742 0 : IPC::Message* msg__ = PBackground::Msg_ShutdownServiceWorkerRegistrar(MSG_ROUTING_CONTROL);
743 :
744 :
745 :
746 :
747 :
748 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
749 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
750 : }
751 0 : AUTO_PROFILER_LABEL("PBackground::Msg_ShutdownServiceWorkerRegistrar", OTHER);
752 0 : PBackground::Transition(PBackground::Msg_ShutdownServiceWorkerRegistrar__ID, (&(mState)));
753 :
754 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
755 0 : return sendok__;
756 : }
757 :
758 0 : auto PBackgroundChild::SendPCacheStorageConstructor(
759 : const Namespace& aNamespace,
760 : const PrincipalInfo& aPrincipalInfo) -> PCacheStorageChild*
761 : {
762 0 : return SendPCacheStorageConstructor(AllocPCacheStorageChild(aNamespace, aPrincipalInfo), aNamespace, aPrincipalInfo);
763 : }
764 :
765 0 : auto PBackgroundChild::SendPCacheStorageConstructor(
766 : PCacheStorageChild* actor,
767 : const Namespace& aNamespace,
768 : const PrincipalInfo& aPrincipalInfo) -> PCacheStorageChild*
769 : {
770 0 : if ((!(actor))) {
771 0 : NS_WARNING("Error constructing actor PCacheStorageChild");
772 0 : return nullptr;
773 : }
774 0 : (actor)->SetManager(this);
775 0 : Register(actor);
776 0 : (actor)->SetIPCChannel(GetIPCChannel());
777 0 : (mManagedPCacheStorageChild).PutEntry(actor);
778 0 : (actor)->mState = mozilla::dom::cache::PCacheStorage::__Start;
779 :
780 0 : IPC::Message* msg__ = PBackground::Msg_PCacheStorageConstructor(MSG_ROUTING_CONTROL);
781 :
782 0 : Write(actor, msg__, false);
783 : // Sentinel = 'actor'
784 0 : (msg__)->WriteSentinel(875202478);
785 0 : Write(aNamespace, msg__);
786 : // Sentinel = 'aNamespace'
787 0 : (msg__)->WriteSentinel(1104189952);
788 0 : Write(aPrincipalInfo, msg__);
789 : // Sentinel = 'aPrincipalInfo'
790 0 : (msg__)->WriteSentinel(2377045983);
791 :
792 0 : (msg__)->set_constructor();
793 :
794 :
795 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
796 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
797 : }
798 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PCacheStorageConstructor", OTHER);
799 0 : PBackground::Transition(PBackground::Msg_PCacheStorageConstructor__ID, (&(mState)));
800 :
801 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
802 0 : if ((!(sendok__))) {
803 0 : FatalError("constructor for actor failed");
804 0 : return nullptr;
805 : }
806 0 : return actor;
807 : }
808 :
809 0 : auto PBackgroundChild::SendPMessagePortConstructor(
810 : const nsID& uuid,
811 : const nsID& destinationUuid,
812 : const uint32_t& sequenceId) -> PMessagePortChild*
813 : {
814 0 : return SendPMessagePortConstructor(AllocPMessagePortChild(uuid, destinationUuid, sequenceId), uuid, destinationUuid, sequenceId);
815 : }
816 :
817 0 : auto PBackgroundChild::SendPMessagePortConstructor(
818 : PMessagePortChild* actor,
819 : const nsID& uuid,
820 : const nsID& destinationUuid,
821 : const uint32_t& sequenceId) -> PMessagePortChild*
822 : {
823 0 : if ((!(actor))) {
824 0 : NS_WARNING("Error constructing actor PMessagePortChild");
825 0 : return nullptr;
826 : }
827 0 : (actor)->SetManager(this);
828 0 : Register(actor);
829 0 : (actor)->SetIPCChannel(GetIPCChannel());
830 0 : (mManagedPMessagePortChild).PutEntry(actor);
831 0 : (actor)->mState = mozilla::dom::PMessagePort::__Start;
832 :
833 0 : IPC::Message* msg__ = PBackground::Msg_PMessagePortConstructor(MSG_ROUTING_CONTROL);
834 :
835 0 : Write(actor, msg__, false);
836 : // Sentinel = 'actor'
837 0 : (msg__)->WriteSentinel(875202478);
838 0 : Write(uuid, msg__);
839 : // Sentinel = 'uuid'
840 0 : (msg__)->WriteSentinel(1982267941);
841 0 : Write(destinationUuid, msg__);
842 : // Sentinel = 'destinationUuid'
843 0 : (msg__)->WriteSentinel(372087918);
844 0 : Write(sequenceId, msg__);
845 : // Sentinel = 'sequenceId'
846 0 : (msg__)->WriteSentinel(2743535618);
847 :
848 0 : (msg__)->set_constructor();
849 :
850 :
851 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
852 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
853 : }
854 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PMessagePortConstructor", OTHER);
855 0 : PBackground::Transition(PBackground::Msg_PMessagePortConstructor__ID, (&(mState)));
856 :
857 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
858 0 : if ((!(sendok__))) {
859 0 : FatalError("constructor for actor failed");
860 0 : return nullptr;
861 : }
862 0 : return actor;
863 : }
864 :
865 0 : auto PBackgroundChild::SendPChildToParentStreamConstructor() -> PChildToParentStreamChild*
866 : {
867 0 : return SendPChildToParentStreamConstructor(AllocPChildToParentStreamChild());
868 : }
869 :
870 0 : auto PBackgroundChild::SendPChildToParentStreamConstructor(PChildToParentStreamChild* actor) -> PChildToParentStreamChild*
871 : {
872 0 : if ((!(actor))) {
873 0 : NS_WARNING("Error constructing actor PChildToParentStreamChild");
874 0 : return nullptr;
875 : }
876 0 : (actor)->SetManager(this);
877 0 : Register(actor);
878 0 : (actor)->SetIPCChannel(GetIPCChannel());
879 0 : (mManagedPChildToParentStreamChild).PutEntry(actor);
880 0 : (actor)->mState = mozilla::ipc::PChildToParentStream::__Start;
881 :
882 0 : IPC::Message* msg__ = PBackground::Msg_PChildToParentStreamConstructor(MSG_ROUTING_CONTROL);
883 :
884 0 : Write(actor, msg__, false);
885 : // Sentinel = 'actor'
886 0 : (msg__)->WriteSentinel(875202478);
887 :
888 0 : (msg__)->set_constructor();
889 :
890 :
891 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
892 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
893 : }
894 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PChildToParentStreamConstructor", OTHER);
895 0 : PBackground::Transition(PBackground::Msg_PChildToParentStreamConstructor__ID, (&(mState)));
896 :
897 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
898 0 : if ((!(sendok__))) {
899 0 : FatalError("constructor for actor failed");
900 0 : return nullptr;
901 : }
902 0 : return actor;
903 : }
904 :
905 0 : auto PBackgroundChild::SendMessagePortForceClose(
906 : const nsID& uuid,
907 : const nsID& destinationUuid,
908 : const uint32_t& sequenceId) -> bool
909 : {
910 0 : IPC::Message* msg__ = PBackground::Msg_MessagePortForceClose(MSG_ROUTING_CONTROL);
911 :
912 0 : Write(uuid, msg__);
913 : // Sentinel = 'uuid'
914 0 : (msg__)->WriteSentinel(1982267941);
915 0 : Write(destinationUuid, msg__);
916 : // Sentinel = 'destinationUuid'
917 0 : (msg__)->WriteSentinel(372087918);
918 0 : Write(sequenceId, msg__);
919 : // Sentinel = 'sequenceId'
920 0 : (msg__)->WriteSentinel(2743535618);
921 :
922 :
923 :
924 :
925 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
926 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
927 : }
928 0 : AUTO_PROFILER_LABEL("PBackground::Msg_MessagePortForceClose", OTHER);
929 0 : PBackground::Transition(PBackground::Msg_MessagePortForceClose__ID, (&(mState)));
930 :
931 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
932 0 : return sendok__;
933 : }
934 :
935 0 : auto PBackgroundChild::SendPAsmJSCacheEntryConstructor(
936 : const OpenMode& openMode,
937 : const WriteParams& write,
938 : const PrincipalInfo& principalInfo) -> PAsmJSCacheEntryChild*
939 : {
940 0 : return SendPAsmJSCacheEntryConstructor(AllocPAsmJSCacheEntryChild(openMode, write, principalInfo), openMode, write, principalInfo);
941 : }
942 :
943 0 : auto PBackgroundChild::SendPAsmJSCacheEntryConstructor(
944 : PAsmJSCacheEntryChild* actor,
945 : const OpenMode& openMode,
946 : const WriteParams& write,
947 : const PrincipalInfo& principalInfo) -> PAsmJSCacheEntryChild*
948 : {
949 0 : if ((!(actor))) {
950 0 : NS_WARNING("Error constructing actor PAsmJSCacheEntryChild");
951 0 : return nullptr;
952 : }
953 0 : (actor)->SetManager(this);
954 0 : Register(actor);
955 0 : (actor)->SetIPCChannel(GetIPCChannel());
956 0 : (mManagedPAsmJSCacheEntryChild).PutEntry(actor);
957 0 : (actor)->mState = mozilla::dom::asmjscache::PAsmJSCacheEntry::__Start;
958 :
959 0 : IPC::Message* msg__ = PBackground::Msg_PAsmJSCacheEntryConstructor(MSG_ROUTING_CONTROL);
960 :
961 0 : Write(actor, msg__, false);
962 : // Sentinel = 'actor'
963 0 : (msg__)->WriteSentinel(875202478);
964 0 : Write(openMode, msg__);
965 : // Sentinel = 'openMode'
966 0 : (msg__)->WriteSentinel(2477830497);
967 0 : Write(write, msg__);
968 : // Sentinel = 'write'
969 0 : (msg__)->WriteSentinel(1000843696);
970 0 : Write(principalInfo, msg__);
971 : // Sentinel = 'principalInfo'
972 0 : (msg__)->WriteSentinel(3386633731);
973 :
974 0 : (msg__)->set_constructor();
975 :
976 :
977 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
978 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
979 : }
980 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PAsmJSCacheEntryConstructor", OTHER);
981 0 : PBackground::Transition(PBackground::Msg_PAsmJSCacheEntryConstructor__ID, (&(mState)));
982 :
983 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
984 0 : if ((!(sendok__))) {
985 0 : FatalError("constructor for actor failed");
986 0 : return nullptr;
987 : }
988 0 : return actor;
989 : }
990 :
991 0 : auto PBackgroundChild::SendPQuotaConstructor() -> PQuotaChild*
992 : {
993 0 : return SendPQuotaConstructor(AllocPQuotaChild());
994 : }
995 :
996 0 : auto PBackgroundChild::SendPQuotaConstructor(PQuotaChild* actor) -> PQuotaChild*
997 : {
998 0 : if ((!(actor))) {
999 0 : NS_WARNING("Error constructing actor PQuotaChild");
1000 0 : return nullptr;
1001 : }
1002 0 : (actor)->SetManager(this);
1003 0 : Register(actor);
1004 0 : (actor)->SetIPCChannel(GetIPCChannel());
1005 0 : (mManagedPQuotaChild).PutEntry(actor);
1006 0 : (actor)->mState = mozilla::dom::quota::PQuota::__Start;
1007 :
1008 0 : IPC::Message* msg__ = PBackground::Msg_PQuotaConstructor(MSG_ROUTING_CONTROL);
1009 :
1010 0 : Write(actor, msg__, false);
1011 : // Sentinel = 'actor'
1012 0 : (msg__)->WriteSentinel(875202478);
1013 :
1014 0 : (msg__)->set_constructor();
1015 :
1016 :
1017 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
1018 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1019 : }
1020 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PQuotaConstructor", OTHER);
1021 0 : PBackground::Transition(PBackground::Msg_PQuotaConstructor__ID, (&(mState)));
1022 :
1023 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1024 0 : if ((!(sendok__))) {
1025 0 : FatalError("constructor for actor failed");
1026 0 : return nullptr;
1027 : }
1028 0 : return actor;
1029 : }
1030 :
1031 0 : auto PBackgroundChild::SendPFileSystemRequestConstructor(const FileSystemParams& params) -> PFileSystemRequestChild*
1032 : {
1033 0 : return SendPFileSystemRequestConstructor(AllocPFileSystemRequestChild(params), params);
1034 : }
1035 :
1036 0 : auto PBackgroundChild::SendPFileSystemRequestConstructor(
1037 : PFileSystemRequestChild* actor,
1038 : const FileSystemParams& params) -> PFileSystemRequestChild*
1039 : {
1040 0 : if ((!(actor))) {
1041 0 : NS_WARNING("Error constructing actor PFileSystemRequestChild");
1042 0 : return nullptr;
1043 : }
1044 0 : (actor)->SetManager(this);
1045 0 : Register(actor);
1046 0 : (actor)->SetIPCChannel(GetIPCChannel());
1047 0 : (mManagedPFileSystemRequestChild).PutEntry(actor);
1048 0 : (actor)->mState = mozilla::dom::PFileSystemRequest::__Start;
1049 :
1050 0 : IPC::Message* msg__ = PBackground::Msg_PFileSystemRequestConstructor(MSG_ROUTING_CONTROL);
1051 :
1052 0 : Write(actor, msg__, false);
1053 : // Sentinel = 'actor'
1054 0 : (msg__)->WriteSentinel(875202478);
1055 0 : Write(params, msg__);
1056 : // Sentinel = 'params'
1057 0 : (msg__)->WriteSentinel(1677790004);
1058 :
1059 0 : (msg__)->set_constructor();
1060 :
1061 :
1062 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
1063 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1064 : }
1065 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PFileSystemRequestConstructor", OTHER);
1066 0 : PBackground::Transition(PBackground::Msg_PFileSystemRequestConstructor__ID, (&(mState)));
1067 :
1068 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1069 0 : if ((!(sendok__))) {
1070 0 : FatalError("constructor for actor failed");
1071 0 : return nullptr;
1072 : }
1073 0 : return actor;
1074 : }
1075 :
1076 0 : auto PBackgroundChild::SendPGamepadEventChannelConstructor() -> PGamepadEventChannelChild*
1077 : {
1078 0 : return SendPGamepadEventChannelConstructor(AllocPGamepadEventChannelChild());
1079 : }
1080 :
1081 0 : auto PBackgroundChild::SendPGamepadEventChannelConstructor(PGamepadEventChannelChild* actor) -> PGamepadEventChannelChild*
1082 : {
1083 0 : if ((!(actor))) {
1084 0 : NS_WARNING("Error constructing actor PGamepadEventChannelChild");
1085 0 : return nullptr;
1086 : }
1087 0 : (actor)->SetManager(this);
1088 0 : Register(actor);
1089 0 : (actor)->SetIPCChannel(GetIPCChannel());
1090 0 : (mManagedPGamepadEventChannelChild).PutEntry(actor);
1091 0 : (actor)->mState = mozilla::dom::PGamepadEventChannel::__Start;
1092 :
1093 0 : IPC::Message* msg__ = PBackground::Msg_PGamepadEventChannelConstructor(MSG_ROUTING_CONTROL);
1094 :
1095 0 : Write(actor, msg__, false);
1096 : // Sentinel = 'actor'
1097 0 : (msg__)->WriteSentinel(875202478);
1098 :
1099 0 : (msg__)->set_constructor();
1100 :
1101 :
1102 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
1103 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1104 : }
1105 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PGamepadEventChannelConstructor", OTHER);
1106 0 : PBackground::Transition(PBackground::Msg_PGamepadEventChannelConstructor__ID, (&(mState)));
1107 :
1108 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1109 0 : if ((!(sendok__))) {
1110 0 : FatalError("constructor for actor failed");
1111 0 : return nullptr;
1112 : }
1113 0 : return actor;
1114 : }
1115 :
1116 0 : auto PBackgroundChild::SendPGamepadTestChannelConstructor() -> PGamepadTestChannelChild*
1117 : {
1118 0 : return SendPGamepadTestChannelConstructor(AllocPGamepadTestChannelChild());
1119 : }
1120 :
1121 0 : auto PBackgroundChild::SendPGamepadTestChannelConstructor(PGamepadTestChannelChild* actor) -> PGamepadTestChannelChild*
1122 : {
1123 0 : if ((!(actor))) {
1124 0 : NS_WARNING("Error constructing actor PGamepadTestChannelChild");
1125 0 : return nullptr;
1126 : }
1127 0 : (actor)->SetManager(this);
1128 0 : Register(actor);
1129 0 : (actor)->SetIPCChannel(GetIPCChannel());
1130 0 : (mManagedPGamepadTestChannelChild).PutEntry(actor);
1131 0 : (actor)->mState = mozilla::dom::PGamepadTestChannel::__Start;
1132 :
1133 0 : IPC::Message* msg__ = PBackground::Msg_PGamepadTestChannelConstructor(MSG_ROUTING_CONTROL);
1134 :
1135 0 : Write(actor, msg__, false);
1136 : // Sentinel = 'actor'
1137 0 : (msg__)->WriteSentinel(875202478);
1138 :
1139 0 : (msg__)->set_constructor();
1140 :
1141 :
1142 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
1143 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1144 : }
1145 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PGamepadTestChannelConstructor", OTHER);
1146 0 : PBackground::Transition(PBackground::Msg_PGamepadTestChannelConstructor__ID, (&(mState)));
1147 :
1148 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1149 0 : if ((!(sendok__))) {
1150 0 : FatalError("constructor for actor failed");
1151 0 : return nullptr;
1152 : }
1153 0 : return actor;
1154 : }
1155 :
1156 0 : auto PBackgroundChild::SendPHttpBackgroundChannelConstructor(const uint64_t& channelId) -> PHttpBackgroundChannelChild*
1157 : {
1158 0 : return SendPHttpBackgroundChannelConstructor(AllocPHttpBackgroundChannelChild(channelId), channelId);
1159 : }
1160 :
1161 3 : auto PBackgroundChild::SendPHttpBackgroundChannelConstructor(
1162 : PHttpBackgroundChannelChild* actor,
1163 : const uint64_t& channelId) -> PHttpBackgroundChannelChild*
1164 : {
1165 3 : if ((!(actor))) {
1166 0 : NS_WARNING("Error constructing actor PHttpBackgroundChannelChild");
1167 0 : return nullptr;
1168 : }
1169 3 : (actor)->SetManager(this);
1170 3 : Register(actor);
1171 3 : (actor)->SetIPCChannel(GetIPCChannel());
1172 3 : (mManagedPHttpBackgroundChannelChild).PutEntry(actor);
1173 3 : (actor)->mState = mozilla::net::PHttpBackgroundChannel::__Start;
1174 :
1175 3 : IPC::Message* msg__ = PBackground::Msg_PHttpBackgroundChannelConstructor(MSG_ROUTING_CONTROL);
1176 :
1177 3 : Write(actor, msg__, false);
1178 : // Sentinel = 'actor'
1179 3 : (msg__)->WriteSentinel(875202478);
1180 3 : Write(channelId, msg__);
1181 : // Sentinel = 'channelId'
1182 3 : (msg__)->WriteSentinel(6854027);
1183 :
1184 3 : (msg__)->set_constructor();
1185 :
1186 :
1187 3 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
1188 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1189 : }
1190 6 : AUTO_PROFILER_LABEL("PBackground::Msg_PHttpBackgroundChannelConstructor", OTHER);
1191 3 : PBackground::Transition(PBackground::Msg_PHttpBackgroundChannelConstructor__ID, (&(mState)));
1192 :
1193 3 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1194 3 : if ((!(sendok__))) {
1195 0 : FatalError("constructor for actor failed");
1196 0 : return nullptr;
1197 : }
1198 3 : return actor;
1199 : }
1200 :
1201 0 : auto PBackgroundChild::SendPWebAuthnTransactionConstructor() -> PWebAuthnTransactionChild*
1202 : {
1203 0 : return SendPWebAuthnTransactionConstructor(AllocPWebAuthnTransactionChild());
1204 : }
1205 :
1206 0 : auto PBackgroundChild::SendPWebAuthnTransactionConstructor(PWebAuthnTransactionChild* actor) -> PWebAuthnTransactionChild*
1207 : {
1208 0 : if ((!(actor))) {
1209 0 : NS_WARNING("Error constructing actor PWebAuthnTransactionChild");
1210 0 : return nullptr;
1211 : }
1212 0 : (actor)->SetManager(this);
1213 0 : Register(actor);
1214 0 : (actor)->SetIPCChannel(GetIPCChannel());
1215 0 : (mManagedPWebAuthnTransactionChild).PutEntry(actor);
1216 0 : (actor)->mState = mozilla::dom::PWebAuthnTransaction::__Start;
1217 :
1218 0 : IPC::Message* msg__ = PBackground::Msg_PWebAuthnTransactionConstructor(MSG_ROUTING_CONTROL);
1219 :
1220 0 : Write(actor, msg__, false);
1221 : // Sentinel = 'actor'
1222 0 : (msg__)->WriteSentinel(875202478);
1223 :
1224 0 : (msg__)->set_constructor();
1225 :
1226 :
1227 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
1228 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1229 : }
1230 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PWebAuthnTransactionConstructor", OTHER);
1231 0 : PBackground::Transition(PBackground::Msg_PWebAuthnTransactionConstructor__ID, (&(mState)));
1232 :
1233 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1234 0 : if ((!(sendok__))) {
1235 0 : FatalError("constructor for actor failed");
1236 0 : return nullptr;
1237 : }
1238 0 : return actor;
1239 : }
1240 :
1241 0 : auto PBackgroundChild::SendPIPCBlobInputStreamConstructor(
1242 : const nsID& aID,
1243 : const uint64_t& aSize) -> PIPCBlobInputStreamChild*
1244 : {
1245 0 : return SendPIPCBlobInputStreamConstructor(AllocPIPCBlobInputStreamChild(aID, aSize), aID, aSize);
1246 : }
1247 :
1248 0 : auto PBackgroundChild::SendPIPCBlobInputStreamConstructor(
1249 : PIPCBlobInputStreamChild* actor,
1250 : const nsID& aID,
1251 : const uint64_t& aSize) -> PIPCBlobInputStreamChild*
1252 : {
1253 0 : if ((!(actor))) {
1254 0 : NS_WARNING("Error constructing actor PIPCBlobInputStreamChild");
1255 0 : return nullptr;
1256 : }
1257 0 : (actor)->SetManager(this);
1258 0 : Register(actor);
1259 0 : (actor)->SetIPCChannel(GetIPCChannel());
1260 0 : (mManagedPIPCBlobInputStreamChild).PutEntry(actor);
1261 0 : (actor)->mState = mozilla::ipc::PIPCBlobInputStream::__Start;
1262 :
1263 0 : IPC::Message* msg__ = PBackground::Msg_PIPCBlobInputStreamConstructor(MSG_ROUTING_CONTROL);
1264 :
1265 0 : Write(actor, msg__, false);
1266 : // Sentinel = 'actor'
1267 0 : (msg__)->WriteSentinel(875202478);
1268 0 : Write(aID, msg__);
1269 : // Sentinel = 'aID'
1270 0 : (msg__)->WriteSentinel(2735041849);
1271 0 : Write(aSize, msg__);
1272 : // Sentinel = 'aSize'
1273 0 : (msg__)->WriteSentinel(2556665555);
1274 :
1275 0 : (msg__)->set_constructor();
1276 :
1277 :
1278 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
1279 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1280 : }
1281 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PIPCBlobInputStreamConstructor", OTHER);
1282 0 : PBackground::Transition(PBackground::Msg_PIPCBlobInputStreamConstructor__ID, (&(mState)));
1283 :
1284 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1285 0 : if ((!(sendok__))) {
1286 0 : FatalError("constructor for actor failed");
1287 0 : return nullptr;
1288 : }
1289 0 : return actor;
1290 : }
1291 :
1292 0 : auto PBackgroundChild::SendPFileDescriptorSetConstructor(const FileDescriptor& fd) -> PFileDescriptorSetChild*
1293 : {
1294 0 : return SendPFileDescriptorSetConstructor(AllocPFileDescriptorSetChild(fd), fd);
1295 : }
1296 :
1297 0 : auto PBackgroundChild::SendPFileDescriptorSetConstructor(
1298 : PFileDescriptorSetChild* actor,
1299 : const FileDescriptor& fd) -> PFileDescriptorSetChild*
1300 : {
1301 0 : if ((!(actor))) {
1302 0 : NS_WARNING("Error constructing actor PFileDescriptorSetChild");
1303 0 : return nullptr;
1304 : }
1305 0 : (actor)->SetManager(this);
1306 0 : Register(actor);
1307 0 : (actor)->SetIPCChannel(GetIPCChannel());
1308 0 : (mManagedPFileDescriptorSetChild).PutEntry(actor);
1309 0 : (actor)->mState = mozilla::ipc::PFileDescriptorSet::__Start;
1310 :
1311 0 : IPC::Message* msg__ = PBackground::Msg_PFileDescriptorSetConstructor(MSG_ROUTING_CONTROL);
1312 :
1313 0 : Write(actor, msg__, false);
1314 : // Sentinel = 'actor'
1315 0 : (msg__)->WriteSentinel(875202478);
1316 0 : Write(fd, msg__);
1317 : // Sentinel = 'fd'
1318 0 : (msg__)->WriteSentinel(628535764);
1319 :
1320 0 : (msg__)->set_constructor();
1321 :
1322 :
1323 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
1324 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1325 : }
1326 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PFileDescriptorSetConstructor", OTHER);
1327 0 : PBackground::Transition(PBackground::Msg_PFileDescriptorSetConstructor__ID, (&(mState)));
1328 :
1329 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1330 0 : if ((!(sendok__))) {
1331 0 : FatalError("constructor for actor failed");
1332 0 : return nullptr;
1333 : }
1334 0 : return actor;
1335 : }
1336 :
1337 16 : auto PBackgroundChild::GetIPCChannel() -> MessageChannel*
1338 : {
1339 16 : return (&(mChannel));
1340 : }
1341 :
1342 0 : auto PBackgroundChild::GetIPCChannel() const -> const MessageChannel*
1343 : {
1344 0 : return (&(mChannel));
1345 : }
1346 :
1347 3 : auto PBackgroundChild::RemoveManagee(
1348 : int32_t aProtocolId,
1349 : ProtocolBase* aListener) -> void
1350 : {
1351 3 : switch (aProtocolId) {
1352 : case PAsmJSCacheEntryMsgStart:
1353 : {
1354 0 : PAsmJSCacheEntryChild* actor = static_cast<PAsmJSCacheEntryChild*>(aListener);
1355 0 : auto& container = mManagedPAsmJSCacheEntryChild;
1356 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1357 :
1358 0 : (container).RemoveEntry(actor);
1359 0 : DeallocPAsmJSCacheEntryChild(actor);
1360 0 : return;
1361 : }
1362 : case PBackgroundIDBFactoryMsgStart:
1363 : {
1364 0 : PBackgroundIDBFactoryChild* actor = static_cast<PBackgroundIDBFactoryChild*>(aListener);
1365 0 : auto& container = mManagedPBackgroundIDBFactoryChild;
1366 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1367 :
1368 0 : (container).RemoveEntry(actor);
1369 0 : DeallocPBackgroundIDBFactoryChild(actor);
1370 0 : return;
1371 : }
1372 : case PBackgroundIndexedDBUtilsMsgStart:
1373 : {
1374 0 : PBackgroundIndexedDBUtilsChild* actor = static_cast<PBackgroundIndexedDBUtilsChild*>(aListener);
1375 0 : auto& container = mManagedPBackgroundIndexedDBUtilsChild;
1376 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1377 :
1378 0 : (container).RemoveEntry(actor);
1379 0 : DeallocPBackgroundIndexedDBUtilsChild(actor);
1380 0 : return;
1381 : }
1382 : case PBackgroundTestMsgStart:
1383 : {
1384 0 : PBackgroundTestChild* actor = static_cast<PBackgroundTestChild*>(aListener);
1385 0 : auto& container = mManagedPBackgroundTestChild;
1386 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1387 :
1388 0 : (container).RemoveEntry(actor);
1389 0 : DeallocPBackgroundTestChild(actor);
1390 0 : return;
1391 : }
1392 : case PBroadcastChannelMsgStart:
1393 : {
1394 0 : PBroadcastChannelChild* actor = static_cast<PBroadcastChannelChild*>(aListener);
1395 0 : auto& container = mManagedPBroadcastChannelChild;
1396 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1397 :
1398 0 : (container).RemoveEntry(actor);
1399 0 : DeallocPBroadcastChannelChild(actor);
1400 0 : return;
1401 : }
1402 : case PCacheMsgStart:
1403 : {
1404 0 : PCacheChild* actor = static_cast<PCacheChild*>(aListener);
1405 0 : auto& container = mManagedPCacheChild;
1406 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1407 :
1408 0 : (container).RemoveEntry(actor);
1409 0 : DeallocPCacheChild(actor);
1410 0 : return;
1411 : }
1412 : case PCacheStorageMsgStart:
1413 : {
1414 0 : PCacheStorageChild* actor = static_cast<PCacheStorageChild*>(aListener);
1415 0 : auto& container = mManagedPCacheStorageChild;
1416 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1417 :
1418 0 : (container).RemoveEntry(actor);
1419 0 : DeallocPCacheStorageChild(actor);
1420 0 : return;
1421 : }
1422 : case PCacheStreamControlMsgStart:
1423 : {
1424 0 : PCacheStreamControlChild* actor = static_cast<PCacheStreamControlChild*>(aListener);
1425 0 : auto& container = mManagedPCacheStreamControlChild;
1426 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1427 :
1428 0 : (container).RemoveEntry(actor);
1429 0 : DeallocPCacheStreamControlChild(actor);
1430 0 : return;
1431 : }
1432 : case PFileDescriptorSetMsgStart:
1433 : {
1434 0 : PFileDescriptorSetChild* actor = static_cast<PFileDescriptorSetChild*>(aListener);
1435 0 : auto& container = mManagedPFileDescriptorSetChild;
1436 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1437 :
1438 0 : (container).RemoveEntry(actor);
1439 0 : DeallocPFileDescriptorSetChild(actor);
1440 0 : return;
1441 : }
1442 : case PFileSystemRequestMsgStart:
1443 : {
1444 0 : PFileSystemRequestChild* actor = static_cast<PFileSystemRequestChild*>(aListener);
1445 0 : auto& container = mManagedPFileSystemRequestChild;
1446 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1447 :
1448 0 : (container).RemoveEntry(actor);
1449 0 : DeallocPFileSystemRequestChild(actor);
1450 0 : return;
1451 : }
1452 : case PGamepadEventChannelMsgStart:
1453 : {
1454 0 : PGamepadEventChannelChild* actor = static_cast<PGamepadEventChannelChild*>(aListener);
1455 0 : auto& container = mManagedPGamepadEventChannelChild;
1456 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1457 :
1458 0 : (container).RemoveEntry(actor);
1459 0 : DeallocPGamepadEventChannelChild(actor);
1460 0 : return;
1461 : }
1462 : case PGamepadTestChannelMsgStart:
1463 : {
1464 0 : PGamepadTestChannelChild* actor = static_cast<PGamepadTestChannelChild*>(aListener);
1465 0 : auto& container = mManagedPGamepadTestChannelChild;
1466 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1467 :
1468 0 : (container).RemoveEntry(actor);
1469 0 : DeallocPGamepadTestChannelChild(actor);
1470 0 : return;
1471 : }
1472 : case PHttpBackgroundChannelMsgStart:
1473 : {
1474 3 : PHttpBackgroundChannelChild* actor = static_cast<PHttpBackgroundChannelChild*>(aListener);
1475 3 : auto& container = mManagedPHttpBackgroundChannelChild;
1476 3 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1477 :
1478 3 : (container).RemoveEntry(actor);
1479 3 : DeallocPHttpBackgroundChannelChild(actor);
1480 3 : return;
1481 : }
1482 : case PIPCBlobInputStreamMsgStart:
1483 : {
1484 0 : PIPCBlobInputStreamChild* actor = static_cast<PIPCBlobInputStreamChild*>(aListener);
1485 0 : auto& container = mManagedPIPCBlobInputStreamChild;
1486 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1487 :
1488 0 : (container).RemoveEntry(actor);
1489 0 : DeallocPIPCBlobInputStreamChild(actor);
1490 0 : return;
1491 : }
1492 : case PPendingIPCBlobMsgStart:
1493 : {
1494 0 : PPendingIPCBlobChild* actor = static_cast<PPendingIPCBlobChild*>(aListener);
1495 0 : auto& container = mManagedPPendingIPCBlobChild;
1496 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1497 :
1498 0 : (container).RemoveEntry(actor);
1499 0 : DeallocPPendingIPCBlobChild(actor);
1500 0 : return;
1501 : }
1502 : case PMessagePortMsgStart:
1503 : {
1504 0 : PMessagePortChild* actor = static_cast<PMessagePortChild*>(aListener);
1505 0 : auto& container = mManagedPMessagePortChild;
1506 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1507 :
1508 0 : (container).RemoveEntry(actor);
1509 0 : DeallocPMessagePortChild(actor);
1510 0 : return;
1511 : }
1512 : case PCamerasMsgStart:
1513 : {
1514 0 : PCamerasChild* actor = static_cast<PCamerasChild*>(aListener);
1515 0 : auto& container = mManagedPCamerasChild;
1516 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1517 :
1518 0 : (container).RemoveEntry(actor);
1519 0 : DeallocPCamerasChild(actor);
1520 0 : return;
1521 : }
1522 : case PQuotaMsgStart:
1523 : {
1524 0 : PQuotaChild* actor = static_cast<PQuotaChild*>(aListener);
1525 0 : auto& container = mManagedPQuotaChild;
1526 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1527 :
1528 0 : (container).RemoveEntry(actor);
1529 0 : DeallocPQuotaChild(actor);
1530 0 : return;
1531 : }
1532 : case PChildToParentStreamMsgStart:
1533 : {
1534 0 : PChildToParentStreamChild* actor = static_cast<PChildToParentStreamChild*>(aListener);
1535 0 : auto& container = mManagedPChildToParentStreamChild;
1536 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1537 :
1538 0 : (container).RemoveEntry(actor);
1539 0 : DeallocPChildToParentStreamChild(actor);
1540 0 : return;
1541 : }
1542 : case PParentToChildStreamMsgStart:
1543 : {
1544 0 : PParentToChildStreamChild* actor = static_cast<PParentToChildStreamChild*>(aListener);
1545 0 : auto& container = mManagedPParentToChildStreamChild;
1546 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1547 :
1548 0 : (container).RemoveEntry(actor);
1549 0 : DeallocPParentToChildStreamChild(actor);
1550 0 : return;
1551 : }
1552 : case PServiceWorkerManagerMsgStart:
1553 : {
1554 0 : PServiceWorkerManagerChild* actor = static_cast<PServiceWorkerManagerChild*>(aListener);
1555 0 : auto& container = mManagedPServiceWorkerManagerChild;
1556 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1557 :
1558 0 : (container).RemoveEntry(actor);
1559 0 : DeallocPServiceWorkerManagerChild(actor);
1560 0 : return;
1561 : }
1562 : case PWebAuthnTransactionMsgStart:
1563 : {
1564 0 : PWebAuthnTransactionChild* actor = static_cast<PWebAuthnTransactionChild*>(aListener);
1565 0 : auto& container = mManagedPWebAuthnTransactionChild;
1566 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1567 :
1568 0 : (container).RemoveEntry(actor);
1569 0 : DeallocPWebAuthnTransactionChild(actor);
1570 0 : return;
1571 : }
1572 : case PUDPSocketMsgStart:
1573 : {
1574 0 : PUDPSocketChild* actor = static_cast<PUDPSocketChild*>(aListener);
1575 0 : auto& container = mManagedPUDPSocketChild;
1576 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1577 :
1578 0 : (container).RemoveEntry(actor);
1579 0 : DeallocPUDPSocketChild(actor);
1580 0 : return;
1581 : }
1582 : case PVsyncMsgStart:
1583 : {
1584 0 : PVsyncChild* actor = static_cast<PVsyncChild*>(aListener);
1585 0 : auto& container = mManagedPVsyncChild;
1586 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1587 :
1588 0 : (container).RemoveEntry(actor);
1589 0 : DeallocPVsyncChild(actor);
1590 0 : return;
1591 : }
1592 : default:
1593 : {
1594 0 : FatalError("unreached");
1595 0 : return;
1596 : }
1597 : }
1598 : }
1599 :
1600 22 : auto PBackgroundChild::OnMessageReceived(const Message& msg__) -> PBackgroundChild::Result
1601 : {
1602 22 : int32_t route__ = (msg__).routing_id();
1603 22 : if ((MSG_ROUTING_CONTROL) != (route__)) {
1604 22 : ChannelListener* routed__ = Lookup(route__);
1605 22 : if ((!(routed__))) {
1606 0 : return MsgRouteError;
1607 : }
1608 22 : return (routed__)->OnMessageReceived(msg__);
1609 : }
1610 :
1611 0 : switch ((msg__).type()) {
1612 : case PBackground::Reply_PBackgroundTestConstructor__ID:
1613 : {
1614 0 : return MsgProcessed;
1615 : }
1616 : case PBackground::Reply_PBackgroundIDBFactoryConstructor__ID:
1617 : {
1618 0 : return MsgProcessed;
1619 : }
1620 : case PBackground::Reply_PBackgroundIndexedDBUtilsConstructor__ID:
1621 : {
1622 0 : return MsgProcessed;
1623 : }
1624 : case PBackground::Reply_PVsyncConstructor__ID:
1625 : {
1626 0 : return MsgProcessed;
1627 : }
1628 : case PBackground::Reply_PCamerasConstructor__ID:
1629 : {
1630 0 : return MsgProcessed;
1631 : }
1632 : case PBackground::Reply_PUDPSocketConstructor__ID:
1633 : {
1634 0 : return MsgProcessed;
1635 : }
1636 : case PBackground::Reply_PBroadcastChannelConstructor__ID:
1637 : {
1638 0 : return MsgProcessed;
1639 : }
1640 : case PBackground::Reply_PServiceWorkerManagerConstructor__ID:
1641 : {
1642 0 : return MsgProcessed;
1643 : }
1644 : case PBackground::Reply_PCacheStorageConstructor__ID:
1645 : {
1646 0 : return MsgProcessed;
1647 : }
1648 : case PBackground::Reply_PMessagePortConstructor__ID:
1649 : {
1650 0 : return MsgProcessed;
1651 : }
1652 : case PBackground::Reply_PChildToParentStreamConstructor__ID:
1653 : {
1654 0 : return MsgProcessed;
1655 : }
1656 : case PBackground::Reply_PAsmJSCacheEntryConstructor__ID:
1657 : {
1658 0 : return MsgProcessed;
1659 : }
1660 : case PBackground::Reply_PQuotaConstructor__ID:
1661 : {
1662 0 : return MsgProcessed;
1663 : }
1664 : case PBackground::Reply_PFileSystemRequestConstructor__ID:
1665 : {
1666 0 : return MsgProcessed;
1667 : }
1668 : case PBackground::Reply_PGamepadEventChannelConstructor__ID:
1669 : {
1670 0 : return MsgProcessed;
1671 : }
1672 : case PBackground::Reply_PGamepadTestChannelConstructor__ID:
1673 : {
1674 0 : return MsgProcessed;
1675 : }
1676 : case PBackground::Reply_PHttpBackgroundChannelConstructor__ID:
1677 : {
1678 0 : return MsgProcessed;
1679 : }
1680 : case PBackground::Reply_PWebAuthnTransactionConstructor__ID:
1681 : {
1682 0 : return MsgProcessed;
1683 : }
1684 : case PBackground::Msg_PCacheConstructor__ID:
1685 : {
1686 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
1687 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
1688 : }
1689 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PCacheConstructor", OTHER);
1690 :
1691 0 : PickleIterator iter__(msg__);
1692 : ActorHandle handle__;
1693 : PCacheChild* actor;
1694 :
1695 0 : if ((!(Read((&(handle__)), (&(msg__)), (&(iter__)))))) {
1696 0 : FatalError("Error deserializing 'ActorHandle'");
1697 0 : return MsgValueError;
1698 : }
1699 : // Sentinel = 'actor'
1700 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
1701 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
1702 0 : return MsgValueError;
1703 : }
1704 0 : (msg__).EndRead(iter__, (msg__).type());
1705 0 : PBackground::Transition(PBackground::Msg_PCacheConstructor__ID, (&(mState)));
1706 0 : actor = AllocPCacheChild();
1707 0 : if ((!(actor))) {
1708 0 : NS_WARNING("Error constructing actor PCacheChild");
1709 0 : return MsgValueError;
1710 : }
1711 0 : (actor)->SetManager(this);
1712 0 : RegisterID(actor, (handle__).mId);
1713 0 : (actor)->SetIPCChannel(GetIPCChannel());
1714 0 : (mManagedPCacheChild).PutEntry(actor);
1715 0 : (actor)->mState = mozilla::dom::cache::PCache::__Start;
1716 :
1717 0 : if ((!(RecvPCacheConstructor(mozilla::Move(actor))))) {
1718 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1719 : // Error handled in mozilla::ipc::IPCResult
1720 0 : return MsgProcessingError;
1721 : }
1722 :
1723 0 : return MsgProcessed;
1724 : }
1725 : case PBackground::Msg_PCacheStreamControlConstructor__ID:
1726 : {
1727 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
1728 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
1729 : }
1730 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PCacheStreamControlConstructor", OTHER);
1731 :
1732 0 : PickleIterator iter__(msg__);
1733 : ActorHandle handle__;
1734 : PCacheStreamControlChild* actor;
1735 :
1736 0 : if ((!(Read((&(handle__)), (&(msg__)), (&(iter__)))))) {
1737 0 : FatalError("Error deserializing 'ActorHandle'");
1738 0 : return MsgValueError;
1739 : }
1740 : // Sentinel = 'actor'
1741 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
1742 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
1743 0 : return MsgValueError;
1744 : }
1745 0 : (msg__).EndRead(iter__, (msg__).type());
1746 0 : PBackground::Transition(PBackground::Msg_PCacheStreamControlConstructor__ID, (&(mState)));
1747 0 : actor = AllocPCacheStreamControlChild();
1748 0 : if ((!(actor))) {
1749 0 : NS_WARNING("Error constructing actor PCacheStreamControlChild");
1750 0 : return MsgValueError;
1751 : }
1752 0 : (actor)->SetManager(this);
1753 0 : RegisterID(actor, (handle__).mId);
1754 0 : (actor)->SetIPCChannel(GetIPCChannel());
1755 0 : (mManagedPCacheStreamControlChild).PutEntry(actor);
1756 0 : (actor)->mState = mozilla::dom::cache::PCacheStreamControl::__Start;
1757 :
1758 0 : if ((!(RecvPCacheStreamControlConstructor(mozilla::Move(actor))))) {
1759 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1760 : // Error handled in mozilla::ipc::IPCResult
1761 0 : return MsgProcessingError;
1762 : }
1763 :
1764 0 : return MsgProcessed;
1765 : }
1766 : case PBackground::Msg_PParentToChildStreamConstructor__ID:
1767 : {
1768 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
1769 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
1770 : }
1771 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PParentToChildStreamConstructor", OTHER);
1772 :
1773 0 : PickleIterator iter__(msg__);
1774 : ActorHandle handle__;
1775 : PParentToChildStreamChild* actor;
1776 :
1777 0 : if ((!(Read((&(handle__)), (&(msg__)), (&(iter__)))))) {
1778 0 : FatalError("Error deserializing 'ActorHandle'");
1779 0 : return MsgValueError;
1780 : }
1781 : // Sentinel = 'actor'
1782 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
1783 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
1784 0 : return MsgValueError;
1785 : }
1786 0 : (msg__).EndRead(iter__, (msg__).type());
1787 0 : PBackground::Transition(PBackground::Msg_PParentToChildStreamConstructor__ID, (&(mState)));
1788 0 : actor = AllocPParentToChildStreamChild();
1789 0 : if ((!(actor))) {
1790 0 : NS_WARNING("Error constructing actor PParentToChildStreamChild");
1791 0 : return MsgValueError;
1792 : }
1793 0 : (actor)->SetManager(this);
1794 0 : RegisterID(actor, (handle__).mId);
1795 0 : (actor)->SetIPCChannel(GetIPCChannel());
1796 0 : (mManagedPParentToChildStreamChild).PutEntry(actor);
1797 0 : (actor)->mState = mozilla::ipc::PParentToChildStream::__Start;
1798 :
1799 0 : if ((!(RecvPParentToChildStreamConstructor(mozilla::Move(actor))))) {
1800 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1801 : // Error handled in mozilla::ipc::IPCResult
1802 0 : return MsgProcessingError;
1803 : }
1804 :
1805 0 : return MsgProcessed;
1806 : }
1807 : case PBackground::Msg_PPendingIPCBlobConstructor__ID:
1808 : {
1809 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
1810 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
1811 : }
1812 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PPendingIPCBlobConstructor", OTHER);
1813 :
1814 0 : PickleIterator iter__(msg__);
1815 : ActorHandle handle__;
1816 : PPendingIPCBlobChild* actor;
1817 0 : IPCBlob blob;
1818 :
1819 0 : if ((!(Read((&(handle__)), (&(msg__)), (&(iter__)))))) {
1820 0 : FatalError("Error deserializing 'ActorHandle'");
1821 0 : return MsgValueError;
1822 : }
1823 : // Sentinel = 'actor'
1824 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
1825 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
1826 0 : return MsgValueError;
1827 : }
1828 0 : if ((!(Read((&(blob)), (&(msg__)), (&(iter__)))))) {
1829 0 : FatalError("Error deserializing 'IPCBlob'");
1830 0 : return MsgValueError;
1831 : }
1832 : // Sentinel = 'blob'
1833 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1963585077)))) {
1834 0 : mozilla::ipc::SentinelReadError("Error deserializing 'IPCBlob'");
1835 0 : return MsgValueError;
1836 : }
1837 0 : (msg__).EndRead(iter__, (msg__).type());
1838 0 : PBackground::Transition(PBackground::Msg_PPendingIPCBlobConstructor__ID, (&(mState)));
1839 0 : actor = AllocPPendingIPCBlobChild(blob);
1840 0 : if ((!(actor))) {
1841 0 : NS_WARNING("Error constructing actor PPendingIPCBlobChild");
1842 0 : return MsgValueError;
1843 : }
1844 0 : (actor)->SetManager(this);
1845 0 : RegisterID(actor, (handle__).mId);
1846 0 : (actor)->SetIPCChannel(GetIPCChannel());
1847 0 : (mManagedPPendingIPCBlobChild).PutEntry(actor);
1848 0 : (actor)->mState = mozilla::ipc::PPendingIPCBlob::__Start;
1849 :
1850 0 : if ((!(RecvPPendingIPCBlobConstructor(mozilla::Move(actor), mozilla::Move(blob))))) {
1851 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1852 : // Error handled in mozilla::ipc::IPCResult
1853 0 : return MsgProcessingError;
1854 : }
1855 :
1856 0 : return MsgProcessed;
1857 : }
1858 : case PBackground::Reply_PIPCBlobInputStreamConstructor__ID:
1859 : {
1860 0 : return MsgProcessed;
1861 : }
1862 : case PBackground::Msg_PIPCBlobInputStreamConstructor__ID:
1863 : {
1864 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
1865 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
1866 : }
1867 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PIPCBlobInputStreamConstructor", OTHER);
1868 :
1869 0 : PickleIterator iter__(msg__);
1870 : ActorHandle handle__;
1871 : PIPCBlobInputStreamChild* actor;
1872 : nsID aID;
1873 : uint64_t aSize;
1874 :
1875 0 : if ((!(Read((&(handle__)), (&(msg__)), (&(iter__)))))) {
1876 0 : FatalError("Error deserializing 'ActorHandle'");
1877 0 : return MsgValueError;
1878 : }
1879 : // Sentinel = 'actor'
1880 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
1881 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
1882 0 : return MsgValueError;
1883 : }
1884 0 : if ((!(Read((&(aID)), (&(msg__)), (&(iter__)))))) {
1885 0 : FatalError("Error deserializing 'nsID'");
1886 0 : return MsgValueError;
1887 : }
1888 : // Sentinel = 'aID'
1889 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2735041849)))) {
1890 0 : mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
1891 0 : return MsgValueError;
1892 : }
1893 0 : if ((!(Read((&(aSize)), (&(msg__)), (&(iter__)))))) {
1894 0 : FatalError("Error deserializing 'uint64_t'");
1895 0 : return MsgValueError;
1896 : }
1897 : // Sentinel = 'aSize'
1898 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2556665555)))) {
1899 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
1900 0 : return MsgValueError;
1901 : }
1902 0 : (msg__).EndRead(iter__, (msg__).type());
1903 0 : PBackground::Transition(PBackground::Msg_PIPCBlobInputStreamConstructor__ID, (&(mState)));
1904 0 : actor = AllocPIPCBlobInputStreamChild(aID, aSize);
1905 0 : if ((!(actor))) {
1906 0 : NS_WARNING("Error constructing actor PIPCBlobInputStreamChild");
1907 0 : return MsgValueError;
1908 : }
1909 0 : (actor)->SetManager(this);
1910 0 : RegisterID(actor, (handle__).mId);
1911 0 : (actor)->SetIPCChannel(GetIPCChannel());
1912 0 : (mManagedPIPCBlobInputStreamChild).PutEntry(actor);
1913 0 : (actor)->mState = mozilla::ipc::PIPCBlobInputStream::__Start;
1914 :
1915 0 : if ((!(RecvPIPCBlobInputStreamConstructor(mozilla::Move(actor), mozilla::Move(aID), mozilla::Move(aSize))))) {
1916 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1917 : // Error handled in mozilla::ipc::IPCResult
1918 0 : return MsgProcessingError;
1919 : }
1920 :
1921 0 : return MsgProcessed;
1922 : }
1923 : case PBackground::Reply_PFileDescriptorSetConstructor__ID:
1924 : {
1925 0 : return MsgProcessed;
1926 : }
1927 : case PBackground::Msg_PFileDescriptorSetConstructor__ID:
1928 : {
1929 0 : if (mozilla::ipc::LoggingEnabledFor("PBackgroundChild")) {
1930 0 : mozilla::ipc::LogMessageForProtocol("PBackgroundChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
1931 : }
1932 0 : AUTO_PROFILER_LABEL("PBackground::Msg_PFileDescriptorSetConstructor", OTHER);
1933 :
1934 0 : PickleIterator iter__(msg__);
1935 : ActorHandle handle__;
1936 : PFileDescriptorSetChild* actor;
1937 0 : FileDescriptor fd;
1938 :
1939 0 : if ((!(Read((&(handle__)), (&(msg__)), (&(iter__)))))) {
1940 0 : FatalError("Error deserializing 'ActorHandle'");
1941 0 : return MsgValueError;
1942 : }
1943 : // Sentinel = 'actor'
1944 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
1945 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
1946 0 : return MsgValueError;
1947 : }
1948 0 : if ((!(Read((&(fd)), (&(msg__)), (&(iter__)))))) {
1949 0 : FatalError("Error deserializing 'FileDescriptor'");
1950 0 : return MsgValueError;
1951 : }
1952 : // Sentinel = 'fd'
1953 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 628535764)))) {
1954 0 : mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor'");
1955 0 : return MsgValueError;
1956 : }
1957 0 : (msg__).EndRead(iter__, (msg__).type());
1958 0 : PBackground::Transition(PBackground::Msg_PFileDescriptorSetConstructor__ID, (&(mState)));
1959 0 : actor = AllocPFileDescriptorSetChild(fd);
1960 0 : if ((!(actor))) {
1961 0 : NS_WARNING("Error constructing actor PFileDescriptorSetChild");
1962 0 : return MsgValueError;
1963 : }
1964 0 : (actor)->SetManager(this);
1965 0 : RegisterID(actor, (handle__).mId);
1966 0 : (actor)->SetIPCChannel(GetIPCChannel());
1967 0 : (mManagedPFileDescriptorSetChild).PutEntry(actor);
1968 0 : (actor)->mState = mozilla::ipc::PFileDescriptorSet::__Start;
1969 :
1970 0 : if ((!(RecvPFileDescriptorSetConstructor(mozilla::Move(actor), mozilla::Move(fd))))) {
1971 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1972 : // Error handled in mozilla::ipc::IPCResult
1973 0 : return MsgProcessingError;
1974 : }
1975 :
1976 0 : return MsgProcessed;
1977 : }
1978 : default:
1979 : {
1980 0 : return MsgNotKnown;
1981 : }
1982 : case SHMEM_CREATED_MESSAGE_TYPE:
1983 : {
1984 0 : if ((!(ShmemCreated(msg__)))) {
1985 0 : return MsgPayloadError;
1986 : }
1987 0 : return MsgProcessed;
1988 : }
1989 : case SHMEM_DESTROYED_MESSAGE_TYPE:
1990 : {
1991 0 : if ((!(ShmemDestroyed(msg__)))) {
1992 0 : return MsgPayloadError;
1993 : }
1994 0 : return MsgProcessed;
1995 : }
1996 : }
1997 : }
1998 :
1999 0 : auto PBackgroundChild::OnMessageReceived(
2000 : const Message& msg__,
2001 : Message*& reply__) -> PBackgroundChild::Result
2002 : {
2003 0 : int32_t route__ = (msg__).routing_id();
2004 0 : if ((MSG_ROUTING_CONTROL) != (route__)) {
2005 0 : ChannelListener* routed__ = Lookup(route__);
2006 0 : if ((!(routed__))) {
2007 0 : return MsgRouteError;
2008 : }
2009 0 : return (routed__)->OnMessageReceived(msg__, reply__);
2010 : }
2011 :
2012 0 : return MsgNotKnown;
2013 : }
2014 :
2015 0 : auto PBackgroundChild::OnCallReceived(
2016 : const Message& msg__,
2017 : Message*& reply__) -> PBackgroundChild::Result
2018 : {
2019 0 : MOZ_ASSERT_UNREACHABLE("message protocol not supported");
2020 : return MsgNotKnown;
2021 : }
2022 :
2023 0 : auto PBackgroundChild::GetProtocolTypeId() -> int32_t
2024 : {
2025 0 : return PBackgroundMsgStart;
2026 : }
2027 :
2028 0 : auto PBackgroundChild::OnChannelClose() -> void
2029 : {
2030 0 : DestroySubtree(NormalShutdown);
2031 0 : DeallocSubtree();
2032 0 : DeallocShmems();
2033 0 : DeallocPBackgroundChild();
2034 0 : }
2035 :
2036 0 : auto PBackgroundChild::OnChannelError() -> void
2037 : {
2038 0 : DestroySubtree(AbnormalShutdown);
2039 0 : DeallocSubtree();
2040 0 : DeallocShmems();
2041 0 : DeallocPBackgroundChild();
2042 0 : }
2043 :
2044 0 : auto PBackgroundChild::ProtocolName() const -> const char*
2045 : {
2046 0 : return "PBackgroundChild";
2047 : }
2048 :
2049 0 : auto PBackgroundChild::DestroySubtree(ActorDestroyReason why) -> void
2050 : {
2051 0 : ActorDestroyReason subtreewhy = (((why) == (Deletion)) || ((why) == (FailedConstructor)) ? AncestorDeletion : why);
2052 :
2053 : {
2054 : // Recursively shutting down PAsmJSCacheEntry kids
2055 0 : nsTArray<PAsmJSCacheEntryChild*> kids;
2056 : // Accumulate kids into a stable structure to iterate over
2057 0 : ManagedPAsmJSCacheEntryChild(kids);
2058 0 : for (auto& kid : kids) {
2059 : // Guarding against a child removing a sibling from the list during the iteration.
2060 0 : if ((mManagedPAsmJSCacheEntryChild).Contains(kid)) {
2061 0 : (kid)->DestroySubtree(subtreewhy);
2062 : }
2063 : }
2064 : }
2065 : {
2066 : // Recursively shutting down PBackgroundIDBFactory kids
2067 0 : nsTArray<PBackgroundIDBFactoryChild*> kids;
2068 : // Accumulate kids into a stable structure to iterate over
2069 0 : ManagedPBackgroundIDBFactoryChild(kids);
2070 0 : for (auto& kid : kids) {
2071 : // Guarding against a child removing a sibling from the list during the iteration.
2072 0 : if ((mManagedPBackgroundIDBFactoryChild).Contains(kid)) {
2073 0 : (kid)->DestroySubtree(subtreewhy);
2074 : }
2075 : }
2076 : }
2077 : {
2078 : // Recursively shutting down PBackgroundIndexedDBUtils kids
2079 0 : nsTArray<PBackgroundIndexedDBUtilsChild*> kids;
2080 : // Accumulate kids into a stable structure to iterate over
2081 0 : ManagedPBackgroundIndexedDBUtilsChild(kids);
2082 0 : for (auto& kid : kids) {
2083 : // Guarding against a child removing a sibling from the list during the iteration.
2084 0 : if ((mManagedPBackgroundIndexedDBUtilsChild).Contains(kid)) {
2085 0 : (kid)->DestroySubtree(subtreewhy);
2086 : }
2087 : }
2088 : }
2089 : {
2090 : // Recursively shutting down PBackgroundTest kids
2091 0 : nsTArray<PBackgroundTestChild*> kids;
2092 : // Accumulate kids into a stable structure to iterate over
2093 0 : ManagedPBackgroundTestChild(kids);
2094 0 : for (auto& kid : kids) {
2095 : // Guarding against a child removing a sibling from the list during the iteration.
2096 0 : if ((mManagedPBackgroundTestChild).Contains(kid)) {
2097 0 : (kid)->DestroySubtree(subtreewhy);
2098 : }
2099 : }
2100 : }
2101 : {
2102 : // Recursively shutting down PBroadcastChannel kids
2103 0 : nsTArray<PBroadcastChannelChild*> kids;
2104 : // Accumulate kids into a stable structure to iterate over
2105 0 : ManagedPBroadcastChannelChild(kids);
2106 0 : for (auto& kid : kids) {
2107 : // Guarding against a child removing a sibling from the list during the iteration.
2108 0 : if ((mManagedPBroadcastChannelChild).Contains(kid)) {
2109 0 : (kid)->DestroySubtree(subtreewhy);
2110 : }
2111 : }
2112 : }
2113 : {
2114 : // Recursively shutting down PCache kids
2115 0 : nsTArray<PCacheChild*> kids;
2116 : // Accumulate kids into a stable structure to iterate over
2117 0 : ManagedPCacheChild(kids);
2118 0 : for (auto& kid : kids) {
2119 : // Guarding against a child removing a sibling from the list during the iteration.
2120 0 : if ((mManagedPCacheChild).Contains(kid)) {
2121 0 : (kid)->DestroySubtree(subtreewhy);
2122 : }
2123 : }
2124 : }
2125 : {
2126 : // Recursively shutting down PCacheStorage kids
2127 0 : nsTArray<PCacheStorageChild*> kids;
2128 : // Accumulate kids into a stable structure to iterate over
2129 0 : ManagedPCacheStorageChild(kids);
2130 0 : for (auto& kid : kids) {
2131 : // Guarding against a child removing a sibling from the list during the iteration.
2132 0 : if ((mManagedPCacheStorageChild).Contains(kid)) {
2133 0 : (kid)->DestroySubtree(subtreewhy);
2134 : }
2135 : }
2136 : }
2137 : {
2138 : // Recursively shutting down PCacheStreamControl kids
2139 0 : nsTArray<PCacheStreamControlChild*> kids;
2140 : // Accumulate kids into a stable structure to iterate over
2141 0 : ManagedPCacheStreamControlChild(kids);
2142 0 : for (auto& kid : kids) {
2143 : // Guarding against a child removing a sibling from the list during the iteration.
2144 0 : if ((mManagedPCacheStreamControlChild).Contains(kid)) {
2145 0 : (kid)->DestroySubtree(subtreewhy);
2146 : }
2147 : }
2148 : }
2149 : {
2150 : // Recursively shutting down PFileDescriptorSet kids
2151 0 : nsTArray<PFileDescriptorSetChild*> kids;
2152 : // Accumulate kids into a stable structure to iterate over
2153 0 : ManagedPFileDescriptorSetChild(kids);
2154 0 : for (auto& kid : kids) {
2155 : // Guarding against a child removing a sibling from the list during the iteration.
2156 0 : if ((mManagedPFileDescriptorSetChild).Contains(kid)) {
2157 0 : (kid)->DestroySubtree(subtreewhy);
2158 : }
2159 : }
2160 : }
2161 : {
2162 : // Recursively shutting down PFileSystemRequest kids
2163 0 : nsTArray<PFileSystemRequestChild*> kids;
2164 : // Accumulate kids into a stable structure to iterate over
2165 0 : ManagedPFileSystemRequestChild(kids);
2166 0 : for (auto& kid : kids) {
2167 : // Guarding against a child removing a sibling from the list during the iteration.
2168 0 : if ((mManagedPFileSystemRequestChild).Contains(kid)) {
2169 0 : (kid)->DestroySubtree(subtreewhy);
2170 : }
2171 : }
2172 : }
2173 : {
2174 : // Recursively shutting down PGamepadEventChannel kids
2175 0 : nsTArray<PGamepadEventChannelChild*> kids;
2176 : // Accumulate kids into a stable structure to iterate over
2177 0 : ManagedPGamepadEventChannelChild(kids);
2178 0 : for (auto& kid : kids) {
2179 : // Guarding against a child removing a sibling from the list during the iteration.
2180 0 : if ((mManagedPGamepadEventChannelChild).Contains(kid)) {
2181 0 : (kid)->DestroySubtree(subtreewhy);
2182 : }
2183 : }
2184 : }
2185 : {
2186 : // Recursively shutting down PGamepadTestChannel kids
2187 0 : nsTArray<PGamepadTestChannelChild*> kids;
2188 : // Accumulate kids into a stable structure to iterate over
2189 0 : ManagedPGamepadTestChannelChild(kids);
2190 0 : for (auto& kid : kids) {
2191 : // Guarding against a child removing a sibling from the list during the iteration.
2192 0 : if ((mManagedPGamepadTestChannelChild).Contains(kid)) {
2193 0 : (kid)->DestroySubtree(subtreewhy);
2194 : }
2195 : }
2196 : }
2197 : {
2198 : // Recursively shutting down PHttpBackgroundChannel kids
2199 0 : nsTArray<PHttpBackgroundChannelChild*> kids;
2200 : // Accumulate kids into a stable structure to iterate over
2201 0 : ManagedPHttpBackgroundChannelChild(kids);
2202 0 : for (auto& kid : kids) {
2203 : // Guarding against a child removing a sibling from the list during the iteration.
2204 0 : if ((mManagedPHttpBackgroundChannelChild).Contains(kid)) {
2205 0 : (kid)->DestroySubtree(subtreewhy);
2206 : }
2207 : }
2208 : }
2209 : {
2210 : // Recursively shutting down PIPCBlobInputStream kids
2211 0 : nsTArray<PIPCBlobInputStreamChild*> kids;
2212 : // Accumulate kids into a stable structure to iterate over
2213 0 : ManagedPIPCBlobInputStreamChild(kids);
2214 0 : for (auto& kid : kids) {
2215 : // Guarding against a child removing a sibling from the list during the iteration.
2216 0 : if ((mManagedPIPCBlobInputStreamChild).Contains(kid)) {
2217 0 : (kid)->DestroySubtree(subtreewhy);
2218 : }
2219 : }
2220 : }
2221 : {
2222 : // Recursively shutting down PPendingIPCBlob kids
2223 0 : nsTArray<PPendingIPCBlobChild*> kids;
2224 : // Accumulate kids into a stable structure to iterate over
2225 0 : ManagedPPendingIPCBlobChild(kids);
2226 0 : for (auto& kid : kids) {
2227 : // Guarding against a child removing a sibling from the list during the iteration.
2228 0 : if ((mManagedPPendingIPCBlobChild).Contains(kid)) {
2229 0 : (kid)->DestroySubtree(subtreewhy);
2230 : }
2231 : }
2232 : }
2233 : {
2234 : // Recursively shutting down PMessagePort kids
2235 0 : nsTArray<PMessagePortChild*> kids;
2236 : // Accumulate kids into a stable structure to iterate over
2237 0 : ManagedPMessagePortChild(kids);
2238 0 : for (auto& kid : kids) {
2239 : // Guarding against a child removing a sibling from the list during the iteration.
2240 0 : if ((mManagedPMessagePortChild).Contains(kid)) {
2241 0 : (kid)->DestroySubtree(subtreewhy);
2242 : }
2243 : }
2244 : }
2245 : {
2246 : // Recursively shutting down PCameras kids
2247 0 : nsTArray<PCamerasChild*> kids;
2248 : // Accumulate kids into a stable structure to iterate over
2249 0 : ManagedPCamerasChild(kids);
2250 0 : for (auto& kid : kids) {
2251 : // Guarding against a child removing a sibling from the list during the iteration.
2252 0 : if ((mManagedPCamerasChild).Contains(kid)) {
2253 0 : (kid)->DestroySubtree(subtreewhy);
2254 : }
2255 : }
2256 : }
2257 : {
2258 : // Recursively shutting down PQuota kids
2259 0 : nsTArray<PQuotaChild*> kids;
2260 : // Accumulate kids into a stable structure to iterate over
2261 0 : ManagedPQuotaChild(kids);
2262 0 : for (auto& kid : kids) {
2263 : // Guarding against a child removing a sibling from the list during the iteration.
2264 0 : if ((mManagedPQuotaChild).Contains(kid)) {
2265 0 : (kid)->DestroySubtree(subtreewhy);
2266 : }
2267 : }
2268 : }
2269 : {
2270 : // Recursively shutting down PChildToParentStream kids
2271 0 : nsTArray<PChildToParentStreamChild*> kids;
2272 : // Accumulate kids into a stable structure to iterate over
2273 0 : ManagedPChildToParentStreamChild(kids);
2274 0 : for (auto& kid : kids) {
2275 : // Guarding against a child removing a sibling from the list during the iteration.
2276 0 : if ((mManagedPChildToParentStreamChild).Contains(kid)) {
2277 0 : (kid)->DestroySubtree(subtreewhy);
2278 : }
2279 : }
2280 : }
2281 : {
2282 : // Recursively shutting down PParentToChildStream kids
2283 0 : nsTArray<PParentToChildStreamChild*> kids;
2284 : // Accumulate kids into a stable structure to iterate over
2285 0 : ManagedPParentToChildStreamChild(kids);
2286 0 : for (auto& kid : kids) {
2287 : // Guarding against a child removing a sibling from the list during the iteration.
2288 0 : if ((mManagedPParentToChildStreamChild).Contains(kid)) {
2289 0 : (kid)->DestroySubtree(subtreewhy);
2290 : }
2291 : }
2292 : }
2293 : {
2294 : // Recursively shutting down PServiceWorkerManager kids
2295 0 : nsTArray<PServiceWorkerManagerChild*> kids;
2296 : // Accumulate kids into a stable structure to iterate over
2297 0 : ManagedPServiceWorkerManagerChild(kids);
2298 0 : for (auto& kid : kids) {
2299 : // Guarding against a child removing a sibling from the list during the iteration.
2300 0 : if ((mManagedPServiceWorkerManagerChild).Contains(kid)) {
2301 0 : (kid)->DestroySubtree(subtreewhy);
2302 : }
2303 : }
2304 : }
2305 : {
2306 : // Recursively shutting down PWebAuthnTransaction kids
2307 0 : nsTArray<PWebAuthnTransactionChild*> kids;
2308 : // Accumulate kids into a stable structure to iterate over
2309 0 : ManagedPWebAuthnTransactionChild(kids);
2310 0 : for (auto& kid : kids) {
2311 : // Guarding against a child removing a sibling from the list during the iteration.
2312 0 : if ((mManagedPWebAuthnTransactionChild).Contains(kid)) {
2313 0 : (kid)->DestroySubtree(subtreewhy);
2314 : }
2315 : }
2316 : }
2317 : {
2318 : // Recursively shutting down PUDPSocket kids
2319 0 : nsTArray<PUDPSocketChild*> kids;
2320 : // Accumulate kids into a stable structure to iterate over
2321 0 : ManagedPUDPSocketChild(kids);
2322 0 : for (auto& kid : kids) {
2323 : // Guarding against a child removing a sibling from the list during the iteration.
2324 0 : if ((mManagedPUDPSocketChild).Contains(kid)) {
2325 0 : (kid)->DestroySubtree(subtreewhy);
2326 : }
2327 : }
2328 : }
2329 : {
2330 : // Recursively shutting down PVsync kids
2331 0 : nsTArray<PVsyncChild*> kids;
2332 : // Accumulate kids into a stable structure to iterate over
2333 0 : ManagedPVsyncChild(kids);
2334 0 : for (auto& kid : kids) {
2335 : // Guarding against a child removing a sibling from the list during the iteration.
2336 0 : if ((mManagedPVsyncChild).Contains(kid)) {
2337 0 : (kid)->DestroySubtree(subtreewhy);
2338 : }
2339 : }
2340 : }
2341 :
2342 : // Reject owning pending promises.
2343 0 : (GetIPCChannel())->RejectPendingPromisesForActor(this);
2344 :
2345 : // Finally, destroy "us".
2346 0 : ActorDestroy(why);
2347 0 : }
2348 :
2349 0 : auto PBackgroundChild::DeallocSubtree() -> void
2350 : {
2351 : {
2352 : // Recursively deleting PAsmJSCacheEntry kids
2353 0 : for (auto iter = (mManagedPAsmJSCacheEntryChild).Iter(); (!((iter).Done())); (iter).Next()) {
2354 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2355 : }
2356 :
2357 0 : for (auto iter = (mManagedPAsmJSCacheEntryChild).Iter(); (!((iter).Done())); (iter).Next()) {
2358 0 : DeallocPAsmJSCacheEntryChild(((iter).Get())->GetKey());
2359 : }
2360 0 : (mManagedPAsmJSCacheEntryChild).Clear();
2361 : }
2362 : {
2363 : // Recursively deleting PBackgroundIDBFactory kids
2364 0 : for (auto iter = (mManagedPBackgroundIDBFactoryChild).Iter(); (!((iter).Done())); (iter).Next()) {
2365 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2366 : }
2367 :
2368 0 : for (auto iter = (mManagedPBackgroundIDBFactoryChild).Iter(); (!((iter).Done())); (iter).Next()) {
2369 0 : DeallocPBackgroundIDBFactoryChild(((iter).Get())->GetKey());
2370 : }
2371 0 : (mManagedPBackgroundIDBFactoryChild).Clear();
2372 : }
2373 : {
2374 : // Recursively deleting PBackgroundIndexedDBUtils kids
2375 0 : for (auto iter = (mManagedPBackgroundIndexedDBUtilsChild).Iter(); (!((iter).Done())); (iter).Next()) {
2376 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2377 : }
2378 :
2379 0 : for (auto iter = (mManagedPBackgroundIndexedDBUtilsChild).Iter(); (!((iter).Done())); (iter).Next()) {
2380 0 : DeallocPBackgroundIndexedDBUtilsChild(((iter).Get())->GetKey());
2381 : }
2382 0 : (mManagedPBackgroundIndexedDBUtilsChild).Clear();
2383 : }
2384 : {
2385 : // Recursively deleting PBackgroundTest kids
2386 0 : for (auto iter = (mManagedPBackgroundTestChild).Iter(); (!((iter).Done())); (iter).Next()) {
2387 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2388 : }
2389 :
2390 0 : for (auto iter = (mManagedPBackgroundTestChild).Iter(); (!((iter).Done())); (iter).Next()) {
2391 0 : DeallocPBackgroundTestChild(((iter).Get())->GetKey());
2392 : }
2393 0 : (mManagedPBackgroundTestChild).Clear();
2394 : }
2395 : {
2396 : // Recursively deleting PBroadcastChannel kids
2397 0 : for (auto iter = (mManagedPBroadcastChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2398 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2399 : }
2400 :
2401 0 : for (auto iter = (mManagedPBroadcastChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2402 0 : DeallocPBroadcastChannelChild(((iter).Get())->GetKey());
2403 : }
2404 0 : (mManagedPBroadcastChannelChild).Clear();
2405 : }
2406 : {
2407 : // Recursively deleting PCache kids
2408 0 : for (auto iter = (mManagedPCacheChild).Iter(); (!((iter).Done())); (iter).Next()) {
2409 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2410 : }
2411 :
2412 0 : for (auto iter = (mManagedPCacheChild).Iter(); (!((iter).Done())); (iter).Next()) {
2413 0 : DeallocPCacheChild(((iter).Get())->GetKey());
2414 : }
2415 0 : (mManagedPCacheChild).Clear();
2416 : }
2417 : {
2418 : // Recursively deleting PCacheStorage kids
2419 0 : for (auto iter = (mManagedPCacheStorageChild).Iter(); (!((iter).Done())); (iter).Next()) {
2420 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2421 : }
2422 :
2423 0 : for (auto iter = (mManagedPCacheStorageChild).Iter(); (!((iter).Done())); (iter).Next()) {
2424 0 : DeallocPCacheStorageChild(((iter).Get())->GetKey());
2425 : }
2426 0 : (mManagedPCacheStorageChild).Clear();
2427 : }
2428 : {
2429 : // Recursively deleting PCacheStreamControl kids
2430 0 : for (auto iter = (mManagedPCacheStreamControlChild).Iter(); (!((iter).Done())); (iter).Next()) {
2431 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2432 : }
2433 :
2434 0 : for (auto iter = (mManagedPCacheStreamControlChild).Iter(); (!((iter).Done())); (iter).Next()) {
2435 0 : DeallocPCacheStreamControlChild(((iter).Get())->GetKey());
2436 : }
2437 0 : (mManagedPCacheStreamControlChild).Clear();
2438 : }
2439 : {
2440 : // Recursively deleting PFileDescriptorSet kids
2441 0 : for (auto iter = (mManagedPFileDescriptorSetChild).Iter(); (!((iter).Done())); (iter).Next()) {
2442 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2443 : }
2444 :
2445 0 : for (auto iter = (mManagedPFileDescriptorSetChild).Iter(); (!((iter).Done())); (iter).Next()) {
2446 0 : DeallocPFileDescriptorSetChild(((iter).Get())->GetKey());
2447 : }
2448 0 : (mManagedPFileDescriptorSetChild).Clear();
2449 : }
2450 : {
2451 : // Recursively deleting PFileSystemRequest kids
2452 0 : for (auto iter = (mManagedPFileSystemRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
2453 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2454 : }
2455 :
2456 0 : for (auto iter = (mManagedPFileSystemRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
2457 0 : DeallocPFileSystemRequestChild(((iter).Get())->GetKey());
2458 : }
2459 0 : (mManagedPFileSystemRequestChild).Clear();
2460 : }
2461 : {
2462 : // Recursively deleting PGamepadEventChannel kids
2463 0 : for (auto iter = (mManagedPGamepadEventChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2464 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2465 : }
2466 :
2467 0 : for (auto iter = (mManagedPGamepadEventChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2468 0 : DeallocPGamepadEventChannelChild(((iter).Get())->GetKey());
2469 : }
2470 0 : (mManagedPGamepadEventChannelChild).Clear();
2471 : }
2472 : {
2473 : // Recursively deleting PGamepadTestChannel kids
2474 0 : for (auto iter = (mManagedPGamepadTestChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2475 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2476 : }
2477 :
2478 0 : for (auto iter = (mManagedPGamepadTestChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2479 0 : DeallocPGamepadTestChannelChild(((iter).Get())->GetKey());
2480 : }
2481 0 : (mManagedPGamepadTestChannelChild).Clear();
2482 : }
2483 : {
2484 : // Recursively deleting PHttpBackgroundChannel kids
2485 0 : for (auto iter = (mManagedPHttpBackgroundChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2486 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2487 : }
2488 :
2489 0 : for (auto iter = (mManagedPHttpBackgroundChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2490 0 : DeallocPHttpBackgroundChannelChild(((iter).Get())->GetKey());
2491 : }
2492 0 : (mManagedPHttpBackgroundChannelChild).Clear();
2493 : }
2494 : {
2495 : // Recursively deleting PIPCBlobInputStream kids
2496 0 : for (auto iter = (mManagedPIPCBlobInputStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
2497 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2498 : }
2499 :
2500 0 : for (auto iter = (mManagedPIPCBlobInputStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
2501 0 : DeallocPIPCBlobInputStreamChild(((iter).Get())->GetKey());
2502 : }
2503 0 : (mManagedPIPCBlobInputStreamChild).Clear();
2504 : }
2505 : {
2506 : // Recursively deleting PPendingIPCBlob kids
2507 0 : for (auto iter = (mManagedPPendingIPCBlobChild).Iter(); (!((iter).Done())); (iter).Next()) {
2508 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2509 : }
2510 :
2511 0 : for (auto iter = (mManagedPPendingIPCBlobChild).Iter(); (!((iter).Done())); (iter).Next()) {
2512 0 : DeallocPPendingIPCBlobChild(((iter).Get())->GetKey());
2513 : }
2514 0 : (mManagedPPendingIPCBlobChild).Clear();
2515 : }
2516 : {
2517 : // Recursively deleting PMessagePort kids
2518 0 : for (auto iter = (mManagedPMessagePortChild).Iter(); (!((iter).Done())); (iter).Next()) {
2519 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2520 : }
2521 :
2522 0 : for (auto iter = (mManagedPMessagePortChild).Iter(); (!((iter).Done())); (iter).Next()) {
2523 0 : DeallocPMessagePortChild(((iter).Get())->GetKey());
2524 : }
2525 0 : (mManagedPMessagePortChild).Clear();
2526 : }
2527 : {
2528 : // Recursively deleting PCameras kids
2529 0 : for (auto iter = (mManagedPCamerasChild).Iter(); (!((iter).Done())); (iter).Next()) {
2530 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2531 : }
2532 :
2533 0 : for (auto iter = (mManagedPCamerasChild).Iter(); (!((iter).Done())); (iter).Next()) {
2534 0 : DeallocPCamerasChild(((iter).Get())->GetKey());
2535 : }
2536 0 : (mManagedPCamerasChild).Clear();
2537 : }
2538 : {
2539 : // Recursively deleting PQuota kids
2540 0 : for (auto iter = (mManagedPQuotaChild).Iter(); (!((iter).Done())); (iter).Next()) {
2541 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2542 : }
2543 :
2544 0 : for (auto iter = (mManagedPQuotaChild).Iter(); (!((iter).Done())); (iter).Next()) {
2545 0 : DeallocPQuotaChild(((iter).Get())->GetKey());
2546 : }
2547 0 : (mManagedPQuotaChild).Clear();
2548 : }
2549 : {
2550 : // Recursively deleting PChildToParentStream kids
2551 0 : for (auto iter = (mManagedPChildToParentStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
2552 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2553 : }
2554 :
2555 0 : for (auto iter = (mManagedPChildToParentStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
2556 0 : DeallocPChildToParentStreamChild(((iter).Get())->GetKey());
2557 : }
2558 0 : (mManagedPChildToParentStreamChild).Clear();
2559 : }
2560 : {
2561 : // Recursively deleting PParentToChildStream kids
2562 0 : for (auto iter = (mManagedPParentToChildStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
2563 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2564 : }
2565 :
2566 0 : for (auto iter = (mManagedPParentToChildStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
2567 0 : DeallocPParentToChildStreamChild(((iter).Get())->GetKey());
2568 : }
2569 0 : (mManagedPParentToChildStreamChild).Clear();
2570 : }
2571 : {
2572 : // Recursively deleting PServiceWorkerManager kids
2573 0 : for (auto iter = (mManagedPServiceWorkerManagerChild).Iter(); (!((iter).Done())); (iter).Next()) {
2574 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2575 : }
2576 :
2577 0 : for (auto iter = (mManagedPServiceWorkerManagerChild).Iter(); (!((iter).Done())); (iter).Next()) {
2578 0 : DeallocPServiceWorkerManagerChild(((iter).Get())->GetKey());
2579 : }
2580 0 : (mManagedPServiceWorkerManagerChild).Clear();
2581 : }
2582 : {
2583 : // Recursively deleting PWebAuthnTransaction kids
2584 0 : for (auto iter = (mManagedPWebAuthnTransactionChild).Iter(); (!((iter).Done())); (iter).Next()) {
2585 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2586 : }
2587 :
2588 0 : for (auto iter = (mManagedPWebAuthnTransactionChild).Iter(); (!((iter).Done())); (iter).Next()) {
2589 0 : DeallocPWebAuthnTransactionChild(((iter).Get())->GetKey());
2590 : }
2591 0 : (mManagedPWebAuthnTransactionChild).Clear();
2592 : }
2593 : {
2594 : // Recursively deleting PUDPSocket kids
2595 0 : for (auto iter = (mManagedPUDPSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
2596 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2597 : }
2598 :
2599 0 : for (auto iter = (mManagedPUDPSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
2600 0 : DeallocPUDPSocketChild(((iter).Get())->GetKey());
2601 : }
2602 0 : (mManagedPUDPSocketChild).Clear();
2603 : }
2604 : {
2605 : // Recursively deleting PVsync kids
2606 0 : for (auto iter = (mManagedPVsyncChild).Iter(); (!((iter).Done())); (iter).Next()) {
2607 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2608 : }
2609 :
2610 0 : for (auto iter = (mManagedPVsyncChild).Iter(); (!((iter).Done())); (iter).Next()) {
2611 0 : DeallocPVsyncChild(((iter).Get())->GetKey());
2612 : }
2613 0 : (mManagedPVsyncChild).Clear();
2614 : }
2615 0 : }
2616 :
2617 0 : auto PBackgroundChild::DeallocPBackgroundChild() -> void
2618 : {
2619 0 : }
2620 :
2621 0 : auto PBackgroundChild::Write(
2622 : const SystemPrincipalInfo& v__,
2623 : Message* msg__) -> void
2624 : {
2625 0 : }
2626 :
2627 0 : auto PBackgroundChild::Read(
2628 : SystemPrincipalInfo* v__,
2629 : const Message* msg__,
2630 : PickleIterator* iter__) -> bool
2631 : {
2632 0 : return true;
2633 : }
2634 :
2635 0 : auto PBackgroundChild::Write(
2636 : const nsTArray<PrincipalInfo>& v__,
2637 : Message* msg__) -> void
2638 : {
2639 0 : uint32_t length = (v__).Length();
2640 0 : Write(length, msg__);
2641 : // Sentinel = ('length', 'PrincipalInfo[]')
2642 0 : (msg__)->WriteSentinel(1032188126);
2643 :
2644 0 : for (auto& elem : v__) {
2645 0 : Write(elem, msg__);
2646 : // Sentinel = 'PrincipalInfo[]'
2647 0 : (msg__)->WriteSentinel(413380193);
2648 : }
2649 0 : }
2650 :
2651 0 : auto PBackgroundChild::Read(
2652 : nsTArray<PrincipalInfo>* v__,
2653 : const Message* msg__,
2654 : PickleIterator* iter__) -> bool
2655 : {
2656 0 : nsTArray<PrincipalInfo> fa;
2657 : uint32_t length;
2658 0 : if ((!(Read((&(length)), msg__, iter__)))) {
2659 0 : mozilla::ipc::ArrayLengthReadError("PrincipalInfo[]");
2660 0 : return false;
2661 : }
2662 : // Sentinel = ('length', 'PrincipalInfo[]')
2663 0 : if ((!((msg__)->ReadSentinel(iter__, 1032188126)))) {
2664 0 : mozilla::ipc::SentinelReadError("PrincipalInfo[]");
2665 0 : return false;
2666 : }
2667 :
2668 0 : PrincipalInfo* elems = (fa).AppendElements(length);
2669 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
2670 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
2671 0 : FatalError("Error deserializing 'PrincipalInfo[i]'");
2672 0 : return false;
2673 : }
2674 : // Sentinel = 'PrincipalInfo[]'
2675 0 : if ((!((msg__)->ReadSentinel(iter__, 413380193)))) {
2676 0 : mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo[i]'");
2677 0 : return false;
2678 : }
2679 : }
2680 0 : (v__)->SwapElements(fa);
2681 0 : return true;
2682 : }
2683 :
2684 0 : auto PBackgroundChild::Write(
2685 : const PUDPSocketChild* v__,
2686 : Message* msg__,
2687 : bool nullable__) -> void
2688 : {
2689 : int32_t id;
2690 0 : if ((!(v__))) {
2691 0 : if ((!(nullable__))) {
2692 0 : FatalError("NULL actor value passed to non-nullable param");
2693 : }
2694 0 : id = 0;
2695 : }
2696 : else {
2697 0 : id = (v__)->Id();
2698 0 : if ((1) == (id)) {
2699 0 : FatalError("actor has been |delete|d");
2700 : }
2701 : }
2702 :
2703 0 : Write(id, msg__);
2704 0 : }
2705 :
2706 0 : auto PBackgroundChild::Read(
2707 : PUDPSocketChild** v__,
2708 : const Message* msg__,
2709 : PickleIterator* iter__,
2710 : bool nullable__) -> bool
2711 : {
2712 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PUDPSocket", PUDPSocketMsgStart);
2713 0 : if ((actor).isNothing()) {
2714 0 : return false;
2715 : }
2716 :
2717 0 : (*(v__)) = static_cast<PUDPSocketChild*>((actor).value());
2718 0 : return true;
2719 : }
2720 :
2721 0 : auto PBackgroundChild::Write(
2722 : const SlicedInputStreamParams& v__,
2723 : Message* msg__) -> void
2724 : {
2725 0 : Write((v__).stream(), msg__);
2726 : // Sentinel = 'stream'
2727 0 : (msg__)->WriteSentinel(4152748422);
2728 0 : Write((v__).start(), msg__);
2729 : // Sentinel = 'start'
2730 0 : (msg__)->WriteSentinel(2088644401);
2731 0 : Write((v__).length(), msg__);
2732 : // Sentinel = 'length'
2733 0 : (msg__)->WriteSentinel(1726618354);
2734 0 : Write((v__).curPos(), msg__);
2735 : // Sentinel = 'curPos'
2736 0 : (msg__)->WriteSentinel(4042140974);
2737 0 : Write((v__).closed(), msg__);
2738 : // Sentinel = 'closed'
2739 0 : (msg__)->WriteSentinel(561249462);
2740 0 : }
2741 :
2742 0 : auto PBackgroundChild::Read(
2743 : SlicedInputStreamParams* v__,
2744 : const Message* msg__,
2745 : PickleIterator* iter__) -> bool
2746 : {
2747 0 : if ((!(Read((&((v__)->stream())), msg__, iter__)))) {
2748 0 : FatalError("Error deserializing 'stream' (InputStreamParams) member of 'SlicedInputStreamParams'");
2749 0 : return false;
2750 : }
2751 : // Sentinel = 'stream'
2752 0 : if ((!((msg__)->ReadSentinel(iter__, 4152748422)))) {
2753 0 : mozilla::ipc::SentinelReadError("Error deserializing 'stream' (InputStreamParams) member of 'SlicedInputStreamParams'");
2754 0 : return false;
2755 : }
2756 0 : if ((!(Read((&((v__)->start())), msg__, iter__)))) {
2757 0 : FatalError("Error deserializing 'start' (uint64_t) member of 'SlicedInputStreamParams'");
2758 0 : return false;
2759 : }
2760 : // Sentinel = 'start'
2761 0 : if ((!((msg__)->ReadSentinel(iter__, 2088644401)))) {
2762 0 : mozilla::ipc::SentinelReadError("Error deserializing 'start' (uint64_t) member of 'SlicedInputStreamParams'");
2763 0 : return false;
2764 : }
2765 0 : if ((!(Read((&((v__)->length())), msg__, iter__)))) {
2766 0 : FatalError("Error deserializing 'length' (uint64_t) member of 'SlicedInputStreamParams'");
2767 0 : return false;
2768 : }
2769 : // Sentinel = 'length'
2770 0 : if ((!((msg__)->ReadSentinel(iter__, 1726618354)))) {
2771 0 : mozilla::ipc::SentinelReadError("Error deserializing 'length' (uint64_t) member of 'SlicedInputStreamParams'");
2772 0 : return false;
2773 : }
2774 0 : if ((!(Read((&((v__)->curPos())), msg__, iter__)))) {
2775 0 : FatalError("Error deserializing 'curPos' (uint64_t) member of 'SlicedInputStreamParams'");
2776 0 : return false;
2777 : }
2778 : // Sentinel = 'curPos'
2779 0 : if ((!((msg__)->ReadSentinel(iter__, 4042140974)))) {
2780 0 : mozilla::ipc::SentinelReadError("Error deserializing 'curPos' (uint64_t) member of 'SlicedInputStreamParams'");
2781 0 : return false;
2782 : }
2783 0 : if ((!(Read((&((v__)->closed())), msg__, iter__)))) {
2784 0 : FatalError("Error deserializing 'closed' (bool) member of 'SlicedInputStreamParams'");
2785 0 : return false;
2786 : }
2787 : // Sentinel = 'closed'
2788 0 : if ((!((msg__)->ReadSentinel(iter__, 561249462)))) {
2789 0 : mozilla::ipc::SentinelReadError("Error deserializing 'closed' (bool) member of 'SlicedInputStreamParams'");
2790 0 : return false;
2791 : }
2792 0 : return true;
2793 : }
2794 :
2795 0 : auto PBackgroundChild::Write(
2796 : const PBackgroundTestChild* v__,
2797 : Message* msg__,
2798 : bool nullable__) -> void
2799 : {
2800 : int32_t id;
2801 0 : if ((!(v__))) {
2802 0 : if ((!(nullable__))) {
2803 0 : FatalError("NULL actor value passed to non-nullable param");
2804 : }
2805 0 : id = 0;
2806 : }
2807 : else {
2808 0 : id = (v__)->Id();
2809 0 : if ((1) == (id)) {
2810 0 : FatalError("actor has been |delete|d");
2811 : }
2812 : }
2813 :
2814 0 : Write(id, msg__);
2815 0 : }
2816 :
2817 0 : auto PBackgroundChild::Read(
2818 : PBackgroundTestChild** v__,
2819 : const Message* msg__,
2820 : PickleIterator* iter__,
2821 : bool nullable__) -> bool
2822 : {
2823 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PBackgroundTest", PBackgroundTestMsgStart);
2824 0 : if ((actor).isNothing()) {
2825 0 : return false;
2826 : }
2827 :
2828 0 : (*(v__)) = static_cast<PBackgroundTestChild*>((actor).value());
2829 0 : return true;
2830 : }
2831 :
2832 0 : auto PBackgroundChild::Write(
2833 : const PBackgroundIndexedDBUtilsChild* v__,
2834 : Message* msg__,
2835 : bool nullable__) -> void
2836 : {
2837 : int32_t id;
2838 0 : if ((!(v__))) {
2839 0 : if ((!(nullable__))) {
2840 0 : FatalError("NULL actor value passed to non-nullable param");
2841 : }
2842 0 : id = 0;
2843 : }
2844 : else {
2845 0 : id = (v__)->Id();
2846 0 : if ((1) == (id)) {
2847 0 : FatalError("actor has been |delete|d");
2848 : }
2849 : }
2850 :
2851 0 : Write(id, msg__);
2852 0 : }
2853 :
2854 0 : auto PBackgroundChild::Read(
2855 : PBackgroundIndexedDBUtilsChild** v__,
2856 : const Message* msg__,
2857 : PickleIterator* iter__,
2858 : bool nullable__) -> bool
2859 : {
2860 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PBackgroundIndexedDBUtils", PBackgroundIndexedDBUtilsMsgStart);
2861 0 : if ((actor).isNothing()) {
2862 0 : return false;
2863 : }
2864 :
2865 0 : (*(v__)) = static_cast<PBackgroundIndexedDBUtilsChild*>((actor).value());
2866 0 : return true;
2867 : }
2868 :
2869 0 : auto PBackgroundChild::Write(
2870 : const PCacheChild* v__,
2871 : Message* msg__,
2872 : bool nullable__) -> void
2873 : {
2874 : int32_t id;
2875 0 : if ((!(v__))) {
2876 0 : if ((!(nullable__))) {
2877 0 : FatalError("NULL actor value passed to non-nullable param");
2878 : }
2879 0 : id = 0;
2880 : }
2881 : else {
2882 0 : id = (v__)->Id();
2883 0 : if ((1) == (id)) {
2884 0 : FatalError("actor has been |delete|d");
2885 : }
2886 : }
2887 :
2888 0 : Write(id, msg__);
2889 0 : }
2890 :
2891 0 : auto PBackgroundChild::Read(
2892 : PCacheChild** v__,
2893 : const Message* msg__,
2894 : PickleIterator* iter__,
2895 : bool nullable__) -> bool
2896 : {
2897 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PCache", PCacheMsgStart);
2898 0 : if ((actor).isNothing()) {
2899 0 : return false;
2900 : }
2901 :
2902 0 : (*(v__)) = static_cast<PCacheChild*>((actor).value());
2903 0 : return true;
2904 : }
2905 :
2906 0 : auto PBackgroundChild::Write(
2907 : const ContentPrincipalInfoOriginNoSuffix& v__,
2908 : Message* msg__) -> void
2909 : {
2910 : typedef ContentPrincipalInfoOriginNoSuffix type__;
2911 0 : Write(int((v__).type()), msg__);
2912 : // Sentinel = 'ContentPrincipalInfoOriginNoSuffix'
2913 0 : (msg__)->WriteSentinel(2442066713);
2914 :
2915 0 : switch ((v__).type()) {
2916 : case type__::TnsCString:
2917 : {
2918 0 : Write((v__).get_nsCString(), msg__);
2919 : // Sentinel = 'TnsCString'
2920 0 : (msg__)->WriteSentinel(2427411293);
2921 0 : return;
2922 : }
2923 : case type__::Tvoid_t:
2924 : {
2925 0 : Write((v__).get_void_t(), msg__);
2926 : // Sentinel = 'Tvoid_t'
2927 0 : (msg__)->WriteSentinel(3041273328);
2928 0 : return;
2929 : }
2930 : default:
2931 : {
2932 0 : FatalError("unknown union type");
2933 0 : return;
2934 : }
2935 : }
2936 : }
2937 :
2938 0 : auto PBackgroundChild::Read(
2939 : ContentPrincipalInfoOriginNoSuffix* v__,
2940 : const Message* msg__,
2941 : PickleIterator* iter__) -> bool
2942 : {
2943 : typedef ContentPrincipalInfoOriginNoSuffix type__;
2944 : int type;
2945 0 : if ((!(Read((&(type)), msg__, iter__)))) {
2946 0 : mozilla::ipc::UnionTypeReadError("ContentPrincipalInfoOriginNoSuffix");
2947 0 : return false;
2948 : }
2949 : // Sentinel = 'ContentPrincipalInfoOriginNoSuffix'
2950 0 : if ((!((msg__)->ReadSentinel(iter__, 2442066713)))) {
2951 0 : mozilla::ipc::SentinelReadError("ContentPrincipalInfoOriginNoSuffix");
2952 0 : return false;
2953 : }
2954 :
2955 0 : switch (type) {
2956 : case type__::TnsCString:
2957 : {
2958 0 : nsCString tmp = nsCString();
2959 0 : (*(v__)) = tmp;
2960 0 : if ((!(Read((&((v__)->get_nsCString())), msg__, iter__)))) {
2961 0 : FatalError("Error deserializing Union type");
2962 0 : return false;
2963 : }
2964 : // Sentinel = 'TnsCString'
2965 0 : if ((!((msg__)->ReadSentinel(iter__, 2427411293)))) {
2966 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2967 0 : return false;
2968 : }
2969 0 : return true;
2970 : }
2971 : case type__::Tvoid_t:
2972 : {
2973 : void_t tmp = void_t();
2974 0 : (*(v__)) = tmp;
2975 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
2976 0 : FatalError("Error deserializing Union type");
2977 0 : return false;
2978 : }
2979 : // Sentinel = 'Tvoid_t'
2980 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
2981 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2982 0 : return false;
2983 : }
2984 0 : return true;
2985 : }
2986 : default:
2987 : {
2988 0 : FatalError("unknown union type");
2989 0 : return false;
2990 : }
2991 : }
2992 : }
2993 :
2994 0 : auto PBackgroundChild::Write(
2995 : const FileDescriptor& v__,
2996 : Message* msg__) -> void
2997 : {
2998 0 : FileDescriptor::PickleType pfd = (v__).ShareTo(FileDescriptor::IPDLPrivate(), OtherPid());
2999 0 : IPC::WriteParam(msg__, pfd);
3000 0 : }
3001 :
3002 0 : auto PBackgroundChild::Read(
3003 : FileDescriptor* v__,
3004 : const Message* msg__,
3005 : PickleIterator* iter__) -> bool
3006 : {
3007 0 : FileDescriptor::PickleType pfd;
3008 0 : if ((!(IPC::ReadParam(msg__, iter__, (&(pfd)))))) {
3009 0 : return false;
3010 : }
3011 :
3012 0 : FileDescriptor fd = FileDescriptor(FileDescriptor::IPDLPrivate(), pfd);
3013 0 : if ((!((fd).IsValid()))) {
3014 0 : mozilla::ipc::ProtocolErrorBreakpoint("[PBackgroundChild] Received an invalid file descriptor!");
3015 : }
3016 :
3017 0 : (*(v__)) = fd;
3018 0 : return true;
3019 : }
3020 :
3021 0 : auto PBackgroundChild::Write(
3022 : const PGamepadEventChannelChild* v__,
3023 : Message* msg__,
3024 : bool nullable__) -> void
3025 : {
3026 : int32_t id;
3027 0 : if ((!(v__))) {
3028 0 : if ((!(nullable__))) {
3029 0 : FatalError("NULL actor value passed to non-nullable param");
3030 : }
3031 0 : id = 0;
3032 : }
3033 : else {
3034 0 : id = (v__)->Id();
3035 0 : if ((1) == (id)) {
3036 0 : FatalError("actor has been |delete|d");
3037 : }
3038 : }
3039 :
3040 0 : Write(id, msg__);
3041 0 : }
3042 :
3043 0 : auto PBackgroundChild::Read(
3044 : PGamepadEventChannelChild** v__,
3045 : const Message* msg__,
3046 : PickleIterator* iter__,
3047 : bool nullable__) -> bool
3048 : {
3049 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PGamepadEventChannel", PGamepadEventChannelMsgStart);
3050 0 : if ((actor).isNothing()) {
3051 0 : return false;
3052 : }
3053 :
3054 0 : (*(v__)) = static_cast<PGamepadEventChannelChild*>((actor).value());
3055 0 : return true;
3056 : }
3057 :
3058 0 : auto PBackgroundChild::Write(
3059 : const PParentToChildStreamChild* v__,
3060 : Message* msg__,
3061 : bool nullable__) -> void
3062 : {
3063 : int32_t id;
3064 0 : if ((!(v__))) {
3065 0 : if ((!(nullable__))) {
3066 0 : FatalError("NULL actor value passed to non-nullable param");
3067 : }
3068 0 : id = 0;
3069 : }
3070 : else {
3071 0 : id = (v__)->Id();
3072 0 : if ((1) == (id)) {
3073 0 : FatalError("actor has been |delete|d");
3074 : }
3075 : }
3076 :
3077 0 : Write(id, msg__);
3078 0 : }
3079 :
3080 0 : auto PBackgroundChild::Read(
3081 : PParentToChildStreamChild** v__,
3082 : const Message* msg__,
3083 : PickleIterator* iter__,
3084 : bool nullable__) -> bool
3085 : {
3086 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PParentToChildStream", PParentToChildStreamMsgStart);
3087 0 : if ((actor).isNothing()) {
3088 0 : return false;
3089 : }
3090 :
3091 0 : (*(v__)) = static_cast<PParentToChildStreamChild*>((actor).value());
3092 0 : return true;
3093 : }
3094 :
3095 0 : auto PBackgroundChild::Write(
3096 : const PWebAuthnTransactionChild* v__,
3097 : Message* msg__,
3098 : bool nullable__) -> void
3099 : {
3100 : int32_t id;
3101 0 : if ((!(v__))) {
3102 0 : if ((!(nullable__))) {
3103 0 : FatalError("NULL actor value passed to non-nullable param");
3104 : }
3105 0 : id = 0;
3106 : }
3107 : else {
3108 0 : id = (v__)->Id();
3109 0 : if ((1) == (id)) {
3110 0 : FatalError("actor has been |delete|d");
3111 : }
3112 : }
3113 :
3114 0 : Write(id, msg__);
3115 0 : }
3116 :
3117 0 : auto PBackgroundChild::Read(
3118 : PWebAuthnTransactionChild** v__,
3119 : const Message* msg__,
3120 : PickleIterator* iter__,
3121 : bool nullable__) -> bool
3122 : {
3123 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PWebAuthnTransaction", PWebAuthnTransactionMsgStart);
3124 0 : if ((actor).isNothing()) {
3125 0 : return false;
3126 : }
3127 :
3128 0 : (*(v__)) = static_cast<PWebAuthnTransactionChild*>((actor).value());
3129 0 : return true;
3130 : }
3131 :
3132 0 : auto PBackgroundChild::Write(
3133 : const nsTArray<InputStreamParams>& v__,
3134 : Message* msg__) -> void
3135 : {
3136 0 : uint32_t length = (v__).Length();
3137 0 : Write(length, msg__);
3138 : // Sentinel = ('length', 'InputStreamParams[]')
3139 0 : (msg__)->WriteSentinel(348334258);
3140 :
3141 0 : for (auto& elem : v__) {
3142 0 : Write(elem, msg__);
3143 : // Sentinel = 'InputStreamParams[]'
3144 0 : (msg__)->WriteSentinel(2927715197);
3145 : }
3146 0 : }
3147 :
3148 0 : auto PBackgroundChild::Read(
3149 : nsTArray<InputStreamParams>* v__,
3150 : const Message* msg__,
3151 : PickleIterator* iter__) -> bool
3152 : {
3153 0 : nsTArray<InputStreamParams> fa;
3154 : uint32_t length;
3155 0 : if ((!(Read((&(length)), msg__, iter__)))) {
3156 0 : mozilla::ipc::ArrayLengthReadError("InputStreamParams[]");
3157 0 : return false;
3158 : }
3159 : // Sentinel = ('length', 'InputStreamParams[]')
3160 0 : if ((!((msg__)->ReadSentinel(iter__, 348334258)))) {
3161 0 : mozilla::ipc::SentinelReadError("InputStreamParams[]");
3162 0 : return false;
3163 : }
3164 :
3165 0 : InputStreamParams* elems = (fa).AppendElements(length);
3166 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
3167 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
3168 0 : FatalError("Error deserializing 'InputStreamParams[i]'");
3169 0 : return false;
3170 : }
3171 : // Sentinel = 'InputStreamParams[]'
3172 0 : if ((!((msg__)->ReadSentinel(iter__, 2927715197)))) {
3173 0 : mozilla::ipc::SentinelReadError("Error deserializing 'InputStreamParams[i]'");
3174 0 : return false;
3175 : }
3176 : }
3177 0 : (v__)->SwapElements(fa);
3178 0 : return true;
3179 : }
3180 :
3181 0 : auto PBackgroundChild::Write(
3182 : const IPCFileUnion& v__,
3183 : Message* msg__) -> void
3184 : {
3185 : typedef IPCFileUnion type__;
3186 0 : Write(int((v__).type()), msg__);
3187 : // Sentinel = 'IPCFileUnion'
3188 0 : (msg__)->WriteSentinel(1913022529);
3189 :
3190 0 : switch ((v__).type()) {
3191 : case type__::Tvoid_t:
3192 : {
3193 0 : Write((v__).get_void_t(), msg__);
3194 : // Sentinel = 'Tvoid_t'
3195 0 : (msg__)->WriteSentinel(3041273328);
3196 0 : return;
3197 : }
3198 : case type__::TIPCFile:
3199 : {
3200 0 : Write((v__).get_IPCFile(), msg__);
3201 : // Sentinel = 'TIPCFile'
3202 0 : (msg__)->WriteSentinel(3562676876);
3203 0 : return;
3204 : }
3205 : default:
3206 : {
3207 0 : FatalError("unknown union type");
3208 0 : return;
3209 : }
3210 : }
3211 : }
3212 :
3213 0 : auto PBackgroundChild::Read(
3214 : IPCFileUnion* v__,
3215 : const Message* msg__,
3216 : PickleIterator* iter__) -> bool
3217 : {
3218 : typedef IPCFileUnion type__;
3219 : int type;
3220 0 : if ((!(Read((&(type)), msg__, iter__)))) {
3221 0 : mozilla::ipc::UnionTypeReadError("IPCFileUnion");
3222 0 : return false;
3223 : }
3224 : // Sentinel = 'IPCFileUnion'
3225 0 : if ((!((msg__)->ReadSentinel(iter__, 1913022529)))) {
3226 0 : mozilla::ipc::SentinelReadError("IPCFileUnion");
3227 0 : return false;
3228 : }
3229 :
3230 0 : switch (type) {
3231 : case type__::Tvoid_t:
3232 : {
3233 : void_t tmp = void_t();
3234 0 : (*(v__)) = tmp;
3235 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
3236 0 : FatalError("Error deserializing Union type");
3237 0 : return false;
3238 : }
3239 : // Sentinel = 'Tvoid_t'
3240 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
3241 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3242 0 : return false;
3243 : }
3244 0 : return true;
3245 : }
3246 : case type__::TIPCFile:
3247 : {
3248 0 : IPCFile tmp = IPCFile();
3249 0 : (*(v__)) = tmp;
3250 0 : if ((!(Read((&((v__)->get_IPCFile())), msg__, iter__)))) {
3251 0 : FatalError("Error deserializing Union type");
3252 0 : return false;
3253 : }
3254 : // Sentinel = 'TIPCFile'
3255 0 : if ((!((msg__)->ReadSentinel(iter__, 3562676876)))) {
3256 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3257 0 : return false;
3258 : }
3259 0 : return true;
3260 : }
3261 : default:
3262 : {
3263 0 : FatalError("unknown union type");
3264 0 : return false;
3265 : }
3266 : }
3267 : }
3268 :
3269 0 : auto PBackgroundChild::Write(
3270 : const PPendingIPCBlobChild* v__,
3271 : Message* msg__,
3272 : bool nullable__) -> void
3273 : {
3274 : int32_t id;
3275 0 : if ((!(v__))) {
3276 0 : if ((!(nullable__))) {
3277 0 : FatalError("NULL actor value passed to non-nullable param");
3278 : }
3279 0 : id = 0;
3280 : }
3281 : else {
3282 0 : id = (v__)->Id();
3283 0 : if ((1) == (id)) {
3284 0 : FatalError("actor has been |delete|d");
3285 : }
3286 : }
3287 :
3288 0 : Write(id, msg__);
3289 0 : }
3290 :
3291 0 : auto PBackgroundChild::Read(
3292 : PPendingIPCBlobChild** v__,
3293 : const Message* msg__,
3294 : PickleIterator* iter__,
3295 : bool nullable__) -> bool
3296 : {
3297 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PPendingIPCBlob", PPendingIPCBlobMsgStart);
3298 0 : if ((actor).isNothing()) {
3299 0 : return false;
3300 : }
3301 :
3302 0 : (*(v__)) = static_cast<PPendingIPCBlobChild*>((actor).value());
3303 0 : return true;
3304 : }
3305 :
3306 0 : auto PBackgroundChild::Write(
3307 : const FileSystemParams& v__,
3308 : Message* msg__) -> void
3309 : {
3310 : typedef FileSystemParams type__;
3311 0 : Write(int((v__).type()), msg__);
3312 : // Sentinel = 'FileSystemParams'
3313 0 : (msg__)->WriteSentinel(109932807);
3314 :
3315 0 : switch ((v__).type()) {
3316 : case type__::TFileSystemGetDirectoryListingParams:
3317 : {
3318 0 : Write((v__).get_FileSystemGetDirectoryListingParams(), msg__);
3319 : // Sentinel = 'TFileSystemGetDirectoryListingParams'
3320 0 : (msg__)->WriteSentinel(2814132262);
3321 0 : return;
3322 : }
3323 : case type__::TFileSystemGetFilesParams:
3324 : {
3325 0 : Write((v__).get_FileSystemGetFilesParams(), msg__);
3326 : // Sentinel = 'TFileSystemGetFilesParams'
3327 0 : (msg__)->WriteSentinel(2793550675);
3328 0 : return;
3329 : }
3330 : case type__::TFileSystemGetFileOrDirectoryParams:
3331 : {
3332 0 : Write((v__).get_FileSystemGetFileOrDirectoryParams(), msg__);
3333 : // Sentinel = 'TFileSystemGetFileOrDirectoryParams'
3334 0 : (msg__)->WriteSentinel(411751270);
3335 0 : return;
3336 : }
3337 : default:
3338 : {
3339 0 : FatalError("unknown union type");
3340 0 : return;
3341 : }
3342 : }
3343 : }
3344 :
3345 0 : auto PBackgroundChild::Read(
3346 : FileSystemParams* v__,
3347 : const Message* msg__,
3348 : PickleIterator* iter__) -> bool
3349 : {
3350 : typedef FileSystemParams type__;
3351 : int type;
3352 0 : if ((!(Read((&(type)), msg__, iter__)))) {
3353 0 : mozilla::ipc::UnionTypeReadError("FileSystemParams");
3354 0 : return false;
3355 : }
3356 : // Sentinel = 'FileSystemParams'
3357 0 : if ((!((msg__)->ReadSentinel(iter__, 109932807)))) {
3358 0 : mozilla::ipc::SentinelReadError("FileSystemParams");
3359 0 : return false;
3360 : }
3361 :
3362 0 : switch (type) {
3363 : case type__::TFileSystemGetDirectoryListingParams:
3364 : {
3365 0 : FileSystemGetDirectoryListingParams tmp = FileSystemGetDirectoryListingParams();
3366 0 : (*(v__)) = tmp;
3367 0 : if ((!(Read((&((v__)->get_FileSystemGetDirectoryListingParams())), msg__, iter__)))) {
3368 0 : FatalError("Error deserializing Union type");
3369 0 : return false;
3370 : }
3371 : // Sentinel = 'TFileSystemGetDirectoryListingParams'
3372 0 : if ((!((msg__)->ReadSentinel(iter__, 2814132262)))) {
3373 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3374 0 : return false;
3375 : }
3376 0 : return true;
3377 : }
3378 : case type__::TFileSystemGetFilesParams:
3379 : {
3380 0 : FileSystemGetFilesParams tmp = FileSystemGetFilesParams();
3381 0 : (*(v__)) = tmp;
3382 0 : if ((!(Read((&((v__)->get_FileSystemGetFilesParams())), msg__, iter__)))) {
3383 0 : FatalError("Error deserializing Union type");
3384 0 : return false;
3385 : }
3386 : // Sentinel = 'TFileSystemGetFilesParams'
3387 0 : if ((!((msg__)->ReadSentinel(iter__, 2793550675)))) {
3388 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3389 0 : return false;
3390 : }
3391 0 : return true;
3392 : }
3393 : case type__::TFileSystemGetFileOrDirectoryParams:
3394 : {
3395 0 : FileSystemGetFileOrDirectoryParams tmp = FileSystemGetFileOrDirectoryParams();
3396 0 : (*(v__)) = tmp;
3397 0 : if ((!(Read((&((v__)->get_FileSystemGetFileOrDirectoryParams())), msg__, iter__)))) {
3398 0 : FatalError("Error deserializing Union type");
3399 0 : return false;
3400 : }
3401 : // Sentinel = 'TFileSystemGetFileOrDirectoryParams'
3402 0 : if ((!((msg__)->ReadSentinel(iter__, 411751270)))) {
3403 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3404 0 : return false;
3405 : }
3406 0 : return true;
3407 : }
3408 : default:
3409 : {
3410 0 : FatalError("unknown union type");
3411 0 : return false;
3412 : }
3413 : }
3414 : }
3415 :
3416 0 : auto PBackgroundChild::Write(
3417 : const OptionalPrincipalInfo& v__,
3418 : Message* msg__) -> void
3419 : {
3420 : typedef OptionalPrincipalInfo type__;
3421 0 : Write(int((v__).type()), msg__);
3422 : // Sentinel = 'OptionalPrincipalInfo'
3423 0 : (msg__)->WriteSentinel(3041452007);
3424 :
3425 0 : switch ((v__).type()) {
3426 : case type__::Tvoid_t:
3427 : {
3428 0 : Write((v__).get_void_t(), msg__);
3429 : // Sentinel = 'Tvoid_t'
3430 0 : (msg__)->WriteSentinel(3041273328);
3431 0 : return;
3432 : }
3433 : case type__::TPrincipalInfo:
3434 : {
3435 0 : Write((v__).get_PrincipalInfo(), msg__);
3436 : // Sentinel = 'TPrincipalInfo'
3437 0 : (msg__)->WriteSentinel(1396743580);
3438 0 : return;
3439 : }
3440 : default:
3441 : {
3442 0 : FatalError("unknown union type");
3443 0 : return;
3444 : }
3445 : }
3446 : }
3447 :
3448 0 : auto PBackgroundChild::Read(
3449 : OptionalPrincipalInfo* v__,
3450 : const Message* msg__,
3451 : PickleIterator* iter__) -> bool
3452 : {
3453 : typedef OptionalPrincipalInfo type__;
3454 : int type;
3455 0 : if ((!(Read((&(type)), msg__, iter__)))) {
3456 0 : mozilla::ipc::UnionTypeReadError("OptionalPrincipalInfo");
3457 0 : return false;
3458 : }
3459 : // Sentinel = 'OptionalPrincipalInfo'
3460 0 : if ((!((msg__)->ReadSentinel(iter__, 3041452007)))) {
3461 0 : mozilla::ipc::SentinelReadError("OptionalPrincipalInfo");
3462 0 : return false;
3463 : }
3464 :
3465 0 : switch (type) {
3466 : case type__::Tvoid_t:
3467 : {
3468 : void_t tmp = void_t();
3469 0 : (*(v__)) = tmp;
3470 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
3471 0 : FatalError("Error deserializing Union type");
3472 0 : return false;
3473 : }
3474 : // Sentinel = 'Tvoid_t'
3475 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
3476 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3477 0 : return false;
3478 : }
3479 0 : return true;
3480 : }
3481 : case type__::TPrincipalInfo:
3482 : {
3483 0 : PrincipalInfo tmp = PrincipalInfo();
3484 0 : (*(v__)) = tmp;
3485 0 : if ((!(Read((&((v__)->get_PrincipalInfo())), msg__, iter__)))) {
3486 0 : FatalError("Error deserializing Union type");
3487 0 : return false;
3488 : }
3489 : // Sentinel = 'TPrincipalInfo'
3490 0 : if ((!((msg__)->ReadSentinel(iter__, 1396743580)))) {
3491 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3492 0 : return false;
3493 : }
3494 0 : return true;
3495 : }
3496 : default:
3497 : {
3498 0 : FatalError("unknown union type");
3499 0 : return false;
3500 : }
3501 : }
3502 : }
3503 :
3504 3 : auto PBackgroundChild::Write(
3505 : const PHttpBackgroundChannelChild* v__,
3506 : Message* msg__,
3507 : bool nullable__) -> void
3508 : {
3509 : int32_t id;
3510 3 : if ((!(v__))) {
3511 0 : if ((!(nullable__))) {
3512 0 : FatalError("NULL actor value passed to non-nullable param");
3513 : }
3514 0 : id = 0;
3515 : }
3516 : else {
3517 3 : id = (v__)->Id();
3518 3 : if ((1) == (id)) {
3519 0 : FatalError("actor has been |delete|d");
3520 : }
3521 : }
3522 :
3523 3 : Write(id, msg__);
3524 3 : }
3525 :
3526 0 : auto PBackgroundChild::Read(
3527 : PHttpBackgroundChannelChild** v__,
3528 : const Message* msg__,
3529 : PickleIterator* iter__,
3530 : bool nullable__) -> bool
3531 : {
3532 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PHttpBackgroundChannel", PHttpBackgroundChannelMsgStart);
3533 0 : if ((actor).isNothing()) {
3534 0 : return false;
3535 : }
3536 :
3537 0 : (*(v__)) = static_cast<PHttpBackgroundChannelChild*>((actor).value());
3538 0 : return true;
3539 : }
3540 :
3541 0 : auto PBackgroundChild::Write(
3542 : const IPCBlob& v__,
3543 : Message* msg__) -> void
3544 : {
3545 0 : Write((v__).type(), msg__);
3546 : // Sentinel = 'type'
3547 0 : (msg__)->WriteSentinel(2982068540);
3548 0 : Write((v__).size(), msg__);
3549 : // Sentinel = 'size'
3550 0 : (msg__)->WriteSentinel(931048223);
3551 0 : Write((v__).inputStream(), msg__);
3552 : // Sentinel = 'inputStream'
3553 0 : (msg__)->WriteSentinel(2684883823);
3554 0 : Write((v__).file(), msg__);
3555 : // Sentinel = 'file'
3556 0 : (msg__)->WriteSentinel(224874390);
3557 0 : Write((v__).fileId(), msg__);
3558 : // Sentinel = 'fileId'
3559 0 : (msg__)->WriteSentinel(108004447);
3560 0 : }
3561 :
3562 0 : auto PBackgroundChild::Read(
3563 : IPCBlob* v__,
3564 : const Message* msg__,
3565 : PickleIterator* iter__) -> bool
3566 : {
3567 0 : if ((!(Read((&((v__)->type())), msg__, iter__)))) {
3568 0 : FatalError("Error deserializing 'type' (nsString) member of 'IPCBlob'");
3569 0 : return false;
3570 : }
3571 : // Sentinel = 'type'
3572 0 : if ((!((msg__)->ReadSentinel(iter__, 2982068540)))) {
3573 0 : mozilla::ipc::SentinelReadError("Error deserializing 'type' (nsString) member of 'IPCBlob'");
3574 0 : return false;
3575 : }
3576 0 : if ((!(Read((&((v__)->size())), msg__, iter__)))) {
3577 0 : FatalError("Error deserializing 'size' (uint64_t) member of 'IPCBlob'");
3578 0 : return false;
3579 : }
3580 : // Sentinel = 'size'
3581 0 : if ((!((msg__)->ReadSentinel(iter__, 931048223)))) {
3582 0 : mozilla::ipc::SentinelReadError("Error deserializing 'size' (uint64_t) member of 'IPCBlob'");
3583 0 : return false;
3584 : }
3585 0 : if ((!(Read((&((v__)->inputStream())), msg__, iter__)))) {
3586 0 : FatalError("Error deserializing 'inputStream' (IPCBlobStream) member of 'IPCBlob'");
3587 0 : return false;
3588 : }
3589 : // Sentinel = 'inputStream'
3590 0 : if ((!((msg__)->ReadSentinel(iter__, 2684883823)))) {
3591 0 : mozilla::ipc::SentinelReadError("Error deserializing 'inputStream' (IPCBlobStream) member of 'IPCBlob'");
3592 0 : return false;
3593 : }
3594 0 : if ((!(Read((&((v__)->file())), msg__, iter__)))) {
3595 0 : FatalError("Error deserializing 'file' (IPCFileUnion) member of 'IPCBlob'");
3596 0 : return false;
3597 : }
3598 : // Sentinel = 'file'
3599 0 : if ((!((msg__)->ReadSentinel(iter__, 224874390)))) {
3600 0 : mozilla::ipc::SentinelReadError("Error deserializing 'file' (IPCFileUnion) member of 'IPCBlob'");
3601 0 : return false;
3602 : }
3603 0 : if ((!(Read((&((v__)->fileId())), msg__, iter__)))) {
3604 0 : FatalError("Error deserializing 'fileId' (int64_t) member of 'IPCBlob'");
3605 0 : return false;
3606 : }
3607 : // Sentinel = 'fileId'
3608 0 : if ((!((msg__)->ReadSentinel(iter__, 108004447)))) {
3609 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fileId' (int64_t) member of 'IPCBlob'");
3610 0 : return false;
3611 : }
3612 0 : return true;
3613 : }
3614 :
3615 0 : auto PBackgroundChild::Write(
3616 : const PQuotaChild* v__,
3617 : Message* msg__,
3618 : bool nullable__) -> void
3619 : {
3620 : int32_t id;
3621 0 : if ((!(v__))) {
3622 0 : if ((!(nullable__))) {
3623 0 : FatalError("NULL actor value passed to non-nullable param");
3624 : }
3625 0 : id = 0;
3626 : }
3627 : else {
3628 0 : id = (v__)->Id();
3629 0 : if ((1) == (id)) {
3630 0 : FatalError("actor has been |delete|d");
3631 : }
3632 : }
3633 :
3634 0 : Write(id, msg__);
3635 0 : }
3636 :
3637 0 : auto PBackgroundChild::Read(
3638 : PQuotaChild** v__,
3639 : const Message* msg__,
3640 : PickleIterator* iter__,
3641 : bool nullable__) -> bool
3642 : {
3643 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PQuota", PQuotaMsgStart);
3644 0 : if ((actor).isNothing()) {
3645 0 : return false;
3646 : }
3647 :
3648 0 : (*(v__)) = static_cast<PQuotaChild*>((actor).value());
3649 0 : return true;
3650 : }
3651 :
3652 0 : auto PBackgroundChild::Write(
3653 : const PFileSystemRequestChild* v__,
3654 : Message* msg__,
3655 : bool nullable__) -> void
3656 : {
3657 : int32_t id;
3658 0 : if ((!(v__))) {
3659 0 : if ((!(nullable__))) {
3660 0 : FatalError("NULL actor value passed to non-nullable param");
3661 : }
3662 0 : id = 0;
3663 : }
3664 : else {
3665 0 : id = (v__)->Id();
3666 0 : if ((1) == (id)) {
3667 0 : FatalError("actor has been |delete|d");
3668 : }
3669 : }
3670 :
3671 0 : Write(id, msg__);
3672 0 : }
3673 :
3674 0 : auto PBackgroundChild::Read(
3675 : PFileSystemRequestChild** v__,
3676 : const Message* msg__,
3677 : PickleIterator* iter__,
3678 : bool nullable__) -> bool
3679 : {
3680 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PFileSystemRequest", PFileSystemRequestMsgStart);
3681 0 : if ((actor).isNothing()) {
3682 0 : return false;
3683 : }
3684 :
3685 0 : (*(v__)) = static_cast<PFileSystemRequestChild*>((actor).value());
3686 0 : return true;
3687 : }
3688 :
3689 0 : auto PBackgroundChild::Write(
3690 : const IPCFile& v__,
3691 : Message* msg__) -> void
3692 : {
3693 0 : Write((v__).name(), msg__);
3694 : // Sentinel = 'name'
3695 0 : (msg__)->WriteSentinel(15034981);
3696 0 : Write((v__).lastModified(), msg__);
3697 : // Sentinel = 'lastModified'
3698 0 : (msg__)->WriteSentinel(3456113257);
3699 0 : Write((v__).DOMPath(), msg__);
3700 : // Sentinel = 'DOMPath'
3701 0 : (msg__)->WriteSentinel(1724352494);
3702 0 : Write((v__).fullPath(), msg__);
3703 : // Sentinel = 'fullPath'
3704 0 : (msg__)->WriteSentinel(385652698);
3705 0 : Write((v__).isDirectory(), msg__);
3706 : // Sentinel = 'isDirectory'
3707 0 : (msg__)->WriteSentinel(2309743506);
3708 0 : }
3709 :
3710 0 : auto PBackgroundChild::Read(
3711 : IPCFile* v__,
3712 : const Message* msg__,
3713 : PickleIterator* iter__) -> bool
3714 : {
3715 0 : if ((!(Read((&((v__)->name())), msg__, iter__)))) {
3716 0 : FatalError("Error deserializing 'name' (nsString) member of 'IPCFile'");
3717 0 : return false;
3718 : }
3719 : // Sentinel = 'name'
3720 0 : if ((!((msg__)->ReadSentinel(iter__, 15034981)))) {
3721 0 : mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'IPCFile'");
3722 0 : return false;
3723 : }
3724 0 : if ((!(Read((&((v__)->lastModified())), msg__, iter__)))) {
3725 0 : FatalError("Error deserializing 'lastModified' (int64_t) member of 'IPCFile'");
3726 0 : return false;
3727 : }
3728 : // Sentinel = 'lastModified'
3729 0 : if ((!((msg__)->ReadSentinel(iter__, 3456113257)))) {
3730 0 : mozilla::ipc::SentinelReadError("Error deserializing 'lastModified' (int64_t) member of 'IPCFile'");
3731 0 : return false;
3732 : }
3733 0 : if ((!(Read((&((v__)->DOMPath())), msg__, iter__)))) {
3734 0 : FatalError("Error deserializing 'DOMPath' (nsString) member of 'IPCFile'");
3735 0 : return false;
3736 : }
3737 : // Sentinel = 'DOMPath'
3738 0 : if ((!((msg__)->ReadSentinel(iter__, 1724352494)))) {
3739 0 : mozilla::ipc::SentinelReadError("Error deserializing 'DOMPath' (nsString) member of 'IPCFile'");
3740 0 : return false;
3741 : }
3742 0 : if ((!(Read((&((v__)->fullPath())), msg__, iter__)))) {
3743 0 : FatalError("Error deserializing 'fullPath' (nsString) member of 'IPCFile'");
3744 0 : return false;
3745 : }
3746 : // Sentinel = 'fullPath'
3747 0 : if ((!((msg__)->ReadSentinel(iter__, 385652698)))) {
3748 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fullPath' (nsString) member of 'IPCFile'");
3749 0 : return false;
3750 : }
3751 0 : if ((!(Read((&((v__)->isDirectory())), msg__, iter__)))) {
3752 0 : FatalError("Error deserializing 'isDirectory' (bool) member of 'IPCFile'");
3753 0 : return false;
3754 : }
3755 : // Sentinel = 'isDirectory'
3756 0 : if ((!((msg__)->ReadSentinel(iter__, 2309743506)))) {
3757 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isDirectory' (bool) member of 'IPCFile'");
3758 0 : return false;
3759 : }
3760 0 : return true;
3761 : }
3762 :
3763 2 : auto PBackgroundChild::Write(
3764 : const PServiceWorkerManagerChild* v__,
3765 : Message* msg__,
3766 : bool nullable__) -> void
3767 : {
3768 : int32_t id;
3769 2 : if ((!(v__))) {
3770 0 : if ((!(nullable__))) {
3771 0 : FatalError("NULL actor value passed to non-nullable param");
3772 : }
3773 0 : id = 0;
3774 : }
3775 : else {
3776 2 : id = (v__)->Id();
3777 2 : if ((1) == (id)) {
3778 0 : FatalError("actor has been |delete|d");
3779 : }
3780 : }
3781 :
3782 2 : Write(id, msg__);
3783 2 : }
3784 :
3785 0 : auto PBackgroundChild::Read(
3786 : PServiceWorkerManagerChild** v__,
3787 : const Message* msg__,
3788 : PickleIterator* iter__,
3789 : bool nullable__) -> bool
3790 : {
3791 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PServiceWorkerManager", PServiceWorkerManagerMsgStart);
3792 0 : if ((actor).isNothing()) {
3793 0 : return false;
3794 : }
3795 :
3796 0 : (*(v__)) = static_cast<PServiceWorkerManagerChild*>((actor).value());
3797 0 : return true;
3798 : }
3799 :
3800 0 : auto PBackgroundChild::Write(
3801 : const ExpandedPrincipalInfo& v__,
3802 : Message* msg__) -> void
3803 : {
3804 0 : Write((v__).attrs(), msg__);
3805 : // Sentinel = 'attrs'
3806 0 : (msg__)->WriteSentinel(3014987797);
3807 0 : Write((v__).whitelist(), msg__);
3808 : // Sentinel = 'whitelist'
3809 0 : (msg__)->WriteSentinel(3731637258);
3810 0 : }
3811 :
3812 0 : auto PBackgroundChild::Read(
3813 : ExpandedPrincipalInfo* v__,
3814 : const Message* msg__,
3815 : PickleIterator* iter__) -> bool
3816 : {
3817 0 : if ((!(Read((&((v__)->attrs())), msg__, iter__)))) {
3818 0 : FatalError("Error deserializing 'attrs' (OriginAttributes) member of 'ExpandedPrincipalInfo'");
3819 0 : return false;
3820 : }
3821 : // Sentinel = 'attrs'
3822 0 : if ((!((msg__)->ReadSentinel(iter__, 3014987797)))) {
3823 0 : mozilla::ipc::SentinelReadError("Error deserializing 'attrs' (OriginAttributes) member of 'ExpandedPrincipalInfo'");
3824 0 : return false;
3825 : }
3826 0 : if ((!(Read((&((v__)->whitelist())), msg__, iter__)))) {
3827 0 : FatalError("Error deserializing 'whitelist' (PrincipalInfo[]) member of 'ExpandedPrincipalInfo'");
3828 0 : return false;
3829 : }
3830 : // Sentinel = 'whitelist'
3831 0 : if ((!((msg__)->ReadSentinel(iter__, 3731637258)))) {
3832 0 : mozilla::ipc::SentinelReadError("Error deserializing 'whitelist' (PrincipalInfo[]) member of 'ExpandedPrincipalInfo'");
3833 0 : return false;
3834 : }
3835 0 : return true;
3836 : }
3837 :
3838 0 : auto PBackgroundChild::Write(
3839 : const PCacheStorageChild* v__,
3840 : Message* msg__,
3841 : bool nullable__) -> void
3842 : {
3843 : int32_t id;
3844 0 : if ((!(v__))) {
3845 0 : if ((!(nullable__))) {
3846 0 : FatalError("NULL actor value passed to non-nullable param");
3847 : }
3848 0 : id = 0;
3849 : }
3850 : else {
3851 0 : id = (v__)->Id();
3852 0 : if ((1) == (id)) {
3853 0 : FatalError("actor has been |delete|d");
3854 : }
3855 : }
3856 :
3857 0 : Write(id, msg__);
3858 0 : }
3859 :
3860 0 : auto PBackgroundChild::Read(
3861 : PCacheStorageChild** v__,
3862 : const Message* msg__,
3863 : PickleIterator* iter__,
3864 : bool nullable__) -> bool
3865 : {
3866 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PCacheStorage", PCacheStorageMsgStart);
3867 0 : if ((actor).isNothing()) {
3868 0 : return false;
3869 : }
3870 :
3871 0 : (*(v__)) = static_cast<PCacheStorageChild*>((actor).value());
3872 0 : return true;
3873 : }
3874 :
3875 0 : auto PBackgroundChild::Write(
3876 : const InputStreamParamsWithFds& v__,
3877 : Message* msg__) -> void
3878 : {
3879 0 : Write((v__).stream(), msg__);
3880 : // Sentinel = 'stream'
3881 0 : (msg__)->WriteSentinel(4152748422);
3882 0 : Write((v__).optionalFds(), msg__);
3883 : // Sentinel = 'optionalFds'
3884 0 : (msg__)->WriteSentinel(1021803302);
3885 0 : }
3886 :
3887 0 : auto PBackgroundChild::Read(
3888 : InputStreamParamsWithFds* v__,
3889 : const Message* msg__,
3890 : PickleIterator* iter__) -> bool
3891 : {
3892 0 : if ((!(Read((&((v__)->stream())), msg__, iter__)))) {
3893 0 : FatalError("Error deserializing 'stream' (InputStreamParams) member of 'InputStreamParamsWithFds'");
3894 0 : return false;
3895 : }
3896 : // Sentinel = 'stream'
3897 0 : if ((!((msg__)->ReadSentinel(iter__, 4152748422)))) {
3898 0 : mozilla::ipc::SentinelReadError("Error deserializing 'stream' (InputStreamParams) member of 'InputStreamParamsWithFds'");
3899 0 : return false;
3900 : }
3901 0 : if ((!(Read((&((v__)->optionalFds())), msg__, iter__)))) {
3902 0 : FatalError("Error deserializing 'optionalFds' (OptionalFileDescriptorSet) member of 'InputStreamParamsWithFds'");
3903 0 : return false;
3904 : }
3905 : // Sentinel = 'optionalFds'
3906 0 : if ((!((msg__)->ReadSentinel(iter__, 1021803302)))) {
3907 0 : mozilla::ipc::SentinelReadError("Error deserializing 'optionalFds' (OptionalFileDescriptorSet) member of 'InputStreamParamsWithFds'");
3908 0 : return false;
3909 : }
3910 0 : return true;
3911 : }
3912 :
3913 0 : auto PBackgroundChild::Write(
3914 : const IPCBlobStream& v__,
3915 : Message* msg__) -> void
3916 : {
3917 : typedef IPCBlobStream type__;
3918 0 : Write(int((v__).type()), msg__);
3919 : // Sentinel = 'IPCBlobStream'
3920 0 : (msg__)->WriteSentinel(2926762354);
3921 :
3922 0 : switch ((v__).type()) {
3923 : case type__::TPIPCBlobInputStreamParent:
3924 : {
3925 0 : FatalError("wrong side!");
3926 0 : return;
3927 : }
3928 : case type__::TPIPCBlobInputStreamChild:
3929 : {
3930 0 : Write((v__).get_PIPCBlobInputStreamChild(), msg__, false);
3931 : // Sentinel = 'TPIPCBlobInputStreamChild'
3932 0 : (msg__)->WriteSentinel(3349556844);
3933 0 : return;
3934 : }
3935 : case type__::TIPCStream:
3936 : {
3937 0 : Write((v__).get_IPCStream(), msg__);
3938 : // Sentinel = 'TIPCStream'
3939 0 : (msg__)->WriteSentinel(40701900);
3940 0 : return;
3941 : }
3942 : default:
3943 : {
3944 0 : FatalError("unknown union type");
3945 0 : return;
3946 : }
3947 : }
3948 : }
3949 :
3950 0 : auto PBackgroundChild::Read(
3951 : IPCBlobStream* v__,
3952 : const Message* msg__,
3953 : PickleIterator* iter__) -> bool
3954 : {
3955 : typedef IPCBlobStream type__;
3956 : int type;
3957 0 : if ((!(Read((&(type)), msg__, iter__)))) {
3958 0 : mozilla::ipc::UnionTypeReadError("IPCBlobStream");
3959 0 : return false;
3960 : }
3961 : // Sentinel = 'IPCBlobStream'
3962 0 : if ((!((msg__)->ReadSentinel(iter__, 2926762354)))) {
3963 0 : mozilla::ipc::SentinelReadError("IPCBlobStream");
3964 0 : return false;
3965 : }
3966 :
3967 0 : switch (type) {
3968 : case type__::TPIPCBlobInputStreamParent:
3969 : {
3970 0 : PIPCBlobInputStreamChild* tmp = nullptr;
3971 0 : (*(v__)) = tmp;
3972 0 : if ((!(Read((&((v__)->get_PIPCBlobInputStreamChild())), msg__, iter__, false)))) {
3973 0 : FatalError("Error deserializing Union type");
3974 0 : return false;
3975 : }
3976 : // Sentinel = 'TPIPCBlobInputStreamParent'
3977 0 : if ((!((msg__)->ReadSentinel(iter__, 2944059743)))) {
3978 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3979 0 : return false;
3980 : }
3981 0 : return true;
3982 : }
3983 : case type__::TPIPCBlobInputStreamChild:
3984 : {
3985 0 : return false;
3986 : }
3987 : case type__::TIPCStream:
3988 : {
3989 0 : IPCStream tmp = IPCStream();
3990 0 : (*(v__)) = tmp;
3991 0 : if ((!(Read((&((v__)->get_IPCStream())), msg__, iter__)))) {
3992 0 : FatalError("Error deserializing Union type");
3993 0 : return false;
3994 : }
3995 : // Sentinel = 'TIPCStream'
3996 0 : if ((!((msg__)->ReadSentinel(iter__, 40701900)))) {
3997 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3998 0 : return false;
3999 : }
4000 0 : return true;
4001 : }
4002 : default:
4003 : {
4004 0 : FatalError("unknown union type");
4005 0 : return false;
4006 : }
4007 : }
4008 : }
4009 :
4010 0 : auto PBackgroundChild::Write(
4011 : const FileSystemGetFilesParams& v__,
4012 : Message* msg__) -> void
4013 : {
4014 0 : Write((v__).filesystem(), msg__);
4015 : // Sentinel = 'filesystem'
4016 0 : (msg__)->WriteSentinel(1299848695);
4017 0 : Write((v__).realPath(), msg__);
4018 : // Sentinel = 'realPath'
4019 0 : (msg__)->WriteSentinel(2928426273);
4020 0 : Write((v__).domPath(), msg__);
4021 : // Sentinel = 'domPath'
4022 0 : (msg__)->WriteSentinel(3617779470);
4023 0 : Write((v__).recursiveFlag(), msg__);
4024 : // Sentinel = 'recursiveFlag'
4025 0 : (msg__)->WriteSentinel(3824256759);
4026 0 : }
4027 :
4028 0 : auto PBackgroundChild::Read(
4029 : FileSystemGetFilesParams* v__,
4030 : const Message* msg__,
4031 : PickleIterator* iter__) -> bool
4032 : {
4033 0 : if ((!(Read((&((v__)->filesystem())), msg__, iter__)))) {
4034 0 : FatalError("Error deserializing 'filesystem' (nsString) member of 'FileSystemGetFilesParams'");
4035 0 : return false;
4036 : }
4037 : // Sentinel = 'filesystem'
4038 0 : if ((!((msg__)->ReadSentinel(iter__, 1299848695)))) {
4039 0 : mozilla::ipc::SentinelReadError("Error deserializing 'filesystem' (nsString) member of 'FileSystemGetFilesParams'");
4040 0 : return false;
4041 : }
4042 0 : if ((!(Read((&((v__)->realPath())), msg__, iter__)))) {
4043 0 : FatalError("Error deserializing 'realPath' (nsString) member of 'FileSystemGetFilesParams'");
4044 0 : return false;
4045 : }
4046 : // Sentinel = 'realPath'
4047 0 : if ((!((msg__)->ReadSentinel(iter__, 2928426273)))) {
4048 0 : mozilla::ipc::SentinelReadError("Error deserializing 'realPath' (nsString) member of 'FileSystemGetFilesParams'");
4049 0 : return false;
4050 : }
4051 0 : if ((!(Read((&((v__)->domPath())), msg__, iter__)))) {
4052 0 : FatalError("Error deserializing 'domPath' (nsString) member of 'FileSystemGetFilesParams'");
4053 0 : return false;
4054 : }
4055 : // Sentinel = 'domPath'
4056 0 : if ((!((msg__)->ReadSentinel(iter__, 3617779470)))) {
4057 0 : mozilla::ipc::SentinelReadError("Error deserializing 'domPath' (nsString) member of 'FileSystemGetFilesParams'");
4058 0 : return false;
4059 : }
4060 0 : if ((!(Read((&((v__)->recursiveFlag())), msg__, iter__)))) {
4061 0 : FatalError("Error deserializing 'recursiveFlag' (bool) member of 'FileSystemGetFilesParams'");
4062 0 : return false;
4063 : }
4064 : // Sentinel = 'recursiveFlag'
4065 0 : if ((!((msg__)->ReadSentinel(iter__, 3824256759)))) {
4066 0 : mozilla::ipc::SentinelReadError("Error deserializing 'recursiveFlag' (bool) member of 'FileSystemGetFilesParams'");
4067 0 : return false;
4068 : }
4069 0 : return true;
4070 : }
4071 :
4072 0 : auto PBackgroundChild::Write(
4073 : const nsTArray<FileDescriptor>& v__,
4074 : Message* msg__) -> void
4075 : {
4076 0 : uint32_t length = (v__).Length();
4077 0 : Write(length, msg__);
4078 : // Sentinel = ('length', 'FileDescriptor[]')
4079 0 : (msg__)->WriteSentinel(1697726450);
4080 :
4081 0 : for (auto& elem : v__) {
4082 0 : Write(elem, msg__);
4083 : // Sentinel = 'FileDescriptor[]'
4084 0 : (msg__)->WriteSentinel(1630221245);
4085 : }
4086 0 : }
4087 :
4088 0 : auto PBackgroundChild::Read(
4089 : nsTArray<FileDescriptor>* v__,
4090 : const Message* msg__,
4091 : PickleIterator* iter__) -> bool
4092 : {
4093 0 : nsTArray<FileDescriptor> fa;
4094 : uint32_t length;
4095 0 : if ((!(Read((&(length)), msg__, iter__)))) {
4096 0 : mozilla::ipc::ArrayLengthReadError("FileDescriptor[]");
4097 0 : return false;
4098 : }
4099 : // Sentinel = ('length', 'FileDescriptor[]')
4100 0 : if ((!((msg__)->ReadSentinel(iter__, 1697726450)))) {
4101 0 : mozilla::ipc::SentinelReadError("FileDescriptor[]");
4102 0 : return false;
4103 : }
4104 :
4105 0 : FileDescriptor* elems = (fa).AppendElements(length);
4106 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
4107 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
4108 0 : FatalError("Error deserializing 'FileDescriptor[i]'");
4109 0 : return false;
4110 : }
4111 : // Sentinel = 'FileDescriptor[]'
4112 0 : if ((!((msg__)->ReadSentinel(iter__, 1630221245)))) {
4113 0 : mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor[i]'");
4114 0 : return false;
4115 : }
4116 : }
4117 0 : (v__)->SwapElements(fa);
4118 0 : return true;
4119 : }
4120 :
4121 0 : auto PBackgroundChild::Write(
4122 : const PFileDescriptorSetChild* v__,
4123 : Message* msg__,
4124 : bool nullable__) -> void
4125 : {
4126 : int32_t id;
4127 0 : if ((!(v__))) {
4128 0 : if ((!(nullable__))) {
4129 0 : FatalError("NULL actor value passed to non-nullable param");
4130 : }
4131 0 : id = 0;
4132 : }
4133 : else {
4134 0 : id = (v__)->Id();
4135 0 : if ((1) == (id)) {
4136 0 : FatalError("actor has been |delete|d");
4137 : }
4138 : }
4139 :
4140 0 : Write(id, msg__);
4141 0 : }
4142 :
4143 0 : auto PBackgroundChild::Read(
4144 : PFileDescriptorSetChild** v__,
4145 : const Message* msg__,
4146 : PickleIterator* iter__,
4147 : bool nullable__) -> bool
4148 : {
4149 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PFileDescriptorSet", PFileDescriptorSetMsgStart);
4150 0 : if ((actor).isNothing()) {
4151 0 : return false;
4152 : }
4153 :
4154 0 : (*(v__)) = static_cast<PFileDescriptorSetChild*>((actor).value());
4155 0 : return true;
4156 : }
4157 :
4158 0 : auto PBackgroundChild::Write(
4159 : const nsTArray<HeaderEntry>& v__,
4160 : Message* msg__) -> void
4161 : {
4162 0 : uint32_t length = (v__).Length();
4163 0 : Write(length, msg__);
4164 : // Sentinel = ('length', 'HeaderEntry[]')
4165 0 : (msg__)->WriteSentinel(2689457705);
4166 :
4167 0 : for (auto& elem : v__) {
4168 0 : Write(elem, msg__);
4169 : // Sentinel = 'HeaderEntry[]'
4170 0 : (msg__)->WriteSentinel(454836120);
4171 : }
4172 0 : }
4173 :
4174 0 : auto PBackgroundChild::Read(
4175 : nsTArray<HeaderEntry>* v__,
4176 : const Message* msg__,
4177 : PickleIterator* iter__) -> bool
4178 : {
4179 0 : nsTArray<HeaderEntry> fa;
4180 : uint32_t length;
4181 0 : if ((!(Read((&(length)), msg__, iter__)))) {
4182 0 : mozilla::ipc::ArrayLengthReadError("HeaderEntry[]");
4183 0 : return false;
4184 : }
4185 : // Sentinel = ('length', 'HeaderEntry[]')
4186 0 : if ((!((msg__)->ReadSentinel(iter__, 2689457705)))) {
4187 0 : mozilla::ipc::SentinelReadError("HeaderEntry[]");
4188 0 : return false;
4189 : }
4190 :
4191 0 : HeaderEntry* elems = (fa).AppendElements(length);
4192 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
4193 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
4194 0 : FatalError("Error deserializing 'HeaderEntry[i]'");
4195 0 : return false;
4196 : }
4197 : // Sentinel = 'HeaderEntry[]'
4198 0 : if ((!((msg__)->ReadSentinel(iter__, 454836120)))) {
4199 0 : mozilla::ipc::SentinelReadError("Error deserializing 'HeaderEntry[i]'");
4200 0 : return false;
4201 : }
4202 : }
4203 0 : (v__)->SwapElements(fa);
4204 0 : return true;
4205 : }
4206 :
4207 1 : auto PBackgroundChild::Write(
4208 : const PVsyncChild* v__,
4209 : Message* msg__,
4210 : bool nullable__) -> void
4211 : {
4212 : int32_t id;
4213 1 : if ((!(v__))) {
4214 0 : if ((!(nullable__))) {
4215 0 : FatalError("NULL actor value passed to non-nullable param");
4216 : }
4217 0 : id = 0;
4218 : }
4219 : else {
4220 1 : id = (v__)->Id();
4221 1 : if ((1) == (id)) {
4222 0 : FatalError("actor has been |delete|d");
4223 : }
4224 : }
4225 :
4226 1 : Write(id, msg__);
4227 1 : }
4228 :
4229 0 : auto PBackgroundChild::Read(
4230 : PVsyncChild** v__,
4231 : const Message* msg__,
4232 : PickleIterator* iter__,
4233 : bool nullable__) -> bool
4234 : {
4235 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PVsync", PVsyncMsgStart);
4236 0 : if ((actor).isNothing()) {
4237 0 : return false;
4238 : }
4239 :
4240 0 : (*(v__)) = static_cast<PVsyncChild*>((actor).value());
4241 0 : return true;
4242 : }
4243 :
4244 0 : auto PBackgroundChild::Write(
4245 : const PAsmJSCacheEntryChild* v__,
4246 : Message* msg__,
4247 : bool nullable__) -> void
4248 : {
4249 : int32_t id;
4250 0 : if ((!(v__))) {
4251 0 : if ((!(nullable__))) {
4252 0 : FatalError("NULL actor value passed to non-nullable param");
4253 : }
4254 0 : id = 0;
4255 : }
4256 : else {
4257 0 : id = (v__)->Id();
4258 0 : if ((1) == (id)) {
4259 0 : FatalError("actor has been |delete|d");
4260 : }
4261 : }
4262 :
4263 0 : Write(id, msg__);
4264 0 : }
4265 :
4266 0 : auto PBackgroundChild::Read(
4267 : PAsmJSCacheEntryChild** v__,
4268 : const Message* msg__,
4269 : PickleIterator* iter__,
4270 : bool nullable__) -> bool
4271 : {
4272 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PAsmJSCacheEntry", PAsmJSCacheEntryMsgStart);
4273 0 : if ((actor).isNothing()) {
4274 0 : return false;
4275 : }
4276 :
4277 0 : (*(v__)) = static_cast<PAsmJSCacheEntryChild*>((actor).value());
4278 0 : return true;
4279 : }
4280 :
4281 0 : auto PBackgroundChild::Write(
4282 : const FileInputStreamParams& v__,
4283 : Message* msg__) -> void
4284 : {
4285 0 : Write((v__).fileDescriptorIndex(), msg__);
4286 : // Sentinel = 'fileDescriptorIndex'
4287 0 : (msg__)->WriteSentinel(587329112);
4288 0 : Write((v__).behaviorFlags(), msg__);
4289 : // Sentinel = 'behaviorFlags'
4290 0 : (msg__)->WriteSentinel(2404401962);
4291 0 : Write((v__).ioFlags(), msg__);
4292 : // Sentinel = 'ioFlags'
4293 0 : (msg__)->WriteSentinel(1483009730);
4294 0 : }
4295 :
4296 0 : auto PBackgroundChild::Read(
4297 : FileInputStreamParams* v__,
4298 : const Message* msg__,
4299 : PickleIterator* iter__) -> bool
4300 : {
4301 0 : if ((!(Read((&((v__)->fileDescriptorIndex())), msg__, iter__)))) {
4302 0 : FatalError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'FileInputStreamParams'");
4303 0 : return false;
4304 : }
4305 : // Sentinel = 'fileDescriptorIndex'
4306 0 : if ((!((msg__)->ReadSentinel(iter__, 587329112)))) {
4307 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'FileInputStreamParams'");
4308 0 : return false;
4309 : }
4310 0 : if ((!(Read((&((v__)->behaviorFlags())), msg__, iter__)))) {
4311 0 : FatalError("Error deserializing 'behaviorFlags' (int32_t) member of 'FileInputStreamParams'");
4312 0 : return false;
4313 : }
4314 : // Sentinel = 'behaviorFlags'
4315 0 : if ((!((msg__)->ReadSentinel(iter__, 2404401962)))) {
4316 0 : mozilla::ipc::SentinelReadError("Error deserializing 'behaviorFlags' (int32_t) member of 'FileInputStreamParams'");
4317 0 : return false;
4318 : }
4319 0 : if ((!(Read((&((v__)->ioFlags())), msg__, iter__)))) {
4320 0 : FatalError("Error deserializing 'ioFlags' (int32_t) member of 'FileInputStreamParams'");
4321 0 : return false;
4322 : }
4323 : // Sentinel = 'ioFlags'
4324 0 : if ((!((msg__)->ReadSentinel(iter__, 1483009730)))) {
4325 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ioFlags' (int32_t) member of 'FileInputStreamParams'");
4326 0 : return false;
4327 : }
4328 0 : return true;
4329 : }
4330 :
4331 0 : auto PBackgroundChild::Write(
4332 : const FileSystemGetFileOrDirectoryParams& v__,
4333 : Message* msg__) -> void
4334 : {
4335 0 : Write((v__).filesystem(), msg__);
4336 : // Sentinel = 'filesystem'
4337 0 : (msg__)->WriteSentinel(1299848695);
4338 0 : Write((v__).realPath(), msg__);
4339 : // Sentinel = 'realPath'
4340 0 : (msg__)->WriteSentinel(2928426273);
4341 0 : }
4342 :
4343 0 : auto PBackgroundChild::Read(
4344 : FileSystemGetFileOrDirectoryParams* v__,
4345 : const Message* msg__,
4346 : PickleIterator* iter__) -> bool
4347 : {
4348 0 : if ((!(Read((&((v__)->filesystem())), msg__, iter__)))) {
4349 0 : FatalError("Error deserializing 'filesystem' (nsString) member of 'FileSystemGetFileOrDirectoryParams'");
4350 0 : return false;
4351 : }
4352 : // Sentinel = 'filesystem'
4353 0 : if ((!((msg__)->ReadSentinel(iter__, 1299848695)))) {
4354 0 : mozilla::ipc::SentinelReadError("Error deserializing 'filesystem' (nsString) member of 'FileSystemGetFileOrDirectoryParams'");
4355 0 : return false;
4356 : }
4357 0 : if ((!(Read((&((v__)->realPath())), msg__, iter__)))) {
4358 0 : FatalError("Error deserializing 'realPath' (nsString) member of 'FileSystemGetFileOrDirectoryParams'");
4359 0 : return false;
4360 : }
4361 : // Sentinel = 'realPath'
4362 0 : if ((!((msg__)->ReadSentinel(iter__, 2928426273)))) {
4363 0 : mozilla::ipc::SentinelReadError("Error deserializing 'realPath' (nsString) member of 'FileSystemGetFileOrDirectoryParams'");
4364 0 : return false;
4365 : }
4366 0 : return true;
4367 : }
4368 :
4369 0 : auto PBackgroundChild::Write(
4370 : const PrincipalInfo& v__,
4371 : Message* msg__) -> void
4372 : {
4373 : typedef PrincipalInfo type__;
4374 0 : Write(int((v__).type()), msg__);
4375 : // Sentinel = 'PrincipalInfo'
4376 0 : (msg__)->WriteSentinel(4194518819);
4377 :
4378 0 : switch ((v__).type()) {
4379 : case type__::TContentPrincipalInfo:
4380 : {
4381 0 : Write((v__).get_ContentPrincipalInfo(), msg__);
4382 : // Sentinel = 'TContentPrincipalInfo'
4383 0 : (msg__)->WriteSentinel(3677342258);
4384 0 : return;
4385 : }
4386 : case type__::TSystemPrincipalInfo:
4387 : {
4388 0 : Write((v__).get_SystemPrincipalInfo(), msg__);
4389 : // Sentinel = 'TSystemPrincipalInfo'
4390 0 : (msg__)->WriteSentinel(3590603679);
4391 0 : return;
4392 : }
4393 : case type__::TNullPrincipalInfo:
4394 : {
4395 0 : Write((v__).get_NullPrincipalInfo(), msg__);
4396 : // Sentinel = 'TNullPrincipalInfo'
4397 0 : (msg__)->WriteSentinel(3477774965);
4398 0 : return;
4399 : }
4400 : case type__::TExpandedPrincipalInfo:
4401 : {
4402 0 : Write((v__).get_ExpandedPrincipalInfo(), msg__);
4403 : // Sentinel = 'TExpandedPrincipalInfo'
4404 0 : (msg__)->WriteSentinel(589324917);
4405 0 : return;
4406 : }
4407 : default:
4408 : {
4409 0 : FatalError("unknown union type");
4410 0 : return;
4411 : }
4412 : }
4413 : }
4414 :
4415 0 : auto PBackgroundChild::Read(
4416 : PrincipalInfo* v__,
4417 : const Message* msg__,
4418 : PickleIterator* iter__) -> bool
4419 : {
4420 : typedef PrincipalInfo type__;
4421 : int type;
4422 0 : if ((!(Read((&(type)), msg__, iter__)))) {
4423 0 : mozilla::ipc::UnionTypeReadError("PrincipalInfo");
4424 0 : return false;
4425 : }
4426 : // Sentinel = 'PrincipalInfo'
4427 0 : if ((!((msg__)->ReadSentinel(iter__, 4194518819)))) {
4428 0 : mozilla::ipc::SentinelReadError("PrincipalInfo");
4429 0 : return false;
4430 : }
4431 :
4432 0 : switch (type) {
4433 : case type__::TContentPrincipalInfo:
4434 : {
4435 0 : ContentPrincipalInfo tmp = ContentPrincipalInfo();
4436 0 : (*(v__)) = tmp;
4437 0 : if ((!(Read((&((v__)->get_ContentPrincipalInfo())), msg__, iter__)))) {
4438 0 : FatalError("Error deserializing Union type");
4439 0 : return false;
4440 : }
4441 : // Sentinel = 'TContentPrincipalInfo'
4442 0 : if ((!((msg__)->ReadSentinel(iter__, 3677342258)))) {
4443 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4444 0 : return false;
4445 : }
4446 0 : return true;
4447 : }
4448 : case type__::TSystemPrincipalInfo:
4449 : {
4450 0 : SystemPrincipalInfo tmp = SystemPrincipalInfo();
4451 0 : (*(v__)) = tmp;
4452 0 : if ((!(Read((&((v__)->get_SystemPrincipalInfo())), msg__, iter__)))) {
4453 0 : FatalError("Error deserializing Union type");
4454 0 : return false;
4455 : }
4456 : // Sentinel = 'TSystemPrincipalInfo'
4457 0 : if ((!((msg__)->ReadSentinel(iter__, 3590603679)))) {
4458 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4459 0 : return false;
4460 : }
4461 0 : return true;
4462 : }
4463 : case type__::TNullPrincipalInfo:
4464 : {
4465 0 : NullPrincipalInfo tmp = NullPrincipalInfo();
4466 0 : (*(v__)) = tmp;
4467 0 : if ((!(Read((&((v__)->get_NullPrincipalInfo())), msg__, iter__)))) {
4468 0 : FatalError("Error deserializing Union type");
4469 0 : return false;
4470 : }
4471 : // Sentinel = 'TNullPrincipalInfo'
4472 0 : if ((!((msg__)->ReadSentinel(iter__, 3477774965)))) {
4473 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4474 0 : return false;
4475 : }
4476 0 : return true;
4477 : }
4478 : case type__::TExpandedPrincipalInfo:
4479 : {
4480 0 : ExpandedPrincipalInfo tmp = ExpandedPrincipalInfo();
4481 0 : (*(v__)) = tmp;
4482 0 : if ((!(Read((&((v__)->get_ExpandedPrincipalInfo())), msg__, iter__)))) {
4483 0 : FatalError("Error deserializing Union type");
4484 0 : return false;
4485 : }
4486 : // Sentinel = 'TExpandedPrincipalInfo'
4487 0 : if ((!((msg__)->ReadSentinel(iter__, 589324917)))) {
4488 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4489 0 : return false;
4490 : }
4491 0 : return true;
4492 : }
4493 : default:
4494 : {
4495 0 : FatalError("unknown union type");
4496 0 : return false;
4497 : }
4498 : }
4499 : }
4500 :
4501 0 : auto PBackgroundChild::Write(
4502 : const TemporaryFileInputStreamParams& v__,
4503 : Message* msg__) -> void
4504 : {
4505 0 : Write((v__).fileDescriptorIndex(), msg__);
4506 : // Sentinel = 'fileDescriptorIndex'
4507 0 : (msg__)->WriteSentinel(587329112);
4508 0 : Write((v__).startPos(), msg__);
4509 : // Sentinel = 'startPos'
4510 0 : (msg__)->WriteSentinel(557207962);
4511 0 : Write((v__).endPos(), msg__);
4512 : // Sentinel = 'endPos'
4513 0 : (msg__)->WriteSentinel(881536245);
4514 0 : }
4515 :
4516 0 : auto PBackgroundChild::Read(
4517 : TemporaryFileInputStreamParams* v__,
4518 : const Message* msg__,
4519 : PickleIterator* iter__) -> bool
4520 : {
4521 0 : if ((!(Read((&((v__)->fileDescriptorIndex())), msg__, iter__)))) {
4522 0 : FatalError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'TemporaryFileInputStreamParams'");
4523 0 : return false;
4524 : }
4525 : // Sentinel = 'fileDescriptorIndex'
4526 0 : if ((!((msg__)->ReadSentinel(iter__, 587329112)))) {
4527 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'TemporaryFileInputStreamParams'");
4528 0 : return false;
4529 : }
4530 0 : if ((!(Read((&((v__)->startPos())), msg__, iter__)))) {
4531 0 : FatalError("Error deserializing 'startPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
4532 0 : return false;
4533 : }
4534 : // Sentinel = 'startPos'
4535 0 : if ((!((msg__)->ReadSentinel(iter__, 557207962)))) {
4536 0 : mozilla::ipc::SentinelReadError("Error deserializing 'startPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
4537 0 : return false;
4538 : }
4539 0 : if ((!(Read((&((v__)->endPos())), msg__, iter__)))) {
4540 0 : FatalError("Error deserializing 'endPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
4541 0 : return false;
4542 : }
4543 : // Sentinel = 'endPos'
4544 0 : if ((!((msg__)->ReadSentinel(iter__, 881536245)))) {
4545 0 : mozilla::ipc::SentinelReadError("Error deserializing 'endPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
4546 0 : return false;
4547 : }
4548 0 : return true;
4549 : }
4550 :
4551 0 : auto PBackgroundChild::Write(
4552 : const IPCStream& v__,
4553 : Message* msg__) -> void
4554 : {
4555 : typedef IPCStream type__;
4556 0 : Write(int((v__).type()), msg__);
4557 : // Sentinel = 'IPCStream'
4558 0 : (msg__)->WriteSentinel(442610715);
4559 :
4560 0 : switch ((v__).type()) {
4561 : case type__::TInputStreamParamsWithFds:
4562 : {
4563 0 : Write((v__).get_InputStreamParamsWithFds(), msg__);
4564 : // Sentinel = 'TInputStreamParamsWithFds'
4565 0 : (msg__)->WriteSentinel(2170706066);
4566 0 : return;
4567 : }
4568 : case type__::TIPCRemoteStream:
4569 : {
4570 0 : Write((v__).get_IPCRemoteStream(), msg__);
4571 : // Sentinel = 'TIPCRemoteStream'
4572 0 : (msg__)->WriteSentinel(2978132448);
4573 0 : return;
4574 : }
4575 : default:
4576 : {
4577 0 : FatalError("unknown union type");
4578 0 : return;
4579 : }
4580 : }
4581 : }
4582 :
4583 0 : auto PBackgroundChild::Read(
4584 : IPCStream* v__,
4585 : const Message* msg__,
4586 : PickleIterator* iter__) -> bool
4587 : {
4588 : typedef IPCStream type__;
4589 : int type;
4590 0 : if ((!(Read((&(type)), msg__, iter__)))) {
4591 0 : mozilla::ipc::UnionTypeReadError("IPCStream");
4592 0 : return false;
4593 : }
4594 : // Sentinel = 'IPCStream'
4595 0 : if ((!((msg__)->ReadSentinel(iter__, 442610715)))) {
4596 0 : mozilla::ipc::SentinelReadError("IPCStream");
4597 0 : return false;
4598 : }
4599 :
4600 0 : switch (type) {
4601 : case type__::TInputStreamParamsWithFds:
4602 : {
4603 0 : InputStreamParamsWithFds tmp = InputStreamParamsWithFds();
4604 0 : (*(v__)) = tmp;
4605 0 : if ((!(Read((&((v__)->get_InputStreamParamsWithFds())), msg__, iter__)))) {
4606 0 : FatalError("Error deserializing Union type");
4607 0 : return false;
4608 : }
4609 : // Sentinel = 'TInputStreamParamsWithFds'
4610 0 : if ((!((msg__)->ReadSentinel(iter__, 2170706066)))) {
4611 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4612 0 : return false;
4613 : }
4614 0 : return true;
4615 : }
4616 : case type__::TIPCRemoteStream:
4617 : {
4618 0 : IPCRemoteStream tmp = IPCRemoteStream();
4619 0 : (*(v__)) = tmp;
4620 0 : if ((!(Read((&((v__)->get_IPCRemoteStream())), msg__, iter__)))) {
4621 0 : FatalError("Error deserializing Union type");
4622 0 : return false;
4623 : }
4624 : // Sentinel = 'TIPCRemoteStream'
4625 0 : if ((!((msg__)->ReadSentinel(iter__, 2978132448)))) {
4626 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4627 0 : return false;
4628 : }
4629 0 : return true;
4630 : }
4631 : default:
4632 : {
4633 0 : FatalError("unknown union type");
4634 0 : return false;
4635 : }
4636 : }
4637 : }
4638 :
4639 0 : auto PBackgroundChild::Write(
4640 : const IPCRemoteStream& v__,
4641 : Message* msg__) -> void
4642 : {
4643 0 : Write((v__).delayedStart(), msg__);
4644 : // Sentinel = 'delayedStart'
4645 0 : (msg__)->WriteSentinel(1491822294);
4646 0 : Write((v__).stream(), msg__);
4647 : // Sentinel = 'stream'
4648 0 : (msg__)->WriteSentinel(4152748422);
4649 0 : }
4650 :
4651 0 : auto PBackgroundChild::Read(
4652 : IPCRemoteStream* v__,
4653 : const Message* msg__,
4654 : PickleIterator* iter__) -> bool
4655 : {
4656 0 : if ((!(Read((&((v__)->delayedStart())), msg__, iter__)))) {
4657 0 : FatalError("Error deserializing 'delayedStart' (bool) member of 'IPCRemoteStream'");
4658 0 : return false;
4659 : }
4660 : // Sentinel = 'delayedStart'
4661 0 : if ((!((msg__)->ReadSentinel(iter__, 1491822294)))) {
4662 0 : mozilla::ipc::SentinelReadError("Error deserializing 'delayedStart' (bool) member of 'IPCRemoteStream'");
4663 0 : return false;
4664 : }
4665 0 : if ((!(Read((&((v__)->stream())), msg__, iter__)))) {
4666 0 : FatalError("Error deserializing 'stream' (IPCRemoteStreamType) member of 'IPCRemoteStream'");
4667 0 : return false;
4668 : }
4669 : // Sentinel = 'stream'
4670 0 : if ((!((msg__)->ReadSentinel(iter__, 4152748422)))) {
4671 0 : mozilla::ipc::SentinelReadError("Error deserializing 'stream' (IPCRemoteStreamType) member of 'IPCRemoteStream'");
4672 0 : return false;
4673 : }
4674 0 : return true;
4675 : }
4676 :
4677 0 : auto PBackgroundChild::Write(
4678 : const PBroadcastChannelChild* v__,
4679 : Message* msg__,
4680 : bool nullable__) -> void
4681 : {
4682 : int32_t id;
4683 0 : if ((!(v__))) {
4684 0 : if ((!(nullable__))) {
4685 0 : FatalError("NULL actor value passed to non-nullable param");
4686 : }
4687 0 : id = 0;
4688 : }
4689 : else {
4690 0 : id = (v__)->Id();
4691 0 : if ((1) == (id)) {
4692 0 : FatalError("actor has been |delete|d");
4693 : }
4694 : }
4695 :
4696 0 : Write(id, msg__);
4697 0 : }
4698 :
4699 0 : auto PBackgroundChild::Read(
4700 : PBroadcastChannelChild** v__,
4701 : const Message* msg__,
4702 : PickleIterator* iter__,
4703 : bool nullable__) -> bool
4704 : {
4705 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PBroadcastChannel", PBroadcastChannelMsgStart);
4706 0 : if ((actor).isNothing()) {
4707 0 : return false;
4708 : }
4709 :
4710 0 : (*(v__)) = static_cast<PBroadcastChannelChild*>((actor).value());
4711 0 : return true;
4712 : }
4713 :
4714 0 : auto PBackgroundChild::Write(
4715 : const ContentPrincipalInfo& v__,
4716 : Message* msg__) -> void
4717 : {
4718 0 : Write((v__).attrs(), msg__);
4719 : // Sentinel = 'attrs'
4720 0 : (msg__)->WriteSentinel(3014987797);
4721 0 : Write((v__).originNoSuffix(), msg__);
4722 : // Sentinel = 'originNoSuffix'
4723 0 : (msg__)->WriteSentinel(2833071422);
4724 0 : Write((v__).spec(), msg__);
4725 : // Sentinel = 'spec'
4726 0 : (msg__)->WriteSentinel(1630740541);
4727 0 : }
4728 :
4729 0 : auto PBackgroundChild::Read(
4730 : ContentPrincipalInfo* v__,
4731 : const Message* msg__,
4732 : PickleIterator* iter__) -> bool
4733 : {
4734 0 : if ((!(Read((&((v__)->attrs())), msg__, iter__)))) {
4735 0 : FatalError("Error deserializing 'attrs' (OriginAttributes) member of 'ContentPrincipalInfo'");
4736 0 : return false;
4737 : }
4738 : // Sentinel = 'attrs'
4739 0 : if ((!((msg__)->ReadSentinel(iter__, 3014987797)))) {
4740 0 : mozilla::ipc::SentinelReadError("Error deserializing 'attrs' (OriginAttributes) member of 'ContentPrincipalInfo'");
4741 0 : return false;
4742 : }
4743 0 : if ((!(Read((&((v__)->originNoSuffix())), msg__, iter__)))) {
4744 0 : FatalError("Error deserializing 'originNoSuffix' (ContentPrincipalInfoOriginNoSuffix) member of 'ContentPrincipalInfo'");
4745 0 : return false;
4746 : }
4747 : // Sentinel = 'originNoSuffix'
4748 0 : if ((!((msg__)->ReadSentinel(iter__, 2833071422)))) {
4749 0 : mozilla::ipc::SentinelReadError("Error deserializing 'originNoSuffix' (ContentPrincipalInfoOriginNoSuffix) member of 'ContentPrincipalInfo'");
4750 0 : return false;
4751 : }
4752 0 : if ((!(Read((&((v__)->spec())), msg__, iter__)))) {
4753 0 : FatalError("Error deserializing 'spec' (nsCString) member of 'ContentPrincipalInfo'");
4754 0 : return false;
4755 : }
4756 : // Sentinel = 'spec'
4757 0 : if ((!((msg__)->ReadSentinel(iter__, 1630740541)))) {
4758 0 : mozilla::ipc::SentinelReadError("Error deserializing 'spec' (nsCString) member of 'ContentPrincipalInfo'");
4759 0 : return false;
4760 : }
4761 0 : return true;
4762 : }
4763 :
4764 0 : auto PBackgroundChild::Write(
4765 : const LoggingInfo& v__,
4766 : Message* msg__) -> void
4767 : {
4768 0 : Write((v__).backgroundChildLoggingId(), msg__);
4769 : // Sentinel = 'backgroundChildLoggingId'
4770 0 : (msg__)->WriteSentinel(1141875058);
4771 0 : Write((v__).nextTransactionSerialNumber(), msg__);
4772 : // Sentinel = 'nextTransactionSerialNumber'
4773 0 : (msg__)->WriteSentinel(3152678733);
4774 0 : Write((v__).nextVersionChangeTransactionSerialNumber(), msg__);
4775 : // Sentinel = 'nextVersionChangeTransactionSerialNumber'
4776 0 : (msg__)->WriteSentinel(1202652600);
4777 0 : Write((v__).nextRequestSerialNumber(), msg__);
4778 : // Sentinel = 'nextRequestSerialNumber'
4779 0 : (msg__)->WriteSentinel(37621626);
4780 0 : }
4781 :
4782 0 : auto PBackgroundChild::Read(
4783 : LoggingInfo* v__,
4784 : const Message* msg__,
4785 : PickleIterator* iter__) -> bool
4786 : {
4787 0 : if ((!(Read((&((v__)->backgroundChildLoggingId())), msg__, iter__)))) {
4788 0 : FatalError("Error deserializing 'backgroundChildLoggingId' (nsID) member of 'LoggingInfo'");
4789 0 : return false;
4790 : }
4791 : // Sentinel = 'backgroundChildLoggingId'
4792 0 : if ((!((msg__)->ReadSentinel(iter__, 1141875058)))) {
4793 0 : mozilla::ipc::SentinelReadError("Error deserializing 'backgroundChildLoggingId' (nsID) member of 'LoggingInfo'");
4794 0 : return false;
4795 : }
4796 0 : if ((!(Read((&((v__)->nextTransactionSerialNumber())), msg__, iter__)))) {
4797 0 : FatalError("Error deserializing 'nextTransactionSerialNumber' (int64_t) member of 'LoggingInfo'");
4798 0 : return false;
4799 : }
4800 : // Sentinel = 'nextTransactionSerialNumber'
4801 0 : if ((!((msg__)->ReadSentinel(iter__, 3152678733)))) {
4802 0 : mozilla::ipc::SentinelReadError("Error deserializing 'nextTransactionSerialNumber' (int64_t) member of 'LoggingInfo'");
4803 0 : return false;
4804 : }
4805 0 : if ((!(Read((&((v__)->nextVersionChangeTransactionSerialNumber())), msg__, iter__)))) {
4806 0 : FatalError("Error deserializing 'nextVersionChangeTransactionSerialNumber' (int64_t) member of 'LoggingInfo'");
4807 0 : return false;
4808 : }
4809 : // Sentinel = 'nextVersionChangeTransactionSerialNumber'
4810 0 : if ((!((msg__)->ReadSentinel(iter__, 1202652600)))) {
4811 0 : mozilla::ipc::SentinelReadError("Error deserializing 'nextVersionChangeTransactionSerialNumber' (int64_t) member of 'LoggingInfo'");
4812 0 : return false;
4813 : }
4814 0 : if ((!(Read((&((v__)->nextRequestSerialNumber())), msg__, iter__)))) {
4815 0 : FatalError("Error deserializing 'nextRequestSerialNumber' (uint64_t) member of 'LoggingInfo'");
4816 0 : return false;
4817 : }
4818 : // Sentinel = 'nextRequestSerialNumber'
4819 0 : if ((!((msg__)->ReadSentinel(iter__, 37621626)))) {
4820 0 : mozilla::ipc::SentinelReadError("Error deserializing 'nextRequestSerialNumber' (uint64_t) member of 'LoggingInfo'");
4821 0 : return false;
4822 : }
4823 0 : return true;
4824 : }
4825 :
4826 0 : auto PBackgroundChild::Write(
4827 : const MIMEInputStreamParams& v__,
4828 : Message* msg__) -> void
4829 : {
4830 0 : Write((v__).optionalStream(), msg__);
4831 : // Sentinel = 'optionalStream'
4832 0 : (msg__)->WriteSentinel(1003718562);
4833 0 : Write((v__).headers(), msg__);
4834 : // Sentinel = 'headers'
4835 0 : (msg__)->WriteSentinel(4284175217);
4836 0 : Write((v__).startedReading(), msg__);
4837 : // Sentinel = 'startedReading'
4838 0 : (msg__)->WriteSentinel(1906875903);
4839 0 : }
4840 :
4841 0 : auto PBackgroundChild::Read(
4842 : MIMEInputStreamParams* v__,
4843 : const Message* msg__,
4844 : PickleIterator* iter__) -> bool
4845 : {
4846 0 : if ((!(Read((&((v__)->optionalStream())), msg__, iter__)))) {
4847 0 : FatalError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'MIMEInputStreamParams'");
4848 0 : return false;
4849 : }
4850 : // Sentinel = 'optionalStream'
4851 0 : if ((!((msg__)->ReadSentinel(iter__, 1003718562)))) {
4852 0 : mozilla::ipc::SentinelReadError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'MIMEInputStreamParams'");
4853 0 : return false;
4854 : }
4855 0 : if ((!(Read((&((v__)->headers())), msg__, iter__)))) {
4856 0 : FatalError("Error deserializing 'headers' (HeaderEntry[]) member of 'MIMEInputStreamParams'");
4857 0 : return false;
4858 : }
4859 : // Sentinel = 'headers'
4860 0 : if ((!((msg__)->ReadSentinel(iter__, 4284175217)))) {
4861 0 : mozilla::ipc::SentinelReadError("Error deserializing 'headers' (HeaderEntry[]) member of 'MIMEInputStreamParams'");
4862 0 : return false;
4863 : }
4864 0 : if ((!(Read((&((v__)->startedReading())), msg__, iter__)))) {
4865 0 : FatalError("Error deserializing 'startedReading' (bool) member of 'MIMEInputStreamParams'");
4866 0 : return false;
4867 : }
4868 : // Sentinel = 'startedReading'
4869 0 : if ((!((msg__)->ReadSentinel(iter__, 1906875903)))) {
4870 0 : mozilla::ipc::SentinelReadError("Error deserializing 'startedReading' (bool) member of 'MIMEInputStreamParams'");
4871 0 : return false;
4872 : }
4873 0 : return true;
4874 : }
4875 :
4876 0 : auto PBackgroundChild::Write(
4877 : const PCamerasChild* v__,
4878 : Message* msg__,
4879 : bool nullable__) -> void
4880 : {
4881 : int32_t id;
4882 0 : if ((!(v__))) {
4883 0 : if ((!(nullable__))) {
4884 0 : FatalError("NULL actor value passed to non-nullable param");
4885 : }
4886 0 : id = 0;
4887 : }
4888 : else {
4889 0 : id = (v__)->Id();
4890 0 : if ((1) == (id)) {
4891 0 : FatalError("actor has been |delete|d");
4892 : }
4893 : }
4894 :
4895 0 : Write(id, msg__);
4896 0 : }
4897 :
4898 0 : auto PBackgroundChild::Read(
4899 : PCamerasChild** v__,
4900 : const Message* msg__,
4901 : PickleIterator* iter__,
4902 : bool nullable__) -> bool
4903 : {
4904 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PCameras", PCamerasMsgStart);
4905 0 : if ((actor).isNothing()) {
4906 0 : return false;
4907 : }
4908 :
4909 0 : (*(v__)) = static_cast<PCamerasChild*>((actor).value());
4910 0 : return true;
4911 : }
4912 :
4913 0 : auto PBackgroundChild::Write(
4914 : const FileSystemGetDirectoryListingParams& v__,
4915 : Message* msg__) -> void
4916 : {
4917 0 : Write((v__).filesystem(), msg__);
4918 : // Sentinel = 'filesystem'
4919 0 : (msg__)->WriteSentinel(1299848695);
4920 0 : Write((v__).realPath(), msg__);
4921 : // Sentinel = 'realPath'
4922 0 : (msg__)->WriteSentinel(2928426273);
4923 0 : Write((v__).domPath(), msg__);
4924 : // Sentinel = 'domPath'
4925 0 : (msg__)->WriteSentinel(3617779470);
4926 0 : Write((v__).filters(), msg__);
4927 : // Sentinel = 'filters'
4928 0 : (msg__)->WriteSentinel(4001190422);
4929 0 : }
4930 :
4931 0 : auto PBackgroundChild::Read(
4932 : FileSystemGetDirectoryListingParams* v__,
4933 : const Message* msg__,
4934 : PickleIterator* iter__) -> bool
4935 : {
4936 0 : if ((!(Read((&((v__)->filesystem())), msg__, iter__)))) {
4937 0 : FatalError("Error deserializing 'filesystem' (nsString) member of 'FileSystemGetDirectoryListingParams'");
4938 0 : return false;
4939 : }
4940 : // Sentinel = 'filesystem'
4941 0 : if ((!((msg__)->ReadSentinel(iter__, 1299848695)))) {
4942 0 : mozilla::ipc::SentinelReadError("Error deserializing 'filesystem' (nsString) member of 'FileSystemGetDirectoryListingParams'");
4943 0 : return false;
4944 : }
4945 0 : if ((!(Read((&((v__)->realPath())), msg__, iter__)))) {
4946 0 : FatalError("Error deserializing 'realPath' (nsString) member of 'FileSystemGetDirectoryListingParams'");
4947 0 : return false;
4948 : }
4949 : // Sentinel = 'realPath'
4950 0 : if ((!((msg__)->ReadSentinel(iter__, 2928426273)))) {
4951 0 : mozilla::ipc::SentinelReadError("Error deserializing 'realPath' (nsString) member of 'FileSystemGetDirectoryListingParams'");
4952 0 : return false;
4953 : }
4954 0 : if ((!(Read((&((v__)->domPath())), msg__, iter__)))) {
4955 0 : FatalError("Error deserializing 'domPath' (nsString) member of 'FileSystemGetDirectoryListingParams'");
4956 0 : return false;
4957 : }
4958 : // Sentinel = 'domPath'
4959 0 : if ((!((msg__)->ReadSentinel(iter__, 3617779470)))) {
4960 0 : mozilla::ipc::SentinelReadError("Error deserializing 'domPath' (nsString) member of 'FileSystemGetDirectoryListingParams'");
4961 0 : return false;
4962 : }
4963 0 : if ((!(Read((&((v__)->filters())), msg__, iter__)))) {
4964 0 : FatalError("Error deserializing 'filters' (nsString) member of 'FileSystemGetDirectoryListingParams'");
4965 0 : return false;
4966 : }
4967 : // Sentinel = 'filters'
4968 0 : if ((!((msg__)->ReadSentinel(iter__, 4001190422)))) {
4969 0 : mozilla::ipc::SentinelReadError("Error deserializing 'filters' (nsString) member of 'FileSystemGetDirectoryListingParams'");
4970 0 : return false;
4971 : }
4972 0 : return true;
4973 : }
4974 :
4975 0 : auto PBackgroundChild::Write(
4976 : const StringInputStreamParams& v__,
4977 : Message* msg__) -> void
4978 : {
4979 0 : Write((v__).data(), msg__);
4980 : // Sentinel = 'data'
4981 0 : (msg__)->WriteSentinel(843352540);
4982 0 : }
4983 :
4984 0 : auto PBackgroundChild::Read(
4985 : StringInputStreamParams* v__,
4986 : const Message* msg__,
4987 : PickleIterator* iter__) -> bool
4988 : {
4989 0 : if ((!(Read((&((v__)->data())), msg__, iter__)))) {
4990 0 : FatalError("Error deserializing 'data' (nsCString) member of 'StringInputStreamParams'");
4991 0 : return false;
4992 : }
4993 : // Sentinel = 'data'
4994 0 : if ((!((msg__)->ReadSentinel(iter__, 843352540)))) {
4995 0 : mozilla::ipc::SentinelReadError("Error deserializing 'data' (nsCString) member of 'StringInputStreamParams'");
4996 0 : return false;
4997 : }
4998 0 : return true;
4999 : }
5000 :
5001 0 : auto PBackgroundChild::Write(
5002 : const MultiplexInputStreamParams& v__,
5003 : Message* msg__) -> void
5004 : {
5005 0 : Write((v__).streams(), msg__);
5006 : // Sentinel = 'streams'
5007 0 : (msg__)->WriteSentinel(4240383220);
5008 0 : Write((v__).currentStream(), msg__);
5009 : // Sentinel = 'currentStream'
5010 0 : (msg__)->WriteSentinel(682778074);
5011 0 : Write((v__).status(), msg__);
5012 : // Sentinel = 'status'
5013 0 : (msg__)->WriteSentinel(3714608576);
5014 0 : Write((v__).startedReadingCurrent(), msg__);
5015 : // Sentinel = 'startedReadingCurrent'
5016 0 : (msg__)->WriteSentinel(970542033);
5017 0 : }
5018 :
5019 0 : auto PBackgroundChild::Read(
5020 : MultiplexInputStreamParams* v__,
5021 : const Message* msg__,
5022 : PickleIterator* iter__) -> bool
5023 : {
5024 0 : if ((!(Read((&((v__)->streams())), msg__, iter__)))) {
5025 0 : FatalError("Error deserializing 'streams' (InputStreamParams[]) member of 'MultiplexInputStreamParams'");
5026 0 : return false;
5027 : }
5028 : // Sentinel = 'streams'
5029 0 : if ((!((msg__)->ReadSentinel(iter__, 4240383220)))) {
5030 0 : mozilla::ipc::SentinelReadError("Error deserializing 'streams' (InputStreamParams[]) member of 'MultiplexInputStreamParams'");
5031 0 : return false;
5032 : }
5033 0 : if ((!(Read((&((v__)->currentStream())), msg__, iter__)))) {
5034 0 : FatalError("Error deserializing 'currentStream' (uint32_t) member of 'MultiplexInputStreamParams'");
5035 0 : return false;
5036 : }
5037 : // Sentinel = 'currentStream'
5038 0 : if ((!((msg__)->ReadSentinel(iter__, 682778074)))) {
5039 0 : mozilla::ipc::SentinelReadError("Error deserializing 'currentStream' (uint32_t) member of 'MultiplexInputStreamParams'");
5040 0 : return false;
5041 : }
5042 0 : if ((!(Read((&((v__)->status())), msg__, iter__)))) {
5043 0 : FatalError("Error deserializing 'status' (nsresult) member of 'MultiplexInputStreamParams'");
5044 0 : return false;
5045 : }
5046 : // Sentinel = 'status'
5047 0 : if ((!((msg__)->ReadSentinel(iter__, 3714608576)))) {
5048 0 : mozilla::ipc::SentinelReadError("Error deserializing 'status' (nsresult) member of 'MultiplexInputStreamParams'");
5049 0 : return false;
5050 : }
5051 0 : if ((!(Read((&((v__)->startedReadingCurrent())), msg__, iter__)))) {
5052 0 : FatalError("Error deserializing 'startedReadingCurrent' (bool) member of 'MultiplexInputStreamParams'");
5053 0 : return false;
5054 : }
5055 : // Sentinel = 'startedReadingCurrent'
5056 0 : if ((!((msg__)->ReadSentinel(iter__, 970542033)))) {
5057 0 : mozilla::ipc::SentinelReadError("Error deserializing 'startedReadingCurrent' (bool) member of 'MultiplexInputStreamParams'");
5058 0 : return false;
5059 : }
5060 0 : return true;
5061 : }
5062 :
5063 0 : auto PBackgroundChild::Write(
5064 : const IPCBlobInputStreamParams& v__,
5065 : Message* msg__) -> void
5066 : {
5067 0 : Write((v__).id(), msg__);
5068 : // Sentinel = 'id'
5069 0 : (msg__)->WriteSentinel(2794505629);
5070 0 : }
5071 :
5072 0 : auto PBackgroundChild::Read(
5073 : IPCBlobInputStreamParams* v__,
5074 : const Message* msg__,
5075 : PickleIterator* iter__) -> bool
5076 : {
5077 0 : if ((!(Read((&((v__)->id())), msg__, iter__)))) {
5078 0 : FatalError("Error deserializing 'id' (nsID) member of 'IPCBlobInputStreamParams'");
5079 0 : return false;
5080 : }
5081 : // Sentinel = 'id'
5082 0 : if ((!((msg__)->ReadSentinel(iter__, 2794505629)))) {
5083 0 : mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsID) member of 'IPCBlobInputStreamParams'");
5084 0 : return false;
5085 : }
5086 0 : return true;
5087 : }
5088 :
5089 0 : auto PBackgroundChild::Write(
5090 : const PIPCBlobInputStreamChild* v__,
5091 : Message* msg__,
5092 : bool nullable__) -> void
5093 : {
5094 : int32_t id;
5095 0 : if ((!(v__))) {
5096 0 : if ((!(nullable__))) {
5097 0 : FatalError("NULL actor value passed to non-nullable param");
5098 : }
5099 0 : id = 0;
5100 : }
5101 : else {
5102 0 : id = (v__)->Id();
5103 0 : if ((1) == (id)) {
5104 0 : FatalError("actor has been |delete|d");
5105 : }
5106 : }
5107 :
5108 0 : Write(id, msg__);
5109 0 : }
5110 :
5111 0 : auto PBackgroundChild::Read(
5112 : PIPCBlobInputStreamChild** v__,
5113 : const Message* msg__,
5114 : PickleIterator* iter__,
5115 : bool nullable__) -> bool
5116 : {
5117 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PIPCBlobInputStream", PIPCBlobInputStreamMsgStart);
5118 0 : if ((actor).isNothing()) {
5119 0 : return false;
5120 : }
5121 :
5122 0 : (*(v__)) = static_cast<PIPCBlobInputStreamChild*>((actor).value());
5123 0 : return true;
5124 : }
5125 :
5126 0 : auto PBackgroundChild::Write(
5127 : const OptionalInputStreamParams& v__,
5128 : Message* msg__) -> void
5129 : {
5130 : typedef OptionalInputStreamParams type__;
5131 0 : Write(int((v__).type()), msg__);
5132 : // Sentinel = 'OptionalInputStreamParams'
5133 0 : (msg__)->WriteSentinel(1355174443);
5134 :
5135 0 : switch ((v__).type()) {
5136 : case type__::Tvoid_t:
5137 : {
5138 0 : Write((v__).get_void_t(), msg__);
5139 : // Sentinel = 'Tvoid_t'
5140 0 : (msg__)->WriteSentinel(3041273328);
5141 0 : return;
5142 : }
5143 : case type__::TInputStreamParams:
5144 : {
5145 0 : Write((v__).get_InputStreamParams(), msg__);
5146 : // Sentinel = 'TInputStreamParams'
5147 0 : (msg__)->WriteSentinel(55652096);
5148 0 : return;
5149 : }
5150 : default:
5151 : {
5152 0 : FatalError("unknown union type");
5153 0 : return;
5154 : }
5155 : }
5156 : }
5157 :
5158 0 : auto PBackgroundChild::Read(
5159 : OptionalInputStreamParams* v__,
5160 : const Message* msg__,
5161 : PickleIterator* iter__) -> bool
5162 : {
5163 : typedef OptionalInputStreamParams type__;
5164 : int type;
5165 0 : if ((!(Read((&(type)), msg__, iter__)))) {
5166 0 : mozilla::ipc::UnionTypeReadError("OptionalInputStreamParams");
5167 0 : return false;
5168 : }
5169 : // Sentinel = 'OptionalInputStreamParams'
5170 0 : if ((!((msg__)->ReadSentinel(iter__, 1355174443)))) {
5171 0 : mozilla::ipc::SentinelReadError("OptionalInputStreamParams");
5172 0 : return false;
5173 : }
5174 :
5175 0 : switch (type) {
5176 : case type__::Tvoid_t:
5177 : {
5178 : void_t tmp = void_t();
5179 0 : (*(v__)) = tmp;
5180 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
5181 0 : FatalError("Error deserializing Union type");
5182 0 : return false;
5183 : }
5184 : // Sentinel = 'Tvoid_t'
5185 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
5186 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5187 0 : return false;
5188 : }
5189 0 : return true;
5190 : }
5191 : case type__::TInputStreamParams:
5192 : {
5193 0 : InputStreamParams tmp = InputStreamParams();
5194 0 : (*(v__)) = tmp;
5195 0 : if ((!(Read((&((v__)->get_InputStreamParams())), msg__, iter__)))) {
5196 0 : FatalError("Error deserializing Union type");
5197 0 : return false;
5198 : }
5199 : // Sentinel = 'TInputStreamParams'
5200 0 : if ((!((msg__)->ReadSentinel(iter__, 55652096)))) {
5201 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5202 0 : return false;
5203 : }
5204 0 : return true;
5205 : }
5206 : default:
5207 : {
5208 0 : FatalError("unknown union type");
5209 0 : return false;
5210 : }
5211 : }
5212 : }
5213 :
5214 0 : auto PBackgroundChild::Write(
5215 : const PGamepadTestChannelChild* v__,
5216 : Message* msg__,
5217 : bool nullable__) -> void
5218 : {
5219 : int32_t id;
5220 0 : if ((!(v__))) {
5221 0 : if ((!(nullable__))) {
5222 0 : FatalError("NULL actor value passed to non-nullable param");
5223 : }
5224 0 : id = 0;
5225 : }
5226 : else {
5227 0 : id = (v__)->Id();
5228 0 : if ((1) == (id)) {
5229 0 : FatalError("actor has been |delete|d");
5230 : }
5231 : }
5232 :
5233 0 : Write(id, msg__);
5234 0 : }
5235 :
5236 0 : auto PBackgroundChild::Read(
5237 : PGamepadTestChannelChild** v__,
5238 : const Message* msg__,
5239 : PickleIterator* iter__,
5240 : bool nullable__) -> bool
5241 : {
5242 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PGamepadTestChannel", PGamepadTestChannelMsgStart);
5243 0 : if ((actor).isNothing()) {
5244 0 : return false;
5245 : }
5246 :
5247 0 : (*(v__)) = static_cast<PGamepadTestChannelChild*>((actor).value());
5248 0 : return true;
5249 : }
5250 :
5251 0 : auto PBackgroundChild::Write(
5252 : const OptionalFileDescriptorSet& v__,
5253 : Message* msg__) -> void
5254 : {
5255 : typedef OptionalFileDescriptorSet type__;
5256 0 : Write(int((v__).type()), msg__);
5257 : // Sentinel = 'OptionalFileDescriptorSet'
5258 0 : (msg__)->WriteSentinel(955222862);
5259 :
5260 0 : switch ((v__).type()) {
5261 : case type__::TPFileDescriptorSetParent:
5262 : {
5263 0 : FatalError("wrong side!");
5264 0 : return;
5265 : }
5266 : case type__::TPFileDescriptorSetChild:
5267 : {
5268 0 : Write((v__).get_PFileDescriptorSetChild(), msg__, false);
5269 : // Sentinel = 'TPFileDescriptorSetChild'
5270 0 : (msg__)->WriteSentinel(3477929935);
5271 0 : return;
5272 : }
5273 : case type__::TArrayOfFileDescriptor:
5274 : {
5275 0 : Write((v__).get_ArrayOfFileDescriptor(), msg__);
5276 : // Sentinel = 'TArrayOfFileDescriptor'
5277 0 : (msg__)->WriteSentinel(2366096715);
5278 0 : return;
5279 : }
5280 : case type__::Tvoid_t:
5281 : {
5282 0 : Write((v__).get_void_t(), msg__);
5283 : // Sentinel = 'Tvoid_t'
5284 0 : (msg__)->WriteSentinel(3041273328);
5285 0 : return;
5286 : }
5287 : default:
5288 : {
5289 0 : FatalError("unknown union type");
5290 0 : return;
5291 : }
5292 : }
5293 : }
5294 :
5295 0 : auto PBackgroundChild::Read(
5296 : OptionalFileDescriptorSet* v__,
5297 : const Message* msg__,
5298 : PickleIterator* iter__) -> bool
5299 : {
5300 : typedef OptionalFileDescriptorSet type__;
5301 : int type;
5302 0 : if ((!(Read((&(type)), msg__, iter__)))) {
5303 0 : mozilla::ipc::UnionTypeReadError("OptionalFileDescriptorSet");
5304 0 : return false;
5305 : }
5306 : // Sentinel = 'OptionalFileDescriptorSet'
5307 0 : if ((!((msg__)->ReadSentinel(iter__, 955222862)))) {
5308 0 : mozilla::ipc::SentinelReadError("OptionalFileDescriptorSet");
5309 0 : return false;
5310 : }
5311 :
5312 0 : switch (type) {
5313 : case type__::TPFileDescriptorSetParent:
5314 : {
5315 0 : PFileDescriptorSetChild* tmp = nullptr;
5316 0 : (*(v__)) = tmp;
5317 0 : if ((!(Read((&((v__)->get_PFileDescriptorSetChild())), msg__, iter__, false)))) {
5318 0 : FatalError("Error deserializing Union type");
5319 0 : return false;
5320 : }
5321 : // Sentinel = 'TPFileDescriptorSetParent'
5322 0 : if ((!((msg__)->ReadSentinel(iter__, 143041934)))) {
5323 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5324 0 : return false;
5325 : }
5326 0 : return true;
5327 : }
5328 : case type__::TPFileDescriptorSetChild:
5329 : {
5330 0 : return false;
5331 : }
5332 : case type__::TArrayOfFileDescriptor:
5333 : {
5334 0 : nsTArray<FileDescriptor> tmp;
5335 0 : (*(v__)) = tmp;
5336 0 : if ((!(Read((&((v__)->get_ArrayOfFileDescriptor())), msg__, iter__)))) {
5337 0 : FatalError("Error deserializing Union type");
5338 0 : return false;
5339 : }
5340 : // Sentinel = 'TArrayOfFileDescriptor'
5341 0 : if ((!((msg__)->ReadSentinel(iter__, 2366096715)))) {
5342 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5343 0 : return false;
5344 : }
5345 0 : return true;
5346 : }
5347 : case type__::Tvoid_t:
5348 : {
5349 : void_t tmp = void_t();
5350 0 : (*(v__)) = tmp;
5351 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
5352 0 : FatalError("Error deserializing Union type");
5353 0 : return false;
5354 : }
5355 : // Sentinel = 'Tvoid_t'
5356 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
5357 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5358 0 : return false;
5359 : }
5360 0 : return true;
5361 : }
5362 : default:
5363 : {
5364 0 : FatalError("unknown union type");
5365 0 : return false;
5366 : }
5367 : }
5368 : }
5369 :
5370 0 : auto PBackgroundChild::Write(
5371 : const PMessagePortChild* v__,
5372 : Message* msg__,
5373 : bool nullable__) -> void
5374 : {
5375 : int32_t id;
5376 0 : if ((!(v__))) {
5377 0 : if ((!(nullable__))) {
5378 0 : FatalError("NULL actor value passed to non-nullable param");
5379 : }
5380 0 : id = 0;
5381 : }
5382 : else {
5383 0 : id = (v__)->Id();
5384 0 : if ((1) == (id)) {
5385 0 : FatalError("actor has been |delete|d");
5386 : }
5387 : }
5388 :
5389 0 : Write(id, msg__);
5390 0 : }
5391 :
5392 0 : auto PBackgroundChild::Read(
5393 : PMessagePortChild** v__,
5394 : const Message* msg__,
5395 : PickleIterator* iter__,
5396 : bool nullable__) -> bool
5397 : {
5398 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PMessagePort", PMessagePortMsgStart);
5399 0 : if ((actor).isNothing()) {
5400 0 : return false;
5401 : }
5402 :
5403 0 : (*(v__)) = static_cast<PMessagePortChild*>((actor).value());
5404 0 : return true;
5405 : }
5406 :
5407 0 : auto PBackgroundChild::Write(
5408 : const InputStreamParams& v__,
5409 : Message* msg__) -> void
5410 : {
5411 : typedef InputStreamParams type__;
5412 0 : Write(int((v__).type()), msg__);
5413 : // Sentinel = 'InputStreamParams'
5414 0 : (msg__)->WriteSentinel(4114814015);
5415 :
5416 0 : switch ((v__).type()) {
5417 : case type__::TStringInputStreamParams:
5418 : {
5419 0 : Write((v__).get_StringInputStreamParams(), msg__);
5420 : // Sentinel = 'TStringInputStreamParams'
5421 0 : (msg__)->WriteSentinel(3395831651);
5422 0 : return;
5423 : }
5424 : case type__::TFileInputStreamParams:
5425 : {
5426 0 : Write((v__).get_FileInputStreamParams(), msg__);
5427 : // Sentinel = 'TFileInputStreamParams'
5428 0 : (msg__)->WriteSentinel(2543620282);
5429 0 : return;
5430 : }
5431 : case type__::TTemporaryFileInputStreamParams:
5432 : {
5433 0 : Write((v__).get_TemporaryFileInputStreamParams(), msg__);
5434 : // Sentinel = 'TTemporaryFileInputStreamParams'
5435 0 : (msg__)->WriteSentinel(587771548);
5436 0 : return;
5437 : }
5438 : case type__::TBufferedInputStreamParams:
5439 : {
5440 0 : Write((v__).get_BufferedInputStreamParams(), msg__);
5441 : // Sentinel = 'TBufferedInputStreamParams'
5442 0 : (msg__)->WriteSentinel(1698289307);
5443 0 : return;
5444 : }
5445 : case type__::TMIMEInputStreamParams:
5446 : {
5447 0 : Write((v__).get_MIMEInputStreamParams(), msg__);
5448 : // Sentinel = 'TMIMEInputStreamParams'
5449 0 : (msg__)->WriteSentinel(1948001964);
5450 0 : return;
5451 : }
5452 : case type__::TMultiplexInputStreamParams:
5453 : {
5454 0 : Write((v__).get_MultiplexInputStreamParams(), msg__);
5455 : // Sentinel = 'TMultiplexInputStreamParams'
5456 0 : (msg__)->WriteSentinel(3317853213);
5457 0 : return;
5458 : }
5459 : case type__::TSlicedInputStreamParams:
5460 : {
5461 0 : Write((v__).get_SlicedInputStreamParams(), msg__);
5462 : // Sentinel = 'TSlicedInputStreamParams'
5463 0 : (msg__)->WriteSentinel(445810472);
5464 0 : return;
5465 : }
5466 : case type__::TIPCBlobInputStreamParams:
5467 : {
5468 0 : Write((v__).get_IPCBlobInputStreamParams(), msg__);
5469 : // Sentinel = 'TIPCBlobInputStreamParams'
5470 0 : (msg__)->WriteSentinel(2436989998);
5471 0 : return;
5472 : }
5473 : default:
5474 : {
5475 0 : FatalError("unknown union type");
5476 0 : return;
5477 : }
5478 : }
5479 : }
5480 :
5481 0 : auto PBackgroundChild::Read(
5482 : InputStreamParams* v__,
5483 : const Message* msg__,
5484 : PickleIterator* iter__) -> bool
5485 : {
5486 : typedef InputStreamParams type__;
5487 : int type;
5488 0 : if ((!(Read((&(type)), msg__, iter__)))) {
5489 0 : mozilla::ipc::UnionTypeReadError("InputStreamParams");
5490 0 : return false;
5491 : }
5492 : // Sentinel = 'InputStreamParams'
5493 0 : if ((!((msg__)->ReadSentinel(iter__, 4114814015)))) {
5494 0 : mozilla::ipc::SentinelReadError("InputStreamParams");
5495 0 : return false;
5496 : }
5497 :
5498 0 : switch (type) {
5499 : case type__::TStringInputStreamParams:
5500 : {
5501 0 : StringInputStreamParams tmp = StringInputStreamParams();
5502 0 : (*(v__)) = tmp;
5503 0 : if ((!(Read((&((v__)->get_StringInputStreamParams())), msg__, iter__)))) {
5504 0 : FatalError("Error deserializing Union type");
5505 0 : return false;
5506 : }
5507 : // Sentinel = 'TStringInputStreamParams'
5508 0 : if ((!((msg__)->ReadSentinel(iter__, 3395831651)))) {
5509 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5510 0 : return false;
5511 : }
5512 0 : return true;
5513 : }
5514 : case type__::TFileInputStreamParams:
5515 : {
5516 0 : FileInputStreamParams tmp = FileInputStreamParams();
5517 0 : (*(v__)) = tmp;
5518 0 : if ((!(Read((&((v__)->get_FileInputStreamParams())), msg__, iter__)))) {
5519 0 : FatalError("Error deserializing Union type");
5520 0 : return false;
5521 : }
5522 : // Sentinel = 'TFileInputStreamParams'
5523 0 : if ((!((msg__)->ReadSentinel(iter__, 2543620282)))) {
5524 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5525 0 : return false;
5526 : }
5527 0 : return true;
5528 : }
5529 : case type__::TTemporaryFileInputStreamParams:
5530 : {
5531 0 : TemporaryFileInputStreamParams tmp = TemporaryFileInputStreamParams();
5532 0 : (*(v__)) = tmp;
5533 0 : if ((!(Read((&((v__)->get_TemporaryFileInputStreamParams())), msg__, iter__)))) {
5534 0 : FatalError("Error deserializing Union type");
5535 0 : return false;
5536 : }
5537 : // Sentinel = 'TTemporaryFileInputStreamParams'
5538 0 : if ((!((msg__)->ReadSentinel(iter__, 587771548)))) {
5539 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5540 0 : return false;
5541 : }
5542 0 : return true;
5543 : }
5544 : case type__::TBufferedInputStreamParams:
5545 : {
5546 0 : BufferedInputStreamParams tmp = BufferedInputStreamParams();
5547 0 : (*(v__)) = tmp;
5548 0 : if ((!(Read((&((v__)->get_BufferedInputStreamParams())), msg__, iter__)))) {
5549 0 : FatalError("Error deserializing Union type");
5550 0 : return false;
5551 : }
5552 : // Sentinel = 'TBufferedInputStreamParams'
5553 0 : if ((!((msg__)->ReadSentinel(iter__, 1698289307)))) {
5554 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5555 0 : return false;
5556 : }
5557 0 : return true;
5558 : }
5559 : case type__::TMIMEInputStreamParams:
5560 : {
5561 0 : MIMEInputStreamParams tmp = MIMEInputStreamParams();
5562 0 : (*(v__)) = tmp;
5563 0 : if ((!(Read((&((v__)->get_MIMEInputStreamParams())), msg__, iter__)))) {
5564 0 : FatalError("Error deserializing Union type");
5565 0 : return false;
5566 : }
5567 : // Sentinel = 'TMIMEInputStreamParams'
5568 0 : if ((!((msg__)->ReadSentinel(iter__, 1948001964)))) {
5569 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5570 0 : return false;
5571 : }
5572 0 : return true;
5573 : }
5574 : case type__::TMultiplexInputStreamParams:
5575 : {
5576 0 : MultiplexInputStreamParams tmp = MultiplexInputStreamParams();
5577 0 : (*(v__)) = tmp;
5578 0 : if ((!(Read((&((v__)->get_MultiplexInputStreamParams())), msg__, iter__)))) {
5579 0 : FatalError("Error deserializing Union type");
5580 0 : return false;
5581 : }
5582 : // Sentinel = 'TMultiplexInputStreamParams'
5583 0 : if ((!((msg__)->ReadSentinel(iter__, 3317853213)))) {
5584 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5585 0 : return false;
5586 : }
5587 0 : return true;
5588 : }
5589 : case type__::TSlicedInputStreamParams:
5590 : {
5591 0 : SlicedInputStreamParams tmp = SlicedInputStreamParams();
5592 0 : (*(v__)) = tmp;
5593 0 : if ((!(Read((&((v__)->get_SlicedInputStreamParams())), msg__, iter__)))) {
5594 0 : FatalError("Error deserializing Union type");
5595 0 : return false;
5596 : }
5597 : // Sentinel = 'TSlicedInputStreamParams'
5598 0 : if ((!((msg__)->ReadSentinel(iter__, 445810472)))) {
5599 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5600 0 : return false;
5601 : }
5602 0 : return true;
5603 : }
5604 : case type__::TIPCBlobInputStreamParams:
5605 : {
5606 0 : IPCBlobInputStreamParams tmp = IPCBlobInputStreamParams();
5607 0 : (*(v__)) = tmp;
5608 0 : if ((!(Read((&((v__)->get_IPCBlobInputStreamParams())), msg__, iter__)))) {
5609 0 : FatalError("Error deserializing Union type");
5610 0 : return false;
5611 : }
5612 : // Sentinel = 'TIPCBlobInputStreamParams'
5613 0 : if ((!((msg__)->ReadSentinel(iter__, 2436989998)))) {
5614 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5615 0 : return false;
5616 : }
5617 0 : return true;
5618 : }
5619 : default:
5620 : {
5621 0 : FatalError("unknown union type");
5622 0 : return false;
5623 : }
5624 : }
5625 : }
5626 :
5627 0 : auto PBackgroundChild::Write(
5628 : const BufferedInputStreamParams& v__,
5629 : Message* msg__) -> void
5630 : {
5631 0 : Write((v__).optionalStream(), msg__);
5632 : // Sentinel = 'optionalStream'
5633 0 : (msg__)->WriteSentinel(1003718562);
5634 0 : Write((v__).bufferSize(), msg__);
5635 : // Sentinel = 'bufferSize'
5636 0 : (msg__)->WriteSentinel(3444538779);
5637 0 : }
5638 :
5639 0 : auto PBackgroundChild::Read(
5640 : BufferedInputStreamParams* v__,
5641 : const Message* msg__,
5642 : PickleIterator* iter__) -> bool
5643 : {
5644 0 : if ((!(Read((&((v__)->optionalStream())), msg__, iter__)))) {
5645 0 : FatalError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'BufferedInputStreamParams'");
5646 0 : return false;
5647 : }
5648 : // Sentinel = 'optionalStream'
5649 0 : if ((!((msg__)->ReadSentinel(iter__, 1003718562)))) {
5650 0 : mozilla::ipc::SentinelReadError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'BufferedInputStreamParams'");
5651 0 : return false;
5652 : }
5653 0 : if ((!(Read((&((v__)->bufferSize())), msg__, iter__)))) {
5654 0 : FatalError("Error deserializing 'bufferSize' (uint32_t) member of 'BufferedInputStreamParams'");
5655 0 : return false;
5656 : }
5657 : // Sentinel = 'bufferSize'
5658 0 : if ((!((msg__)->ReadSentinel(iter__, 3444538779)))) {
5659 0 : mozilla::ipc::SentinelReadError("Error deserializing 'bufferSize' (uint32_t) member of 'BufferedInputStreamParams'");
5660 0 : return false;
5661 : }
5662 0 : return true;
5663 : }
5664 :
5665 0 : auto PBackgroundChild::Write(
5666 : const NullPrincipalInfo& v__,
5667 : Message* msg__) -> void
5668 : {
5669 0 : Write((v__).attrs(), msg__);
5670 : // Sentinel = 'attrs'
5671 0 : (msg__)->WriteSentinel(3014987797);
5672 0 : Write((v__).spec(), msg__);
5673 : // Sentinel = 'spec'
5674 0 : (msg__)->WriteSentinel(1630740541);
5675 0 : }
5676 :
5677 0 : auto PBackgroundChild::Read(
5678 : NullPrincipalInfo* v__,
5679 : const Message* msg__,
5680 : PickleIterator* iter__) -> bool
5681 : {
5682 0 : if ((!(Read((&((v__)->attrs())), msg__, iter__)))) {
5683 0 : FatalError("Error deserializing 'attrs' (OriginAttributes) member of 'NullPrincipalInfo'");
5684 0 : return false;
5685 : }
5686 : // Sentinel = 'attrs'
5687 0 : if ((!((msg__)->ReadSentinel(iter__, 3014987797)))) {
5688 0 : mozilla::ipc::SentinelReadError("Error deserializing 'attrs' (OriginAttributes) member of 'NullPrincipalInfo'");
5689 0 : return false;
5690 : }
5691 0 : if ((!(Read((&((v__)->spec())), msg__, iter__)))) {
5692 0 : FatalError("Error deserializing 'spec' (nsCString) member of 'NullPrincipalInfo'");
5693 0 : return false;
5694 : }
5695 : // Sentinel = 'spec'
5696 0 : if ((!((msg__)->ReadSentinel(iter__, 1630740541)))) {
5697 0 : mozilla::ipc::SentinelReadError("Error deserializing 'spec' (nsCString) member of 'NullPrincipalInfo'");
5698 0 : return false;
5699 : }
5700 0 : return true;
5701 : }
5702 :
5703 0 : auto PBackgroundChild::Write(
5704 : const PBackgroundIDBFactoryChild* v__,
5705 : Message* msg__,
5706 : bool nullable__) -> void
5707 : {
5708 : int32_t id;
5709 0 : if ((!(v__))) {
5710 0 : if ((!(nullable__))) {
5711 0 : FatalError("NULL actor value passed to non-nullable param");
5712 : }
5713 0 : id = 0;
5714 : }
5715 : else {
5716 0 : id = (v__)->Id();
5717 0 : if ((1) == (id)) {
5718 0 : FatalError("actor has been |delete|d");
5719 : }
5720 : }
5721 :
5722 0 : Write(id, msg__);
5723 0 : }
5724 :
5725 0 : auto PBackgroundChild::Read(
5726 : PBackgroundIDBFactoryChild** v__,
5727 : const Message* msg__,
5728 : PickleIterator* iter__,
5729 : bool nullable__) -> bool
5730 : {
5731 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PBackgroundIDBFactory", PBackgroundIDBFactoryMsgStart);
5732 0 : if ((actor).isNothing()) {
5733 0 : return false;
5734 : }
5735 :
5736 0 : (*(v__)) = static_cast<PBackgroundIDBFactoryChild*>((actor).value());
5737 0 : return true;
5738 : }
5739 :
5740 0 : auto PBackgroundChild::Write(
5741 : const HeaderEntry& v__,
5742 : Message* msg__) -> void
5743 : {
5744 0 : Write((v__).name(), msg__);
5745 : // Sentinel = 'name'
5746 0 : (msg__)->WriteSentinel(15034981);
5747 0 : Write((v__).value(), msg__);
5748 : // Sentinel = 'value'
5749 0 : (msg__)->WriteSentinel(3456818542);
5750 0 : }
5751 :
5752 0 : auto PBackgroundChild::Read(
5753 : HeaderEntry* v__,
5754 : const Message* msg__,
5755 : PickleIterator* iter__) -> bool
5756 : {
5757 0 : if ((!(Read((&((v__)->name())), msg__, iter__)))) {
5758 0 : FatalError("Error deserializing 'name' (nsCString) member of 'HeaderEntry'");
5759 0 : return false;
5760 : }
5761 : // Sentinel = 'name'
5762 0 : if ((!((msg__)->ReadSentinel(iter__, 15034981)))) {
5763 0 : mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsCString) member of 'HeaderEntry'");
5764 0 : return false;
5765 : }
5766 0 : if ((!(Read((&((v__)->value())), msg__, iter__)))) {
5767 0 : FatalError("Error deserializing 'value' (nsCString) member of 'HeaderEntry'");
5768 0 : return false;
5769 : }
5770 : // Sentinel = 'value'
5771 0 : if ((!((msg__)->ReadSentinel(iter__, 3456818542)))) {
5772 0 : mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsCString) member of 'HeaderEntry'");
5773 0 : return false;
5774 : }
5775 0 : return true;
5776 : }
5777 :
5778 0 : auto PBackgroundChild::Write(
5779 : const PChildToParentStreamChild* v__,
5780 : Message* msg__,
5781 : bool nullable__) -> void
5782 : {
5783 : int32_t id;
5784 0 : if ((!(v__))) {
5785 0 : if ((!(nullable__))) {
5786 0 : FatalError("NULL actor value passed to non-nullable param");
5787 : }
5788 0 : id = 0;
5789 : }
5790 : else {
5791 0 : id = (v__)->Id();
5792 0 : if ((1) == (id)) {
5793 0 : FatalError("actor has been |delete|d");
5794 : }
5795 : }
5796 :
5797 0 : Write(id, msg__);
5798 0 : }
5799 :
5800 0 : auto PBackgroundChild::Read(
5801 : PChildToParentStreamChild** v__,
5802 : const Message* msg__,
5803 : PickleIterator* iter__,
5804 : bool nullable__) -> bool
5805 : {
5806 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PChildToParentStream", PChildToParentStreamMsgStart);
5807 0 : if ((actor).isNothing()) {
5808 0 : return false;
5809 : }
5810 :
5811 0 : (*(v__)) = static_cast<PChildToParentStreamChild*>((actor).value());
5812 0 : return true;
5813 : }
5814 :
5815 0 : auto PBackgroundChild::Write(
5816 : const IPCRemoteStreamType& v__,
5817 : Message* msg__) -> void
5818 : {
5819 : typedef IPCRemoteStreamType type__;
5820 0 : Write(int((v__).type()), msg__);
5821 : // Sentinel = 'IPCRemoteStreamType'
5822 0 : (msg__)->WriteSentinel(391674895);
5823 :
5824 0 : switch ((v__).type()) {
5825 : case type__::TPChildToParentStreamParent:
5826 : {
5827 0 : FatalError("wrong side!");
5828 0 : return;
5829 : }
5830 : case type__::TPChildToParentStreamChild:
5831 : {
5832 0 : Write((v__).get_PChildToParentStreamChild(), msg__, false);
5833 : // Sentinel = 'TPChildToParentStreamChild'
5834 0 : (msg__)->WriteSentinel(1882094295);
5835 0 : return;
5836 : }
5837 : case type__::TPParentToChildStreamParent:
5838 : {
5839 0 : FatalError("wrong side!");
5840 0 : return;
5841 : }
5842 : case type__::TPParentToChildStreamChild:
5843 : {
5844 0 : Write((v__).get_PParentToChildStreamChild(), msg__, false);
5845 : // Sentinel = 'TPParentToChildStreamChild'
5846 0 : (msg__)->WriteSentinel(190098493);
5847 0 : return;
5848 : }
5849 : default:
5850 : {
5851 0 : FatalError("unknown union type");
5852 0 : return;
5853 : }
5854 : }
5855 : }
5856 :
5857 0 : auto PBackgroundChild::Read(
5858 : IPCRemoteStreamType* v__,
5859 : const Message* msg__,
5860 : PickleIterator* iter__) -> bool
5861 : {
5862 : typedef IPCRemoteStreamType type__;
5863 : int type;
5864 0 : if ((!(Read((&(type)), msg__, iter__)))) {
5865 0 : mozilla::ipc::UnionTypeReadError("IPCRemoteStreamType");
5866 0 : return false;
5867 : }
5868 : // Sentinel = 'IPCRemoteStreamType'
5869 0 : if ((!((msg__)->ReadSentinel(iter__, 391674895)))) {
5870 0 : mozilla::ipc::SentinelReadError("IPCRemoteStreamType");
5871 0 : return false;
5872 : }
5873 :
5874 0 : switch (type) {
5875 : case type__::TPChildToParentStreamParent:
5876 : {
5877 0 : PChildToParentStreamChild* tmp = nullptr;
5878 0 : (*(v__)) = tmp;
5879 0 : if ((!(Read((&((v__)->get_PChildToParentStreamChild())), msg__, iter__, false)))) {
5880 0 : FatalError("Error deserializing Union type");
5881 0 : return false;
5882 : }
5883 : // Sentinel = 'TPChildToParentStreamParent'
5884 0 : if ((!((msg__)->ReadSentinel(iter__, 2724777622)))) {
5885 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5886 0 : return false;
5887 : }
5888 0 : return true;
5889 : }
5890 : case type__::TPChildToParentStreamChild:
5891 : {
5892 0 : return false;
5893 : }
5894 : case type__::TPParentToChildStreamParent:
5895 : {
5896 0 : PParentToChildStreamChild* tmp = nullptr;
5897 0 : (*(v__)) = tmp;
5898 0 : if ((!(Read((&((v__)->get_PParentToChildStreamChild())), msg__, iter__, false)))) {
5899 0 : FatalError("Error deserializing Union type");
5900 0 : return false;
5901 : }
5902 : // Sentinel = 'TPParentToChildStreamParent'
5903 0 : if ((!((msg__)->ReadSentinel(iter__, 3335986876)))) {
5904 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5905 0 : return false;
5906 : }
5907 0 : return true;
5908 : }
5909 : case type__::TPParentToChildStreamChild:
5910 : {
5911 0 : return false;
5912 : }
5913 : default:
5914 : {
5915 0 : FatalError("unknown union type");
5916 0 : return false;
5917 : }
5918 : }
5919 : }
5920 :
5921 0 : auto PBackgroundChild::Write(
5922 : const PCacheStreamControlChild* v__,
5923 : Message* msg__,
5924 : bool nullable__) -> void
5925 : {
5926 : int32_t id;
5927 0 : if ((!(v__))) {
5928 0 : if ((!(nullable__))) {
5929 0 : FatalError("NULL actor value passed to non-nullable param");
5930 : }
5931 0 : id = 0;
5932 : }
5933 : else {
5934 0 : id = (v__)->Id();
5935 0 : if ((1) == (id)) {
5936 0 : FatalError("actor has been |delete|d");
5937 : }
5938 : }
5939 :
5940 0 : Write(id, msg__);
5941 0 : }
5942 :
5943 0 : auto PBackgroundChild::Read(
5944 : PCacheStreamControlChild** v__,
5945 : const Message* msg__,
5946 : PickleIterator* iter__,
5947 : bool nullable__) -> bool
5948 : {
5949 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PCacheStreamControl", PCacheStreamControlMsgStart);
5950 0 : if ((actor).isNothing()) {
5951 0 : return false;
5952 : }
5953 :
5954 0 : (*(v__)) = static_cast<PCacheStreamControlChild*>((actor).value());
5955 0 : return true;
5956 : }
5957 :
5958 :
5959 :
5960 : } // namespace ipc
5961 : } // namespace mozilla
|
