Line data Source code
1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 :
7 : #include "mozilla/net/PNeckoChild.h"
8 : #include "SerializedLoadContext.h"
9 : #include "mozilla/dom/PermissionMessageUtils.h"
10 :
11 : #include "mozilla/dom/PContentChild.h"
12 : #include "mozilla/net/PHttpChannelChild.h"
13 : #include "mozilla/net/PCookieServiceChild.h"
14 : #include "mozilla/dom/PBrowserChild.h"
15 : #include "mozilla/net/PWyciwygChannelChild.h"
16 : #include "mozilla/net/PFTPChannelChild.h"
17 : #include "mozilla/net/PWebSocketChild.h"
18 : #include "mozilla/net/PWebSocketEventListenerChild.h"
19 : #include "mozilla/net/PTCPSocketChild.h"
20 : #include "mozilla/net/PTCPServerSocketChild.h"
21 : #include "mozilla/net/PUDPSocketChild.h"
22 : #include "mozilla/net/PDNSRequestChild.h"
23 : #include "mozilla/net/PChannelDiverterChild.h"
24 : #include "mozilla/ipc/PFileDescriptorSetChild.h"
25 : #include "mozilla/net/PDataChannelChild.h"
26 : #include "mozilla/net/PTransportProviderChild.h"
27 : #include "mozilla/ipc/PChildToParentStreamChild.h"
28 : #include "mozilla/ipc/PParentToChildStreamChild.h"
29 : #include "mozilla/net/PStunAddrsRequestChild.h"
30 : #include "mozilla/net/PFileChannelChild.h"
31 : #include "mozilla/net/PRtspControllerChild.h"
32 : #include "mozilla/net/PRtspChannelChild.h"
33 : #include "mozilla/net/PAltDataOutputStreamChild.h"
34 :
35 : #include "nsIFile.h"
36 : #include "GeckoProfiler.h"
37 :
38 : namespace mozilla {
39 : namespace net {
40 :
41 :
42 0 : auto PNeckoChild::RecvPTransportProviderConstructor(PTransportProviderChild* actor) -> mozilla::ipc::IPCResult
43 : {
44 0 : return IPC_OK();
45 : }
46 :
47 0 : auto PNeckoChild::RecvPTCPSocketConstructor(
48 : PTCPSocketChild* actor,
49 : const nsString& host,
50 : const uint16_t& port) -> mozilla::ipc::IPCResult
51 : {
52 0 : return IPC_OK();
53 : }
54 :
55 0 : auto PNeckoChild::ActorDestroy(ActorDestroyReason aWhy) -> void
56 : {
57 0 : }
58 :
59 2 : MOZ_IMPLICIT PNeckoChild::PNeckoChild() :
60 : mozilla::ipc::IProtocol(mozilla::ipc::ChildSide),
61 2 : mState(PNecko::__Dead)
62 : {
63 2 : MOZ_COUNT_CTOR(PNeckoChild);
64 2 : }
65 :
66 0 : PNeckoChild::~PNeckoChild()
67 : {
68 0 : MOZ_COUNT_DTOR(PNeckoChild);
69 0 : }
70 :
71 3 : auto PNeckoChild::Manager() const -> PContentChild*
72 : {
73 3 : return static_cast<PContentChild*>(IProtocol::Manager());
74 : }
75 :
76 0 : auto PNeckoChild::ManagedPHttpChannelChild(nsTArray<PHttpChannelChild*>& aArr) const -> void
77 : {
78 0 : (mManagedPHttpChannelChild).ToArray(aArr);
79 0 : }
80 :
81 0 : auto PNeckoChild::ManagedPHttpChannelChild() const -> const ManagedContainer<PHttpChannelChild>&
82 : {
83 0 : return mManagedPHttpChannelChild;
84 : }
85 :
86 0 : auto PNeckoChild::ManagedPCookieServiceChild(nsTArray<PCookieServiceChild*>& aArr) const -> void
87 : {
88 0 : (mManagedPCookieServiceChild).ToArray(aArr);
89 0 : }
90 :
91 0 : auto PNeckoChild::ManagedPCookieServiceChild() const -> const ManagedContainer<PCookieServiceChild>&
92 : {
93 0 : return mManagedPCookieServiceChild;
94 : }
95 :
96 0 : auto PNeckoChild::ManagedPWyciwygChannelChild(nsTArray<PWyciwygChannelChild*>& aArr) const -> void
97 : {
98 0 : (mManagedPWyciwygChannelChild).ToArray(aArr);
99 0 : }
100 :
101 0 : auto PNeckoChild::ManagedPWyciwygChannelChild() const -> const ManagedContainer<PWyciwygChannelChild>&
102 : {
103 0 : return mManagedPWyciwygChannelChild;
104 : }
105 :
106 0 : auto PNeckoChild::ManagedPFTPChannelChild(nsTArray<PFTPChannelChild*>& aArr) const -> void
107 : {
108 0 : (mManagedPFTPChannelChild).ToArray(aArr);
109 0 : }
110 :
111 0 : auto PNeckoChild::ManagedPFTPChannelChild() const -> const ManagedContainer<PFTPChannelChild>&
112 : {
113 0 : return mManagedPFTPChannelChild;
114 : }
115 :
116 0 : auto PNeckoChild::ManagedPWebSocketChild(nsTArray<PWebSocketChild*>& aArr) const -> void
117 : {
118 0 : (mManagedPWebSocketChild).ToArray(aArr);
119 0 : }
120 :
121 0 : auto PNeckoChild::ManagedPWebSocketChild() const -> const ManagedContainer<PWebSocketChild>&
122 : {
123 0 : return mManagedPWebSocketChild;
124 : }
125 :
126 0 : auto PNeckoChild::ManagedPWebSocketEventListenerChild(nsTArray<PWebSocketEventListenerChild*>& aArr) const -> void
127 : {
128 0 : (mManagedPWebSocketEventListenerChild).ToArray(aArr);
129 0 : }
130 :
131 0 : auto PNeckoChild::ManagedPWebSocketEventListenerChild() const -> const ManagedContainer<PWebSocketEventListenerChild>&
132 : {
133 0 : return mManagedPWebSocketEventListenerChild;
134 : }
135 :
136 0 : auto PNeckoChild::ManagedPTCPSocketChild(nsTArray<PTCPSocketChild*>& aArr) const -> void
137 : {
138 0 : (mManagedPTCPSocketChild).ToArray(aArr);
139 0 : }
140 :
141 0 : auto PNeckoChild::ManagedPTCPSocketChild() const -> const ManagedContainer<PTCPSocketChild>&
142 : {
143 0 : return mManagedPTCPSocketChild;
144 : }
145 :
146 0 : auto PNeckoChild::ManagedPTCPServerSocketChild(nsTArray<PTCPServerSocketChild*>& aArr) const -> void
147 : {
148 0 : (mManagedPTCPServerSocketChild).ToArray(aArr);
149 0 : }
150 :
151 0 : auto PNeckoChild::ManagedPTCPServerSocketChild() const -> const ManagedContainer<PTCPServerSocketChild>&
152 : {
153 0 : return mManagedPTCPServerSocketChild;
154 : }
155 :
156 0 : auto PNeckoChild::ManagedPUDPSocketChild(nsTArray<PUDPSocketChild*>& aArr) const -> void
157 : {
158 0 : (mManagedPUDPSocketChild).ToArray(aArr);
159 0 : }
160 :
161 0 : auto PNeckoChild::ManagedPUDPSocketChild() const -> const ManagedContainer<PUDPSocketChild>&
162 : {
163 0 : return mManagedPUDPSocketChild;
164 : }
165 :
166 0 : auto PNeckoChild::ManagedPDNSRequestChild(nsTArray<PDNSRequestChild*>& aArr) const -> void
167 : {
168 0 : (mManagedPDNSRequestChild).ToArray(aArr);
169 0 : }
170 :
171 0 : auto PNeckoChild::ManagedPDNSRequestChild() const -> const ManagedContainer<PDNSRequestChild>&
172 : {
173 0 : return mManagedPDNSRequestChild;
174 : }
175 :
176 0 : auto PNeckoChild::ManagedPDataChannelChild(nsTArray<PDataChannelChild*>& aArr) const -> void
177 : {
178 0 : (mManagedPDataChannelChild).ToArray(aArr);
179 0 : }
180 :
181 0 : auto PNeckoChild::ManagedPDataChannelChild() const -> const ManagedContainer<PDataChannelChild>&
182 : {
183 0 : return mManagedPDataChannelChild;
184 : }
185 :
186 0 : auto PNeckoChild::ManagedPFileChannelChild(nsTArray<PFileChannelChild*>& aArr) const -> void
187 : {
188 0 : (mManagedPFileChannelChild).ToArray(aArr);
189 0 : }
190 :
191 0 : auto PNeckoChild::ManagedPFileChannelChild() const -> const ManagedContainer<PFileChannelChild>&
192 : {
193 0 : return mManagedPFileChannelChild;
194 : }
195 :
196 0 : auto PNeckoChild::ManagedPRtspControllerChild(nsTArray<PRtspControllerChild*>& aArr) const -> void
197 : {
198 0 : (mManagedPRtspControllerChild).ToArray(aArr);
199 0 : }
200 :
201 0 : auto PNeckoChild::ManagedPRtspControllerChild() const -> const ManagedContainer<PRtspControllerChild>&
202 : {
203 0 : return mManagedPRtspControllerChild;
204 : }
205 :
206 0 : auto PNeckoChild::ManagedPRtspChannelChild(nsTArray<PRtspChannelChild*>& aArr) const -> void
207 : {
208 0 : (mManagedPRtspChannelChild).ToArray(aArr);
209 0 : }
210 :
211 0 : auto PNeckoChild::ManagedPRtspChannelChild() const -> const ManagedContainer<PRtspChannelChild>&
212 : {
213 0 : return mManagedPRtspChannelChild;
214 : }
215 :
216 0 : auto PNeckoChild::ManagedPChannelDiverterChild(nsTArray<PChannelDiverterChild*>& aArr) const -> void
217 : {
218 0 : (mManagedPChannelDiverterChild).ToArray(aArr);
219 0 : }
220 :
221 0 : auto PNeckoChild::ManagedPChannelDiverterChild() const -> const ManagedContainer<PChannelDiverterChild>&
222 : {
223 0 : return mManagedPChannelDiverterChild;
224 : }
225 :
226 0 : auto PNeckoChild::ManagedPTransportProviderChild(nsTArray<PTransportProviderChild*>& aArr) const -> void
227 : {
228 0 : (mManagedPTransportProviderChild).ToArray(aArr);
229 0 : }
230 :
231 0 : auto PNeckoChild::ManagedPTransportProviderChild() const -> const ManagedContainer<PTransportProviderChild>&
232 : {
233 0 : return mManagedPTransportProviderChild;
234 : }
235 :
236 0 : auto PNeckoChild::ManagedPAltDataOutputStreamChild(nsTArray<PAltDataOutputStreamChild*>& aArr) const -> void
237 : {
238 0 : (mManagedPAltDataOutputStreamChild).ToArray(aArr);
239 0 : }
240 :
241 0 : auto PNeckoChild::ManagedPAltDataOutputStreamChild() const -> const ManagedContainer<PAltDataOutputStreamChild>&
242 : {
243 0 : return mManagedPAltDataOutputStreamChild;
244 : }
245 :
246 0 : auto PNeckoChild::ManagedPStunAddrsRequestChild(nsTArray<PStunAddrsRequestChild*>& aArr) const -> void
247 : {
248 0 : (mManagedPStunAddrsRequestChild).ToArray(aArr);
249 0 : }
250 :
251 0 : auto PNeckoChild::ManagedPStunAddrsRequestChild() const -> const ManagedContainer<PStunAddrsRequestChild>&
252 : {
253 0 : return mManagedPStunAddrsRequestChild;
254 : }
255 :
256 0 : auto PNeckoChild::Send__delete__(PNeckoChild* actor) -> bool
257 : {
258 0 : if ((!(actor))) {
259 0 : return false;
260 : }
261 :
262 0 : IPC::Message* msg__ = PNecko::Msg___delete__((actor)->Id());
263 :
264 0 : (actor)->Write(actor, msg__, false);
265 : // Sentinel = 'actor'
266 0 : (msg__)->WriteSentinel(875202478);
267 :
268 :
269 :
270 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
271 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", (actor)->OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
272 : }
273 0 : AUTO_PROFILER_LABEL("PNecko::Msg___delete__", OTHER);
274 0 : PNecko::Transition(PNecko::Msg___delete____ID, (&((actor)->mState)));
275 :
276 0 : bool sendok__ = ((actor)->GetIPCChannel())->Send(msg__);
277 :
278 0 : IProtocol* mgr = (actor)->Manager();
279 0 : (actor)->DestroySubtree(Deletion);
280 0 : (actor)->DeallocSubtree();
281 0 : (mgr)->RemoveManagee(PNeckoMsgStart, actor);
282 0 : return sendok__;
283 : }
284 :
285 0 : auto PNeckoChild::SendPCookieServiceConstructor() -> PCookieServiceChild*
286 : {
287 0 : return SendPCookieServiceConstructor(AllocPCookieServiceChild());
288 : }
289 :
290 0 : auto PNeckoChild::SendPCookieServiceConstructor(PCookieServiceChild* actor) -> PCookieServiceChild*
291 : {
292 0 : if ((!(actor))) {
293 0 : NS_WARNING("Error constructing actor PCookieServiceChild");
294 0 : return nullptr;
295 : }
296 0 : (actor)->SetManager(this);
297 0 : Register(actor);
298 0 : (actor)->SetIPCChannel(GetIPCChannel());
299 0 : (mManagedPCookieServiceChild).PutEntry(actor);
300 0 : (actor)->mState = mozilla::net::PCookieService::__Start;
301 :
302 0 : IPC::Message* msg__ = PNecko::Msg_PCookieServiceConstructor(Id());
303 :
304 0 : Write(actor, msg__, false);
305 : // Sentinel = 'actor'
306 0 : (msg__)->WriteSentinel(875202478);
307 :
308 0 : (msg__)->set_constructor();
309 :
310 :
311 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
312 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
313 : }
314 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PCookieServiceConstructor", OTHER);
315 0 : PNecko::Transition(PNecko::Msg_PCookieServiceConstructor__ID, (&(mState)));
316 :
317 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
318 0 : if ((!(sendok__))) {
319 0 : FatalError("constructor for actor failed");
320 0 : return nullptr;
321 : }
322 0 : return actor;
323 : }
324 :
325 0 : auto PNeckoChild::SendPHttpChannelConstructor(
326 : const PBrowserOrId& browser,
327 : const SerializedLoadContext& loadContext,
328 : const HttpChannelCreationArgs& args) -> PHttpChannelChild*
329 : {
330 0 : return SendPHttpChannelConstructor(AllocPHttpChannelChild(browser, loadContext, args), browser, loadContext, args);
331 : }
332 :
333 3 : auto PNeckoChild::SendPHttpChannelConstructor(
334 : PHttpChannelChild* actor,
335 : const PBrowserOrId& browser,
336 : const SerializedLoadContext& loadContext,
337 : const HttpChannelCreationArgs& args) -> PHttpChannelChild*
338 : {
339 3 : if ((!(actor))) {
340 0 : NS_WARNING("Error constructing actor PHttpChannelChild");
341 0 : return nullptr;
342 : }
343 3 : (actor)->SetManager(this);
344 3 : Register(actor);
345 3 : (actor)->SetIPCChannel(GetIPCChannel());
346 3 : (mManagedPHttpChannelChild).PutEntry(actor);
347 3 : (actor)->mState = mozilla::net::PHttpChannel::__Start;
348 :
349 3 : IPC::Message* msg__ = PNecko::Msg_PHttpChannelConstructor(Id());
350 :
351 3 : Write(actor, msg__, false);
352 : // Sentinel = 'actor'
353 3 : (msg__)->WriteSentinel(875202478);
354 3 : Write(browser, msg__);
355 : // Sentinel = 'browser'
356 3 : (msg__)->WriteSentinel(2836343679);
357 3 : Write(loadContext, msg__);
358 : // Sentinel = 'loadContext'
359 3 : (msg__)->WriteSentinel(2917317838);
360 3 : Write(args, msg__);
361 : // Sentinel = 'args'
362 3 : (msg__)->WriteSentinel(2823760587);
363 :
364 3 : (msg__)->set_constructor();
365 :
366 :
367 3 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
368 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
369 : }
370 6 : AUTO_PROFILER_LABEL("PNecko::Msg_PHttpChannelConstructor", OTHER);
371 3 : PNecko::Transition(PNecko::Msg_PHttpChannelConstructor__ID, (&(mState)));
372 :
373 3 : bool sendok__ = (GetIPCChannel())->Send(msg__);
374 3 : if ((!(sendok__))) {
375 0 : FatalError("constructor for actor failed");
376 0 : return nullptr;
377 : }
378 3 : return actor;
379 : }
380 :
381 0 : auto PNeckoChild::SendPWyciwygChannelConstructor() -> PWyciwygChannelChild*
382 : {
383 0 : return SendPWyciwygChannelConstructor(AllocPWyciwygChannelChild());
384 : }
385 :
386 0 : auto PNeckoChild::SendPWyciwygChannelConstructor(PWyciwygChannelChild* actor) -> PWyciwygChannelChild*
387 : {
388 0 : if ((!(actor))) {
389 0 : NS_WARNING("Error constructing actor PWyciwygChannelChild");
390 0 : return nullptr;
391 : }
392 0 : (actor)->SetManager(this);
393 0 : Register(actor);
394 0 : (actor)->SetIPCChannel(GetIPCChannel());
395 0 : (mManagedPWyciwygChannelChild).PutEntry(actor);
396 0 : (actor)->mState = mozilla::net::PWyciwygChannel::__Start;
397 :
398 0 : IPC::Message* msg__ = PNecko::Msg_PWyciwygChannelConstructor(Id());
399 :
400 0 : Write(actor, msg__, false);
401 : // Sentinel = 'actor'
402 0 : (msg__)->WriteSentinel(875202478);
403 :
404 0 : (msg__)->set_constructor();
405 :
406 :
407 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
408 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
409 : }
410 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PWyciwygChannelConstructor", OTHER);
411 0 : PNecko::Transition(PNecko::Msg_PWyciwygChannelConstructor__ID, (&(mState)));
412 :
413 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
414 0 : if ((!(sendok__))) {
415 0 : FatalError("constructor for actor failed");
416 0 : return nullptr;
417 : }
418 0 : return actor;
419 : }
420 :
421 0 : auto PNeckoChild::SendPFTPChannelConstructor(
422 : const PBrowserOrId& browser,
423 : const SerializedLoadContext& loadContext,
424 : const FTPChannelCreationArgs& args) -> PFTPChannelChild*
425 : {
426 0 : return SendPFTPChannelConstructor(AllocPFTPChannelChild(browser, loadContext, args), browser, loadContext, args);
427 : }
428 :
429 0 : auto PNeckoChild::SendPFTPChannelConstructor(
430 : PFTPChannelChild* actor,
431 : const PBrowserOrId& browser,
432 : const SerializedLoadContext& loadContext,
433 : const FTPChannelCreationArgs& args) -> PFTPChannelChild*
434 : {
435 0 : if ((!(actor))) {
436 0 : NS_WARNING("Error constructing actor PFTPChannelChild");
437 0 : return nullptr;
438 : }
439 0 : (actor)->SetManager(this);
440 0 : Register(actor);
441 0 : (actor)->SetIPCChannel(GetIPCChannel());
442 0 : (mManagedPFTPChannelChild).PutEntry(actor);
443 0 : (actor)->mState = mozilla::net::PFTPChannel::__Start;
444 :
445 0 : IPC::Message* msg__ = PNecko::Msg_PFTPChannelConstructor(Id());
446 :
447 0 : Write(actor, msg__, false);
448 : // Sentinel = 'actor'
449 0 : (msg__)->WriteSentinel(875202478);
450 0 : Write(browser, msg__);
451 : // Sentinel = 'browser'
452 0 : (msg__)->WriteSentinel(2836343679);
453 0 : Write(loadContext, msg__);
454 : // Sentinel = 'loadContext'
455 0 : (msg__)->WriteSentinel(2917317838);
456 0 : Write(args, msg__);
457 : // Sentinel = 'args'
458 0 : (msg__)->WriteSentinel(2823760587);
459 :
460 0 : (msg__)->set_constructor();
461 :
462 :
463 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
464 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
465 : }
466 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PFTPChannelConstructor", OTHER);
467 0 : PNecko::Transition(PNecko::Msg_PFTPChannelConstructor__ID, (&(mState)));
468 :
469 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
470 0 : if ((!(sendok__))) {
471 0 : FatalError("constructor for actor failed");
472 0 : return nullptr;
473 : }
474 0 : return actor;
475 : }
476 :
477 0 : auto PNeckoChild::SendPWebSocketConstructor(
478 : const PBrowserOrId& browser,
479 : const SerializedLoadContext& loadContext,
480 : const uint32_t& aSerialID) -> PWebSocketChild*
481 : {
482 0 : return SendPWebSocketConstructor(AllocPWebSocketChild(browser, loadContext, aSerialID), browser, loadContext, aSerialID);
483 : }
484 :
485 0 : auto PNeckoChild::SendPWebSocketConstructor(
486 : PWebSocketChild* actor,
487 : const PBrowserOrId& browser,
488 : const SerializedLoadContext& loadContext,
489 : const uint32_t& aSerialID) -> PWebSocketChild*
490 : {
491 0 : if ((!(actor))) {
492 0 : NS_WARNING("Error constructing actor PWebSocketChild");
493 0 : return nullptr;
494 : }
495 0 : (actor)->SetManager(this);
496 0 : Register(actor);
497 0 : (actor)->SetIPCChannel(GetIPCChannel());
498 0 : (mManagedPWebSocketChild).PutEntry(actor);
499 0 : (actor)->mState = mozilla::net::PWebSocket::__Start;
500 :
501 0 : IPC::Message* msg__ = PNecko::Msg_PWebSocketConstructor(Id());
502 :
503 0 : Write(actor, msg__, false);
504 : // Sentinel = 'actor'
505 0 : (msg__)->WriteSentinel(875202478);
506 0 : Write(browser, msg__);
507 : // Sentinel = 'browser'
508 0 : (msg__)->WriteSentinel(2836343679);
509 0 : Write(loadContext, msg__);
510 : // Sentinel = 'loadContext'
511 0 : (msg__)->WriteSentinel(2917317838);
512 0 : Write(aSerialID, msg__);
513 : // Sentinel = 'aSerialID'
514 0 : (msg__)->WriteSentinel(1337008615);
515 :
516 0 : (msg__)->set_constructor();
517 :
518 :
519 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
520 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
521 : }
522 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PWebSocketConstructor", OTHER);
523 0 : PNecko::Transition(PNecko::Msg_PWebSocketConstructor__ID, (&(mState)));
524 :
525 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
526 0 : if ((!(sendok__))) {
527 0 : FatalError("constructor for actor failed");
528 0 : return nullptr;
529 : }
530 0 : return actor;
531 : }
532 :
533 0 : auto PNeckoChild::SendPTCPServerSocketConstructor(
534 : const uint16_t& localPort,
535 : const uint16_t& backlog,
536 : const bool& useArrayBuffers) -> PTCPServerSocketChild*
537 : {
538 0 : return SendPTCPServerSocketConstructor(AllocPTCPServerSocketChild(localPort, backlog, useArrayBuffers), localPort, backlog, useArrayBuffers);
539 : }
540 :
541 0 : auto PNeckoChild::SendPTCPServerSocketConstructor(
542 : PTCPServerSocketChild* actor,
543 : const uint16_t& localPort,
544 : const uint16_t& backlog,
545 : const bool& useArrayBuffers) -> PTCPServerSocketChild*
546 : {
547 0 : if ((!(actor))) {
548 0 : NS_WARNING("Error constructing actor PTCPServerSocketChild");
549 0 : return nullptr;
550 : }
551 0 : (actor)->SetManager(this);
552 0 : Register(actor);
553 0 : (actor)->SetIPCChannel(GetIPCChannel());
554 0 : (mManagedPTCPServerSocketChild).PutEntry(actor);
555 0 : (actor)->mState = mozilla::net::PTCPServerSocket::__Start;
556 :
557 0 : IPC::Message* msg__ = PNecko::Msg_PTCPServerSocketConstructor(Id());
558 :
559 0 : Write(actor, msg__, false);
560 : // Sentinel = 'actor'
561 0 : (msg__)->WriteSentinel(875202478);
562 0 : Write(localPort, msg__);
563 : // Sentinel = 'localPort'
564 0 : (msg__)->WriteSentinel(2930268933);
565 0 : Write(backlog, msg__);
566 : // Sentinel = 'backlog'
567 0 : (msg__)->WriteSentinel(403095166);
568 0 : Write(useArrayBuffers, msg__);
569 : // Sentinel = 'useArrayBuffers'
570 0 : (msg__)->WriteSentinel(1444022734);
571 :
572 0 : (msg__)->set_constructor();
573 :
574 :
575 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
576 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
577 : }
578 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PTCPServerSocketConstructor", OTHER);
579 0 : PNecko::Transition(PNecko::Msg_PTCPServerSocketConstructor__ID, (&(mState)));
580 :
581 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
582 0 : if ((!(sendok__))) {
583 0 : FatalError("constructor for actor failed");
584 0 : return nullptr;
585 : }
586 0 : return actor;
587 : }
588 :
589 0 : auto PNeckoChild::SendPUDPSocketConstructor(
590 : const Principal& principal,
591 : const nsCString& filter) -> PUDPSocketChild*
592 : {
593 0 : return SendPUDPSocketConstructor(AllocPUDPSocketChild(principal, filter), principal, filter);
594 : }
595 :
596 0 : auto PNeckoChild::SendPUDPSocketConstructor(
597 : PUDPSocketChild* actor,
598 : const Principal& principal,
599 : const nsCString& filter) -> PUDPSocketChild*
600 : {
601 0 : if ((!(actor))) {
602 0 : NS_WARNING("Error constructing actor PUDPSocketChild");
603 0 : return nullptr;
604 : }
605 0 : (actor)->SetManager(this);
606 0 : Register(actor);
607 0 : (actor)->SetIPCChannel(GetIPCChannel());
608 0 : (mManagedPUDPSocketChild).PutEntry(actor);
609 0 : (actor)->mState = mozilla::net::PUDPSocket::__Start;
610 :
611 0 : IPC::Message* msg__ = PNecko::Msg_PUDPSocketConstructor(Id());
612 :
613 0 : Write(actor, msg__, false);
614 : // Sentinel = 'actor'
615 0 : (msg__)->WriteSentinel(875202478);
616 0 : Write(principal, msg__);
617 : // Sentinel = 'principal'
618 0 : (msg__)->WriteSentinel(732240927);
619 0 : Write(filter, msg__);
620 : // Sentinel = 'filter'
621 0 : (msg__)->WriteSentinel(2236769008);
622 :
623 0 : (msg__)->set_constructor();
624 :
625 :
626 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
627 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
628 : }
629 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PUDPSocketConstructor", OTHER);
630 0 : PNecko::Transition(PNecko::Msg_PUDPSocketConstructor__ID, (&(mState)));
631 :
632 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
633 0 : if ((!(sendok__))) {
634 0 : FatalError("constructor for actor failed");
635 0 : return nullptr;
636 : }
637 0 : return actor;
638 : }
639 :
640 0 : auto PNeckoChild::SendPDNSRequestConstructor(
641 : const nsCString& hostName,
642 : const OriginAttributes& originAttributes,
643 : const uint32_t& flags,
644 : const nsCString& networkInterface) -> PDNSRequestChild*
645 : {
646 0 : return SendPDNSRequestConstructor(AllocPDNSRequestChild(hostName, originAttributes, flags, networkInterface), hostName, originAttributes, flags, networkInterface);
647 : }
648 :
649 0 : auto PNeckoChild::SendPDNSRequestConstructor(
650 : PDNSRequestChild* actor,
651 : const nsCString& hostName,
652 : const OriginAttributes& originAttributes,
653 : const uint32_t& flags,
654 : const nsCString& networkInterface) -> PDNSRequestChild*
655 : {
656 0 : if ((!(actor))) {
657 0 : NS_WARNING("Error constructing actor PDNSRequestChild");
658 0 : return nullptr;
659 : }
660 0 : (actor)->SetManager(this);
661 0 : Register(actor);
662 0 : (actor)->SetIPCChannel(GetIPCChannel());
663 0 : (mManagedPDNSRequestChild).PutEntry(actor);
664 0 : (actor)->mState = mozilla::net::PDNSRequest::__Start;
665 :
666 0 : IPC::Message* msg__ = PNecko::Msg_PDNSRequestConstructor(Id());
667 :
668 0 : Write(actor, msg__, false);
669 : // Sentinel = 'actor'
670 0 : (msg__)->WriteSentinel(875202478);
671 0 : Write(hostName, msg__);
672 : // Sentinel = 'hostName'
673 0 : (msg__)->WriteSentinel(1367899915);
674 0 : Write(originAttributes, msg__);
675 : // Sentinel = 'originAttributes'
676 0 : (msg__)->WriteSentinel(2655275965);
677 0 : Write(flags, msg__);
678 : // Sentinel = 'flags'
679 0 : (msg__)->WriteSentinel(2550519284);
680 0 : Write(networkInterface, msg__);
681 : // Sentinel = 'networkInterface'
682 0 : (msg__)->WriteSentinel(1813484207);
683 :
684 0 : (msg__)->set_constructor();
685 :
686 :
687 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
688 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
689 : }
690 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PDNSRequestConstructor", OTHER);
691 0 : PNecko::Transition(PNecko::Msg_PDNSRequestConstructor__ID, (&(mState)));
692 :
693 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
694 0 : if ((!(sendok__))) {
695 0 : FatalError("constructor for actor failed");
696 0 : return nullptr;
697 : }
698 0 : return actor;
699 : }
700 :
701 0 : auto PNeckoChild::SendPWebSocketEventListenerConstructor(const uint64_t& aInnerWindowID) -> PWebSocketEventListenerChild*
702 : {
703 0 : return SendPWebSocketEventListenerConstructor(AllocPWebSocketEventListenerChild(aInnerWindowID), aInnerWindowID);
704 : }
705 :
706 0 : auto PNeckoChild::SendPWebSocketEventListenerConstructor(
707 : PWebSocketEventListenerChild* actor,
708 : const uint64_t& aInnerWindowID) -> PWebSocketEventListenerChild*
709 : {
710 0 : if ((!(actor))) {
711 0 : NS_WARNING("Error constructing actor PWebSocketEventListenerChild");
712 0 : return nullptr;
713 : }
714 0 : (actor)->SetManager(this);
715 0 : Register(actor);
716 0 : (actor)->SetIPCChannel(GetIPCChannel());
717 0 : (mManagedPWebSocketEventListenerChild).PutEntry(actor);
718 0 : (actor)->mState = mozilla::net::PWebSocketEventListener::__Start;
719 :
720 0 : IPC::Message* msg__ = PNecko::Msg_PWebSocketEventListenerConstructor(Id());
721 :
722 0 : Write(actor, msg__, false);
723 : // Sentinel = 'actor'
724 0 : (msg__)->WriteSentinel(875202478);
725 0 : Write(aInnerWindowID, msg__);
726 : // Sentinel = 'aInnerWindowID'
727 0 : (msg__)->WriteSentinel(3059251422);
728 :
729 0 : (msg__)->set_constructor();
730 :
731 :
732 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
733 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
734 : }
735 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PWebSocketEventListenerConstructor", OTHER);
736 0 : PNecko::Transition(PNecko::Msg_PWebSocketEventListenerConstructor__ID, (&(mState)));
737 :
738 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
739 0 : if ((!(sendok__))) {
740 0 : FatalError("constructor for actor failed");
741 0 : return nullptr;
742 : }
743 0 : return actor;
744 : }
745 :
746 1 : auto PNeckoChild::SendPredPredict(
747 : const OptionalURIParams& targetURI,
748 : const OptionalURIParams& sourceURI,
749 : const uint32_t& reason,
750 : const OriginAttributes& originAttributes,
751 : const bool& hasVerifier) -> bool
752 : {
753 1 : IPC::Message* msg__ = PNecko::Msg_PredPredict(Id());
754 :
755 1 : Write(targetURI, msg__);
756 : // Sentinel = 'targetURI'
757 1 : (msg__)->WriteSentinel(1361914354);
758 1 : Write(sourceURI, msg__);
759 : // Sentinel = 'sourceURI'
760 1 : (msg__)->WriteSentinel(3017222278);
761 1 : Write(reason, msg__);
762 : // Sentinel = 'reason'
763 1 : (msg__)->WriteSentinel(4151390930);
764 1 : Write(originAttributes, msg__);
765 : // Sentinel = 'originAttributes'
766 1 : (msg__)->WriteSentinel(2655275965);
767 1 : Write(hasVerifier, msg__);
768 : // Sentinel = 'hasVerifier'
769 1 : (msg__)->WriteSentinel(1905198201);
770 :
771 :
772 :
773 :
774 1 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
775 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
776 : }
777 2 : AUTO_PROFILER_LABEL("PNecko::Msg_PredPredict", OTHER);
778 1 : PNecko::Transition(PNecko::Msg_PredPredict__ID, (&(mState)));
779 :
780 1 : bool sendok__ = (GetIPCChannel())->Send(msg__);
781 2 : return sendok__;
782 : }
783 :
784 3 : auto PNeckoChild::SendPredLearn(
785 : const URIParams& targetURI,
786 : const OptionalURIParams& sourceURI,
787 : const uint32_t& reason,
788 : const OriginAttributes& originAttributes) -> bool
789 : {
790 3 : IPC::Message* msg__ = PNecko::Msg_PredLearn(Id());
791 :
792 3 : Write(targetURI, msg__);
793 : // Sentinel = 'targetURI'
794 3 : (msg__)->WriteSentinel(1361914354);
795 3 : Write(sourceURI, msg__);
796 : // Sentinel = 'sourceURI'
797 3 : (msg__)->WriteSentinel(3017222278);
798 3 : Write(reason, msg__);
799 : // Sentinel = 'reason'
800 3 : (msg__)->WriteSentinel(4151390930);
801 3 : Write(originAttributes, msg__);
802 : // Sentinel = 'originAttributes'
803 3 : (msg__)->WriteSentinel(2655275965);
804 :
805 :
806 :
807 :
808 3 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
809 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
810 : }
811 6 : AUTO_PROFILER_LABEL("PNecko::Msg_PredLearn", OTHER);
812 3 : PNecko::Transition(PNecko::Msg_PredLearn__ID, (&(mState)));
813 :
814 3 : bool sendok__ = (GetIPCChannel())->Send(msg__);
815 6 : return sendok__;
816 : }
817 :
818 0 : auto PNeckoChild::SendPredReset() -> bool
819 : {
820 0 : IPC::Message* msg__ = PNecko::Msg_PredReset(Id());
821 :
822 :
823 :
824 :
825 :
826 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
827 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
828 : }
829 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PredReset", OTHER);
830 0 : PNecko::Transition(PNecko::Msg_PredReset__ID, (&(mState)));
831 :
832 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
833 0 : return sendok__;
834 : }
835 :
836 0 : auto PNeckoChild::SendSpeculativeConnect(
837 : const URIParams& uri,
838 : const Principal& principal,
839 : const bool& anonymous) -> bool
840 : {
841 0 : IPC::Message* msg__ = PNecko::Msg_SpeculativeConnect(Id());
842 :
843 0 : Write(uri, msg__);
844 : // Sentinel = 'uri'
845 0 : (msg__)->WriteSentinel(1453210605);
846 0 : Write(principal, msg__);
847 : // Sentinel = 'principal'
848 0 : (msg__)->WriteSentinel(732240927);
849 0 : Write(anonymous, msg__);
850 : // Sentinel = 'anonymous'
851 0 : (msg__)->WriteSentinel(479504470);
852 :
853 :
854 :
855 :
856 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
857 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
858 : }
859 0 : AUTO_PROFILER_LABEL("PNecko::Msg_SpeculativeConnect", OTHER);
860 0 : PNecko::Transition(PNecko::Msg_SpeculativeConnect__ID, (&(mState)));
861 :
862 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
863 0 : return sendok__;
864 : }
865 :
866 0 : auto PNeckoChild::SendHTMLDNSPrefetch(
867 : const nsString& hostname,
868 : const OriginAttributes& originAttributes,
869 : const uint16_t& flags) -> bool
870 : {
871 0 : IPC::Message* msg__ = PNecko::Msg_HTMLDNSPrefetch(Id());
872 :
873 0 : Write(hostname, msg__);
874 : // Sentinel = 'hostname'
875 0 : (msg__)->WriteSentinel(4013034923);
876 0 : Write(originAttributes, msg__);
877 : // Sentinel = 'originAttributes'
878 0 : (msg__)->WriteSentinel(2655275965);
879 0 : Write(flags, msg__);
880 : // Sentinel = 'flags'
881 0 : (msg__)->WriteSentinel(2550519284);
882 :
883 :
884 :
885 :
886 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
887 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
888 : }
889 0 : AUTO_PROFILER_LABEL("PNecko::Msg_HTMLDNSPrefetch", OTHER);
890 0 : PNecko::Transition(PNecko::Msg_HTMLDNSPrefetch__ID, (&(mState)));
891 :
892 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
893 0 : return sendok__;
894 : }
895 :
896 0 : auto PNeckoChild::SendCancelHTMLDNSPrefetch(
897 : const nsString& hostname,
898 : const OriginAttributes& originAttributes,
899 : const uint16_t& flags,
900 : const nsresult& reason) -> bool
901 : {
902 0 : IPC::Message* msg__ = PNecko::Msg_CancelHTMLDNSPrefetch(Id());
903 :
904 0 : Write(hostname, msg__);
905 : // Sentinel = 'hostname'
906 0 : (msg__)->WriteSentinel(4013034923);
907 0 : Write(originAttributes, msg__);
908 : // Sentinel = 'originAttributes'
909 0 : (msg__)->WriteSentinel(2655275965);
910 0 : Write(flags, msg__);
911 : // Sentinel = 'flags'
912 0 : (msg__)->WriteSentinel(2550519284);
913 0 : Write(reason, msg__);
914 : // Sentinel = 'reason'
915 0 : (msg__)->WriteSentinel(4151390930);
916 :
917 :
918 :
919 :
920 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
921 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
922 : }
923 0 : AUTO_PROFILER_LABEL("PNecko::Msg_CancelHTMLDNSPrefetch", OTHER);
924 0 : PNecko::Transition(PNecko::Msg_CancelHTMLDNSPrefetch__ID, (&(mState)));
925 :
926 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
927 0 : return sendok__;
928 : }
929 :
930 0 : auto PNeckoChild::SendPDataChannelConstructor(const uint32_t& channelId) -> PDataChannelChild*
931 : {
932 0 : return SendPDataChannelConstructor(AllocPDataChannelChild(channelId), channelId);
933 : }
934 :
935 0 : auto PNeckoChild::SendPDataChannelConstructor(
936 : PDataChannelChild* actor,
937 : const uint32_t& channelId) -> PDataChannelChild*
938 : {
939 0 : if ((!(actor))) {
940 0 : NS_WARNING("Error constructing actor PDataChannelChild");
941 0 : return nullptr;
942 : }
943 0 : (actor)->SetManager(this);
944 0 : Register(actor);
945 0 : (actor)->SetIPCChannel(GetIPCChannel());
946 0 : (mManagedPDataChannelChild).PutEntry(actor);
947 0 : (actor)->mState = mozilla::net::PDataChannel::__Start;
948 :
949 0 : IPC::Message* msg__ = PNecko::Msg_PDataChannelConstructor(Id());
950 :
951 0 : Write(actor, msg__, false);
952 : // Sentinel = 'actor'
953 0 : (msg__)->WriteSentinel(875202478);
954 0 : Write(channelId, msg__);
955 : // Sentinel = 'channelId'
956 0 : (msg__)->WriteSentinel(6854027);
957 :
958 0 : (msg__)->set_constructor();
959 :
960 :
961 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
962 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
963 : }
964 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PDataChannelConstructor", OTHER);
965 0 : PNecko::Transition(PNecko::Msg_PDataChannelConstructor__ID, (&(mState)));
966 :
967 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
968 0 : if ((!(sendok__))) {
969 0 : FatalError("constructor for actor failed");
970 0 : return nullptr;
971 : }
972 0 : return actor;
973 : }
974 :
975 0 : auto PNeckoChild::SendPFileChannelConstructor(const uint32_t& channelId) -> PFileChannelChild*
976 : {
977 0 : return SendPFileChannelConstructor(AllocPFileChannelChild(channelId), channelId);
978 : }
979 :
980 0 : auto PNeckoChild::SendPFileChannelConstructor(
981 : PFileChannelChild* actor,
982 : const uint32_t& channelId) -> PFileChannelChild*
983 : {
984 0 : if ((!(actor))) {
985 0 : NS_WARNING("Error constructing actor PFileChannelChild");
986 0 : return nullptr;
987 : }
988 0 : (actor)->SetManager(this);
989 0 : Register(actor);
990 0 : (actor)->SetIPCChannel(GetIPCChannel());
991 0 : (mManagedPFileChannelChild).PutEntry(actor);
992 0 : (actor)->mState = mozilla::net::PFileChannel::__Start;
993 :
994 0 : IPC::Message* msg__ = PNecko::Msg_PFileChannelConstructor(Id());
995 :
996 0 : Write(actor, msg__, false);
997 : // Sentinel = 'actor'
998 0 : (msg__)->WriteSentinel(875202478);
999 0 : Write(channelId, msg__);
1000 : // Sentinel = 'channelId'
1001 0 : (msg__)->WriteSentinel(6854027);
1002 :
1003 0 : (msg__)->set_constructor();
1004 :
1005 :
1006 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1007 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1008 : }
1009 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PFileChannelConstructor", OTHER);
1010 0 : PNecko::Transition(PNecko::Msg_PFileChannelConstructor__ID, (&(mState)));
1011 :
1012 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1013 0 : if ((!(sendok__))) {
1014 0 : FatalError("constructor for actor failed");
1015 0 : return nullptr;
1016 : }
1017 0 : return actor;
1018 : }
1019 :
1020 0 : auto PNeckoChild::SendPRtspControllerConstructor() -> PRtspControllerChild*
1021 : {
1022 0 : return SendPRtspControllerConstructor(AllocPRtspControllerChild());
1023 : }
1024 :
1025 0 : auto PNeckoChild::SendPRtspControllerConstructor(PRtspControllerChild* actor) -> PRtspControllerChild*
1026 : {
1027 0 : if ((!(actor))) {
1028 0 : NS_WARNING("Error constructing actor PRtspControllerChild");
1029 0 : return nullptr;
1030 : }
1031 0 : (actor)->SetManager(this);
1032 0 : Register(actor);
1033 0 : (actor)->SetIPCChannel(GetIPCChannel());
1034 0 : (mManagedPRtspControllerChild).PutEntry(actor);
1035 0 : (actor)->mState = mozilla::net::PRtspController::__Start;
1036 :
1037 0 : IPC::Message* msg__ = PNecko::Msg_PRtspControllerConstructor(Id());
1038 :
1039 0 : Write(actor, msg__, false);
1040 : // Sentinel = 'actor'
1041 0 : (msg__)->WriteSentinel(875202478);
1042 :
1043 0 : (msg__)->set_constructor();
1044 :
1045 :
1046 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1047 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1048 : }
1049 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PRtspControllerConstructor", OTHER);
1050 0 : PNecko::Transition(PNecko::Msg_PRtspControllerConstructor__ID, (&(mState)));
1051 :
1052 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1053 0 : if ((!(sendok__))) {
1054 0 : FatalError("constructor for actor failed");
1055 0 : return nullptr;
1056 : }
1057 0 : return actor;
1058 : }
1059 :
1060 0 : auto PNeckoChild::SendPRtspChannelConstructor(const RtspChannelConnectArgs& args) -> PRtspChannelChild*
1061 : {
1062 0 : return SendPRtspChannelConstructor(AllocPRtspChannelChild(args), args);
1063 : }
1064 :
1065 0 : auto PNeckoChild::SendPRtspChannelConstructor(
1066 : PRtspChannelChild* actor,
1067 : const RtspChannelConnectArgs& args) -> PRtspChannelChild*
1068 : {
1069 0 : if ((!(actor))) {
1070 0 : NS_WARNING("Error constructing actor PRtspChannelChild");
1071 0 : return nullptr;
1072 : }
1073 0 : (actor)->SetManager(this);
1074 0 : Register(actor);
1075 0 : (actor)->SetIPCChannel(GetIPCChannel());
1076 0 : (mManagedPRtspChannelChild).PutEntry(actor);
1077 0 : (actor)->mState = mozilla::net::PRtspChannel::__Start;
1078 :
1079 0 : IPC::Message* msg__ = PNecko::Msg_PRtspChannelConstructor(Id());
1080 :
1081 0 : Write(actor, msg__, false);
1082 : // Sentinel = 'actor'
1083 0 : (msg__)->WriteSentinel(875202478);
1084 0 : Write(args, msg__);
1085 : // Sentinel = 'args'
1086 0 : (msg__)->WriteSentinel(2823760587);
1087 :
1088 0 : (msg__)->set_constructor();
1089 :
1090 :
1091 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1092 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1093 : }
1094 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PRtspChannelConstructor", OTHER);
1095 0 : PNecko::Transition(PNecko::Msg_PRtspChannelConstructor__ID, (&(mState)));
1096 :
1097 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1098 0 : if ((!(sendok__))) {
1099 0 : FatalError("constructor for actor failed");
1100 0 : return nullptr;
1101 : }
1102 0 : return actor;
1103 : }
1104 :
1105 0 : auto PNeckoChild::SendPChannelDiverterConstructor(const ChannelDiverterArgs& channel) -> PChannelDiverterChild*
1106 : {
1107 0 : return SendPChannelDiverterConstructor(AllocPChannelDiverterChild(channel), channel);
1108 : }
1109 :
1110 0 : auto PNeckoChild::SendPChannelDiverterConstructor(
1111 : PChannelDiverterChild* actor,
1112 : const ChannelDiverterArgs& channel) -> PChannelDiverterChild*
1113 : {
1114 0 : if ((!(actor))) {
1115 0 : NS_WARNING("Error constructing actor PChannelDiverterChild");
1116 0 : return nullptr;
1117 : }
1118 0 : (actor)->SetManager(this);
1119 0 : Register(actor);
1120 0 : (actor)->SetIPCChannel(GetIPCChannel());
1121 0 : (mManagedPChannelDiverterChild).PutEntry(actor);
1122 0 : (actor)->mState = mozilla::net::PChannelDiverter::__Start;
1123 :
1124 0 : IPC::Message* msg__ = PNecko::Msg_PChannelDiverterConstructor(Id());
1125 :
1126 0 : Write(actor, msg__, false);
1127 : // Sentinel = 'actor'
1128 0 : (msg__)->WriteSentinel(875202478);
1129 0 : Write(channel, msg__);
1130 : // Sentinel = 'channel'
1131 0 : (msg__)->WriteSentinel(452840382);
1132 :
1133 0 : (msg__)->set_constructor();
1134 :
1135 :
1136 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1137 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1138 : }
1139 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PChannelDiverterConstructor", OTHER);
1140 0 : PNecko::Transition(PNecko::Msg_PChannelDiverterConstructor__ID, (&(mState)));
1141 :
1142 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1143 0 : if ((!(sendok__))) {
1144 0 : FatalError("constructor for actor failed");
1145 0 : return nullptr;
1146 : }
1147 0 : return actor;
1148 : }
1149 :
1150 0 : auto PNeckoChild::SendOnAuthAvailable(
1151 : const uint64_t& callbackId,
1152 : const nsString& user,
1153 : const nsString& password,
1154 : const nsString& domain) -> bool
1155 : {
1156 0 : IPC::Message* msg__ = PNecko::Msg_OnAuthAvailable(Id());
1157 :
1158 0 : Write(callbackId, msg__);
1159 : // Sentinel = 'callbackId'
1160 0 : (msg__)->WriteSentinel(4163989448);
1161 0 : Write(user, msg__);
1162 : // Sentinel = 'user'
1163 0 : (msg__)->WriteSentinel(479507925);
1164 0 : Write(password, msg__);
1165 : // Sentinel = 'password'
1166 0 : (msg__)->WriteSentinel(2527534683);
1167 0 : Write(domain, msg__);
1168 : // Sentinel = 'domain'
1169 0 : (msg__)->WriteSentinel(702229122);
1170 :
1171 :
1172 :
1173 :
1174 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1175 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1176 : }
1177 0 : AUTO_PROFILER_LABEL("PNecko::Msg_OnAuthAvailable", OTHER);
1178 0 : PNecko::Transition(PNecko::Msg_OnAuthAvailable__ID, (&(mState)));
1179 :
1180 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1181 0 : return sendok__;
1182 : }
1183 :
1184 0 : auto PNeckoChild::SendOnAuthCancelled(
1185 : const uint64_t& callbackId,
1186 : const bool& userCancel) -> bool
1187 : {
1188 0 : IPC::Message* msg__ = PNecko::Msg_OnAuthCancelled(Id());
1189 :
1190 0 : Write(callbackId, msg__);
1191 : // Sentinel = 'callbackId'
1192 0 : (msg__)->WriteSentinel(4163989448);
1193 0 : Write(userCancel, msg__);
1194 : // Sentinel = 'userCancel'
1195 0 : (msg__)->WriteSentinel(2063943853);
1196 :
1197 :
1198 :
1199 :
1200 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1201 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1202 : }
1203 0 : AUTO_PROFILER_LABEL("PNecko::Msg_OnAuthCancelled", OTHER);
1204 0 : PNecko::Transition(PNecko::Msg_OnAuthCancelled__ID, (&(mState)));
1205 :
1206 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1207 0 : return sendok__;
1208 : }
1209 :
1210 0 : auto PNeckoChild::SendRemoveRequestContext(const uint64_t& rcid) -> bool
1211 : {
1212 0 : IPC::Message* msg__ = PNecko::Msg_RemoveRequestContext(Id());
1213 :
1214 0 : Write(rcid, msg__);
1215 : // Sentinel = 'rcid'
1216 0 : (msg__)->WriteSentinel(3280983874);
1217 :
1218 :
1219 :
1220 :
1221 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1222 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1223 : }
1224 0 : AUTO_PROFILER_LABEL("PNecko::Msg_RemoveRequestContext", OTHER);
1225 0 : PNecko::Transition(PNecko::Msg_RemoveRequestContext__ID, (&(mState)));
1226 :
1227 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1228 0 : return sendok__;
1229 : }
1230 :
1231 0 : auto PNeckoChild::SendPAltDataOutputStreamConstructor(
1232 : const nsCString& type,
1233 : PHttpChannelChild* channel) -> PAltDataOutputStreamChild*
1234 : {
1235 0 : return SendPAltDataOutputStreamConstructor(AllocPAltDataOutputStreamChild(type, channel), type, channel);
1236 : }
1237 :
1238 0 : auto PNeckoChild::SendPAltDataOutputStreamConstructor(
1239 : PAltDataOutputStreamChild* actor,
1240 : const nsCString& type,
1241 : PHttpChannelChild* channel) -> PAltDataOutputStreamChild*
1242 : {
1243 0 : if ((!(actor))) {
1244 0 : NS_WARNING("Error constructing actor PAltDataOutputStreamChild");
1245 0 : return nullptr;
1246 : }
1247 0 : (actor)->SetManager(this);
1248 0 : Register(actor);
1249 0 : (actor)->SetIPCChannel(GetIPCChannel());
1250 0 : (mManagedPAltDataOutputStreamChild).PutEntry(actor);
1251 0 : (actor)->mState = mozilla::net::PAltDataOutputStream::__Start;
1252 :
1253 0 : IPC::Message* msg__ = PNecko::Msg_PAltDataOutputStreamConstructor(Id());
1254 :
1255 0 : Write(actor, msg__, false);
1256 : // Sentinel = 'actor'
1257 0 : (msg__)->WriteSentinel(875202478);
1258 0 : Write(type, msg__);
1259 : // Sentinel = 'type'
1260 0 : (msg__)->WriteSentinel(2982068540);
1261 0 : Write(channel, msg__, false);
1262 : // Sentinel = 'channel'
1263 0 : (msg__)->WriteSentinel(452840382);
1264 :
1265 0 : (msg__)->set_constructor();
1266 :
1267 :
1268 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1269 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1270 : }
1271 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PAltDataOutputStreamConstructor", OTHER);
1272 0 : PNecko::Transition(PNecko::Msg_PAltDataOutputStreamConstructor__ID, (&(mState)));
1273 :
1274 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1275 0 : if ((!(sendok__))) {
1276 0 : FatalError("constructor for actor failed");
1277 0 : return nullptr;
1278 : }
1279 0 : return actor;
1280 : }
1281 :
1282 0 : auto PNeckoChild::SendPStunAddrsRequestConstructor() -> PStunAddrsRequestChild*
1283 : {
1284 0 : return SendPStunAddrsRequestConstructor(AllocPStunAddrsRequestChild());
1285 : }
1286 :
1287 0 : auto PNeckoChild::SendPStunAddrsRequestConstructor(PStunAddrsRequestChild* actor) -> PStunAddrsRequestChild*
1288 : {
1289 0 : if ((!(actor))) {
1290 0 : NS_WARNING("Error constructing actor PStunAddrsRequestChild");
1291 0 : return nullptr;
1292 : }
1293 0 : (actor)->SetManager(this);
1294 0 : Register(actor);
1295 0 : (actor)->SetIPCChannel(GetIPCChannel());
1296 0 : (mManagedPStunAddrsRequestChild).PutEntry(actor);
1297 0 : (actor)->mState = mozilla::net::PStunAddrsRequest::__Start;
1298 :
1299 0 : IPC::Message* msg__ = PNecko::Msg_PStunAddrsRequestConstructor(Id());
1300 :
1301 0 : Write(actor, msg__, false);
1302 : // Sentinel = 'actor'
1303 0 : (msg__)->WriteSentinel(875202478);
1304 :
1305 0 : (msg__)->set_constructor();
1306 :
1307 :
1308 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1309 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1310 : }
1311 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PStunAddrsRequestConstructor", OTHER);
1312 0 : PNecko::Transition(PNecko::Msg_PStunAddrsRequestConstructor__ID, (&(mState)));
1313 :
1314 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1315 0 : if ((!(sendok__))) {
1316 0 : FatalError("constructor for actor failed");
1317 0 : return nullptr;
1318 : }
1319 0 : return actor;
1320 : }
1321 :
1322 2 : auto PNeckoChild::SendNotifyCurrentTopLevelOuterContentWindowId(const uint64_t& windowId) -> bool
1323 : {
1324 2 : IPC::Message* msg__ = PNecko::Msg_NotifyCurrentTopLevelOuterContentWindowId(Id());
1325 :
1326 2 : Write(windowId, msg__);
1327 : // Sentinel = 'windowId'
1328 2 : (msg__)->WriteSentinel(719502035);
1329 :
1330 :
1331 :
1332 :
1333 2 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1334 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1335 : }
1336 4 : AUTO_PROFILER_LABEL("PNecko::Msg_NotifyCurrentTopLevelOuterContentWindowId", OTHER);
1337 2 : PNecko::Transition(PNecko::Msg_NotifyCurrentTopLevelOuterContentWindowId__ID, (&(mState)));
1338 :
1339 2 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1340 4 : return sendok__;
1341 : }
1342 :
1343 0 : auto PNeckoChild::SendGetExtensionStream(
1344 : const URIParams& uri,
1345 : const LoadInfoArgs& loadInfo) -> RefPtr<GetExtensionStreamPromise>
1346 : {
1347 0 : IPC::Message* msg__ = PNecko::Msg_GetExtensionStream(Id());
1348 :
1349 0 : Write(uri, msg__);
1350 : // Sentinel = 'uri'
1351 0 : (msg__)->WriteSentinel(1453210605);
1352 0 : Write(loadInfo, msg__);
1353 : // Sentinel = 'loadInfo'
1354 0 : (msg__)->WriteSentinel(2597515304);
1355 :
1356 :
1357 :
1358 :
1359 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1360 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1361 : }
1362 0 : AUTO_PROFILER_LABEL("PNecko::Msg_GetExtensionStream", OTHER);
1363 0 : PNecko::Transition(PNecko::Msg_GetExtensionStream__ID, (&(mState)));
1364 :
1365 0 : RefPtr<MozPromise<OptionalIPCStream, PromiseRejectReason, false>::Private> promise__ = new MozPromise<OptionalIPCStream, PromiseRejectReason, false>::Private(__func__);
1366 :
1367 0 : bool sendok__ = (GetIPCChannel())->Send(msg__, (promise__).get(), this);
1368 0 : if ((!(sendok__))) {
1369 0 : (promise__)->Reject(PromiseRejectReason::SendError, __func__);
1370 : }
1371 0 : return promise__;
1372 : }
1373 :
1374 0 : auto PNeckoChild::SendGetExtensionFD(
1375 : const URIParams& uri,
1376 : const OptionalLoadInfoArgs& loadInfo) -> RefPtr<GetExtensionFDPromise>
1377 : {
1378 0 : IPC::Message* msg__ = PNecko::Msg_GetExtensionFD(Id());
1379 :
1380 0 : Write(uri, msg__);
1381 : // Sentinel = 'uri'
1382 0 : (msg__)->WriteSentinel(1453210605);
1383 0 : Write(loadInfo, msg__);
1384 : // Sentinel = 'loadInfo'
1385 0 : (msg__)->WriteSentinel(2597515304);
1386 :
1387 :
1388 :
1389 :
1390 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1391 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1392 : }
1393 0 : AUTO_PROFILER_LABEL("PNecko::Msg_GetExtensionFD", OTHER);
1394 0 : PNecko::Transition(PNecko::Msg_GetExtensionFD__ID, (&(mState)));
1395 :
1396 0 : RefPtr<MozPromise<FileDescriptor, PromiseRejectReason, false>::Private> promise__ = new MozPromise<FileDescriptor, PromiseRejectReason, false>::Private(__func__);
1397 :
1398 0 : bool sendok__ = (GetIPCChannel())->Send(msg__, (promise__).get(), this);
1399 0 : if ((!(sendok__))) {
1400 0 : (promise__)->Reject(PromiseRejectReason::SendError, __func__);
1401 : }
1402 0 : return promise__;
1403 : }
1404 :
1405 0 : auto PNeckoChild::SendPTCPSocketConstructor(
1406 : const nsString& host,
1407 : const uint16_t& port) -> PTCPSocketChild*
1408 : {
1409 0 : return SendPTCPSocketConstructor(AllocPTCPSocketChild(host, port), host, port);
1410 : }
1411 :
1412 0 : auto PNeckoChild::SendPTCPSocketConstructor(
1413 : PTCPSocketChild* actor,
1414 : const nsString& host,
1415 : const uint16_t& port) -> PTCPSocketChild*
1416 : {
1417 0 : if ((!(actor))) {
1418 0 : NS_WARNING("Error constructing actor PTCPSocketChild");
1419 0 : return nullptr;
1420 : }
1421 0 : (actor)->SetManager(this);
1422 0 : Register(actor);
1423 0 : (actor)->SetIPCChannel(GetIPCChannel());
1424 0 : (mManagedPTCPSocketChild).PutEntry(actor);
1425 0 : (actor)->mState = mozilla::net::PTCPSocket::__Start;
1426 :
1427 0 : IPC::Message* msg__ = PNecko::Msg_PTCPSocketConstructor(Id());
1428 :
1429 0 : Write(actor, msg__, false);
1430 : // Sentinel = 'actor'
1431 0 : (msg__)->WriteSentinel(875202478);
1432 0 : Write(host, msg__);
1433 : // Sentinel = 'host'
1434 0 : (msg__)->WriteSentinel(4070301394);
1435 0 : Write(port, msg__);
1436 : // Sentinel = 'port'
1437 0 : (msg__)->WriteSentinel(3633211549);
1438 :
1439 0 : (msg__)->set_constructor();
1440 :
1441 :
1442 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1443 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
1444 : }
1445 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PTCPSocketConstructor", OTHER);
1446 0 : PNecko::Transition(PNecko::Msg_PTCPSocketConstructor__ID, (&(mState)));
1447 :
1448 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
1449 0 : if ((!(sendok__))) {
1450 0 : FatalError("constructor for actor failed");
1451 0 : return nullptr;
1452 : }
1453 0 : return actor;
1454 : }
1455 :
1456 2 : auto PNeckoChild::RemoveManagee(
1457 : int32_t aProtocolId,
1458 : ProtocolBase* aListener) -> void
1459 : {
1460 2 : switch (aProtocolId) {
1461 : case PHttpChannelMsgStart:
1462 : {
1463 2 : PHttpChannelChild* actor = static_cast<PHttpChannelChild*>(aListener);
1464 2 : auto& container = mManagedPHttpChannelChild;
1465 2 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1466 :
1467 2 : (container).RemoveEntry(actor);
1468 2 : DeallocPHttpChannelChild(actor);
1469 2 : return;
1470 : }
1471 : case PCookieServiceMsgStart:
1472 : {
1473 0 : PCookieServiceChild* actor = static_cast<PCookieServiceChild*>(aListener);
1474 0 : auto& container = mManagedPCookieServiceChild;
1475 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1476 :
1477 0 : (container).RemoveEntry(actor);
1478 0 : DeallocPCookieServiceChild(actor);
1479 0 : return;
1480 : }
1481 : case PWyciwygChannelMsgStart:
1482 : {
1483 0 : PWyciwygChannelChild* actor = static_cast<PWyciwygChannelChild*>(aListener);
1484 0 : auto& container = mManagedPWyciwygChannelChild;
1485 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1486 :
1487 0 : (container).RemoveEntry(actor);
1488 0 : DeallocPWyciwygChannelChild(actor);
1489 0 : return;
1490 : }
1491 : case PFTPChannelMsgStart:
1492 : {
1493 0 : PFTPChannelChild* actor = static_cast<PFTPChannelChild*>(aListener);
1494 0 : auto& container = mManagedPFTPChannelChild;
1495 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1496 :
1497 0 : (container).RemoveEntry(actor);
1498 0 : DeallocPFTPChannelChild(actor);
1499 0 : return;
1500 : }
1501 : case PWebSocketMsgStart:
1502 : {
1503 0 : PWebSocketChild* actor = static_cast<PWebSocketChild*>(aListener);
1504 0 : auto& container = mManagedPWebSocketChild;
1505 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1506 :
1507 0 : (container).RemoveEntry(actor);
1508 0 : DeallocPWebSocketChild(actor);
1509 0 : return;
1510 : }
1511 : case PWebSocketEventListenerMsgStart:
1512 : {
1513 0 : PWebSocketEventListenerChild* actor = static_cast<PWebSocketEventListenerChild*>(aListener);
1514 0 : auto& container = mManagedPWebSocketEventListenerChild;
1515 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1516 :
1517 0 : (container).RemoveEntry(actor);
1518 0 : DeallocPWebSocketEventListenerChild(actor);
1519 0 : return;
1520 : }
1521 : case PTCPSocketMsgStart:
1522 : {
1523 0 : PTCPSocketChild* actor = static_cast<PTCPSocketChild*>(aListener);
1524 0 : auto& container = mManagedPTCPSocketChild;
1525 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1526 :
1527 0 : (container).RemoveEntry(actor);
1528 0 : DeallocPTCPSocketChild(actor);
1529 0 : return;
1530 : }
1531 : case PTCPServerSocketMsgStart:
1532 : {
1533 0 : PTCPServerSocketChild* actor = static_cast<PTCPServerSocketChild*>(aListener);
1534 0 : auto& container = mManagedPTCPServerSocketChild;
1535 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1536 :
1537 0 : (container).RemoveEntry(actor);
1538 0 : DeallocPTCPServerSocketChild(actor);
1539 0 : return;
1540 : }
1541 : case PUDPSocketMsgStart:
1542 : {
1543 0 : PUDPSocketChild* actor = static_cast<PUDPSocketChild*>(aListener);
1544 0 : auto& container = mManagedPUDPSocketChild;
1545 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1546 :
1547 0 : (container).RemoveEntry(actor);
1548 0 : DeallocPUDPSocketChild(actor);
1549 0 : return;
1550 : }
1551 : case PDNSRequestMsgStart:
1552 : {
1553 0 : PDNSRequestChild* actor = static_cast<PDNSRequestChild*>(aListener);
1554 0 : auto& container = mManagedPDNSRequestChild;
1555 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1556 :
1557 0 : (container).RemoveEntry(actor);
1558 0 : DeallocPDNSRequestChild(actor);
1559 0 : return;
1560 : }
1561 : case PDataChannelMsgStart:
1562 : {
1563 0 : PDataChannelChild* actor = static_cast<PDataChannelChild*>(aListener);
1564 0 : auto& container = mManagedPDataChannelChild;
1565 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1566 :
1567 0 : (container).RemoveEntry(actor);
1568 0 : DeallocPDataChannelChild(actor);
1569 0 : return;
1570 : }
1571 : case PFileChannelMsgStart:
1572 : {
1573 0 : PFileChannelChild* actor = static_cast<PFileChannelChild*>(aListener);
1574 0 : auto& container = mManagedPFileChannelChild;
1575 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1576 :
1577 0 : (container).RemoveEntry(actor);
1578 0 : DeallocPFileChannelChild(actor);
1579 0 : return;
1580 : }
1581 : case PRtspControllerMsgStart:
1582 : {
1583 0 : PRtspControllerChild* actor = static_cast<PRtspControllerChild*>(aListener);
1584 0 : auto& container = mManagedPRtspControllerChild;
1585 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1586 :
1587 0 : (container).RemoveEntry(actor);
1588 0 : DeallocPRtspControllerChild(actor);
1589 0 : return;
1590 : }
1591 : case PRtspChannelMsgStart:
1592 : {
1593 0 : PRtspChannelChild* actor = static_cast<PRtspChannelChild*>(aListener);
1594 0 : auto& container = mManagedPRtspChannelChild;
1595 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1596 :
1597 0 : (container).RemoveEntry(actor);
1598 0 : DeallocPRtspChannelChild(actor);
1599 0 : return;
1600 : }
1601 : case PChannelDiverterMsgStart:
1602 : {
1603 0 : PChannelDiverterChild* actor = static_cast<PChannelDiverterChild*>(aListener);
1604 0 : auto& container = mManagedPChannelDiverterChild;
1605 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1606 :
1607 0 : (container).RemoveEntry(actor);
1608 0 : DeallocPChannelDiverterChild(actor);
1609 0 : return;
1610 : }
1611 : case PTransportProviderMsgStart:
1612 : {
1613 0 : PTransportProviderChild* actor = static_cast<PTransportProviderChild*>(aListener);
1614 0 : auto& container = mManagedPTransportProviderChild;
1615 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1616 :
1617 0 : (container).RemoveEntry(actor);
1618 0 : DeallocPTransportProviderChild(actor);
1619 0 : return;
1620 : }
1621 : case PAltDataOutputStreamMsgStart:
1622 : {
1623 0 : PAltDataOutputStreamChild* actor = static_cast<PAltDataOutputStreamChild*>(aListener);
1624 0 : auto& container = mManagedPAltDataOutputStreamChild;
1625 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1626 :
1627 0 : (container).RemoveEntry(actor);
1628 0 : DeallocPAltDataOutputStreamChild(actor);
1629 0 : return;
1630 : }
1631 : case PStunAddrsRequestMsgStart:
1632 : {
1633 0 : PStunAddrsRequestChild* actor = static_cast<PStunAddrsRequestChild*>(aListener);
1634 0 : auto& container = mManagedPStunAddrsRequestChild;
1635 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
1636 :
1637 0 : (container).RemoveEntry(actor);
1638 0 : DeallocPStunAddrsRequestChild(actor);
1639 0 : return;
1640 : }
1641 : default:
1642 : {
1643 0 : FatalError("unreached");
1644 0 : return;
1645 : }
1646 : }
1647 : }
1648 :
1649 0 : auto PNeckoChild::OnMessageReceived(const Message& msg__) -> PNeckoChild::Result
1650 : {
1651 0 : switch ((msg__).type()) {
1652 : case PNecko::Reply___delete____ID:
1653 : {
1654 0 : return MsgProcessed;
1655 : }
1656 : case PNecko::Reply_PCookieServiceConstructor__ID:
1657 : {
1658 0 : return MsgProcessed;
1659 : }
1660 : case PNecko::Reply_PHttpChannelConstructor__ID:
1661 : {
1662 0 : return MsgProcessed;
1663 : }
1664 : case PNecko::Reply_PWyciwygChannelConstructor__ID:
1665 : {
1666 0 : return MsgProcessed;
1667 : }
1668 : case PNecko::Reply_PFTPChannelConstructor__ID:
1669 : {
1670 0 : return MsgProcessed;
1671 : }
1672 : case PNecko::Reply_PWebSocketConstructor__ID:
1673 : {
1674 0 : return MsgProcessed;
1675 : }
1676 : case PNecko::Reply_PTCPServerSocketConstructor__ID:
1677 : {
1678 0 : return MsgProcessed;
1679 : }
1680 : case PNecko::Reply_PUDPSocketConstructor__ID:
1681 : {
1682 0 : return MsgProcessed;
1683 : }
1684 : case PNecko::Reply_PDNSRequestConstructor__ID:
1685 : {
1686 0 : return MsgProcessed;
1687 : }
1688 : case PNecko::Reply_PWebSocketEventListenerConstructor__ID:
1689 : {
1690 0 : return MsgProcessed;
1691 : }
1692 : case PNecko::Reply_PDataChannelConstructor__ID:
1693 : {
1694 0 : return MsgProcessed;
1695 : }
1696 : case PNecko::Reply_PFileChannelConstructor__ID:
1697 : {
1698 0 : return MsgProcessed;
1699 : }
1700 : case PNecko::Reply_PRtspControllerConstructor__ID:
1701 : {
1702 0 : return MsgProcessed;
1703 : }
1704 : case PNecko::Reply_PRtspChannelConstructor__ID:
1705 : {
1706 0 : return MsgProcessed;
1707 : }
1708 : case PNecko::Reply_PChannelDiverterConstructor__ID:
1709 : {
1710 0 : return MsgProcessed;
1711 : }
1712 : case PNecko::Reply_PAltDataOutputStreamConstructor__ID:
1713 : {
1714 0 : return MsgProcessed;
1715 : }
1716 : case PNecko::Reply_PStunAddrsRequestConstructor__ID:
1717 : {
1718 0 : return MsgProcessed;
1719 : }
1720 : case PNecko::Reply_GetExtensionStream__ID:
1721 : {
1722 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1723 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
1724 : }
1725 0 : AUTO_PROFILER_LABEL("PNecko::Msg_GetExtensionStream", OTHER);
1726 :
1727 0 : PickleIterator iter__(msg__);
1728 : bool resolve__;
1729 0 : if ((!(Read((&(resolve__)), (&(msg__)), (&(iter__)))))) {
1730 0 : FatalError("Error deserializing 'resolve__'");
1731 0 : return MsgValueError;
1732 : }
1733 : // Sentinel = 'resolve__'
1734 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3997392463)))) {
1735 0 : mozilla::ipc::SentinelReadError("Error deserializing 'resolve__'");
1736 0 : return MsgValueError;
1737 : }
1738 :
1739 0 : RefPtr<MozPromise<OptionalIPCStream, PromiseRejectReason, false>::Private> promise = ((GetIPCChannel())->PopPromise(msg__)).downcast<MozPromise<OptionalIPCStream, PromiseRejectReason, false>::Private>();
1740 0 : if ((!(promise))) {
1741 0 : FatalError("Error unknown promise");
1742 0 : return MsgProcessingError;
1743 : }
1744 0 : if (resolve__) {
1745 0 : OptionalIPCStream stream;
1746 :
1747 0 : if ((!(Read((&(stream)), (&(msg__)), (&(iter__)))))) {
1748 0 : FatalError("Error deserializing 'OptionalIPCStream'");
1749 0 : return MsgValueError;
1750 : }
1751 : // Sentinel = 'stream'
1752 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4152748422)))) {
1753 0 : mozilla::ipc::SentinelReadError("Error deserializing 'OptionalIPCStream'");
1754 0 : return MsgValueError;
1755 : }
1756 0 : (msg__).EndRead(iter__, (msg__).type());
1757 0 : (promise)->Resolve(stream, __func__);
1758 : }
1759 : else {
1760 : PromiseRejectReason reason__;
1761 0 : if ((!(Read((&(reason__)), (&(msg__)), (&(iter__)))))) {
1762 0 : FatalError("Error deserializing 'reason__'");
1763 0 : return MsgValueError;
1764 : }
1765 : // Sentinel = 'reason__'
1766 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 913452670)))) {
1767 0 : mozilla::ipc::SentinelReadError("Error deserializing 'reason__'");
1768 0 : return MsgValueError;
1769 : }
1770 0 : (msg__).EndRead(iter__, (msg__).type());
1771 0 : (promise)->Reject(reason__, __func__);
1772 : }
1773 0 : return MsgProcessed;
1774 : }
1775 : case PNecko::Reply_GetExtensionFD__ID:
1776 : {
1777 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1778 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
1779 : }
1780 0 : AUTO_PROFILER_LABEL("PNecko::Msg_GetExtensionFD", OTHER);
1781 :
1782 0 : PickleIterator iter__(msg__);
1783 : bool resolve__;
1784 0 : if ((!(Read((&(resolve__)), (&(msg__)), (&(iter__)))))) {
1785 0 : FatalError("Error deserializing 'resolve__'");
1786 0 : return MsgValueError;
1787 : }
1788 : // Sentinel = 'resolve__'
1789 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3997392463)))) {
1790 0 : mozilla::ipc::SentinelReadError("Error deserializing 'resolve__'");
1791 0 : return MsgValueError;
1792 : }
1793 :
1794 0 : RefPtr<MozPromise<FileDescriptor, PromiseRejectReason, false>::Private> promise = ((GetIPCChannel())->PopPromise(msg__)).downcast<MozPromise<FileDescriptor, PromiseRejectReason, false>::Private>();
1795 0 : if ((!(promise))) {
1796 0 : FatalError("Error unknown promise");
1797 0 : return MsgProcessingError;
1798 : }
1799 0 : if (resolve__) {
1800 0 : FileDescriptor fd;
1801 :
1802 0 : if ((!(Read((&(fd)), (&(msg__)), (&(iter__)))))) {
1803 0 : FatalError("Error deserializing 'FileDescriptor'");
1804 0 : return MsgValueError;
1805 : }
1806 : // Sentinel = 'fd'
1807 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 628535764)))) {
1808 0 : mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor'");
1809 0 : return MsgValueError;
1810 : }
1811 0 : (msg__).EndRead(iter__, (msg__).type());
1812 0 : (promise)->Resolve(fd, __func__);
1813 : }
1814 : else {
1815 : PromiseRejectReason reason__;
1816 0 : if ((!(Read((&(reason__)), (&(msg__)), (&(iter__)))))) {
1817 0 : FatalError("Error deserializing 'reason__'");
1818 0 : return MsgValueError;
1819 : }
1820 : // Sentinel = 'reason__'
1821 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 913452670)))) {
1822 0 : mozilla::ipc::SentinelReadError("Error deserializing 'reason__'");
1823 0 : return MsgValueError;
1824 : }
1825 0 : (msg__).EndRead(iter__, (msg__).type());
1826 0 : (promise)->Reject(reason__, __func__);
1827 : }
1828 0 : return MsgProcessed;
1829 : }
1830 : case PNecko::Msg_AsyncAuthPromptForNestedFrame__ID:
1831 : {
1832 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1833 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
1834 : }
1835 0 : AUTO_PROFILER_LABEL("PNecko::Msg_AsyncAuthPromptForNestedFrame", OTHER);
1836 :
1837 0 : PickleIterator iter__(msg__);
1838 0 : TabId nestedFrameId;
1839 0 : nsCString uri;
1840 0 : nsString realm;
1841 : uint64_t callbackId;
1842 :
1843 0 : if ((!(Read((&(nestedFrameId)), (&(msg__)), (&(iter__)))))) {
1844 0 : FatalError("Error deserializing 'TabId'");
1845 0 : return MsgValueError;
1846 : }
1847 : // Sentinel = 'nestedFrameId'
1848 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 168911970)))) {
1849 0 : mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
1850 0 : return MsgValueError;
1851 : }
1852 0 : if ((!(Read((&(uri)), (&(msg__)), (&(iter__)))))) {
1853 0 : FatalError("Error deserializing 'nsCString'");
1854 0 : return MsgValueError;
1855 : }
1856 : // Sentinel = 'uri'
1857 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
1858 0 : mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
1859 0 : return MsgValueError;
1860 : }
1861 0 : if ((!(Read((&(realm)), (&(msg__)), (&(iter__)))))) {
1862 0 : FatalError("Error deserializing 'nsString'");
1863 0 : return MsgValueError;
1864 : }
1865 : // Sentinel = 'realm'
1866 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1127162788)))) {
1867 0 : mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
1868 0 : return MsgValueError;
1869 : }
1870 0 : if ((!(Read((&(callbackId)), (&(msg__)), (&(iter__)))))) {
1871 0 : FatalError("Error deserializing 'uint64_t'");
1872 0 : return MsgValueError;
1873 : }
1874 : // Sentinel = 'callbackId'
1875 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4163989448)))) {
1876 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
1877 0 : return MsgValueError;
1878 : }
1879 0 : (msg__).EndRead(iter__, (msg__).type());
1880 0 : PNecko::Transition(PNecko::Msg_AsyncAuthPromptForNestedFrame__ID, (&(mState)));
1881 0 : if ((!(RecvAsyncAuthPromptForNestedFrame(mozilla::Move(nestedFrameId), mozilla::Move(uri), mozilla::Move(realm), mozilla::Move(callbackId))))) {
1882 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1883 : // Error handled in mozilla::ipc::IPCResult
1884 0 : return MsgProcessingError;
1885 : }
1886 :
1887 0 : return MsgProcessed;
1888 : }
1889 : case PNecko::Msg_PredOnPredictPrefetch__ID:
1890 : {
1891 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1892 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
1893 : }
1894 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PredOnPredictPrefetch", OTHER);
1895 :
1896 0 : PickleIterator iter__(msg__);
1897 0 : URIParams uri;
1898 : uint32_t httpStatus;
1899 :
1900 0 : if ((!(Read((&(uri)), (&(msg__)), (&(iter__)))))) {
1901 0 : FatalError("Error deserializing 'URIParams'");
1902 0 : return MsgValueError;
1903 : }
1904 : // Sentinel = 'uri'
1905 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
1906 0 : mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
1907 0 : return MsgValueError;
1908 : }
1909 0 : if ((!(Read((&(httpStatus)), (&(msg__)), (&(iter__)))))) {
1910 0 : FatalError("Error deserializing 'uint32_t'");
1911 0 : return MsgValueError;
1912 : }
1913 : // Sentinel = 'httpStatus'
1914 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2648726124)))) {
1915 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
1916 0 : return MsgValueError;
1917 : }
1918 0 : (msg__).EndRead(iter__, (msg__).type());
1919 0 : PNecko::Transition(PNecko::Msg_PredOnPredictPrefetch__ID, (&(mState)));
1920 0 : if ((!(RecvPredOnPredictPrefetch(mozilla::Move(uri), mozilla::Move(httpStatus))))) {
1921 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1922 : // Error handled in mozilla::ipc::IPCResult
1923 0 : return MsgProcessingError;
1924 : }
1925 :
1926 0 : return MsgProcessed;
1927 : }
1928 : case PNecko::Msg_PredOnPredictPreconnect__ID:
1929 : {
1930 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1931 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
1932 : }
1933 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PredOnPredictPreconnect", OTHER);
1934 :
1935 0 : PickleIterator iter__(msg__);
1936 0 : URIParams uri;
1937 :
1938 0 : if ((!(Read((&(uri)), (&(msg__)), (&(iter__)))))) {
1939 0 : FatalError("Error deserializing 'URIParams'");
1940 0 : return MsgValueError;
1941 : }
1942 : // Sentinel = 'uri'
1943 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
1944 0 : mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
1945 0 : return MsgValueError;
1946 : }
1947 0 : (msg__).EndRead(iter__, (msg__).type());
1948 0 : PNecko::Transition(PNecko::Msg_PredOnPredictPreconnect__ID, (&(mState)));
1949 0 : if ((!(RecvPredOnPredictPreconnect(mozilla::Move(uri))))) {
1950 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1951 : // Error handled in mozilla::ipc::IPCResult
1952 0 : return MsgProcessingError;
1953 : }
1954 :
1955 0 : return MsgProcessed;
1956 : }
1957 : case PNecko::Msg_PredOnPredictDNS__ID:
1958 : {
1959 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1960 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
1961 : }
1962 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PredOnPredictDNS", OTHER);
1963 :
1964 0 : PickleIterator iter__(msg__);
1965 0 : URIParams uri;
1966 :
1967 0 : if ((!(Read((&(uri)), (&(msg__)), (&(iter__)))))) {
1968 0 : FatalError("Error deserializing 'URIParams'");
1969 0 : return MsgValueError;
1970 : }
1971 : // Sentinel = 'uri'
1972 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
1973 0 : mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
1974 0 : return MsgValueError;
1975 : }
1976 0 : (msg__).EndRead(iter__, (msg__).type());
1977 0 : PNecko::Transition(PNecko::Msg_PredOnPredictDNS__ID, (&(mState)));
1978 0 : if ((!(RecvPredOnPredictDNS(mozilla::Move(uri))))) {
1979 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1980 : // Error handled in mozilla::ipc::IPCResult
1981 0 : return MsgProcessingError;
1982 : }
1983 :
1984 0 : return MsgProcessed;
1985 : }
1986 : case PNecko::Msg_SpeculativeConnectRequest__ID:
1987 : {
1988 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
1989 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
1990 : }
1991 0 : AUTO_PROFILER_LABEL("PNecko::Msg_SpeculativeConnectRequest", OTHER);
1992 :
1993 0 : PNecko::Transition(PNecko::Msg_SpeculativeConnectRequest__ID, (&(mState)));
1994 0 : if ((!(RecvSpeculativeConnectRequest()))) {
1995 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
1996 : // Error handled in mozilla::ipc::IPCResult
1997 0 : return MsgProcessingError;
1998 : }
1999 :
2000 0 : return MsgProcessed;
2001 : }
2002 : case PNecko::Msg_PTransportProviderConstructor__ID:
2003 : {
2004 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
2005 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
2006 : }
2007 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PTransportProviderConstructor", OTHER);
2008 :
2009 0 : PickleIterator iter__(msg__);
2010 : ActorHandle handle__;
2011 : PTransportProviderChild* actor;
2012 :
2013 0 : if ((!(Read((&(handle__)), (&(msg__)), (&(iter__)))))) {
2014 0 : FatalError("Error deserializing 'ActorHandle'");
2015 0 : return MsgValueError;
2016 : }
2017 : // Sentinel = 'actor'
2018 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
2019 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
2020 0 : return MsgValueError;
2021 : }
2022 0 : (msg__).EndRead(iter__, (msg__).type());
2023 0 : PNecko::Transition(PNecko::Msg_PTransportProviderConstructor__ID, (&(mState)));
2024 0 : actor = AllocPTransportProviderChild();
2025 0 : if ((!(actor))) {
2026 0 : NS_WARNING("Error constructing actor PTransportProviderChild");
2027 0 : return MsgValueError;
2028 : }
2029 0 : (actor)->SetManager(this);
2030 0 : RegisterID(actor, (handle__).mId);
2031 0 : (actor)->SetIPCChannel(GetIPCChannel());
2032 0 : (mManagedPTransportProviderChild).PutEntry(actor);
2033 0 : (actor)->mState = mozilla::net::PTransportProvider::__Start;
2034 :
2035 0 : if ((!(RecvPTransportProviderConstructor(mozilla::Move(actor))))) {
2036 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
2037 : // Error handled in mozilla::ipc::IPCResult
2038 0 : return MsgProcessingError;
2039 : }
2040 :
2041 0 : return MsgProcessed;
2042 : }
2043 : case PNecko::Reply_PTCPSocketConstructor__ID:
2044 : {
2045 0 : return MsgProcessed;
2046 : }
2047 : case PNecko::Msg_PTCPSocketConstructor__ID:
2048 : {
2049 0 : if (mozilla::ipc::LoggingEnabledFor("PNeckoChild")) {
2050 0 : mozilla::ipc::LogMessageForProtocol("PNeckoChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
2051 : }
2052 0 : AUTO_PROFILER_LABEL("PNecko::Msg_PTCPSocketConstructor", OTHER);
2053 :
2054 0 : PickleIterator iter__(msg__);
2055 : ActorHandle handle__;
2056 : PTCPSocketChild* actor;
2057 0 : nsString host;
2058 : uint16_t port;
2059 :
2060 0 : if ((!(Read((&(handle__)), (&(msg__)), (&(iter__)))))) {
2061 0 : FatalError("Error deserializing 'ActorHandle'");
2062 0 : return MsgValueError;
2063 : }
2064 : // Sentinel = 'actor'
2065 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
2066 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
2067 0 : return MsgValueError;
2068 : }
2069 0 : if ((!(Read((&(host)), (&(msg__)), (&(iter__)))))) {
2070 0 : FatalError("Error deserializing 'nsString'");
2071 0 : return MsgValueError;
2072 : }
2073 : // Sentinel = 'host'
2074 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4070301394)))) {
2075 0 : mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
2076 0 : return MsgValueError;
2077 : }
2078 0 : if ((!(Read((&(port)), (&(msg__)), (&(iter__)))))) {
2079 0 : FatalError("Error deserializing 'uint16_t'");
2080 0 : return MsgValueError;
2081 : }
2082 : // Sentinel = 'port'
2083 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3633211549)))) {
2084 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uint16_t'");
2085 0 : return MsgValueError;
2086 : }
2087 0 : (msg__).EndRead(iter__, (msg__).type());
2088 0 : PNecko::Transition(PNecko::Msg_PTCPSocketConstructor__ID, (&(mState)));
2089 0 : actor = AllocPTCPSocketChild(host, port);
2090 0 : if ((!(actor))) {
2091 0 : NS_WARNING("Error constructing actor PTCPSocketChild");
2092 0 : return MsgValueError;
2093 : }
2094 0 : (actor)->SetManager(this);
2095 0 : RegisterID(actor, (handle__).mId);
2096 0 : (actor)->SetIPCChannel(GetIPCChannel());
2097 0 : (mManagedPTCPSocketChild).PutEntry(actor);
2098 0 : (actor)->mState = mozilla::net::PTCPSocket::__Start;
2099 :
2100 0 : if ((!(RecvPTCPSocketConstructor(mozilla::Move(actor), mozilla::Move(host), mozilla::Move(port))))) {
2101 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
2102 : // Error handled in mozilla::ipc::IPCResult
2103 0 : return MsgProcessingError;
2104 : }
2105 :
2106 0 : return MsgProcessed;
2107 : }
2108 : default:
2109 : {
2110 0 : return MsgNotKnown;
2111 : }
2112 : }
2113 : }
2114 :
2115 0 : auto PNeckoChild::OnMessageReceived(
2116 : const Message& msg__,
2117 : Message*& reply__) -> PNeckoChild::Result
2118 : {
2119 0 : return MsgNotKnown;
2120 : }
2121 :
2122 0 : auto PNeckoChild::OnCallReceived(
2123 : const Message& msg__,
2124 : Message*& reply__) -> PNeckoChild::Result
2125 : {
2126 0 : MOZ_ASSERT_UNREACHABLE("message protocol not supported");
2127 : return MsgNotKnown;
2128 : }
2129 :
2130 0 : auto PNeckoChild::GetProtocolTypeId() -> int32_t
2131 : {
2132 0 : return PNeckoMsgStart;
2133 : }
2134 :
2135 0 : auto PNeckoChild::ProtocolName() const -> const char*
2136 : {
2137 0 : return "PNeckoChild";
2138 : }
2139 :
2140 0 : auto PNeckoChild::DestroySubtree(ActorDestroyReason why) -> void
2141 : {
2142 : // Unregister from our manager.
2143 0 : Unregister(Id());
2144 :
2145 0 : ActorDestroyReason subtreewhy = (((why) == (Deletion)) || ((why) == (FailedConstructor)) ? AncestorDeletion : why);
2146 :
2147 : {
2148 : // Recursively shutting down PHttpChannel kids
2149 0 : nsTArray<PHttpChannelChild*> kids;
2150 : // Accumulate kids into a stable structure to iterate over
2151 0 : ManagedPHttpChannelChild(kids);
2152 0 : for (auto& kid : kids) {
2153 : // Guarding against a child removing a sibling from the list during the iteration.
2154 0 : if ((mManagedPHttpChannelChild).Contains(kid)) {
2155 0 : (kid)->DestroySubtree(subtreewhy);
2156 : }
2157 : }
2158 : }
2159 : {
2160 : // Recursively shutting down PCookieService kids
2161 0 : nsTArray<PCookieServiceChild*> kids;
2162 : // Accumulate kids into a stable structure to iterate over
2163 0 : ManagedPCookieServiceChild(kids);
2164 0 : for (auto& kid : kids) {
2165 : // Guarding against a child removing a sibling from the list during the iteration.
2166 0 : if ((mManagedPCookieServiceChild).Contains(kid)) {
2167 0 : (kid)->DestroySubtree(subtreewhy);
2168 : }
2169 : }
2170 : }
2171 : {
2172 : // Recursively shutting down PWyciwygChannel kids
2173 0 : nsTArray<PWyciwygChannelChild*> kids;
2174 : // Accumulate kids into a stable structure to iterate over
2175 0 : ManagedPWyciwygChannelChild(kids);
2176 0 : for (auto& kid : kids) {
2177 : // Guarding against a child removing a sibling from the list during the iteration.
2178 0 : if ((mManagedPWyciwygChannelChild).Contains(kid)) {
2179 0 : (kid)->DestroySubtree(subtreewhy);
2180 : }
2181 : }
2182 : }
2183 : {
2184 : // Recursively shutting down PFTPChannel kids
2185 0 : nsTArray<PFTPChannelChild*> kids;
2186 : // Accumulate kids into a stable structure to iterate over
2187 0 : ManagedPFTPChannelChild(kids);
2188 0 : for (auto& kid : kids) {
2189 : // Guarding against a child removing a sibling from the list during the iteration.
2190 0 : if ((mManagedPFTPChannelChild).Contains(kid)) {
2191 0 : (kid)->DestroySubtree(subtreewhy);
2192 : }
2193 : }
2194 : }
2195 : {
2196 : // Recursively shutting down PWebSocket kids
2197 0 : nsTArray<PWebSocketChild*> kids;
2198 : // Accumulate kids into a stable structure to iterate over
2199 0 : ManagedPWebSocketChild(kids);
2200 0 : for (auto& kid : kids) {
2201 : // Guarding against a child removing a sibling from the list during the iteration.
2202 0 : if ((mManagedPWebSocketChild).Contains(kid)) {
2203 0 : (kid)->DestroySubtree(subtreewhy);
2204 : }
2205 : }
2206 : }
2207 : {
2208 : // Recursively shutting down PWebSocketEventListener kids
2209 0 : nsTArray<PWebSocketEventListenerChild*> kids;
2210 : // Accumulate kids into a stable structure to iterate over
2211 0 : ManagedPWebSocketEventListenerChild(kids);
2212 0 : for (auto& kid : kids) {
2213 : // Guarding against a child removing a sibling from the list during the iteration.
2214 0 : if ((mManagedPWebSocketEventListenerChild).Contains(kid)) {
2215 0 : (kid)->DestroySubtree(subtreewhy);
2216 : }
2217 : }
2218 : }
2219 : {
2220 : // Recursively shutting down PTCPSocket kids
2221 0 : nsTArray<PTCPSocketChild*> kids;
2222 : // Accumulate kids into a stable structure to iterate over
2223 0 : ManagedPTCPSocketChild(kids);
2224 0 : for (auto& kid : kids) {
2225 : // Guarding against a child removing a sibling from the list during the iteration.
2226 0 : if ((mManagedPTCPSocketChild).Contains(kid)) {
2227 0 : (kid)->DestroySubtree(subtreewhy);
2228 : }
2229 : }
2230 : }
2231 : {
2232 : // Recursively shutting down PTCPServerSocket kids
2233 0 : nsTArray<PTCPServerSocketChild*> kids;
2234 : // Accumulate kids into a stable structure to iterate over
2235 0 : ManagedPTCPServerSocketChild(kids);
2236 0 : for (auto& kid : kids) {
2237 : // Guarding against a child removing a sibling from the list during the iteration.
2238 0 : if ((mManagedPTCPServerSocketChild).Contains(kid)) {
2239 0 : (kid)->DestroySubtree(subtreewhy);
2240 : }
2241 : }
2242 : }
2243 : {
2244 : // Recursively shutting down PUDPSocket kids
2245 0 : nsTArray<PUDPSocketChild*> kids;
2246 : // Accumulate kids into a stable structure to iterate over
2247 0 : ManagedPUDPSocketChild(kids);
2248 0 : for (auto& kid : kids) {
2249 : // Guarding against a child removing a sibling from the list during the iteration.
2250 0 : if ((mManagedPUDPSocketChild).Contains(kid)) {
2251 0 : (kid)->DestroySubtree(subtreewhy);
2252 : }
2253 : }
2254 : }
2255 : {
2256 : // Recursively shutting down PDNSRequest kids
2257 0 : nsTArray<PDNSRequestChild*> kids;
2258 : // Accumulate kids into a stable structure to iterate over
2259 0 : ManagedPDNSRequestChild(kids);
2260 0 : for (auto& kid : kids) {
2261 : // Guarding against a child removing a sibling from the list during the iteration.
2262 0 : if ((mManagedPDNSRequestChild).Contains(kid)) {
2263 0 : (kid)->DestroySubtree(subtreewhy);
2264 : }
2265 : }
2266 : }
2267 : {
2268 : // Recursively shutting down PDataChannel kids
2269 0 : nsTArray<PDataChannelChild*> kids;
2270 : // Accumulate kids into a stable structure to iterate over
2271 0 : ManagedPDataChannelChild(kids);
2272 0 : for (auto& kid : kids) {
2273 : // Guarding against a child removing a sibling from the list during the iteration.
2274 0 : if ((mManagedPDataChannelChild).Contains(kid)) {
2275 0 : (kid)->DestroySubtree(subtreewhy);
2276 : }
2277 : }
2278 : }
2279 : {
2280 : // Recursively shutting down PFileChannel kids
2281 0 : nsTArray<PFileChannelChild*> kids;
2282 : // Accumulate kids into a stable structure to iterate over
2283 0 : ManagedPFileChannelChild(kids);
2284 0 : for (auto& kid : kids) {
2285 : // Guarding against a child removing a sibling from the list during the iteration.
2286 0 : if ((mManagedPFileChannelChild).Contains(kid)) {
2287 0 : (kid)->DestroySubtree(subtreewhy);
2288 : }
2289 : }
2290 : }
2291 : {
2292 : // Recursively shutting down PRtspController kids
2293 0 : nsTArray<PRtspControllerChild*> kids;
2294 : // Accumulate kids into a stable structure to iterate over
2295 0 : ManagedPRtspControllerChild(kids);
2296 0 : for (auto& kid : kids) {
2297 : // Guarding against a child removing a sibling from the list during the iteration.
2298 0 : if ((mManagedPRtspControllerChild).Contains(kid)) {
2299 0 : (kid)->DestroySubtree(subtreewhy);
2300 : }
2301 : }
2302 : }
2303 : {
2304 : // Recursively shutting down PRtspChannel kids
2305 0 : nsTArray<PRtspChannelChild*> kids;
2306 : // Accumulate kids into a stable structure to iterate over
2307 0 : ManagedPRtspChannelChild(kids);
2308 0 : for (auto& kid : kids) {
2309 : // Guarding against a child removing a sibling from the list during the iteration.
2310 0 : if ((mManagedPRtspChannelChild).Contains(kid)) {
2311 0 : (kid)->DestroySubtree(subtreewhy);
2312 : }
2313 : }
2314 : }
2315 : {
2316 : // Recursively shutting down PChannelDiverter kids
2317 0 : nsTArray<PChannelDiverterChild*> kids;
2318 : // Accumulate kids into a stable structure to iterate over
2319 0 : ManagedPChannelDiverterChild(kids);
2320 0 : for (auto& kid : kids) {
2321 : // Guarding against a child removing a sibling from the list during the iteration.
2322 0 : if ((mManagedPChannelDiverterChild).Contains(kid)) {
2323 0 : (kid)->DestroySubtree(subtreewhy);
2324 : }
2325 : }
2326 : }
2327 : {
2328 : // Recursively shutting down PTransportProvider kids
2329 0 : nsTArray<PTransportProviderChild*> kids;
2330 : // Accumulate kids into a stable structure to iterate over
2331 0 : ManagedPTransportProviderChild(kids);
2332 0 : for (auto& kid : kids) {
2333 : // Guarding against a child removing a sibling from the list during the iteration.
2334 0 : if ((mManagedPTransportProviderChild).Contains(kid)) {
2335 0 : (kid)->DestroySubtree(subtreewhy);
2336 : }
2337 : }
2338 : }
2339 : {
2340 : // Recursively shutting down PAltDataOutputStream kids
2341 0 : nsTArray<PAltDataOutputStreamChild*> kids;
2342 : // Accumulate kids into a stable structure to iterate over
2343 0 : ManagedPAltDataOutputStreamChild(kids);
2344 0 : for (auto& kid : kids) {
2345 : // Guarding against a child removing a sibling from the list during the iteration.
2346 0 : if ((mManagedPAltDataOutputStreamChild).Contains(kid)) {
2347 0 : (kid)->DestroySubtree(subtreewhy);
2348 : }
2349 : }
2350 : }
2351 : {
2352 : // Recursively shutting down PStunAddrsRequest kids
2353 0 : nsTArray<PStunAddrsRequestChild*> kids;
2354 : // Accumulate kids into a stable structure to iterate over
2355 0 : ManagedPStunAddrsRequestChild(kids);
2356 0 : for (auto& kid : kids) {
2357 : // Guarding against a child removing a sibling from the list during the iteration.
2358 0 : if ((mManagedPStunAddrsRequestChild).Contains(kid)) {
2359 0 : (kid)->DestroySubtree(subtreewhy);
2360 : }
2361 : }
2362 : }
2363 :
2364 : // Reject owning pending promises.
2365 0 : (GetIPCChannel())->RejectPendingPromisesForActor(this);
2366 :
2367 : // Finally, destroy "us".
2368 0 : ActorDestroy(why);
2369 0 : }
2370 :
2371 0 : auto PNeckoChild::DeallocSubtree() -> void
2372 : {
2373 : {
2374 : // Recursively deleting PHttpChannel kids
2375 0 : for (auto iter = (mManagedPHttpChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2376 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2377 : }
2378 :
2379 0 : for (auto iter = (mManagedPHttpChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2380 0 : DeallocPHttpChannelChild(((iter).Get())->GetKey());
2381 : }
2382 0 : (mManagedPHttpChannelChild).Clear();
2383 : }
2384 : {
2385 : // Recursively deleting PCookieService kids
2386 0 : for (auto iter = (mManagedPCookieServiceChild).Iter(); (!((iter).Done())); (iter).Next()) {
2387 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2388 : }
2389 :
2390 0 : for (auto iter = (mManagedPCookieServiceChild).Iter(); (!((iter).Done())); (iter).Next()) {
2391 0 : DeallocPCookieServiceChild(((iter).Get())->GetKey());
2392 : }
2393 0 : (mManagedPCookieServiceChild).Clear();
2394 : }
2395 : {
2396 : // Recursively deleting PWyciwygChannel kids
2397 0 : for (auto iter = (mManagedPWyciwygChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2398 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2399 : }
2400 :
2401 0 : for (auto iter = (mManagedPWyciwygChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2402 0 : DeallocPWyciwygChannelChild(((iter).Get())->GetKey());
2403 : }
2404 0 : (mManagedPWyciwygChannelChild).Clear();
2405 : }
2406 : {
2407 : // Recursively deleting PFTPChannel kids
2408 0 : for (auto iter = (mManagedPFTPChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2409 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2410 : }
2411 :
2412 0 : for (auto iter = (mManagedPFTPChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2413 0 : DeallocPFTPChannelChild(((iter).Get())->GetKey());
2414 : }
2415 0 : (mManagedPFTPChannelChild).Clear();
2416 : }
2417 : {
2418 : // Recursively deleting PWebSocket kids
2419 0 : for (auto iter = (mManagedPWebSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
2420 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2421 : }
2422 :
2423 0 : for (auto iter = (mManagedPWebSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
2424 0 : DeallocPWebSocketChild(((iter).Get())->GetKey());
2425 : }
2426 0 : (mManagedPWebSocketChild).Clear();
2427 : }
2428 : {
2429 : // Recursively deleting PWebSocketEventListener kids
2430 0 : for (auto iter = (mManagedPWebSocketEventListenerChild).Iter(); (!((iter).Done())); (iter).Next()) {
2431 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2432 : }
2433 :
2434 0 : for (auto iter = (mManagedPWebSocketEventListenerChild).Iter(); (!((iter).Done())); (iter).Next()) {
2435 0 : DeallocPWebSocketEventListenerChild(((iter).Get())->GetKey());
2436 : }
2437 0 : (mManagedPWebSocketEventListenerChild).Clear();
2438 : }
2439 : {
2440 : // Recursively deleting PTCPSocket kids
2441 0 : for (auto iter = (mManagedPTCPSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
2442 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2443 : }
2444 :
2445 0 : for (auto iter = (mManagedPTCPSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
2446 0 : DeallocPTCPSocketChild(((iter).Get())->GetKey());
2447 : }
2448 0 : (mManagedPTCPSocketChild).Clear();
2449 : }
2450 : {
2451 : // Recursively deleting PTCPServerSocket kids
2452 0 : for (auto iter = (mManagedPTCPServerSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
2453 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2454 : }
2455 :
2456 0 : for (auto iter = (mManagedPTCPServerSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
2457 0 : DeallocPTCPServerSocketChild(((iter).Get())->GetKey());
2458 : }
2459 0 : (mManagedPTCPServerSocketChild).Clear();
2460 : }
2461 : {
2462 : // Recursively deleting PUDPSocket kids
2463 0 : for (auto iter = (mManagedPUDPSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
2464 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2465 : }
2466 :
2467 0 : for (auto iter = (mManagedPUDPSocketChild).Iter(); (!((iter).Done())); (iter).Next()) {
2468 0 : DeallocPUDPSocketChild(((iter).Get())->GetKey());
2469 : }
2470 0 : (mManagedPUDPSocketChild).Clear();
2471 : }
2472 : {
2473 : // Recursively deleting PDNSRequest kids
2474 0 : for (auto iter = (mManagedPDNSRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
2475 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2476 : }
2477 :
2478 0 : for (auto iter = (mManagedPDNSRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
2479 0 : DeallocPDNSRequestChild(((iter).Get())->GetKey());
2480 : }
2481 0 : (mManagedPDNSRequestChild).Clear();
2482 : }
2483 : {
2484 : // Recursively deleting PDataChannel kids
2485 0 : for (auto iter = (mManagedPDataChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2486 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2487 : }
2488 :
2489 0 : for (auto iter = (mManagedPDataChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2490 0 : DeallocPDataChannelChild(((iter).Get())->GetKey());
2491 : }
2492 0 : (mManagedPDataChannelChild).Clear();
2493 : }
2494 : {
2495 : // Recursively deleting PFileChannel kids
2496 0 : for (auto iter = (mManagedPFileChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2497 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2498 : }
2499 :
2500 0 : for (auto iter = (mManagedPFileChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2501 0 : DeallocPFileChannelChild(((iter).Get())->GetKey());
2502 : }
2503 0 : (mManagedPFileChannelChild).Clear();
2504 : }
2505 : {
2506 : // Recursively deleting PRtspController kids
2507 0 : for (auto iter = (mManagedPRtspControllerChild).Iter(); (!((iter).Done())); (iter).Next()) {
2508 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2509 : }
2510 :
2511 0 : for (auto iter = (mManagedPRtspControllerChild).Iter(); (!((iter).Done())); (iter).Next()) {
2512 0 : DeallocPRtspControllerChild(((iter).Get())->GetKey());
2513 : }
2514 0 : (mManagedPRtspControllerChild).Clear();
2515 : }
2516 : {
2517 : // Recursively deleting PRtspChannel kids
2518 0 : for (auto iter = (mManagedPRtspChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2519 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2520 : }
2521 :
2522 0 : for (auto iter = (mManagedPRtspChannelChild).Iter(); (!((iter).Done())); (iter).Next()) {
2523 0 : DeallocPRtspChannelChild(((iter).Get())->GetKey());
2524 : }
2525 0 : (mManagedPRtspChannelChild).Clear();
2526 : }
2527 : {
2528 : // Recursively deleting PChannelDiverter kids
2529 0 : for (auto iter = (mManagedPChannelDiverterChild).Iter(); (!((iter).Done())); (iter).Next()) {
2530 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2531 : }
2532 :
2533 0 : for (auto iter = (mManagedPChannelDiverterChild).Iter(); (!((iter).Done())); (iter).Next()) {
2534 0 : DeallocPChannelDiverterChild(((iter).Get())->GetKey());
2535 : }
2536 0 : (mManagedPChannelDiverterChild).Clear();
2537 : }
2538 : {
2539 : // Recursively deleting PTransportProvider kids
2540 0 : for (auto iter = (mManagedPTransportProviderChild).Iter(); (!((iter).Done())); (iter).Next()) {
2541 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2542 : }
2543 :
2544 0 : for (auto iter = (mManagedPTransportProviderChild).Iter(); (!((iter).Done())); (iter).Next()) {
2545 0 : DeallocPTransportProviderChild(((iter).Get())->GetKey());
2546 : }
2547 0 : (mManagedPTransportProviderChild).Clear();
2548 : }
2549 : {
2550 : // Recursively deleting PAltDataOutputStream kids
2551 0 : for (auto iter = (mManagedPAltDataOutputStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
2552 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2553 : }
2554 :
2555 0 : for (auto iter = (mManagedPAltDataOutputStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
2556 0 : DeallocPAltDataOutputStreamChild(((iter).Get())->GetKey());
2557 : }
2558 0 : (mManagedPAltDataOutputStreamChild).Clear();
2559 : }
2560 : {
2561 : // Recursively deleting PStunAddrsRequest kids
2562 0 : for (auto iter = (mManagedPStunAddrsRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
2563 0 : (((iter).Get())->GetKey())->DeallocSubtree();
2564 : }
2565 :
2566 0 : for (auto iter = (mManagedPStunAddrsRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
2567 0 : DeallocPStunAddrsRequestChild(((iter).Get())->GetKey());
2568 : }
2569 0 : (mManagedPStunAddrsRequestChild).Clear();
2570 : }
2571 0 : }
2572 :
2573 1 : auto PNeckoChild::Write(
2574 : const SystemPrincipalInfo& v__,
2575 : Message* msg__) -> void
2576 : {
2577 1 : }
2578 :
2579 0 : auto PNeckoChild::Read(
2580 : SystemPrincipalInfo* v__,
2581 : const Message* msg__,
2582 : PickleIterator* iter__) -> bool
2583 : {
2584 0 : return true;
2585 : }
2586 :
2587 0 : auto PNeckoChild::Write(
2588 : const nsTArray<PrincipalInfo>& v__,
2589 : Message* msg__) -> void
2590 : {
2591 0 : uint32_t length = (v__).Length();
2592 0 : Write(length, msg__);
2593 : // Sentinel = ('length', 'PrincipalInfo[]')
2594 0 : (msg__)->WriteSentinel(1032188126);
2595 :
2596 0 : for (auto& elem : v__) {
2597 0 : Write(elem, msg__);
2598 : // Sentinel = 'PrincipalInfo[]'
2599 0 : (msg__)->WriteSentinel(413380193);
2600 : }
2601 0 : }
2602 :
2603 0 : auto PNeckoChild::Read(
2604 : nsTArray<PrincipalInfo>* v__,
2605 : const Message* msg__,
2606 : PickleIterator* iter__) -> bool
2607 : {
2608 0 : nsTArray<PrincipalInfo> fa;
2609 : uint32_t length;
2610 0 : if ((!(Read((&(length)), msg__, iter__)))) {
2611 0 : mozilla::ipc::ArrayLengthReadError("PrincipalInfo[]");
2612 0 : return false;
2613 : }
2614 : // Sentinel = ('length', 'PrincipalInfo[]')
2615 0 : if ((!((msg__)->ReadSentinel(iter__, 1032188126)))) {
2616 0 : mozilla::ipc::SentinelReadError("PrincipalInfo[]");
2617 0 : return false;
2618 : }
2619 :
2620 0 : PrincipalInfo* elems = (fa).AppendElements(length);
2621 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
2622 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
2623 0 : FatalError("Error deserializing 'PrincipalInfo[i]'");
2624 0 : return false;
2625 : }
2626 : // Sentinel = 'PrincipalInfo[]'
2627 0 : if ((!((msg__)->ReadSentinel(iter__, 413380193)))) {
2628 0 : mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo[i]'");
2629 0 : return false;
2630 : }
2631 : }
2632 0 : (v__)->SwapElements(fa);
2633 0 : return true;
2634 : }
2635 :
2636 0 : auto PNeckoChild::Write(
2637 : const PDNSRequestChild* v__,
2638 : Message* msg__,
2639 : bool nullable__) -> void
2640 : {
2641 : int32_t id;
2642 0 : if ((!(v__))) {
2643 0 : if ((!(nullable__))) {
2644 0 : FatalError("NULL actor value passed to non-nullable param");
2645 : }
2646 0 : id = 0;
2647 : }
2648 : else {
2649 0 : id = (v__)->Id();
2650 0 : if ((1) == (id)) {
2651 0 : FatalError("actor has been |delete|d");
2652 : }
2653 : }
2654 :
2655 0 : Write(id, msg__);
2656 0 : }
2657 :
2658 0 : auto PNeckoChild::Read(
2659 : PDNSRequestChild** v__,
2660 : const Message* msg__,
2661 : PickleIterator* iter__,
2662 : bool nullable__) -> bool
2663 : {
2664 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PDNSRequest", PDNSRequestMsgStart);
2665 0 : if ((actor).isNothing()) {
2666 0 : return false;
2667 : }
2668 :
2669 0 : (*(v__)) = static_cast<PDNSRequestChild*>((actor).value());
2670 0 : return true;
2671 : }
2672 :
2673 0 : auto PNeckoChild::Write(
2674 : const IPCBlobInputStreamParams& v__,
2675 : Message* msg__) -> void
2676 : {
2677 0 : Write((v__).id(), msg__);
2678 : // Sentinel = 'id'
2679 0 : (msg__)->WriteSentinel(2794505629);
2680 0 : }
2681 :
2682 0 : auto PNeckoChild::Read(
2683 : IPCBlobInputStreamParams* v__,
2684 : const Message* msg__,
2685 : PickleIterator* iter__) -> bool
2686 : {
2687 0 : if ((!(Read((&((v__)->id())), msg__, iter__)))) {
2688 0 : FatalError("Error deserializing 'id' (nsID) member of 'IPCBlobInputStreamParams'");
2689 0 : return false;
2690 : }
2691 : // Sentinel = 'id'
2692 0 : if ((!((msg__)->ReadSentinel(iter__, 2794505629)))) {
2693 0 : mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsID) member of 'IPCBlobInputStreamParams'");
2694 0 : return false;
2695 : }
2696 0 : return true;
2697 : }
2698 :
2699 0 : auto PNeckoChild::Write(
2700 : const FTPChannelCreationArgs& v__,
2701 : Message* msg__) -> void
2702 : {
2703 : typedef FTPChannelCreationArgs type__;
2704 0 : Write(int((v__).type()), msg__);
2705 : // Sentinel = 'FTPChannelCreationArgs'
2706 0 : (msg__)->WriteSentinel(1911741737);
2707 :
2708 0 : switch ((v__).type()) {
2709 : case type__::TFTPChannelOpenArgs:
2710 : {
2711 0 : Write((v__).get_FTPChannelOpenArgs(), msg__);
2712 : // Sentinel = 'TFTPChannelOpenArgs'
2713 0 : (msg__)->WriteSentinel(1536686851);
2714 0 : return;
2715 : }
2716 : case type__::TFTPChannelConnectArgs:
2717 : {
2718 0 : Write((v__).get_FTPChannelConnectArgs(), msg__);
2719 : // Sentinel = 'TFTPChannelConnectArgs'
2720 0 : (msg__)->WriteSentinel(3182840870);
2721 0 : return;
2722 : }
2723 : default:
2724 : {
2725 0 : FatalError("unknown union type");
2726 0 : return;
2727 : }
2728 : }
2729 : }
2730 :
2731 0 : auto PNeckoChild::Read(
2732 : FTPChannelCreationArgs* v__,
2733 : const Message* msg__,
2734 : PickleIterator* iter__) -> bool
2735 : {
2736 : typedef FTPChannelCreationArgs type__;
2737 : int type;
2738 0 : if ((!(Read((&(type)), msg__, iter__)))) {
2739 0 : mozilla::ipc::UnionTypeReadError("FTPChannelCreationArgs");
2740 0 : return false;
2741 : }
2742 : // Sentinel = 'FTPChannelCreationArgs'
2743 0 : if ((!((msg__)->ReadSentinel(iter__, 1911741737)))) {
2744 0 : mozilla::ipc::SentinelReadError("FTPChannelCreationArgs");
2745 0 : return false;
2746 : }
2747 :
2748 0 : switch (type) {
2749 : case type__::TFTPChannelOpenArgs:
2750 : {
2751 0 : FTPChannelOpenArgs tmp = FTPChannelOpenArgs();
2752 0 : (*(v__)) = tmp;
2753 0 : if ((!(Read((&((v__)->get_FTPChannelOpenArgs())), msg__, iter__)))) {
2754 0 : FatalError("Error deserializing Union type");
2755 0 : return false;
2756 : }
2757 : // Sentinel = 'TFTPChannelOpenArgs'
2758 0 : if ((!((msg__)->ReadSentinel(iter__, 1536686851)))) {
2759 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2760 0 : return false;
2761 : }
2762 0 : return true;
2763 : }
2764 : case type__::TFTPChannelConnectArgs:
2765 : {
2766 0 : FTPChannelConnectArgs tmp = FTPChannelConnectArgs();
2767 0 : (*(v__)) = tmp;
2768 0 : if ((!(Read((&((v__)->get_FTPChannelConnectArgs())), msg__, iter__)))) {
2769 0 : FatalError("Error deserializing Union type");
2770 0 : return false;
2771 : }
2772 : // Sentinel = 'TFTPChannelConnectArgs'
2773 0 : if ((!((msg__)->ReadSentinel(iter__, 3182840870)))) {
2774 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2775 0 : return false;
2776 : }
2777 0 : return true;
2778 : }
2779 : default:
2780 : {
2781 0 : FatalError("unknown union type");
2782 0 : return false;
2783 : }
2784 : }
2785 : }
2786 :
2787 0 : auto PNeckoChild::Write(
2788 : const nsTArray<InputStreamParams>& v__,
2789 : Message* msg__) -> void
2790 : {
2791 0 : uint32_t length = (v__).Length();
2792 0 : Write(length, msg__);
2793 : // Sentinel = ('length', 'InputStreamParams[]')
2794 0 : (msg__)->WriteSentinel(348334258);
2795 :
2796 0 : for (auto& elem : v__) {
2797 0 : Write(elem, msg__);
2798 : // Sentinel = 'InputStreamParams[]'
2799 0 : (msg__)->WriteSentinel(2927715197);
2800 : }
2801 0 : }
2802 :
2803 0 : auto PNeckoChild::Read(
2804 : nsTArray<InputStreamParams>* v__,
2805 : const Message* msg__,
2806 : PickleIterator* iter__) -> bool
2807 : {
2808 0 : nsTArray<InputStreamParams> fa;
2809 : uint32_t length;
2810 0 : if ((!(Read((&(length)), msg__, iter__)))) {
2811 0 : mozilla::ipc::ArrayLengthReadError("InputStreamParams[]");
2812 0 : return false;
2813 : }
2814 : // Sentinel = ('length', 'InputStreamParams[]')
2815 0 : if ((!((msg__)->ReadSentinel(iter__, 348334258)))) {
2816 0 : mozilla::ipc::SentinelReadError("InputStreamParams[]");
2817 0 : return false;
2818 : }
2819 :
2820 0 : InputStreamParams* elems = (fa).AppendElements(length);
2821 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
2822 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
2823 0 : FatalError("Error deserializing 'InputStreamParams[i]'");
2824 0 : return false;
2825 : }
2826 : // Sentinel = 'InputStreamParams[]'
2827 0 : if ((!((msg__)->ReadSentinel(iter__, 2927715197)))) {
2828 0 : mozilla::ipc::SentinelReadError("Error deserializing 'InputStreamParams[i]'");
2829 0 : return false;
2830 : }
2831 : }
2832 0 : (v__)->SwapElements(fa);
2833 0 : return true;
2834 : }
2835 :
2836 23 : auto PNeckoChild::Write(
2837 : const OptionalURIParams& v__,
2838 : Message* msg__) -> void
2839 : {
2840 : typedef OptionalURIParams type__;
2841 23 : Write(int((v__).type()), msg__);
2842 : // Sentinel = 'OptionalURIParams'
2843 23 : (msg__)->WriteSentinel(1977079525);
2844 :
2845 23 : switch ((v__).type()) {
2846 : case type__::Tvoid_t:
2847 : {
2848 12 : Write((v__).get_void_t(), msg__);
2849 : // Sentinel = 'Tvoid_t'
2850 12 : (msg__)->WriteSentinel(3041273328);
2851 12 : return;
2852 : }
2853 : case type__::TURIParams:
2854 : {
2855 11 : Write((v__).get_URIParams(), msg__);
2856 : // Sentinel = 'TURIParams'
2857 11 : (msg__)->WriteSentinel(1132652062);
2858 11 : return;
2859 : }
2860 : default:
2861 : {
2862 0 : FatalError("unknown union type");
2863 0 : return;
2864 : }
2865 : }
2866 : }
2867 :
2868 0 : auto PNeckoChild::Read(
2869 : OptionalURIParams* v__,
2870 : const Message* msg__,
2871 : PickleIterator* iter__) -> bool
2872 : {
2873 : typedef OptionalURIParams type__;
2874 : int type;
2875 0 : if ((!(Read((&(type)), msg__, iter__)))) {
2876 0 : mozilla::ipc::UnionTypeReadError("OptionalURIParams");
2877 0 : return false;
2878 : }
2879 : // Sentinel = 'OptionalURIParams'
2880 0 : if ((!((msg__)->ReadSentinel(iter__, 1977079525)))) {
2881 0 : mozilla::ipc::SentinelReadError("OptionalURIParams");
2882 0 : return false;
2883 : }
2884 :
2885 0 : switch (type) {
2886 : case type__::Tvoid_t:
2887 : {
2888 : void_t tmp = void_t();
2889 0 : (*(v__)) = tmp;
2890 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
2891 0 : FatalError("Error deserializing Union type");
2892 0 : return false;
2893 : }
2894 : // Sentinel = 'Tvoid_t'
2895 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
2896 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2897 0 : return false;
2898 : }
2899 0 : return true;
2900 : }
2901 : case type__::TURIParams:
2902 : {
2903 0 : URIParams tmp = URIParams();
2904 0 : (*(v__)) = tmp;
2905 0 : if ((!(Read((&((v__)->get_URIParams())), msg__, iter__)))) {
2906 0 : FatalError("Error deserializing Union type");
2907 0 : return false;
2908 : }
2909 : // Sentinel = 'TURIParams'
2910 0 : if ((!((msg__)->ReadSentinel(iter__, 1132652062)))) {
2911 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2912 0 : return false;
2913 : }
2914 0 : return true;
2915 : }
2916 : default:
2917 : {
2918 0 : FatalError("unknown union type");
2919 0 : return false;
2920 : }
2921 : }
2922 : }
2923 :
2924 0 : auto PNeckoChild::Write(
2925 : const PWyciwygChannelChild* v__,
2926 : Message* msg__,
2927 : bool nullable__) -> void
2928 : {
2929 : int32_t id;
2930 0 : if ((!(v__))) {
2931 0 : if ((!(nullable__))) {
2932 0 : FatalError("NULL actor value passed to non-nullable param");
2933 : }
2934 0 : id = 0;
2935 : }
2936 : else {
2937 0 : id = (v__)->Id();
2938 0 : if ((1) == (id)) {
2939 0 : FatalError("actor has been |delete|d");
2940 : }
2941 : }
2942 :
2943 0 : Write(id, msg__);
2944 0 : }
2945 :
2946 0 : auto PNeckoChild::Read(
2947 : PWyciwygChannelChild** v__,
2948 : const Message* msg__,
2949 : PickleIterator* iter__,
2950 : bool nullable__) -> bool
2951 : {
2952 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PWyciwygChannel", PWyciwygChannelMsgStart);
2953 0 : if ((actor).isNothing()) {
2954 0 : return false;
2955 : }
2956 :
2957 0 : (*(v__)) = static_cast<PWyciwygChannelChild*>((actor).value());
2958 0 : return true;
2959 : }
2960 :
2961 4 : auto PNeckoChild::Write(
2962 : const ContentPrincipalInfoOriginNoSuffix& v__,
2963 : Message* msg__) -> void
2964 : {
2965 : typedef ContentPrincipalInfoOriginNoSuffix type__;
2966 4 : Write(int((v__).type()), msg__);
2967 : // Sentinel = 'ContentPrincipalInfoOriginNoSuffix'
2968 4 : (msg__)->WriteSentinel(2442066713);
2969 :
2970 4 : switch ((v__).type()) {
2971 : case type__::TnsCString:
2972 : {
2973 4 : Write((v__).get_nsCString(), msg__);
2974 : // Sentinel = 'TnsCString'
2975 4 : (msg__)->WriteSentinel(2427411293);
2976 4 : return;
2977 : }
2978 : case type__::Tvoid_t:
2979 : {
2980 0 : Write((v__).get_void_t(), msg__);
2981 : // Sentinel = 'Tvoid_t'
2982 0 : (msg__)->WriteSentinel(3041273328);
2983 0 : return;
2984 : }
2985 : default:
2986 : {
2987 0 : FatalError("unknown union type");
2988 0 : return;
2989 : }
2990 : }
2991 : }
2992 :
2993 0 : auto PNeckoChild::Read(
2994 : ContentPrincipalInfoOriginNoSuffix* v__,
2995 : const Message* msg__,
2996 : PickleIterator* iter__) -> bool
2997 : {
2998 : typedef ContentPrincipalInfoOriginNoSuffix type__;
2999 : int type;
3000 0 : if ((!(Read((&(type)), msg__, iter__)))) {
3001 0 : mozilla::ipc::UnionTypeReadError("ContentPrincipalInfoOriginNoSuffix");
3002 0 : return false;
3003 : }
3004 : // Sentinel = 'ContentPrincipalInfoOriginNoSuffix'
3005 0 : if ((!((msg__)->ReadSentinel(iter__, 2442066713)))) {
3006 0 : mozilla::ipc::SentinelReadError("ContentPrincipalInfoOriginNoSuffix");
3007 0 : return false;
3008 : }
3009 :
3010 0 : switch (type) {
3011 : case type__::TnsCString:
3012 : {
3013 0 : nsCString tmp = nsCString();
3014 0 : (*(v__)) = tmp;
3015 0 : if ((!(Read((&((v__)->get_nsCString())), msg__, iter__)))) {
3016 0 : FatalError("Error deserializing Union type");
3017 0 : return false;
3018 : }
3019 : // Sentinel = 'TnsCString'
3020 0 : if ((!((msg__)->ReadSentinel(iter__, 2427411293)))) {
3021 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3022 0 : return false;
3023 : }
3024 0 : return true;
3025 : }
3026 : case type__::Tvoid_t:
3027 : {
3028 : void_t tmp = void_t();
3029 0 : (*(v__)) = tmp;
3030 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
3031 0 : FatalError("Error deserializing Union type");
3032 0 : return false;
3033 : }
3034 : // Sentinel = 'Tvoid_t'
3035 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
3036 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3037 0 : return false;
3038 : }
3039 0 : return true;
3040 : }
3041 : default:
3042 : {
3043 0 : FatalError("unknown union type");
3044 0 : return false;
3045 : }
3046 : }
3047 : }
3048 :
3049 0 : auto PNeckoChild::Write(
3050 : const PTCPSocketChild* v__,
3051 : Message* msg__,
3052 : bool nullable__) -> void
3053 : {
3054 : int32_t id;
3055 0 : if ((!(v__))) {
3056 0 : if ((!(nullable__))) {
3057 0 : FatalError("NULL actor value passed to non-nullable param");
3058 : }
3059 0 : id = 0;
3060 : }
3061 : else {
3062 0 : id = (v__)->Id();
3063 0 : if ((1) == (id)) {
3064 0 : FatalError("actor has been |delete|d");
3065 : }
3066 : }
3067 :
3068 0 : Write(id, msg__);
3069 0 : }
3070 :
3071 0 : auto PNeckoChild::Read(
3072 : PTCPSocketChild** v__,
3073 : const Message* msg__,
3074 : PickleIterator* iter__,
3075 : bool nullable__) -> bool
3076 : {
3077 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PTCPSocket", PTCPSocketMsgStart);
3078 0 : if ((actor).isNothing()) {
3079 0 : return false;
3080 : }
3081 :
3082 0 : (*(v__)) = static_cast<PTCPSocketChild*>((actor).value());
3083 0 : return true;
3084 : }
3085 :
3086 17 : auto PNeckoChild::Write(
3087 : const StandardURLParams& v__,
3088 : Message* msg__) -> void
3089 : {
3090 17 : Write((v__).urlType(), msg__);
3091 : // Sentinel = 'urlType'
3092 17 : (msg__)->WriteSentinel(4149428228);
3093 17 : Write((v__).port(), msg__);
3094 : // Sentinel = 'port'
3095 17 : (msg__)->WriteSentinel(3633211549);
3096 17 : Write((v__).defaultPort(), msg__);
3097 : // Sentinel = 'defaultPort'
3098 17 : (msg__)->WriteSentinel(599318897);
3099 17 : Write((v__).spec(), msg__);
3100 : // Sentinel = 'spec'
3101 17 : (msg__)->WriteSentinel(1630740541);
3102 17 : Write((v__).scheme(), msg__);
3103 : // Sentinel = 'scheme'
3104 17 : (msg__)->WriteSentinel(3619238715);
3105 17 : Write((v__).authority(), msg__);
3106 : // Sentinel = 'authority'
3107 17 : (msg__)->WriteSentinel(1669684878);
3108 17 : Write((v__).username(), msg__);
3109 : // Sentinel = 'username'
3110 17 : (msg__)->WriteSentinel(689225024);
3111 17 : Write((v__).password(), msg__);
3112 : // Sentinel = 'password'
3113 17 : (msg__)->WriteSentinel(2527534683);
3114 17 : Write((v__).host(), msg__);
3115 : // Sentinel = 'host'
3116 17 : (msg__)->WriteSentinel(4070301394);
3117 17 : Write((v__).path(), msg__);
3118 : // Sentinel = 'path'
3119 17 : (msg__)->WriteSentinel(913629401);
3120 17 : Write((v__).filePath(), msg__);
3121 : // Sentinel = 'filePath'
3122 17 : (msg__)->WriteSentinel(4122896455);
3123 17 : Write((v__).directory(), msg__);
3124 : // Sentinel = 'directory'
3125 17 : (msg__)->WriteSentinel(1201172472);
3126 17 : Write((v__).baseName(), msg__);
3127 : // Sentinel = 'baseName'
3128 17 : (msg__)->WriteSentinel(2448877418);
3129 17 : Write((v__).extension(), msg__);
3130 : // Sentinel = 'extension'
3131 17 : (msg__)->WriteSentinel(3211853542);
3132 17 : Write((v__).query(), msg__);
3133 : // Sentinel = 'query'
3134 17 : (msg__)->WriteSentinel(4249802777);
3135 17 : Write((v__).ref(), msg__);
3136 : // Sentinel = 'ref'
3137 17 : (msg__)->WriteSentinel(2626476732);
3138 17 : Write((v__).originCharset(), msg__);
3139 : // Sentinel = 'originCharset'
3140 17 : (msg__)->WriteSentinel(1320725495);
3141 17 : Write((v__).isMutable(), msg__);
3142 : // Sentinel = 'isMutable'
3143 17 : (msg__)->WriteSentinel(3552466783);
3144 17 : Write((v__).supportsFileURL(), msg__);
3145 : // Sentinel = 'supportsFileURL'
3146 17 : (msg__)->WriteSentinel(1871785710);
3147 17 : }
3148 :
3149 0 : auto PNeckoChild::Read(
3150 : StandardURLParams* v__,
3151 : const Message* msg__,
3152 : PickleIterator* iter__) -> bool
3153 : {
3154 0 : if ((!(Read((&((v__)->urlType())), msg__, iter__)))) {
3155 0 : FatalError("Error deserializing 'urlType' (uint32_t) member of 'StandardURLParams'");
3156 0 : return false;
3157 : }
3158 : // Sentinel = 'urlType'
3159 0 : if ((!((msg__)->ReadSentinel(iter__, 4149428228)))) {
3160 0 : mozilla::ipc::SentinelReadError("Error deserializing 'urlType' (uint32_t) member of 'StandardURLParams'");
3161 0 : return false;
3162 : }
3163 0 : if ((!(Read((&((v__)->port())), msg__, iter__)))) {
3164 0 : FatalError("Error deserializing 'port' (int32_t) member of 'StandardURLParams'");
3165 0 : return false;
3166 : }
3167 : // Sentinel = 'port'
3168 0 : if ((!((msg__)->ReadSentinel(iter__, 3633211549)))) {
3169 0 : mozilla::ipc::SentinelReadError("Error deserializing 'port' (int32_t) member of 'StandardURLParams'");
3170 0 : return false;
3171 : }
3172 0 : if ((!(Read((&((v__)->defaultPort())), msg__, iter__)))) {
3173 0 : FatalError("Error deserializing 'defaultPort' (int32_t) member of 'StandardURLParams'");
3174 0 : return false;
3175 : }
3176 : // Sentinel = 'defaultPort'
3177 0 : if ((!((msg__)->ReadSentinel(iter__, 599318897)))) {
3178 0 : mozilla::ipc::SentinelReadError("Error deserializing 'defaultPort' (int32_t) member of 'StandardURLParams'");
3179 0 : return false;
3180 : }
3181 0 : if ((!(Read((&((v__)->spec())), msg__, iter__)))) {
3182 0 : FatalError("Error deserializing 'spec' (nsCString) member of 'StandardURLParams'");
3183 0 : return false;
3184 : }
3185 : // Sentinel = 'spec'
3186 0 : if ((!((msg__)->ReadSentinel(iter__, 1630740541)))) {
3187 0 : mozilla::ipc::SentinelReadError("Error deserializing 'spec' (nsCString) member of 'StandardURLParams'");
3188 0 : return false;
3189 : }
3190 0 : if ((!(Read((&((v__)->scheme())), msg__, iter__)))) {
3191 0 : FatalError("Error deserializing 'scheme' (StandardURLSegment) member of 'StandardURLParams'");
3192 0 : return false;
3193 : }
3194 : // Sentinel = 'scheme'
3195 0 : if ((!((msg__)->ReadSentinel(iter__, 3619238715)))) {
3196 0 : mozilla::ipc::SentinelReadError("Error deserializing 'scheme' (StandardURLSegment) member of 'StandardURLParams'");
3197 0 : return false;
3198 : }
3199 0 : if ((!(Read((&((v__)->authority())), msg__, iter__)))) {
3200 0 : FatalError("Error deserializing 'authority' (StandardURLSegment) member of 'StandardURLParams'");
3201 0 : return false;
3202 : }
3203 : // Sentinel = 'authority'
3204 0 : if ((!((msg__)->ReadSentinel(iter__, 1669684878)))) {
3205 0 : mozilla::ipc::SentinelReadError("Error deserializing 'authority' (StandardURLSegment) member of 'StandardURLParams'");
3206 0 : return false;
3207 : }
3208 0 : if ((!(Read((&((v__)->username())), msg__, iter__)))) {
3209 0 : FatalError("Error deserializing 'username' (StandardURLSegment) member of 'StandardURLParams'");
3210 0 : return false;
3211 : }
3212 : // Sentinel = 'username'
3213 0 : if ((!((msg__)->ReadSentinel(iter__, 689225024)))) {
3214 0 : mozilla::ipc::SentinelReadError("Error deserializing 'username' (StandardURLSegment) member of 'StandardURLParams'");
3215 0 : return false;
3216 : }
3217 0 : if ((!(Read((&((v__)->password())), msg__, iter__)))) {
3218 0 : FatalError("Error deserializing 'password' (StandardURLSegment) member of 'StandardURLParams'");
3219 0 : return false;
3220 : }
3221 : // Sentinel = 'password'
3222 0 : if ((!((msg__)->ReadSentinel(iter__, 2527534683)))) {
3223 0 : mozilla::ipc::SentinelReadError("Error deserializing 'password' (StandardURLSegment) member of 'StandardURLParams'");
3224 0 : return false;
3225 : }
3226 0 : if ((!(Read((&((v__)->host())), msg__, iter__)))) {
3227 0 : FatalError("Error deserializing 'host' (StandardURLSegment) member of 'StandardURLParams'");
3228 0 : return false;
3229 : }
3230 : // Sentinel = 'host'
3231 0 : if ((!((msg__)->ReadSentinel(iter__, 4070301394)))) {
3232 0 : mozilla::ipc::SentinelReadError("Error deserializing 'host' (StandardURLSegment) member of 'StandardURLParams'");
3233 0 : return false;
3234 : }
3235 0 : if ((!(Read((&((v__)->path())), msg__, iter__)))) {
3236 0 : FatalError("Error deserializing 'path' (StandardURLSegment) member of 'StandardURLParams'");
3237 0 : return false;
3238 : }
3239 : // Sentinel = 'path'
3240 0 : if ((!((msg__)->ReadSentinel(iter__, 913629401)))) {
3241 0 : mozilla::ipc::SentinelReadError("Error deserializing 'path' (StandardURLSegment) member of 'StandardURLParams'");
3242 0 : return false;
3243 : }
3244 0 : if ((!(Read((&((v__)->filePath())), msg__, iter__)))) {
3245 0 : FatalError("Error deserializing 'filePath' (StandardURLSegment) member of 'StandardURLParams'");
3246 0 : return false;
3247 : }
3248 : // Sentinel = 'filePath'
3249 0 : if ((!((msg__)->ReadSentinel(iter__, 4122896455)))) {
3250 0 : mozilla::ipc::SentinelReadError("Error deserializing 'filePath' (StandardURLSegment) member of 'StandardURLParams'");
3251 0 : return false;
3252 : }
3253 0 : if ((!(Read((&((v__)->directory())), msg__, iter__)))) {
3254 0 : FatalError("Error deserializing 'directory' (StandardURLSegment) member of 'StandardURLParams'");
3255 0 : return false;
3256 : }
3257 : // Sentinel = 'directory'
3258 0 : if ((!((msg__)->ReadSentinel(iter__, 1201172472)))) {
3259 0 : mozilla::ipc::SentinelReadError("Error deserializing 'directory' (StandardURLSegment) member of 'StandardURLParams'");
3260 0 : return false;
3261 : }
3262 0 : if ((!(Read((&((v__)->baseName())), msg__, iter__)))) {
3263 0 : FatalError("Error deserializing 'baseName' (StandardURLSegment) member of 'StandardURLParams'");
3264 0 : return false;
3265 : }
3266 : // Sentinel = 'baseName'
3267 0 : if ((!((msg__)->ReadSentinel(iter__, 2448877418)))) {
3268 0 : mozilla::ipc::SentinelReadError("Error deserializing 'baseName' (StandardURLSegment) member of 'StandardURLParams'");
3269 0 : return false;
3270 : }
3271 0 : if ((!(Read((&((v__)->extension())), msg__, iter__)))) {
3272 0 : FatalError("Error deserializing 'extension' (StandardURLSegment) member of 'StandardURLParams'");
3273 0 : return false;
3274 : }
3275 : // Sentinel = 'extension'
3276 0 : if ((!((msg__)->ReadSentinel(iter__, 3211853542)))) {
3277 0 : mozilla::ipc::SentinelReadError("Error deserializing 'extension' (StandardURLSegment) member of 'StandardURLParams'");
3278 0 : return false;
3279 : }
3280 0 : if ((!(Read((&((v__)->query())), msg__, iter__)))) {
3281 0 : FatalError("Error deserializing 'query' (StandardURLSegment) member of 'StandardURLParams'");
3282 0 : return false;
3283 : }
3284 : // Sentinel = 'query'
3285 0 : if ((!((msg__)->ReadSentinel(iter__, 4249802777)))) {
3286 0 : mozilla::ipc::SentinelReadError("Error deserializing 'query' (StandardURLSegment) member of 'StandardURLParams'");
3287 0 : return false;
3288 : }
3289 0 : if ((!(Read((&((v__)->ref())), msg__, iter__)))) {
3290 0 : FatalError("Error deserializing 'ref' (StandardURLSegment) member of 'StandardURLParams'");
3291 0 : return false;
3292 : }
3293 : // Sentinel = 'ref'
3294 0 : if ((!((msg__)->ReadSentinel(iter__, 2626476732)))) {
3295 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ref' (StandardURLSegment) member of 'StandardURLParams'");
3296 0 : return false;
3297 : }
3298 0 : if ((!(Read((&((v__)->originCharset())), msg__, iter__)))) {
3299 0 : FatalError("Error deserializing 'originCharset' (nsCString) member of 'StandardURLParams'");
3300 0 : return false;
3301 : }
3302 : // Sentinel = 'originCharset'
3303 0 : if ((!((msg__)->ReadSentinel(iter__, 1320725495)))) {
3304 0 : mozilla::ipc::SentinelReadError("Error deserializing 'originCharset' (nsCString) member of 'StandardURLParams'");
3305 0 : return false;
3306 : }
3307 0 : if ((!(Read((&((v__)->isMutable())), msg__, iter__)))) {
3308 0 : FatalError("Error deserializing 'isMutable' (bool) member of 'StandardURLParams'");
3309 0 : return false;
3310 : }
3311 : // Sentinel = 'isMutable'
3312 0 : if ((!((msg__)->ReadSentinel(iter__, 3552466783)))) {
3313 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isMutable' (bool) member of 'StandardURLParams'");
3314 0 : return false;
3315 : }
3316 0 : if ((!(Read((&((v__)->supportsFileURL())), msg__, iter__)))) {
3317 0 : FatalError("Error deserializing 'supportsFileURL' (bool) member of 'StandardURLParams'");
3318 0 : return false;
3319 : }
3320 : // Sentinel = 'supportsFileURL'
3321 0 : if ((!((msg__)->ReadSentinel(iter__, 1871785710)))) {
3322 0 : mozilla::ipc::SentinelReadError("Error deserializing 'supportsFileURL' (bool) member of 'StandardURLParams'");
3323 0 : return false;
3324 : }
3325 0 : return true;
3326 : }
3327 :
3328 0 : auto PNeckoChild::Write(
3329 : const OptionalInputStreamParams& v__,
3330 : Message* msg__) -> void
3331 : {
3332 : typedef OptionalInputStreamParams type__;
3333 0 : Write(int((v__).type()), msg__);
3334 : // Sentinel = 'OptionalInputStreamParams'
3335 0 : (msg__)->WriteSentinel(1355174443);
3336 :
3337 0 : switch ((v__).type()) {
3338 : case type__::Tvoid_t:
3339 : {
3340 0 : Write((v__).get_void_t(), msg__);
3341 : // Sentinel = 'Tvoid_t'
3342 0 : (msg__)->WriteSentinel(3041273328);
3343 0 : return;
3344 : }
3345 : case type__::TInputStreamParams:
3346 : {
3347 0 : Write((v__).get_InputStreamParams(), msg__);
3348 : // Sentinel = 'TInputStreamParams'
3349 0 : (msg__)->WriteSentinel(55652096);
3350 0 : return;
3351 : }
3352 : default:
3353 : {
3354 0 : FatalError("unknown union type");
3355 0 : return;
3356 : }
3357 : }
3358 : }
3359 :
3360 0 : auto PNeckoChild::Read(
3361 : OptionalInputStreamParams* v__,
3362 : const Message* msg__,
3363 : PickleIterator* iter__) -> bool
3364 : {
3365 : typedef OptionalInputStreamParams type__;
3366 : int type;
3367 0 : if ((!(Read((&(type)), msg__, iter__)))) {
3368 0 : mozilla::ipc::UnionTypeReadError("OptionalInputStreamParams");
3369 0 : return false;
3370 : }
3371 : // Sentinel = 'OptionalInputStreamParams'
3372 0 : if ((!((msg__)->ReadSentinel(iter__, 1355174443)))) {
3373 0 : mozilla::ipc::SentinelReadError("OptionalInputStreamParams");
3374 0 : return false;
3375 : }
3376 :
3377 0 : switch (type) {
3378 : case type__::Tvoid_t:
3379 : {
3380 : void_t tmp = void_t();
3381 0 : (*(v__)) = tmp;
3382 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
3383 0 : FatalError("Error deserializing Union type");
3384 0 : return false;
3385 : }
3386 : // Sentinel = 'Tvoid_t'
3387 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
3388 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3389 0 : return false;
3390 : }
3391 0 : return true;
3392 : }
3393 : case type__::TInputStreamParams:
3394 : {
3395 0 : InputStreamParams tmp = InputStreamParams();
3396 0 : (*(v__)) = tmp;
3397 0 : if ((!(Read((&((v__)->get_InputStreamParams())), msg__, iter__)))) {
3398 0 : FatalError("Error deserializing Union type");
3399 0 : return false;
3400 : }
3401 : // Sentinel = 'TInputStreamParams'
3402 0 : if ((!((msg__)->ReadSentinel(iter__, 55652096)))) {
3403 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3404 0 : return false;
3405 : }
3406 0 : return true;
3407 : }
3408 : default:
3409 : {
3410 0 : FatalError("unknown union type");
3411 0 : return false;
3412 : }
3413 : }
3414 : }
3415 :
3416 3 : auto PNeckoChild::Write(
3417 : const OptionalCorsPreflightArgs& v__,
3418 : Message* msg__) -> void
3419 : {
3420 : typedef OptionalCorsPreflightArgs type__;
3421 3 : Write(int((v__).type()), msg__);
3422 : // Sentinel = 'OptionalCorsPreflightArgs'
3423 3 : (msg__)->WriteSentinel(3238697490);
3424 :
3425 3 : switch ((v__).type()) {
3426 : case type__::Tvoid_t:
3427 : {
3428 3 : Write((v__).get_void_t(), msg__);
3429 : // Sentinel = 'Tvoid_t'
3430 3 : (msg__)->WriteSentinel(3041273328);
3431 3 : return;
3432 : }
3433 : case type__::TCorsPreflightArgs:
3434 : {
3435 0 : Write((v__).get_CorsPreflightArgs(), msg__);
3436 : // Sentinel = 'TCorsPreflightArgs'
3437 0 : (msg__)->WriteSentinel(2263898105);
3438 0 : return;
3439 : }
3440 : default:
3441 : {
3442 0 : FatalError("unknown union type");
3443 0 : return;
3444 : }
3445 : }
3446 : }
3447 :
3448 0 : auto PNeckoChild::Read(
3449 : OptionalCorsPreflightArgs* v__,
3450 : const Message* msg__,
3451 : PickleIterator* iter__) -> bool
3452 : {
3453 : typedef OptionalCorsPreflightArgs type__;
3454 : int type;
3455 0 : if ((!(Read((&(type)), msg__, iter__)))) {
3456 0 : mozilla::ipc::UnionTypeReadError("OptionalCorsPreflightArgs");
3457 0 : return false;
3458 : }
3459 : // Sentinel = 'OptionalCorsPreflightArgs'
3460 0 : if ((!((msg__)->ReadSentinel(iter__, 3238697490)))) {
3461 0 : mozilla::ipc::SentinelReadError("OptionalCorsPreflightArgs");
3462 0 : return false;
3463 : }
3464 :
3465 0 : switch (type) {
3466 : case type__::Tvoid_t:
3467 : {
3468 : void_t tmp = void_t();
3469 0 : (*(v__)) = tmp;
3470 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
3471 0 : FatalError("Error deserializing Union type");
3472 0 : return false;
3473 : }
3474 : // Sentinel = 'Tvoid_t'
3475 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
3476 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3477 0 : return false;
3478 : }
3479 0 : return true;
3480 : }
3481 : case type__::TCorsPreflightArgs:
3482 : {
3483 0 : CorsPreflightArgs tmp = CorsPreflightArgs();
3484 0 : (*(v__)) = tmp;
3485 0 : if ((!(Read((&((v__)->get_CorsPreflightArgs())), msg__, iter__)))) {
3486 0 : FatalError("Error deserializing Union type");
3487 0 : return false;
3488 : }
3489 : // Sentinel = 'TCorsPreflightArgs'
3490 0 : if ((!((msg__)->ReadSentinel(iter__, 2263898105)))) {
3491 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3492 0 : return false;
3493 : }
3494 0 : return true;
3495 : }
3496 : default:
3497 : {
3498 0 : FatalError("unknown union type");
3499 0 : return false;
3500 : }
3501 : }
3502 : }
3503 :
3504 0 : auto PNeckoChild::Write(
3505 : const PAltDataOutputStreamChild* v__,
3506 : Message* msg__,
3507 : bool nullable__) -> void
3508 : {
3509 : int32_t id;
3510 0 : if ((!(v__))) {
3511 0 : if ((!(nullable__))) {
3512 0 : FatalError("NULL actor value passed to non-nullable param");
3513 : }
3514 0 : id = 0;
3515 : }
3516 : else {
3517 0 : id = (v__)->Id();
3518 0 : if ((1) == (id)) {
3519 0 : FatalError("actor has been |delete|d");
3520 : }
3521 : }
3522 :
3523 0 : Write(id, msg__);
3524 0 : }
3525 :
3526 0 : auto PNeckoChild::Read(
3527 : PAltDataOutputStreamChild** v__,
3528 : const Message* msg__,
3529 : PickleIterator* iter__,
3530 : bool nullable__) -> bool
3531 : {
3532 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PAltDataOutputStream", PAltDataOutputStreamMsgStart);
3533 0 : if ((actor).isNothing()) {
3534 0 : return false;
3535 : }
3536 :
3537 0 : (*(v__)) = static_cast<PAltDataOutputStreamChild*>((actor).value());
3538 0 : return true;
3539 : }
3540 :
3541 0 : auto PNeckoChild::Write(
3542 : const IPCRemoteStream& v__,
3543 : Message* msg__) -> void
3544 : {
3545 0 : Write((v__).delayedStart(), msg__);
3546 : // Sentinel = 'delayedStart'
3547 0 : (msg__)->WriteSentinel(1491822294);
3548 0 : Write((v__).stream(), msg__);
3549 : // Sentinel = 'stream'
3550 0 : (msg__)->WriteSentinel(4152748422);
3551 0 : }
3552 :
3553 0 : auto PNeckoChild::Read(
3554 : IPCRemoteStream* v__,
3555 : const Message* msg__,
3556 : PickleIterator* iter__) -> bool
3557 : {
3558 0 : if ((!(Read((&((v__)->delayedStart())), msg__, iter__)))) {
3559 0 : FatalError("Error deserializing 'delayedStart' (bool) member of 'IPCRemoteStream'");
3560 0 : return false;
3561 : }
3562 : // Sentinel = 'delayedStart'
3563 0 : if ((!((msg__)->ReadSentinel(iter__, 1491822294)))) {
3564 0 : mozilla::ipc::SentinelReadError("Error deserializing 'delayedStart' (bool) member of 'IPCRemoteStream'");
3565 0 : return false;
3566 : }
3567 0 : if ((!(Read((&((v__)->stream())), msg__, iter__)))) {
3568 0 : FatalError("Error deserializing 'stream' (IPCRemoteStreamType) member of 'IPCRemoteStream'");
3569 0 : return false;
3570 : }
3571 : // Sentinel = 'stream'
3572 0 : if ((!((msg__)->ReadSentinel(iter__, 4152748422)))) {
3573 0 : mozilla::ipc::SentinelReadError("Error deserializing 'stream' (IPCRemoteStreamType) member of 'IPCRemoteStream'");
3574 0 : return false;
3575 : }
3576 0 : return true;
3577 : }
3578 :
3579 3 : auto PNeckoChild::Write(
3580 : const OptionalHttpResponseHead& v__,
3581 : Message* msg__) -> void
3582 : {
3583 : typedef OptionalHttpResponseHead type__;
3584 3 : Write(int((v__).type()), msg__);
3585 : // Sentinel = 'OptionalHttpResponseHead'
3586 3 : (msg__)->WriteSentinel(1811886563);
3587 :
3588 3 : switch ((v__).type()) {
3589 : case type__::Tvoid_t:
3590 : {
3591 3 : Write((v__).get_void_t(), msg__);
3592 : // Sentinel = 'Tvoid_t'
3593 3 : (msg__)->WriteSentinel(3041273328);
3594 3 : return;
3595 : }
3596 : case type__::TnsHttpResponseHead:
3597 : {
3598 0 : Write((v__).get_nsHttpResponseHead(), msg__);
3599 : // Sentinel = 'TnsHttpResponseHead'
3600 0 : (msg__)->WriteSentinel(2600232857);
3601 0 : return;
3602 : }
3603 : default:
3604 : {
3605 0 : FatalError("unknown union type");
3606 0 : return;
3607 : }
3608 : }
3609 : }
3610 :
3611 0 : auto PNeckoChild::Read(
3612 : OptionalHttpResponseHead* v__,
3613 : const Message* msg__,
3614 : PickleIterator* iter__) -> bool
3615 : {
3616 : typedef OptionalHttpResponseHead type__;
3617 : int type;
3618 0 : if ((!(Read((&(type)), msg__, iter__)))) {
3619 0 : mozilla::ipc::UnionTypeReadError("OptionalHttpResponseHead");
3620 0 : return false;
3621 : }
3622 : // Sentinel = 'OptionalHttpResponseHead'
3623 0 : if ((!((msg__)->ReadSentinel(iter__, 1811886563)))) {
3624 0 : mozilla::ipc::SentinelReadError("OptionalHttpResponseHead");
3625 0 : return false;
3626 : }
3627 :
3628 0 : switch (type) {
3629 : case type__::Tvoid_t:
3630 : {
3631 : void_t tmp = void_t();
3632 0 : (*(v__)) = tmp;
3633 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
3634 0 : FatalError("Error deserializing Union type");
3635 0 : return false;
3636 : }
3637 : // Sentinel = 'Tvoid_t'
3638 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
3639 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3640 0 : return false;
3641 : }
3642 0 : return true;
3643 : }
3644 : case type__::TnsHttpResponseHead:
3645 : {
3646 0 : nsHttpResponseHead tmp = nsHttpResponseHead();
3647 0 : (*(v__)) = tmp;
3648 0 : if ((!(Read((&((v__)->get_nsHttpResponseHead())), msg__, iter__)))) {
3649 0 : FatalError("Error deserializing Union type");
3650 0 : return false;
3651 : }
3652 : // Sentinel = 'TnsHttpResponseHead'
3653 0 : if ((!((msg__)->ReadSentinel(iter__, 2600232857)))) {
3654 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3655 0 : return false;
3656 : }
3657 0 : return true;
3658 : }
3659 : default:
3660 : {
3661 0 : FatalError("unknown union type");
3662 0 : return false;
3663 : }
3664 : }
3665 : }
3666 :
3667 17 : auto PNeckoChild::Write(
3668 : const URIParams& v__,
3669 : Message* msg__) -> void
3670 : {
3671 : typedef URIParams type__;
3672 17 : Write(int((v__).type()), msg__);
3673 : // Sentinel = 'URIParams'
3674 17 : (msg__)->WriteSentinel(1039516337);
3675 :
3676 17 : switch ((v__).type()) {
3677 : case type__::TSimpleURIParams:
3678 : {
3679 0 : Write((v__).get_SimpleURIParams(), msg__);
3680 : // Sentinel = 'TSimpleURIParams'
3681 0 : (msg__)->WriteSentinel(4028607586);
3682 0 : return;
3683 : }
3684 : case type__::TStandardURLParams:
3685 : {
3686 17 : Write((v__).get_StandardURLParams(), msg__);
3687 : // Sentinel = 'TStandardURLParams'
3688 17 : (msg__)->WriteSentinel(248174578);
3689 17 : return;
3690 : }
3691 : case type__::TJARURIParams:
3692 : {
3693 0 : Write((v__).get_JARURIParams(), msg__);
3694 : // Sentinel = 'TJARURIParams'
3695 0 : (msg__)->WriteSentinel(3404434792);
3696 0 : return;
3697 : }
3698 : case type__::TIconURIParams:
3699 : {
3700 0 : Write((v__).get_IconURIParams(), msg__);
3701 : // Sentinel = 'TIconURIParams'
3702 0 : (msg__)->WriteSentinel(1824279023);
3703 0 : return;
3704 : }
3705 : case type__::TNullPrincipalURIParams:
3706 : {
3707 0 : Write((v__).get_NullPrincipalURIParams(), msg__);
3708 : // Sentinel = 'TNullPrincipalURIParams'
3709 0 : (msg__)->WriteSentinel(216801182);
3710 0 : return;
3711 : }
3712 : case type__::TJSURIParams:
3713 : {
3714 0 : Write((v__).get_JSURIParams(), msg__);
3715 : // Sentinel = 'TJSURIParams'
3716 0 : (msg__)->WriteSentinel(32222119);
3717 0 : return;
3718 : }
3719 : case type__::TSimpleNestedURIParams:
3720 : {
3721 0 : Write((v__).get_SimpleNestedURIParams(), msg__);
3722 : // Sentinel = 'TSimpleNestedURIParams'
3723 0 : (msg__)->WriteSentinel(3192238307);
3724 0 : return;
3725 : }
3726 : case type__::THostObjectURIParams:
3727 : {
3728 0 : Write((v__).get_HostObjectURIParams(), msg__);
3729 : // Sentinel = 'THostObjectURIParams'
3730 0 : (msg__)->WriteSentinel(1307971301);
3731 0 : return;
3732 : }
3733 : default:
3734 : {
3735 0 : FatalError("unknown union type");
3736 0 : return;
3737 : }
3738 : }
3739 : }
3740 :
3741 0 : auto PNeckoChild::Read(
3742 : URIParams* v__,
3743 : const Message* msg__,
3744 : PickleIterator* iter__) -> bool
3745 : {
3746 : typedef URIParams type__;
3747 : int type;
3748 0 : if ((!(Read((&(type)), msg__, iter__)))) {
3749 0 : mozilla::ipc::UnionTypeReadError("URIParams");
3750 0 : return false;
3751 : }
3752 : // Sentinel = 'URIParams'
3753 0 : if ((!((msg__)->ReadSentinel(iter__, 1039516337)))) {
3754 0 : mozilla::ipc::SentinelReadError("URIParams");
3755 0 : return false;
3756 : }
3757 :
3758 0 : switch (type) {
3759 : case type__::TSimpleURIParams:
3760 : {
3761 0 : SimpleURIParams tmp = SimpleURIParams();
3762 0 : (*(v__)) = tmp;
3763 0 : if ((!(Read((&((v__)->get_SimpleURIParams())), msg__, iter__)))) {
3764 0 : FatalError("Error deserializing Union type");
3765 0 : return false;
3766 : }
3767 : // Sentinel = 'TSimpleURIParams'
3768 0 : if ((!((msg__)->ReadSentinel(iter__, 4028607586)))) {
3769 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3770 0 : return false;
3771 : }
3772 0 : return true;
3773 : }
3774 : case type__::TStandardURLParams:
3775 : {
3776 0 : StandardURLParams tmp = StandardURLParams();
3777 0 : (*(v__)) = tmp;
3778 0 : if ((!(Read((&((v__)->get_StandardURLParams())), msg__, iter__)))) {
3779 0 : FatalError("Error deserializing Union type");
3780 0 : return false;
3781 : }
3782 : // Sentinel = 'TStandardURLParams'
3783 0 : if ((!((msg__)->ReadSentinel(iter__, 248174578)))) {
3784 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3785 0 : return false;
3786 : }
3787 0 : return true;
3788 : }
3789 : case type__::TJARURIParams:
3790 : {
3791 0 : JARURIParams tmp = JARURIParams();
3792 0 : (*(v__)) = tmp;
3793 0 : if ((!(Read((&((v__)->get_JARURIParams())), msg__, iter__)))) {
3794 0 : FatalError("Error deserializing Union type");
3795 0 : return false;
3796 : }
3797 : // Sentinel = 'TJARURIParams'
3798 0 : if ((!((msg__)->ReadSentinel(iter__, 3404434792)))) {
3799 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3800 0 : return false;
3801 : }
3802 0 : return true;
3803 : }
3804 : case type__::TIconURIParams:
3805 : {
3806 0 : IconURIParams tmp = IconURIParams();
3807 0 : (*(v__)) = tmp;
3808 0 : if ((!(Read((&((v__)->get_IconURIParams())), msg__, iter__)))) {
3809 0 : FatalError("Error deserializing Union type");
3810 0 : return false;
3811 : }
3812 : // Sentinel = 'TIconURIParams'
3813 0 : if ((!((msg__)->ReadSentinel(iter__, 1824279023)))) {
3814 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3815 0 : return false;
3816 : }
3817 0 : return true;
3818 : }
3819 : case type__::TNullPrincipalURIParams:
3820 : {
3821 0 : NullPrincipalURIParams tmp = NullPrincipalURIParams();
3822 0 : (*(v__)) = tmp;
3823 0 : if ((!(Read((&((v__)->get_NullPrincipalURIParams())), msg__, iter__)))) {
3824 0 : FatalError("Error deserializing Union type");
3825 0 : return false;
3826 : }
3827 : // Sentinel = 'TNullPrincipalURIParams'
3828 0 : if ((!((msg__)->ReadSentinel(iter__, 216801182)))) {
3829 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3830 0 : return false;
3831 : }
3832 0 : return true;
3833 : }
3834 : case type__::TJSURIParams:
3835 : {
3836 0 : JSURIParams tmp = JSURIParams();
3837 0 : (*(v__)) = tmp;
3838 0 : if ((!(Read((&((v__)->get_JSURIParams())), msg__, iter__)))) {
3839 0 : FatalError("Error deserializing Union type");
3840 0 : return false;
3841 : }
3842 : // Sentinel = 'TJSURIParams'
3843 0 : if ((!((msg__)->ReadSentinel(iter__, 32222119)))) {
3844 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3845 0 : return false;
3846 : }
3847 0 : return true;
3848 : }
3849 : case type__::TSimpleNestedURIParams:
3850 : {
3851 0 : SimpleNestedURIParams tmp = SimpleNestedURIParams();
3852 0 : (*(v__)) = tmp;
3853 0 : if ((!(Read((&((v__)->get_SimpleNestedURIParams())), msg__, iter__)))) {
3854 0 : FatalError("Error deserializing Union type");
3855 0 : return false;
3856 : }
3857 : // Sentinel = 'TSimpleNestedURIParams'
3858 0 : if ((!((msg__)->ReadSentinel(iter__, 3192238307)))) {
3859 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3860 0 : return false;
3861 : }
3862 0 : return true;
3863 : }
3864 : case type__::THostObjectURIParams:
3865 : {
3866 0 : HostObjectURIParams tmp = HostObjectURIParams();
3867 0 : (*(v__)) = tmp;
3868 0 : if ((!(Read((&((v__)->get_HostObjectURIParams())), msg__, iter__)))) {
3869 0 : FatalError("Error deserializing Union type");
3870 0 : return false;
3871 : }
3872 : // Sentinel = 'THostObjectURIParams'
3873 0 : if ((!((msg__)->ReadSentinel(iter__, 1307971301)))) {
3874 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3875 0 : return false;
3876 : }
3877 0 : return true;
3878 : }
3879 : default:
3880 : {
3881 0 : FatalError("unknown union type");
3882 0 : return false;
3883 : }
3884 : }
3885 : }
3886 :
3887 0 : auto PNeckoChild::Write(
3888 : const RedirectHistoryEntryInfo& v__,
3889 : Message* msg__) -> void
3890 : {
3891 0 : Write((v__).principalInfo(), msg__);
3892 : // Sentinel = 'principalInfo'
3893 0 : (msg__)->WriteSentinel(3386633731);
3894 0 : Write((v__).referrerUri(), msg__);
3895 : // Sentinel = 'referrerUri'
3896 0 : (msg__)->WriteSentinel(622910354);
3897 0 : Write((v__).remoteAddress(), msg__);
3898 : // Sentinel = 'remoteAddress'
3899 0 : (msg__)->WriteSentinel(3204520231);
3900 0 : }
3901 :
3902 0 : auto PNeckoChild::Read(
3903 : RedirectHistoryEntryInfo* v__,
3904 : const Message* msg__,
3905 : PickleIterator* iter__) -> bool
3906 : {
3907 0 : if ((!(Read((&((v__)->principalInfo())), msg__, iter__)))) {
3908 0 : FatalError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'RedirectHistoryEntryInfo'");
3909 0 : return false;
3910 : }
3911 : // Sentinel = 'principalInfo'
3912 0 : if ((!((msg__)->ReadSentinel(iter__, 3386633731)))) {
3913 0 : mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'RedirectHistoryEntryInfo'");
3914 0 : return false;
3915 : }
3916 0 : if ((!(Read((&((v__)->referrerUri())), msg__, iter__)))) {
3917 0 : FatalError("Error deserializing 'referrerUri' (OptionalURIParams) member of 'RedirectHistoryEntryInfo'");
3918 0 : return false;
3919 : }
3920 : // Sentinel = 'referrerUri'
3921 0 : if ((!((msg__)->ReadSentinel(iter__, 622910354)))) {
3922 0 : mozilla::ipc::SentinelReadError("Error deserializing 'referrerUri' (OptionalURIParams) member of 'RedirectHistoryEntryInfo'");
3923 0 : return false;
3924 : }
3925 0 : if ((!(Read((&((v__)->remoteAddress())), msg__, iter__)))) {
3926 0 : FatalError("Error deserializing 'remoteAddress' (nsCString) member of 'RedirectHistoryEntryInfo'");
3927 0 : return false;
3928 : }
3929 : // Sentinel = 'remoteAddress'
3930 0 : if ((!((msg__)->ReadSentinel(iter__, 3204520231)))) {
3931 0 : mozilla::ipc::SentinelReadError("Error deserializing 'remoteAddress' (nsCString) member of 'RedirectHistoryEntryInfo'");
3932 0 : return false;
3933 : }
3934 0 : return true;
3935 : }
3936 :
3937 0 : auto PNeckoChild::Write(
3938 : const PFTPChannelChild* v__,
3939 : Message* msg__,
3940 : bool nullable__) -> void
3941 : {
3942 : int32_t id;
3943 0 : if ((!(v__))) {
3944 0 : if ((!(nullable__))) {
3945 0 : FatalError("NULL actor value passed to non-nullable param");
3946 : }
3947 0 : id = 0;
3948 : }
3949 : else {
3950 0 : id = (v__)->Id();
3951 0 : if ((1) == (id)) {
3952 0 : FatalError("actor has been |delete|d");
3953 : }
3954 : }
3955 :
3956 0 : Write(id, msg__);
3957 0 : }
3958 :
3959 0 : auto PNeckoChild::Read(
3960 : PFTPChannelChild** v__,
3961 : const Message* msg__,
3962 : PickleIterator* iter__,
3963 : bool nullable__) -> bool
3964 : {
3965 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PFTPChannel", PFTPChannelMsgStart);
3966 0 : if ((actor).isNothing()) {
3967 0 : return false;
3968 : }
3969 :
3970 0 : (*(v__)) = static_cast<PFTPChannelChild*>((actor).value());
3971 0 : return true;
3972 : }
3973 :
3974 0 : auto PNeckoChild::Write(
3975 : const CorsPreflightArgs& v__,
3976 : Message* msg__) -> void
3977 : {
3978 0 : Write((v__).unsafeHeaders(), msg__);
3979 : // Sentinel = 'unsafeHeaders'
3980 0 : (msg__)->WriteSentinel(259870561);
3981 0 : }
3982 :
3983 0 : auto PNeckoChild::Read(
3984 : CorsPreflightArgs* v__,
3985 : const Message* msg__,
3986 : PickleIterator* iter__) -> bool
3987 : {
3988 0 : if ((!(Read((&((v__)->unsafeHeaders())), msg__, iter__)))) {
3989 0 : FatalError("Error deserializing 'unsafeHeaders' (nsCString[]) member of 'CorsPreflightArgs'");
3990 0 : return false;
3991 : }
3992 : // Sentinel = 'unsafeHeaders'
3993 0 : if ((!((msg__)->ReadSentinel(iter__, 259870561)))) {
3994 0 : mozilla::ipc::SentinelReadError("Error deserializing 'unsafeHeaders' (nsCString[]) member of 'CorsPreflightArgs'");
3995 0 : return false;
3996 : }
3997 0 : return true;
3998 : }
3999 :
4000 0 : auto PNeckoChild::Write(
4001 : const FileInputStreamParams& v__,
4002 : Message* msg__) -> void
4003 : {
4004 0 : Write((v__).fileDescriptorIndex(), msg__);
4005 : // Sentinel = 'fileDescriptorIndex'
4006 0 : (msg__)->WriteSentinel(587329112);
4007 0 : Write((v__).behaviorFlags(), msg__);
4008 : // Sentinel = 'behaviorFlags'
4009 0 : (msg__)->WriteSentinel(2404401962);
4010 0 : Write((v__).ioFlags(), msg__);
4011 : // Sentinel = 'ioFlags'
4012 0 : (msg__)->WriteSentinel(1483009730);
4013 0 : }
4014 :
4015 0 : auto PNeckoChild::Read(
4016 : FileInputStreamParams* v__,
4017 : const Message* msg__,
4018 : PickleIterator* iter__) -> bool
4019 : {
4020 0 : if ((!(Read((&((v__)->fileDescriptorIndex())), msg__, iter__)))) {
4021 0 : FatalError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'FileInputStreamParams'");
4022 0 : return false;
4023 : }
4024 : // Sentinel = 'fileDescriptorIndex'
4025 0 : if ((!((msg__)->ReadSentinel(iter__, 587329112)))) {
4026 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'FileInputStreamParams'");
4027 0 : return false;
4028 : }
4029 0 : if ((!(Read((&((v__)->behaviorFlags())), msg__, iter__)))) {
4030 0 : FatalError("Error deserializing 'behaviorFlags' (int32_t) member of 'FileInputStreamParams'");
4031 0 : return false;
4032 : }
4033 : // Sentinel = 'behaviorFlags'
4034 0 : if ((!((msg__)->ReadSentinel(iter__, 2404401962)))) {
4035 0 : mozilla::ipc::SentinelReadError("Error deserializing 'behaviorFlags' (int32_t) member of 'FileInputStreamParams'");
4036 0 : return false;
4037 : }
4038 0 : if ((!(Read((&((v__)->ioFlags())), msg__, iter__)))) {
4039 0 : FatalError("Error deserializing 'ioFlags' (int32_t) member of 'FileInputStreamParams'");
4040 0 : return false;
4041 : }
4042 : // Sentinel = 'ioFlags'
4043 0 : if ((!((msg__)->ReadSentinel(iter__, 1483009730)))) {
4044 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ioFlags' (int32_t) member of 'FileInputStreamParams'");
4045 0 : return false;
4046 : }
4047 0 : return true;
4048 : }
4049 :
4050 0 : auto PNeckoChild::Write(
4051 : const PUDPSocketChild* v__,
4052 : Message* msg__,
4053 : bool nullable__) -> void
4054 : {
4055 : int32_t id;
4056 0 : if ((!(v__))) {
4057 0 : if ((!(nullable__))) {
4058 0 : FatalError("NULL actor value passed to non-nullable param");
4059 : }
4060 0 : id = 0;
4061 : }
4062 : else {
4063 0 : id = (v__)->Id();
4064 0 : if ((1) == (id)) {
4065 0 : FatalError("actor has been |delete|d");
4066 : }
4067 : }
4068 :
4069 0 : Write(id, msg__);
4070 0 : }
4071 :
4072 0 : auto PNeckoChild::Read(
4073 : PUDPSocketChild** v__,
4074 : const Message* msg__,
4075 : PickleIterator* iter__,
4076 : bool nullable__) -> bool
4077 : {
4078 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PUDPSocket", PUDPSocketMsgStart);
4079 0 : if ((actor).isNothing()) {
4080 0 : return false;
4081 : }
4082 :
4083 0 : (*(v__)) = static_cast<PUDPSocketChild*>((actor).value());
4084 0 : return true;
4085 : }
4086 :
4087 0 : auto PNeckoChild::Write(
4088 : const HttpChannelDiverterArgs& v__,
4089 : Message* msg__) -> void
4090 : {
4091 : // skipping actor field that's meaningless on this side
4092 0 : Write((v__).mChannelChild(), msg__, false);
4093 : // Sentinel = 'mChannel'
4094 0 : (msg__)->WriteSentinel(1707342666);
4095 0 : Write((v__).mApplyConversion(), msg__);
4096 : // Sentinel = 'mApplyConversion'
4097 0 : (msg__)->WriteSentinel(2495336819);
4098 0 : }
4099 :
4100 0 : auto PNeckoChild::Read(
4101 : HttpChannelDiverterArgs* v__,
4102 : const Message* msg__,
4103 : PickleIterator* iter__) -> bool
4104 : {
4105 : // skipping actor field that's meaningless on this side
4106 0 : if ((!(Read((&((v__)->mChannelChild())), msg__, iter__, false)))) {
4107 0 : FatalError("Error deserializing 'mChannelChild' (PHttpChannel) member of 'HttpChannelDiverterArgs'");
4108 0 : return false;
4109 : }
4110 : // Sentinel = 'mChannel'
4111 0 : if ((!((msg__)->ReadSentinel(iter__, 1707342666)))) {
4112 0 : mozilla::ipc::SentinelReadError("Error deserializing 'mChannelChild' (PHttpChannel) member of 'HttpChannelDiverterArgs'");
4113 0 : return false;
4114 : }
4115 0 : if ((!(Read((&((v__)->mApplyConversion())), msg__, iter__)))) {
4116 0 : FatalError("Error deserializing 'mApplyConversion' (bool) member of 'HttpChannelDiverterArgs'");
4117 0 : return false;
4118 : }
4119 : // Sentinel = 'mApplyConversion'
4120 0 : if ((!((msg__)->ReadSentinel(iter__, 2495336819)))) {
4121 0 : mozilla::ipc::SentinelReadError("Error deserializing 'mApplyConversion' (bool) member of 'HttpChannelDiverterArgs'");
4122 0 : return false;
4123 : }
4124 0 : return true;
4125 : }
4126 :
4127 0 : auto PNeckoChild::Write(
4128 : const PStunAddrsRequestChild* v__,
4129 : Message* msg__,
4130 : bool nullable__) -> void
4131 : {
4132 : int32_t id;
4133 0 : if ((!(v__))) {
4134 0 : if ((!(nullable__))) {
4135 0 : FatalError("NULL actor value passed to non-nullable param");
4136 : }
4137 0 : id = 0;
4138 : }
4139 : else {
4140 0 : id = (v__)->Id();
4141 0 : if ((1) == (id)) {
4142 0 : FatalError("actor has been |delete|d");
4143 : }
4144 : }
4145 :
4146 0 : Write(id, msg__);
4147 0 : }
4148 :
4149 0 : auto PNeckoChild::Read(
4150 : PStunAddrsRequestChild** v__,
4151 : const Message* msg__,
4152 : PickleIterator* iter__,
4153 : bool nullable__) -> bool
4154 : {
4155 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PStunAddrsRequest", PStunAddrsRequestMsgStart);
4156 0 : if ((actor).isNothing()) {
4157 0 : return false;
4158 : }
4159 :
4160 0 : (*(v__)) = static_cast<PStunAddrsRequestChild*>((actor).value());
4161 0 : return true;
4162 : }
4163 :
4164 6 : auto PNeckoChild::Write(
4165 : const nsTArray<RedirectHistoryEntryInfo>& v__,
4166 : Message* msg__) -> void
4167 : {
4168 6 : uint32_t length = (v__).Length();
4169 6 : Write(length, msg__);
4170 : // Sentinel = ('length', 'RedirectHistoryEntryInfo[]')
4171 6 : (msg__)->WriteSentinel(2482278523);
4172 :
4173 6 : for (auto& elem : v__) {
4174 0 : Write(elem, msg__);
4175 : // Sentinel = 'RedirectHistoryEntryInfo[]'
4176 0 : (msg__)->WriteSentinel(2694829470);
4177 : }
4178 6 : }
4179 :
4180 0 : auto PNeckoChild::Read(
4181 : nsTArray<RedirectHistoryEntryInfo>* v__,
4182 : const Message* msg__,
4183 : PickleIterator* iter__) -> bool
4184 : {
4185 0 : nsTArray<RedirectHistoryEntryInfo> fa;
4186 : uint32_t length;
4187 0 : if ((!(Read((&(length)), msg__, iter__)))) {
4188 0 : mozilla::ipc::ArrayLengthReadError("RedirectHistoryEntryInfo[]");
4189 0 : return false;
4190 : }
4191 : // Sentinel = ('length', 'RedirectHistoryEntryInfo[]')
4192 0 : if ((!((msg__)->ReadSentinel(iter__, 2482278523)))) {
4193 0 : mozilla::ipc::SentinelReadError("RedirectHistoryEntryInfo[]");
4194 0 : return false;
4195 : }
4196 :
4197 0 : RedirectHistoryEntryInfo* elems = (fa).AppendElements(length);
4198 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
4199 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
4200 0 : FatalError("Error deserializing 'RedirectHistoryEntryInfo[i]'");
4201 0 : return false;
4202 : }
4203 : // Sentinel = 'RedirectHistoryEntryInfo[]'
4204 0 : if ((!((msg__)->ReadSentinel(iter__, 2694829470)))) {
4205 0 : mozilla::ipc::SentinelReadError("Error deserializing 'RedirectHistoryEntryInfo[i]'");
4206 0 : return false;
4207 : }
4208 : }
4209 0 : (v__)->SwapElements(fa);
4210 0 : return true;
4211 : }
4212 :
4213 0 : auto PNeckoChild::Write(
4214 : const SimpleNestedURIParams& v__,
4215 : Message* msg__) -> void
4216 : {
4217 0 : Write((v__).simpleParams(), msg__);
4218 : // Sentinel = 'simpleParams'
4219 0 : (msg__)->WriteSentinel(3404291700);
4220 0 : Write((v__).innerURI(), msg__);
4221 : // Sentinel = 'innerURI'
4222 0 : (msg__)->WriteSentinel(2573245334);
4223 0 : }
4224 :
4225 0 : auto PNeckoChild::Read(
4226 : SimpleNestedURIParams* v__,
4227 : const Message* msg__,
4228 : PickleIterator* iter__) -> bool
4229 : {
4230 0 : if ((!(Read((&((v__)->simpleParams())), msg__, iter__)))) {
4231 0 : FatalError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'SimpleNestedURIParams'");
4232 0 : return false;
4233 : }
4234 : // Sentinel = 'simpleParams'
4235 0 : if ((!((msg__)->ReadSentinel(iter__, 3404291700)))) {
4236 0 : mozilla::ipc::SentinelReadError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'SimpleNestedURIParams'");
4237 0 : return false;
4238 : }
4239 0 : if ((!(Read((&((v__)->innerURI())), msg__, iter__)))) {
4240 0 : FatalError("Error deserializing 'innerURI' (URIParams) member of 'SimpleNestedURIParams'");
4241 0 : return false;
4242 : }
4243 : // Sentinel = 'innerURI'
4244 0 : if ((!((msg__)->ReadSentinel(iter__, 2573245334)))) {
4245 0 : mozilla::ipc::SentinelReadError("Error deserializing 'innerURI' (URIParams) member of 'SimpleNestedURIParams'");
4246 0 : return false;
4247 : }
4248 0 : return true;
4249 : }
4250 :
4251 0 : auto PNeckoChild::Write(
4252 : const FTPChannelConnectArgs& v__,
4253 : Message* msg__) -> void
4254 : {
4255 0 : Write((v__).channelId(), msg__);
4256 : // Sentinel = 'channelId'
4257 0 : (msg__)->WriteSentinel(6854027);
4258 0 : }
4259 :
4260 0 : auto PNeckoChild::Read(
4261 : FTPChannelConnectArgs* v__,
4262 : const Message* msg__,
4263 : PickleIterator* iter__) -> bool
4264 : {
4265 0 : if ((!(Read((&((v__)->channelId())), msg__, iter__)))) {
4266 0 : FatalError("Error deserializing 'channelId' (uint32_t) member of 'FTPChannelConnectArgs'");
4267 0 : return false;
4268 : }
4269 : // Sentinel = 'channelId'
4270 0 : if ((!((msg__)->ReadSentinel(iter__, 6854027)))) {
4271 0 : mozilla::ipc::SentinelReadError("Error deserializing 'channelId' (uint32_t) member of 'FTPChannelConnectArgs'");
4272 0 : return false;
4273 : }
4274 0 : return true;
4275 : }
4276 :
4277 9 : auto PNeckoChild::Write(
4278 : const OptionalPrincipalInfo& v__,
4279 : Message* msg__) -> void
4280 : {
4281 : typedef OptionalPrincipalInfo type__;
4282 9 : Write(int((v__).type()), msg__);
4283 : // Sentinel = 'OptionalPrincipalInfo'
4284 9 : (msg__)->WriteSentinel(3041452007);
4285 :
4286 9 : switch ((v__).type()) {
4287 : case type__::Tvoid_t:
4288 : {
4289 7 : Write((v__).get_void_t(), msg__);
4290 : // Sentinel = 'Tvoid_t'
4291 7 : (msg__)->WriteSentinel(3041273328);
4292 7 : return;
4293 : }
4294 : case type__::TPrincipalInfo:
4295 : {
4296 2 : Write((v__).get_PrincipalInfo(), msg__);
4297 : // Sentinel = 'TPrincipalInfo'
4298 2 : (msg__)->WriteSentinel(1396743580);
4299 2 : return;
4300 : }
4301 : default:
4302 : {
4303 0 : FatalError("unknown union type");
4304 0 : return;
4305 : }
4306 : }
4307 : }
4308 :
4309 0 : auto PNeckoChild::Read(
4310 : OptionalPrincipalInfo* v__,
4311 : const Message* msg__,
4312 : PickleIterator* iter__) -> bool
4313 : {
4314 : typedef OptionalPrincipalInfo type__;
4315 : int type;
4316 0 : if ((!(Read((&(type)), msg__, iter__)))) {
4317 0 : mozilla::ipc::UnionTypeReadError("OptionalPrincipalInfo");
4318 0 : return false;
4319 : }
4320 : // Sentinel = 'OptionalPrincipalInfo'
4321 0 : if ((!((msg__)->ReadSentinel(iter__, 3041452007)))) {
4322 0 : mozilla::ipc::SentinelReadError("OptionalPrincipalInfo");
4323 0 : return false;
4324 : }
4325 :
4326 0 : switch (type) {
4327 : case type__::Tvoid_t:
4328 : {
4329 : void_t tmp = void_t();
4330 0 : (*(v__)) = tmp;
4331 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
4332 0 : FatalError("Error deserializing Union type");
4333 0 : return false;
4334 : }
4335 : // Sentinel = 'Tvoid_t'
4336 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
4337 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4338 0 : return false;
4339 : }
4340 0 : return true;
4341 : }
4342 : case type__::TPrincipalInfo:
4343 : {
4344 0 : PrincipalInfo tmp = PrincipalInfo();
4345 0 : (*(v__)) = tmp;
4346 0 : if ((!(Read((&((v__)->get_PrincipalInfo())), msg__, iter__)))) {
4347 0 : FatalError("Error deserializing Union type");
4348 0 : return false;
4349 : }
4350 : // Sentinel = 'TPrincipalInfo'
4351 0 : if ((!((msg__)->ReadSentinel(iter__, 1396743580)))) {
4352 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4353 0 : return false;
4354 : }
4355 0 : return true;
4356 : }
4357 : default:
4358 : {
4359 0 : FatalError("unknown union type");
4360 0 : return false;
4361 : }
4362 : }
4363 : }
4364 :
4365 0 : auto PNeckoChild::Write(
4366 : const PTransportProviderChild* v__,
4367 : Message* msg__,
4368 : bool nullable__) -> void
4369 : {
4370 : int32_t id;
4371 0 : if ((!(v__))) {
4372 0 : if ((!(nullable__))) {
4373 0 : FatalError("NULL actor value passed to non-nullable param");
4374 : }
4375 0 : id = 0;
4376 : }
4377 : else {
4378 0 : id = (v__)->Id();
4379 0 : if ((1) == (id)) {
4380 0 : FatalError("actor has been |delete|d");
4381 : }
4382 : }
4383 :
4384 0 : Write(id, msg__);
4385 0 : }
4386 :
4387 0 : auto PNeckoChild::Read(
4388 : PTransportProviderChild** v__,
4389 : const Message* msg__,
4390 : PickleIterator* iter__,
4391 : bool nullable__) -> bool
4392 : {
4393 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PTransportProvider", PTransportProviderMsgStart);
4394 0 : if ((actor).isNothing()) {
4395 0 : return false;
4396 : }
4397 :
4398 0 : (*(v__)) = static_cast<PTransportProviderChild*>((actor).value());
4399 0 : return true;
4400 : }
4401 :
4402 3 : auto PNeckoChild::Write(
4403 : const PBrowserOrId& v__,
4404 : Message* msg__) -> void
4405 : {
4406 : typedef PBrowserOrId type__;
4407 3 : Write(int((v__).type()), msg__);
4408 : // Sentinel = 'PBrowserOrId'
4409 3 : (msg__)->WriteSentinel(1715137324);
4410 :
4411 3 : switch ((v__).type()) {
4412 : case type__::TPBrowserParent:
4413 : {
4414 0 : FatalError("wrong side!");
4415 0 : return;
4416 : }
4417 : case type__::TPBrowserChild:
4418 : {
4419 3 : Write((v__).get_PBrowserChild(), msg__, true);
4420 : // Sentinel = 'TPBrowserChild'
4421 3 : (msg__)->WriteSentinel(2417584432);
4422 3 : return;
4423 : }
4424 : case type__::TTabId:
4425 : {
4426 0 : Write((v__).get_TabId(), msg__);
4427 : // Sentinel = 'TTabId'
4428 0 : (msg__)->WriteSentinel(1071104628);
4429 0 : return;
4430 : }
4431 : default:
4432 : {
4433 0 : FatalError("unknown union type");
4434 0 : return;
4435 : }
4436 : }
4437 : }
4438 :
4439 0 : auto PNeckoChild::Read(
4440 : PBrowserOrId* v__,
4441 : const Message* msg__,
4442 : PickleIterator* iter__) -> bool
4443 : {
4444 : typedef PBrowserOrId type__;
4445 : int type;
4446 0 : if ((!(Read((&(type)), msg__, iter__)))) {
4447 0 : mozilla::ipc::UnionTypeReadError("PBrowserOrId");
4448 0 : return false;
4449 : }
4450 : // Sentinel = 'PBrowserOrId'
4451 0 : if ((!((msg__)->ReadSentinel(iter__, 1715137324)))) {
4452 0 : mozilla::ipc::SentinelReadError("PBrowserOrId");
4453 0 : return false;
4454 : }
4455 :
4456 0 : switch (type) {
4457 : case type__::TPBrowserParent:
4458 : {
4459 0 : PBrowserChild* tmp = nullptr;
4460 0 : (*(v__)) = tmp;
4461 0 : if ((!(Read((&((v__)->get_PBrowserChild())), msg__, iter__, true)))) {
4462 0 : FatalError("Error deserializing Union type");
4463 0 : return false;
4464 : }
4465 : // Sentinel = 'TPBrowserParent'
4466 0 : if ((!((msg__)->ReadSentinel(iter__, 3996262243)))) {
4467 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4468 0 : return false;
4469 : }
4470 0 : return true;
4471 : }
4472 : case type__::TPBrowserChild:
4473 : {
4474 0 : return false;
4475 : }
4476 : case type__::TTabId:
4477 : {
4478 0 : TabId tmp = TabId();
4479 0 : (*(v__)) = tmp;
4480 0 : if ((!(Read((&((v__)->get_TabId())), msg__, iter__)))) {
4481 0 : FatalError("Error deserializing Union type");
4482 0 : return false;
4483 : }
4484 : // Sentinel = 'TTabId'
4485 0 : if ((!((msg__)->ReadSentinel(iter__, 1071104628)))) {
4486 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4487 0 : return false;
4488 : }
4489 0 : return true;
4490 : }
4491 : default:
4492 : {
4493 0 : FatalError("unknown union type");
4494 0 : return false;
4495 : }
4496 : }
4497 : }
4498 :
4499 0 : auto PNeckoChild::Write(
4500 : const FileDescriptor& v__,
4501 : Message* msg__) -> void
4502 : {
4503 0 : FileDescriptor::PickleType pfd = (v__).ShareTo(FileDescriptor::IPDLPrivate(), OtherPid());
4504 0 : IPC::WriteParam(msg__, pfd);
4505 0 : }
4506 :
4507 0 : auto PNeckoChild::Read(
4508 : FileDescriptor* v__,
4509 : const Message* msg__,
4510 : PickleIterator* iter__) -> bool
4511 : {
4512 0 : FileDescriptor::PickleType pfd;
4513 0 : if ((!(IPC::ReadParam(msg__, iter__, (&(pfd)))))) {
4514 0 : return false;
4515 : }
4516 :
4517 0 : FileDescriptor fd = FileDescriptor(FileDescriptor::IPDLPrivate(), pfd);
4518 0 : if ((!((fd).IsValid()))) {
4519 0 : mozilla::ipc::ProtocolErrorBreakpoint("[PNeckoChild] Received an invalid file descriptor!");
4520 : }
4521 :
4522 0 : (*(v__)) = fd;
4523 0 : return true;
4524 : }
4525 :
4526 0 : auto PNeckoChild::Write(
4527 : const PNeckoChild* v__,
4528 : Message* msg__,
4529 : bool nullable__) -> void
4530 : {
4531 : int32_t id;
4532 0 : if ((!(v__))) {
4533 0 : if ((!(nullable__))) {
4534 0 : FatalError("NULL actor value passed to non-nullable param");
4535 : }
4536 0 : id = 0;
4537 : }
4538 : else {
4539 0 : id = (v__)->Id();
4540 0 : if ((1) == (id)) {
4541 0 : FatalError("actor has been |delete|d");
4542 : }
4543 : }
4544 :
4545 0 : Write(id, msg__);
4546 0 : }
4547 :
4548 0 : auto PNeckoChild::Read(
4549 : PNeckoChild** v__,
4550 : const Message* msg__,
4551 : PickleIterator* iter__,
4552 : bool nullable__) -> bool
4553 : {
4554 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PNecko", PNeckoMsgStart);
4555 0 : if ((actor).isNothing()) {
4556 0 : return false;
4557 : }
4558 :
4559 0 : (*(v__)) = static_cast<PNeckoChild*>((actor).value());
4560 0 : return true;
4561 : }
4562 :
4563 0 : auto PNeckoChild::Write(
4564 : const ExpandedPrincipalInfo& v__,
4565 : Message* msg__) -> void
4566 : {
4567 0 : Write((v__).attrs(), msg__);
4568 : // Sentinel = 'attrs'
4569 0 : (msg__)->WriteSentinel(3014987797);
4570 0 : Write((v__).whitelist(), msg__);
4571 : // Sentinel = 'whitelist'
4572 0 : (msg__)->WriteSentinel(3731637258);
4573 0 : }
4574 :
4575 0 : auto PNeckoChild::Read(
4576 : ExpandedPrincipalInfo* v__,
4577 : const Message* msg__,
4578 : PickleIterator* iter__) -> bool
4579 : {
4580 0 : if ((!(Read((&((v__)->attrs())), msg__, iter__)))) {
4581 0 : FatalError("Error deserializing 'attrs' (OriginAttributes) member of 'ExpandedPrincipalInfo'");
4582 0 : return false;
4583 : }
4584 : // Sentinel = 'attrs'
4585 0 : if ((!((msg__)->ReadSentinel(iter__, 3014987797)))) {
4586 0 : mozilla::ipc::SentinelReadError("Error deserializing 'attrs' (OriginAttributes) member of 'ExpandedPrincipalInfo'");
4587 0 : return false;
4588 : }
4589 0 : if ((!(Read((&((v__)->whitelist())), msg__, iter__)))) {
4590 0 : FatalError("Error deserializing 'whitelist' (PrincipalInfo[]) member of 'ExpandedPrincipalInfo'");
4591 0 : return false;
4592 : }
4593 : // Sentinel = 'whitelist'
4594 0 : if ((!((msg__)->ReadSentinel(iter__, 3731637258)))) {
4595 0 : mozilla::ipc::SentinelReadError("Error deserializing 'whitelist' (PrincipalInfo[]) member of 'ExpandedPrincipalInfo'");
4596 0 : return false;
4597 : }
4598 0 : return true;
4599 : }
4600 :
4601 0 : auto PNeckoChild::Write(
4602 : const BufferedInputStreamParams& v__,
4603 : Message* msg__) -> void
4604 : {
4605 0 : Write((v__).optionalStream(), msg__);
4606 : // Sentinel = 'optionalStream'
4607 0 : (msg__)->WriteSentinel(1003718562);
4608 0 : Write((v__).bufferSize(), msg__);
4609 : // Sentinel = 'bufferSize'
4610 0 : (msg__)->WriteSentinel(3444538779);
4611 0 : }
4612 :
4613 0 : auto PNeckoChild::Read(
4614 : BufferedInputStreamParams* v__,
4615 : const Message* msg__,
4616 : PickleIterator* iter__) -> bool
4617 : {
4618 0 : if ((!(Read((&((v__)->optionalStream())), msg__, iter__)))) {
4619 0 : FatalError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'BufferedInputStreamParams'");
4620 0 : return false;
4621 : }
4622 : // Sentinel = 'optionalStream'
4623 0 : if ((!((msg__)->ReadSentinel(iter__, 1003718562)))) {
4624 0 : mozilla::ipc::SentinelReadError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'BufferedInputStreamParams'");
4625 0 : return false;
4626 : }
4627 0 : if ((!(Read((&((v__)->bufferSize())), msg__, iter__)))) {
4628 0 : FatalError("Error deserializing 'bufferSize' (uint32_t) member of 'BufferedInputStreamParams'");
4629 0 : return false;
4630 : }
4631 : // Sentinel = 'bufferSize'
4632 0 : if ((!((msg__)->ReadSentinel(iter__, 3444538779)))) {
4633 0 : mozilla::ipc::SentinelReadError("Error deserializing 'bufferSize' (uint32_t) member of 'BufferedInputStreamParams'");
4634 0 : return false;
4635 : }
4636 0 : return true;
4637 : }
4638 :
4639 0 : auto PNeckoChild::Write(
4640 : const HostObjectURIParams& v__,
4641 : Message* msg__) -> void
4642 : {
4643 0 : Write((v__).simpleParams(), msg__);
4644 : // Sentinel = 'simpleParams'
4645 0 : (msg__)->WriteSentinel(3404291700);
4646 0 : Write((v__).principal(), msg__);
4647 : // Sentinel = 'principal'
4648 0 : (msg__)->WriteSentinel(732240927);
4649 0 : }
4650 :
4651 0 : auto PNeckoChild::Read(
4652 : HostObjectURIParams* v__,
4653 : const Message* msg__,
4654 : PickleIterator* iter__) -> bool
4655 : {
4656 0 : if ((!(Read((&((v__)->simpleParams())), msg__, iter__)))) {
4657 0 : FatalError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'HostObjectURIParams'");
4658 0 : return false;
4659 : }
4660 : // Sentinel = 'simpleParams'
4661 0 : if ((!((msg__)->ReadSentinel(iter__, 3404291700)))) {
4662 0 : mozilla::ipc::SentinelReadError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'HostObjectURIParams'");
4663 0 : return false;
4664 : }
4665 0 : if ((!(Read((&((v__)->principal())), msg__, iter__)))) {
4666 0 : FatalError("Error deserializing 'principal' (OptionalPrincipalInfo) member of 'HostObjectURIParams'");
4667 0 : return false;
4668 : }
4669 : // Sentinel = 'principal'
4670 0 : if ((!((msg__)->ReadSentinel(iter__, 732240927)))) {
4671 0 : mozilla::ipc::SentinelReadError("Error deserializing 'principal' (OptionalPrincipalInfo) member of 'HostObjectURIParams'");
4672 0 : return false;
4673 : }
4674 0 : return true;
4675 : }
4676 :
4677 0 : auto PNeckoChild::Write(
4678 : const InputStreamParamsWithFds& v__,
4679 : Message* msg__) -> void
4680 : {
4681 0 : Write((v__).stream(), msg__);
4682 : // Sentinel = 'stream'
4683 0 : (msg__)->WriteSentinel(4152748422);
4684 0 : Write((v__).optionalFds(), msg__);
4685 : // Sentinel = 'optionalFds'
4686 0 : (msg__)->WriteSentinel(1021803302);
4687 0 : }
4688 :
4689 0 : auto PNeckoChild::Read(
4690 : InputStreamParamsWithFds* v__,
4691 : const Message* msg__,
4692 : PickleIterator* iter__) -> bool
4693 : {
4694 0 : if ((!(Read((&((v__)->stream())), msg__, iter__)))) {
4695 0 : FatalError("Error deserializing 'stream' (InputStreamParams) member of 'InputStreamParamsWithFds'");
4696 0 : return false;
4697 : }
4698 : // Sentinel = 'stream'
4699 0 : if ((!((msg__)->ReadSentinel(iter__, 4152748422)))) {
4700 0 : mozilla::ipc::SentinelReadError("Error deserializing 'stream' (InputStreamParams) member of 'InputStreamParamsWithFds'");
4701 0 : return false;
4702 : }
4703 0 : if ((!(Read((&((v__)->optionalFds())), msg__, iter__)))) {
4704 0 : FatalError("Error deserializing 'optionalFds' (OptionalFileDescriptorSet) member of 'InputStreamParamsWithFds'");
4705 0 : return false;
4706 : }
4707 : // Sentinel = 'optionalFds'
4708 0 : if ((!((msg__)->ReadSentinel(iter__, 1021803302)))) {
4709 0 : mozilla::ipc::SentinelReadError("Error deserializing 'optionalFds' (OptionalFileDescriptorSet) member of 'InputStreamParamsWithFds'");
4710 0 : return false;
4711 : }
4712 0 : return true;
4713 : }
4714 :
4715 0 : auto PNeckoChild::Write(
4716 : const PWebSocketChild* v__,
4717 : Message* msg__,
4718 : bool nullable__) -> void
4719 : {
4720 : int32_t id;
4721 0 : if ((!(v__))) {
4722 0 : if ((!(nullable__))) {
4723 0 : FatalError("NULL actor value passed to non-nullable param");
4724 : }
4725 0 : id = 0;
4726 : }
4727 : else {
4728 0 : id = (v__)->Id();
4729 0 : if ((1) == (id)) {
4730 0 : FatalError("actor has been |delete|d");
4731 : }
4732 : }
4733 :
4734 0 : Write(id, msg__);
4735 0 : }
4736 :
4737 0 : auto PNeckoChild::Read(
4738 : PWebSocketChild** v__,
4739 : const Message* msg__,
4740 : PickleIterator* iter__,
4741 : bool nullable__) -> bool
4742 : {
4743 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PWebSocket", PWebSocketMsgStart);
4744 0 : if ((actor).isNothing()) {
4745 0 : return false;
4746 : }
4747 :
4748 0 : (*(v__)) = static_cast<PWebSocketChild*>((actor).value());
4749 0 : return true;
4750 : }
4751 :
4752 0 : auto PNeckoChild::Write(
4753 : const PFileChannelChild* v__,
4754 : Message* msg__,
4755 : bool nullable__) -> void
4756 : {
4757 : int32_t id;
4758 0 : if ((!(v__))) {
4759 0 : if ((!(nullable__))) {
4760 0 : FatalError("NULL actor value passed to non-nullable param");
4761 : }
4762 0 : id = 0;
4763 : }
4764 : else {
4765 0 : id = (v__)->Id();
4766 0 : if ((1) == (id)) {
4767 0 : FatalError("actor has been |delete|d");
4768 : }
4769 : }
4770 :
4771 0 : Write(id, msg__);
4772 0 : }
4773 :
4774 0 : auto PNeckoChild::Read(
4775 : PFileChannelChild** v__,
4776 : const Message* msg__,
4777 : PickleIterator* iter__,
4778 : bool nullable__) -> bool
4779 : {
4780 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PFileChannel", PFileChannelMsgStart);
4781 0 : if ((actor).isNothing()) {
4782 0 : return false;
4783 : }
4784 :
4785 0 : (*(v__)) = static_cast<PFileChannelChild*>((actor).value());
4786 0 : return true;
4787 : }
4788 :
4789 0 : auto PNeckoChild::Write(
4790 : const nsTArray<FileDescriptor>& v__,
4791 : Message* msg__) -> void
4792 : {
4793 0 : uint32_t length = (v__).Length();
4794 0 : Write(length, msg__);
4795 : // Sentinel = ('length', 'FileDescriptor[]')
4796 0 : (msg__)->WriteSentinel(1697726450);
4797 :
4798 0 : for (auto& elem : v__) {
4799 0 : Write(elem, msg__);
4800 : // Sentinel = 'FileDescriptor[]'
4801 0 : (msg__)->WriteSentinel(1630221245);
4802 : }
4803 0 : }
4804 :
4805 0 : auto PNeckoChild::Read(
4806 : nsTArray<FileDescriptor>* v__,
4807 : const Message* msg__,
4808 : PickleIterator* iter__) -> bool
4809 : {
4810 0 : nsTArray<FileDescriptor> fa;
4811 : uint32_t length;
4812 0 : if ((!(Read((&(length)), msg__, iter__)))) {
4813 0 : mozilla::ipc::ArrayLengthReadError("FileDescriptor[]");
4814 0 : return false;
4815 : }
4816 : // Sentinel = ('length', 'FileDescriptor[]')
4817 0 : if ((!((msg__)->ReadSentinel(iter__, 1697726450)))) {
4818 0 : mozilla::ipc::SentinelReadError("FileDescriptor[]");
4819 0 : return false;
4820 : }
4821 :
4822 0 : FileDescriptor* elems = (fa).AppendElements(length);
4823 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
4824 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
4825 0 : FatalError("Error deserializing 'FileDescriptor[i]'");
4826 0 : return false;
4827 : }
4828 : // Sentinel = 'FileDescriptor[]'
4829 0 : if ((!((msg__)->ReadSentinel(iter__, 1630221245)))) {
4830 0 : mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor[i]'");
4831 0 : return false;
4832 : }
4833 : }
4834 0 : (v__)->SwapElements(fa);
4835 0 : return true;
4836 : }
4837 :
4838 3 : auto PNeckoChild::Write(
4839 : const PHttpChannelChild* v__,
4840 : Message* msg__,
4841 : bool nullable__) -> void
4842 : {
4843 : int32_t id;
4844 3 : if ((!(v__))) {
4845 0 : if ((!(nullable__))) {
4846 0 : FatalError("NULL actor value passed to non-nullable param");
4847 : }
4848 0 : id = 0;
4849 : }
4850 : else {
4851 3 : id = (v__)->Id();
4852 3 : if ((1) == (id)) {
4853 0 : FatalError("actor has been |delete|d");
4854 : }
4855 : }
4856 :
4857 3 : Write(id, msg__);
4858 3 : }
4859 :
4860 0 : auto PNeckoChild::Read(
4861 : PHttpChannelChild** v__,
4862 : const Message* msg__,
4863 : PickleIterator* iter__,
4864 : bool nullable__) -> bool
4865 : {
4866 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PHttpChannel", PHttpChannelMsgStart);
4867 0 : if ((actor).isNothing()) {
4868 0 : return false;
4869 : }
4870 :
4871 0 : (*(v__)) = static_cast<PHttpChannelChild*>((actor).value());
4872 0 : return true;
4873 : }
4874 :
4875 0 : auto PNeckoChild::Write(
4876 : const IPCRemoteStreamType& v__,
4877 : Message* msg__) -> void
4878 : {
4879 : typedef IPCRemoteStreamType type__;
4880 0 : Write(int((v__).type()), msg__);
4881 : // Sentinel = 'IPCRemoteStreamType'
4882 0 : (msg__)->WriteSentinel(391674895);
4883 :
4884 0 : switch ((v__).type()) {
4885 : case type__::TPChildToParentStreamParent:
4886 : {
4887 0 : FatalError("wrong side!");
4888 0 : return;
4889 : }
4890 : case type__::TPChildToParentStreamChild:
4891 : {
4892 0 : Write((v__).get_PChildToParentStreamChild(), msg__, false);
4893 : // Sentinel = 'TPChildToParentStreamChild'
4894 0 : (msg__)->WriteSentinel(1882094295);
4895 0 : return;
4896 : }
4897 : case type__::TPParentToChildStreamParent:
4898 : {
4899 0 : FatalError("wrong side!");
4900 0 : return;
4901 : }
4902 : case type__::TPParentToChildStreamChild:
4903 : {
4904 0 : Write((v__).get_PParentToChildStreamChild(), msg__, false);
4905 : // Sentinel = 'TPParentToChildStreamChild'
4906 0 : (msg__)->WriteSentinel(190098493);
4907 0 : return;
4908 : }
4909 : default:
4910 : {
4911 0 : FatalError("unknown union type");
4912 0 : return;
4913 : }
4914 : }
4915 : }
4916 :
4917 0 : auto PNeckoChild::Read(
4918 : IPCRemoteStreamType* v__,
4919 : const Message* msg__,
4920 : PickleIterator* iter__) -> bool
4921 : {
4922 : typedef IPCRemoteStreamType type__;
4923 : int type;
4924 0 : if ((!(Read((&(type)), msg__, iter__)))) {
4925 0 : mozilla::ipc::UnionTypeReadError("IPCRemoteStreamType");
4926 0 : return false;
4927 : }
4928 : // Sentinel = 'IPCRemoteStreamType'
4929 0 : if ((!((msg__)->ReadSentinel(iter__, 391674895)))) {
4930 0 : mozilla::ipc::SentinelReadError("IPCRemoteStreamType");
4931 0 : return false;
4932 : }
4933 :
4934 0 : switch (type) {
4935 : case type__::TPChildToParentStreamParent:
4936 : {
4937 0 : PChildToParentStreamChild* tmp = nullptr;
4938 0 : (*(v__)) = tmp;
4939 0 : if ((!(Read((&((v__)->get_PChildToParentStreamChild())), msg__, iter__, false)))) {
4940 0 : FatalError("Error deserializing Union type");
4941 0 : return false;
4942 : }
4943 : // Sentinel = 'TPChildToParentStreamParent'
4944 0 : if ((!((msg__)->ReadSentinel(iter__, 2724777622)))) {
4945 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4946 0 : return false;
4947 : }
4948 0 : return true;
4949 : }
4950 : case type__::TPChildToParentStreamChild:
4951 : {
4952 0 : return false;
4953 : }
4954 : case type__::TPParentToChildStreamParent:
4955 : {
4956 0 : PParentToChildStreamChild* tmp = nullptr;
4957 0 : (*(v__)) = tmp;
4958 0 : if ((!(Read((&((v__)->get_PParentToChildStreamChild())), msg__, iter__, false)))) {
4959 0 : FatalError("Error deserializing Union type");
4960 0 : return false;
4961 : }
4962 : // Sentinel = 'TPParentToChildStreamParent'
4963 0 : if ((!((msg__)->ReadSentinel(iter__, 3335986876)))) {
4964 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4965 0 : return false;
4966 : }
4967 0 : return true;
4968 : }
4969 : case type__::TPParentToChildStreamChild:
4970 : {
4971 0 : return false;
4972 : }
4973 : default:
4974 : {
4975 0 : FatalError("unknown union type");
4976 0 : return false;
4977 : }
4978 : }
4979 : }
4980 :
4981 0 : auto PNeckoChild::Write(
4982 : const nsTArray<HeaderEntry>& v__,
4983 : Message* msg__) -> void
4984 : {
4985 0 : uint32_t length = (v__).Length();
4986 0 : Write(length, msg__);
4987 : // Sentinel = ('length', 'HeaderEntry[]')
4988 0 : (msg__)->WriteSentinel(2689457705);
4989 :
4990 0 : for (auto& elem : v__) {
4991 0 : Write(elem, msg__);
4992 : // Sentinel = 'HeaderEntry[]'
4993 0 : (msg__)->WriteSentinel(454836120);
4994 : }
4995 0 : }
4996 :
4997 0 : auto PNeckoChild::Read(
4998 : nsTArray<HeaderEntry>* v__,
4999 : const Message* msg__,
5000 : PickleIterator* iter__) -> bool
5001 : {
5002 0 : nsTArray<HeaderEntry> fa;
5003 : uint32_t length;
5004 0 : if ((!(Read((&(length)), msg__, iter__)))) {
5005 0 : mozilla::ipc::ArrayLengthReadError("HeaderEntry[]");
5006 0 : return false;
5007 : }
5008 : // Sentinel = ('length', 'HeaderEntry[]')
5009 0 : if ((!((msg__)->ReadSentinel(iter__, 2689457705)))) {
5010 0 : mozilla::ipc::SentinelReadError("HeaderEntry[]");
5011 0 : return false;
5012 : }
5013 :
5014 0 : HeaderEntry* elems = (fa).AppendElements(length);
5015 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
5016 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
5017 0 : FatalError("Error deserializing 'HeaderEntry[i]'");
5018 0 : return false;
5019 : }
5020 : // Sentinel = 'HeaderEntry[]'
5021 0 : if ((!((msg__)->ReadSentinel(iter__, 454836120)))) {
5022 0 : mozilla::ipc::SentinelReadError("Error deserializing 'HeaderEntry[i]'");
5023 0 : return false;
5024 : }
5025 : }
5026 0 : (v__)->SwapElements(fa);
5027 0 : return true;
5028 : }
5029 :
5030 0 : auto PNeckoChild::Write(
5031 : const HeaderEntry& v__,
5032 : Message* msg__) -> void
5033 : {
5034 0 : Write((v__).name(), msg__);
5035 : // Sentinel = 'name'
5036 0 : (msg__)->WriteSentinel(15034981);
5037 0 : Write((v__).value(), msg__);
5038 : // Sentinel = 'value'
5039 0 : (msg__)->WriteSentinel(3456818542);
5040 0 : }
5041 :
5042 0 : auto PNeckoChild::Read(
5043 : HeaderEntry* v__,
5044 : const Message* msg__,
5045 : PickleIterator* iter__) -> bool
5046 : {
5047 0 : if ((!(Read((&((v__)->name())), msg__, iter__)))) {
5048 0 : FatalError("Error deserializing 'name' (nsCString) member of 'HeaderEntry'");
5049 0 : return false;
5050 : }
5051 : // Sentinel = 'name'
5052 0 : if ((!((msg__)->ReadSentinel(iter__, 15034981)))) {
5053 0 : mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsCString) member of 'HeaderEntry'");
5054 0 : return false;
5055 : }
5056 0 : if ((!(Read((&((v__)->value())), msg__, iter__)))) {
5057 0 : FatalError("Error deserializing 'value' (nsCString) member of 'HeaderEntry'");
5058 0 : return false;
5059 : }
5060 : // Sentinel = 'value'
5061 0 : if ((!((msg__)->ReadSentinel(iter__, 3456818542)))) {
5062 0 : mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsCString) member of 'HeaderEntry'");
5063 0 : return false;
5064 : }
5065 0 : return true;
5066 : }
5067 :
5068 0 : auto PNeckoChild::Write(
5069 : const PDataChannelChild* v__,
5070 : Message* msg__,
5071 : bool nullable__) -> void
5072 : {
5073 : int32_t id;
5074 0 : if ((!(v__))) {
5075 0 : if ((!(nullable__))) {
5076 0 : FatalError("NULL actor value passed to non-nullable param");
5077 : }
5078 0 : id = 0;
5079 : }
5080 : else {
5081 0 : id = (v__)->Id();
5082 0 : if ((1) == (id)) {
5083 0 : FatalError("actor has been |delete|d");
5084 : }
5085 : }
5086 :
5087 0 : Write(id, msg__);
5088 0 : }
5089 :
5090 0 : auto PNeckoChild::Read(
5091 : PDataChannelChild** v__,
5092 : const Message* msg__,
5093 : PickleIterator* iter__,
5094 : bool nullable__) -> bool
5095 : {
5096 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PDataChannel", PDataChannelMsgStart);
5097 0 : if ((actor).isNothing()) {
5098 0 : return false;
5099 : }
5100 :
5101 0 : (*(v__)) = static_cast<PDataChannelChild*>((actor).value());
5102 0 : return true;
5103 : }
5104 :
5105 0 : auto PNeckoChild::Write(
5106 : const SlicedInputStreamParams& v__,
5107 : Message* msg__) -> void
5108 : {
5109 0 : Write((v__).stream(), msg__);
5110 : // Sentinel = 'stream'
5111 0 : (msg__)->WriteSentinel(4152748422);
5112 0 : Write((v__).start(), msg__);
5113 : // Sentinel = 'start'
5114 0 : (msg__)->WriteSentinel(2088644401);
5115 0 : Write((v__).length(), msg__);
5116 : // Sentinel = 'length'
5117 0 : (msg__)->WriteSentinel(1726618354);
5118 0 : Write((v__).curPos(), msg__);
5119 : // Sentinel = 'curPos'
5120 0 : (msg__)->WriteSentinel(4042140974);
5121 0 : Write((v__).closed(), msg__);
5122 : // Sentinel = 'closed'
5123 0 : (msg__)->WriteSentinel(561249462);
5124 0 : }
5125 :
5126 0 : auto PNeckoChild::Read(
5127 : SlicedInputStreamParams* v__,
5128 : const Message* msg__,
5129 : PickleIterator* iter__) -> bool
5130 : {
5131 0 : if ((!(Read((&((v__)->stream())), msg__, iter__)))) {
5132 0 : FatalError("Error deserializing 'stream' (InputStreamParams) member of 'SlicedInputStreamParams'");
5133 0 : return false;
5134 : }
5135 : // Sentinel = 'stream'
5136 0 : if ((!((msg__)->ReadSentinel(iter__, 4152748422)))) {
5137 0 : mozilla::ipc::SentinelReadError("Error deserializing 'stream' (InputStreamParams) member of 'SlicedInputStreamParams'");
5138 0 : return false;
5139 : }
5140 0 : if ((!(Read((&((v__)->start())), msg__, iter__)))) {
5141 0 : FatalError("Error deserializing 'start' (uint64_t) member of 'SlicedInputStreamParams'");
5142 0 : return false;
5143 : }
5144 : // Sentinel = 'start'
5145 0 : if ((!((msg__)->ReadSentinel(iter__, 2088644401)))) {
5146 0 : mozilla::ipc::SentinelReadError("Error deserializing 'start' (uint64_t) member of 'SlicedInputStreamParams'");
5147 0 : return false;
5148 : }
5149 0 : if ((!(Read((&((v__)->length())), msg__, iter__)))) {
5150 0 : FatalError("Error deserializing 'length' (uint64_t) member of 'SlicedInputStreamParams'");
5151 0 : return false;
5152 : }
5153 : // Sentinel = 'length'
5154 0 : if ((!((msg__)->ReadSentinel(iter__, 1726618354)))) {
5155 0 : mozilla::ipc::SentinelReadError("Error deserializing 'length' (uint64_t) member of 'SlicedInputStreamParams'");
5156 0 : return false;
5157 : }
5158 0 : if ((!(Read((&((v__)->curPos())), msg__, iter__)))) {
5159 0 : FatalError("Error deserializing 'curPos' (uint64_t) member of 'SlicedInputStreamParams'");
5160 0 : return false;
5161 : }
5162 : // Sentinel = 'curPos'
5163 0 : if ((!((msg__)->ReadSentinel(iter__, 4042140974)))) {
5164 0 : mozilla::ipc::SentinelReadError("Error deserializing 'curPos' (uint64_t) member of 'SlicedInputStreamParams'");
5165 0 : return false;
5166 : }
5167 0 : if ((!(Read((&((v__)->closed())), msg__, iter__)))) {
5168 0 : FatalError("Error deserializing 'closed' (bool) member of 'SlicedInputStreamParams'");
5169 0 : return false;
5170 : }
5171 : // Sentinel = 'closed'
5172 0 : if ((!((msg__)->ReadSentinel(iter__, 561249462)))) {
5173 0 : mozilla::ipc::SentinelReadError("Error deserializing 'closed' (bool) member of 'SlicedInputStreamParams'");
5174 0 : return false;
5175 : }
5176 0 : return true;
5177 : }
5178 :
5179 5 : auto PNeckoChild::Write(
5180 : const PrincipalInfo& v__,
5181 : Message* msg__) -> void
5182 : {
5183 : typedef PrincipalInfo type__;
5184 5 : Write(int((v__).type()), msg__);
5185 : // Sentinel = 'PrincipalInfo'
5186 5 : (msg__)->WriteSentinel(4194518819);
5187 :
5188 5 : switch ((v__).type()) {
5189 : case type__::TContentPrincipalInfo:
5190 : {
5191 4 : Write((v__).get_ContentPrincipalInfo(), msg__);
5192 : // Sentinel = 'TContentPrincipalInfo'
5193 4 : (msg__)->WriteSentinel(3677342258);
5194 4 : return;
5195 : }
5196 : case type__::TSystemPrincipalInfo:
5197 : {
5198 1 : Write((v__).get_SystemPrincipalInfo(), msg__);
5199 : // Sentinel = 'TSystemPrincipalInfo'
5200 1 : (msg__)->WriteSentinel(3590603679);
5201 1 : return;
5202 : }
5203 : case type__::TNullPrincipalInfo:
5204 : {
5205 0 : Write((v__).get_NullPrincipalInfo(), msg__);
5206 : // Sentinel = 'TNullPrincipalInfo'
5207 0 : (msg__)->WriteSentinel(3477774965);
5208 0 : return;
5209 : }
5210 : case type__::TExpandedPrincipalInfo:
5211 : {
5212 0 : Write((v__).get_ExpandedPrincipalInfo(), msg__);
5213 : // Sentinel = 'TExpandedPrincipalInfo'
5214 0 : (msg__)->WriteSentinel(589324917);
5215 0 : return;
5216 : }
5217 : default:
5218 : {
5219 0 : FatalError("unknown union type");
5220 0 : return;
5221 : }
5222 : }
5223 : }
5224 :
5225 0 : auto PNeckoChild::Read(
5226 : PrincipalInfo* v__,
5227 : const Message* msg__,
5228 : PickleIterator* iter__) -> bool
5229 : {
5230 : typedef PrincipalInfo type__;
5231 : int type;
5232 0 : if ((!(Read((&(type)), msg__, iter__)))) {
5233 0 : mozilla::ipc::UnionTypeReadError("PrincipalInfo");
5234 0 : return false;
5235 : }
5236 : // Sentinel = 'PrincipalInfo'
5237 0 : if ((!((msg__)->ReadSentinel(iter__, 4194518819)))) {
5238 0 : mozilla::ipc::SentinelReadError("PrincipalInfo");
5239 0 : return false;
5240 : }
5241 :
5242 0 : switch (type) {
5243 : case type__::TContentPrincipalInfo:
5244 : {
5245 0 : ContentPrincipalInfo tmp = ContentPrincipalInfo();
5246 0 : (*(v__)) = tmp;
5247 0 : if ((!(Read((&((v__)->get_ContentPrincipalInfo())), msg__, iter__)))) {
5248 0 : FatalError("Error deserializing Union type");
5249 0 : return false;
5250 : }
5251 : // Sentinel = 'TContentPrincipalInfo'
5252 0 : if ((!((msg__)->ReadSentinel(iter__, 3677342258)))) {
5253 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5254 0 : return false;
5255 : }
5256 0 : return true;
5257 : }
5258 : case type__::TSystemPrincipalInfo:
5259 : {
5260 0 : SystemPrincipalInfo tmp = SystemPrincipalInfo();
5261 0 : (*(v__)) = tmp;
5262 0 : if ((!(Read((&((v__)->get_SystemPrincipalInfo())), msg__, iter__)))) {
5263 0 : FatalError("Error deserializing Union type");
5264 0 : return false;
5265 : }
5266 : // Sentinel = 'TSystemPrincipalInfo'
5267 0 : if ((!((msg__)->ReadSentinel(iter__, 3590603679)))) {
5268 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5269 0 : return false;
5270 : }
5271 0 : return true;
5272 : }
5273 : case type__::TNullPrincipalInfo:
5274 : {
5275 0 : NullPrincipalInfo tmp = NullPrincipalInfo();
5276 0 : (*(v__)) = tmp;
5277 0 : if ((!(Read((&((v__)->get_NullPrincipalInfo())), msg__, iter__)))) {
5278 0 : FatalError("Error deserializing Union type");
5279 0 : return false;
5280 : }
5281 : // Sentinel = 'TNullPrincipalInfo'
5282 0 : if ((!((msg__)->ReadSentinel(iter__, 3477774965)))) {
5283 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5284 0 : return false;
5285 : }
5286 0 : return true;
5287 : }
5288 : case type__::TExpandedPrincipalInfo:
5289 : {
5290 0 : ExpandedPrincipalInfo tmp = ExpandedPrincipalInfo();
5291 0 : (*(v__)) = tmp;
5292 0 : if ((!(Read((&((v__)->get_ExpandedPrincipalInfo())), msg__, iter__)))) {
5293 0 : FatalError("Error deserializing Union type");
5294 0 : return false;
5295 : }
5296 : // Sentinel = 'TExpandedPrincipalInfo'
5297 0 : if ((!((msg__)->ReadSentinel(iter__, 589324917)))) {
5298 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5299 0 : return false;
5300 : }
5301 0 : return true;
5302 : }
5303 : default:
5304 : {
5305 0 : FatalError("unknown union type");
5306 0 : return false;
5307 : }
5308 : }
5309 : }
5310 :
5311 0 : auto PNeckoChild::Write(
5312 : const PTCPServerSocketChild* v__,
5313 : Message* msg__,
5314 : bool nullable__) -> void
5315 : {
5316 : int32_t id;
5317 0 : if ((!(v__))) {
5318 0 : if ((!(nullable__))) {
5319 0 : FatalError("NULL actor value passed to non-nullable param");
5320 : }
5321 0 : id = 0;
5322 : }
5323 : else {
5324 0 : id = (v__)->Id();
5325 0 : if ((1) == (id)) {
5326 0 : FatalError("actor has been |delete|d");
5327 : }
5328 : }
5329 :
5330 0 : Write(id, msg__);
5331 0 : }
5332 :
5333 0 : auto PNeckoChild::Read(
5334 : PTCPServerSocketChild** v__,
5335 : const Message* msg__,
5336 : PickleIterator* iter__,
5337 : bool nullable__) -> bool
5338 : {
5339 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PTCPServerSocket", PTCPServerSocketMsgStart);
5340 0 : if ((actor).isNothing()) {
5341 0 : return false;
5342 : }
5343 :
5344 0 : (*(v__)) = static_cast<PTCPServerSocketChild*>((actor).value());
5345 0 : return true;
5346 : }
5347 :
5348 0 : auto PNeckoChild::Write(
5349 : const TemporaryFileInputStreamParams& v__,
5350 : Message* msg__) -> void
5351 : {
5352 0 : Write((v__).fileDescriptorIndex(), msg__);
5353 : // Sentinel = 'fileDescriptorIndex'
5354 0 : (msg__)->WriteSentinel(587329112);
5355 0 : Write((v__).startPos(), msg__);
5356 : // Sentinel = 'startPos'
5357 0 : (msg__)->WriteSentinel(557207962);
5358 0 : Write((v__).endPos(), msg__);
5359 : // Sentinel = 'endPos'
5360 0 : (msg__)->WriteSentinel(881536245);
5361 0 : }
5362 :
5363 0 : auto PNeckoChild::Read(
5364 : TemporaryFileInputStreamParams* v__,
5365 : const Message* msg__,
5366 : PickleIterator* iter__) -> bool
5367 : {
5368 0 : if ((!(Read((&((v__)->fileDescriptorIndex())), msg__, iter__)))) {
5369 0 : FatalError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'TemporaryFileInputStreamParams'");
5370 0 : return false;
5371 : }
5372 : // Sentinel = 'fileDescriptorIndex'
5373 0 : if ((!((msg__)->ReadSentinel(iter__, 587329112)))) {
5374 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'TemporaryFileInputStreamParams'");
5375 0 : return false;
5376 : }
5377 0 : if ((!(Read((&((v__)->startPos())), msg__, iter__)))) {
5378 0 : FatalError("Error deserializing 'startPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
5379 0 : return false;
5380 : }
5381 : // Sentinel = 'startPos'
5382 0 : if ((!((msg__)->ReadSentinel(iter__, 557207962)))) {
5383 0 : mozilla::ipc::SentinelReadError("Error deserializing 'startPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
5384 0 : return false;
5385 : }
5386 0 : if ((!(Read((&((v__)->endPos())), msg__, iter__)))) {
5387 0 : FatalError("Error deserializing 'endPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
5388 0 : return false;
5389 : }
5390 : // Sentinel = 'endPos'
5391 0 : if ((!((msg__)->ReadSentinel(iter__, 881536245)))) {
5392 0 : mozilla::ipc::SentinelReadError("Error deserializing 'endPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
5393 0 : return false;
5394 : }
5395 0 : return true;
5396 : }
5397 :
5398 0 : auto PNeckoChild::Write(
5399 : const IPCStream& v__,
5400 : Message* msg__) -> void
5401 : {
5402 : typedef IPCStream type__;
5403 0 : Write(int((v__).type()), msg__);
5404 : // Sentinel = 'IPCStream'
5405 0 : (msg__)->WriteSentinel(442610715);
5406 :
5407 0 : switch ((v__).type()) {
5408 : case type__::TInputStreamParamsWithFds:
5409 : {
5410 0 : Write((v__).get_InputStreamParamsWithFds(), msg__);
5411 : // Sentinel = 'TInputStreamParamsWithFds'
5412 0 : (msg__)->WriteSentinel(2170706066);
5413 0 : return;
5414 : }
5415 : case type__::TIPCRemoteStream:
5416 : {
5417 0 : Write((v__).get_IPCRemoteStream(), msg__);
5418 : // Sentinel = 'TIPCRemoteStream'
5419 0 : (msg__)->WriteSentinel(2978132448);
5420 0 : return;
5421 : }
5422 : default:
5423 : {
5424 0 : FatalError("unknown union type");
5425 0 : return;
5426 : }
5427 : }
5428 : }
5429 :
5430 0 : auto PNeckoChild::Read(
5431 : IPCStream* v__,
5432 : const Message* msg__,
5433 : PickleIterator* iter__) -> bool
5434 : {
5435 : typedef IPCStream type__;
5436 : int type;
5437 0 : if ((!(Read((&(type)), msg__, iter__)))) {
5438 0 : mozilla::ipc::UnionTypeReadError("IPCStream");
5439 0 : return false;
5440 : }
5441 : // Sentinel = 'IPCStream'
5442 0 : if ((!((msg__)->ReadSentinel(iter__, 442610715)))) {
5443 0 : mozilla::ipc::SentinelReadError("IPCStream");
5444 0 : return false;
5445 : }
5446 :
5447 0 : switch (type) {
5448 : case type__::TInputStreamParamsWithFds:
5449 : {
5450 0 : InputStreamParamsWithFds tmp = InputStreamParamsWithFds();
5451 0 : (*(v__)) = tmp;
5452 0 : if ((!(Read((&((v__)->get_InputStreamParamsWithFds())), msg__, iter__)))) {
5453 0 : FatalError("Error deserializing Union type");
5454 0 : return false;
5455 : }
5456 : // Sentinel = 'TInputStreamParamsWithFds'
5457 0 : if ((!((msg__)->ReadSentinel(iter__, 2170706066)))) {
5458 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5459 0 : return false;
5460 : }
5461 0 : return true;
5462 : }
5463 : case type__::TIPCRemoteStream:
5464 : {
5465 0 : IPCRemoteStream tmp = IPCRemoteStream();
5466 0 : (*(v__)) = tmp;
5467 0 : if ((!(Read((&((v__)->get_IPCRemoteStream())), msg__, iter__)))) {
5468 0 : FatalError("Error deserializing Union type");
5469 0 : return false;
5470 : }
5471 : // Sentinel = 'TIPCRemoteStream'
5472 0 : if ((!((msg__)->ReadSentinel(iter__, 2978132448)))) {
5473 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
5474 0 : return false;
5475 : }
5476 0 : return true;
5477 : }
5478 : default:
5479 : {
5480 0 : FatalError("unknown union type");
5481 0 : return false;
5482 : }
5483 : }
5484 : }
5485 :
5486 0 : auto PNeckoChild::Write(
5487 : const JARURIParams& v__,
5488 : Message* msg__) -> void
5489 : {
5490 0 : Write((v__).jarFile(), msg__);
5491 : // Sentinel = 'jarFile'
5492 0 : (msg__)->WriteSentinel(1572070078);
5493 0 : Write((v__).jarEntry(), msg__);
5494 : // Sentinel = 'jarEntry'
5495 0 : (msg__)->WriteSentinel(941016033);
5496 0 : Write((v__).charset(), msg__);
5497 : // Sentinel = 'charset'
5498 0 : (msg__)->WriteSentinel(1551550891);
5499 0 : }
5500 :
5501 0 : auto PNeckoChild::Read(
5502 : JARURIParams* v__,
5503 : const Message* msg__,
5504 : PickleIterator* iter__) -> bool
5505 : {
5506 0 : if ((!(Read((&((v__)->jarFile())), msg__, iter__)))) {
5507 0 : FatalError("Error deserializing 'jarFile' (URIParams) member of 'JARURIParams'");
5508 0 : return false;
5509 : }
5510 : // Sentinel = 'jarFile'
5511 0 : if ((!((msg__)->ReadSentinel(iter__, 1572070078)))) {
5512 0 : mozilla::ipc::SentinelReadError("Error deserializing 'jarFile' (URIParams) member of 'JARURIParams'");
5513 0 : return false;
5514 : }
5515 0 : if ((!(Read((&((v__)->jarEntry())), msg__, iter__)))) {
5516 0 : FatalError("Error deserializing 'jarEntry' (URIParams) member of 'JARURIParams'");
5517 0 : return false;
5518 : }
5519 : // Sentinel = 'jarEntry'
5520 0 : if ((!((msg__)->ReadSentinel(iter__, 941016033)))) {
5521 0 : mozilla::ipc::SentinelReadError("Error deserializing 'jarEntry' (URIParams) member of 'JARURIParams'");
5522 0 : return false;
5523 : }
5524 0 : if ((!(Read((&((v__)->charset())), msg__, iter__)))) {
5525 0 : FatalError("Error deserializing 'charset' (nsCString) member of 'JARURIParams'");
5526 0 : return false;
5527 : }
5528 : // Sentinel = 'charset'
5529 0 : if ((!((msg__)->ReadSentinel(iter__, 1551550891)))) {
5530 0 : mozilla::ipc::SentinelReadError("Error deserializing 'charset' (nsCString) member of 'JARURIParams'");
5531 0 : return false;
5532 : }
5533 0 : return true;
5534 : }
5535 :
5536 4 : auto PNeckoChild::Write(
5537 : const ContentPrincipalInfo& v__,
5538 : Message* msg__) -> void
5539 : {
5540 4 : Write((v__).attrs(), msg__);
5541 : // Sentinel = 'attrs'
5542 4 : (msg__)->WriteSentinel(3014987797);
5543 4 : Write((v__).originNoSuffix(), msg__);
5544 : // Sentinel = 'originNoSuffix'
5545 4 : (msg__)->WriteSentinel(2833071422);
5546 4 : Write((v__).spec(), msg__);
5547 : // Sentinel = 'spec'
5548 4 : (msg__)->WriteSentinel(1630740541);
5549 4 : }
5550 :
5551 0 : auto PNeckoChild::Read(
5552 : ContentPrincipalInfo* v__,
5553 : const Message* msg__,
5554 : PickleIterator* iter__) -> bool
5555 : {
5556 0 : if ((!(Read((&((v__)->attrs())), msg__, iter__)))) {
5557 0 : FatalError("Error deserializing 'attrs' (OriginAttributes) member of 'ContentPrincipalInfo'");
5558 0 : return false;
5559 : }
5560 : // Sentinel = 'attrs'
5561 0 : if ((!((msg__)->ReadSentinel(iter__, 3014987797)))) {
5562 0 : mozilla::ipc::SentinelReadError("Error deserializing 'attrs' (OriginAttributes) member of 'ContentPrincipalInfo'");
5563 0 : return false;
5564 : }
5565 0 : if ((!(Read((&((v__)->originNoSuffix())), msg__, iter__)))) {
5566 0 : FatalError("Error deserializing 'originNoSuffix' (ContentPrincipalInfoOriginNoSuffix) member of 'ContentPrincipalInfo'");
5567 0 : return false;
5568 : }
5569 : // Sentinel = 'originNoSuffix'
5570 0 : if ((!((msg__)->ReadSentinel(iter__, 2833071422)))) {
5571 0 : mozilla::ipc::SentinelReadError("Error deserializing 'originNoSuffix' (ContentPrincipalInfoOriginNoSuffix) member of 'ContentPrincipalInfo'");
5572 0 : return false;
5573 : }
5574 0 : if ((!(Read((&((v__)->spec())), msg__, iter__)))) {
5575 0 : FatalError("Error deserializing 'spec' (nsCString) member of 'ContentPrincipalInfo'");
5576 0 : return false;
5577 : }
5578 : // Sentinel = 'spec'
5579 0 : if ((!((msg__)->ReadSentinel(iter__, 1630740541)))) {
5580 0 : mozilla::ipc::SentinelReadError("Error deserializing 'spec' (nsCString) member of 'ContentPrincipalInfo'");
5581 0 : return false;
5582 : }
5583 0 : return true;
5584 : }
5585 :
5586 0 : auto PNeckoChild::Write(
5587 : const PParentToChildStreamChild* v__,
5588 : Message* msg__,
5589 : bool nullable__) -> void
5590 : {
5591 : int32_t id;
5592 0 : if ((!(v__))) {
5593 0 : if ((!(nullable__))) {
5594 0 : FatalError("NULL actor value passed to non-nullable param");
5595 : }
5596 0 : id = 0;
5597 : }
5598 : else {
5599 0 : id = (v__)->Id();
5600 0 : if ((1) == (id)) {
5601 0 : FatalError("actor has been |delete|d");
5602 : }
5603 : }
5604 :
5605 0 : Write(id, msg__);
5606 0 : }
5607 :
5608 0 : auto PNeckoChild::Read(
5609 : PParentToChildStreamChild** v__,
5610 : const Message* msg__,
5611 : PickleIterator* iter__,
5612 : bool nullable__) -> bool
5613 : {
5614 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PParentToChildStream", PParentToChildStreamMsgStart);
5615 0 : if ((actor).isNothing()) {
5616 0 : return false;
5617 : }
5618 :
5619 0 : (*(v__)) = static_cast<PParentToChildStreamChild*>((actor).value());
5620 0 : return true;
5621 : }
5622 :
5623 3 : auto PNeckoChild::Write(
5624 : const LoadInfoArgs& v__,
5625 : Message* msg__) -> void
5626 : {
5627 3 : Write((v__).requestingPrincipalInfo(), msg__);
5628 : // Sentinel = 'requestingPrincipalInfo'
5629 3 : (msg__)->WriteSentinel(3181737698);
5630 3 : Write((v__).triggeringPrincipalInfo(), msg__);
5631 : // Sentinel = 'triggeringPrincipalInfo'
5632 3 : (msg__)->WriteSentinel(4145483429);
5633 3 : Write((v__).principalToInheritInfo(), msg__);
5634 : // Sentinel = 'principalToInheritInfo'
5635 3 : (msg__)->WriteSentinel(3087636212);
5636 3 : Write((v__).sandboxedLoadingPrincipalInfo(), msg__);
5637 : // Sentinel = 'sandboxedLoadingPrincipalInfo'
5638 3 : (msg__)->WriteSentinel(3064871301);
5639 3 : Write((v__).resultPrincipalURI(), msg__);
5640 : // Sentinel = 'resultPrincipalURI'
5641 3 : (msg__)->WriteSentinel(4283562701);
5642 3 : Write((v__).securityFlags(), msg__);
5643 : // Sentinel = 'securityFlags'
5644 3 : (msg__)->WriteSentinel(1948430358);
5645 3 : Write((v__).contentPolicyType(), msg__);
5646 : // Sentinel = 'contentPolicyType'
5647 3 : (msg__)->WriteSentinel(3089607692);
5648 3 : Write((v__).tainting(), msg__);
5649 : // Sentinel = 'tainting'
5650 3 : (msg__)->WriteSentinel(2959281848);
5651 3 : Write((v__).upgradeInsecureRequests(), msg__);
5652 : // Sentinel = 'upgradeInsecureRequests'
5653 3 : (msg__)->WriteSentinel(220885803);
5654 3 : Write((v__).verifySignedContent(), msg__);
5655 : // Sentinel = 'verifySignedContent'
5656 3 : (msg__)->WriteSentinel(4254189773);
5657 3 : Write((v__).enforceSRI(), msg__);
5658 : // Sentinel = 'enforceSRI'
5659 3 : (msg__)->WriteSentinel(3434063852);
5660 3 : Write((v__).forceInheritPrincipalDropped(), msg__);
5661 : // Sentinel = 'forceInheritPrincipalDropped'
5662 3 : (msg__)->WriteSentinel(2486717930);
5663 3 : Write((v__).innerWindowID(), msg__);
5664 : // Sentinel = 'innerWindowID'
5665 3 : (msg__)->WriteSentinel(4018103366);
5666 3 : Write((v__).outerWindowID(), msg__);
5667 : // Sentinel = 'outerWindowID'
5668 3 : (msg__)->WriteSentinel(2801565535);
5669 3 : Write((v__).parentOuterWindowID(), msg__);
5670 : // Sentinel = 'parentOuterWindowID'
5671 3 : (msg__)->WriteSentinel(1687557921);
5672 3 : Write((v__).frameOuterWindowID(), msg__);
5673 : // Sentinel = 'frameOuterWindowID'
5674 3 : (msg__)->WriteSentinel(2873618957);
5675 3 : Write((v__).enforceSecurity(), msg__);
5676 : // Sentinel = 'enforceSecurity'
5677 3 : (msg__)->WriteSentinel(646099439);
5678 3 : Write((v__).initialSecurityCheckDone(), msg__);
5679 : // Sentinel = 'initialSecurityCheckDone'
5680 3 : (msg__)->WriteSentinel(872070054);
5681 3 : Write((v__).isInThirdPartyContext(), msg__);
5682 : // Sentinel = 'isInThirdPartyContext'
5683 3 : (msg__)->WriteSentinel(525088520);
5684 3 : Write((v__).originAttributes(), msg__);
5685 : // Sentinel = 'originAttributes'
5686 3 : (msg__)->WriteSentinel(2655275965);
5687 3 : Write((v__).redirectChainIncludingInternalRedirects(), msg__);
5688 : // Sentinel = 'redirectChainIncludingInternalRedirects'
5689 3 : (msg__)->WriteSentinel(967904109);
5690 3 : Write((v__).redirectChain(), msg__);
5691 : // Sentinel = 'redirectChain'
5692 3 : (msg__)->WriteSentinel(2550711462);
5693 3 : Write((v__).corsUnsafeHeaders(), msg__);
5694 : // Sentinel = 'corsUnsafeHeaders'
5695 3 : (msg__)->WriteSentinel(2369694136);
5696 3 : Write((v__).forcePreflight(), msg__);
5697 : // Sentinel = 'forcePreflight'
5698 3 : (msg__)->WriteSentinel(2198503272);
5699 3 : Write((v__).isPreflight(), msg__);
5700 : // Sentinel = 'isPreflight'
5701 3 : (msg__)->WriteSentinel(3402379662);
5702 3 : Write((v__).forceHSTSPriming(), msg__);
5703 : // Sentinel = 'forceHSTSPriming'
5704 3 : (msg__)->WriteSentinel(1123937751);
5705 3 : Write((v__).mixedContentWouldBlock(), msg__);
5706 : // Sentinel = 'mixedContentWouldBlock'
5707 3 : (msg__)->WriteSentinel(3609505564);
5708 3 : Write((v__).isHSTSPriming(), msg__);
5709 : // Sentinel = 'isHSTSPriming'
5710 3 : (msg__)->WriteSentinel(3794927777);
5711 3 : Write((v__).isHSTSPrimingUpgrade(), msg__);
5712 : // Sentinel = 'isHSTSPrimingUpgrade'
5713 3 : (msg__)->WriteSentinel(3851270092);
5714 3 : }
5715 :
5716 0 : auto PNeckoChild::Read(
5717 : LoadInfoArgs* v__,
5718 : const Message* msg__,
5719 : PickleIterator* iter__) -> bool
5720 : {
5721 0 : if ((!(Read((&((v__)->requestingPrincipalInfo())), msg__, iter__)))) {
5722 0 : FatalError("Error deserializing 'requestingPrincipalInfo' (OptionalPrincipalInfo) member of 'LoadInfoArgs'");
5723 0 : return false;
5724 : }
5725 : // Sentinel = 'requestingPrincipalInfo'
5726 0 : if ((!((msg__)->ReadSentinel(iter__, 3181737698)))) {
5727 0 : mozilla::ipc::SentinelReadError("Error deserializing 'requestingPrincipalInfo' (OptionalPrincipalInfo) member of 'LoadInfoArgs'");
5728 0 : return false;
5729 : }
5730 0 : if ((!(Read((&((v__)->triggeringPrincipalInfo())), msg__, iter__)))) {
5731 0 : FatalError("Error deserializing 'triggeringPrincipalInfo' (PrincipalInfo) member of 'LoadInfoArgs'");
5732 0 : return false;
5733 : }
5734 : // Sentinel = 'triggeringPrincipalInfo'
5735 0 : if ((!((msg__)->ReadSentinel(iter__, 4145483429)))) {
5736 0 : mozilla::ipc::SentinelReadError("Error deserializing 'triggeringPrincipalInfo' (PrincipalInfo) member of 'LoadInfoArgs'");
5737 0 : return false;
5738 : }
5739 0 : if ((!(Read((&((v__)->principalToInheritInfo())), msg__, iter__)))) {
5740 0 : FatalError("Error deserializing 'principalToInheritInfo' (OptionalPrincipalInfo) member of 'LoadInfoArgs'");
5741 0 : return false;
5742 : }
5743 : // Sentinel = 'principalToInheritInfo'
5744 0 : if ((!((msg__)->ReadSentinel(iter__, 3087636212)))) {
5745 0 : mozilla::ipc::SentinelReadError("Error deserializing 'principalToInheritInfo' (OptionalPrincipalInfo) member of 'LoadInfoArgs'");
5746 0 : return false;
5747 : }
5748 0 : if ((!(Read((&((v__)->sandboxedLoadingPrincipalInfo())), msg__, iter__)))) {
5749 0 : FatalError("Error deserializing 'sandboxedLoadingPrincipalInfo' (OptionalPrincipalInfo) member of 'LoadInfoArgs'");
5750 0 : return false;
5751 : }
5752 : // Sentinel = 'sandboxedLoadingPrincipalInfo'
5753 0 : if ((!((msg__)->ReadSentinel(iter__, 3064871301)))) {
5754 0 : mozilla::ipc::SentinelReadError("Error deserializing 'sandboxedLoadingPrincipalInfo' (OptionalPrincipalInfo) member of 'LoadInfoArgs'");
5755 0 : return false;
5756 : }
5757 0 : if ((!(Read((&((v__)->resultPrincipalURI())), msg__, iter__)))) {
5758 0 : FatalError("Error deserializing 'resultPrincipalURI' (OptionalURIParams) member of 'LoadInfoArgs'");
5759 0 : return false;
5760 : }
5761 : // Sentinel = 'resultPrincipalURI'
5762 0 : if ((!((msg__)->ReadSentinel(iter__, 4283562701)))) {
5763 0 : mozilla::ipc::SentinelReadError("Error deserializing 'resultPrincipalURI' (OptionalURIParams) member of 'LoadInfoArgs'");
5764 0 : return false;
5765 : }
5766 0 : if ((!(Read((&((v__)->securityFlags())), msg__, iter__)))) {
5767 0 : FatalError("Error deserializing 'securityFlags' (uint32_t) member of 'LoadInfoArgs'");
5768 0 : return false;
5769 : }
5770 : // Sentinel = 'securityFlags'
5771 0 : if ((!((msg__)->ReadSentinel(iter__, 1948430358)))) {
5772 0 : mozilla::ipc::SentinelReadError("Error deserializing 'securityFlags' (uint32_t) member of 'LoadInfoArgs'");
5773 0 : return false;
5774 : }
5775 0 : if ((!(Read((&((v__)->contentPolicyType())), msg__, iter__)))) {
5776 0 : FatalError("Error deserializing 'contentPolicyType' (uint32_t) member of 'LoadInfoArgs'");
5777 0 : return false;
5778 : }
5779 : // Sentinel = 'contentPolicyType'
5780 0 : if ((!((msg__)->ReadSentinel(iter__, 3089607692)))) {
5781 0 : mozilla::ipc::SentinelReadError("Error deserializing 'contentPolicyType' (uint32_t) member of 'LoadInfoArgs'");
5782 0 : return false;
5783 : }
5784 0 : if ((!(Read((&((v__)->tainting())), msg__, iter__)))) {
5785 0 : FatalError("Error deserializing 'tainting' (uint32_t) member of 'LoadInfoArgs'");
5786 0 : return false;
5787 : }
5788 : // Sentinel = 'tainting'
5789 0 : if ((!((msg__)->ReadSentinel(iter__, 2959281848)))) {
5790 0 : mozilla::ipc::SentinelReadError("Error deserializing 'tainting' (uint32_t) member of 'LoadInfoArgs'");
5791 0 : return false;
5792 : }
5793 0 : if ((!(Read((&((v__)->upgradeInsecureRequests())), msg__, iter__)))) {
5794 0 : FatalError("Error deserializing 'upgradeInsecureRequests' (bool) member of 'LoadInfoArgs'");
5795 0 : return false;
5796 : }
5797 : // Sentinel = 'upgradeInsecureRequests'
5798 0 : if ((!((msg__)->ReadSentinel(iter__, 220885803)))) {
5799 0 : mozilla::ipc::SentinelReadError("Error deserializing 'upgradeInsecureRequests' (bool) member of 'LoadInfoArgs'");
5800 0 : return false;
5801 : }
5802 0 : if ((!(Read((&((v__)->verifySignedContent())), msg__, iter__)))) {
5803 0 : FatalError("Error deserializing 'verifySignedContent' (bool) member of 'LoadInfoArgs'");
5804 0 : return false;
5805 : }
5806 : // Sentinel = 'verifySignedContent'
5807 0 : if ((!((msg__)->ReadSentinel(iter__, 4254189773)))) {
5808 0 : mozilla::ipc::SentinelReadError("Error deserializing 'verifySignedContent' (bool) member of 'LoadInfoArgs'");
5809 0 : return false;
5810 : }
5811 0 : if ((!(Read((&((v__)->enforceSRI())), msg__, iter__)))) {
5812 0 : FatalError("Error deserializing 'enforceSRI' (bool) member of 'LoadInfoArgs'");
5813 0 : return false;
5814 : }
5815 : // Sentinel = 'enforceSRI'
5816 0 : if ((!((msg__)->ReadSentinel(iter__, 3434063852)))) {
5817 0 : mozilla::ipc::SentinelReadError("Error deserializing 'enforceSRI' (bool) member of 'LoadInfoArgs'");
5818 0 : return false;
5819 : }
5820 0 : if ((!(Read((&((v__)->forceInheritPrincipalDropped())), msg__, iter__)))) {
5821 0 : FatalError("Error deserializing 'forceInheritPrincipalDropped' (bool) member of 'LoadInfoArgs'");
5822 0 : return false;
5823 : }
5824 : // Sentinel = 'forceInheritPrincipalDropped'
5825 0 : if ((!((msg__)->ReadSentinel(iter__, 2486717930)))) {
5826 0 : mozilla::ipc::SentinelReadError("Error deserializing 'forceInheritPrincipalDropped' (bool) member of 'LoadInfoArgs'");
5827 0 : return false;
5828 : }
5829 0 : if ((!(Read((&((v__)->innerWindowID())), msg__, iter__)))) {
5830 0 : FatalError("Error deserializing 'innerWindowID' (uint64_t) member of 'LoadInfoArgs'");
5831 0 : return false;
5832 : }
5833 : // Sentinel = 'innerWindowID'
5834 0 : if ((!((msg__)->ReadSentinel(iter__, 4018103366)))) {
5835 0 : mozilla::ipc::SentinelReadError("Error deserializing 'innerWindowID' (uint64_t) member of 'LoadInfoArgs'");
5836 0 : return false;
5837 : }
5838 0 : if ((!(Read((&((v__)->outerWindowID())), msg__, iter__)))) {
5839 0 : FatalError("Error deserializing 'outerWindowID' (uint64_t) member of 'LoadInfoArgs'");
5840 0 : return false;
5841 : }
5842 : // Sentinel = 'outerWindowID'
5843 0 : if ((!((msg__)->ReadSentinel(iter__, 2801565535)))) {
5844 0 : mozilla::ipc::SentinelReadError("Error deserializing 'outerWindowID' (uint64_t) member of 'LoadInfoArgs'");
5845 0 : return false;
5846 : }
5847 0 : if ((!(Read((&((v__)->parentOuterWindowID())), msg__, iter__)))) {
5848 0 : FatalError("Error deserializing 'parentOuterWindowID' (uint64_t) member of 'LoadInfoArgs'");
5849 0 : return false;
5850 : }
5851 : // Sentinel = 'parentOuterWindowID'
5852 0 : if ((!((msg__)->ReadSentinel(iter__, 1687557921)))) {
5853 0 : mozilla::ipc::SentinelReadError("Error deserializing 'parentOuterWindowID' (uint64_t) member of 'LoadInfoArgs'");
5854 0 : return false;
5855 : }
5856 0 : if ((!(Read((&((v__)->frameOuterWindowID())), msg__, iter__)))) {
5857 0 : FatalError("Error deserializing 'frameOuterWindowID' (uint64_t) member of 'LoadInfoArgs'");
5858 0 : return false;
5859 : }
5860 : // Sentinel = 'frameOuterWindowID'
5861 0 : if ((!((msg__)->ReadSentinel(iter__, 2873618957)))) {
5862 0 : mozilla::ipc::SentinelReadError("Error deserializing 'frameOuterWindowID' (uint64_t) member of 'LoadInfoArgs'");
5863 0 : return false;
5864 : }
5865 0 : if ((!(Read((&((v__)->enforceSecurity())), msg__, iter__)))) {
5866 0 : FatalError("Error deserializing 'enforceSecurity' (bool) member of 'LoadInfoArgs'");
5867 0 : return false;
5868 : }
5869 : // Sentinel = 'enforceSecurity'
5870 0 : if ((!((msg__)->ReadSentinel(iter__, 646099439)))) {
5871 0 : mozilla::ipc::SentinelReadError("Error deserializing 'enforceSecurity' (bool) member of 'LoadInfoArgs'");
5872 0 : return false;
5873 : }
5874 0 : if ((!(Read((&((v__)->initialSecurityCheckDone())), msg__, iter__)))) {
5875 0 : FatalError("Error deserializing 'initialSecurityCheckDone' (bool) member of 'LoadInfoArgs'");
5876 0 : return false;
5877 : }
5878 : // Sentinel = 'initialSecurityCheckDone'
5879 0 : if ((!((msg__)->ReadSentinel(iter__, 872070054)))) {
5880 0 : mozilla::ipc::SentinelReadError("Error deserializing 'initialSecurityCheckDone' (bool) member of 'LoadInfoArgs'");
5881 0 : return false;
5882 : }
5883 0 : if ((!(Read((&((v__)->isInThirdPartyContext())), msg__, iter__)))) {
5884 0 : FatalError("Error deserializing 'isInThirdPartyContext' (bool) member of 'LoadInfoArgs'");
5885 0 : return false;
5886 : }
5887 : // Sentinel = 'isInThirdPartyContext'
5888 0 : if ((!((msg__)->ReadSentinel(iter__, 525088520)))) {
5889 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isInThirdPartyContext' (bool) member of 'LoadInfoArgs'");
5890 0 : return false;
5891 : }
5892 0 : if ((!(Read((&((v__)->originAttributes())), msg__, iter__)))) {
5893 0 : FatalError("Error deserializing 'originAttributes' (OriginAttributes) member of 'LoadInfoArgs'");
5894 0 : return false;
5895 : }
5896 : // Sentinel = 'originAttributes'
5897 0 : if ((!((msg__)->ReadSentinel(iter__, 2655275965)))) {
5898 0 : mozilla::ipc::SentinelReadError("Error deserializing 'originAttributes' (OriginAttributes) member of 'LoadInfoArgs'");
5899 0 : return false;
5900 : }
5901 0 : if ((!(Read((&((v__)->redirectChainIncludingInternalRedirects())), msg__, iter__)))) {
5902 0 : FatalError("Error deserializing 'redirectChainIncludingInternalRedirects' (RedirectHistoryEntryInfo[]) member of 'LoadInfoArgs'");
5903 0 : return false;
5904 : }
5905 : // Sentinel = 'redirectChainIncludingInternalRedirects'
5906 0 : if ((!((msg__)->ReadSentinel(iter__, 967904109)))) {
5907 0 : mozilla::ipc::SentinelReadError("Error deserializing 'redirectChainIncludingInternalRedirects' (RedirectHistoryEntryInfo[]) member of 'LoadInfoArgs'");
5908 0 : return false;
5909 : }
5910 0 : if ((!(Read((&((v__)->redirectChain())), msg__, iter__)))) {
5911 0 : FatalError("Error deserializing 'redirectChain' (RedirectHistoryEntryInfo[]) member of 'LoadInfoArgs'");
5912 0 : return false;
5913 : }
5914 : // Sentinel = 'redirectChain'
5915 0 : if ((!((msg__)->ReadSentinel(iter__, 2550711462)))) {
5916 0 : mozilla::ipc::SentinelReadError("Error deserializing 'redirectChain' (RedirectHistoryEntryInfo[]) member of 'LoadInfoArgs'");
5917 0 : return false;
5918 : }
5919 0 : if ((!(Read((&((v__)->corsUnsafeHeaders())), msg__, iter__)))) {
5920 0 : FatalError("Error deserializing 'corsUnsafeHeaders' (nsCString[]) member of 'LoadInfoArgs'");
5921 0 : return false;
5922 : }
5923 : // Sentinel = 'corsUnsafeHeaders'
5924 0 : if ((!((msg__)->ReadSentinel(iter__, 2369694136)))) {
5925 0 : mozilla::ipc::SentinelReadError("Error deserializing 'corsUnsafeHeaders' (nsCString[]) member of 'LoadInfoArgs'");
5926 0 : return false;
5927 : }
5928 0 : if ((!(Read((&((v__)->forcePreflight())), msg__, iter__)))) {
5929 0 : FatalError("Error deserializing 'forcePreflight' (bool) member of 'LoadInfoArgs'");
5930 0 : return false;
5931 : }
5932 : // Sentinel = 'forcePreflight'
5933 0 : if ((!((msg__)->ReadSentinel(iter__, 2198503272)))) {
5934 0 : mozilla::ipc::SentinelReadError("Error deserializing 'forcePreflight' (bool) member of 'LoadInfoArgs'");
5935 0 : return false;
5936 : }
5937 0 : if ((!(Read((&((v__)->isPreflight())), msg__, iter__)))) {
5938 0 : FatalError("Error deserializing 'isPreflight' (bool) member of 'LoadInfoArgs'");
5939 0 : return false;
5940 : }
5941 : // Sentinel = 'isPreflight'
5942 0 : if ((!((msg__)->ReadSentinel(iter__, 3402379662)))) {
5943 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isPreflight' (bool) member of 'LoadInfoArgs'");
5944 0 : return false;
5945 : }
5946 0 : if ((!(Read((&((v__)->forceHSTSPriming())), msg__, iter__)))) {
5947 0 : FatalError("Error deserializing 'forceHSTSPriming' (bool) member of 'LoadInfoArgs'");
5948 0 : return false;
5949 : }
5950 : // Sentinel = 'forceHSTSPriming'
5951 0 : if ((!((msg__)->ReadSentinel(iter__, 1123937751)))) {
5952 0 : mozilla::ipc::SentinelReadError("Error deserializing 'forceHSTSPriming' (bool) member of 'LoadInfoArgs'");
5953 0 : return false;
5954 : }
5955 0 : if ((!(Read((&((v__)->mixedContentWouldBlock())), msg__, iter__)))) {
5956 0 : FatalError("Error deserializing 'mixedContentWouldBlock' (bool) member of 'LoadInfoArgs'");
5957 0 : return false;
5958 : }
5959 : // Sentinel = 'mixedContentWouldBlock'
5960 0 : if ((!((msg__)->ReadSentinel(iter__, 3609505564)))) {
5961 0 : mozilla::ipc::SentinelReadError("Error deserializing 'mixedContentWouldBlock' (bool) member of 'LoadInfoArgs'");
5962 0 : return false;
5963 : }
5964 0 : if ((!(Read((&((v__)->isHSTSPriming())), msg__, iter__)))) {
5965 0 : FatalError("Error deserializing 'isHSTSPriming' (bool) member of 'LoadInfoArgs'");
5966 0 : return false;
5967 : }
5968 : // Sentinel = 'isHSTSPriming'
5969 0 : if ((!((msg__)->ReadSentinel(iter__, 3794927777)))) {
5970 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isHSTSPriming' (bool) member of 'LoadInfoArgs'");
5971 0 : return false;
5972 : }
5973 0 : if ((!(Read((&((v__)->isHSTSPrimingUpgrade())), msg__, iter__)))) {
5974 0 : FatalError("Error deserializing 'isHSTSPrimingUpgrade' (bool) member of 'LoadInfoArgs'");
5975 0 : return false;
5976 : }
5977 : // Sentinel = 'isHSTSPrimingUpgrade'
5978 0 : if ((!((msg__)->ReadSentinel(iter__, 3851270092)))) {
5979 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isHSTSPrimingUpgrade' (bool) member of 'LoadInfoArgs'");
5980 0 : return false;
5981 : }
5982 0 : return true;
5983 : }
5984 :
5985 3 : auto PNeckoChild::Write(
5986 : const HttpChannelCreationArgs& v__,
5987 : Message* msg__) -> void
5988 : {
5989 : typedef HttpChannelCreationArgs type__;
5990 3 : Write(int((v__).type()), msg__);
5991 : // Sentinel = 'HttpChannelCreationArgs'
5992 3 : (msg__)->WriteSentinel(2242561662);
5993 :
5994 3 : switch ((v__).type()) {
5995 : case type__::THttpChannelOpenArgs:
5996 : {
5997 3 : Write((v__).get_HttpChannelOpenArgs(), msg__);
5998 : // Sentinel = 'THttpChannelOpenArgs'
5999 3 : (msg__)->WriteSentinel(273235350);
6000 3 : return;
6001 : }
6002 : case type__::THttpChannelConnectArgs:
6003 : {
6004 0 : Write((v__).get_HttpChannelConnectArgs(), msg__);
6005 : // Sentinel = 'THttpChannelConnectArgs'
6006 0 : (msg__)->WriteSentinel(3100124069);
6007 0 : return;
6008 : }
6009 : default:
6010 : {
6011 0 : FatalError("unknown union type");
6012 0 : return;
6013 : }
6014 : }
6015 : }
6016 :
6017 0 : auto PNeckoChild::Read(
6018 : HttpChannelCreationArgs* v__,
6019 : const Message* msg__,
6020 : PickleIterator* iter__) -> bool
6021 : {
6022 : typedef HttpChannelCreationArgs type__;
6023 : int type;
6024 0 : if ((!(Read((&(type)), msg__, iter__)))) {
6025 0 : mozilla::ipc::UnionTypeReadError("HttpChannelCreationArgs");
6026 0 : return false;
6027 : }
6028 : // Sentinel = 'HttpChannelCreationArgs'
6029 0 : if ((!((msg__)->ReadSentinel(iter__, 2242561662)))) {
6030 0 : mozilla::ipc::SentinelReadError("HttpChannelCreationArgs");
6031 0 : return false;
6032 : }
6033 :
6034 0 : switch (type) {
6035 : case type__::THttpChannelOpenArgs:
6036 : {
6037 0 : HttpChannelOpenArgs tmp = HttpChannelOpenArgs();
6038 0 : (*(v__)) = tmp;
6039 0 : if ((!(Read((&((v__)->get_HttpChannelOpenArgs())), msg__, iter__)))) {
6040 0 : FatalError("Error deserializing Union type");
6041 0 : return false;
6042 : }
6043 : // Sentinel = 'THttpChannelOpenArgs'
6044 0 : if ((!((msg__)->ReadSentinel(iter__, 273235350)))) {
6045 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
6046 0 : return false;
6047 : }
6048 0 : return true;
6049 : }
6050 : case type__::THttpChannelConnectArgs:
6051 : {
6052 0 : HttpChannelConnectArgs tmp = HttpChannelConnectArgs();
6053 0 : (*(v__)) = tmp;
6054 0 : if ((!(Read((&((v__)->get_HttpChannelConnectArgs())), msg__, iter__)))) {
6055 0 : FatalError("Error deserializing Union type");
6056 0 : return false;
6057 : }
6058 : // Sentinel = 'THttpChannelConnectArgs'
6059 0 : if ((!((msg__)->ReadSentinel(iter__, 3100124069)))) {
6060 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
6061 0 : return false;
6062 : }
6063 0 : return true;
6064 : }
6065 : default:
6066 : {
6067 0 : FatalError("unknown union type");
6068 0 : return false;
6069 : }
6070 : }
6071 : }
6072 :
6073 0 : auto PNeckoChild::Write(
6074 : const MultiplexInputStreamParams& v__,
6075 : Message* msg__) -> void
6076 : {
6077 0 : Write((v__).streams(), msg__);
6078 : // Sentinel = 'streams'
6079 0 : (msg__)->WriteSentinel(4240383220);
6080 0 : Write((v__).currentStream(), msg__);
6081 : // Sentinel = 'currentStream'
6082 0 : (msg__)->WriteSentinel(682778074);
6083 0 : Write((v__).status(), msg__);
6084 : // Sentinel = 'status'
6085 0 : (msg__)->WriteSentinel(3714608576);
6086 0 : Write((v__).startedReadingCurrent(), msg__);
6087 : // Sentinel = 'startedReadingCurrent'
6088 0 : (msg__)->WriteSentinel(970542033);
6089 0 : }
6090 :
6091 0 : auto PNeckoChild::Read(
6092 : MultiplexInputStreamParams* v__,
6093 : const Message* msg__,
6094 : PickleIterator* iter__) -> bool
6095 : {
6096 0 : if ((!(Read((&((v__)->streams())), msg__, iter__)))) {
6097 0 : FatalError("Error deserializing 'streams' (InputStreamParams[]) member of 'MultiplexInputStreamParams'");
6098 0 : return false;
6099 : }
6100 : // Sentinel = 'streams'
6101 0 : if ((!((msg__)->ReadSentinel(iter__, 4240383220)))) {
6102 0 : mozilla::ipc::SentinelReadError("Error deserializing 'streams' (InputStreamParams[]) member of 'MultiplexInputStreamParams'");
6103 0 : return false;
6104 : }
6105 0 : if ((!(Read((&((v__)->currentStream())), msg__, iter__)))) {
6106 0 : FatalError("Error deserializing 'currentStream' (uint32_t) member of 'MultiplexInputStreamParams'");
6107 0 : return false;
6108 : }
6109 : // Sentinel = 'currentStream'
6110 0 : if ((!((msg__)->ReadSentinel(iter__, 682778074)))) {
6111 0 : mozilla::ipc::SentinelReadError("Error deserializing 'currentStream' (uint32_t) member of 'MultiplexInputStreamParams'");
6112 0 : return false;
6113 : }
6114 0 : if ((!(Read((&((v__)->status())), msg__, iter__)))) {
6115 0 : FatalError("Error deserializing 'status' (nsresult) member of 'MultiplexInputStreamParams'");
6116 0 : return false;
6117 : }
6118 : // Sentinel = 'status'
6119 0 : if ((!((msg__)->ReadSentinel(iter__, 3714608576)))) {
6120 0 : mozilla::ipc::SentinelReadError("Error deserializing 'status' (nsresult) member of 'MultiplexInputStreamParams'");
6121 0 : return false;
6122 : }
6123 0 : if ((!(Read((&((v__)->startedReadingCurrent())), msg__, iter__)))) {
6124 0 : FatalError("Error deserializing 'startedReadingCurrent' (bool) member of 'MultiplexInputStreamParams'");
6125 0 : return false;
6126 : }
6127 : // Sentinel = 'startedReadingCurrent'
6128 0 : if ((!((msg__)->ReadSentinel(iter__, 970542033)))) {
6129 0 : mozilla::ipc::SentinelReadError("Error deserializing 'startedReadingCurrent' (bool) member of 'MultiplexInputStreamParams'");
6130 0 : return false;
6131 : }
6132 0 : return true;
6133 : }
6134 :
6135 0 : auto PNeckoChild::Write(
6136 : const MIMEInputStreamParams& v__,
6137 : Message* msg__) -> void
6138 : {
6139 0 : Write((v__).optionalStream(), msg__);
6140 : // Sentinel = 'optionalStream'
6141 0 : (msg__)->WriteSentinel(1003718562);
6142 0 : Write((v__).headers(), msg__);
6143 : // Sentinel = 'headers'
6144 0 : (msg__)->WriteSentinel(4284175217);
6145 0 : Write((v__).startedReading(), msg__);
6146 : // Sentinel = 'startedReading'
6147 0 : (msg__)->WriteSentinel(1906875903);
6148 0 : }
6149 :
6150 0 : auto PNeckoChild::Read(
6151 : MIMEInputStreamParams* v__,
6152 : const Message* msg__,
6153 : PickleIterator* iter__) -> bool
6154 : {
6155 0 : if ((!(Read((&((v__)->optionalStream())), msg__, iter__)))) {
6156 0 : FatalError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'MIMEInputStreamParams'");
6157 0 : return false;
6158 : }
6159 : // Sentinel = 'optionalStream'
6160 0 : if ((!((msg__)->ReadSentinel(iter__, 1003718562)))) {
6161 0 : mozilla::ipc::SentinelReadError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'MIMEInputStreamParams'");
6162 0 : return false;
6163 : }
6164 0 : if ((!(Read((&((v__)->headers())), msg__, iter__)))) {
6165 0 : FatalError("Error deserializing 'headers' (HeaderEntry[]) member of 'MIMEInputStreamParams'");
6166 0 : return false;
6167 : }
6168 : // Sentinel = 'headers'
6169 0 : if ((!((msg__)->ReadSentinel(iter__, 4284175217)))) {
6170 0 : mozilla::ipc::SentinelReadError("Error deserializing 'headers' (HeaderEntry[]) member of 'MIMEInputStreamParams'");
6171 0 : return false;
6172 : }
6173 0 : if ((!(Read((&((v__)->startedReading())), msg__, iter__)))) {
6174 0 : FatalError("Error deserializing 'startedReading' (bool) member of 'MIMEInputStreamParams'");
6175 0 : return false;
6176 : }
6177 : // Sentinel = 'startedReading'
6178 0 : if ((!((msg__)->ReadSentinel(iter__, 1906875903)))) {
6179 0 : mozilla::ipc::SentinelReadError("Error deserializing 'startedReading' (bool) member of 'MIMEInputStreamParams'");
6180 0 : return false;
6181 : }
6182 0 : return true;
6183 : }
6184 :
6185 3 : auto PNeckoChild::Write(
6186 : const OptionalLoadInfoArgs& v__,
6187 : Message* msg__) -> void
6188 : {
6189 : typedef OptionalLoadInfoArgs type__;
6190 3 : Write(int((v__).type()), msg__);
6191 : // Sentinel = 'OptionalLoadInfoArgs'
6192 3 : (msg__)->WriteSentinel(1063815263);
6193 :
6194 3 : switch ((v__).type()) {
6195 : case type__::Tvoid_t:
6196 : {
6197 0 : Write((v__).get_void_t(), msg__);
6198 : // Sentinel = 'Tvoid_t'
6199 0 : (msg__)->WriteSentinel(3041273328);
6200 0 : return;
6201 : }
6202 : case type__::TLoadInfoArgs:
6203 : {
6204 3 : Write((v__).get_LoadInfoArgs(), msg__);
6205 : // Sentinel = 'TLoadInfoArgs'
6206 3 : (msg__)->WriteSentinel(3550797606);
6207 3 : return;
6208 : }
6209 : default:
6210 : {
6211 0 : FatalError("unknown union type");
6212 0 : return;
6213 : }
6214 : }
6215 : }
6216 :
6217 0 : auto PNeckoChild::Read(
6218 : OptionalLoadInfoArgs* v__,
6219 : const Message* msg__,
6220 : PickleIterator* iter__) -> bool
6221 : {
6222 : typedef OptionalLoadInfoArgs type__;
6223 : int type;
6224 0 : if ((!(Read((&(type)), msg__, iter__)))) {
6225 0 : mozilla::ipc::UnionTypeReadError("OptionalLoadInfoArgs");
6226 0 : return false;
6227 : }
6228 : // Sentinel = 'OptionalLoadInfoArgs'
6229 0 : if ((!((msg__)->ReadSentinel(iter__, 1063815263)))) {
6230 0 : mozilla::ipc::SentinelReadError("OptionalLoadInfoArgs");
6231 0 : return false;
6232 : }
6233 :
6234 0 : switch (type) {
6235 : case type__::Tvoid_t:
6236 : {
6237 : void_t tmp = void_t();
6238 0 : (*(v__)) = tmp;
6239 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
6240 0 : FatalError("Error deserializing Union type");
6241 0 : return false;
6242 : }
6243 : // Sentinel = 'Tvoid_t'
6244 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
6245 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
6246 0 : return false;
6247 : }
6248 0 : return true;
6249 : }
6250 : case type__::TLoadInfoArgs:
6251 : {
6252 0 : LoadInfoArgs tmp = LoadInfoArgs();
6253 0 : (*(v__)) = tmp;
6254 0 : if ((!(Read((&((v__)->get_LoadInfoArgs())), msg__, iter__)))) {
6255 0 : FatalError("Error deserializing Union type");
6256 0 : return false;
6257 : }
6258 : // Sentinel = 'TLoadInfoArgs'
6259 0 : if ((!((msg__)->ReadSentinel(iter__, 3550797606)))) {
6260 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
6261 0 : return false;
6262 : }
6263 0 : return true;
6264 : }
6265 : default:
6266 : {
6267 0 : FatalError("unknown union type");
6268 0 : return false;
6269 : }
6270 : }
6271 : }
6272 :
6273 0 : auto PNeckoChild::Write(
6274 : const SimpleURIParams& v__,
6275 : Message* msg__) -> void
6276 : {
6277 0 : Write((v__).scheme(), msg__);
6278 : // Sentinel = 'scheme'
6279 0 : (msg__)->WriteSentinel(3619238715);
6280 0 : Write((v__).path(), msg__);
6281 : // Sentinel = 'path'
6282 0 : (msg__)->WriteSentinel(913629401);
6283 0 : Write((v__).ref(), msg__);
6284 : // Sentinel = 'ref'
6285 0 : (msg__)->WriteSentinel(2626476732);
6286 0 : Write((v__).query(), msg__);
6287 : // Sentinel = 'query'
6288 0 : (msg__)->WriteSentinel(4249802777);
6289 0 : Write((v__).isMutable(), msg__);
6290 : // Sentinel = 'isMutable'
6291 0 : (msg__)->WriteSentinel(3552466783);
6292 0 : }
6293 :
6294 0 : auto PNeckoChild::Read(
6295 : SimpleURIParams* v__,
6296 : const Message* msg__,
6297 : PickleIterator* iter__) -> bool
6298 : {
6299 0 : if ((!(Read((&((v__)->scheme())), msg__, iter__)))) {
6300 0 : FatalError("Error deserializing 'scheme' (nsCString) member of 'SimpleURIParams'");
6301 0 : return false;
6302 : }
6303 : // Sentinel = 'scheme'
6304 0 : if ((!((msg__)->ReadSentinel(iter__, 3619238715)))) {
6305 0 : mozilla::ipc::SentinelReadError("Error deserializing 'scheme' (nsCString) member of 'SimpleURIParams'");
6306 0 : return false;
6307 : }
6308 0 : if ((!(Read((&((v__)->path())), msg__, iter__)))) {
6309 0 : FatalError("Error deserializing 'path' (nsCString) member of 'SimpleURIParams'");
6310 0 : return false;
6311 : }
6312 : // Sentinel = 'path'
6313 0 : if ((!((msg__)->ReadSentinel(iter__, 913629401)))) {
6314 0 : mozilla::ipc::SentinelReadError("Error deserializing 'path' (nsCString) member of 'SimpleURIParams'");
6315 0 : return false;
6316 : }
6317 0 : if ((!(Read((&((v__)->ref())), msg__, iter__)))) {
6318 0 : FatalError("Error deserializing 'ref' (nsCString) member of 'SimpleURIParams'");
6319 0 : return false;
6320 : }
6321 : // Sentinel = 'ref'
6322 0 : if ((!((msg__)->ReadSentinel(iter__, 2626476732)))) {
6323 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ref' (nsCString) member of 'SimpleURIParams'");
6324 0 : return false;
6325 : }
6326 0 : if ((!(Read((&((v__)->query())), msg__, iter__)))) {
6327 0 : FatalError("Error deserializing 'query' (nsCString) member of 'SimpleURIParams'");
6328 0 : return false;
6329 : }
6330 : // Sentinel = 'query'
6331 0 : if ((!((msg__)->ReadSentinel(iter__, 4249802777)))) {
6332 0 : mozilla::ipc::SentinelReadError("Error deserializing 'query' (nsCString) member of 'SimpleURIParams'");
6333 0 : return false;
6334 : }
6335 0 : if ((!(Read((&((v__)->isMutable())), msg__, iter__)))) {
6336 0 : FatalError("Error deserializing 'isMutable' (bool) member of 'SimpleURIParams'");
6337 0 : return false;
6338 : }
6339 : // Sentinel = 'isMutable'
6340 0 : if ((!((msg__)->ReadSentinel(iter__, 3552466783)))) {
6341 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isMutable' (bool) member of 'SimpleURIParams'");
6342 0 : return false;
6343 : }
6344 0 : return true;
6345 : }
6346 :
6347 0 : auto PNeckoChild::Write(
6348 : const PCookieServiceChild* v__,
6349 : Message* msg__,
6350 : bool nullable__) -> void
6351 : {
6352 : int32_t id;
6353 0 : if ((!(v__))) {
6354 0 : if ((!(nullable__))) {
6355 0 : FatalError("NULL actor value passed to non-nullable param");
6356 : }
6357 0 : id = 0;
6358 : }
6359 : else {
6360 0 : id = (v__)->Id();
6361 0 : if ((1) == (id)) {
6362 0 : FatalError("actor has been |delete|d");
6363 : }
6364 : }
6365 :
6366 0 : Write(id, msg__);
6367 0 : }
6368 :
6369 0 : auto PNeckoChild::Read(
6370 : PCookieServiceChild** v__,
6371 : const Message* msg__,
6372 : PickleIterator* iter__,
6373 : bool nullable__) -> bool
6374 : {
6375 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PCookieService", PCookieServiceMsgStart);
6376 0 : if ((actor).isNothing()) {
6377 0 : return false;
6378 : }
6379 :
6380 0 : (*(v__)) = static_cast<PCookieServiceChild*>((actor).value());
6381 0 : return true;
6382 : }
6383 :
6384 3 : auto PNeckoChild::Write(
6385 : const OptionalIPCStream& v__,
6386 : Message* msg__) -> void
6387 : {
6388 : typedef OptionalIPCStream type__;
6389 3 : Write(int((v__).type()), msg__);
6390 : // Sentinel = 'OptionalIPCStream'
6391 3 : (msg__)->WriteSentinel(3815982647);
6392 :
6393 3 : switch ((v__).type()) {
6394 : case type__::TIPCStream:
6395 : {
6396 0 : Write((v__).get_IPCStream(), msg__);
6397 : // Sentinel = 'TIPCStream'
6398 0 : (msg__)->WriteSentinel(40701900);
6399 0 : return;
6400 : }
6401 : case type__::Tvoid_t:
6402 : {
6403 3 : Write((v__).get_void_t(), msg__);
6404 : // Sentinel = 'Tvoid_t'
6405 3 : (msg__)->WriteSentinel(3041273328);
6406 3 : return;
6407 : }
6408 : default:
6409 : {
6410 0 : FatalError("unknown union type");
6411 0 : return;
6412 : }
6413 : }
6414 : }
6415 :
6416 0 : auto PNeckoChild::Read(
6417 : OptionalIPCStream* v__,
6418 : const Message* msg__,
6419 : PickleIterator* iter__) -> bool
6420 : {
6421 : typedef OptionalIPCStream type__;
6422 : int type;
6423 0 : if ((!(Read((&(type)), msg__, iter__)))) {
6424 0 : mozilla::ipc::UnionTypeReadError("OptionalIPCStream");
6425 0 : return false;
6426 : }
6427 : // Sentinel = 'OptionalIPCStream'
6428 0 : if ((!((msg__)->ReadSentinel(iter__, 3815982647)))) {
6429 0 : mozilla::ipc::SentinelReadError("OptionalIPCStream");
6430 0 : return false;
6431 : }
6432 :
6433 0 : switch (type) {
6434 : case type__::TIPCStream:
6435 : {
6436 0 : IPCStream tmp = IPCStream();
6437 0 : (*(v__)) = tmp;
6438 0 : if ((!(Read((&((v__)->get_IPCStream())), msg__, iter__)))) {
6439 0 : FatalError("Error deserializing Union type");
6440 0 : return false;
6441 : }
6442 : // Sentinel = 'TIPCStream'
6443 0 : if ((!((msg__)->ReadSentinel(iter__, 40701900)))) {
6444 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
6445 0 : return false;
6446 : }
6447 0 : return true;
6448 : }
6449 : case type__::Tvoid_t:
6450 : {
6451 : void_t tmp = void_t();
6452 0 : (*(v__)) = tmp;
6453 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
6454 0 : FatalError("Error deserializing Union type");
6455 0 : return false;
6456 : }
6457 : // Sentinel = 'Tvoid_t'
6458 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
6459 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
6460 0 : return false;
6461 : }
6462 0 : return true;
6463 : }
6464 : default:
6465 : {
6466 0 : FatalError("unknown union type");
6467 0 : return false;
6468 : }
6469 : }
6470 : }
6471 :
6472 0 : auto PNeckoChild::Write(
6473 : const StringInputStreamParams& v__,
6474 : Message* msg__) -> void
6475 : {
6476 0 : Write((v__).data(), msg__);
6477 : // Sentinel = 'data'
6478 0 : (msg__)->WriteSentinel(843352540);
6479 0 : }
6480 :
6481 0 : auto PNeckoChild::Read(
6482 : StringInputStreamParams* v__,
6483 : const Message* msg__,
6484 : PickleIterator* iter__) -> bool
6485 : {
6486 0 : if ((!(Read((&((v__)->data())), msg__, iter__)))) {
6487 0 : FatalError("Error deserializing 'data' (nsCString) member of 'StringInputStreamParams'");
6488 0 : return false;
6489 : }
6490 : // Sentinel = 'data'
6491 0 : if ((!((msg__)->ReadSentinel(iter__, 843352540)))) {
6492 0 : mozilla::ipc::SentinelReadError("Error deserializing 'data' (nsCString) member of 'StringInputStreamParams'");
6493 0 : return false;
6494 : }
6495 0 : return true;
6496 : }
6497 :
6498 0 : auto PNeckoChild::Write(
6499 : const FTPChannelOpenArgs& v__,
6500 : Message* msg__) -> void
6501 : {
6502 0 : Write((v__).uri(), msg__);
6503 : // Sentinel = 'uri'
6504 0 : (msg__)->WriteSentinel(1453210605);
6505 0 : Write((v__).startPos(), msg__);
6506 : // Sentinel = 'startPos'
6507 0 : (msg__)->WriteSentinel(557207962);
6508 0 : Write((v__).entityID(), msg__);
6509 : // Sentinel = 'entityID'
6510 0 : (msg__)->WriteSentinel(245743354);
6511 0 : Write((v__).uploadStream(), msg__);
6512 : // Sentinel = 'uploadStream'
6513 0 : (msg__)->WriteSentinel(3559827199);
6514 0 : Write((v__).loadInfo(), msg__);
6515 : // Sentinel = 'loadInfo'
6516 0 : (msg__)->WriteSentinel(2597515304);
6517 0 : }
6518 :
6519 0 : auto PNeckoChild::Read(
6520 : FTPChannelOpenArgs* v__,
6521 : const Message* msg__,
6522 : PickleIterator* iter__) -> bool
6523 : {
6524 0 : if ((!(Read((&((v__)->uri())), msg__, iter__)))) {
6525 0 : FatalError("Error deserializing 'uri' (URIParams) member of 'FTPChannelOpenArgs'");
6526 0 : return false;
6527 : }
6528 : // Sentinel = 'uri'
6529 0 : if ((!((msg__)->ReadSentinel(iter__, 1453210605)))) {
6530 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uri' (URIParams) member of 'FTPChannelOpenArgs'");
6531 0 : return false;
6532 : }
6533 0 : if ((!(Read((&((v__)->startPos())), msg__, iter__)))) {
6534 0 : FatalError("Error deserializing 'startPos' (uint64_t) member of 'FTPChannelOpenArgs'");
6535 0 : return false;
6536 : }
6537 : // Sentinel = 'startPos'
6538 0 : if ((!((msg__)->ReadSentinel(iter__, 557207962)))) {
6539 0 : mozilla::ipc::SentinelReadError("Error deserializing 'startPos' (uint64_t) member of 'FTPChannelOpenArgs'");
6540 0 : return false;
6541 : }
6542 0 : if ((!(Read((&((v__)->entityID())), msg__, iter__)))) {
6543 0 : FatalError("Error deserializing 'entityID' (nsCString) member of 'FTPChannelOpenArgs'");
6544 0 : return false;
6545 : }
6546 : // Sentinel = 'entityID'
6547 0 : if ((!((msg__)->ReadSentinel(iter__, 245743354)))) {
6548 0 : mozilla::ipc::SentinelReadError("Error deserializing 'entityID' (nsCString) member of 'FTPChannelOpenArgs'");
6549 0 : return false;
6550 : }
6551 0 : if ((!(Read((&((v__)->uploadStream())), msg__, iter__)))) {
6552 0 : FatalError("Error deserializing 'uploadStream' (OptionalIPCStream) member of 'FTPChannelOpenArgs'");
6553 0 : return false;
6554 : }
6555 : // Sentinel = 'uploadStream'
6556 0 : if ((!((msg__)->ReadSentinel(iter__, 3559827199)))) {
6557 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uploadStream' (OptionalIPCStream) member of 'FTPChannelOpenArgs'");
6558 0 : return false;
6559 : }
6560 0 : if ((!(Read((&((v__)->loadInfo())), msg__, iter__)))) {
6561 0 : FatalError("Error deserializing 'loadInfo' (OptionalLoadInfoArgs) member of 'FTPChannelOpenArgs'");
6562 0 : return false;
6563 : }
6564 : // Sentinel = 'loadInfo'
6565 0 : if ((!((msg__)->ReadSentinel(iter__, 2597515304)))) {
6566 0 : mozilla::ipc::SentinelReadError("Error deserializing 'loadInfo' (OptionalLoadInfoArgs) member of 'FTPChannelOpenArgs'");
6567 0 : return false;
6568 : }
6569 0 : return true;
6570 : }
6571 :
6572 0 : auto PNeckoChild::Write(
6573 : const NullPrincipalURIParams& v__,
6574 : Message* msg__) -> void
6575 : {
6576 0 : }
6577 :
6578 0 : auto PNeckoChild::Read(
6579 : NullPrincipalURIParams* v__,
6580 : const Message* msg__,
6581 : PickleIterator* iter__) -> bool
6582 : {
6583 0 : return true;
6584 : }
6585 :
6586 0 : auto PNeckoChild::Write(
6587 : const IconURIParams& v__,
6588 : Message* msg__) -> void
6589 : {
6590 0 : Write((v__).uri(), msg__);
6591 : // Sentinel = 'uri'
6592 0 : (msg__)->WriteSentinel(1453210605);
6593 0 : Write((v__).size(), msg__);
6594 : // Sentinel = 'size'
6595 0 : (msg__)->WriteSentinel(931048223);
6596 0 : Write((v__).contentType(), msg__);
6597 : // Sentinel = 'contentType'
6598 0 : (msg__)->WriteSentinel(2092571716);
6599 0 : Write((v__).fileName(), msg__);
6600 : // Sentinel = 'fileName'
6601 0 : (msg__)->WriteSentinel(3833449039);
6602 0 : Write((v__).stockIcon(), msg__);
6603 : // Sentinel = 'stockIcon'
6604 0 : (msg__)->WriteSentinel(3601770784);
6605 0 : Write((v__).iconSize(), msg__);
6606 : // Sentinel = 'iconSize'
6607 0 : (msg__)->WriteSentinel(2585310920);
6608 0 : Write((v__).iconState(), msg__);
6609 : // Sentinel = 'iconState'
6610 0 : (msg__)->WriteSentinel(3444306207);
6611 0 : }
6612 :
6613 0 : auto PNeckoChild::Read(
6614 : IconURIParams* v__,
6615 : const Message* msg__,
6616 : PickleIterator* iter__) -> bool
6617 : {
6618 0 : if ((!(Read((&((v__)->uri())), msg__, iter__)))) {
6619 0 : FatalError("Error deserializing 'uri' (OptionalURIParams) member of 'IconURIParams'");
6620 0 : return false;
6621 : }
6622 : // Sentinel = 'uri'
6623 0 : if ((!((msg__)->ReadSentinel(iter__, 1453210605)))) {
6624 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uri' (OptionalURIParams) member of 'IconURIParams'");
6625 0 : return false;
6626 : }
6627 0 : if ((!(Read((&((v__)->size())), msg__, iter__)))) {
6628 0 : FatalError("Error deserializing 'size' (uint32_t) member of 'IconURIParams'");
6629 0 : return false;
6630 : }
6631 : // Sentinel = 'size'
6632 0 : if ((!((msg__)->ReadSentinel(iter__, 931048223)))) {
6633 0 : mozilla::ipc::SentinelReadError("Error deserializing 'size' (uint32_t) member of 'IconURIParams'");
6634 0 : return false;
6635 : }
6636 0 : if ((!(Read((&((v__)->contentType())), msg__, iter__)))) {
6637 0 : FatalError("Error deserializing 'contentType' (nsCString) member of 'IconURIParams'");
6638 0 : return false;
6639 : }
6640 : // Sentinel = 'contentType'
6641 0 : if ((!((msg__)->ReadSentinel(iter__, 2092571716)))) {
6642 0 : mozilla::ipc::SentinelReadError("Error deserializing 'contentType' (nsCString) member of 'IconURIParams'");
6643 0 : return false;
6644 : }
6645 0 : if ((!(Read((&((v__)->fileName())), msg__, iter__)))) {
6646 0 : FatalError("Error deserializing 'fileName' (nsCString) member of 'IconURIParams'");
6647 0 : return false;
6648 : }
6649 : // Sentinel = 'fileName'
6650 0 : if ((!((msg__)->ReadSentinel(iter__, 3833449039)))) {
6651 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fileName' (nsCString) member of 'IconURIParams'");
6652 0 : return false;
6653 : }
6654 0 : if ((!(Read((&((v__)->stockIcon())), msg__, iter__)))) {
6655 0 : FatalError("Error deserializing 'stockIcon' (nsCString) member of 'IconURIParams'");
6656 0 : return false;
6657 : }
6658 : // Sentinel = 'stockIcon'
6659 0 : if ((!((msg__)->ReadSentinel(iter__, 3601770784)))) {
6660 0 : mozilla::ipc::SentinelReadError("Error deserializing 'stockIcon' (nsCString) member of 'IconURIParams'");
6661 0 : return false;
6662 : }
6663 0 : if ((!(Read((&((v__)->iconSize())), msg__, iter__)))) {
6664 0 : FatalError("Error deserializing 'iconSize' (int32_t) member of 'IconURIParams'");
6665 0 : return false;
6666 : }
6667 : // Sentinel = 'iconSize'
6668 0 : if ((!((msg__)->ReadSentinel(iter__, 2585310920)))) {
6669 0 : mozilla::ipc::SentinelReadError("Error deserializing 'iconSize' (int32_t) member of 'IconURIParams'");
6670 0 : return false;
6671 : }
6672 0 : if ((!(Read((&((v__)->iconState())), msg__, iter__)))) {
6673 0 : FatalError("Error deserializing 'iconState' (int32_t) member of 'IconURIParams'");
6674 0 : return false;
6675 : }
6676 : // Sentinel = 'iconState'
6677 0 : if ((!((msg__)->ReadSentinel(iter__, 3444306207)))) {
6678 0 : mozilla::ipc::SentinelReadError("Error deserializing 'iconState' (int32_t) member of 'IconURIParams'");
6679 0 : return false;
6680 : }
6681 0 : return true;
6682 : }
6683 :
6684 0 : auto PNeckoChild::Write(
6685 : const PFileDescriptorSetChild* v__,
6686 : Message* msg__,
6687 : bool nullable__) -> void
6688 : {
6689 : int32_t id;
6690 0 : if ((!(v__))) {
6691 0 : if ((!(nullable__))) {
6692 0 : FatalError("NULL actor value passed to non-nullable param");
6693 : }
6694 0 : id = 0;
6695 : }
6696 : else {
6697 0 : id = (v__)->Id();
6698 0 : if ((1) == (id)) {
6699 0 : FatalError("actor has been |delete|d");
6700 : }
6701 : }
6702 :
6703 0 : Write(id, msg__);
6704 0 : }
6705 :
6706 0 : auto PNeckoChild::Read(
6707 : PFileDescriptorSetChild** v__,
6708 : const Message* msg__,
6709 : PickleIterator* iter__,
6710 : bool nullable__) -> bool
6711 : {
6712 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PFileDescriptorSet", PFileDescriptorSetMsgStart);
6713 0 : if ((actor).isNothing()) {
6714 0 : return false;
6715 : }
6716 :
6717 0 : (*(v__)) = static_cast<PFileDescriptorSetChild*>((actor).value());
6718 0 : return true;
6719 : }
6720 :
6721 3 : auto PNeckoChild::Write(
6722 : const PBrowserChild* v__,
6723 : Message* msg__,
6724 : bool nullable__) -> void
6725 : {
6726 : int32_t id;
6727 3 : if ((!(v__))) {
6728 0 : if ((!(nullable__))) {
6729 0 : FatalError("NULL actor value passed to non-nullable param");
6730 : }
6731 0 : id = 0;
6732 : }
6733 : else {
6734 3 : id = (v__)->Id();
6735 3 : if ((1) == (id)) {
6736 0 : FatalError("actor has been |delete|d");
6737 : }
6738 : }
6739 :
6740 3 : Write(id, msg__);
6741 3 : }
6742 :
6743 0 : auto PNeckoChild::Read(
6744 : PBrowserChild** v__,
6745 : const Message* msg__,
6746 : PickleIterator* iter__,
6747 : bool nullable__) -> bool
6748 : {
6749 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PBrowser", PBrowserMsgStart);
6750 0 : if ((actor).isNothing()) {
6751 0 : return false;
6752 : }
6753 :
6754 0 : (*(v__)) = static_cast<PBrowserChild*>((actor).value());
6755 0 : return true;
6756 : }
6757 :
6758 0 : auto PNeckoChild::Write(
6759 : const PRtspControllerChild* v__,
6760 : Message* msg__,
6761 : bool nullable__) -> void
6762 : {
6763 : int32_t id;
6764 0 : if ((!(v__))) {
6765 0 : if ((!(nullable__))) {
6766 0 : FatalError("NULL actor value passed to non-nullable param");
6767 : }
6768 0 : id = 0;
6769 : }
6770 : else {
6771 0 : id = (v__)->Id();
6772 0 : if ((1) == (id)) {
6773 0 : FatalError("actor has been |delete|d");
6774 : }
6775 : }
6776 :
6777 0 : Write(id, msg__);
6778 0 : }
6779 :
6780 0 : auto PNeckoChild::Read(
6781 : PRtspControllerChild** v__,
6782 : const Message* msg__,
6783 : PickleIterator* iter__,
6784 : bool nullable__) -> bool
6785 : {
6786 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PRtspController", PRtspControllerMsgStart);
6787 0 : if ((actor).isNothing()) {
6788 0 : return false;
6789 : }
6790 :
6791 0 : (*(v__)) = static_cast<PRtspControllerChild*>((actor).value());
6792 0 : return true;
6793 : }
6794 :
6795 3 : auto PNeckoChild::Write(
6796 : const HttpChannelOpenArgs& v__,
6797 : Message* msg__) -> void
6798 : {
6799 3 : Write((v__).uri(), msg__);
6800 : // Sentinel = 'uri'
6801 3 : (msg__)->WriteSentinel(1453210605);
6802 3 : Write((v__).original(), msg__);
6803 : // Sentinel = 'original'
6804 3 : (msg__)->WriteSentinel(3262287869);
6805 3 : Write((v__).doc(), msg__);
6806 : // Sentinel = 'doc'
6807 3 : (msg__)->WriteSentinel(1528775657);
6808 3 : Write((v__).referrer(), msg__);
6809 : // Sentinel = 'referrer'
6810 3 : (msg__)->WriteSentinel(3770987113);
6811 3 : Write((v__).referrerPolicy(), msg__);
6812 : // Sentinel = 'referrerPolicy'
6813 3 : (msg__)->WriteSentinel(2269890057);
6814 3 : Write((v__).apiRedirectTo(), msg__);
6815 : // Sentinel = 'apiRedirectTo'
6816 3 : (msg__)->WriteSentinel(3162811030);
6817 3 : Write((v__).topWindowURI(), msg__);
6818 : // Sentinel = 'topWindowURI'
6819 3 : (msg__)->WriteSentinel(2325499925);
6820 3 : Write((v__).loadFlags(), msg__);
6821 : // Sentinel = 'loadFlags'
6822 3 : (msg__)->WriteSentinel(2391120444);
6823 3 : Write((v__).requestHeaders(), msg__);
6824 : // Sentinel = 'requestHeaders'
6825 3 : (msg__)->WriteSentinel(2055989545);
6826 3 : Write((v__).requestMethod(), msg__);
6827 : // Sentinel = 'requestMethod'
6828 3 : (msg__)->WriteSentinel(2210890865);
6829 3 : Write((v__).uploadStream(), msg__);
6830 : // Sentinel = 'uploadStream'
6831 3 : (msg__)->WriteSentinel(3559827199);
6832 3 : Write((v__).uploadStreamHasHeaders(), msg__);
6833 : // Sentinel = 'uploadStreamHasHeaders'
6834 3 : (msg__)->WriteSentinel(670009587);
6835 3 : Write((v__).priority(), msg__);
6836 : // Sentinel = 'priority'
6837 3 : (msg__)->WriteSentinel(558136112);
6838 3 : Write((v__).classOfService(), msg__);
6839 : // Sentinel = 'classOfService'
6840 3 : (msg__)->WriteSentinel(1829468214);
6841 3 : Write((v__).redirectionLimit(), msg__);
6842 : // Sentinel = 'redirectionLimit'
6843 3 : (msg__)->WriteSentinel(1070866783);
6844 3 : Write((v__).allowSTS(), msg__);
6845 : // Sentinel = 'allowSTS'
6846 3 : (msg__)->WriteSentinel(384958533);
6847 3 : Write((v__).thirdPartyFlags(), msg__);
6848 : // Sentinel = 'thirdPartyFlags'
6849 3 : (msg__)->WriteSentinel(3577174809);
6850 3 : Write((v__).resumeAt(), msg__);
6851 : // Sentinel = 'resumeAt'
6852 3 : (msg__)->WriteSentinel(866346170);
6853 3 : Write((v__).startPos(), msg__);
6854 : // Sentinel = 'startPos'
6855 3 : (msg__)->WriteSentinel(557207962);
6856 3 : Write((v__).entityID(), msg__);
6857 : // Sentinel = 'entityID'
6858 3 : (msg__)->WriteSentinel(245743354);
6859 3 : Write((v__).chooseApplicationCache(), msg__);
6860 : // Sentinel = 'chooseApplicationCache'
6861 3 : (msg__)->WriteSentinel(2898467869);
6862 3 : Write((v__).appCacheClientID(), msg__);
6863 : // Sentinel = 'appCacheClientID'
6864 3 : (msg__)->WriteSentinel(3495226687);
6865 3 : Write((v__).allowSpdy(), msg__);
6866 : // Sentinel = 'allowSpdy'
6867 3 : (msg__)->WriteSentinel(1630260538);
6868 3 : Write((v__).allowAltSvc(), msg__);
6869 : // Sentinel = 'allowAltSvc'
6870 3 : (msg__)->WriteSentinel(879875677);
6871 3 : Write((v__).beConservative(), msg__);
6872 : // Sentinel = 'beConservative'
6873 3 : (msg__)->WriteSentinel(1177063294);
6874 3 : Write((v__).loadInfo(), msg__);
6875 : // Sentinel = 'loadInfo'
6876 3 : (msg__)->WriteSentinel(2597515304);
6877 3 : Write((v__).synthesizedResponseHead(), msg__);
6878 : // Sentinel = 'synthesizedResponseHead'
6879 3 : (msg__)->WriteSentinel(588784596);
6880 3 : Write((v__).synthesizedSecurityInfoSerialization(), msg__);
6881 : // Sentinel = 'synthesizedSecurityInfoSerialization'
6882 3 : (msg__)->WriteSentinel(2702766326);
6883 3 : Write((v__).cacheKey(), msg__);
6884 : // Sentinel = 'cacheKey'
6885 3 : (msg__)->WriteSentinel(249191363);
6886 3 : Write((v__).requestContextID(), msg__);
6887 : // Sentinel = 'requestContextID'
6888 3 : (msg__)->WriteSentinel(2427410503);
6889 3 : Write((v__).preflightArgs(), msg__);
6890 : // Sentinel = 'preflightArgs'
6891 3 : (msg__)->WriteSentinel(2363616251);
6892 3 : Write((v__).initialRwin(), msg__);
6893 : // Sentinel = 'initialRwin'
6894 3 : (msg__)->WriteSentinel(967782407);
6895 3 : Write((v__).blockAuthPrompt(), msg__);
6896 : // Sentinel = 'blockAuthPrompt'
6897 3 : (msg__)->WriteSentinel(1543637500);
6898 3 : Write((v__).suspendAfterSynthesizeResponse(), msg__);
6899 : // Sentinel = 'suspendAfterSynthesizeResponse'
6900 3 : (msg__)->WriteSentinel(656622613);
6901 3 : Write((v__).allowStaleCacheContent(), msg__);
6902 : // Sentinel = 'allowStaleCacheContent'
6903 3 : (msg__)->WriteSentinel(3064959537);
6904 3 : Write((v__).contentTypeHint(), msg__);
6905 : // Sentinel = 'contentTypeHint'
6906 3 : (msg__)->WriteSentinel(2155295759);
6907 3 : Write((v__).channelId(), msg__);
6908 : // Sentinel = 'channelId'
6909 3 : (msg__)->WriteSentinel(6854027);
6910 3 : Write((v__).contentWindowId(), msg__);
6911 : // Sentinel = 'contentWindowId'
6912 3 : (msg__)->WriteSentinel(2188138839);
6913 3 : Write((v__).preferredAlternativeType(), msg__);
6914 : // Sentinel = 'preferredAlternativeType'
6915 3 : (msg__)->WriteSentinel(1019174360);
6916 3 : Write((v__).topLevelOuterContentWindowId(), msg__);
6917 : // Sentinel = 'topLevelOuterContentWindowId'
6918 3 : (msg__)->WriteSentinel(810319786);
6919 3 : Write((v__).launchServiceWorkerStart(), msg__);
6920 : // Sentinel = 'launchServiceWorkerStart'
6921 3 : (msg__)->WriteSentinel(1191023364);
6922 3 : Write((v__).launchServiceWorkerEnd(), msg__);
6923 : // Sentinel = 'launchServiceWorkerEnd'
6924 3 : (msg__)->WriteSentinel(2236809033);
6925 3 : Write((v__).dispatchFetchEventStart(), msg__);
6926 : // Sentinel = 'dispatchFetchEventStart'
6927 3 : (msg__)->WriteSentinel(2132895785);
6928 3 : Write((v__).dispatchFetchEventEnd(), msg__);
6929 : // Sentinel = 'dispatchFetchEventEnd'
6930 3 : (msg__)->WriteSentinel(256182528);
6931 3 : Write((v__).handleFetchEventStart(), msg__);
6932 : // Sentinel = 'handleFetchEventStart'
6933 3 : (msg__)->WriteSentinel(3840539911);
6934 3 : Write((v__).handleFetchEventEnd(), msg__);
6935 : // Sentinel = 'handleFetchEventEnd'
6936 3 : (msg__)->WriteSentinel(2420571602);
6937 3 : }
6938 :
6939 0 : auto PNeckoChild::Read(
6940 : HttpChannelOpenArgs* v__,
6941 : const Message* msg__,
6942 : PickleIterator* iter__) -> bool
6943 : {
6944 0 : if ((!(Read((&((v__)->uri())), msg__, iter__)))) {
6945 0 : FatalError("Error deserializing 'uri' (URIParams) member of 'HttpChannelOpenArgs'");
6946 0 : return false;
6947 : }
6948 : // Sentinel = 'uri'
6949 0 : if ((!((msg__)->ReadSentinel(iter__, 1453210605)))) {
6950 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uri' (URIParams) member of 'HttpChannelOpenArgs'");
6951 0 : return false;
6952 : }
6953 0 : if ((!(Read((&((v__)->original())), msg__, iter__)))) {
6954 0 : FatalError("Error deserializing 'original' (OptionalURIParams) member of 'HttpChannelOpenArgs'");
6955 0 : return false;
6956 : }
6957 : // Sentinel = 'original'
6958 0 : if ((!((msg__)->ReadSentinel(iter__, 3262287869)))) {
6959 0 : mozilla::ipc::SentinelReadError("Error deserializing 'original' (OptionalURIParams) member of 'HttpChannelOpenArgs'");
6960 0 : return false;
6961 : }
6962 0 : if ((!(Read((&((v__)->doc())), msg__, iter__)))) {
6963 0 : FatalError("Error deserializing 'doc' (OptionalURIParams) member of 'HttpChannelOpenArgs'");
6964 0 : return false;
6965 : }
6966 : // Sentinel = 'doc'
6967 0 : if ((!((msg__)->ReadSentinel(iter__, 1528775657)))) {
6968 0 : mozilla::ipc::SentinelReadError("Error deserializing 'doc' (OptionalURIParams) member of 'HttpChannelOpenArgs'");
6969 0 : return false;
6970 : }
6971 0 : if ((!(Read((&((v__)->referrer())), msg__, iter__)))) {
6972 0 : FatalError("Error deserializing 'referrer' (OptionalURIParams) member of 'HttpChannelOpenArgs'");
6973 0 : return false;
6974 : }
6975 : // Sentinel = 'referrer'
6976 0 : if ((!((msg__)->ReadSentinel(iter__, 3770987113)))) {
6977 0 : mozilla::ipc::SentinelReadError("Error deserializing 'referrer' (OptionalURIParams) member of 'HttpChannelOpenArgs'");
6978 0 : return false;
6979 : }
6980 0 : if ((!(Read((&((v__)->referrerPolicy())), msg__, iter__)))) {
6981 0 : FatalError("Error deserializing 'referrerPolicy' (uint32_t) member of 'HttpChannelOpenArgs'");
6982 0 : return false;
6983 : }
6984 : // Sentinel = 'referrerPolicy'
6985 0 : if ((!((msg__)->ReadSentinel(iter__, 2269890057)))) {
6986 0 : mozilla::ipc::SentinelReadError("Error deserializing 'referrerPolicy' (uint32_t) member of 'HttpChannelOpenArgs'");
6987 0 : return false;
6988 : }
6989 0 : if ((!(Read((&((v__)->apiRedirectTo())), msg__, iter__)))) {
6990 0 : FatalError("Error deserializing 'apiRedirectTo' (OptionalURIParams) member of 'HttpChannelOpenArgs'");
6991 0 : return false;
6992 : }
6993 : // Sentinel = 'apiRedirectTo'
6994 0 : if ((!((msg__)->ReadSentinel(iter__, 3162811030)))) {
6995 0 : mozilla::ipc::SentinelReadError("Error deserializing 'apiRedirectTo' (OptionalURIParams) member of 'HttpChannelOpenArgs'");
6996 0 : return false;
6997 : }
6998 0 : if ((!(Read((&((v__)->topWindowURI())), msg__, iter__)))) {
6999 0 : FatalError("Error deserializing 'topWindowURI' (OptionalURIParams) member of 'HttpChannelOpenArgs'");
7000 0 : return false;
7001 : }
7002 : // Sentinel = 'topWindowURI'
7003 0 : if ((!((msg__)->ReadSentinel(iter__, 2325499925)))) {
7004 0 : mozilla::ipc::SentinelReadError("Error deserializing 'topWindowURI' (OptionalURIParams) member of 'HttpChannelOpenArgs'");
7005 0 : return false;
7006 : }
7007 0 : if ((!(Read((&((v__)->loadFlags())), msg__, iter__)))) {
7008 0 : FatalError("Error deserializing 'loadFlags' (uint32_t) member of 'HttpChannelOpenArgs'");
7009 0 : return false;
7010 : }
7011 : // Sentinel = 'loadFlags'
7012 0 : if ((!((msg__)->ReadSentinel(iter__, 2391120444)))) {
7013 0 : mozilla::ipc::SentinelReadError("Error deserializing 'loadFlags' (uint32_t) member of 'HttpChannelOpenArgs'");
7014 0 : return false;
7015 : }
7016 0 : if ((!(Read((&((v__)->requestHeaders())), msg__, iter__)))) {
7017 0 : FatalError("Error deserializing 'requestHeaders' (RequestHeaderTuples) member of 'HttpChannelOpenArgs'");
7018 0 : return false;
7019 : }
7020 : // Sentinel = 'requestHeaders'
7021 0 : if ((!((msg__)->ReadSentinel(iter__, 2055989545)))) {
7022 0 : mozilla::ipc::SentinelReadError("Error deserializing 'requestHeaders' (RequestHeaderTuples) member of 'HttpChannelOpenArgs'");
7023 0 : return false;
7024 : }
7025 0 : if ((!(Read((&((v__)->requestMethod())), msg__, iter__)))) {
7026 0 : FatalError("Error deserializing 'requestMethod' (nsCString) member of 'HttpChannelOpenArgs'");
7027 0 : return false;
7028 : }
7029 : // Sentinel = 'requestMethod'
7030 0 : if ((!((msg__)->ReadSentinel(iter__, 2210890865)))) {
7031 0 : mozilla::ipc::SentinelReadError("Error deserializing 'requestMethod' (nsCString) member of 'HttpChannelOpenArgs'");
7032 0 : return false;
7033 : }
7034 0 : if ((!(Read((&((v__)->uploadStream())), msg__, iter__)))) {
7035 0 : FatalError("Error deserializing 'uploadStream' (OptionalIPCStream) member of 'HttpChannelOpenArgs'");
7036 0 : return false;
7037 : }
7038 : // Sentinel = 'uploadStream'
7039 0 : if ((!((msg__)->ReadSentinel(iter__, 3559827199)))) {
7040 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uploadStream' (OptionalIPCStream) member of 'HttpChannelOpenArgs'");
7041 0 : return false;
7042 : }
7043 0 : if ((!(Read((&((v__)->uploadStreamHasHeaders())), msg__, iter__)))) {
7044 0 : FatalError("Error deserializing 'uploadStreamHasHeaders' (bool) member of 'HttpChannelOpenArgs'");
7045 0 : return false;
7046 : }
7047 : // Sentinel = 'uploadStreamHasHeaders'
7048 0 : if ((!((msg__)->ReadSentinel(iter__, 670009587)))) {
7049 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uploadStreamHasHeaders' (bool) member of 'HttpChannelOpenArgs'");
7050 0 : return false;
7051 : }
7052 0 : if ((!(Read((&((v__)->priority())), msg__, iter__)))) {
7053 0 : FatalError("Error deserializing 'priority' (int16_t) member of 'HttpChannelOpenArgs'");
7054 0 : return false;
7055 : }
7056 : // Sentinel = 'priority'
7057 0 : if ((!((msg__)->ReadSentinel(iter__, 558136112)))) {
7058 0 : mozilla::ipc::SentinelReadError("Error deserializing 'priority' (int16_t) member of 'HttpChannelOpenArgs'");
7059 0 : return false;
7060 : }
7061 0 : if ((!(Read((&((v__)->classOfService())), msg__, iter__)))) {
7062 0 : FatalError("Error deserializing 'classOfService' (uint32_t) member of 'HttpChannelOpenArgs'");
7063 0 : return false;
7064 : }
7065 : // Sentinel = 'classOfService'
7066 0 : if ((!((msg__)->ReadSentinel(iter__, 1829468214)))) {
7067 0 : mozilla::ipc::SentinelReadError("Error deserializing 'classOfService' (uint32_t) member of 'HttpChannelOpenArgs'");
7068 0 : return false;
7069 : }
7070 0 : if ((!(Read((&((v__)->redirectionLimit())), msg__, iter__)))) {
7071 0 : FatalError("Error deserializing 'redirectionLimit' (uint8_t) member of 'HttpChannelOpenArgs'");
7072 0 : return false;
7073 : }
7074 : // Sentinel = 'redirectionLimit'
7075 0 : if ((!((msg__)->ReadSentinel(iter__, 1070866783)))) {
7076 0 : mozilla::ipc::SentinelReadError("Error deserializing 'redirectionLimit' (uint8_t) member of 'HttpChannelOpenArgs'");
7077 0 : return false;
7078 : }
7079 0 : if ((!(Read((&((v__)->allowSTS())), msg__, iter__)))) {
7080 0 : FatalError("Error deserializing 'allowSTS' (bool) member of 'HttpChannelOpenArgs'");
7081 0 : return false;
7082 : }
7083 : // Sentinel = 'allowSTS'
7084 0 : if ((!((msg__)->ReadSentinel(iter__, 384958533)))) {
7085 0 : mozilla::ipc::SentinelReadError("Error deserializing 'allowSTS' (bool) member of 'HttpChannelOpenArgs'");
7086 0 : return false;
7087 : }
7088 0 : if ((!(Read((&((v__)->thirdPartyFlags())), msg__, iter__)))) {
7089 0 : FatalError("Error deserializing 'thirdPartyFlags' (uint32_t) member of 'HttpChannelOpenArgs'");
7090 0 : return false;
7091 : }
7092 : // Sentinel = 'thirdPartyFlags'
7093 0 : if ((!((msg__)->ReadSentinel(iter__, 3577174809)))) {
7094 0 : mozilla::ipc::SentinelReadError("Error deserializing 'thirdPartyFlags' (uint32_t) member of 'HttpChannelOpenArgs'");
7095 0 : return false;
7096 : }
7097 0 : if ((!(Read((&((v__)->resumeAt())), msg__, iter__)))) {
7098 0 : FatalError("Error deserializing 'resumeAt' (bool) member of 'HttpChannelOpenArgs'");
7099 0 : return false;
7100 : }
7101 : // Sentinel = 'resumeAt'
7102 0 : if ((!((msg__)->ReadSentinel(iter__, 866346170)))) {
7103 0 : mozilla::ipc::SentinelReadError("Error deserializing 'resumeAt' (bool) member of 'HttpChannelOpenArgs'");
7104 0 : return false;
7105 : }
7106 0 : if ((!(Read((&((v__)->startPos())), msg__, iter__)))) {
7107 0 : FatalError("Error deserializing 'startPos' (uint64_t) member of 'HttpChannelOpenArgs'");
7108 0 : return false;
7109 : }
7110 : // Sentinel = 'startPos'
7111 0 : if ((!((msg__)->ReadSentinel(iter__, 557207962)))) {
7112 0 : mozilla::ipc::SentinelReadError("Error deserializing 'startPos' (uint64_t) member of 'HttpChannelOpenArgs'");
7113 0 : return false;
7114 : }
7115 0 : if ((!(Read((&((v__)->entityID())), msg__, iter__)))) {
7116 0 : FatalError("Error deserializing 'entityID' (nsCString) member of 'HttpChannelOpenArgs'");
7117 0 : return false;
7118 : }
7119 : // Sentinel = 'entityID'
7120 0 : if ((!((msg__)->ReadSentinel(iter__, 245743354)))) {
7121 0 : mozilla::ipc::SentinelReadError("Error deserializing 'entityID' (nsCString) member of 'HttpChannelOpenArgs'");
7122 0 : return false;
7123 : }
7124 0 : if ((!(Read((&((v__)->chooseApplicationCache())), msg__, iter__)))) {
7125 0 : FatalError("Error deserializing 'chooseApplicationCache' (bool) member of 'HttpChannelOpenArgs'");
7126 0 : return false;
7127 : }
7128 : // Sentinel = 'chooseApplicationCache'
7129 0 : if ((!((msg__)->ReadSentinel(iter__, 2898467869)))) {
7130 0 : mozilla::ipc::SentinelReadError("Error deserializing 'chooseApplicationCache' (bool) member of 'HttpChannelOpenArgs'");
7131 0 : return false;
7132 : }
7133 0 : if ((!(Read((&((v__)->appCacheClientID())), msg__, iter__)))) {
7134 0 : FatalError("Error deserializing 'appCacheClientID' (nsCString) member of 'HttpChannelOpenArgs'");
7135 0 : return false;
7136 : }
7137 : // Sentinel = 'appCacheClientID'
7138 0 : if ((!((msg__)->ReadSentinel(iter__, 3495226687)))) {
7139 0 : mozilla::ipc::SentinelReadError("Error deserializing 'appCacheClientID' (nsCString) member of 'HttpChannelOpenArgs'");
7140 0 : return false;
7141 : }
7142 0 : if ((!(Read((&((v__)->allowSpdy())), msg__, iter__)))) {
7143 0 : FatalError("Error deserializing 'allowSpdy' (bool) member of 'HttpChannelOpenArgs'");
7144 0 : return false;
7145 : }
7146 : // Sentinel = 'allowSpdy'
7147 0 : if ((!((msg__)->ReadSentinel(iter__, 1630260538)))) {
7148 0 : mozilla::ipc::SentinelReadError("Error deserializing 'allowSpdy' (bool) member of 'HttpChannelOpenArgs'");
7149 0 : return false;
7150 : }
7151 0 : if ((!(Read((&((v__)->allowAltSvc())), msg__, iter__)))) {
7152 0 : FatalError("Error deserializing 'allowAltSvc' (bool) member of 'HttpChannelOpenArgs'");
7153 0 : return false;
7154 : }
7155 : // Sentinel = 'allowAltSvc'
7156 0 : if ((!((msg__)->ReadSentinel(iter__, 879875677)))) {
7157 0 : mozilla::ipc::SentinelReadError("Error deserializing 'allowAltSvc' (bool) member of 'HttpChannelOpenArgs'");
7158 0 : return false;
7159 : }
7160 0 : if ((!(Read((&((v__)->beConservative())), msg__, iter__)))) {
7161 0 : FatalError("Error deserializing 'beConservative' (bool) member of 'HttpChannelOpenArgs'");
7162 0 : return false;
7163 : }
7164 : // Sentinel = 'beConservative'
7165 0 : if ((!((msg__)->ReadSentinel(iter__, 1177063294)))) {
7166 0 : mozilla::ipc::SentinelReadError("Error deserializing 'beConservative' (bool) member of 'HttpChannelOpenArgs'");
7167 0 : return false;
7168 : }
7169 0 : if ((!(Read((&((v__)->loadInfo())), msg__, iter__)))) {
7170 0 : FatalError("Error deserializing 'loadInfo' (OptionalLoadInfoArgs) member of 'HttpChannelOpenArgs'");
7171 0 : return false;
7172 : }
7173 : // Sentinel = 'loadInfo'
7174 0 : if ((!((msg__)->ReadSentinel(iter__, 2597515304)))) {
7175 0 : mozilla::ipc::SentinelReadError("Error deserializing 'loadInfo' (OptionalLoadInfoArgs) member of 'HttpChannelOpenArgs'");
7176 0 : return false;
7177 : }
7178 0 : if ((!(Read((&((v__)->synthesizedResponseHead())), msg__, iter__)))) {
7179 0 : FatalError("Error deserializing 'synthesizedResponseHead' (OptionalHttpResponseHead) member of 'HttpChannelOpenArgs'");
7180 0 : return false;
7181 : }
7182 : // Sentinel = 'synthesizedResponseHead'
7183 0 : if ((!((msg__)->ReadSentinel(iter__, 588784596)))) {
7184 0 : mozilla::ipc::SentinelReadError("Error deserializing 'synthesizedResponseHead' (OptionalHttpResponseHead) member of 'HttpChannelOpenArgs'");
7185 0 : return false;
7186 : }
7187 0 : if ((!(Read((&((v__)->synthesizedSecurityInfoSerialization())), msg__, iter__)))) {
7188 0 : FatalError("Error deserializing 'synthesizedSecurityInfoSerialization' (nsCString) member of 'HttpChannelOpenArgs'");
7189 0 : return false;
7190 : }
7191 : // Sentinel = 'synthesizedSecurityInfoSerialization'
7192 0 : if ((!((msg__)->ReadSentinel(iter__, 2702766326)))) {
7193 0 : mozilla::ipc::SentinelReadError("Error deserializing 'synthesizedSecurityInfoSerialization' (nsCString) member of 'HttpChannelOpenArgs'");
7194 0 : return false;
7195 : }
7196 0 : if ((!(Read((&((v__)->cacheKey())), msg__, iter__)))) {
7197 0 : FatalError("Error deserializing 'cacheKey' (uint32_t) member of 'HttpChannelOpenArgs'");
7198 0 : return false;
7199 : }
7200 : // Sentinel = 'cacheKey'
7201 0 : if ((!((msg__)->ReadSentinel(iter__, 249191363)))) {
7202 0 : mozilla::ipc::SentinelReadError("Error deserializing 'cacheKey' (uint32_t) member of 'HttpChannelOpenArgs'");
7203 0 : return false;
7204 : }
7205 0 : if ((!(Read((&((v__)->requestContextID())), msg__, iter__)))) {
7206 0 : FatalError("Error deserializing 'requestContextID' (uint64_t) member of 'HttpChannelOpenArgs'");
7207 0 : return false;
7208 : }
7209 : // Sentinel = 'requestContextID'
7210 0 : if ((!((msg__)->ReadSentinel(iter__, 2427410503)))) {
7211 0 : mozilla::ipc::SentinelReadError("Error deserializing 'requestContextID' (uint64_t) member of 'HttpChannelOpenArgs'");
7212 0 : return false;
7213 : }
7214 0 : if ((!(Read((&((v__)->preflightArgs())), msg__, iter__)))) {
7215 0 : FatalError("Error deserializing 'preflightArgs' (OptionalCorsPreflightArgs) member of 'HttpChannelOpenArgs'");
7216 0 : return false;
7217 : }
7218 : // Sentinel = 'preflightArgs'
7219 0 : if ((!((msg__)->ReadSentinel(iter__, 2363616251)))) {
7220 0 : mozilla::ipc::SentinelReadError("Error deserializing 'preflightArgs' (OptionalCorsPreflightArgs) member of 'HttpChannelOpenArgs'");
7221 0 : return false;
7222 : }
7223 0 : if ((!(Read((&((v__)->initialRwin())), msg__, iter__)))) {
7224 0 : FatalError("Error deserializing 'initialRwin' (uint32_t) member of 'HttpChannelOpenArgs'");
7225 0 : return false;
7226 : }
7227 : // Sentinel = 'initialRwin'
7228 0 : if ((!((msg__)->ReadSentinel(iter__, 967782407)))) {
7229 0 : mozilla::ipc::SentinelReadError("Error deserializing 'initialRwin' (uint32_t) member of 'HttpChannelOpenArgs'");
7230 0 : return false;
7231 : }
7232 0 : if ((!(Read((&((v__)->blockAuthPrompt())), msg__, iter__)))) {
7233 0 : FatalError("Error deserializing 'blockAuthPrompt' (bool) member of 'HttpChannelOpenArgs'");
7234 0 : return false;
7235 : }
7236 : // Sentinel = 'blockAuthPrompt'
7237 0 : if ((!((msg__)->ReadSentinel(iter__, 1543637500)))) {
7238 0 : mozilla::ipc::SentinelReadError("Error deserializing 'blockAuthPrompt' (bool) member of 'HttpChannelOpenArgs'");
7239 0 : return false;
7240 : }
7241 0 : if ((!(Read((&((v__)->suspendAfterSynthesizeResponse())), msg__, iter__)))) {
7242 0 : FatalError("Error deserializing 'suspendAfterSynthesizeResponse' (bool) member of 'HttpChannelOpenArgs'");
7243 0 : return false;
7244 : }
7245 : // Sentinel = 'suspendAfterSynthesizeResponse'
7246 0 : if ((!((msg__)->ReadSentinel(iter__, 656622613)))) {
7247 0 : mozilla::ipc::SentinelReadError("Error deserializing 'suspendAfterSynthesizeResponse' (bool) member of 'HttpChannelOpenArgs'");
7248 0 : return false;
7249 : }
7250 0 : if ((!(Read((&((v__)->allowStaleCacheContent())), msg__, iter__)))) {
7251 0 : FatalError("Error deserializing 'allowStaleCacheContent' (bool) member of 'HttpChannelOpenArgs'");
7252 0 : return false;
7253 : }
7254 : // Sentinel = 'allowStaleCacheContent'
7255 0 : if ((!((msg__)->ReadSentinel(iter__, 3064959537)))) {
7256 0 : mozilla::ipc::SentinelReadError("Error deserializing 'allowStaleCacheContent' (bool) member of 'HttpChannelOpenArgs'");
7257 0 : return false;
7258 : }
7259 0 : if ((!(Read((&((v__)->contentTypeHint())), msg__, iter__)))) {
7260 0 : FatalError("Error deserializing 'contentTypeHint' (nsCString) member of 'HttpChannelOpenArgs'");
7261 0 : return false;
7262 : }
7263 : // Sentinel = 'contentTypeHint'
7264 0 : if ((!((msg__)->ReadSentinel(iter__, 2155295759)))) {
7265 0 : mozilla::ipc::SentinelReadError("Error deserializing 'contentTypeHint' (nsCString) member of 'HttpChannelOpenArgs'");
7266 0 : return false;
7267 : }
7268 0 : if ((!(Read((&((v__)->channelId())), msg__, iter__)))) {
7269 0 : FatalError("Error deserializing 'channelId' (uint64_t) member of 'HttpChannelOpenArgs'");
7270 0 : return false;
7271 : }
7272 : // Sentinel = 'channelId'
7273 0 : if ((!((msg__)->ReadSentinel(iter__, 6854027)))) {
7274 0 : mozilla::ipc::SentinelReadError("Error deserializing 'channelId' (uint64_t) member of 'HttpChannelOpenArgs'");
7275 0 : return false;
7276 : }
7277 0 : if ((!(Read((&((v__)->contentWindowId())), msg__, iter__)))) {
7278 0 : FatalError("Error deserializing 'contentWindowId' (uint64_t) member of 'HttpChannelOpenArgs'");
7279 0 : return false;
7280 : }
7281 : // Sentinel = 'contentWindowId'
7282 0 : if ((!((msg__)->ReadSentinel(iter__, 2188138839)))) {
7283 0 : mozilla::ipc::SentinelReadError("Error deserializing 'contentWindowId' (uint64_t) member of 'HttpChannelOpenArgs'");
7284 0 : return false;
7285 : }
7286 0 : if ((!(Read((&((v__)->preferredAlternativeType())), msg__, iter__)))) {
7287 0 : FatalError("Error deserializing 'preferredAlternativeType' (nsCString) member of 'HttpChannelOpenArgs'");
7288 0 : return false;
7289 : }
7290 : // Sentinel = 'preferredAlternativeType'
7291 0 : if ((!((msg__)->ReadSentinel(iter__, 1019174360)))) {
7292 0 : mozilla::ipc::SentinelReadError("Error deserializing 'preferredAlternativeType' (nsCString) member of 'HttpChannelOpenArgs'");
7293 0 : return false;
7294 : }
7295 0 : if ((!(Read((&((v__)->topLevelOuterContentWindowId())), msg__, iter__)))) {
7296 0 : FatalError("Error deserializing 'topLevelOuterContentWindowId' (uint64_t) member of 'HttpChannelOpenArgs'");
7297 0 : return false;
7298 : }
7299 : // Sentinel = 'topLevelOuterContentWindowId'
7300 0 : if ((!((msg__)->ReadSentinel(iter__, 810319786)))) {
7301 0 : mozilla::ipc::SentinelReadError("Error deserializing 'topLevelOuterContentWindowId' (uint64_t) member of 'HttpChannelOpenArgs'");
7302 0 : return false;
7303 : }
7304 0 : if ((!(Read((&((v__)->launchServiceWorkerStart())), msg__, iter__)))) {
7305 0 : FatalError("Error deserializing 'launchServiceWorkerStart' (TimeStamp) member of 'HttpChannelOpenArgs'");
7306 0 : return false;
7307 : }
7308 : // Sentinel = 'launchServiceWorkerStart'
7309 0 : if ((!((msg__)->ReadSentinel(iter__, 1191023364)))) {
7310 0 : mozilla::ipc::SentinelReadError("Error deserializing 'launchServiceWorkerStart' (TimeStamp) member of 'HttpChannelOpenArgs'");
7311 0 : return false;
7312 : }
7313 0 : if ((!(Read((&((v__)->launchServiceWorkerEnd())), msg__, iter__)))) {
7314 0 : FatalError("Error deserializing 'launchServiceWorkerEnd' (TimeStamp) member of 'HttpChannelOpenArgs'");
7315 0 : return false;
7316 : }
7317 : // Sentinel = 'launchServiceWorkerEnd'
7318 0 : if ((!((msg__)->ReadSentinel(iter__, 2236809033)))) {
7319 0 : mozilla::ipc::SentinelReadError("Error deserializing 'launchServiceWorkerEnd' (TimeStamp) member of 'HttpChannelOpenArgs'");
7320 0 : return false;
7321 : }
7322 0 : if ((!(Read((&((v__)->dispatchFetchEventStart())), msg__, iter__)))) {
7323 0 : FatalError("Error deserializing 'dispatchFetchEventStart' (TimeStamp) member of 'HttpChannelOpenArgs'");
7324 0 : return false;
7325 : }
7326 : // Sentinel = 'dispatchFetchEventStart'
7327 0 : if ((!((msg__)->ReadSentinel(iter__, 2132895785)))) {
7328 0 : mozilla::ipc::SentinelReadError("Error deserializing 'dispatchFetchEventStart' (TimeStamp) member of 'HttpChannelOpenArgs'");
7329 0 : return false;
7330 : }
7331 0 : if ((!(Read((&((v__)->dispatchFetchEventEnd())), msg__, iter__)))) {
7332 0 : FatalError("Error deserializing 'dispatchFetchEventEnd' (TimeStamp) member of 'HttpChannelOpenArgs'");
7333 0 : return false;
7334 : }
7335 : // Sentinel = 'dispatchFetchEventEnd'
7336 0 : if ((!((msg__)->ReadSentinel(iter__, 256182528)))) {
7337 0 : mozilla::ipc::SentinelReadError("Error deserializing 'dispatchFetchEventEnd' (TimeStamp) member of 'HttpChannelOpenArgs'");
7338 0 : return false;
7339 : }
7340 0 : if ((!(Read((&((v__)->handleFetchEventStart())), msg__, iter__)))) {
7341 0 : FatalError("Error deserializing 'handleFetchEventStart' (TimeStamp) member of 'HttpChannelOpenArgs'");
7342 0 : return false;
7343 : }
7344 : // Sentinel = 'handleFetchEventStart'
7345 0 : if ((!((msg__)->ReadSentinel(iter__, 3840539911)))) {
7346 0 : mozilla::ipc::SentinelReadError("Error deserializing 'handleFetchEventStart' (TimeStamp) member of 'HttpChannelOpenArgs'");
7347 0 : return false;
7348 : }
7349 0 : if ((!(Read((&((v__)->handleFetchEventEnd())), msg__, iter__)))) {
7350 0 : FatalError("Error deserializing 'handleFetchEventEnd' (TimeStamp) member of 'HttpChannelOpenArgs'");
7351 0 : return false;
7352 : }
7353 : // Sentinel = 'handleFetchEventEnd'
7354 0 : if ((!((msg__)->ReadSentinel(iter__, 2420571602)))) {
7355 0 : mozilla::ipc::SentinelReadError("Error deserializing 'handleFetchEventEnd' (TimeStamp) member of 'HttpChannelOpenArgs'");
7356 0 : return false;
7357 : }
7358 0 : return true;
7359 : }
7360 :
7361 0 : auto PNeckoChild::Write(
7362 : const PWebSocketEventListenerChild* v__,
7363 : Message* msg__,
7364 : bool nullable__) -> void
7365 : {
7366 : int32_t id;
7367 0 : if ((!(v__))) {
7368 0 : if ((!(nullable__))) {
7369 0 : FatalError("NULL actor value passed to non-nullable param");
7370 : }
7371 0 : id = 0;
7372 : }
7373 : else {
7374 0 : id = (v__)->Id();
7375 0 : if ((1) == (id)) {
7376 0 : FatalError("actor has been |delete|d");
7377 : }
7378 : }
7379 :
7380 0 : Write(id, msg__);
7381 0 : }
7382 :
7383 0 : auto PNeckoChild::Read(
7384 : PWebSocketEventListenerChild** v__,
7385 : const Message* msg__,
7386 : PickleIterator* iter__,
7387 : bool nullable__) -> bool
7388 : {
7389 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PWebSocketEventListener", PWebSocketEventListenerMsgStart);
7390 0 : if ((actor).isNothing()) {
7391 0 : return false;
7392 : }
7393 :
7394 0 : (*(v__)) = static_cast<PWebSocketEventListenerChild*>((actor).value());
7395 0 : return true;
7396 : }
7397 :
7398 0 : auto PNeckoChild::Write(
7399 : const ChannelDiverterArgs& v__,
7400 : Message* msg__) -> void
7401 : {
7402 : typedef ChannelDiverterArgs type__;
7403 0 : Write(int((v__).type()), msg__);
7404 : // Sentinel = 'ChannelDiverterArgs'
7405 0 : (msg__)->WriteSentinel(2207945912);
7406 :
7407 0 : switch ((v__).type()) {
7408 : case type__::THttpChannelDiverterArgs:
7409 : {
7410 0 : Write((v__).get_HttpChannelDiverterArgs(), msg__);
7411 : // Sentinel = 'THttpChannelDiverterArgs'
7412 0 : (msg__)->WriteSentinel(1911457823);
7413 0 : return;
7414 : }
7415 : case type__::TPFTPChannelParent:
7416 : {
7417 0 : FatalError("wrong side!");
7418 0 : return;
7419 : }
7420 : case type__::TPFTPChannelChild:
7421 : {
7422 0 : Write((v__).get_PFTPChannelChild(), msg__, false);
7423 : // Sentinel = 'TPFTPChannelChild'
7424 0 : (msg__)->WriteSentinel(889018702);
7425 0 : return;
7426 : }
7427 : default:
7428 : {
7429 0 : FatalError("unknown union type");
7430 0 : return;
7431 : }
7432 : }
7433 : }
7434 :
7435 0 : auto PNeckoChild::Read(
7436 : ChannelDiverterArgs* v__,
7437 : const Message* msg__,
7438 : PickleIterator* iter__) -> bool
7439 : {
7440 : typedef ChannelDiverterArgs type__;
7441 : int type;
7442 0 : if ((!(Read((&(type)), msg__, iter__)))) {
7443 0 : mozilla::ipc::UnionTypeReadError("ChannelDiverterArgs");
7444 0 : return false;
7445 : }
7446 : // Sentinel = 'ChannelDiverterArgs'
7447 0 : if ((!((msg__)->ReadSentinel(iter__, 2207945912)))) {
7448 0 : mozilla::ipc::SentinelReadError("ChannelDiverterArgs");
7449 0 : return false;
7450 : }
7451 :
7452 0 : switch (type) {
7453 : case type__::THttpChannelDiverterArgs:
7454 : {
7455 0 : HttpChannelDiverterArgs tmp = HttpChannelDiverterArgs();
7456 0 : (*(v__)) = tmp;
7457 0 : if ((!(Read((&((v__)->get_HttpChannelDiverterArgs())), msg__, iter__)))) {
7458 0 : FatalError("Error deserializing Union type");
7459 0 : return false;
7460 : }
7461 : // Sentinel = 'THttpChannelDiverterArgs'
7462 0 : if ((!((msg__)->ReadSentinel(iter__, 1911457823)))) {
7463 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
7464 0 : return false;
7465 : }
7466 0 : return true;
7467 : }
7468 : case type__::TPFTPChannelParent:
7469 : {
7470 0 : PFTPChannelChild* tmp = nullptr;
7471 0 : (*(v__)) = tmp;
7472 0 : if ((!(Read((&((v__)->get_PFTPChannelChild())), msg__, iter__, false)))) {
7473 0 : FatalError("Error deserializing Union type");
7474 0 : return false;
7475 : }
7476 : // Sentinel = 'TPFTPChannelParent'
7477 0 : if ((!((msg__)->ReadSentinel(iter__, 694358909)))) {
7478 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
7479 0 : return false;
7480 : }
7481 0 : return true;
7482 : }
7483 : case type__::TPFTPChannelChild:
7484 : {
7485 0 : return false;
7486 : }
7487 : default:
7488 : {
7489 0 : FatalError("unknown union type");
7490 0 : return false;
7491 : }
7492 : }
7493 : }
7494 :
7495 0 : auto PNeckoChild::Write(
7496 : const PRtspChannelChild* v__,
7497 : Message* msg__,
7498 : bool nullable__) -> void
7499 : {
7500 : int32_t id;
7501 0 : if ((!(v__))) {
7502 0 : if ((!(nullable__))) {
7503 0 : FatalError("NULL actor value passed to non-nullable param");
7504 : }
7505 0 : id = 0;
7506 : }
7507 : else {
7508 0 : id = (v__)->Id();
7509 0 : if ((1) == (id)) {
7510 0 : FatalError("actor has been |delete|d");
7511 : }
7512 : }
7513 :
7514 0 : Write(id, msg__);
7515 0 : }
7516 :
7517 0 : auto PNeckoChild::Read(
7518 : PRtspChannelChild** v__,
7519 : const Message* msg__,
7520 : PickleIterator* iter__,
7521 : bool nullable__) -> bool
7522 : {
7523 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PRtspChannel", PRtspChannelMsgStart);
7524 0 : if ((actor).isNothing()) {
7525 0 : return false;
7526 : }
7527 :
7528 0 : (*(v__)) = static_cast<PRtspChannelChild*>((actor).value());
7529 0 : return true;
7530 : }
7531 :
7532 0 : auto PNeckoChild::Write(
7533 : const PChannelDiverterChild* v__,
7534 : Message* msg__,
7535 : bool nullable__) -> void
7536 : {
7537 : int32_t id;
7538 0 : if ((!(v__))) {
7539 0 : if ((!(nullable__))) {
7540 0 : FatalError("NULL actor value passed to non-nullable param");
7541 : }
7542 0 : id = 0;
7543 : }
7544 : else {
7545 0 : id = (v__)->Id();
7546 0 : if ((1) == (id)) {
7547 0 : FatalError("actor has been |delete|d");
7548 : }
7549 : }
7550 :
7551 0 : Write(id, msg__);
7552 0 : }
7553 :
7554 0 : auto PNeckoChild::Read(
7555 : PChannelDiverterChild** v__,
7556 : const Message* msg__,
7557 : PickleIterator* iter__,
7558 : bool nullable__) -> bool
7559 : {
7560 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PChannelDiverter", PChannelDiverterMsgStart);
7561 0 : if ((actor).isNothing()) {
7562 0 : return false;
7563 : }
7564 :
7565 0 : (*(v__)) = static_cast<PChannelDiverterChild*>((actor).value());
7566 0 : return true;
7567 : }
7568 :
7569 0 : auto PNeckoChild::Write(
7570 : const OptionalFileDescriptorSet& v__,
7571 : Message* msg__) -> void
7572 : {
7573 : typedef OptionalFileDescriptorSet type__;
7574 0 : Write(int((v__).type()), msg__);
7575 : // Sentinel = 'OptionalFileDescriptorSet'
7576 0 : (msg__)->WriteSentinel(955222862);
7577 :
7578 0 : switch ((v__).type()) {
7579 : case type__::TPFileDescriptorSetParent:
7580 : {
7581 0 : FatalError("wrong side!");
7582 0 : return;
7583 : }
7584 : case type__::TPFileDescriptorSetChild:
7585 : {
7586 0 : Write((v__).get_PFileDescriptorSetChild(), msg__, false);
7587 : // Sentinel = 'TPFileDescriptorSetChild'
7588 0 : (msg__)->WriteSentinel(3477929935);
7589 0 : return;
7590 : }
7591 : case type__::TArrayOfFileDescriptor:
7592 : {
7593 0 : Write((v__).get_ArrayOfFileDescriptor(), msg__);
7594 : // Sentinel = 'TArrayOfFileDescriptor'
7595 0 : (msg__)->WriteSentinel(2366096715);
7596 0 : return;
7597 : }
7598 : case type__::Tvoid_t:
7599 : {
7600 0 : Write((v__).get_void_t(), msg__);
7601 : // Sentinel = 'Tvoid_t'
7602 0 : (msg__)->WriteSentinel(3041273328);
7603 0 : return;
7604 : }
7605 : default:
7606 : {
7607 0 : FatalError("unknown union type");
7608 0 : return;
7609 : }
7610 : }
7611 : }
7612 :
7613 0 : auto PNeckoChild::Read(
7614 : OptionalFileDescriptorSet* v__,
7615 : const Message* msg__,
7616 : PickleIterator* iter__) -> bool
7617 : {
7618 : typedef OptionalFileDescriptorSet type__;
7619 : int type;
7620 0 : if ((!(Read((&(type)), msg__, iter__)))) {
7621 0 : mozilla::ipc::UnionTypeReadError("OptionalFileDescriptorSet");
7622 0 : return false;
7623 : }
7624 : // Sentinel = 'OptionalFileDescriptorSet'
7625 0 : if ((!((msg__)->ReadSentinel(iter__, 955222862)))) {
7626 0 : mozilla::ipc::SentinelReadError("OptionalFileDescriptorSet");
7627 0 : return false;
7628 : }
7629 :
7630 0 : switch (type) {
7631 : case type__::TPFileDescriptorSetParent:
7632 : {
7633 0 : PFileDescriptorSetChild* tmp = nullptr;
7634 0 : (*(v__)) = tmp;
7635 0 : if ((!(Read((&((v__)->get_PFileDescriptorSetChild())), msg__, iter__, false)))) {
7636 0 : FatalError("Error deserializing Union type");
7637 0 : return false;
7638 : }
7639 : // Sentinel = 'TPFileDescriptorSetParent'
7640 0 : if ((!((msg__)->ReadSentinel(iter__, 143041934)))) {
7641 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
7642 0 : return false;
7643 : }
7644 0 : return true;
7645 : }
7646 : case type__::TPFileDescriptorSetChild:
7647 : {
7648 0 : return false;
7649 : }
7650 : case type__::TArrayOfFileDescriptor:
7651 : {
7652 0 : nsTArray<FileDescriptor> tmp;
7653 0 : (*(v__)) = tmp;
7654 0 : if ((!(Read((&((v__)->get_ArrayOfFileDescriptor())), msg__, iter__)))) {
7655 0 : FatalError("Error deserializing Union type");
7656 0 : return false;
7657 : }
7658 : // Sentinel = 'TArrayOfFileDescriptor'
7659 0 : if ((!((msg__)->ReadSentinel(iter__, 2366096715)))) {
7660 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
7661 0 : return false;
7662 : }
7663 0 : return true;
7664 : }
7665 : case type__::Tvoid_t:
7666 : {
7667 : void_t tmp = void_t();
7668 0 : (*(v__)) = tmp;
7669 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
7670 0 : FatalError("Error deserializing Union type");
7671 0 : return false;
7672 : }
7673 : // Sentinel = 'Tvoid_t'
7674 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
7675 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
7676 0 : return false;
7677 : }
7678 0 : return true;
7679 : }
7680 : default:
7681 : {
7682 0 : FatalError("unknown union type");
7683 0 : return false;
7684 : }
7685 : }
7686 : }
7687 :
7688 0 : auto PNeckoChild::Write(
7689 : const InputStreamParams& v__,
7690 : Message* msg__) -> void
7691 : {
7692 : typedef InputStreamParams type__;
7693 0 : Write(int((v__).type()), msg__);
7694 : // Sentinel = 'InputStreamParams'
7695 0 : (msg__)->WriteSentinel(4114814015);
7696 :
7697 0 : switch ((v__).type()) {
7698 : case type__::TStringInputStreamParams:
7699 : {
7700 0 : Write((v__).get_StringInputStreamParams(), msg__);
7701 : // Sentinel = 'TStringInputStreamParams'
7702 0 : (msg__)->WriteSentinel(3395831651);
7703 0 : return;
7704 : }
7705 : case type__::TFileInputStreamParams:
7706 : {
7707 0 : Write((v__).get_FileInputStreamParams(), msg__);
7708 : // Sentinel = 'TFileInputStreamParams'
7709 0 : (msg__)->WriteSentinel(2543620282);
7710 0 : return;
7711 : }
7712 : case type__::TTemporaryFileInputStreamParams:
7713 : {
7714 0 : Write((v__).get_TemporaryFileInputStreamParams(), msg__);
7715 : // Sentinel = 'TTemporaryFileInputStreamParams'
7716 0 : (msg__)->WriteSentinel(587771548);
7717 0 : return;
7718 : }
7719 : case type__::TBufferedInputStreamParams:
7720 : {
7721 0 : Write((v__).get_BufferedInputStreamParams(), msg__);
7722 : // Sentinel = 'TBufferedInputStreamParams'
7723 0 : (msg__)->WriteSentinel(1698289307);
7724 0 : return;
7725 : }
7726 : case type__::TMIMEInputStreamParams:
7727 : {
7728 0 : Write((v__).get_MIMEInputStreamParams(), msg__);
7729 : // Sentinel = 'TMIMEInputStreamParams'
7730 0 : (msg__)->WriteSentinel(1948001964);
7731 0 : return;
7732 : }
7733 : case type__::TMultiplexInputStreamParams:
7734 : {
7735 0 : Write((v__).get_MultiplexInputStreamParams(), msg__);
7736 : // Sentinel = 'TMultiplexInputStreamParams'
7737 0 : (msg__)->WriteSentinel(3317853213);
7738 0 : return;
7739 : }
7740 : case type__::TSlicedInputStreamParams:
7741 : {
7742 0 : Write((v__).get_SlicedInputStreamParams(), msg__);
7743 : // Sentinel = 'TSlicedInputStreamParams'
7744 0 : (msg__)->WriteSentinel(445810472);
7745 0 : return;
7746 : }
7747 : case type__::TIPCBlobInputStreamParams:
7748 : {
7749 0 : Write((v__).get_IPCBlobInputStreamParams(), msg__);
7750 : // Sentinel = 'TIPCBlobInputStreamParams'
7751 0 : (msg__)->WriteSentinel(2436989998);
7752 0 : return;
7753 : }
7754 : default:
7755 : {
7756 0 : FatalError("unknown union type");
7757 0 : return;
7758 : }
7759 : }
7760 : }
7761 :
7762 0 : auto PNeckoChild::Read(
7763 : InputStreamParams* v__,
7764 : const Message* msg__,
7765 : PickleIterator* iter__) -> bool
7766 : {
7767 : typedef InputStreamParams type__;
7768 : int type;
7769 0 : if ((!(Read((&(type)), msg__, iter__)))) {
7770 0 : mozilla::ipc::UnionTypeReadError("InputStreamParams");
7771 0 : return false;
7772 : }
7773 : // Sentinel = 'InputStreamParams'
7774 0 : if ((!((msg__)->ReadSentinel(iter__, 4114814015)))) {
7775 0 : mozilla::ipc::SentinelReadError("InputStreamParams");
7776 0 : return false;
7777 : }
7778 :
7779 0 : switch (type) {
7780 : case type__::TStringInputStreamParams:
7781 : {
7782 0 : StringInputStreamParams tmp = StringInputStreamParams();
7783 0 : (*(v__)) = tmp;
7784 0 : if ((!(Read((&((v__)->get_StringInputStreamParams())), msg__, iter__)))) {
7785 0 : FatalError("Error deserializing Union type");
7786 0 : return false;
7787 : }
7788 : // Sentinel = 'TStringInputStreamParams'
7789 0 : if ((!((msg__)->ReadSentinel(iter__, 3395831651)))) {
7790 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
7791 0 : return false;
7792 : }
7793 0 : return true;
7794 : }
7795 : case type__::TFileInputStreamParams:
7796 : {
7797 0 : FileInputStreamParams tmp = FileInputStreamParams();
7798 0 : (*(v__)) = tmp;
7799 0 : if ((!(Read((&((v__)->get_FileInputStreamParams())), msg__, iter__)))) {
7800 0 : FatalError("Error deserializing Union type");
7801 0 : return false;
7802 : }
7803 : // Sentinel = 'TFileInputStreamParams'
7804 0 : if ((!((msg__)->ReadSentinel(iter__, 2543620282)))) {
7805 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
7806 0 : return false;
7807 : }
7808 0 : return true;
7809 : }
7810 : case type__::TTemporaryFileInputStreamParams:
7811 : {
7812 0 : TemporaryFileInputStreamParams tmp = TemporaryFileInputStreamParams();
7813 0 : (*(v__)) = tmp;
7814 0 : if ((!(Read((&((v__)->get_TemporaryFileInputStreamParams())), msg__, iter__)))) {
7815 0 : FatalError("Error deserializing Union type");
7816 0 : return false;
7817 : }
7818 : // Sentinel = 'TTemporaryFileInputStreamParams'
7819 0 : if ((!((msg__)->ReadSentinel(iter__, 587771548)))) {
7820 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
7821 0 : return false;
7822 : }
7823 0 : return true;
7824 : }
7825 : case type__::TBufferedInputStreamParams:
7826 : {
7827 0 : BufferedInputStreamParams tmp = BufferedInputStreamParams();
7828 0 : (*(v__)) = tmp;
7829 0 : if ((!(Read((&((v__)->get_BufferedInputStreamParams())), msg__, iter__)))) {
7830 0 : FatalError("Error deserializing Union type");
7831 0 : return false;
7832 : }
7833 : // Sentinel = 'TBufferedInputStreamParams'
7834 0 : if ((!((msg__)->ReadSentinel(iter__, 1698289307)))) {
7835 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
7836 0 : return false;
7837 : }
7838 0 : return true;
7839 : }
7840 : case type__::TMIMEInputStreamParams:
7841 : {
7842 0 : MIMEInputStreamParams tmp = MIMEInputStreamParams();
7843 0 : (*(v__)) = tmp;
7844 0 : if ((!(Read((&((v__)->get_MIMEInputStreamParams())), msg__, iter__)))) {
7845 0 : FatalError("Error deserializing Union type");
7846 0 : return false;
7847 : }
7848 : // Sentinel = 'TMIMEInputStreamParams'
7849 0 : if ((!((msg__)->ReadSentinel(iter__, 1948001964)))) {
7850 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
7851 0 : return false;
7852 : }
7853 0 : return true;
7854 : }
7855 : case type__::TMultiplexInputStreamParams:
7856 : {
7857 0 : MultiplexInputStreamParams tmp = MultiplexInputStreamParams();
7858 0 : (*(v__)) = tmp;
7859 0 : if ((!(Read((&((v__)->get_MultiplexInputStreamParams())), msg__, iter__)))) {
7860 0 : FatalError("Error deserializing Union type");
7861 0 : return false;
7862 : }
7863 : // Sentinel = 'TMultiplexInputStreamParams'
7864 0 : if ((!((msg__)->ReadSentinel(iter__, 3317853213)))) {
7865 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
7866 0 : return false;
7867 : }
7868 0 : return true;
7869 : }
7870 : case type__::TSlicedInputStreamParams:
7871 : {
7872 0 : SlicedInputStreamParams tmp = SlicedInputStreamParams();
7873 0 : (*(v__)) = tmp;
7874 0 : if ((!(Read((&((v__)->get_SlicedInputStreamParams())), msg__, iter__)))) {
7875 0 : FatalError("Error deserializing Union type");
7876 0 : return false;
7877 : }
7878 : // Sentinel = 'TSlicedInputStreamParams'
7879 0 : if ((!((msg__)->ReadSentinel(iter__, 445810472)))) {
7880 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
7881 0 : return false;
7882 : }
7883 0 : return true;
7884 : }
7885 : case type__::TIPCBlobInputStreamParams:
7886 : {
7887 0 : IPCBlobInputStreamParams tmp = IPCBlobInputStreamParams();
7888 0 : (*(v__)) = tmp;
7889 0 : if ((!(Read((&((v__)->get_IPCBlobInputStreamParams())), msg__, iter__)))) {
7890 0 : FatalError("Error deserializing Union type");
7891 0 : return false;
7892 : }
7893 : // Sentinel = 'TIPCBlobInputStreamParams'
7894 0 : if ((!((msg__)->ReadSentinel(iter__, 2436989998)))) {
7895 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
7896 0 : return false;
7897 : }
7898 0 : return true;
7899 : }
7900 : default:
7901 : {
7902 0 : FatalError("unknown union type");
7903 0 : return false;
7904 : }
7905 : }
7906 : }
7907 :
7908 0 : auto PNeckoChild::Write(
7909 : const JSURIParams& v__,
7910 : Message* msg__) -> void
7911 : {
7912 0 : Write((v__).simpleParams(), msg__);
7913 : // Sentinel = 'simpleParams'
7914 0 : (msg__)->WriteSentinel(3404291700);
7915 0 : Write((v__).baseURI(), msg__);
7916 : // Sentinel = 'baseURI'
7917 0 : (msg__)->WriteSentinel(1836705256);
7918 0 : }
7919 :
7920 0 : auto PNeckoChild::Read(
7921 : JSURIParams* v__,
7922 : const Message* msg__,
7923 : PickleIterator* iter__) -> bool
7924 : {
7925 0 : if ((!(Read((&((v__)->simpleParams())), msg__, iter__)))) {
7926 0 : FatalError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'JSURIParams'");
7927 0 : return false;
7928 : }
7929 : // Sentinel = 'simpleParams'
7930 0 : if ((!((msg__)->ReadSentinel(iter__, 3404291700)))) {
7931 0 : mozilla::ipc::SentinelReadError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'JSURIParams'");
7932 0 : return false;
7933 : }
7934 0 : if ((!(Read((&((v__)->baseURI())), msg__, iter__)))) {
7935 0 : FatalError("Error deserializing 'baseURI' (OptionalURIParams) member of 'JSURIParams'");
7936 0 : return false;
7937 : }
7938 : // Sentinel = 'baseURI'
7939 0 : if ((!((msg__)->ReadSentinel(iter__, 1836705256)))) {
7940 0 : mozilla::ipc::SentinelReadError("Error deserializing 'baseURI' (OptionalURIParams) member of 'JSURIParams'");
7941 0 : return false;
7942 : }
7943 0 : return true;
7944 : }
7945 :
7946 0 : auto PNeckoChild::Write(
7947 : const NullPrincipalInfo& v__,
7948 : Message* msg__) -> void
7949 : {
7950 0 : Write((v__).attrs(), msg__);
7951 : // Sentinel = 'attrs'
7952 0 : (msg__)->WriteSentinel(3014987797);
7953 0 : Write((v__).spec(), msg__);
7954 : // Sentinel = 'spec'
7955 0 : (msg__)->WriteSentinel(1630740541);
7956 0 : }
7957 :
7958 0 : auto PNeckoChild::Read(
7959 : NullPrincipalInfo* v__,
7960 : const Message* msg__,
7961 : PickleIterator* iter__) -> bool
7962 : {
7963 0 : if ((!(Read((&((v__)->attrs())), msg__, iter__)))) {
7964 0 : FatalError("Error deserializing 'attrs' (OriginAttributes) member of 'NullPrincipalInfo'");
7965 0 : return false;
7966 : }
7967 : // Sentinel = 'attrs'
7968 0 : if ((!((msg__)->ReadSentinel(iter__, 3014987797)))) {
7969 0 : mozilla::ipc::SentinelReadError("Error deserializing 'attrs' (OriginAttributes) member of 'NullPrincipalInfo'");
7970 0 : return false;
7971 : }
7972 0 : if ((!(Read((&((v__)->spec())), msg__, iter__)))) {
7973 0 : FatalError("Error deserializing 'spec' (nsCString) member of 'NullPrincipalInfo'");
7974 0 : return false;
7975 : }
7976 : // Sentinel = 'spec'
7977 0 : if ((!((msg__)->ReadSentinel(iter__, 1630740541)))) {
7978 0 : mozilla::ipc::SentinelReadError("Error deserializing 'spec' (nsCString) member of 'NullPrincipalInfo'");
7979 0 : return false;
7980 : }
7981 0 : return true;
7982 : }
7983 :
7984 204 : auto PNeckoChild::Write(
7985 : const StandardURLSegment& v__,
7986 : Message* msg__) -> void
7987 : {
7988 204 : Write((v__).position(), msg__);
7989 : // Sentinel = 'position'
7990 204 : (msg__)->WriteSentinel(50847225);
7991 204 : Write((v__).length(), msg__);
7992 : // Sentinel = 'length'
7993 204 : (msg__)->WriteSentinel(1726618354);
7994 204 : }
7995 :
7996 0 : auto PNeckoChild::Read(
7997 : StandardURLSegment* v__,
7998 : const Message* msg__,
7999 : PickleIterator* iter__) -> bool
8000 : {
8001 0 : if ((!(Read((&((v__)->position())), msg__, iter__)))) {
8002 0 : FatalError("Error deserializing 'position' (uint32_t) member of 'StandardURLSegment'");
8003 0 : return false;
8004 : }
8005 : // Sentinel = 'position'
8006 0 : if ((!((msg__)->ReadSentinel(iter__, 50847225)))) {
8007 0 : mozilla::ipc::SentinelReadError("Error deserializing 'position' (uint32_t) member of 'StandardURLSegment'");
8008 0 : return false;
8009 : }
8010 0 : if ((!(Read((&((v__)->length())), msg__, iter__)))) {
8011 0 : FatalError("Error deserializing 'length' (int32_t) member of 'StandardURLSegment'");
8012 0 : return false;
8013 : }
8014 : // Sentinel = 'length'
8015 0 : if ((!((msg__)->ReadSentinel(iter__, 1726618354)))) {
8016 0 : mozilla::ipc::SentinelReadError("Error deserializing 'length' (int32_t) member of 'StandardURLSegment'");
8017 0 : return false;
8018 : }
8019 0 : return true;
8020 : }
8021 :
8022 0 : auto PNeckoChild::Write(
8023 : const RtspChannelConnectArgs& v__,
8024 : Message* msg__) -> void
8025 : {
8026 0 : Write((v__).uri(), msg__);
8027 : // Sentinel = 'uri'
8028 0 : (msg__)->WriteSentinel(1453210605);
8029 0 : Write((v__).channelId(), msg__);
8030 : // Sentinel = 'channelId'
8031 0 : (msg__)->WriteSentinel(6854027);
8032 0 : }
8033 :
8034 0 : auto PNeckoChild::Read(
8035 : RtspChannelConnectArgs* v__,
8036 : const Message* msg__,
8037 : PickleIterator* iter__) -> bool
8038 : {
8039 0 : if ((!(Read((&((v__)->uri())), msg__, iter__)))) {
8040 0 : FatalError("Error deserializing 'uri' (URIParams) member of 'RtspChannelConnectArgs'");
8041 0 : return false;
8042 : }
8043 : // Sentinel = 'uri'
8044 0 : if ((!((msg__)->ReadSentinel(iter__, 1453210605)))) {
8045 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uri' (URIParams) member of 'RtspChannelConnectArgs'");
8046 0 : return false;
8047 : }
8048 0 : if ((!(Read((&((v__)->channelId())), msg__, iter__)))) {
8049 0 : FatalError("Error deserializing 'channelId' (uint32_t) member of 'RtspChannelConnectArgs'");
8050 0 : return false;
8051 : }
8052 : // Sentinel = 'channelId'
8053 0 : if ((!((msg__)->ReadSentinel(iter__, 6854027)))) {
8054 0 : mozilla::ipc::SentinelReadError("Error deserializing 'channelId' (uint32_t) member of 'RtspChannelConnectArgs'");
8055 0 : return false;
8056 : }
8057 0 : return true;
8058 : }
8059 :
8060 0 : auto PNeckoChild::Write(
8061 : const PChildToParentStreamChild* v__,
8062 : Message* msg__,
8063 : bool nullable__) -> void
8064 : {
8065 : int32_t id;
8066 0 : if ((!(v__))) {
8067 0 : if ((!(nullable__))) {
8068 0 : FatalError("NULL actor value passed to non-nullable param");
8069 : }
8070 0 : id = 0;
8071 : }
8072 : else {
8073 0 : id = (v__)->Id();
8074 0 : if ((1) == (id)) {
8075 0 : FatalError("actor has been |delete|d");
8076 : }
8077 : }
8078 :
8079 0 : Write(id, msg__);
8080 0 : }
8081 :
8082 0 : auto PNeckoChild::Read(
8083 : PChildToParentStreamChild** v__,
8084 : const Message* msg__,
8085 : PickleIterator* iter__,
8086 : bool nullable__) -> bool
8087 : {
8088 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PChildToParentStream", PChildToParentStreamMsgStart);
8089 0 : if ((actor).isNothing()) {
8090 0 : return false;
8091 : }
8092 :
8093 0 : (*(v__)) = static_cast<PChildToParentStreamChild*>((actor).value());
8094 0 : return true;
8095 : }
8096 :
8097 0 : auto PNeckoChild::Write(
8098 : const HttpChannelConnectArgs& v__,
8099 : Message* msg__) -> void
8100 : {
8101 0 : Write((v__).registrarId(), msg__);
8102 : // Sentinel = 'registrarId'
8103 0 : (msg__)->WriteSentinel(3202787989);
8104 0 : Write((v__).shouldIntercept(), msg__);
8105 : // Sentinel = 'shouldIntercept'
8106 0 : (msg__)->WriteSentinel(2213461606);
8107 0 : }
8108 :
8109 0 : auto PNeckoChild::Read(
8110 : HttpChannelConnectArgs* v__,
8111 : const Message* msg__,
8112 : PickleIterator* iter__) -> bool
8113 : {
8114 0 : if ((!(Read((&((v__)->registrarId())), msg__, iter__)))) {
8115 0 : FatalError("Error deserializing 'registrarId' (uint32_t) member of 'HttpChannelConnectArgs'");
8116 0 : return false;
8117 : }
8118 : // Sentinel = 'registrarId'
8119 0 : if ((!((msg__)->ReadSentinel(iter__, 3202787989)))) {
8120 0 : mozilla::ipc::SentinelReadError("Error deserializing 'registrarId' (uint32_t) member of 'HttpChannelConnectArgs'");
8121 0 : return false;
8122 : }
8123 0 : if ((!(Read((&((v__)->shouldIntercept())), msg__, iter__)))) {
8124 0 : FatalError("Error deserializing 'shouldIntercept' (bool) member of 'HttpChannelConnectArgs'");
8125 0 : return false;
8126 : }
8127 : // Sentinel = 'shouldIntercept'
8128 0 : if ((!((msg__)->ReadSentinel(iter__, 2213461606)))) {
8129 0 : mozilla::ipc::SentinelReadError("Error deserializing 'shouldIntercept' (bool) member of 'HttpChannelConnectArgs'");
8130 0 : return false;
8131 : }
8132 0 : return true;
8133 : }
8134 :
8135 :
8136 :
8137 : } // namespace net
8138 : } // namespace mozilla
|
