Line data Source code
1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 :
7 : #include "mozilla/dom/PContentBridgeChild.h"
8 : #include "mozilla/dom/MessagePort.h"
9 : #include "mozilla/dom/PermissionMessageUtils.h"
10 : #include "mozilla/dom/ipc/StructuredCloneData.h"
11 : #ifdef MOZ_CRASHREPORTER
12 : # include "nsXULAppAPI.h"
13 : #endif
14 :
15 : #include "mozilla/dom/PBrowserChild.h"
16 : #include "mozilla/dom/PContentChild.h"
17 : #include "mozilla/jsipc/PJavaScriptChild.h"
18 : #include "mozilla/ipc/PFileDescriptorSetChild.h"
19 : #include "mozilla/ipc/PChildToParentStreamChild.h"
20 : #include "mozilla/ipc/PParentToChildStreamChild.h"
21 : #include "mozilla/ipc/PIPCBlobInputStreamChild.h"
22 :
23 : #include "nsIFile.h"
24 : #include "GeckoProfiler.h"
25 :
26 : namespace mozilla {
27 : namespace dom {
28 :
29 :
30 0 : auto PContentBridgeChild::RecvPParentToChildStreamConstructor(PParentToChildStreamChild* actor) -> mozilla::ipc::IPCResult
31 : {
32 0 : return IPC_OK();
33 : }
34 :
35 0 : auto PContentBridgeChild::RecvPIPCBlobInputStreamConstructor(
36 : PIPCBlobInputStreamChild* actor,
37 : const nsID& aID,
38 : const uint64_t& aSize) -> mozilla::ipc::IPCResult
39 : {
40 0 : return IPC_OK();
41 : }
42 :
43 0 : auto PContentBridgeChild::RecvPBrowserConstructor(
44 : PBrowserChild* actor,
45 : const TabId& tabId,
46 : const TabId& sameTabGroupAs,
47 : const IPCTabContext& context,
48 : const uint32_t& chromeFlags,
49 : const ContentParentId& cpId,
50 : const bool& isForBrowser) -> mozilla::ipc::IPCResult
51 : {
52 0 : return IPC_OK();
53 : }
54 :
55 0 : auto PContentBridgeChild::RecvPFileDescriptorSetConstructor(
56 : PFileDescriptorSetChild* actor,
57 : const FileDescriptor& fd) -> mozilla::ipc::IPCResult
58 : {
59 0 : return IPC_OK();
60 : }
61 :
62 0 : auto PContentBridgeChild::ActorDestroy(ActorDestroyReason aWhy) -> void
63 : {
64 0 : }
65 :
66 0 : auto PContentBridgeChild::ProcessingError(
67 : Result aCode,
68 : const char* aReason) -> void
69 : {
70 0 : }
71 :
72 0 : auto PContentBridgeChild::ShouldContinueFromReplyTimeout() -> bool
73 : {
74 0 : return true;
75 : }
76 :
77 0 : auto PContentBridgeChild::EnteredCxxStack() -> void
78 : {
79 0 : }
80 :
81 0 : auto PContentBridgeChild::ExitedCxxStack() -> void
82 : {
83 0 : }
84 :
85 0 : auto PContentBridgeChild::EnteredCall() -> void
86 : {
87 0 : }
88 :
89 0 : auto PContentBridgeChild::ExitedCall() -> void
90 : {
91 0 : }
92 :
93 0 : MOZ_IMPLICIT PContentBridgeChild::PContentBridgeChild() :
94 : mozilla::ipc::IToplevelProtocol(PContentBridgeMsgStart, mozilla::ipc::ChildSide),
95 : mChannel("PContentBridgeChild", ALLOW_THIS_IN_INITIALIZER_LIST(this)),
96 0 : mState(PContentBridge::__Start)
97 : {
98 0 : MOZ_COUNT_CTOR(PContentBridgeChild);
99 0 : }
100 :
101 0 : PContentBridgeChild::~PContentBridgeChild()
102 : {
103 0 : MOZ_COUNT_DTOR(PContentBridgeChild);
104 0 : }
105 :
106 0 : auto PContentBridgeChild::ManagedPBrowserChild(nsTArray<PBrowserChild*>& aArr) const -> void
107 : {
108 0 : (mManagedPBrowserChild).ToArray(aArr);
109 0 : }
110 :
111 0 : auto PContentBridgeChild::ManagedPBrowserChild() const -> const ManagedContainer<PBrowserChild>&
112 : {
113 0 : return mManagedPBrowserChild;
114 : }
115 :
116 0 : auto PContentBridgeChild::ManagedPFileDescriptorSetChild(nsTArray<PFileDescriptorSetChild*>& aArr) const -> void
117 : {
118 0 : (mManagedPFileDescriptorSetChild).ToArray(aArr);
119 0 : }
120 :
121 0 : auto PContentBridgeChild::ManagedPFileDescriptorSetChild() const -> const ManagedContainer<PFileDescriptorSetChild>&
122 : {
123 0 : return mManagedPFileDescriptorSetChild;
124 : }
125 :
126 0 : auto PContentBridgeChild::ManagedPJavaScriptChild(nsTArray<PJavaScriptChild*>& aArr) const -> void
127 : {
128 0 : (mManagedPJavaScriptChild).ToArray(aArr);
129 0 : }
130 :
131 0 : auto PContentBridgeChild::ManagedPJavaScriptChild() const -> const ManagedContainer<PJavaScriptChild>&
132 : {
133 0 : return mManagedPJavaScriptChild;
134 : }
135 :
136 0 : auto PContentBridgeChild::ManagedPChildToParentStreamChild(nsTArray<PChildToParentStreamChild*>& aArr) const -> void
137 : {
138 0 : (mManagedPChildToParentStreamChild).ToArray(aArr);
139 0 : }
140 :
141 0 : auto PContentBridgeChild::ManagedPChildToParentStreamChild() const -> const ManagedContainer<PChildToParentStreamChild>&
142 : {
143 0 : return mManagedPChildToParentStreamChild;
144 : }
145 :
146 0 : auto PContentBridgeChild::ManagedPParentToChildStreamChild(nsTArray<PParentToChildStreamChild*>& aArr) const -> void
147 : {
148 0 : (mManagedPParentToChildStreamChild).ToArray(aArr);
149 0 : }
150 :
151 0 : auto PContentBridgeChild::ManagedPParentToChildStreamChild() const -> const ManagedContainer<PParentToChildStreamChild>&
152 : {
153 0 : return mManagedPParentToChildStreamChild;
154 : }
155 :
156 0 : auto PContentBridgeChild::ManagedPIPCBlobInputStreamChild(nsTArray<PIPCBlobInputStreamChild*>& aArr) const -> void
157 : {
158 0 : (mManagedPIPCBlobInputStreamChild).ToArray(aArr);
159 0 : }
160 :
161 0 : auto PContentBridgeChild::ManagedPIPCBlobInputStreamChild() const -> const ManagedContainer<PIPCBlobInputStreamChild>&
162 : {
163 0 : return mManagedPIPCBlobInputStreamChild;
164 : }
165 :
166 0 : auto PContentBridgeChild::SendSyncMessage(
167 : const nsString& aMessage,
168 : const ClonedMessageData& aData,
169 : const nsTArray<CpowEntry>& aCpows,
170 : const Principal& aPrincipal,
171 : nsTArray<StructuredCloneData>* retval) -> bool
172 : {
173 0 : IPC::Message* msg__ = PContentBridge::Msg_SyncMessage(MSG_ROUTING_CONTROL);
174 :
175 0 : Write(aMessage, msg__);
176 : // Sentinel = 'aMessage'
177 0 : (msg__)->WriteSentinel(3453110902);
178 0 : Write(aData, msg__);
179 : // Sentinel = 'aData'
180 0 : (msg__)->WriteSentinel(3285075324);
181 0 : Write(aCpows, msg__);
182 : // Sentinel = 'aCpows'
183 0 : (msg__)->WriteSentinel(2178221451);
184 0 : Write(aPrincipal, msg__);
185 : // Sentinel = 'aPrincipal'
186 0 : (msg__)->WriteSentinel(4097511);
187 :
188 0 : (msg__)->set_sync();
189 :
190 :
191 0 : Message reply__;
192 :
193 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
194 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
195 : }
196 0 : AUTO_PROFILER_LABEL("PContentBridge::Msg_SyncMessage", OTHER);
197 0 : PContentBridge::Transition(PContentBridge::Msg_SyncMessage__ID, (&(mState)));
198 :
199 : bool sendok__;
200 : {
201 : AutoProfilerTracing syncIPCTracer(
202 : "IPC",
203 0 : "PContentBridge::Msg_SyncMessage");
204 0 : sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
205 : }
206 0 : if ((!(sendok__))) {
207 0 : return false;
208 : }
209 :
210 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
211 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
212 : }
213 :
214 0 : PickleIterator iter__(reply__);
215 :
216 0 : if ((!(Read(retval, (&(reply__)), (&(iter__)))))) {
217 0 : FatalError("Error deserializing 'nsTArray'");
218 0 : return false;
219 : }
220 : // Sentinel = 'retval'
221 0 : if ((!(((&(reply__)))->ReadSentinel((&(iter__)), 3130628604)))) {
222 0 : mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
223 0 : return false;
224 : }
225 0 : (reply__).EndRead(iter__, (reply__).type());
226 :
227 0 : return true;
228 : }
229 :
230 0 : auto PContentBridgeChild::SendPJavaScriptConstructor() -> PJavaScriptChild*
231 : {
232 0 : return SendPJavaScriptConstructor(AllocPJavaScriptChild());
233 : }
234 :
235 0 : auto PContentBridgeChild::SendPJavaScriptConstructor(PJavaScriptChild* actor) -> PJavaScriptChild*
236 : {
237 0 : if ((!(actor))) {
238 0 : NS_WARNING("Error constructing actor PJavaScriptChild");
239 0 : return nullptr;
240 : }
241 0 : (actor)->SetManager(this);
242 0 : Register(actor);
243 0 : (actor)->SetIPCChannel(GetIPCChannel());
244 0 : (mManagedPJavaScriptChild).PutEntry(actor);
245 0 : (actor)->mState = mozilla::jsipc::PJavaScript::__Start;
246 :
247 0 : IPC::Message* msg__ = PContentBridge::Msg_PJavaScriptConstructor(MSG_ROUTING_CONTROL);
248 :
249 0 : Write(actor, msg__, false);
250 : // Sentinel = 'actor'
251 0 : (msg__)->WriteSentinel(875202478);
252 :
253 0 : (msg__)->set_constructor();
254 :
255 :
256 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
257 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
258 : }
259 0 : AUTO_PROFILER_LABEL("PContentBridge::Msg_PJavaScriptConstructor", OTHER);
260 0 : PContentBridge::Transition(PContentBridge::Msg_PJavaScriptConstructor__ID, (&(mState)));
261 :
262 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
263 0 : if ((!(sendok__))) {
264 0 : FatalError("constructor for actor failed");
265 0 : return nullptr;
266 : }
267 0 : return actor;
268 : }
269 :
270 0 : auto PContentBridgeChild::SendPChildToParentStreamConstructor() -> PChildToParentStreamChild*
271 : {
272 0 : return SendPChildToParentStreamConstructor(AllocPChildToParentStreamChild());
273 : }
274 :
275 0 : auto PContentBridgeChild::SendPChildToParentStreamConstructor(PChildToParentStreamChild* actor) -> PChildToParentStreamChild*
276 : {
277 0 : if ((!(actor))) {
278 0 : NS_WARNING("Error constructing actor PChildToParentStreamChild");
279 0 : return nullptr;
280 : }
281 0 : (actor)->SetManager(this);
282 0 : Register(actor);
283 0 : (actor)->SetIPCChannel(GetIPCChannel());
284 0 : (mManagedPChildToParentStreamChild).PutEntry(actor);
285 0 : (actor)->mState = mozilla::ipc::PChildToParentStream::__Start;
286 :
287 0 : IPC::Message* msg__ = PContentBridge::Msg_PChildToParentStreamConstructor(MSG_ROUTING_CONTROL);
288 :
289 0 : Write(actor, msg__, false);
290 : // Sentinel = 'actor'
291 0 : (msg__)->WriteSentinel(875202478);
292 :
293 0 : (msg__)->set_constructor();
294 :
295 :
296 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
297 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
298 : }
299 0 : AUTO_PROFILER_LABEL("PContentBridge::Msg_PChildToParentStreamConstructor", OTHER);
300 0 : PContentBridge::Transition(PContentBridge::Msg_PChildToParentStreamConstructor__ID, (&(mState)));
301 :
302 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
303 0 : if ((!(sendok__))) {
304 0 : FatalError("constructor for actor failed");
305 0 : return nullptr;
306 : }
307 0 : return actor;
308 : }
309 :
310 0 : auto PContentBridgeChild::SendPBrowserConstructor(
311 : const TabId& tabId,
312 : const TabId& sameTabGroupAs,
313 : const IPCTabContext& context,
314 : const uint32_t& chromeFlags,
315 : const ContentParentId& cpId,
316 : const bool& isForBrowser) -> PBrowserChild*
317 : {
318 0 : return SendPBrowserConstructor(AllocPBrowserChild(tabId, sameTabGroupAs, context, chromeFlags, cpId, isForBrowser), tabId, sameTabGroupAs, context, chromeFlags, cpId, isForBrowser);
319 : }
320 :
321 0 : auto PContentBridgeChild::SendPBrowserConstructor(
322 : PBrowserChild* actor,
323 : const TabId& tabId,
324 : const TabId& sameTabGroupAs,
325 : const IPCTabContext& context,
326 : const uint32_t& chromeFlags,
327 : const ContentParentId& cpId,
328 : const bool& isForBrowser) -> PBrowserChild*
329 : {
330 0 : if ((!(actor))) {
331 0 : NS_WARNING("Error constructing actor PBrowserChild");
332 0 : return nullptr;
333 : }
334 0 : (actor)->SetManager(this);
335 0 : Register(actor);
336 0 : (actor)->SetIPCChannel(GetIPCChannel());
337 0 : (mManagedPBrowserChild).PutEntry(actor);
338 0 : (actor)->mState = mozilla::dom::PBrowser::__Start;
339 :
340 0 : IPC::Message* msg__ = PContentBridge::Msg_PBrowserConstructor(MSG_ROUTING_CONTROL);
341 :
342 0 : Write(actor, msg__, false);
343 : // Sentinel = 'actor'
344 0 : (msg__)->WriteSentinel(875202478);
345 0 : Write(tabId, msg__);
346 : // Sentinel = 'tabId'
347 0 : (msg__)->WriteSentinel(3419081923);
348 0 : Write(sameTabGroupAs, msg__);
349 : // Sentinel = 'sameTabGroupAs'
350 0 : (msg__)->WriteSentinel(3969365410);
351 0 : Write(context, msg__);
352 : // Sentinel = 'context'
353 0 : (msg__)->WriteSentinel(3514529014);
354 0 : Write(chromeFlags, msg__);
355 : // Sentinel = 'chromeFlags'
356 0 : (msg__)->WriteSentinel(299515804);
357 0 : Write(cpId, msg__);
358 : // Sentinel = 'cpId'
359 0 : (msg__)->WriteSentinel(2452595622);
360 0 : Write(isForBrowser, msg__);
361 : // Sentinel = 'isForBrowser'
362 0 : (msg__)->WriteSentinel(2051565587);
363 :
364 0 : (msg__)->set_constructor();
365 :
366 :
367 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
368 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
369 : }
370 0 : AUTO_PROFILER_LABEL("PContentBridge::Msg_PBrowserConstructor", OTHER);
371 0 : PContentBridge::Transition(PContentBridge::Msg_PBrowserConstructor__ID, (&(mState)));
372 :
373 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
374 0 : if ((!(sendok__))) {
375 0 : FatalError("constructor for actor failed");
376 0 : return nullptr;
377 : }
378 0 : return actor;
379 : }
380 :
381 0 : auto PContentBridgeChild::SendPFileDescriptorSetConstructor(const FileDescriptor& fd) -> PFileDescriptorSetChild*
382 : {
383 0 : return SendPFileDescriptorSetConstructor(AllocPFileDescriptorSetChild(fd), fd);
384 : }
385 :
386 0 : auto PContentBridgeChild::SendPFileDescriptorSetConstructor(
387 : PFileDescriptorSetChild* actor,
388 : const FileDescriptor& fd) -> PFileDescriptorSetChild*
389 : {
390 0 : if ((!(actor))) {
391 0 : NS_WARNING("Error constructing actor PFileDescriptorSetChild");
392 0 : return nullptr;
393 : }
394 0 : (actor)->SetManager(this);
395 0 : Register(actor);
396 0 : (actor)->SetIPCChannel(GetIPCChannel());
397 0 : (mManagedPFileDescriptorSetChild).PutEntry(actor);
398 0 : (actor)->mState = mozilla::ipc::PFileDescriptorSet::__Start;
399 :
400 0 : IPC::Message* msg__ = PContentBridge::Msg_PFileDescriptorSetConstructor(MSG_ROUTING_CONTROL);
401 :
402 0 : Write(actor, msg__, false);
403 : // Sentinel = 'actor'
404 0 : (msg__)->WriteSentinel(875202478);
405 0 : Write(fd, msg__);
406 : // Sentinel = 'fd'
407 0 : (msg__)->WriteSentinel(628535764);
408 :
409 0 : (msg__)->set_constructor();
410 :
411 :
412 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
413 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
414 : }
415 0 : AUTO_PROFILER_LABEL("PContentBridge::Msg_PFileDescriptorSetConstructor", OTHER);
416 0 : PContentBridge::Transition(PContentBridge::Msg_PFileDescriptorSetConstructor__ID, (&(mState)));
417 :
418 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
419 0 : if ((!(sendok__))) {
420 0 : FatalError("constructor for actor failed");
421 0 : return nullptr;
422 : }
423 0 : return actor;
424 : }
425 :
426 0 : auto PContentBridgeChild::SendAsyncMessage(
427 : const nsString& aMessage,
428 : const nsTArray<CpowEntry>& aCpows,
429 : const Principal& aPrincipal,
430 : const ClonedMessageData& aData) -> bool
431 : {
432 0 : IPC::Message* msg__ = PContentBridge::Msg_AsyncMessage(MSG_ROUTING_CONTROL);
433 :
434 0 : Write(aMessage, msg__);
435 : // Sentinel = 'aMessage'
436 0 : (msg__)->WriteSentinel(3453110902);
437 0 : Write(aCpows, msg__);
438 : // Sentinel = 'aCpows'
439 0 : (msg__)->WriteSentinel(2178221451);
440 0 : Write(aPrincipal, msg__);
441 : // Sentinel = 'aPrincipal'
442 0 : (msg__)->WriteSentinel(4097511);
443 0 : Write(aData, msg__);
444 : // Sentinel = 'aData'
445 0 : (msg__)->WriteSentinel(3285075324);
446 :
447 :
448 :
449 :
450 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
451 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
452 : }
453 0 : AUTO_PROFILER_LABEL("PContentBridge::Msg_AsyncMessage", OTHER);
454 0 : PContentBridge::Transition(PContentBridge::Msg_AsyncMessage__ID, (&(mState)));
455 :
456 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
457 0 : return sendok__;
458 : }
459 :
460 0 : auto PContentBridgeChild::GetIPCChannel() -> MessageChannel*
461 : {
462 0 : return (&(mChannel));
463 : }
464 :
465 0 : auto PContentBridgeChild::GetIPCChannel() const -> const MessageChannel*
466 : {
467 0 : return (&(mChannel));
468 : }
469 :
470 0 : auto PContentBridgeChild::RemoveManagee(
471 : int32_t aProtocolId,
472 : ProtocolBase* aListener) -> void
473 : {
474 0 : switch (aProtocolId) {
475 : case PBrowserMsgStart:
476 : {
477 0 : PBrowserChild* actor = static_cast<PBrowserChild*>(aListener);
478 0 : auto& container = mManagedPBrowserChild;
479 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
480 :
481 0 : (container).RemoveEntry(actor);
482 0 : DeallocPBrowserChild(actor);
483 0 : return;
484 : }
485 : case PFileDescriptorSetMsgStart:
486 : {
487 0 : PFileDescriptorSetChild* actor = static_cast<PFileDescriptorSetChild*>(aListener);
488 0 : auto& container = mManagedPFileDescriptorSetChild;
489 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
490 :
491 0 : (container).RemoveEntry(actor);
492 0 : DeallocPFileDescriptorSetChild(actor);
493 0 : return;
494 : }
495 : case PJavaScriptMsgStart:
496 : {
497 0 : PJavaScriptChild* actor = static_cast<PJavaScriptChild*>(aListener);
498 0 : auto& container = mManagedPJavaScriptChild;
499 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
500 :
501 0 : (container).RemoveEntry(actor);
502 0 : DeallocPJavaScriptChild(actor);
503 0 : return;
504 : }
505 : case PChildToParentStreamMsgStart:
506 : {
507 0 : PChildToParentStreamChild* actor = static_cast<PChildToParentStreamChild*>(aListener);
508 0 : auto& container = mManagedPChildToParentStreamChild;
509 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
510 :
511 0 : (container).RemoveEntry(actor);
512 0 : DeallocPChildToParentStreamChild(actor);
513 0 : return;
514 : }
515 : case PParentToChildStreamMsgStart:
516 : {
517 0 : PParentToChildStreamChild* actor = static_cast<PParentToChildStreamChild*>(aListener);
518 0 : auto& container = mManagedPParentToChildStreamChild;
519 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
520 :
521 0 : (container).RemoveEntry(actor);
522 0 : DeallocPParentToChildStreamChild(actor);
523 0 : return;
524 : }
525 : case PIPCBlobInputStreamMsgStart:
526 : {
527 0 : PIPCBlobInputStreamChild* actor = static_cast<PIPCBlobInputStreamChild*>(aListener);
528 0 : auto& container = mManagedPIPCBlobInputStreamChild;
529 0 : MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
530 :
531 0 : (container).RemoveEntry(actor);
532 0 : DeallocPIPCBlobInputStreamChild(actor);
533 0 : return;
534 : }
535 : default:
536 : {
537 0 : FatalError("unreached");
538 0 : return;
539 : }
540 : }
541 : }
542 :
543 0 : auto PContentBridgeChild::OnMessageReceived(const Message& msg__) -> PContentBridgeChild::Result
544 : {
545 0 : int32_t route__ = (msg__).routing_id();
546 0 : if ((MSG_ROUTING_CONTROL) != (route__)) {
547 0 : ChannelListener* routed__ = Lookup(route__);
548 0 : if ((!(routed__))) {
549 0 : return MsgRouteError;
550 : }
551 0 : return (routed__)->OnMessageReceived(msg__);
552 : }
553 :
554 0 : switch ((msg__).type()) {
555 : case PContentBridge::Msg_PParentToChildStreamConstructor__ID:
556 : {
557 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
558 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
559 : }
560 0 : AUTO_PROFILER_LABEL("PContentBridge::Msg_PParentToChildStreamConstructor", OTHER);
561 :
562 0 : PickleIterator iter__(msg__);
563 : ActorHandle handle__;
564 : PParentToChildStreamChild* actor;
565 :
566 0 : if ((!(Read((&(handle__)), (&(msg__)), (&(iter__)))))) {
567 0 : FatalError("Error deserializing 'ActorHandle'");
568 0 : return MsgValueError;
569 : }
570 : // Sentinel = 'actor'
571 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
572 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
573 0 : return MsgValueError;
574 : }
575 0 : (msg__).EndRead(iter__, (msg__).type());
576 0 : PContentBridge::Transition(PContentBridge::Msg_PParentToChildStreamConstructor__ID, (&(mState)));
577 0 : actor = AllocPParentToChildStreamChild();
578 0 : if ((!(actor))) {
579 0 : NS_WARNING("Error constructing actor PParentToChildStreamChild");
580 0 : return MsgValueError;
581 : }
582 0 : (actor)->SetManager(this);
583 0 : RegisterID(actor, (handle__).mId);
584 0 : (actor)->SetIPCChannel(GetIPCChannel());
585 0 : (mManagedPParentToChildStreamChild).PutEntry(actor);
586 0 : (actor)->mState = mozilla::ipc::PParentToChildStream::__Start;
587 :
588 0 : if ((!(RecvPParentToChildStreamConstructor(mozilla::Move(actor))))) {
589 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
590 : // Error handled in mozilla::ipc::IPCResult
591 0 : return MsgProcessingError;
592 : }
593 :
594 0 : return MsgProcessed;
595 : }
596 : case PContentBridge::Msg_Activate__ID:
597 : {
598 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
599 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
600 : }
601 0 : AUTO_PROFILER_LABEL("PContentBridge::Msg_Activate", OTHER);
602 :
603 0 : PickleIterator iter__(msg__);
604 : PBrowserChild* aTab;
605 :
606 0 : if ((!(Read((&(aTab)), (&(msg__)), (&(iter__)), false)))) {
607 0 : FatalError("Error deserializing 'PBrowserChild'");
608 0 : return MsgValueError;
609 : }
610 : // Sentinel = 'aTab'
611 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1179125994)))) {
612 0 : mozilla::ipc::SentinelReadError("Error deserializing 'PBrowserChild'");
613 0 : return MsgValueError;
614 : }
615 0 : (msg__).EndRead(iter__, (msg__).type());
616 0 : PContentBridge::Transition(PContentBridge::Msg_Activate__ID, (&(mState)));
617 0 : if ((!(RecvActivate(mozilla::Move(aTab))))) {
618 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
619 : // Error handled in mozilla::ipc::IPCResult
620 0 : return MsgProcessingError;
621 : }
622 :
623 0 : return MsgProcessed;
624 : }
625 : case PContentBridge::Msg_Deactivate__ID:
626 : {
627 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
628 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
629 : }
630 0 : AUTO_PROFILER_LABEL("PContentBridge::Msg_Deactivate", OTHER);
631 :
632 0 : PickleIterator iter__(msg__);
633 : PBrowserChild* aTab;
634 :
635 0 : if ((!(Read((&(aTab)), (&(msg__)), (&(iter__)), false)))) {
636 0 : FatalError("Error deserializing 'PBrowserChild'");
637 0 : return MsgValueError;
638 : }
639 : // Sentinel = 'aTab'
640 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1179125994)))) {
641 0 : mozilla::ipc::SentinelReadError("Error deserializing 'PBrowserChild'");
642 0 : return MsgValueError;
643 : }
644 0 : (msg__).EndRead(iter__, (msg__).type());
645 0 : PContentBridge::Transition(PContentBridge::Msg_Deactivate__ID, (&(mState)));
646 0 : if ((!(RecvDeactivate(mozilla::Move(aTab))))) {
647 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
648 : // Error handled in mozilla::ipc::IPCResult
649 0 : return MsgProcessingError;
650 : }
651 :
652 0 : return MsgProcessed;
653 : }
654 : case PContentBridge::Msg_ParentActivated__ID:
655 : {
656 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
657 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
658 : }
659 0 : AUTO_PROFILER_LABEL("PContentBridge::Msg_ParentActivated", OTHER);
660 :
661 0 : PickleIterator iter__(msg__);
662 : PBrowserChild* aTab;
663 : bool aActivated;
664 :
665 0 : if ((!(Read((&(aTab)), (&(msg__)), (&(iter__)), false)))) {
666 0 : FatalError("Error deserializing 'PBrowserChild'");
667 0 : return MsgValueError;
668 : }
669 : // Sentinel = 'aTab'
670 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1179125994)))) {
671 0 : mozilla::ipc::SentinelReadError("Error deserializing 'PBrowserChild'");
672 0 : return MsgValueError;
673 : }
674 0 : if ((!(Read((&(aActivated)), (&(msg__)), (&(iter__)))))) {
675 0 : FatalError("Error deserializing 'bool'");
676 0 : return MsgValueError;
677 : }
678 : // Sentinel = 'aActivated'
679 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2491273264)))) {
680 0 : mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
681 0 : return MsgValueError;
682 : }
683 0 : (msg__).EndRead(iter__, (msg__).type());
684 0 : PContentBridge::Transition(PContentBridge::Msg_ParentActivated__ID, (&(mState)));
685 0 : if ((!(RecvParentActivated(mozilla::Move(aTab), mozilla::Move(aActivated))))) {
686 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
687 : // Error handled in mozilla::ipc::IPCResult
688 0 : return MsgProcessingError;
689 : }
690 :
691 0 : return MsgProcessed;
692 : }
693 : case PContentBridge::Msg_PIPCBlobInputStreamConstructor__ID:
694 : {
695 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
696 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
697 : }
698 0 : AUTO_PROFILER_LABEL("PContentBridge::Msg_PIPCBlobInputStreamConstructor", OTHER);
699 :
700 0 : PickleIterator iter__(msg__);
701 : ActorHandle handle__;
702 : PIPCBlobInputStreamChild* actor;
703 : nsID aID;
704 : uint64_t aSize;
705 :
706 0 : if ((!(Read((&(handle__)), (&(msg__)), (&(iter__)))))) {
707 0 : FatalError("Error deserializing 'ActorHandle'");
708 0 : return MsgValueError;
709 : }
710 : // Sentinel = 'actor'
711 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
712 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
713 0 : return MsgValueError;
714 : }
715 0 : if ((!(Read((&(aID)), (&(msg__)), (&(iter__)))))) {
716 0 : FatalError("Error deserializing 'nsID'");
717 0 : return MsgValueError;
718 : }
719 : // Sentinel = 'aID'
720 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2735041849)))) {
721 0 : mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
722 0 : return MsgValueError;
723 : }
724 0 : if ((!(Read((&(aSize)), (&(msg__)), (&(iter__)))))) {
725 0 : FatalError("Error deserializing 'uint64_t'");
726 0 : return MsgValueError;
727 : }
728 : // Sentinel = 'aSize'
729 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2556665555)))) {
730 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
731 0 : return MsgValueError;
732 : }
733 0 : (msg__).EndRead(iter__, (msg__).type());
734 0 : PContentBridge::Transition(PContentBridge::Msg_PIPCBlobInputStreamConstructor__ID, (&(mState)));
735 0 : actor = AllocPIPCBlobInputStreamChild(aID, aSize);
736 0 : if ((!(actor))) {
737 0 : NS_WARNING("Error constructing actor PIPCBlobInputStreamChild");
738 0 : return MsgValueError;
739 : }
740 0 : (actor)->SetManager(this);
741 0 : RegisterID(actor, (handle__).mId);
742 0 : (actor)->SetIPCChannel(GetIPCChannel());
743 0 : (mManagedPIPCBlobInputStreamChild).PutEntry(actor);
744 0 : (actor)->mState = mozilla::ipc::PIPCBlobInputStream::__Start;
745 :
746 0 : if ((!(RecvPIPCBlobInputStreamConstructor(mozilla::Move(actor), mozilla::Move(aID), mozilla::Move(aSize))))) {
747 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
748 : // Error handled in mozilla::ipc::IPCResult
749 0 : return MsgProcessingError;
750 : }
751 :
752 0 : return MsgProcessed;
753 : }
754 : case PContentBridge::Reply_PJavaScriptConstructor__ID:
755 : {
756 0 : return MsgProcessed;
757 : }
758 : case PContentBridge::Reply_PChildToParentStreamConstructor__ID:
759 : {
760 0 : return MsgProcessed;
761 : }
762 : case PContentBridge::Reply_PBrowserConstructor__ID:
763 : {
764 0 : return MsgProcessed;
765 : }
766 : case PContentBridge::Msg_PBrowserConstructor__ID:
767 : {
768 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
769 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
770 : }
771 0 : AUTO_PROFILER_LABEL("PContentBridge::Msg_PBrowserConstructor", OTHER);
772 :
773 0 : PickleIterator iter__(msg__);
774 : ActorHandle handle__;
775 : PBrowserChild* actor;
776 0 : TabId tabId;
777 0 : TabId sameTabGroupAs;
778 0 : IPCTabContext context;
779 : uint32_t chromeFlags;
780 0 : ContentParentId cpId;
781 : bool isForBrowser;
782 :
783 0 : if ((!(Read((&(handle__)), (&(msg__)), (&(iter__)))))) {
784 0 : FatalError("Error deserializing 'ActorHandle'");
785 0 : return MsgValueError;
786 : }
787 : // Sentinel = 'actor'
788 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
789 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
790 0 : return MsgValueError;
791 : }
792 0 : if ((!(Read((&(tabId)), (&(msg__)), (&(iter__)))))) {
793 0 : FatalError("Error deserializing 'TabId'");
794 0 : return MsgValueError;
795 : }
796 : // Sentinel = 'tabId'
797 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3419081923)))) {
798 0 : mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
799 0 : return MsgValueError;
800 : }
801 0 : if ((!(Read((&(sameTabGroupAs)), (&(msg__)), (&(iter__)))))) {
802 0 : FatalError("Error deserializing 'TabId'");
803 0 : return MsgValueError;
804 : }
805 : // Sentinel = 'sameTabGroupAs'
806 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3969365410)))) {
807 0 : mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
808 0 : return MsgValueError;
809 : }
810 0 : if ((!(Read((&(context)), (&(msg__)), (&(iter__)))))) {
811 0 : FatalError("Error deserializing 'IPCTabContext'");
812 0 : return MsgValueError;
813 : }
814 : // Sentinel = 'context'
815 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3514529014)))) {
816 0 : mozilla::ipc::SentinelReadError("Error deserializing 'IPCTabContext'");
817 0 : return MsgValueError;
818 : }
819 0 : if ((!(Read((&(chromeFlags)), (&(msg__)), (&(iter__)))))) {
820 0 : FatalError("Error deserializing 'uint32_t'");
821 0 : return MsgValueError;
822 : }
823 : // Sentinel = 'chromeFlags'
824 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 299515804)))) {
825 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
826 0 : return MsgValueError;
827 : }
828 0 : if ((!(Read((&(cpId)), (&(msg__)), (&(iter__)))))) {
829 0 : FatalError("Error deserializing 'ContentParentId'");
830 0 : return MsgValueError;
831 : }
832 : // Sentinel = 'cpId'
833 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2452595622)))) {
834 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ContentParentId'");
835 0 : return MsgValueError;
836 : }
837 0 : if ((!(Read((&(isForBrowser)), (&(msg__)), (&(iter__)))))) {
838 0 : FatalError("Error deserializing 'bool'");
839 0 : return MsgValueError;
840 : }
841 : // Sentinel = 'isForBrowser'
842 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2051565587)))) {
843 0 : mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
844 0 : return MsgValueError;
845 : }
846 0 : (msg__).EndRead(iter__, (msg__).type());
847 0 : PContentBridge::Transition(PContentBridge::Msg_PBrowserConstructor__ID, (&(mState)));
848 0 : actor = AllocPBrowserChild(tabId, sameTabGroupAs, context, chromeFlags, cpId, isForBrowser);
849 0 : if ((!(actor))) {
850 0 : NS_WARNING("Error constructing actor PBrowserChild");
851 0 : return MsgValueError;
852 : }
853 0 : (actor)->SetManager(this);
854 0 : RegisterID(actor, (handle__).mId);
855 0 : (actor)->SetIPCChannel(GetIPCChannel());
856 0 : (mManagedPBrowserChild).PutEntry(actor);
857 0 : (actor)->mState = mozilla::dom::PBrowser::__Start;
858 :
859 0 : if ((!(RecvPBrowserConstructor(mozilla::Move(actor), mozilla::Move(tabId), mozilla::Move(sameTabGroupAs), mozilla::Move(context), mozilla::Move(chromeFlags), mozilla::Move(cpId), mozilla::Move(isForBrowser))))) {
860 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
861 : // Error handled in mozilla::ipc::IPCResult
862 0 : return MsgProcessingError;
863 : }
864 :
865 0 : return MsgProcessed;
866 : }
867 : case PContentBridge::Reply_PFileDescriptorSetConstructor__ID:
868 : {
869 0 : return MsgProcessed;
870 : }
871 : case PContentBridge::Msg_PFileDescriptorSetConstructor__ID:
872 : {
873 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
874 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
875 : }
876 0 : AUTO_PROFILER_LABEL("PContentBridge::Msg_PFileDescriptorSetConstructor", OTHER);
877 :
878 0 : PickleIterator iter__(msg__);
879 : ActorHandle handle__;
880 : PFileDescriptorSetChild* actor;
881 0 : FileDescriptor fd;
882 :
883 0 : if ((!(Read((&(handle__)), (&(msg__)), (&(iter__)))))) {
884 0 : FatalError("Error deserializing 'ActorHandle'");
885 0 : return MsgValueError;
886 : }
887 : // Sentinel = 'actor'
888 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
889 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
890 0 : return MsgValueError;
891 : }
892 0 : if ((!(Read((&(fd)), (&(msg__)), (&(iter__)))))) {
893 0 : FatalError("Error deserializing 'FileDescriptor'");
894 0 : return MsgValueError;
895 : }
896 : // Sentinel = 'fd'
897 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 628535764)))) {
898 0 : mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor'");
899 0 : return MsgValueError;
900 : }
901 0 : (msg__).EndRead(iter__, (msg__).type());
902 0 : PContentBridge::Transition(PContentBridge::Msg_PFileDescriptorSetConstructor__ID, (&(mState)));
903 0 : actor = AllocPFileDescriptorSetChild(fd);
904 0 : if ((!(actor))) {
905 0 : NS_WARNING("Error constructing actor PFileDescriptorSetChild");
906 0 : return MsgValueError;
907 : }
908 0 : (actor)->SetManager(this);
909 0 : RegisterID(actor, (handle__).mId);
910 0 : (actor)->SetIPCChannel(GetIPCChannel());
911 0 : (mManagedPFileDescriptorSetChild).PutEntry(actor);
912 0 : (actor)->mState = mozilla::ipc::PFileDescriptorSet::__Start;
913 :
914 0 : if ((!(RecvPFileDescriptorSetConstructor(mozilla::Move(actor), mozilla::Move(fd))))) {
915 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
916 : // Error handled in mozilla::ipc::IPCResult
917 0 : return MsgProcessingError;
918 : }
919 :
920 0 : return MsgProcessed;
921 : }
922 : case PContentBridge::Msg_AsyncMessage__ID:
923 : {
924 0 : if (mozilla::ipc::LoggingEnabledFor("PContentBridgeChild")) {
925 0 : mozilla::ipc::LogMessageForProtocol("PContentBridgeChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
926 : }
927 0 : AUTO_PROFILER_LABEL("PContentBridge::Msg_AsyncMessage", OTHER);
928 :
929 0 : PickleIterator iter__(msg__);
930 0 : nsString aMessage;
931 0 : nsTArray<CpowEntry> aCpows;
932 0 : Principal aPrincipal;
933 0 : ClonedMessageData aData;
934 :
935 0 : if ((!(Read((&(aMessage)), (&(msg__)), (&(iter__)))))) {
936 0 : FatalError("Error deserializing 'nsString'");
937 0 : return MsgValueError;
938 : }
939 : // Sentinel = 'aMessage'
940 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3453110902)))) {
941 0 : mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
942 0 : return MsgValueError;
943 : }
944 0 : if ((!(Read((&(aCpows)), (&(msg__)), (&(iter__)))))) {
945 0 : FatalError("Error deserializing 'nsTArray'");
946 0 : return MsgValueError;
947 : }
948 : // Sentinel = 'aCpows'
949 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2178221451)))) {
950 0 : mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
951 0 : return MsgValueError;
952 : }
953 0 : if ((!(Read((&(aPrincipal)), (&(msg__)), (&(iter__)))))) {
954 0 : FatalError("Error deserializing 'Principal'");
955 0 : return MsgValueError;
956 : }
957 : // Sentinel = 'aPrincipal'
958 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4097511)))) {
959 0 : mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
960 0 : return MsgValueError;
961 : }
962 0 : if ((!(Read((&(aData)), (&(msg__)), (&(iter__)))))) {
963 0 : FatalError("Error deserializing 'ClonedMessageData'");
964 0 : return MsgValueError;
965 : }
966 : // Sentinel = 'aData'
967 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3285075324)))) {
968 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData'");
969 0 : return MsgValueError;
970 : }
971 0 : (msg__).EndRead(iter__, (msg__).type());
972 0 : PContentBridge::Transition(PContentBridge::Msg_AsyncMessage__ID, (&(mState)));
973 0 : if ((!(RecvAsyncMessage(mozilla::Move(aMessage), mozilla::Move(aCpows), mozilla::Move(aPrincipal), mozilla::Move(aData))))) {
974 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
975 : // Error handled in mozilla::ipc::IPCResult
976 0 : return MsgProcessingError;
977 : }
978 :
979 0 : return MsgProcessed;
980 : }
981 : default:
982 : {
983 0 : return MsgNotKnown;
984 : }
985 : case SHMEM_CREATED_MESSAGE_TYPE:
986 : {
987 0 : if ((!(ShmemCreated(msg__)))) {
988 0 : return MsgPayloadError;
989 : }
990 0 : return MsgProcessed;
991 : }
992 : case SHMEM_DESTROYED_MESSAGE_TYPE:
993 : {
994 0 : if ((!(ShmemDestroyed(msg__)))) {
995 0 : return MsgPayloadError;
996 : }
997 0 : return MsgProcessed;
998 : }
999 : }
1000 : }
1001 :
1002 0 : auto PContentBridgeChild::OnMessageReceived(
1003 : const Message& msg__,
1004 : Message*& reply__) -> PContentBridgeChild::Result
1005 : {
1006 0 : int32_t route__ = (msg__).routing_id();
1007 0 : if ((MSG_ROUTING_CONTROL) != (route__)) {
1008 0 : ChannelListener* routed__ = Lookup(route__);
1009 0 : if ((!(routed__))) {
1010 0 : return MsgRouteError;
1011 : }
1012 0 : return (routed__)->OnMessageReceived(msg__, reply__);
1013 : }
1014 :
1015 0 : return MsgNotKnown;
1016 : }
1017 :
1018 0 : auto PContentBridgeChild::OnCallReceived(
1019 : const Message& msg__,
1020 : Message*& reply__) -> PContentBridgeChild::Result
1021 : {
1022 0 : MOZ_ASSERT_UNREACHABLE("message protocol not supported");
1023 : return MsgNotKnown;
1024 : }
1025 :
1026 0 : auto PContentBridgeChild::GetProtocolTypeId() -> int32_t
1027 : {
1028 0 : return PContentBridgeMsgStart;
1029 : }
1030 :
1031 0 : auto PContentBridgeChild::OnChannelClose() -> void
1032 : {
1033 0 : DestroySubtree(NormalShutdown);
1034 0 : DeallocSubtree();
1035 0 : DeallocShmems();
1036 0 : DeallocPContentBridgeChild();
1037 0 : }
1038 :
1039 0 : auto PContentBridgeChild::OnChannelError() -> void
1040 : {
1041 0 : DestroySubtree(AbnormalShutdown);
1042 0 : DeallocSubtree();
1043 0 : DeallocShmems();
1044 0 : DeallocPContentBridgeChild();
1045 0 : }
1046 :
1047 0 : auto PContentBridgeChild::ProtocolName() const -> const char*
1048 : {
1049 0 : return "PContentBridgeChild";
1050 : }
1051 :
1052 0 : auto PContentBridgeChild::DestroySubtree(ActorDestroyReason why) -> void
1053 : {
1054 0 : ActorDestroyReason subtreewhy = (((why) == (Deletion)) || ((why) == (FailedConstructor)) ? AncestorDeletion : why);
1055 :
1056 : {
1057 : // Recursively shutting down PBrowser kids
1058 0 : nsTArray<PBrowserChild*> kids;
1059 : // Accumulate kids into a stable structure to iterate over
1060 0 : ManagedPBrowserChild(kids);
1061 0 : for (auto& kid : kids) {
1062 : // Guarding against a child removing a sibling from the list during the iteration.
1063 0 : if ((mManagedPBrowserChild).Contains(kid)) {
1064 0 : (kid)->DestroySubtree(subtreewhy);
1065 : }
1066 : }
1067 : }
1068 : {
1069 : // Recursively shutting down PFileDescriptorSet kids
1070 0 : nsTArray<PFileDescriptorSetChild*> kids;
1071 : // Accumulate kids into a stable structure to iterate over
1072 0 : ManagedPFileDescriptorSetChild(kids);
1073 0 : for (auto& kid : kids) {
1074 : // Guarding against a child removing a sibling from the list during the iteration.
1075 0 : if ((mManagedPFileDescriptorSetChild).Contains(kid)) {
1076 0 : (kid)->DestroySubtree(subtreewhy);
1077 : }
1078 : }
1079 : }
1080 : {
1081 : // Recursively shutting down PJavaScript kids
1082 0 : nsTArray<PJavaScriptChild*> kids;
1083 : // Accumulate kids into a stable structure to iterate over
1084 0 : ManagedPJavaScriptChild(kids);
1085 0 : for (auto& kid : kids) {
1086 : // Guarding against a child removing a sibling from the list during the iteration.
1087 0 : if ((mManagedPJavaScriptChild).Contains(kid)) {
1088 0 : (kid)->DestroySubtree(subtreewhy);
1089 : }
1090 : }
1091 : }
1092 : {
1093 : // Recursively shutting down PChildToParentStream kids
1094 0 : nsTArray<PChildToParentStreamChild*> kids;
1095 : // Accumulate kids into a stable structure to iterate over
1096 0 : ManagedPChildToParentStreamChild(kids);
1097 0 : for (auto& kid : kids) {
1098 : // Guarding against a child removing a sibling from the list during the iteration.
1099 0 : if ((mManagedPChildToParentStreamChild).Contains(kid)) {
1100 0 : (kid)->DestroySubtree(subtreewhy);
1101 : }
1102 : }
1103 : }
1104 : {
1105 : // Recursively shutting down PParentToChildStream kids
1106 0 : nsTArray<PParentToChildStreamChild*> kids;
1107 : // Accumulate kids into a stable structure to iterate over
1108 0 : ManagedPParentToChildStreamChild(kids);
1109 0 : for (auto& kid : kids) {
1110 : // Guarding against a child removing a sibling from the list during the iteration.
1111 0 : if ((mManagedPParentToChildStreamChild).Contains(kid)) {
1112 0 : (kid)->DestroySubtree(subtreewhy);
1113 : }
1114 : }
1115 : }
1116 : {
1117 : // Recursively shutting down PIPCBlobInputStream kids
1118 0 : nsTArray<PIPCBlobInputStreamChild*> kids;
1119 : // Accumulate kids into a stable structure to iterate over
1120 0 : ManagedPIPCBlobInputStreamChild(kids);
1121 0 : for (auto& kid : kids) {
1122 : // Guarding against a child removing a sibling from the list during the iteration.
1123 0 : if ((mManagedPIPCBlobInputStreamChild).Contains(kid)) {
1124 0 : (kid)->DestroySubtree(subtreewhy);
1125 : }
1126 : }
1127 : }
1128 :
1129 : // Reject owning pending promises.
1130 0 : (GetIPCChannel())->RejectPendingPromisesForActor(this);
1131 :
1132 : // Finally, destroy "us".
1133 0 : ActorDestroy(why);
1134 0 : }
1135 :
1136 0 : auto PContentBridgeChild::DeallocSubtree() -> void
1137 : {
1138 : {
1139 : // Recursively deleting PBrowser kids
1140 0 : for (auto iter = (mManagedPBrowserChild).Iter(); (!((iter).Done())); (iter).Next()) {
1141 0 : (((iter).Get())->GetKey())->DeallocSubtree();
1142 : }
1143 :
1144 0 : for (auto iter = (mManagedPBrowserChild).Iter(); (!((iter).Done())); (iter).Next()) {
1145 0 : DeallocPBrowserChild(((iter).Get())->GetKey());
1146 : }
1147 0 : (mManagedPBrowserChild).Clear();
1148 : }
1149 : {
1150 : // Recursively deleting PFileDescriptorSet kids
1151 0 : for (auto iter = (mManagedPFileDescriptorSetChild).Iter(); (!((iter).Done())); (iter).Next()) {
1152 0 : (((iter).Get())->GetKey())->DeallocSubtree();
1153 : }
1154 :
1155 0 : for (auto iter = (mManagedPFileDescriptorSetChild).Iter(); (!((iter).Done())); (iter).Next()) {
1156 0 : DeallocPFileDescriptorSetChild(((iter).Get())->GetKey());
1157 : }
1158 0 : (mManagedPFileDescriptorSetChild).Clear();
1159 : }
1160 : {
1161 : // Recursively deleting PJavaScript kids
1162 0 : for (auto iter = (mManagedPJavaScriptChild).Iter(); (!((iter).Done())); (iter).Next()) {
1163 0 : (((iter).Get())->GetKey())->DeallocSubtree();
1164 : }
1165 :
1166 0 : for (auto iter = (mManagedPJavaScriptChild).Iter(); (!((iter).Done())); (iter).Next()) {
1167 0 : DeallocPJavaScriptChild(((iter).Get())->GetKey());
1168 : }
1169 0 : (mManagedPJavaScriptChild).Clear();
1170 : }
1171 : {
1172 : // Recursively deleting PChildToParentStream kids
1173 0 : for (auto iter = (mManagedPChildToParentStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
1174 0 : (((iter).Get())->GetKey())->DeallocSubtree();
1175 : }
1176 :
1177 0 : for (auto iter = (mManagedPChildToParentStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
1178 0 : DeallocPChildToParentStreamChild(((iter).Get())->GetKey());
1179 : }
1180 0 : (mManagedPChildToParentStreamChild).Clear();
1181 : }
1182 : {
1183 : // Recursively deleting PParentToChildStream kids
1184 0 : for (auto iter = (mManagedPParentToChildStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
1185 0 : (((iter).Get())->GetKey())->DeallocSubtree();
1186 : }
1187 :
1188 0 : for (auto iter = (mManagedPParentToChildStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
1189 0 : DeallocPParentToChildStreamChild(((iter).Get())->GetKey());
1190 : }
1191 0 : (mManagedPParentToChildStreamChild).Clear();
1192 : }
1193 : {
1194 : // Recursively deleting PIPCBlobInputStream kids
1195 0 : for (auto iter = (mManagedPIPCBlobInputStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
1196 0 : (((iter).Get())->GetKey())->DeallocSubtree();
1197 : }
1198 :
1199 0 : for (auto iter = (mManagedPIPCBlobInputStreamChild).Iter(); (!((iter).Done())); (iter).Next()) {
1200 0 : DeallocPIPCBlobInputStreamChild(((iter).Get())->GetKey());
1201 : }
1202 0 : (mManagedPIPCBlobInputStreamChild).Clear();
1203 : }
1204 0 : }
1205 :
1206 0 : auto PContentBridgeChild::DeallocPContentBridgeChild() -> void
1207 : {
1208 0 : }
1209 :
1210 0 : auto PContentBridgeChild::Write(
1211 : const nsTArray<InputStreamParams>& v__,
1212 : Message* msg__) -> void
1213 : {
1214 0 : uint32_t length = (v__).Length();
1215 0 : Write(length, msg__);
1216 : // Sentinel = ('length', 'InputStreamParams[]')
1217 0 : (msg__)->WriteSentinel(348334258);
1218 :
1219 0 : for (auto& elem : v__) {
1220 0 : Write(elem, msg__);
1221 : // Sentinel = 'InputStreamParams[]'
1222 0 : (msg__)->WriteSentinel(2927715197);
1223 : }
1224 0 : }
1225 :
1226 0 : auto PContentBridgeChild::Read(
1227 : nsTArray<InputStreamParams>* v__,
1228 : const Message* msg__,
1229 : PickleIterator* iter__) -> bool
1230 : {
1231 0 : nsTArray<InputStreamParams> fa;
1232 : uint32_t length;
1233 0 : if ((!(Read((&(length)), msg__, iter__)))) {
1234 0 : mozilla::ipc::ArrayLengthReadError("InputStreamParams[]");
1235 0 : return false;
1236 : }
1237 : // Sentinel = ('length', 'InputStreamParams[]')
1238 0 : if ((!((msg__)->ReadSentinel(iter__, 348334258)))) {
1239 0 : mozilla::ipc::SentinelReadError("InputStreamParams[]");
1240 0 : return false;
1241 : }
1242 :
1243 0 : InputStreamParams* elems = (fa).AppendElements(length);
1244 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
1245 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
1246 0 : FatalError("Error deserializing 'InputStreamParams[i]'");
1247 0 : return false;
1248 : }
1249 : // Sentinel = 'InputStreamParams[]'
1250 0 : if ((!((msg__)->ReadSentinel(iter__, 2927715197)))) {
1251 0 : mozilla::ipc::SentinelReadError("Error deserializing 'InputStreamParams[i]'");
1252 0 : return false;
1253 : }
1254 : }
1255 0 : (v__)->SwapElements(fa);
1256 0 : return true;
1257 : }
1258 :
1259 0 : auto PContentBridgeChild::Write(
1260 : const nsTArray<FileDescriptor>& v__,
1261 : Message* msg__) -> void
1262 : {
1263 0 : uint32_t length = (v__).Length();
1264 0 : Write(length, msg__);
1265 : // Sentinel = ('length', 'FileDescriptor[]')
1266 0 : (msg__)->WriteSentinel(1697726450);
1267 :
1268 0 : for (auto& elem : v__) {
1269 0 : Write(elem, msg__);
1270 : // Sentinel = 'FileDescriptor[]'
1271 0 : (msg__)->WriteSentinel(1630221245);
1272 : }
1273 0 : }
1274 :
1275 0 : auto PContentBridgeChild::Read(
1276 : nsTArray<FileDescriptor>* v__,
1277 : const Message* msg__,
1278 : PickleIterator* iter__) -> bool
1279 : {
1280 0 : nsTArray<FileDescriptor> fa;
1281 : uint32_t length;
1282 0 : if ((!(Read((&(length)), msg__, iter__)))) {
1283 0 : mozilla::ipc::ArrayLengthReadError("FileDescriptor[]");
1284 0 : return false;
1285 : }
1286 : // Sentinel = ('length', 'FileDescriptor[]')
1287 0 : if ((!((msg__)->ReadSentinel(iter__, 1697726450)))) {
1288 0 : mozilla::ipc::SentinelReadError("FileDescriptor[]");
1289 0 : return false;
1290 : }
1291 :
1292 0 : FileDescriptor* elems = (fa).AppendElements(length);
1293 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
1294 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
1295 0 : FatalError("Error deserializing 'FileDescriptor[i]'");
1296 0 : return false;
1297 : }
1298 : // Sentinel = 'FileDescriptor[]'
1299 0 : if ((!((msg__)->ReadSentinel(iter__, 1630221245)))) {
1300 0 : mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor[i]'");
1301 0 : return false;
1302 : }
1303 : }
1304 0 : (v__)->SwapElements(fa);
1305 0 : return true;
1306 : }
1307 :
1308 0 : auto PContentBridgeChild::Write(
1309 : const nsTArray<MessagePortIdentifier>& v__,
1310 : Message* msg__) -> void
1311 : {
1312 0 : uint32_t length = (v__).Length();
1313 0 : Write(length, msg__);
1314 : // Sentinel = ('length', 'MessagePortIdentifier[]')
1315 0 : (msg__)->WriteSentinel(680130807);
1316 :
1317 0 : for (auto& elem : v__) {
1318 0 : Write(elem, msg__);
1319 : // Sentinel = 'MessagePortIdentifier[]'
1320 0 : (msg__)->WriteSentinel(1200404786);
1321 : }
1322 0 : }
1323 :
1324 0 : auto PContentBridgeChild::Read(
1325 : nsTArray<MessagePortIdentifier>* v__,
1326 : const Message* msg__,
1327 : PickleIterator* iter__) -> bool
1328 : {
1329 0 : nsTArray<MessagePortIdentifier> fa;
1330 : uint32_t length;
1331 0 : if ((!(Read((&(length)), msg__, iter__)))) {
1332 0 : mozilla::ipc::ArrayLengthReadError("MessagePortIdentifier[]");
1333 0 : return false;
1334 : }
1335 : // Sentinel = ('length', 'MessagePortIdentifier[]')
1336 0 : if ((!((msg__)->ReadSentinel(iter__, 680130807)))) {
1337 0 : mozilla::ipc::SentinelReadError("MessagePortIdentifier[]");
1338 0 : return false;
1339 : }
1340 :
1341 0 : MessagePortIdentifier* elems = (fa).AppendElements(length);
1342 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
1343 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
1344 0 : FatalError("Error deserializing 'MessagePortIdentifier[i]'");
1345 0 : return false;
1346 : }
1347 : // Sentinel = 'MessagePortIdentifier[]'
1348 0 : if ((!((msg__)->ReadSentinel(iter__, 1200404786)))) {
1349 0 : mozilla::ipc::SentinelReadError("Error deserializing 'MessagePortIdentifier[i]'");
1350 0 : return false;
1351 : }
1352 : }
1353 0 : (v__)->SwapElements(fa);
1354 0 : return true;
1355 : }
1356 :
1357 0 : auto PContentBridgeChild::Write(
1358 : const UnsafeIPCTabContext& v__,
1359 : Message* msg__) -> void
1360 : {
1361 0 : }
1362 :
1363 0 : auto PContentBridgeChild::Read(
1364 : UnsafeIPCTabContext* v__,
1365 : const Message* msg__,
1366 : PickleIterator* iter__) -> bool
1367 : {
1368 0 : return true;
1369 : }
1370 :
1371 0 : auto PContentBridgeChild::Write(
1372 : const RemoteObject& v__,
1373 : Message* msg__) -> void
1374 : {
1375 0 : Write((v__).serializedId(), msg__);
1376 : // Sentinel = 'serializedId'
1377 0 : (msg__)->WriteSentinel(517551973);
1378 0 : Write((v__).isCallable(), msg__);
1379 : // Sentinel = 'isCallable'
1380 0 : (msg__)->WriteSentinel(581027930);
1381 0 : Write((v__).isConstructor(), msg__);
1382 : // Sentinel = 'isConstructor'
1383 0 : (msg__)->WriteSentinel(2453797865);
1384 0 : Write((v__).isDOMObject(), msg__);
1385 : // Sentinel = 'isDOMObject'
1386 0 : (msg__)->WriteSentinel(4083735162);
1387 0 : Write((v__).objectTag(), msg__);
1388 : // Sentinel = 'objectTag'
1389 0 : (msg__)->WriteSentinel(4009834374);
1390 0 : }
1391 :
1392 0 : auto PContentBridgeChild::Read(
1393 : RemoteObject* v__,
1394 : const Message* msg__,
1395 : PickleIterator* iter__) -> bool
1396 : {
1397 0 : if ((!(Read((&((v__)->serializedId())), msg__, iter__)))) {
1398 0 : FatalError("Error deserializing 'serializedId' (uint64_t) member of 'RemoteObject'");
1399 0 : return false;
1400 : }
1401 : // Sentinel = 'serializedId'
1402 0 : if ((!((msg__)->ReadSentinel(iter__, 517551973)))) {
1403 0 : mozilla::ipc::SentinelReadError("Error deserializing 'serializedId' (uint64_t) member of 'RemoteObject'");
1404 0 : return false;
1405 : }
1406 0 : if ((!(Read((&((v__)->isCallable())), msg__, iter__)))) {
1407 0 : FatalError("Error deserializing 'isCallable' (bool) member of 'RemoteObject'");
1408 0 : return false;
1409 : }
1410 : // Sentinel = 'isCallable'
1411 0 : if ((!((msg__)->ReadSentinel(iter__, 581027930)))) {
1412 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isCallable' (bool) member of 'RemoteObject'");
1413 0 : return false;
1414 : }
1415 0 : if ((!(Read((&((v__)->isConstructor())), msg__, iter__)))) {
1416 0 : FatalError("Error deserializing 'isConstructor' (bool) member of 'RemoteObject'");
1417 0 : return false;
1418 : }
1419 : // Sentinel = 'isConstructor'
1420 0 : if ((!((msg__)->ReadSentinel(iter__, 2453797865)))) {
1421 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isConstructor' (bool) member of 'RemoteObject'");
1422 0 : return false;
1423 : }
1424 0 : if ((!(Read((&((v__)->isDOMObject())), msg__, iter__)))) {
1425 0 : FatalError("Error deserializing 'isDOMObject' (bool) member of 'RemoteObject'");
1426 0 : return false;
1427 : }
1428 : // Sentinel = 'isDOMObject'
1429 0 : if ((!((msg__)->ReadSentinel(iter__, 4083735162)))) {
1430 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isDOMObject' (bool) member of 'RemoteObject'");
1431 0 : return false;
1432 : }
1433 0 : if ((!(Read((&((v__)->objectTag())), msg__, iter__)))) {
1434 0 : FatalError("Error deserializing 'objectTag' (nsCString) member of 'RemoteObject'");
1435 0 : return false;
1436 : }
1437 : // Sentinel = 'objectTag'
1438 0 : if ((!((msg__)->ReadSentinel(iter__, 4009834374)))) {
1439 0 : mozilla::ipc::SentinelReadError("Error deserializing 'objectTag' (nsCString) member of 'RemoteObject'");
1440 0 : return false;
1441 : }
1442 0 : return true;
1443 : }
1444 :
1445 0 : auto PContentBridgeChild::Write(
1446 : const WellKnownSymbol& v__,
1447 : Message* msg__) -> void
1448 : {
1449 0 : Write((v__).which(), msg__);
1450 : // Sentinel = 'which'
1451 0 : (msg__)->WriteSentinel(328170422);
1452 0 : }
1453 :
1454 0 : auto PContentBridgeChild::Read(
1455 : WellKnownSymbol* v__,
1456 : const Message* msg__,
1457 : PickleIterator* iter__) -> bool
1458 : {
1459 0 : if ((!(Read((&((v__)->which())), msg__, iter__)))) {
1460 0 : FatalError("Error deserializing 'which' (uint32_t) member of 'WellKnownSymbol'");
1461 0 : return false;
1462 : }
1463 : // Sentinel = 'which'
1464 0 : if ((!((msg__)->ReadSentinel(iter__, 328170422)))) {
1465 0 : mozilla::ipc::SentinelReadError("Error deserializing 'which' (uint32_t) member of 'WellKnownSymbol'");
1466 0 : return false;
1467 : }
1468 0 : return true;
1469 : }
1470 :
1471 0 : auto PContentBridgeChild::Write(
1472 : const OptionalInputStreamParams& v__,
1473 : Message* msg__) -> void
1474 : {
1475 : typedef OptionalInputStreamParams type__;
1476 0 : Write(int((v__).type()), msg__);
1477 : // Sentinel = 'OptionalInputStreamParams'
1478 0 : (msg__)->WriteSentinel(1355174443);
1479 :
1480 0 : switch ((v__).type()) {
1481 : case type__::Tvoid_t:
1482 : {
1483 0 : Write((v__).get_void_t(), msg__);
1484 : // Sentinel = 'Tvoid_t'
1485 0 : (msg__)->WriteSentinel(3041273328);
1486 0 : return;
1487 : }
1488 : case type__::TInputStreamParams:
1489 : {
1490 0 : Write((v__).get_InputStreamParams(), msg__);
1491 : // Sentinel = 'TInputStreamParams'
1492 0 : (msg__)->WriteSentinel(55652096);
1493 0 : return;
1494 : }
1495 : default:
1496 : {
1497 0 : FatalError("unknown union type");
1498 0 : return;
1499 : }
1500 : }
1501 : }
1502 :
1503 0 : auto PContentBridgeChild::Read(
1504 : OptionalInputStreamParams* v__,
1505 : const Message* msg__,
1506 : PickleIterator* iter__) -> bool
1507 : {
1508 : typedef OptionalInputStreamParams type__;
1509 : int type;
1510 0 : if ((!(Read((&(type)), msg__, iter__)))) {
1511 0 : mozilla::ipc::UnionTypeReadError("OptionalInputStreamParams");
1512 0 : return false;
1513 : }
1514 : // Sentinel = 'OptionalInputStreamParams'
1515 0 : if ((!((msg__)->ReadSentinel(iter__, 1355174443)))) {
1516 0 : mozilla::ipc::SentinelReadError("OptionalInputStreamParams");
1517 0 : return false;
1518 : }
1519 :
1520 0 : switch (type) {
1521 : case type__::Tvoid_t:
1522 : {
1523 : void_t tmp = void_t();
1524 0 : (*(v__)) = tmp;
1525 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
1526 0 : FatalError("Error deserializing Union type");
1527 0 : return false;
1528 : }
1529 : // Sentinel = 'Tvoid_t'
1530 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
1531 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1532 0 : return false;
1533 : }
1534 0 : return true;
1535 : }
1536 : case type__::TInputStreamParams:
1537 : {
1538 0 : InputStreamParams tmp = InputStreamParams();
1539 0 : (*(v__)) = tmp;
1540 0 : if ((!(Read((&((v__)->get_InputStreamParams())), msg__, iter__)))) {
1541 0 : FatalError("Error deserializing Union type");
1542 0 : return false;
1543 : }
1544 : // Sentinel = 'TInputStreamParams'
1545 0 : if ((!((msg__)->ReadSentinel(iter__, 55652096)))) {
1546 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1547 0 : return false;
1548 : }
1549 0 : return true;
1550 : }
1551 : default:
1552 : {
1553 0 : FatalError("unknown union type");
1554 0 : return false;
1555 : }
1556 : }
1557 : }
1558 :
1559 0 : auto PContentBridgeChild::Write(
1560 : const JSIID& v__,
1561 : Message* msg__) -> void
1562 : {
1563 0 : Write((v__).m0(), msg__);
1564 : // Sentinel = 'm0'
1565 0 : (msg__)->WriteSentinel(2819154229);
1566 0 : Write((v__).m1(), msg__);
1567 : // Sentinel = 'm1'
1568 0 : (msg__)->WriteSentinel(2819154228);
1569 0 : Write((v__).m2(), msg__);
1570 : // Sentinel = 'm2'
1571 0 : (msg__)->WriteSentinel(2819154231);
1572 0 : Write((v__).m3_0(), msg__);
1573 : // Sentinel = 'm3_0'
1574 0 : (msg__)->WriteSentinel(2771419453);
1575 0 : Write((v__).m3_1(), msg__);
1576 : // Sentinel = 'm3_1'
1577 0 : (msg__)->WriteSentinel(2771419452);
1578 0 : Write((v__).m3_2(), msg__);
1579 : // Sentinel = 'm3_2'
1580 0 : (msg__)->WriteSentinel(2771419455);
1581 0 : Write((v__).m3_3(), msg__);
1582 : // Sentinel = 'm3_3'
1583 0 : (msg__)->WriteSentinel(2771419454);
1584 0 : Write((v__).m3_4(), msg__);
1585 : // Sentinel = 'm3_4'
1586 0 : (msg__)->WriteSentinel(2771419449);
1587 0 : Write((v__).m3_5(), msg__);
1588 : // Sentinel = 'm3_5'
1589 0 : (msg__)->WriteSentinel(2771419448);
1590 0 : Write((v__).m3_6(), msg__);
1591 : // Sentinel = 'm3_6'
1592 0 : (msg__)->WriteSentinel(2771419451);
1593 0 : Write((v__).m3_7(), msg__);
1594 : // Sentinel = 'm3_7'
1595 0 : (msg__)->WriteSentinel(2771419450);
1596 0 : }
1597 :
1598 0 : auto PContentBridgeChild::Read(
1599 : JSIID* v__,
1600 : const Message* msg__,
1601 : PickleIterator* iter__) -> bool
1602 : {
1603 0 : if ((!(Read((&((v__)->m0())), msg__, iter__)))) {
1604 0 : FatalError("Error deserializing 'm0' (uint32_t) member of 'JSIID'");
1605 0 : return false;
1606 : }
1607 : // Sentinel = 'm0'
1608 0 : if ((!((msg__)->ReadSentinel(iter__, 2819154229)))) {
1609 0 : mozilla::ipc::SentinelReadError("Error deserializing 'm0' (uint32_t) member of 'JSIID'");
1610 0 : return false;
1611 : }
1612 0 : if ((!(Read((&((v__)->m1())), msg__, iter__)))) {
1613 0 : FatalError("Error deserializing 'm1' (uint16_t) member of 'JSIID'");
1614 0 : return false;
1615 : }
1616 : // Sentinel = 'm1'
1617 0 : if ((!((msg__)->ReadSentinel(iter__, 2819154228)))) {
1618 0 : mozilla::ipc::SentinelReadError("Error deserializing 'm1' (uint16_t) member of 'JSIID'");
1619 0 : return false;
1620 : }
1621 0 : if ((!(Read((&((v__)->m2())), msg__, iter__)))) {
1622 0 : FatalError("Error deserializing 'm2' (uint16_t) member of 'JSIID'");
1623 0 : return false;
1624 : }
1625 : // Sentinel = 'm2'
1626 0 : if ((!((msg__)->ReadSentinel(iter__, 2819154231)))) {
1627 0 : mozilla::ipc::SentinelReadError("Error deserializing 'm2' (uint16_t) member of 'JSIID'");
1628 0 : return false;
1629 : }
1630 0 : if ((!(Read((&((v__)->m3_0())), msg__, iter__)))) {
1631 0 : FatalError("Error deserializing 'm3_0' (uint8_t) member of 'JSIID'");
1632 0 : return false;
1633 : }
1634 : // Sentinel = 'm3_0'
1635 0 : if ((!((msg__)->ReadSentinel(iter__, 2771419453)))) {
1636 0 : mozilla::ipc::SentinelReadError("Error deserializing 'm3_0' (uint8_t) member of 'JSIID'");
1637 0 : return false;
1638 : }
1639 0 : if ((!(Read((&((v__)->m3_1())), msg__, iter__)))) {
1640 0 : FatalError("Error deserializing 'm3_1' (uint8_t) member of 'JSIID'");
1641 0 : return false;
1642 : }
1643 : // Sentinel = 'm3_1'
1644 0 : if ((!((msg__)->ReadSentinel(iter__, 2771419452)))) {
1645 0 : mozilla::ipc::SentinelReadError("Error deserializing 'm3_1' (uint8_t) member of 'JSIID'");
1646 0 : return false;
1647 : }
1648 0 : if ((!(Read((&((v__)->m3_2())), msg__, iter__)))) {
1649 0 : FatalError("Error deserializing 'm3_2' (uint8_t) member of 'JSIID'");
1650 0 : return false;
1651 : }
1652 : // Sentinel = 'm3_2'
1653 0 : if ((!((msg__)->ReadSentinel(iter__, 2771419455)))) {
1654 0 : mozilla::ipc::SentinelReadError("Error deserializing 'm3_2' (uint8_t) member of 'JSIID'");
1655 0 : return false;
1656 : }
1657 0 : if ((!(Read((&((v__)->m3_3())), msg__, iter__)))) {
1658 0 : FatalError("Error deserializing 'm3_3' (uint8_t) member of 'JSIID'");
1659 0 : return false;
1660 : }
1661 : // Sentinel = 'm3_3'
1662 0 : if ((!((msg__)->ReadSentinel(iter__, 2771419454)))) {
1663 0 : mozilla::ipc::SentinelReadError("Error deserializing 'm3_3' (uint8_t) member of 'JSIID'");
1664 0 : return false;
1665 : }
1666 0 : if ((!(Read((&((v__)->m3_4())), msg__, iter__)))) {
1667 0 : FatalError("Error deserializing 'm3_4' (uint8_t) member of 'JSIID'");
1668 0 : return false;
1669 : }
1670 : // Sentinel = 'm3_4'
1671 0 : if ((!((msg__)->ReadSentinel(iter__, 2771419449)))) {
1672 0 : mozilla::ipc::SentinelReadError("Error deserializing 'm3_4' (uint8_t) member of 'JSIID'");
1673 0 : return false;
1674 : }
1675 0 : if ((!(Read((&((v__)->m3_5())), msg__, iter__)))) {
1676 0 : FatalError("Error deserializing 'm3_5' (uint8_t) member of 'JSIID'");
1677 0 : return false;
1678 : }
1679 : // Sentinel = 'm3_5'
1680 0 : if ((!((msg__)->ReadSentinel(iter__, 2771419448)))) {
1681 0 : mozilla::ipc::SentinelReadError("Error deserializing 'm3_5' (uint8_t) member of 'JSIID'");
1682 0 : return false;
1683 : }
1684 0 : if ((!(Read((&((v__)->m3_6())), msg__, iter__)))) {
1685 0 : FatalError("Error deserializing 'm3_6' (uint8_t) member of 'JSIID'");
1686 0 : return false;
1687 : }
1688 : // Sentinel = 'm3_6'
1689 0 : if ((!((msg__)->ReadSentinel(iter__, 2771419451)))) {
1690 0 : mozilla::ipc::SentinelReadError("Error deserializing 'm3_6' (uint8_t) member of 'JSIID'");
1691 0 : return false;
1692 : }
1693 0 : if ((!(Read((&((v__)->m3_7())), msg__, iter__)))) {
1694 0 : FatalError("Error deserializing 'm3_7' (uint8_t) member of 'JSIID'");
1695 0 : return false;
1696 : }
1697 : // Sentinel = 'm3_7'
1698 0 : if ((!((msg__)->ReadSentinel(iter__, 2771419450)))) {
1699 0 : mozilla::ipc::SentinelReadError("Error deserializing 'm3_7' (uint8_t) member of 'JSIID'");
1700 0 : return false;
1701 : }
1702 0 : return true;
1703 : }
1704 :
1705 0 : auto PContentBridgeChild::Write(
1706 : const JSVariant& v__,
1707 : Message* msg__) -> void
1708 : {
1709 : typedef JSVariant type__;
1710 0 : Write(int((v__).type()), msg__);
1711 : // Sentinel = 'JSVariant'
1712 0 : (msg__)->WriteSentinel(4205756945);
1713 :
1714 0 : switch ((v__).type()) {
1715 : case type__::TUndefinedVariant:
1716 : {
1717 0 : Write((v__).get_UndefinedVariant(), msg__);
1718 : // Sentinel = 'TUndefinedVariant'
1719 0 : (msg__)->WriteSentinel(309349602);
1720 0 : return;
1721 : }
1722 : case type__::TNullVariant:
1723 : {
1724 0 : Write((v__).get_NullVariant(), msg__);
1725 : // Sentinel = 'TNullVariant'
1726 0 : (msg__)->WriteSentinel(3606183426);
1727 0 : return;
1728 : }
1729 : case type__::TObjectVariant:
1730 : {
1731 0 : Write((v__).get_ObjectVariant(), msg__);
1732 : // Sentinel = 'TObjectVariant'
1733 0 : (msg__)->WriteSentinel(78811130);
1734 0 : return;
1735 : }
1736 : case type__::TSymbolVariant:
1737 : {
1738 0 : Write((v__).get_SymbolVariant(), msg__);
1739 : // Sentinel = 'TSymbolVariant'
1740 0 : (msg__)->WriteSentinel(549729725);
1741 0 : return;
1742 : }
1743 : case type__::TnsString:
1744 : {
1745 0 : Write((v__).get_nsString(), msg__);
1746 : // Sentinel = 'TnsString'
1747 0 : (msg__)->WriteSentinel(2161603959);
1748 0 : return;
1749 : }
1750 : case type__::Tdouble:
1751 : {
1752 0 : Write((v__).get_double(), msg__);
1753 : // Sentinel = 'Tdouble'
1754 0 : (msg__)->WriteSentinel(3456933244);
1755 0 : return;
1756 : }
1757 : case type__::Tbool:
1758 : {
1759 0 : Write((v__).get_bool(), msg__);
1760 : // Sentinel = 'Tbool'
1761 0 : (msg__)->WriteSentinel(1958350201);
1762 0 : return;
1763 : }
1764 : case type__::TJSIID:
1765 : {
1766 0 : Write((v__).get_JSIID(), msg__);
1767 : // Sentinel = 'TJSIID'
1768 0 : (msg__)->WriteSentinel(3312553047);
1769 0 : return;
1770 : }
1771 : default:
1772 : {
1773 0 : FatalError("unknown union type");
1774 0 : return;
1775 : }
1776 : }
1777 : }
1778 :
1779 0 : auto PContentBridgeChild::Read(
1780 : JSVariant* v__,
1781 : const Message* msg__,
1782 : PickleIterator* iter__) -> bool
1783 : {
1784 : typedef JSVariant type__;
1785 : int type;
1786 0 : if ((!(Read((&(type)), msg__, iter__)))) {
1787 0 : mozilla::ipc::UnionTypeReadError("JSVariant");
1788 0 : return false;
1789 : }
1790 : // Sentinel = 'JSVariant'
1791 0 : if ((!((msg__)->ReadSentinel(iter__, 4205756945)))) {
1792 0 : mozilla::ipc::SentinelReadError("JSVariant");
1793 0 : return false;
1794 : }
1795 :
1796 0 : switch (type) {
1797 : case type__::TUndefinedVariant:
1798 : {
1799 0 : UndefinedVariant tmp = UndefinedVariant();
1800 0 : (*(v__)) = tmp;
1801 0 : if ((!(Read((&((v__)->get_UndefinedVariant())), msg__, iter__)))) {
1802 0 : FatalError("Error deserializing Union type");
1803 0 : return false;
1804 : }
1805 : // Sentinel = 'TUndefinedVariant'
1806 0 : if ((!((msg__)->ReadSentinel(iter__, 309349602)))) {
1807 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1808 0 : return false;
1809 : }
1810 0 : return true;
1811 : }
1812 : case type__::TNullVariant:
1813 : {
1814 0 : NullVariant tmp = NullVariant();
1815 0 : (*(v__)) = tmp;
1816 0 : if ((!(Read((&((v__)->get_NullVariant())), msg__, iter__)))) {
1817 0 : FatalError("Error deserializing Union type");
1818 0 : return false;
1819 : }
1820 : // Sentinel = 'TNullVariant'
1821 0 : if ((!((msg__)->ReadSentinel(iter__, 3606183426)))) {
1822 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1823 0 : return false;
1824 : }
1825 0 : return true;
1826 : }
1827 : case type__::TObjectVariant:
1828 : {
1829 0 : ObjectVariant tmp = ObjectVariant();
1830 0 : (*(v__)) = tmp;
1831 0 : if ((!(Read((&((v__)->get_ObjectVariant())), msg__, iter__)))) {
1832 0 : FatalError("Error deserializing Union type");
1833 0 : return false;
1834 : }
1835 : // Sentinel = 'TObjectVariant'
1836 0 : if ((!((msg__)->ReadSentinel(iter__, 78811130)))) {
1837 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1838 0 : return false;
1839 : }
1840 0 : return true;
1841 : }
1842 : case type__::TSymbolVariant:
1843 : {
1844 0 : SymbolVariant tmp = SymbolVariant();
1845 0 : (*(v__)) = tmp;
1846 0 : if ((!(Read((&((v__)->get_SymbolVariant())), msg__, iter__)))) {
1847 0 : FatalError("Error deserializing Union type");
1848 0 : return false;
1849 : }
1850 : // Sentinel = 'TSymbolVariant'
1851 0 : if ((!((msg__)->ReadSentinel(iter__, 549729725)))) {
1852 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1853 0 : return false;
1854 : }
1855 0 : return true;
1856 : }
1857 : case type__::TnsString:
1858 : {
1859 0 : nsString tmp = nsString();
1860 0 : (*(v__)) = tmp;
1861 0 : if ((!(Read((&((v__)->get_nsString())), msg__, iter__)))) {
1862 0 : FatalError("Error deserializing Union type");
1863 0 : return false;
1864 : }
1865 : // Sentinel = 'TnsString'
1866 0 : if ((!((msg__)->ReadSentinel(iter__, 2161603959)))) {
1867 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1868 0 : return false;
1869 : }
1870 0 : return true;
1871 : }
1872 : case type__::Tdouble:
1873 : {
1874 0 : double tmp = double();
1875 0 : (*(v__)) = tmp;
1876 0 : if ((!(Read((&((v__)->get_double())), msg__, iter__)))) {
1877 0 : FatalError("Error deserializing Union type");
1878 0 : return false;
1879 : }
1880 : // Sentinel = 'Tdouble'
1881 0 : if ((!((msg__)->ReadSentinel(iter__, 3456933244)))) {
1882 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1883 0 : return false;
1884 : }
1885 0 : return true;
1886 : }
1887 : case type__::Tbool:
1888 : {
1889 0 : bool tmp = bool();
1890 0 : (*(v__)) = tmp;
1891 0 : if ((!(Read((&((v__)->get_bool())), msg__, iter__)))) {
1892 0 : FatalError("Error deserializing Union type");
1893 0 : return false;
1894 : }
1895 : // Sentinel = 'Tbool'
1896 0 : if ((!((msg__)->ReadSentinel(iter__, 1958350201)))) {
1897 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1898 0 : return false;
1899 : }
1900 0 : return true;
1901 : }
1902 : case type__::TJSIID:
1903 : {
1904 0 : JSIID tmp = JSIID();
1905 0 : (*(v__)) = tmp;
1906 0 : if ((!(Read((&((v__)->get_JSIID())), msg__, iter__)))) {
1907 0 : FatalError("Error deserializing Union type");
1908 0 : return false;
1909 : }
1910 : // Sentinel = 'TJSIID'
1911 0 : if ((!((msg__)->ReadSentinel(iter__, 3312553047)))) {
1912 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1913 0 : return false;
1914 : }
1915 0 : return true;
1916 : }
1917 : default:
1918 : {
1919 0 : FatalError("unknown union type");
1920 0 : return false;
1921 : }
1922 : }
1923 : }
1924 :
1925 0 : auto PContentBridgeChild::Write(
1926 : const IPCRemoteStream& v__,
1927 : Message* msg__) -> void
1928 : {
1929 0 : Write((v__).delayedStart(), msg__);
1930 : // Sentinel = 'delayedStart'
1931 0 : (msg__)->WriteSentinel(1491822294);
1932 0 : Write((v__).stream(), msg__);
1933 : // Sentinel = 'stream'
1934 0 : (msg__)->WriteSentinel(4152748422);
1935 0 : }
1936 :
1937 0 : auto PContentBridgeChild::Read(
1938 : IPCRemoteStream* v__,
1939 : const Message* msg__,
1940 : PickleIterator* iter__) -> bool
1941 : {
1942 0 : if ((!(Read((&((v__)->delayedStart())), msg__, iter__)))) {
1943 0 : FatalError("Error deserializing 'delayedStart' (bool) member of 'IPCRemoteStream'");
1944 0 : return false;
1945 : }
1946 : // Sentinel = 'delayedStart'
1947 0 : if ((!((msg__)->ReadSentinel(iter__, 1491822294)))) {
1948 0 : mozilla::ipc::SentinelReadError("Error deserializing 'delayedStart' (bool) member of 'IPCRemoteStream'");
1949 0 : return false;
1950 : }
1951 0 : if ((!(Read((&((v__)->stream())), msg__, iter__)))) {
1952 0 : FatalError("Error deserializing 'stream' (IPCRemoteStreamType) member of 'IPCRemoteStream'");
1953 0 : return false;
1954 : }
1955 : // Sentinel = 'stream'
1956 0 : if ((!((msg__)->ReadSentinel(iter__, 4152748422)))) {
1957 0 : mozilla::ipc::SentinelReadError("Error deserializing 'stream' (IPCRemoteStreamType) member of 'IPCRemoteStream'");
1958 0 : return false;
1959 : }
1960 0 : return true;
1961 : }
1962 :
1963 0 : auto PContentBridgeChild::Write(
1964 : const FileInputStreamParams& v__,
1965 : Message* msg__) -> void
1966 : {
1967 0 : Write((v__).fileDescriptorIndex(), msg__);
1968 : // Sentinel = 'fileDescriptorIndex'
1969 0 : (msg__)->WriteSentinel(587329112);
1970 0 : Write((v__).behaviorFlags(), msg__);
1971 : // Sentinel = 'behaviorFlags'
1972 0 : (msg__)->WriteSentinel(2404401962);
1973 0 : Write((v__).ioFlags(), msg__);
1974 : // Sentinel = 'ioFlags'
1975 0 : (msg__)->WriteSentinel(1483009730);
1976 0 : }
1977 :
1978 0 : auto PContentBridgeChild::Read(
1979 : FileInputStreamParams* v__,
1980 : const Message* msg__,
1981 : PickleIterator* iter__) -> bool
1982 : {
1983 0 : if ((!(Read((&((v__)->fileDescriptorIndex())), msg__, iter__)))) {
1984 0 : FatalError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'FileInputStreamParams'");
1985 0 : return false;
1986 : }
1987 : // Sentinel = 'fileDescriptorIndex'
1988 0 : if ((!((msg__)->ReadSentinel(iter__, 587329112)))) {
1989 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'FileInputStreamParams'");
1990 0 : return false;
1991 : }
1992 0 : if ((!(Read((&((v__)->behaviorFlags())), msg__, iter__)))) {
1993 0 : FatalError("Error deserializing 'behaviorFlags' (int32_t) member of 'FileInputStreamParams'");
1994 0 : return false;
1995 : }
1996 : // Sentinel = 'behaviorFlags'
1997 0 : if ((!((msg__)->ReadSentinel(iter__, 2404401962)))) {
1998 0 : mozilla::ipc::SentinelReadError("Error deserializing 'behaviorFlags' (int32_t) member of 'FileInputStreamParams'");
1999 0 : return false;
2000 : }
2001 0 : if ((!(Read((&((v__)->ioFlags())), msg__, iter__)))) {
2002 0 : FatalError("Error deserializing 'ioFlags' (int32_t) member of 'FileInputStreamParams'");
2003 0 : return false;
2004 : }
2005 : // Sentinel = 'ioFlags'
2006 0 : if ((!((msg__)->ReadSentinel(iter__, 1483009730)))) {
2007 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ioFlags' (int32_t) member of 'FileInputStreamParams'");
2008 0 : return false;
2009 : }
2010 0 : return true;
2011 : }
2012 :
2013 0 : auto PContentBridgeChild::Write(
2014 : const RegisteredSymbol& v__,
2015 : Message* msg__) -> void
2016 : {
2017 0 : Write((v__).key(), msg__);
2018 : // Sentinel = 'key'
2019 0 : (msg__)->WriteSentinel(35142870);
2020 0 : }
2021 :
2022 0 : auto PContentBridgeChild::Read(
2023 : RegisteredSymbol* v__,
2024 : const Message* msg__,
2025 : PickleIterator* iter__) -> bool
2026 : {
2027 0 : if ((!(Read((&((v__)->key())), msg__, iter__)))) {
2028 0 : FatalError("Error deserializing 'key' (nsString) member of 'RegisteredSymbol'");
2029 0 : return false;
2030 : }
2031 : // Sentinel = 'key'
2032 0 : if ((!((msg__)->ReadSentinel(iter__, 35142870)))) {
2033 0 : mozilla::ipc::SentinelReadError("Error deserializing 'key' (nsString) member of 'RegisteredSymbol'");
2034 0 : return false;
2035 : }
2036 0 : return true;
2037 : }
2038 :
2039 0 : auto PContentBridgeChild::Write(
2040 : const IPCBlobInputStreamParams& v__,
2041 : Message* msg__) -> void
2042 : {
2043 0 : Write((v__).id(), msg__);
2044 : // Sentinel = 'id'
2045 0 : (msg__)->WriteSentinel(2794505629);
2046 0 : }
2047 :
2048 0 : auto PContentBridgeChild::Read(
2049 : IPCBlobInputStreamParams* v__,
2050 : const Message* msg__,
2051 : PickleIterator* iter__) -> bool
2052 : {
2053 0 : if ((!(Read((&((v__)->id())), msg__, iter__)))) {
2054 0 : FatalError("Error deserializing 'id' (nsID) member of 'IPCBlobInputStreamParams'");
2055 0 : return false;
2056 : }
2057 : // Sentinel = 'id'
2058 0 : if ((!((msg__)->ReadSentinel(iter__, 2794505629)))) {
2059 0 : mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsID) member of 'IPCBlobInputStreamParams'");
2060 0 : return false;
2061 : }
2062 0 : return true;
2063 : }
2064 :
2065 0 : auto PContentBridgeChild::Write(
2066 : const IPCFile& v__,
2067 : Message* msg__) -> void
2068 : {
2069 0 : Write((v__).name(), msg__);
2070 : // Sentinel = 'name'
2071 0 : (msg__)->WriteSentinel(15034981);
2072 0 : Write((v__).lastModified(), msg__);
2073 : // Sentinel = 'lastModified'
2074 0 : (msg__)->WriteSentinel(3456113257);
2075 0 : Write((v__).DOMPath(), msg__);
2076 : // Sentinel = 'DOMPath'
2077 0 : (msg__)->WriteSentinel(1724352494);
2078 0 : Write((v__).fullPath(), msg__);
2079 : // Sentinel = 'fullPath'
2080 0 : (msg__)->WriteSentinel(385652698);
2081 0 : Write((v__).isDirectory(), msg__);
2082 : // Sentinel = 'isDirectory'
2083 0 : (msg__)->WriteSentinel(2309743506);
2084 0 : }
2085 :
2086 0 : auto PContentBridgeChild::Read(
2087 : IPCFile* v__,
2088 : const Message* msg__,
2089 : PickleIterator* iter__) -> bool
2090 : {
2091 0 : if ((!(Read((&((v__)->name())), msg__, iter__)))) {
2092 0 : FatalError("Error deserializing 'name' (nsString) member of 'IPCFile'");
2093 0 : return false;
2094 : }
2095 : // Sentinel = 'name'
2096 0 : if ((!((msg__)->ReadSentinel(iter__, 15034981)))) {
2097 0 : mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'IPCFile'");
2098 0 : return false;
2099 : }
2100 0 : if ((!(Read((&((v__)->lastModified())), msg__, iter__)))) {
2101 0 : FatalError("Error deserializing 'lastModified' (int64_t) member of 'IPCFile'");
2102 0 : return false;
2103 : }
2104 : // Sentinel = 'lastModified'
2105 0 : if ((!((msg__)->ReadSentinel(iter__, 3456113257)))) {
2106 0 : mozilla::ipc::SentinelReadError("Error deserializing 'lastModified' (int64_t) member of 'IPCFile'");
2107 0 : return false;
2108 : }
2109 0 : if ((!(Read((&((v__)->DOMPath())), msg__, iter__)))) {
2110 0 : FatalError("Error deserializing 'DOMPath' (nsString) member of 'IPCFile'");
2111 0 : return false;
2112 : }
2113 : // Sentinel = 'DOMPath'
2114 0 : if ((!((msg__)->ReadSentinel(iter__, 1724352494)))) {
2115 0 : mozilla::ipc::SentinelReadError("Error deserializing 'DOMPath' (nsString) member of 'IPCFile'");
2116 0 : return false;
2117 : }
2118 0 : if ((!(Read((&((v__)->fullPath())), msg__, iter__)))) {
2119 0 : FatalError("Error deserializing 'fullPath' (nsString) member of 'IPCFile'");
2120 0 : return false;
2121 : }
2122 : // Sentinel = 'fullPath'
2123 0 : if ((!((msg__)->ReadSentinel(iter__, 385652698)))) {
2124 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fullPath' (nsString) member of 'IPCFile'");
2125 0 : return false;
2126 : }
2127 0 : if ((!(Read((&((v__)->isDirectory())), msg__, iter__)))) {
2128 0 : FatalError("Error deserializing 'isDirectory' (bool) member of 'IPCFile'");
2129 0 : return false;
2130 : }
2131 : // Sentinel = 'isDirectory'
2132 0 : if ((!((msg__)->ReadSentinel(iter__, 2309743506)))) {
2133 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isDirectory' (bool) member of 'IPCFile'");
2134 0 : return false;
2135 : }
2136 0 : return true;
2137 : }
2138 :
2139 0 : auto PContentBridgeChild::Write(
2140 : const IPCFileUnion& v__,
2141 : Message* msg__) -> void
2142 : {
2143 : typedef IPCFileUnion type__;
2144 0 : Write(int((v__).type()), msg__);
2145 : // Sentinel = 'IPCFileUnion'
2146 0 : (msg__)->WriteSentinel(1913022529);
2147 :
2148 0 : switch ((v__).type()) {
2149 : case type__::Tvoid_t:
2150 : {
2151 0 : Write((v__).get_void_t(), msg__);
2152 : // Sentinel = 'Tvoid_t'
2153 0 : (msg__)->WriteSentinel(3041273328);
2154 0 : return;
2155 : }
2156 : case type__::TIPCFile:
2157 : {
2158 0 : Write((v__).get_IPCFile(), msg__);
2159 : // Sentinel = 'TIPCFile'
2160 0 : (msg__)->WriteSentinel(3562676876);
2161 0 : return;
2162 : }
2163 : default:
2164 : {
2165 0 : FatalError("unknown union type");
2166 0 : return;
2167 : }
2168 : }
2169 : }
2170 :
2171 0 : auto PContentBridgeChild::Read(
2172 : IPCFileUnion* v__,
2173 : const Message* msg__,
2174 : PickleIterator* iter__) -> bool
2175 : {
2176 : typedef IPCFileUnion type__;
2177 : int type;
2178 0 : if ((!(Read((&(type)), msg__, iter__)))) {
2179 0 : mozilla::ipc::UnionTypeReadError("IPCFileUnion");
2180 0 : return false;
2181 : }
2182 : // Sentinel = 'IPCFileUnion'
2183 0 : if ((!((msg__)->ReadSentinel(iter__, 1913022529)))) {
2184 0 : mozilla::ipc::SentinelReadError("IPCFileUnion");
2185 0 : return false;
2186 : }
2187 :
2188 0 : switch (type) {
2189 : case type__::Tvoid_t:
2190 : {
2191 : void_t tmp = void_t();
2192 0 : (*(v__)) = tmp;
2193 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
2194 0 : FatalError("Error deserializing Union type");
2195 0 : return false;
2196 : }
2197 : // Sentinel = 'Tvoid_t'
2198 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
2199 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2200 0 : return false;
2201 : }
2202 0 : return true;
2203 : }
2204 : case type__::TIPCFile:
2205 : {
2206 0 : IPCFile tmp = IPCFile();
2207 0 : (*(v__)) = tmp;
2208 0 : if ((!(Read((&((v__)->get_IPCFile())), msg__, iter__)))) {
2209 0 : FatalError("Error deserializing Union type");
2210 0 : return false;
2211 : }
2212 : // Sentinel = 'TIPCFile'
2213 0 : if ((!((msg__)->ReadSentinel(iter__, 3562676876)))) {
2214 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2215 0 : return false;
2216 : }
2217 0 : return true;
2218 : }
2219 : default:
2220 : {
2221 0 : FatalError("unknown union type");
2222 0 : return false;
2223 : }
2224 : }
2225 : }
2226 :
2227 0 : auto PContentBridgeChild::Write(
2228 : const PBrowserOrId& v__,
2229 : Message* msg__) -> void
2230 : {
2231 : typedef PBrowserOrId type__;
2232 0 : Write(int((v__).type()), msg__);
2233 : // Sentinel = 'PBrowserOrId'
2234 0 : (msg__)->WriteSentinel(1715137324);
2235 :
2236 0 : switch ((v__).type()) {
2237 : case type__::TPBrowserParent:
2238 : {
2239 0 : FatalError("wrong side!");
2240 0 : return;
2241 : }
2242 : case type__::TPBrowserChild:
2243 : {
2244 0 : Write((v__).get_PBrowserChild(), msg__, true);
2245 : // Sentinel = 'TPBrowserChild'
2246 0 : (msg__)->WriteSentinel(2417584432);
2247 0 : return;
2248 : }
2249 : case type__::TTabId:
2250 : {
2251 0 : Write((v__).get_TabId(), msg__);
2252 : // Sentinel = 'TTabId'
2253 0 : (msg__)->WriteSentinel(1071104628);
2254 0 : return;
2255 : }
2256 : default:
2257 : {
2258 0 : FatalError("unknown union type");
2259 0 : return;
2260 : }
2261 : }
2262 : }
2263 :
2264 0 : auto PContentBridgeChild::Read(
2265 : PBrowserOrId* v__,
2266 : const Message* msg__,
2267 : PickleIterator* iter__) -> bool
2268 : {
2269 : typedef PBrowserOrId type__;
2270 : int type;
2271 0 : if ((!(Read((&(type)), msg__, iter__)))) {
2272 0 : mozilla::ipc::UnionTypeReadError("PBrowserOrId");
2273 0 : return false;
2274 : }
2275 : // Sentinel = 'PBrowserOrId'
2276 0 : if ((!((msg__)->ReadSentinel(iter__, 1715137324)))) {
2277 0 : mozilla::ipc::SentinelReadError("PBrowserOrId");
2278 0 : return false;
2279 : }
2280 :
2281 0 : switch (type) {
2282 : case type__::TPBrowserParent:
2283 : {
2284 0 : PBrowserChild* tmp = nullptr;
2285 0 : (*(v__)) = tmp;
2286 0 : if ((!(Read((&((v__)->get_PBrowserChild())), msg__, iter__, true)))) {
2287 0 : FatalError("Error deserializing Union type");
2288 0 : return false;
2289 : }
2290 : // Sentinel = 'TPBrowserParent'
2291 0 : if ((!((msg__)->ReadSentinel(iter__, 3996262243)))) {
2292 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2293 0 : return false;
2294 : }
2295 0 : return true;
2296 : }
2297 : case type__::TPBrowserChild:
2298 : {
2299 0 : return false;
2300 : }
2301 : case type__::TTabId:
2302 : {
2303 0 : TabId tmp = TabId();
2304 0 : (*(v__)) = tmp;
2305 0 : if ((!(Read((&((v__)->get_TabId())), msg__, iter__)))) {
2306 0 : FatalError("Error deserializing Union type");
2307 0 : return false;
2308 : }
2309 : // Sentinel = 'TTabId'
2310 0 : if ((!((msg__)->ReadSentinel(iter__, 1071104628)))) {
2311 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2312 0 : return false;
2313 : }
2314 0 : return true;
2315 : }
2316 : default:
2317 : {
2318 0 : FatalError("unknown union type");
2319 0 : return false;
2320 : }
2321 : }
2322 : }
2323 :
2324 0 : auto PContentBridgeChild::Write(
2325 : const FileDescriptor& v__,
2326 : Message* msg__) -> void
2327 : {
2328 0 : FileDescriptor::PickleType pfd = (v__).ShareTo(FileDescriptor::IPDLPrivate(), OtherPid());
2329 0 : IPC::WriteParam(msg__, pfd);
2330 0 : }
2331 :
2332 0 : auto PContentBridgeChild::Read(
2333 : FileDescriptor* v__,
2334 : const Message* msg__,
2335 : PickleIterator* iter__) -> bool
2336 : {
2337 0 : FileDescriptor::PickleType pfd;
2338 0 : if ((!(IPC::ReadParam(msg__, iter__, (&(pfd)))))) {
2339 0 : return false;
2340 : }
2341 :
2342 0 : FileDescriptor fd = FileDescriptor(FileDescriptor::IPDLPrivate(), pfd);
2343 0 : if ((!((fd).IsValid()))) {
2344 0 : mozilla::ipc::ProtocolErrorBreakpoint("[PContentBridgeChild] Received an invalid file descriptor!");
2345 : }
2346 :
2347 0 : (*(v__)) = fd;
2348 0 : return true;
2349 : }
2350 :
2351 0 : auto PContentBridgeChild::Write(
2352 : const MessagePortIdentifier& v__,
2353 : Message* msg__) -> void
2354 : {
2355 0 : Write((v__).uuid(), msg__);
2356 : // Sentinel = 'uuid'
2357 0 : (msg__)->WriteSentinel(1982267941);
2358 0 : Write((v__).destinationUuid(), msg__);
2359 : // Sentinel = 'destinationUuid'
2360 0 : (msg__)->WriteSentinel(372087918);
2361 0 : Write((v__).sequenceId(), msg__);
2362 : // Sentinel = 'sequenceId'
2363 0 : (msg__)->WriteSentinel(2743535618);
2364 0 : Write((v__).neutered(), msg__);
2365 : // Sentinel = 'neutered'
2366 0 : (msg__)->WriteSentinel(520678014);
2367 0 : }
2368 :
2369 0 : auto PContentBridgeChild::Read(
2370 : MessagePortIdentifier* v__,
2371 : const Message* msg__,
2372 : PickleIterator* iter__) -> bool
2373 : {
2374 0 : if ((!(Read((&((v__)->uuid())), msg__, iter__)))) {
2375 0 : FatalError("Error deserializing 'uuid' (nsID) member of 'MessagePortIdentifier'");
2376 0 : return false;
2377 : }
2378 : // Sentinel = 'uuid'
2379 0 : if ((!((msg__)->ReadSentinel(iter__, 1982267941)))) {
2380 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uuid' (nsID) member of 'MessagePortIdentifier'");
2381 0 : return false;
2382 : }
2383 0 : if ((!(Read((&((v__)->destinationUuid())), msg__, iter__)))) {
2384 0 : FatalError("Error deserializing 'destinationUuid' (nsID) member of 'MessagePortIdentifier'");
2385 0 : return false;
2386 : }
2387 : // Sentinel = 'destinationUuid'
2388 0 : if ((!((msg__)->ReadSentinel(iter__, 372087918)))) {
2389 0 : mozilla::ipc::SentinelReadError("Error deserializing 'destinationUuid' (nsID) member of 'MessagePortIdentifier'");
2390 0 : return false;
2391 : }
2392 0 : if ((!(Read((&((v__)->sequenceId())), msg__, iter__)))) {
2393 0 : FatalError("Error deserializing 'sequenceId' (uint32_t) member of 'MessagePortIdentifier'");
2394 0 : return false;
2395 : }
2396 : // Sentinel = 'sequenceId'
2397 0 : if ((!((msg__)->ReadSentinel(iter__, 2743535618)))) {
2398 0 : mozilla::ipc::SentinelReadError("Error deserializing 'sequenceId' (uint32_t) member of 'MessagePortIdentifier'");
2399 0 : return false;
2400 : }
2401 0 : if ((!(Read((&((v__)->neutered())), msg__, iter__)))) {
2402 0 : FatalError("Error deserializing 'neutered' (bool) member of 'MessagePortIdentifier'");
2403 0 : return false;
2404 : }
2405 : // Sentinel = 'neutered'
2406 0 : if ((!((msg__)->ReadSentinel(iter__, 520678014)))) {
2407 0 : mozilla::ipc::SentinelReadError("Error deserializing 'neutered' (bool) member of 'MessagePortIdentifier'");
2408 0 : return false;
2409 : }
2410 0 : return true;
2411 : }
2412 :
2413 0 : auto PContentBridgeChild::Write(
2414 : const InputStreamParamsWithFds& v__,
2415 : Message* msg__) -> void
2416 : {
2417 0 : Write((v__).stream(), msg__);
2418 : // Sentinel = 'stream'
2419 0 : (msg__)->WriteSentinel(4152748422);
2420 0 : Write((v__).optionalFds(), msg__);
2421 : // Sentinel = 'optionalFds'
2422 0 : (msg__)->WriteSentinel(1021803302);
2423 0 : }
2424 :
2425 0 : auto PContentBridgeChild::Read(
2426 : InputStreamParamsWithFds* v__,
2427 : const Message* msg__,
2428 : PickleIterator* iter__) -> bool
2429 : {
2430 0 : if ((!(Read((&((v__)->stream())), msg__, iter__)))) {
2431 0 : FatalError("Error deserializing 'stream' (InputStreamParams) member of 'InputStreamParamsWithFds'");
2432 0 : return false;
2433 : }
2434 : // Sentinel = 'stream'
2435 0 : if ((!((msg__)->ReadSentinel(iter__, 4152748422)))) {
2436 0 : mozilla::ipc::SentinelReadError("Error deserializing 'stream' (InputStreamParams) member of 'InputStreamParamsWithFds'");
2437 0 : return false;
2438 : }
2439 0 : if ((!(Read((&((v__)->optionalFds())), msg__, iter__)))) {
2440 0 : FatalError("Error deserializing 'optionalFds' (OptionalFileDescriptorSet) member of 'InputStreamParamsWithFds'");
2441 0 : return false;
2442 : }
2443 : // Sentinel = 'optionalFds'
2444 0 : if ((!((msg__)->ReadSentinel(iter__, 1021803302)))) {
2445 0 : mozilla::ipc::SentinelReadError("Error deserializing 'optionalFds' (OptionalFileDescriptorSet) member of 'InputStreamParamsWithFds'");
2446 0 : return false;
2447 : }
2448 0 : return true;
2449 : }
2450 :
2451 0 : auto PContentBridgeChild::Write(
2452 : const IPCBlobStream& v__,
2453 : Message* msg__) -> void
2454 : {
2455 : typedef IPCBlobStream type__;
2456 0 : Write(int((v__).type()), msg__);
2457 : // Sentinel = 'IPCBlobStream'
2458 0 : (msg__)->WriteSentinel(2926762354);
2459 :
2460 0 : switch ((v__).type()) {
2461 : case type__::TPIPCBlobInputStreamParent:
2462 : {
2463 0 : FatalError("wrong side!");
2464 0 : return;
2465 : }
2466 : case type__::TPIPCBlobInputStreamChild:
2467 : {
2468 0 : Write((v__).get_PIPCBlobInputStreamChild(), msg__, false);
2469 : // Sentinel = 'TPIPCBlobInputStreamChild'
2470 0 : (msg__)->WriteSentinel(3349556844);
2471 0 : return;
2472 : }
2473 : case type__::TIPCStream:
2474 : {
2475 0 : Write((v__).get_IPCStream(), msg__);
2476 : // Sentinel = 'TIPCStream'
2477 0 : (msg__)->WriteSentinel(40701900);
2478 0 : return;
2479 : }
2480 : default:
2481 : {
2482 0 : FatalError("unknown union type");
2483 0 : return;
2484 : }
2485 : }
2486 : }
2487 :
2488 0 : auto PContentBridgeChild::Read(
2489 : IPCBlobStream* v__,
2490 : const Message* msg__,
2491 : PickleIterator* iter__) -> bool
2492 : {
2493 : typedef IPCBlobStream type__;
2494 : int type;
2495 0 : if ((!(Read((&(type)), msg__, iter__)))) {
2496 0 : mozilla::ipc::UnionTypeReadError("IPCBlobStream");
2497 0 : return false;
2498 : }
2499 : // Sentinel = 'IPCBlobStream'
2500 0 : if ((!((msg__)->ReadSentinel(iter__, 2926762354)))) {
2501 0 : mozilla::ipc::SentinelReadError("IPCBlobStream");
2502 0 : return false;
2503 : }
2504 :
2505 0 : switch (type) {
2506 : case type__::TPIPCBlobInputStreamParent:
2507 : {
2508 0 : PIPCBlobInputStreamChild* tmp = nullptr;
2509 0 : (*(v__)) = tmp;
2510 0 : if ((!(Read((&((v__)->get_PIPCBlobInputStreamChild())), msg__, iter__, false)))) {
2511 0 : FatalError("Error deserializing Union type");
2512 0 : return false;
2513 : }
2514 : // Sentinel = 'TPIPCBlobInputStreamParent'
2515 0 : if ((!((msg__)->ReadSentinel(iter__, 2944059743)))) {
2516 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2517 0 : return false;
2518 : }
2519 0 : return true;
2520 : }
2521 : case type__::TPIPCBlobInputStreamChild:
2522 : {
2523 0 : return false;
2524 : }
2525 : case type__::TIPCStream:
2526 : {
2527 0 : IPCStream tmp = IPCStream();
2528 0 : (*(v__)) = tmp;
2529 0 : if ((!(Read((&((v__)->get_IPCStream())), msg__, iter__)))) {
2530 0 : FatalError("Error deserializing Union type");
2531 0 : return false;
2532 : }
2533 : // Sentinel = 'TIPCStream'
2534 0 : if ((!((msg__)->ReadSentinel(iter__, 40701900)))) {
2535 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2536 0 : return false;
2537 : }
2538 0 : return true;
2539 : }
2540 : default:
2541 : {
2542 0 : FatalError("unknown union type");
2543 0 : return false;
2544 : }
2545 : }
2546 : }
2547 :
2548 0 : auto PContentBridgeChild::Write(
2549 : const nsTArray<IPCBlob>& v__,
2550 : Message* msg__) -> void
2551 : {
2552 0 : uint32_t length = (v__).Length();
2553 0 : Write(length, msg__);
2554 : // Sentinel = ('length', 'IPCBlob[]')
2555 0 : (msg__)->WriteSentinel(894413667);
2556 :
2557 0 : for (auto& elem : v__) {
2558 0 : Write(elem, msg__);
2559 : // Sentinel = 'IPCBlob[]'
2560 0 : (msg__)->WriteSentinel(3337464726);
2561 : }
2562 0 : }
2563 :
2564 0 : auto PContentBridgeChild::Read(
2565 : nsTArray<IPCBlob>* v__,
2566 : const Message* msg__,
2567 : PickleIterator* iter__) -> bool
2568 : {
2569 0 : nsTArray<IPCBlob> fa;
2570 : uint32_t length;
2571 0 : if ((!(Read((&(length)), msg__, iter__)))) {
2572 0 : mozilla::ipc::ArrayLengthReadError("IPCBlob[]");
2573 0 : return false;
2574 : }
2575 : // Sentinel = ('length', 'IPCBlob[]')
2576 0 : if ((!((msg__)->ReadSentinel(iter__, 894413667)))) {
2577 0 : mozilla::ipc::SentinelReadError("IPCBlob[]");
2578 0 : return false;
2579 : }
2580 :
2581 0 : IPCBlob* elems = (fa).AppendElements(length);
2582 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
2583 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
2584 0 : FatalError("Error deserializing 'IPCBlob[i]'");
2585 0 : return false;
2586 : }
2587 : // Sentinel = 'IPCBlob[]'
2588 0 : if ((!((msg__)->ReadSentinel(iter__, 3337464726)))) {
2589 0 : mozilla::ipc::SentinelReadError("Error deserializing 'IPCBlob[i]'");
2590 0 : return false;
2591 : }
2592 : }
2593 0 : (v__)->SwapElements(fa);
2594 0 : return true;
2595 : }
2596 :
2597 0 : auto PContentBridgeChild::Write(
2598 : const ClonedMessageData& v__,
2599 : Message* msg__) -> void
2600 : {
2601 0 : Write((v__).data(), msg__);
2602 : // Sentinel = 'data'
2603 0 : (msg__)->WriteSentinel(843352540);
2604 0 : Write((v__).blobs(), msg__);
2605 : // Sentinel = 'blobs'
2606 0 : (msg__)->WriteSentinel(635500709);
2607 0 : Write((v__).inputStreams(), msg__);
2608 : // Sentinel = 'inputStreams'
2609 0 : (msg__)->WriteSentinel(435739475);
2610 0 : Write((v__).identfiers(), msg__);
2611 : // Sentinel = 'identfiers'
2612 0 : (msg__)->WriteSentinel(3130566733);
2613 0 : }
2614 :
2615 0 : auto PContentBridgeChild::Read(
2616 : ClonedMessageData* v__,
2617 : const Message* msg__,
2618 : PickleIterator* iter__) -> bool
2619 : {
2620 0 : if ((!(Read((&((v__)->data())), msg__, iter__)))) {
2621 0 : FatalError("Error deserializing 'data' (SerializedStructuredCloneBuffer) member of 'ClonedMessageData'");
2622 0 : return false;
2623 : }
2624 : // Sentinel = 'data'
2625 0 : if ((!((msg__)->ReadSentinel(iter__, 843352540)))) {
2626 0 : mozilla::ipc::SentinelReadError("Error deserializing 'data' (SerializedStructuredCloneBuffer) member of 'ClonedMessageData'");
2627 0 : return false;
2628 : }
2629 0 : if ((!(Read((&((v__)->blobs())), msg__, iter__)))) {
2630 0 : FatalError("Error deserializing 'blobs' (IPCBlob[]) member of 'ClonedMessageData'");
2631 0 : return false;
2632 : }
2633 : // Sentinel = 'blobs'
2634 0 : if ((!((msg__)->ReadSentinel(iter__, 635500709)))) {
2635 0 : mozilla::ipc::SentinelReadError("Error deserializing 'blobs' (IPCBlob[]) member of 'ClonedMessageData'");
2636 0 : return false;
2637 : }
2638 0 : if ((!(Read((&((v__)->inputStreams())), msg__, iter__)))) {
2639 0 : FatalError("Error deserializing 'inputStreams' (IPCStream[]) member of 'ClonedMessageData'");
2640 0 : return false;
2641 : }
2642 : // Sentinel = 'inputStreams'
2643 0 : if ((!((msg__)->ReadSentinel(iter__, 435739475)))) {
2644 0 : mozilla::ipc::SentinelReadError("Error deserializing 'inputStreams' (IPCStream[]) member of 'ClonedMessageData'");
2645 0 : return false;
2646 : }
2647 0 : if ((!(Read((&((v__)->identfiers())), msg__, iter__)))) {
2648 0 : FatalError("Error deserializing 'identfiers' (MessagePortIdentifier[]) member of 'ClonedMessageData'");
2649 0 : return false;
2650 : }
2651 : // Sentinel = 'identfiers'
2652 0 : if ((!((msg__)->ReadSentinel(iter__, 3130566733)))) {
2653 0 : mozilla::ipc::SentinelReadError("Error deserializing 'identfiers' (MessagePortIdentifier[]) member of 'ClonedMessageData'");
2654 0 : return false;
2655 : }
2656 0 : return true;
2657 : }
2658 :
2659 0 : auto PContentBridgeChild::Write(
2660 : const nsTArray<HeaderEntry>& v__,
2661 : Message* msg__) -> void
2662 : {
2663 0 : uint32_t length = (v__).Length();
2664 0 : Write(length, msg__);
2665 : // Sentinel = ('length', 'HeaderEntry[]')
2666 0 : (msg__)->WriteSentinel(2689457705);
2667 :
2668 0 : for (auto& elem : v__) {
2669 0 : Write(elem, msg__);
2670 : // Sentinel = 'HeaderEntry[]'
2671 0 : (msg__)->WriteSentinel(454836120);
2672 : }
2673 0 : }
2674 :
2675 0 : auto PContentBridgeChild::Read(
2676 : nsTArray<HeaderEntry>* v__,
2677 : const Message* msg__,
2678 : PickleIterator* iter__) -> bool
2679 : {
2680 0 : nsTArray<HeaderEntry> fa;
2681 : uint32_t length;
2682 0 : if ((!(Read((&(length)), msg__, iter__)))) {
2683 0 : mozilla::ipc::ArrayLengthReadError("HeaderEntry[]");
2684 0 : return false;
2685 : }
2686 : // Sentinel = ('length', 'HeaderEntry[]')
2687 0 : if ((!((msg__)->ReadSentinel(iter__, 2689457705)))) {
2688 0 : mozilla::ipc::SentinelReadError("HeaderEntry[]");
2689 0 : return false;
2690 : }
2691 :
2692 0 : HeaderEntry* elems = (fa).AppendElements(length);
2693 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
2694 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
2695 0 : FatalError("Error deserializing 'HeaderEntry[i]'");
2696 0 : return false;
2697 : }
2698 : // Sentinel = 'HeaderEntry[]'
2699 0 : if ((!((msg__)->ReadSentinel(iter__, 454836120)))) {
2700 0 : mozilla::ipc::SentinelReadError("Error deserializing 'HeaderEntry[i]'");
2701 0 : return false;
2702 : }
2703 : }
2704 0 : (v__)->SwapElements(fa);
2705 0 : return true;
2706 : }
2707 :
2708 0 : auto PContentBridgeChild::Write(
2709 : const nsTArray<CpowEntry>& v__,
2710 : Message* msg__) -> void
2711 : {
2712 0 : uint32_t length = (v__).Length();
2713 0 : Write(length, msg__);
2714 : // Sentinel = ('length', 'CpowEntry[]')
2715 0 : (msg__)->WriteSentinel(2290776287);
2716 :
2717 0 : for (auto& elem : v__) {
2718 0 : Write(elem, msg__);
2719 : // Sentinel = 'CpowEntry[]'
2720 0 : (msg__)->WriteSentinel(2263212074);
2721 : }
2722 0 : }
2723 :
2724 0 : auto PContentBridgeChild::Read(
2725 : nsTArray<CpowEntry>* v__,
2726 : const Message* msg__,
2727 : PickleIterator* iter__) -> bool
2728 : {
2729 0 : nsTArray<CpowEntry> fa;
2730 : uint32_t length;
2731 0 : if ((!(Read((&(length)), msg__, iter__)))) {
2732 0 : mozilla::ipc::ArrayLengthReadError("CpowEntry[]");
2733 0 : return false;
2734 : }
2735 : // Sentinel = ('length', 'CpowEntry[]')
2736 0 : if ((!((msg__)->ReadSentinel(iter__, 2290776287)))) {
2737 0 : mozilla::ipc::SentinelReadError("CpowEntry[]");
2738 0 : return false;
2739 : }
2740 :
2741 0 : CpowEntry* elems = (fa).AppendElements(length);
2742 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
2743 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
2744 0 : FatalError("Error deserializing 'CpowEntry[i]'");
2745 0 : return false;
2746 : }
2747 : // Sentinel = 'CpowEntry[]'
2748 0 : if ((!((msg__)->ReadSentinel(iter__, 2263212074)))) {
2749 0 : mozilla::ipc::SentinelReadError("Error deserializing 'CpowEntry[i]'");
2750 0 : return false;
2751 : }
2752 : }
2753 0 : (v__)->SwapElements(fa);
2754 0 : return true;
2755 : }
2756 :
2757 0 : auto PContentBridgeChild::Write(
2758 : const SlicedInputStreamParams& v__,
2759 : Message* msg__) -> void
2760 : {
2761 0 : Write((v__).stream(), msg__);
2762 : // Sentinel = 'stream'
2763 0 : (msg__)->WriteSentinel(4152748422);
2764 0 : Write((v__).start(), msg__);
2765 : // Sentinel = 'start'
2766 0 : (msg__)->WriteSentinel(2088644401);
2767 0 : Write((v__).length(), msg__);
2768 : // Sentinel = 'length'
2769 0 : (msg__)->WriteSentinel(1726618354);
2770 0 : Write((v__).curPos(), msg__);
2771 : // Sentinel = 'curPos'
2772 0 : (msg__)->WriteSentinel(4042140974);
2773 0 : Write((v__).closed(), msg__);
2774 : // Sentinel = 'closed'
2775 0 : (msg__)->WriteSentinel(561249462);
2776 0 : }
2777 :
2778 0 : auto PContentBridgeChild::Read(
2779 : SlicedInputStreamParams* v__,
2780 : const Message* msg__,
2781 : PickleIterator* iter__) -> bool
2782 : {
2783 0 : if ((!(Read((&((v__)->stream())), msg__, iter__)))) {
2784 0 : FatalError("Error deserializing 'stream' (InputStreamParams) member of 'SlicedInputStreamParams'");
2785 0 : return false;
2786 : }
2787 : // Sentinel = 'stream'
2788 0 : if ((!((msg__)->ReadSentinel(iter__, 4152748422)))) {
2789 0 : mozilla::ipc::SentinelReadError("Error deserializing 'stream' (InputStreamParams) member of 'SlicedInputStreamParams'");
2790 0 : return false;
2791 : }
2792 0 : if ((!(Read((&((v__)->start())), msg__, iter__)))) {
2793 0 : FatalError("Error deserializing 'start' (uint64_t) member of 'SlicedInputStreamParams'");
2794 0 : return false;
2795 : }
2796 : // Sentinel = 'start'
2797 0 : if ((!((msg__)->ReadSentinel(iter__, 2088644401)))) {
2798 0 : mozilla::ipc::SentinelReadError("Error deserializing 'start' (uint64_t) member of 'SlicedInputStreamParams'");
2799 0 : return false;
2800 : }
2801 0 : if ((!(Read((&((v__)->length())), msg__, iter__)))) {
2802 0 : FatalError("Error deserializing 'length' (uint64_t) member of 'SlicedInputStreamParams'");
2803 0 : return false;
2804 : }
2805 : // Sentinel = 'length'
2806 0 : if ((!((msg__)->ReadSentinel(iter__, 1726618354)))) {
2807 0 : mozilla::ipc::SentinelReadError("Error deserializing 'length' (uint64_t) member of 'SlicedInputStreamParams'");
2808 0 : return false;
2809 : }
2810 0 : if ((!(Read((&((v__)->curPos())), msg__, iter__)))) {
2811 0 : FatalError("Error deserializing 'curPos' (uint64_t) member of 'SlicedInputStreamParams'");
2812 0 : return false;
2813 : }
2814 : // Sentinel = 'curPos'
2815 0 : if ((!((msg__)->ReadSentinel(iter__, 4042140974)))) {
2816 0 : mozilla::ipc::SentinelReadError("Error deserializing 'curPos' (uint64_t) member of 'SlicedInputStreamParams'");
2817 0 : return false;
2818 : }
2819 0 : if ((!(Read((&((v__)->closed())), msg__, iter__)))) {
2820 0 : FatalError("Error deserializing 'closed' (bool) member of 'SlicedInputStreamParams'");
2821 0 : return false;
2822 : }
2823 : // Sentinel = 'closed'
2824 0 : if ((!((msg__)->ReadSentinel(iter__, 561249462)))) {
2825 0 : mozilla::ipc::SentinelReadError("Error deserializing 'closed' (bool) member of 'SlicedInputStreamParams'");
2826 0 : return false;
2827 : }
2828 0 : return true;
2829 : }
2830 :
2831 0 : auto PContentBridgeChild::Write(
2832 : const IPCRemoteStreamType& v__,
2833 : Message* msg__) -> void
2834 : {
2835 : typedef IPCRemoteStreamType type__;
2836 0 : Write(int((v__).type()), msg__);
2837 : // Sentinel = 'IPCRemoteStreamType'
2838 0 : (msg__)->WriteSentinel(391674895);
2839 :
2840 0 : switch ((v__).type()) {
2841 : case type__::TPChildToParentStreamParent:
2842 : {
2843 0 : FatalError("wrong side!");
2844 0 : return;
2845 : }
2846 : case type__::TPChildToParentStreamChild:
2847 : {
2848 0 : Write((v__).get_PChildToParentStreamChild(), msg__, false);
2849 : // Sentinel = 'TPChildToParentStreamChild'
2850 0 : (msg__)->WriteSentinel(1882094295);
2851 0 : return;
2852 : }
2853 : case type__::TPParentToChildStreamParent:
2854 : {
2855 0 : FatalError("wrong side!");
2856 0 : return;
2857 : }
2858 : case type__::TPParentToChildStreamChild:
2859 : {
2860 0 : Write((v__).get_PParentToChildStreamChild(), msg__, false);
2861 : // Sentinel = 'TPParentToChildStreamChild'
2862 0 : (msg__)->WriteSentinel(190098493);
2863 0 : return;
2864 : }
2865 : default:
2866 : {
2867 0 : FatalError("unknown union type");
2868 0 : return;
2869 : }
2870 : }
2871 : }
2872 :
2873 0 : auto PContentBridgeChild::Read(
2874 : IPCRemoteStreamType* v__,
2875 : const Message* msg__,
2876 : PickleIterator* iter__) -> bool
2877 : {
2878 : typedef IPCRemoteStreamType type__;
2879 : int type;
2880 0 : if ((!(Read((&(type)), msg__, iter__)))) {
2881 0 : mozilla::ipc::UnionTypeReadError("IPCRemoteStreamType");
2882 0 : return false;
2883 : }
2884 : // Sentinel = 'IPCRemoteStreamType'
2885 0 : if ((!((msg__)->ReadSentinel(iter__, 391674895)))) {
2886 0 : mozilla::ipc::SentinelReadError("IPCRemoteStreamType");
2887 0 : return false;
2888 : }
2889 :
2890 0 : switch (type) {
2891 : case type__::TPChildToParentStreamParent:
2892 : {
2893 0 : PChildToParentStreamChild* tmp = nullptr;
2894 0 : (*(v__)) = tmp;
2895 0 : if ((!(Read((&((v__)->get_PChildToParentStreamChild())), msg__, iter__, false)))) {
2896 0 : FatalError("Error deserializing Union type");
2897 0 : return false;
2898 : }
2899 : // Sentinel = 'TPChildToParentStreamParent'
2900 0 : if ((!((msg__)->ReadSentinel(iter__, 2724777622)))) {
2901 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2902 0 : return false;
2903 : }
2904 0 : return true;
2905 : }
2906 : case type__::TPChildToParentStreamChild:
2907 : {
2908 0 : return false;
2909 : }
2910 : case type__::TPParentToChildStreamParent:
2911 : {
2912 0 : PParentToChildStreamChild* tmp = nullptr;
2913 0 : (*(v__)) = tmp;
2914 0 : if ((!(Read((&((v__)->get_PParentToChildStreamChild())), msg__, iter__, false)))) {
2915 0 : FatalError("Error deserializing Union type");
2916 0 : return false;
2917 : }
2918 : // Sentinel = 'TPParentToChildStreamParent'
2919 0 : if ((!((msg__)->ReadSentinel(iter__, 3335986876)))) {
2920 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2921 0 : return false;
2922 : }
2923 0 : return true;
2924 : }
2925 : case type__::TPParentToChildStreamChild:
2926 : {
2927 0 : return false;
2928 : }
2929 : default:
2930 : {
2931 0 : FatalError("unknown union type");
2932 0 : return false;
2933 : }
2934 : }
2935 : }
2936 :
2937 0 : auto PContentBridgeChild::Write(
2938 : const TemporaryFileInputStreamParams& v__,
2939 : Message* msg__) -> void
2940 : {
2941 0 : Write((v__).fileDescriptorIndex(), msg__);
2942 : // Sentinel = 'fileDescriptorIndex'
2943 0 : (msg__)->WriteSentinel(587329112);
2944 0 : Write((v__).startPos(), msg__);
2945 : // Sentinel = 'startPos'
2946 0 : (msg__)->WriteSentinel(557207962);
2947 0 : Write((v__).endPos(), msg__);
2948 : // Sentinel = 'endPos'
2949 0 : (msg__)->WriteSentinel(881536245);
2950 0 : }
2951 :
2952 0 : auto PContentBridgeChild::Read(
2953 : TemporaryFileInputStreamParams* v__,
2954 : const Message* msg__,
2955 : PickleIterator* iter__) -> bool
2956 : {
2957 0 : if ((!(Read((&((v__)->fileDescriptorIndex())), msg__, iter__)))) {
2958 0 : FatalError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'TemporaryFileInputStreamParams'");
2959 0 : return false;
2960 : }
2961 : // Sentinel = 'fileDescriptorIndex'
2962 0 : if ((!((msg__)->ReadSentinel(iter__, 587329112)))) {
2963 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'TemporaryFileInputStreamParams'");
2964 0 : return false;
2965 : }
2966 0 : if ((!(Read((&((v__)->startPos())), msg__, iter__)))) {
2967 0 : FatalError("Error deserializing 'startPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
2968 0 : return false;
2969 : }
2970 : // Sentinel = 'startPos'
2971 0 : if ((!((msg__)->ReadSentinel(iter__, 557207962)))) {
2972 0 : mozilla::ipc::SentinelReadError("Error deserializing 'startPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
2973 0 : return false;
2974 : }
2975 0 : if ((!(Read((&((v__)->endPos())), msg__, iter__)))) {
2976 0 : FatalError("Error deserializing 'endPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
2977 0 : return false;
2978 : }
2979 : // Sentinel = 'endPos'
2980 0 : if ((!((msg__)->ReadSentinel(iter__, 881536245)))) {
2981 0 : mozilla::ipc::SentinelReadError("Error deserializing 'endPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
2982 0 : return false;
2983 : }
2984 0 : return true;
2985 : }
2986 :
2987 0 : auto PContentBridgeChild::Write(
2988 : const FrameIPCTabContext& v__,
2989 : Message* msg__) -> void
2990 : {
2991 0 : Write((v__).originAttributes(), msg__);
2992 : // Sentinel = 'originAttributes'
2993 0 : (msg__)->WriteSentinel(2655275965);
2994 0 : Write((v__).isMozBrowserElement(), msg__);
2995 : // Sentinel = 'isMozBrowserElement'
2996 0 : (msg__)->WriteSentinel(2365644109);
2997 0 : Write((v__).isPrerendered(), msg__);
2998 : // Sentinel = 'isPrerendered'
2999 0 : (msg__)->WriteSentinel(752926845);
3000 0 : Write((v__).presentationURL(), msg__);
3001 : // Sentinel = 'presentationURL'
3002 0 : (msg__)->WriteSentinel(4359828);
3003 0 : Write((v__).showAccelerators(), msg__);
3004 : // Sentinel = 'showAccelerators'
3005 0 : (msg__)->WriteSentinel(2628588971);
3006 0 : Write((v__).showFocusRings(), msg__);
3007 : // Sentinel = 'showFocusRings'
3008 0 : (msg__)->WriteSentinel(2619412036);
3009 0 : }
3010 :
3011 0 : auto PContentBridgeChild::Read(
3012 : FrameIPCTabContext* v__,
3013 : const Message* msg__,
3014 : PickleIterator* iter__) -> bool
3015 : {
3016 0 : if ((!(Read((&((v__)->originAttributes())), msg__, iter__)))) {
3017 0 : FatalError("Error deserializing 'originAttributes' (OriginAttributes) member of 'FrameIPCTabContext'");
3018 0 : return false;
3019 : }
3020 : // Sentinel = 'originAttributes'
3021 0 : if ((!((msg__)->ReadSentinel(iter__, 2655275965)))) {
3022 0 : mozilla::ipc::SentinelReadError("Error deserializing 'originAttributes' (OriginAttributes) member of 'FrameIPCTabContext'");
3023 0 : return false;
3024 : }
3025 0 : if ((!(Read((&((v__)->isMozBrowserElement())), msg__, iter__)))) {
3026 0 : FatalError("Error deserializing 'isMozBrowserElement' (bool) member of 'FrameIPCTabContext'");
3027 0 : return false;
3028 : }
3029 : // Sentinel = 'isMozBrowserElement'
3030 0 : if ((!((msg__)->ReadSentinel(iter__, 2365644109)))) {
3031 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isMozBrowserElement' (bool) member of 'FrameIPCTabContext'");
3032 0 : return false;
3033 : }
3034 0 : if ((!(Read((&((v__)->isPrerendered())), msg__, iter__)))) {
3035 0 : FatalError("Error deserializing 'isPrerendered' (bool) member of 'FrameIPCTabContext'");
3036 0 : return false;
3037 : }
3038 : // Sentinel = 'isPrerendered'
3039 0 : if ((!((msg__)->ReadSentinel(iter__, 752926845)))) {
3040 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isPrerendered' (bool) member of 'FrameIPCTabContext'");
3041 0 : return false;
3042 : }
3043 0 : if ((!(Read((&((v__)->presentationURL())), msg__, iter__)))) {
3044 0 : FatalError("Error deserializing 'presentationURL' (nsString) member of 'FrameIPCTabContext'");
3045 0 : return false;
3046 : }
3047 : // Sentinel = 'presentationURL'
3048 0 : if ((!((msg__)->ReadSentinel(iter__, 4359828)))) {
3049 0 : mozilla::ipc::SentinelReadError("Error deserializing 'presentationURL' (nsString) member of 'FrameIPCTabContext'");
3050 0 : return false;
3051 : }
3052 0 : if ((!(Read((&((v__)->showAccelerators())), msg__, iter__)))) {
3053 0 : FatalError("Error deserializing 'showAccelerators' (UIStateChangeType) member of 'FrameIPCTabContext'");
3054 0 : return false;
3055 : }
3056 : // Sentinel = 'showAccelerators'
3057 0 : if ((!((msg__)->ReadSentinel(iter__, 2628588971)))) {
3058 0 : mozilla::ipc::SentinelReadError("Error deserializing 'showAccelerators' (UIStateChangeType) member of 'FrameIPCTabContext'");
3059 0 : return false;
3060 : }
3061 0 : if ((!(Read((&((v__)->showFocusRings())), msg__, iter__)))) {
3062 0 : FatalError("Error deserializing 'showFocusRings' (UIStateChangeType) member of 'FrameIPCTabContext'");
3063 0 : return false;
3064 : }
3065 : // Sentinel = 'showFocusRings'
3066 0 : if ((!((msg__)->ReadSentinel(iter__, 2619412036)))) {
3067 0 : mozilla::ipc::SentinelReadError("Error deserializing 'showFocusRings' (UIStateChangeType) member of 'FrameIPCTabContext'");
3068 0 : return false;
3069 : }
3070 0 : return true;
3071 : }
3072 :
3073 0 : auto PContentBridgeChild::Write(
3074 : const MIMEInputStreamParams& v__,
3075 : Message* msg__) -> void
3076 : {
3077 0 : Write((v__).optionalStream(), msg__);
3078 : // Sentinel = 'optionalStream'
3079 0 : (msg__)->WriteSentinel(1003718562);
3080 0 : Write((v__).headers(), msg__);
3081 : // Sentinel = 'headers'
3082 0 : (msg__)->WriteSentinel(4284175217);
3083 0 : Write((v__).startedReading(), msg__);
3084 : // Sentinel = 'startedReading'
3085 0 : (msg__)->WriteSentinel(1906875903);
3086 0 : }
3087 :
3088 0 : auto PContentBridgeChild::Read(
3089 : MIMEInputStreamParams* v__,
3090 : const Message* msg__,
3091 : PickleIterator* iter__) -> bool
3092 : {
3093 0 : if ((!(Read((&((v__)->optionalStream())), msg__, iter__)))) {
3094 0 : FatalError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'MIMEInputStreamParams'");
3095 0 : return false;
3096 : }
3097 : // Sentinel = 'optionalStream'
3098 0 : if ((!((msg__)->ReadSentinel(iter__, 1003718562)))) {
3099 0 : mozilla::ipc::SentinelReadError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'MIMEInputStreamParams'");
3100 0 : return false;
3101 : }
3102 0 : if ((!(Read((&((v__)->headers())), msg__, iter__)))) {
3103 0 : FatalError("Error deserializing 'headers' (HeaderEntry[]) member of 'MIMEInputStreamParams'");
3104 0 : return false;
3105 : }
3106 : // Sentinel = 'headers'
3107 0 : if ((!((msg__)->ReadSentinel(iter__, 4284175217)))) {
3108 0 : mozilla::ipc::SentinelReadError("Error deserializing 'headers' (HeaderEntry[]) member of 'MIMEInputStreamParams'");
3109 0 : return false;
3110 : }
3111 0 : if ((!(Read((&((v__)->startedReading())), msg__, iter__)))) {
3112 0 : FatalError("Error deserializing 'startedReading' (bool) member of 'MIMEInputStreamParams'");
3113 0 : return false;
3114 : }
3115 : // Sentinel = 'startedReading'
3116 0 : if ((!((msg__)->ReadSentinel(iter__, 1906875903)))) {
3117 0 : mozilla::ipc::SentinelReadError("Error deserializing 'startedReading' (bool) member of 'MIMEInputStreamParams'");
3118 0 : return false;
3119 : }
3120 0 : return true;
3121 : }
3122 :
3123 0 : auto PContentBridgeChild::Write(
3124 : const InputStreamParams& v__,
3125 : Message* msg__) -> void
3126 : {
3127 : typedef InputStreamParams type__;
3128 0 : Write(int((v__).type()), msg__);
3129 : // Sentinel = 'InputStreamParams'
3130 0 : (msg__)->WriteSentinel(4114814015);
3131 :
3132 0 : switch ((v__).type()) {
3133 : case type__::TStringInputStreamParams:
3134 : {
3135 0 : Write((v__).get_StringInputStreamParams(), msg__);
3136 : // Sentinel = 'TStringInputStreamParams'
3137 0 : (msg__)->WriteSentinel(3395831651);
3138 0 : return;
3139 : }
3140 : case type__::TFileInputStreamParams:
3141 : {
3142 0 : Write((v__).get_FileInputStreamParams(), msg__);
3143 : // Sentinel = 'TFileInputStreamParams'
3144 0 : (msg__)->WriteSentinel(2543620282);
3145 0 : return;
3146 : }
3147 : case type__::TTemporaryFileInputStreamParams:
3148 : {
3149 0 : Write((v__).get_TemporaryFileInputStreamParams(), msg__);
3150 : // Sentinel = 'TTemporaryFileInputStreamParams'
3151 0 : (msg__)->WriteSentinel(587771548);
3152 0 : return;
3153 : }
3154 : case type__::TBufferedInputStreamParams:
3155 : {
3156 0 : Write((v__).get_BufferedInputStreamParams(), msg__);
3157 : // Sentinel = 'TBufferedInputStreamParams'
3158 0 : (msg__)->WriteSentinel(1698289307);
3159 0 : return;
3160 : }
3161 : case type__::TMIMEInputStreamParams:
3162 : {
3163 0 : Write((v__).get_MIMEInputStreamParams(), msg__);
3164 : // Sentinel = 'TMIMEInputStreamParams'
3165 0 : (msg__)->WriteSentinel(1948001964);
3166 0 : return;
3167 : }
3168 : case type__::TMultiplexInputStreamParams:
3169 : {
3170 0 : Write((v__).get_MultiplexInputStreamParams(), msg__);
3171 : // Sentinel = 'TMultiplexInputStreamParams'
3172 0 : (msg__)->WriteSentinel(3317853213);
3173 0 : return;
3174 : }
3175 : case type__::TSlicedInputStreamParams:
3176 : {
3177 0 : Write((v__).get_SlicedInputStreamParams(), msg__);
3178 : // Sentinel = 'TSlicedInputStreamParams'
3179 0 : (msg__)->WriteSentinel(445810472);
3180 0 : return;
3181 : }
3182 : case type__::TIPCBlobInputStreamParams:
3183 : {
3184 0 : Write((v__).get_IPCBlobInputStreamParams(), msg__);
3185 : // Sentinel = 'TIPCBlobInputStreamParams'
3186 0 : (msg__)->WriteSentinel(2436989998);
3187 0 : return;
3188 : }
3189 : default:
3190 : {
3191 0 : FatalError("unknown union type");
3192 0 : return;
3193 : }
3194 : }
3195 : }
3196 :
3197 0 : auto PContentBridgeChild::Read(
3198 : InputStreamParams* v__,
3199 : const Message* msg__,
3200 : PickleIterator* iter__) -> bool
3201 : {
3202 : typedef InputStreamParams type__;
3203 : int type;
3204 0 : if ((!(Read((&(type)), msg__, iter__)))) {
3205 0 : mozilla::ipc::UnionTypeReadError("InputStreamParams");
3206 0 : return false;
3207 : }
3208 : // Sentinel = 'InputStreamParams'
3209 0 : if ((!((msg__)->ReadSentinel(iter__, 4114814015)))) {
3210 0 : mozilla::ipc::SentinelReadError("InputStreamParams");
3211 0 : return false;
3212 : }
3213 :
3214 0 : switch (type) {
3215 : case type__::TStringInputStreamParams:
3216 : {
3217 0 : StringInputStreamParams tmp = StringInputStreamParams();
3218 0 : (*(v__)) = tmp;
3219 0 : if ((!(Read((&((v__)->get_StringInputStreamParams())), msg__, iter__)))) {
3220 0 : FatalError("Error deserializing Union type");
3221 0 : return false;
3222 : }
3223 : // Sentinel = 'TStringInputStreamParams'
3224 0 : if ((!((msg__)->ReadSentinel(iter__, 3395831651)))) {
3225 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3226 0 : return false;
3227 : }
3228 0 : return true;
3229 : }
3230 : case type__::TFileInputStreamParams:
3231 : {
3232 0 : FileInputStreamParams tmp = FileInputStreamParams();
3233 0 : (*(v__)) = tmp;
3234 0 : if ((!(Read((&((v__)->get_FileInputStreamParams())), msg__, iter__)))) {
3235 0 : FatalError("Error deserializing Union type");
3236 0 : return false;
3237 : }
3238 : // Sentinel = 'TFileInputStreamParams'
3239 0 : if ((!((msg__)->ReadSentinel(iter__, 2543620282)))) {
3240 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3241 0 : return false;
3242 : }
3243 0 : return true;
3244 : }
3245 : case type__::TTemporaryFileInputStreamParams:
3246 : {
3247 0 : TemporaryFileInputStreamParams tmp = TemporaryFileInputStreamParams();
3248 0 : (*(v__)) = tmp;
3249 0 : if ((!(Read((&((v__)->get_TemporaryFileInputStreamParams())), msg__, iter__)))) {
3250 0 : FatalError("Error deserializing Union type");
3251 0 : return false;
3252 : }
3253 : // Sentinel = 'TTemporaryFileInputStreamParams'
3254 0 : if ((!((msg__)->ReadSentinel(iter__, 587771548)))) {
3255 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3256 0 : return false;
3257 : }
3258 0 : return true;
3259 : }
3260 : case type__::TBufferedInputStreamParams:
3261 : {
3262 0 : BufferedInputStreamParams tmp = BufferedInputStreamParams();
3263 0 : (*(v__)) = tmp;
3264 0 : if ((!(Read((&((v__)->get_BufferedInputStreamParams())), msg__, iter__)))) {
3265 0 : FatalError("Error deserializing Union type");
3266 0 : return false;
3267 : }
3268 : // Sentinel = 'TBufferedInputStreamParams'
3269 0 : if ((!((msg__)->ReadSentinel(iter__, 1698289307)))) {
3270 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3271 0 : return false;
3272 : }
3273 0 : return true;
3274 : }
3275 : case type__::TMIMEInputStreamParams:
3276 : {
3277 0 : MIMEInputStreamParams tmp = MIMEInputStreamParams();
3278 0 : (*(v__)) = tmp;
3279 0 : if ((!(Read((&((v__)->get_MIMEInputStreamParams())), msg__, iter__)))) {
3280 0 : FatalError("Error deserializing Union type");
3281 0 : return false;
3282 : }
3283 : // Sentinel = 'TMIMEInputStreamParams'
3284 0 : if ((!((msg__)->ReadSentinel(iter__, 1948001964)))) {
3285 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3286 0 : return false;
3287 : }
3288 0 : return true;
3289 : }
3290 : case type__::TMultiplexInputStreamParams:
3291 : {
3292 0 : MultiplexInputStreamParams tmp = MultiplexInputStreamParams();
3293 0 : (*(v__)) = tmp;
3294 0 : if ((!(Read((&((v__)->get_MultiplexInputStreamParams())), msg__, iter__)))) {
3295 0 : FatalError("Error deserializing Union type");
3296 0 : return false;
3297 : }
3298 : // Sentinel = 'TMultiplexInputStreamParams'
3299 0 : if ((!((msg__)->ReadSentinel(iter__, 3317853213)))) {
3300 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3301 0 : return false;
3302 : }
3303 0 : return true;
3304 : }
3305 : case type__::TSlicedInputStreamParams:
3306 : {
3307 0 : SlicedInputStreamParams tmp = SlicedInputStreamParams();
3308 0 : (*(v__)) = tmp;
3309 0 : if ((!(Read((&((v__)->get_SlicedInputStreamParams())), msg__, iter__)))) {
3310 0 : FatalError("Error deserializing Union type");
3311 0 : return false;
3312 : }
3313 : // Sentinel = 'TSlicedInputStreamParams'
3314 0 : if ((!((msg__)->ReadSentinel(iter__, 445810472)))) {
3315 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3316 0 : return false;
3317 : }
3318 0 : return true;
3319 : }
3320 : case type__::TIPCBlobInputStreamParams:
3321 : {
3322 0 : IPCBlobInputStreamParams tmp = IPCBlobInputStreamParams();
3323 0 : (*(v__)) = tmp;
3324 0 : if ((!(Read((&((v__)->get_IPCBlobInputStreamParams())), msg__, iter__)))) {
3325 0 : FatalError("Error deserializing Union type");
3326 0 : return false;
3327 : }
3328 : // Sentinel = 'TIPCBlobInputStreamParams'
3329 0 : if ((!((msg__)->ReadSentinel(iter__, 2436989998)))) {
3330 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3331 0 : return false;
3332 : }
3333 0 : return true;
3334 : }
3335 : default:
3336 : {
3337 0 : FatalError("unknown union type");
3338 0 : return false;
3339 : }
3340 : }
3341 : }
3342 :
3343 0 : auto PContentBridgeChild::Write(
3344 : const PopupIPCTabContext& v__,
3345 : Message* msg__) -> void
3346 : {
3347 0 : Write((v__).opener(), msg__);
3348 : // Sentinel = 'opener'
3349 0 : (msg__)->WriteSentinel(2714806963);
3350 0 : Write((v__).isMozBrowserElement(), msg__);
3351 : // Sentinel = 'isMozBrowserElement'
3352 0 : (msg__)->WriteSentinel(2365644109);
3353 0 : }
3354 :
3355 0 : auto PContentBridgeChild::Read(
3356 : PopupIPCTabContext* v__,
3357 : const Message* msg__,
3358 : PickleIterator* iter__) -> bool
3359 : {
3360 0 : if ((!(Read((&((v__)->opener())), msg__, iter__)))) {
3361 0 : FatalError("Error deserializing 'opener' (PBrowserOrId) member of 'PopupIPCTabContext'");
3362 0 : return false;
3363 : }
3364 : // Sentinel = 'opener'
3365 0 : if ((!((msg__)->ReadSentinel(iter__, 2714806963)))) {
3366 0 : mozilla::ipc::SentinelReadError("Error deserializing 'opener' (PBrowserOrId) member of 'PopupIPCTabContext'");
3367 0 : return false;
3368 : }
3369 0 : if ((!(Read((&((v__)->isMozBrowserElement())), msg__, iter__)))) {
3370 0 : FatalError("Error deserializing 'isMozBrowserElement' (bool) member of 'PopupIPCTabContext'");
3371 0 : return false;
3372 : }
3373 : // Sentinel = 'isMozBrowserElement'
3374 0 : if ((!((msg__)->ReadSentinel(iter__, 2365644109)))) {
3375 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isMozBrowserElement' (bool) member of 'PopupIPCTabContext'");
3376 0 : return false;
3377 : }
3378 0 : return true;
3379 : }
3380 :
3381 0 : auto PContentBridgeChild::Write(
3382 : const IPCStream& v__,
3383 : Message* msg__) -> void
3384 : {
3385 : typedef IPCStream type__;
3386 0 : Write(int((v__).type()), msg__);
3387 : // Sentinel = 'IPCStream'
3388 0 : (msg__)->WriteSentinel(442610715);
3389 :
3390 0 : switch ((v__).type()) {
3391 : case type__::TInputStreamParamsWithFds:
3392 : {
3393 0 : Write((v__).get_InputStreamParamsWithFds(), msg__);
3394 : // Sentinel = 'TInputStreamParamsWithFds'
3395 0 : (msg__)->WriteSentinel(2170706066);
3396 0 : return;
3397 : }
3398 : case type__::TIPCRemoteStream:
3399 : {
3400 0 : Write((v__).get_IPCRemoteStream(), msg__);
3401 : // Sentinel = 'TIPCRemoteStream'
3402 0 : (msg__)->WriteSentinel(2978132448);
3403 0 : return;
3404 : }
3405 : default:
3406 : {
3407 0 : FatalError("unknown union type");
3408 0 : return;
3409 : }
3410 : }
3411 : }
3412 :
3413 0 : auto PContentBridgeChild::Read(
3414 : IPCStream* v__,
3415 : const Message* msg__,
3416 : PickleIterator* iter__) -> bool
3417 : {
3418 : typedef IPCStream type__;
3419 : int type;
3420 0 : if ((!(Read((&(type)), msg__, iter__)))) {
3421 0 : mozilla::ipc::UnionTypeReadError("IPCStream");
3422 0 : return false;
3423 : }
3424 : // Sentinel = 'IPCStream'
3425 0 : if ((!((msg__)->ReadSentinel(iter__, 442610715)))) {
3426 0 : mozilla::ipc::SentinelReadError("IPCStream");
3427 0 : return false;
3428 : }
3429 :
3430 0 : switch (type) {
3431 : case type__::TInputStreamParamsWithFds:
3432 : {
3433 0 : InputStreamParamsWithFds tmp = InputStreamParamsWithFds();
3434 0 : (*(v__)) = tmp;
3435 0 : if ((!(Read((&((v__)->get_InputStreamParamsWithFds())), msg__, iter__)))) {
3436 0 : FatalError("Error deserializing Union type");
3437 0 : return false;
3438 : }
3439 : // Sentinel = 'TInputStreamParamsWithFds'
3440 0 : if ((!((msg__)->ReadSentinel(iter__, 2170706066)))) {
3441 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3442 0 : return false;
3443 : }
3444 0 : return true;
3445 : }
3446 : case type__::TIPCRemoteStream:
3447 : {
3448 0 : IPCRemoteStream tmp = IPCRemoteStream();
3449 0 : (*(v__)) = tmp;
3450 0 : if ((!(Read((&((v__)->get_IPCRemoteStream())), msg__, iter__)))) {
3451 0 : FatalError("Error deserializing Union type");
3452 0 : return false;
3453 : }
3454 : // Sentinel = 'TIPCRemoteStream'
3455 0 : if ((!((msg__)->ReadSentinel(iter__, 2978132448)))) {
3456 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3457 0 : return false;
3458 : }
3459 0 : return true;
3460 : }
3461 : default:
3462 : {
3463 0 : FatalError("unknown union type");
3464 0 : return false;
3465 : }
3466 : }
3467 : }
3468 :
3469 0 : auto PContentBridgeChild::Write(
3470 : const LocalObject& v__,
3471 : Message* msg__) -> void
3472 : {
3473 0 : Write((v__).serializedId(), msg__);
3474 : // Sentinel = 'serializedId'
3475 0 : (msg__)->WriteSentinel(517551973);
3476 0 : }
3477 :
3478 0 : auto PContentBridgeChild::Read(
3479 : LocalObject* v__,
3480 : const Message* msg__,
3481 : PickleIterator* iter__) -> bool
3482 : {
3483 0 : if ((!(Read((&((v__)->serializedId())), msg__, iter__)))) {
3484 0 : FatalError("Error deserializing 'serializedId' (uint64_t) member of 'LocalObject'");
3485 0 : return false;
3486 : }
3487 : // Sentinel = 'serializedId'
3488 0 : if ((!((msg__)->ReadSentinel(iter__, 517551973)))) {
3489 0 : mozilla::ipc::SentinelReadError("Error deserializing 'serializedId' (uint64_t) member of 'LocalObject'");
3490 0 : return false;
3491 : }
3492 0 : return true;
3493 : }
3494 :
3495 0 : auto PContentBridgeChild::Write(
3496 : const ObjectVariant& v__,
3497 : Message* msg__) -> void
3498 : {
3499 : typedef ObjectVariant type__;
3500 0 : Write(int((v__).type()), msg__);
3501 : // Sentinel = 'ObjectVariant'
3502 0 : (msg__)->WriteSentinel(3403328885);
3503 :
3504 0 : switch ((v__).type()) {
3505 : case type__::TLocalObject:
3506 : {
3507 0 : Write((v__).get_LocalObject(), msg__);
3508 : // Sentinel = 'TLocalObject'
3509 0 : (msg__)->WriteSentinel(2788453632);
3510 0 : return;
3511 : }
3512 : case type__::TRemoteObject:
3513 : {
3514 0 : Write((v__).get_RemoteObject(), msg__);
3515 : // Sentinel = 'TRemoteObject'
3516 0 : (msg__)->WriteSentinel(807590902);
3517 0 : return;
3518 : }
3519 : default:
3520 : {
3521 0 : FatalError("unknown union type");
3522 0 : return;
3523 : }
3524 : }
3525 : }
3526 :
3527 0 : auto PContentBridgeChild::Read(
3528 : ObjectVariant* v__,
3529 : const Message* msg__,
3530 : PickleIterator* iter__) -> bool
3531 : {
3532 : typedef ObjectVariant type__;
3533 : int type;
3534 0 : if ((!(Read((&(type)), msg__, iter__)))) {
3535 0 : mozilla::ipc::UnionTypeReadError("ObjectVariant");
3536 0 : return false;
3537 : }
3538 : // Sentinel = 'ObjectVariant'
3539 0 : if ((!((msg__)->ReadSentinel(iter__, 3403328885)))) {
3540 0 : mozilla::ipc::SentinelReadError("ObjectVariant");
3541 0 : return false;
3542 : }
3543 :
3544 0 : switch (type) {
3545 : case type__::TLocalObject:
3546 : {
3547 0 : LocalObject tmp = LocalObject();
3548 0 : (*(v__)) = tmp;
3549 0 : if ((!(Read((&((v__)->get_LocalObject())), msg__, iter__)))) {
3550 0 : FatalError("Error deserializing Union type");
3551 0 : return false;
3552 : }
3553 : // Sentinel = 'TLocalObject'
3554 0 : if ((!((msg__)->ReadSentinel(iter__, 2788453632)))) {
3555 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3556 0 : return false;
3557 : }
3558 0 : return true;
3559 : }
3560 : case type__::TRemoteObject:
3561 : {
3562 0 : RemoteObject tmp = RemoteObject();
3563 0 : (*(v__)) = tmp;
3564 0 : if ((!(Read((&((v__)->get_RemoteObject())), msg__, iter__)))) {
3565 0 : FatalError("Error deserializing Union type");
3566 0 : return false;
3567 : }
3568 : // Sentinel = 'TRemoteObject'
3569 0 : if ((!((msg__)->ReadSentinel(iter__, 807590902)))) {
3570 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3571 0 : return false;
3572 : }
3573 0 : return true;
3574 : }
3575 : default:
3576 : {
3577 0 : FatalError("unknown union type");
3578 0 : return false;
3579 : }
3580 : }
3581 : }
3582 :
3583 0 : auto PContentBridgeChild::Write(
3584 : const PFileDescriptorSetChild* v__,
3585 : Message* msg__,
3586 : bool nullable__) -> void
3587 : {
3588 : int32_t id;
3589 0 : if ((!(v__))) {
3590 0 : if ((!(nullable__))) {
3591 0 : FatalError("NULL actor value passed to non-nullable param");
3592 : }
3593 0 : id = 0;
3594 : }
3595 : else {
3596 0 : id = (v__)->Id();
3597 0 : if ((1) == (id)) {
3598 0 : FatalError("actor has been |delete|d");
3599 : }
3600 : }
3601 :
3602 0 : Write(id, msg__);
3603 0 : }
3604 :
3605 0 : auto PContentBridgeChild::Read(
3606 : PFileDescriptorSetChild** v__,
3607 : const Message* msg__,
3608 : PickleIterator* iter__,
3609 : bool nullable__) -> bool
3610 : {
3611 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PFileDescriptorSet", PFileDescriptorSetMsgStart);
3612 0 : if ((actor).isNothing()) {
3613 0 : return false;
3614 : }
3615 :
3616 0 : (*(v__)) = static_cast<PFileDescriptorSetChild*>((actor).value());
3617 0 : return true;
3618 : }
3619 :
3620 0 : auto PContentBridgeChild::Write(
3621 : const StringInputStreamParams& v__,
3622 : Message* msg__) -> void
3623 : {
3624 0 : Write((v__).data(), msg__);
3625 : // Sentinel = 'data'
3626 0 : (msg__)->WriteSentinel(843352540);
3627 0 : }
3628 :
3629 0 : auto PContentBridgeChild::Read(
3630 : StringInputStreamParams* v__,
3631 : const Message* msg__,
3632 : PickleIterator* iter__) -> bool
3633 : {
3634 0 : if ((!(Read((&((v__)->data())), msg__, iter__)))) {
3635 0 : FatalError("Error deserializing 'data' (nsCString) member of 'StringInputStreamParams'");
3636 0 : return false;
3637 : }
3638 : // Sentinel = 'data'
3639 0 : if ((!((msg__)->ReadSentinel(iter__, 843352540)))) {
3640 0 : mozilla::ipc::SentinelReadError("Error deserializing 'data' (nsCString) member of 'StringInputStreamParams'");
3641 0 : return false;
3642 : }
3643 0 : return true;
3644 : }
3645 :
3646 0 : auto PContentBridgeChild::Write(
3647 : const JSPluginFrameIPCTabContext& v__,
3648 : Message* msg__) -> void
3649 : {
3650 0 : Write((v__).jsPluginId(), msg__);
3651 : // Sentinel = 'jsPluginId'
3652 0 : (msg__)->WriteSentinel(3968295297);
3653 0 : }
3654 :
3655 0 : auto PContentBridgeChild::Read(
3656 : JSPluginFrameIPCTabContext* v__,
3657 : const Message* msg__,
3658 : PickleIterator* iter__) -> bool
3659 : {
3660 0 : if ((!(Read((&((v__)->jsPluginId())), msg__, iter__)))) {
3661 0 : FatalError("Error deserializing 'jsPluginId' (uint32_t) member of 'JSPluginFrameIPCTabContext'");
3662 0 : return false;
3663 : }
3664 : // Sentinel = 'jsPluginId'
3665 0 : if ((!((msg__)->ReadSentinel(iter__, 3968295297)))) {
3666 0 : mozilla::ipc::SentinelReadError("Error deserializing 'jsPluginId' (uint32_t) member of 'JSPluginFrameIPCTabContext'");
3667 0 : return false;
3668 : }
3669 0 : return true;
3670 : }
3671 :
3672 0 : auto PContentBridgeChild::Write(
3673 : const UndefinedVariant& v__,
3674 : Message* msg__) -> void
3675 : {
3676 0 : }
3677 :
3678 0 : auto PContentBridgeChild::Read(
3679 : UndefinedVariant* v__,
3680 : const Message* msg__,
3681 : PickleIterator* iter__) -> bool
3682 : {
3683 0 : return true;
3684 : }
3685 :
3686 0 : auto PContentBridgeChild::Write(
3687 : const MultiplexInputStreamParams& v__,
3688 : Message* msg__) -> void
3689 : {
3690 0 : Write((v__).streams(), msg__);
3691 : // Sentinel = 'streams'
3692 0 : (msg__)->WriteSentinel(4240383220);
3693 0 : Write((v__).currentStream(), msg__);
3694 : // Sentinel = 'currentStream'
3695 0 : (msg__)->WriteSentinel(682778074);
3696 0 : Write((v__).status(), msg__);
3697 : // Sentinel = 'status'
3698 0 : (msg__)->WriteSentinel(3714608576);
3699 0 : Write((v__).startedReadingCurrent(), msg__);
3700 : // Sentinel = 'startedReadingCurrent'
3701 0 : (msg__)->WriteSentinel(970542033);
3702 0 : }
3703 :
3704 0 : auto PContentBridgeChild::Read(
3705 : MultiplexInputStreamParams* v__,
3706 : const Message* msg__,
3707 : PickleIterator* iter__) -> bool
3708 : {
3709 0 : if ((!(Read((&((v__)->streams())), msg__, iter__)))) {
3710 0 : FatalError("Error deserializing 'streams' (InputStreamParams[]) member of 'MultiplexInputStreamParams'");
3711 0 : return false;
3712 : }
3713 : // Sentinel = 'streams'
3714 0 : if ((!((msg__)->ReadSentinel(iter__, 4240383220)))) {
3715 0 : mozilla::ipc::SentinelReadError("Error deserializing 'streams' (InputStreamParams[]) member of 'MultiplexInputStreamParams'");
3716 0 : return false;
3717 : }
3718 0 : if ((!(Read((&((v__)->currentStream())), msg__, iter__)))) {
3719 0 : FatalError("Error deserializing 'currentStream' (uint32_t) member of 'MultiplexInputStreamParams'");
3720 0 : return false;
3721 : }
3722 : // Sentinel = 'currentStream'
3723 0 : if ((!((msg__)->ReadSentinel(iter__, 682778074)))) {
3724 0 : mozilla::ipc::SentinelReadError("Error deserializing 'currentStream' (uint32_t) member of 'MultiplexInputStreamParams'");
3725 0 : return false;
3726 : }
3727 0 : if ((!(Read((&((v__)->status())), msg__, iter__)))) {
3728 0 : FatalError("Error deserializing 'status' (nsresult) member of 'MultiplexInputStreamParams'");
3729 0 : return false;
3730 : }
3731 : // Sentinel = 'status'
3732 0 : if ((!((msg__)->ReadSentinel(iter__, 3714608576)))) {
3733 0 : mozilla::ipc::SentinelReadError("Error deserializing 'status' (nsresult) member of 'MultiplexInputStreamParams'");
3734 0 : return false;
3735 : }
3736 0 : if ((!(Read((&((v__)->startedReadingCurrent())), msg__, iter__)))) {
3737 0 : FatalError("Error deserializing 'startedReadingCurrent' (bool) member of 'MultiplexInputStreamParams'");
3738 0 : return false;
3739 : }
3740 : // Sentinel = 'startedReadingCurrent'
3741 0 : if ((!((msg__)->ReadSentinel(iter__, 970542033)))) {
3742 0 : mozilla::ipc::SentinelReadError("Error deserializing 'startedReadingCurrent' (bool) member of 'MultiplexInputStreamParams'");
3743 0 : return false;
3744 : }
3745 0 : return true;
3746 : }
3747 :
3748 0 : auto PContentBridgeChild::Write(
3749 : const PIPCBlobInputStreamChild* v__,
3750 : Message* msg__,
3751 : bool nullable__) -> void
3752 : {
3753 : int32_t id;
3754 0 : if ((!(v__))) {
3755 0 : if ((!(nullable__))) {
3756 0 : FatalError("NULL actor value passed to non-nullable param");
3757 : }
3758 0 : id = 0;
3759 : }
3760 : else {
3761 0 : id = (v__)->Id();
3762 0 : if ((1) == (id)) {
3763 0 : FatalError("actor has been |delete|d");
3764 : }
3765 : }
3766 :
3767 0 : Write(id, msg__);
3768 0 : }
3769 :
3770 0 : auto PContentBridgeChild::Read(
3771 : PIPCBlobInputStreamChild** v__,
3772 : const Message* msg__,
3773 : PickleIterator* iter__,
3774 : bool nullable__) -> bool
3775 : {
3776 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PIPCBlobInputStream", PIPCBlobInputStreamMsgStart);
3777 0 : if ((actor).isNothing()) {
3778 0 : return false;
3779 : }
3780 :
3781 0 : (*(v__)) = static_cast<PIPCBlobInputStreamChild*>((actor).value());
3782 0 : return true;
3783 : }
3784 :
3785 0 : auto PContentBridgeChild::Write(
3786 : const PBrowserChild* v__,
3787 : Message* msg__,
3788 : bool nullable__) -> void
3789 : {
3790 : int32_t id;
3791 0 : if ((!(v__))) {
3792 0 : if ((!(nullable__))) {
3793 0 : FatalError("NULL actor value passed to non-nullable param");
3794 : }
3795 0 : id = 0;
3796 : }
3797 : else {
3798 0 : id = (v__)->Id();
3799 0 : if ((1) == (id)) {
3800 0 : FatalError("actor has been |delete|d");
3801 : }
3802 : }
3803 :
3804 0 : Write(id, msg__);
3805 0 : }
3806 :
3807 0 : auto PContentBridgeChild::Read(
3808 : PBrowserChild** v__,
3809 : const Message* msg__,
3810 : PickleIterator* iter__,
3811 : bool nullable__) -> bool
3812 : {
3813 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PBrowser", PBrowserMsgStart);
3814 0 : if ((actor).isNothing()) {
3815 0 : return false;
3816 : }
3817 :
3818 0 : (*(v__)) = static_cast<PBrowserChild*>((actor).value());
3819 0 : return true;
3820 : }
3821 :
3822 0 : auto PContentBridgeChild::Write(
3823 : const OptionalFileDescriptorSet& v__,
3824 : Message* msg__) -> void
3825 : {
3826 : typedef OptionalFileDescriptorSet type__;
3827 0 : Write(int((v__).type()), msg__);
3828 : // Sentinel = 'OptionalFileDescriptorSet'
3829 0 : (msg__)->WriteSentinel(955222862);
3830 :
3831 0 : switch ((v__).type()) {
3832 : case type__::TPFileDescriptorSetParent:
3833 : {
3834 0 : FatalError("wrong side!");
3835 0 : return;
3836 : }
3837 : case type__::TPFileDescriptorSetChild:
3838 : {
3839 0 : Write((v__).get_PFileDescriptorSetChild(), msg__, false);
3840 : // Sentinel = 'TPFileDescriptorSetChild'
3841 0 : (msg__)->WriteSentinel(3477929935);
3842 0 : return;
3843 : }
3844 : case type__::TArrayOfFileDescriptor:
3845 : {
3846 0 : Write((v__).get_ArrayOfFileDescriptor(), msg__);
3847 : // Sentinel = 'TArrayOfFileDescriptor'
3848 0 : (msg__)->WriteSentinel(2366096715);
3849 0 : return;
3850 : }
3851 : case type__::Tvoid_t:
3852 : {
3853 0 : Write((v__).get_void_t(), msg__);
3854 : // Sentinel = 'Tvoid_t'
3855 0 : (msg__)->WriteSentinel(3041273328);
3856 0 : return;
3857 : }
3858 : default:
3859 : {
3860 0 : FatalError("unknown union type");
3861 0 : return;
3862 : }
3863 : }
3864 : }
3865 :
3866 0 : auto PContentBridgeChild::Read(
3867 : OptionalFileDescriptorSet* v__,
3868 : const Message* msg__,
3869 : PickleIterator* iter__) -> bool
3870 : {
3871 : typedef OptionalFileDescriptorSet type__;
3872 : int type;
3873 0 : if ((!(Read((&(type)), msg__, iter__)))) {
3874 0 : mozilla::ipc::UnionTypeReadError("OptionalFileDescriptorSet");
3875 0 : return false;
3876 : }
3877 : // Sentinel = 'OptionalFileDescriptorSet'
3878 0 : if ((!((msg__)->ReadSentinel(iter__, 955222862)))) {
3879 0 : mozilla::ipc::SentinelReadError("OptionalFileDescriptorSet");
3880 0 : return false;
3881 : }
3882 :
3883 0 : switch (type) {
3884 : case type__::TPFileDescriptorSetParent:
3885 : {
3886 0 : PFileDescriptorSetChild* tmp = nullptr;
3887 0 : (*(v__)) = tmp;
3888 0 : if ((!(Read((&((v__)->get_PFileDescriptorSetChild())), msg__, iter__, false)))) {
3889 0 : FatalError("Error deserializing Union type");
3890 0 : return false;
3891 : }
3892 : // Sentinel = 'TPFileDescriptorSetParent'
3893 0 : if ((!((msg__)->ReadSentinel(iter__, 143041934)))) {
3894 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3895 0 : return false;
3896 : }
3897 0 : return true;
3898 : }
3899 : case type__::TPFileDescriptorSetChild:
3900 : {
3901 0 : return false;
3902 : }
3903 : case type__::TArrayOfFileDescriptor:
3904 : {
3905 0 : nsTArray<FileDescriptor> tmp;
3906 0 : (*(v__)) = tmp;
3907 0 : if ((!(Read((&((v__)->get_ArrayOfFileDescriptor())), msg__, iter__)))) {
3908 0 : FatalError("Error deserializing Union type");
3909 0 : return false;
3910 : }
3911 : // Sentinel = 'TArrayOfFileDescriptor'
3912 0 : if ((!((msg__)->ReadSentinel(iter__, 2366096715)))) {
3913 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3914 0 : return false;
3915 : }
3916 0 : return true;
3917 : }
3918 : case type__::Tvoid_t:
3919 : {
3920 : void_t tmp = void_t();
3921 0 : (*(v__)) = tmp;
3922 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
3923 0 : FatalError("Error deserializing Union type");
3924 0 : return false;
3925 : }
3926 : // Sentinel = 'Tvoid_t'
3927 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
3928 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
3929 0 : return false;
3930 : }
3931 0 : return true;
3932 : }
3933 : default:
3934 : {
3935 0 : FatalError("unknown union type");
3936 0 : return false;
3937 : }
3938 : }
3939 : }
3940 :
3941 0 : auto PContentBridgeChild::Write(
3942 : const SymbolVariant& v__,
3943 : Message* msg__) -> void
3944 : {
3945 : typedef SymbolVariant type__;
3946 0 : Write(int((v__).type()), msg__);
3947 : // Sentinel = 'SymbolVariant'
3948 0 : (msg__)->WriteSentinel(2359697882);
3949 :
3950 0 : switch ((v__).type()) {
3951 : case type__::TWellKnownSymbol:
3952 : {
3953 0 : Write((v__).get_WellKnownSymbol(), msg__);
3954 : // Sentinel = 'TWellKnownSymbol'
3955 0 : (msg__)->WriteSentinel(3625871441);
3956 0 : return;
3957 : }
3958 : case type__::TRegisteredSymbol:
3959 : {
3960 0 : Write((v__).get_RegisteredSymbol(), msg__);
3961 : // Sentinel = 'TRegisteredSymbol'
3962 0 : (msg__)->WriteSentinel(3546540137);
3963 0 : return;
3964 : }
3965 : default:
3966 : {
3967 0 : FatalError("unknown union type");
3968 0 : return;
3969 : }
3970 : }
3971 : }
3972 :
3973 0 : auto PContentBridgeChild::Read(
3974 : SymbolVariant* v__,
3975 : const Message* msg__,
3976 : PickleIterator* iter__) -> bool
3977 : {
3978 : typedef SymbolVariant type__;
3979 : int type;
3980 0 : if ((!(Read((&(type)), msg__, iter__)))) {
3981 0 : mozilla::ipc::UnionTypeReadError("SymbolVariant");
3982 0 : return false;
3983 : }
3984 : // Sentinel = 'SymbolVariant'
3985 0 : if ((!((msg__)->ReadSentinel(iter__, 2359697882)))) {
3986 0 : mozilla::ipc::SentinelReadError("SymbolVariant");
3987 0 : return false;
3988 : }
3989 :
3990 0 : switch (type) {
3991 : case type__::TWellKnownSymbol:
3992 : {
3993 0 : WellKnownSymbol tmp = WellKnownSymbol();
3994 0 : (*(v__)) = tmp;
3995 0 : if ((!(Read((&((v__)->get_WellKnownSymbol())), msg__, iter__)))) {
3996 0 : FatalError("Error deserializing Union type");
3997 0 : return false;
3998 : }
3999 : // Sentinel = 'TWellKnownSymbol'
4000 0 : if ((!((msg__)->ReadSentinel(iter__, 3625871441)))) {
4001 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4002 0 : return false;
4003 : }
4004 0 : return true;
4005 : }
4006 : case type__::TRegisteredSymbol:
4007 : {
4008 0 : RegisteredSymbol tmp = RegisteredSymbol();
4009 0 : (*(v__)) = tmp;
4010 0 : if ((!(Read((&((v__)->get_RegisteredSymbol())), msg__, iter__)))) {
4011 0 : FatalError("Error deserializing Union type");
4012 0 : return false;
4013 : }
4014 : // Sentinel = 'TRegisteredSymbol'
4015 0 : if ((!((msg__)->ReadSentinel(iter__, 3546540137)))) {
4016 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4017 0 : return false;
4018 : }
4019 0 : return true;
4020 : }
4021 : default:
4022 : {
4023 0 : FatalError("unknown union type");
4024 0 : return false;
4025 : }
4026 : }
4027 : }
4028 :
4029 0 : auto PContentBridgeChild::Write(
4030 : const CpowEntry& v__,
4031 : Message* msg__) -> void
4032 : {
4033 0 : Write((v__).name(), msg__);
4034 : // Sentinel = 'name'
4035 0 : (msg__)->WriteSentinel(15034981);
4036 0 : Write((v__).value(), msg__);
4037 : // Sentinel = 'value'
4038 0 : (msg__)->WriteSentinel(3456818542);
4039 0 : }
4040 :
4041 0 : auto PContentBridgeChild::Read(
4042 : CpowEntry* v__,
4043 : const Message* msg__,
4044 : PickleIterator* iter__) -> bool
4045 : {
4046 0 : if ((!(Read((&((v__)->name())), msg__, iter__)))) {
4047 0 : FatalError("Error deserializing 'name' (nsString) member of 'CpowEntry'");
4048 0 : return false;
4049 : }
4050 : // Sentinel = 'name'
4051 0 : if ((!((msg__)->ReadSentinel(iter__, 15034981)))) {
4052 0 : mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'CpowEntry'");
4053 0 : return false;
4054 : }
4055 0 : if ((!(Read((&((v__)->value())), msg__, iter__)))) {
4056 0 : FatalError("Error deserializing 'value' (JSVariant) member of 'CpowEntry'");
4057 0 : return false;
4058 : }
4059 : // Sentinel = 'value'
4060 0 : if ((!((msg__)->ReadSentinel(iter__, 3456818542)))) {
4061 0 : mozilla::ipc::SentinelReadError("Error deserializing 'value' (JSVariant) member of 'CpowEntry'");
4062 0 : return false;
4063 : }
4064 0 : return true;
4065 : }
4066 :
4067 0 : auto PContentBridgeChild::Write(
4068 : const nsTArray<IPCStream>& v__,
4069 : Message* msg__) -> void
4070 : {
4071 0 : uint32_t length = (v__).Length();
4072 0 : Write(length, msg__);
4073 : // Sentinel = ('length', 'IPCStream[]')
4074 0 : (msg__)->WriteSentinel(790413678);
4075 :
4076 0 : for (auto& elem : v__) {
4077 0 : Write(elem, msg__);
4078 : // Sentinel = 'IPCStream[]'
4079 0 : (msg__)->WriteSentinel(117417041);
4080 : }
4081 0 : }
4082 :
4083 0 : auto PContentBridgeChild::Read(
4084 : nsTArray<IPCStream>* v__,
4085 : const Message* msg__,
4086 : PickleIterator* iter__) -> bool
4087 : {
4088 0 : nsTArray<IPCStream> fa;
4089 : uint32_t length;
4090 0 : if ((!(Read((&(length)), msg__, iter__)))) {
4091 0 : mozilla::ipc::ArrayLengthReadError("IPCStream[]");
4092 0 : return false;
4093 : }
4094 : // Sentinel = ('length', 'IPCStream[]')
4095 0 : if ((!((msg__)->ReadSentinel(iter__, 790413678)))) {
4096 0 : mozilla::ipc::SentinelReadError("IPCStream[]");
4097 0 : return false;
4098 : }
4099 :
4100 0 : IPCStream* elems = (fa).AppendElements(length);
4101 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
4102 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
4103 0 : FatalError("Error deserializing 'IPCStream[i]'");
4104 0 : return false;
4105 : }
4106 : // Sentinel = 'IPCStream[]'
4107 0 : if ((!((msg__)->ReadSentinel(iter__, 117417041)))) {
4108 0 : mozilla::ipc::SentinelReadError("Error deserializing 'IPCStream[i]'");
4109 0 : return false;
4110 : }
4111 : }
4112 0 : (v__)->SwapElements(fa);
4113 0 : return true;
4114 : }
4115 :
4116 0 : auto PContentBridgeChild::Write(
4117 : const IPCBlob& v__,
4118 : Message* msg__) -> void
4119 : {
4120 0 : Write((v__).type(), msg__);
4121 : // Sentinel = 'type'
4122 0 : (msg__)->WriteSentinel(2982068540);
4123 0 : Write((v__).size(), msg__);
4124 : // Sentinel = 'size'
4125 0 : (msg__)->WriteSentinel(931048223);
4126 0 : Write((v__).inputStream(), msg__);
4127 : // Sentinel = 'inputStream'
4128 0 : (msg__)->WriteSentinel(2684883823);
4129 0 : Write((v__).file(), msg__);
4130 : // Sentinel = 'file'
4131 0 : (msg__)->WriteSentinel(224874390);
4132 0 : Write((v__).fileId(), msg__);
4133 : // Sentinel = 'fileId'
4134 0 : (msg__)->WriteSentinel(108004447);
4135 0 : }
4136 :
4137 0 : auto PContentBridgeChild::Read(
4138 : IPCBlob* v__,
4139 : const Message* msg__,
4140 : PickleIterator* iter__) -> bool
4141 : {
4142 0 : if ((!(Read((&((v__)->type())), msg__, iter__)))) {
4143 0 : FatalError("Error deserializing 'type' (nsString) member of 'IPCBlob'");
4144 0 : return false;
4145 : }
4146 : // Sentinel = 'type'
4147 0 : if ((!((msg__)->ReadSentinel(iter__, 2982068540)))) {
4148 0 : mozilla::ipc::SentinelReadError("Error deserializing 'type' (nsString) member of 'IPCBlob'");
4149 0 : return false;
4150 : }
4151 0 : if ((!(Read((&((v__)->size())), msg__, iter__)))) {
4152 0 : FatalError("Error deserializing 'size' (uint64_t) member of 'IPCBlob'");
4153 0 : return false;
4154 : }
4155 : // Sentinel = 'size'
4156 0 : if ((!((msg__)->ReadSentinel(iter__, 931048223)))) {
4157 0 : mozilla::ipc::SentinelReadError("Error deserializing 'size' (uint64_t) member of 'IPCBlob'");
4158 0 : return false;
4159 : }
4160 0 : if ((!(Read((&((v__)->inputStream())), msg__, iter__)))) {
4161 0 : FatalError("Error deserializing 'inputStream' (IPCBlobStream) member of 'IPCBlob'");
4162 0 : return false;
4163 : }
4164 : // Sentinel = 'inputStream'
4165 0 : if ((!((msg__)->ReadSentinel(iter__, 2684883823)))) {
4166 0 : mozilla::ipc::SentinelReadError("Error deserializing 'inputStream' (IPCBlobStream) member of 'IPCBlob'");
4167 0 : return false;
4168 : }
4169 0 : if ((!(Read((&((v__)->file())), msg__, iter__)))) {
4170 0 : FatalError("Error deserializing 'file' (IPCFileUnion) member of 'IPCBlob'");
4171 0 : return false;
4172 : }
4173 : // Sentinel = 'file'
4174 0 : if ((!((msg__)->ReadSentinel(iter__, 224874390)))) {
4175 0 : mozilla::ipc::SentinelReadError("Error deserializing 'file' (IPCFileUnion) member of 'IPCBlob'");
4176 0 : return false;
4177 : }
4178 0 : if ((!(Read((&((v__)->fileId())), msg__, iter__)))) {
4179 0 : FatalError("Error deserializing 'fileId' (int64_t) member of 'IPCBlob'");
4180 0 : return false;
4181 : }
4182 : // Sentinel = 'fileId'
4183 0 : if ((!((msg__)->ReadSentinel(iter__, 108004447)))) {
4184 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fileId' (int64_t) member of 'IPCBlob'");
4185 0 : return false;
4186 : }
4187 0 : return true;
4188 : }
4189 :
4190 0 : auto PContentBridgeChild::Write(
4191 : const PParentToChildStreamChild* v__,
4192 : Message* msg__,
4193 : bool nullable__) -> void
4194 : {
4195 : int32_t id;
4196 0 : if ((!(v__))) {
4197 0 : if ((!(nullable__))) {
4198 0 : FatalError("NULL actor value passed to non-nullable param");
4199 : }
4200 0 : id = 0;
4201 : }
4202 : else {
4203 0 : id = (v__)->Id();
4204 0 : if ((1) == (id)) {
4205 0 : FatalError("actor has been |delete|d");
4206 : }
4207 : }
4208 :
4209 0 : Write(id, msg__);
4210 0 : }
4211 :
4212 0 : auto PContentBridgeChild::Read(
4213 : PParentToChildStreamChild** v__,
4214 : const Message* msg__,
4215 : PickleIterator* iter__,
4216 : bool nullable__) -> bool
4217 : {
4218 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PParentToChildStream", PParentToChildStreamMsgStart);
4219 0 : if ((actor).isNothing()) {
4220 0 : return false;
4221 : }
4222 :
4223 0 : (*(v__)) = static_cast<PParentToChildStreamChild*>((actor).value());
4224 0 : return true;
4225 : }
4226 :
4227 0 : auto PContentBridgeChild::Write(
4228 : const BufferedInputStreamParams& v__,
4229 : Message* msg__) -> void
4230 : {
4231 0 : Write((v__).optionalStream(), msg__);
4232 : // Sentinel = 'optionalStream'
4233 0 : (msg__)->WriteSentinel(1003718562);
4234 0 : Write((v__).bufferSize(), msg__);
4235 : // Sentinel = 'bufferSize'
4236 0 : (msg__)->WriteSentinel(3444538779);
4237 0 : }
4238 :
4239 0 : auto PContentBridgeChild::Read(
4240 : BufferedInputStreamParams* v__,
4241 : const Message* msg__,
4242 : PickleIterator* iter__) -> bool
4243 : {
4244 0 : if ((!(Read((&((v__)->optionalStream())), msg__, iter__)))) {
4245 0 : FatalError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'BufferedInputStreamParams'");
4246 0 : return false;
4247 : }
4248 : // Sentinel = 'optionalStream'
4249 0 : if ((!((msg__)->ReadSentinel(iter__, 1003718562)))) {
4250 0 : mozilla::ipc::SentinelReadError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'BufferedInputStreamParams'");
4251 0 : return false;
4252 : }
4253 0 : if ((!(Read((&((v__)->bufferSize())), msg__, iter__)))) {
4254 0 : FatalError("Error deserializing 'bufferSize' (uint32_t) member of 'BufferedInputStreamParams'");
4255 0 : return false;
4256 : }
4257 : // Sentinel = 'bufferSize'
4258 0 : if ((!((msg__)->ReadSentinel(iter__, 3444538779)))) {
4259 0 : mozilla::ipc::SentinelReadError("Error deserializing 'bufferSize' (uint32_t) member of 'BufferedInputStreamParams'");
4260 0 : return false;
4261 : }
4262 0 : return true;
4263 : }
4264 :
4265 0 : auto PContentBridgeChild::Write(
4266 : const NullVariant& v__,
4267 : Message* msg__) -> void
4268 : {
4269 0 : }
4270 :
4271 0 : auto PContentBridgeChild::Read(
4272 : NullVariant* v__,
4273 : const Message* msg__,
4274 : PickleIterator* iter__) -> bool
4275 : {
4276 0 : return true;
4277 : }
4278 :
4279 0 : auto PContentBridgeChild::Write(
4280 : const HeaderEntry& v__,
4281 : Message* msg__) -> void
4282 : {
4283 0 : Write((v__).name(), msg__);
4284 : // Sentinel = 'name'
4285 0 : (msg__)->WriteSentinel(15034981);
4286 0 : Write((v__).value(), msg__);
4287 : // Sentinel = 'value'
4288 0 : (msg__)->WriteSentinel(3456818542);
4289 0 : }
4290 :
4291 0 : auto PContentBridgeChild::Read(
4292 : HeaderEntry* v__,
4293 : const Message* msg__,
4294 : PickleIterator* iter__) -> bool
4295 : {
4296 0 : if ((!(Read((&((v__)->name())), msg__, iter__)))) {
4297 0 : FatalError("Error deserializing 'name' (nsCString) member of 'HeaderEntry'");
4298 0 : return false;
4299 : }
4300 : // Sentinel = 'name'
4301 0 : if ((!((msg__)->ReadSentinel(iter__, 15034981)))) {
4302 0 : mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsCString) member of 'HeaderEntry'");
4303 0 : return false;
4304 : }
4305 0 : if ((!(Read((&((v__)->value())), msg__, iter__)))) {
4306 0 : FatalError("Error deserializing 'value' (nsCString) member of 'HeaderEntry'");
4307 0 : return false;
4308 : }
4309 : // Sentinel = 'value'
4310 0 : if ((!((msg__)->ReadSentinel(iter__, 3456818542)))) {
4311 0 : mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsCString) member of 'HeaderEntry'");
4312 0 : return false;
4313 : }
4314 0 : return true;
4315 : }
4316 :
4317 0 : auto PContentBridgeChild::Write(
4318 : const IPCTabContext& v__,
4319 : Message* msg__) -> void
4320 : {
4321 : typedef IPCTabContext type__;
4322 0 : Write(int((v__).type()), msg__);
4323 : // Sentinel = 'IPCTabContext'
4324 0 : (msg__)->WriteSentinel(506037529);
4325 :
4326 0 : switch ((v__).type()) {
4327 : case type__::TPopupIPCTabContext:
4328 : {
4329 0 : Write((v__).get_PopupIPCTabContext(), msg__);
4330 : // Sentinel = 'TPopupIPCTabContext'
4331 0 : (msg__)->WriteSentinel(4038668053);
4332 0 : return;
4333 : }
4334 : case type__::TFrameIPCTabContext:
4335 : {
4336 0 : Write((v__).get_FrameIPCTabContext(), msg__);
4337 : // Sentinel = 'TFrameIPCTabContext'
4338 0 : (msg__)->WriteSentinel(4211766306);
4339 0 : return;
4340 : }
4341 : case type__::TJSPluginFrameIPCTabContext:
4342 : {
4343 0 : Write((v__).get_JSPluginFrameIPCTabContext(), msg__);
4344 : // Sentinel = 'TJSPluginFrameIPCTabContext'
4345 0 : (msg__)->WriteSentinel(953478246);
4346 0 : return;
4347 : }
4348 : case type__::TUnsafeIPCTabContext:
4349 : {
4350 0 : Write((v__).get_UnsafeIPCTabContext(), msg__);
4351 : // Sentinel = 'TUnsafeIPCTabContext'
4352 0 : (msg__)->WriteSentinel(152883886);
4353 0 : return;
4354 : }
4355 : default:
4356 : {
4357 0 : FatalError("unknown union type");
4358 0 : return;
4359 : }
4360 : }
4361 : }
4362 :
4363 0 : auto PContentBridgeChild::Read(
4364 : IPCTabContext* v__,
4365 : const Message* msg__,
4366 : PickleIterator* iter__) -> bool
4367 : {
4368 : typedef IPCTabContext type__;
4369 : int type;
4370 0 : if ((!(Read((&(type)), msg__, iter__)))) {
4371 0 : mozilla::ipc::UnionTypeReadError("IPCTabContext");
4372 0 : return false;
4373 : }
4374 : // Sentinel = 'IPCTabContext'
4375 0 : if ((!((msg__)->ReadSentinel(iter__, 506037529)))) {
4376 0 : mozilla::ipc::SentinelReadError("IPCTabContext");
4377 0 : return false;
4378 : }
4379 :
4380 0 : switch (type) {
4381 : case type__::TPopupIPCTabContext:
4382 : {
4383 0 : PopupIPCTabContext tmp = PopupIPCTabContext();
4384 0 : (*(v__)) = tmp;
4385 0 : if ((!(Read((&((v__)->get_PopupIPCTabContext())), msg__, iter__)))) {
4386 0 : FatalError("Error deserializing Union type");
4387 0 : return false;
4388 : }
4389 : // Sentinel = 'TPopupIPCTabContext'
4390 0 : if ((!((msg__)->ReadSentinel(iter__, 4038668053)))) {
4391 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4392 0 : return false;
4393 : }
4394 0 : return true;
4395 : }
4396 : case type__::TFrameIPCTabContext:
4397 : {
4398 0 : FrameIPCTabContext tmp = FrameIPCTabContext();
4399 0 : (*(v__)) = tmp;
4400 0 : if ((!(Read((&((v__)->get_FrameIPCTabContext())), msg__, iter__)))) {
4401 0 : FatalError("Error deserializing Union type");
4402 0 : return false;
4403 : }
4404 : // Sentinel = 'TFrameIPCTabContext'
4405 0 : if ((!((msg__)->ReadSentinel(iter__, 4211766306)))) {
4406 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4407 0 : return false;
4408 : }
4409 0 : return true;
4410 : }
4411 : case type__::TJSPluginFrameIPCTabContext:
4412 : {
4413 0 : JSPluginFrameIPCTabContext tmp = JSPluginFrameIPCTabContext();
4414 0 : (*(v__)) = tmp;
4415 0 : if ((!(Read((&((v__)->get_JSPluginFrameIPCTabContext())), msg__, iter__)))) {
4416 0 : FatalError("Error deserializing Union type");
4417 0 : return false;
4418 : }
4419 : // Sentinel = 'TJSPluginFrameIPCTabContext'
4420 0 : if ((!((msg__)->ReadSentinel(iter__, 953478246)))) {
4421 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4422 0 : return false;
4423 : }
4424 0 : return true;
4425 : }
4426 : case type__::TUnsafeIPCTabContext:
4427 : {
4428 0 : UnsafeIPCTabContext tmp = UnsafeIPCTabContext();
4429 0 : (*(v__)) = tmp;
4430 0 : if ((!(Read((&((v__)->get_UnsafeIPCTabContext())), msg__, iter__)))) {
4431 0 : FatalError("Error deserializing Union type");
4432 0 : return false;
4433 : }
4434 : // Sentinel = 'TUnsafeIPCTabContext'
4435 0 : if ((!((msg__)->ReadSentinel(iter__, 152883886)))) {
4436 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
4437 0 : return false;
4438 : }
4439 0 : return true;
4440 : }
4441 : default:
4442 : {
4443 0 : FatalError("unknown union type");
4444 0 : return false;
4445 : }
4446 : }
4447 : }
4448 :
4449 0 : auto PContentBridgeChild::Write(
4450 : const PChildToParentStreamChild* v__,
4451 : Message* msg__,
4452 : bool nullable__) -> void
4453 : {
4454 : int32_t id;
4455 0 : if ((!(v__))) {
4456 0 : if ((!(nullable__))) {
4457 0 : FatalError("NULL actor value passed to non-nullable param");
4458 : }
4459 0 : id = 0;
4460 : }
4461 : else {
4462 0 : id = (v__)->Id();
4463 0 : if ((1) == (id)) {
4464 0 : FatalError("actor has been |delete|d");
4465 : }
4466 : }
4467 :
4468 0 : Write(id, msg__);
4469 0 : }
4470 :
4471 0 : auto PContentBridgeChild::Read(
4472 : PChildToParentStreamChild** v__,
4473 : const Message* msg__,
4474 : PickleIterator* iter__,
4475 : bool nullable__) -> bool
4476 : {
4477 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PChildToParentStream", PChildToParentStreamMsgStart);
4478 0 : if ((actor).isNothing()) {
4479 0 : return false;
4480 : }
4481 :
4482 0 : (*(v__)) = static_cast<PChildToParentStreamChild*>((actor).value());
4483 0 : return true;
4484 : }
4485 :
4486 0 : auto PContentBridgeChild::Write(
4487 : const PJavaScriptChild* v__,
4488 : Message* msg__,
4489 : bool nullable__) -> void
4490 : {
4491 : int32_t id;
4492 0 : if ((!(v__))) {
4493 0 : if ((!(nullable__))) {
4494 0 : FatalError("NULL actor value passed to non-nullable param");
4495 : }
4496 0 : id = 0;
4497 : }
4498 : else {
4499 0 : id = (v__)->Id();
4500 0 : if ((1) == (id)) {
4501 0 : FatalError("actor has been |delete|d");
4502 : }
4503 : }
4504 :
4505 0 : Write(id, msg__);
4506 0 : }
4507 :
4508 0 : auto PContentBridgeChild::Read(
4509 : PJavaScriptChild** v__,
4510 : const Message* msg__,
4511 : PickleIterator* iter__,
4512 : bool nullable__) -> bool
4513 : {
4514 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PJavaScript", PJavaScriptMsgStart);
4515 0 : if ((actor).isNothing()) {
4516 0 : return false;
4517 : }
4518 :
4519 0 : (*(v__)) = static_cast<PJavaScriptChild*>((actor).value());
4520 0 : return true;
4521 : }
4522 :
4523 :
4524 :
4525 : } // namespace dom
4526 : } // namespace mozilla
|
