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