Line data Source code
1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 :
7 : #include "mozilla/dom/PBroadcastChannelChild.h"
8 : #include "ipc/IPCMessageUtils.h"
9 :
10 : #include "mozilla/ipc/PBackgroundChild.h"
11 : #include "mozilla/ipc/PChildToParentStreamChild.h"
12 : #include "mozilla/ipc/PFileDescriptorSetChild.h"
13 : #include "mozilla/ipc/PIPCBlobInputStreamChild.h"
14 : #include "mozilla/ipc/PParentToChildStreamChild.h"
15 :
16 : #include "nsIFile.h"
17 : #include "GeckoProfiler.h"
18 :
19 : namespace mozilla {
20 : namespace dom {
21 :
22 :
23 0 : auto PBroadcastChannelChild::Recv__delete__() -> mozilla::ipc::IPCResult
24 : {
25 0 : return IPC_OK();
26 : }
27 :
28 0 : auto PBroadcastChannelChild::ActorDestroy(ActorDestroyReason aWhy) -> void
29 : {
30 0 : }
31 :
32 0 : MOZ_IMPLICIT PBroadcastChannelChild::PBroadcastChannelChild() :
33 : mozilla::ipc::IProtocol(mozilla::ipc::ChildSide),
34 0 : mState(PBroadcastChannel::__Dead)
35 : {
36 0 : MOZ_COUNT_CTOR(PBroadcastChannelChild);
37 0 : }
38 :
39 0 : PBroadcastChannelChild::~PBroadcastChannelChild()
40 : {
41 0 : MOZ_COUNT_DTOR(PBroadcastChannelChild);
42 0 : }
43 :
44 0 : auto PBroadcastChannelChild::Manager() const -> PBackgroundChild*
45 : {
46 0 : return static_cast<PBackgroundChild*>(IProtocol::Manager());
47 : }
48 :
49 0 : auto PBroadcastChannelChild::SendPostMessage(const ClonedMessageData& message) -> bool
50 : {
51 0 : IPC::Message* msg__ = PBroadcastChannel::Msg_PostMessage(Id());
52 :
53 0 : Write(message, msg__);
54 : // Sentinel = 'message'
55 0 : (msg__)->WriteSentinel(1366108954);
56 :
57 :
58 :
59 :
60 0 : if (mozilla::ipc::LoggingEnabledFor("PBroadcastChannelChild")) {
61 0 : mozilla::ipc::LogMessageForProtocol("PBroadcastChannelChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
62 : }
63 0 : AUTO_PROFILER_LABEL("PBroadcastChannel::Msg_PostMessage", OTHER);
64 0 : PBroadcastChannel::Transition(PBroadcastChannel::Msg_PostMessage__ID, (&(mState)));
65 :
66 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
67 0 : return sendok__;
68 : }
69 :
70 0 : auto PBroadcastChannelChild::SendClose() -> bool
71 : {
72 0 : IPC::Message* msg__ = PBroadcastChannel::Msg_Close(Id());
73 :
74 :
75 :
76 :
77 :
78 0 : if (mozilla::ipc::LoggingEnabledFor("PBroadcastChannelChild")) {
79 0 : mozilla::ipc::LogMessageForProtocol("PBroadcastChannelChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
80 : }
81 0 : AUTO_PROFILER_LABEL("PBroadcastChannel::Msg_Close", OTHER);
82 0 : PBroadcastChannel::Transition(PBroadcastChannel::Msg_Close__ID, (&(mState)));
83 :
84 0 : bool sendok__ = (GetIPCChannel())->Send(msg__);
85 0 : return sendok__;
86 : }
87 :
88 0 : auto PBroadcastChannelChild::RemoveManagee(
89 : int32_t aProtocolId,
90 : ProtocolBase* aListener) -> void
91 : {
92 0 : FatalError("unreached");
93 0 : return;
94 : }
95 :
96 0 : auto PBroadcastChannelChild::OnMessageReceived(const Message& msg__) -> PBroadcastChannelChild::Result
97 : {
98 0 : switch ((msg__).type()) {
99 : case PBroadcastChannel::Msg_Notify__ID:
100 : {
101 0 : if (mozilla::ipc::LoggingEnabledFor("PBroadcastChannelChild")) {
102 0 : mozilla::ipc::LogMessageForProtocol("PBroadcastChannelChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
103 : }
104 0 : AUTO_PROFILER_LABEL("PBroadcastChannel::Msg_Notify", OTHER);
105 :
106 0 : PickleIterator iter__(msg__);
107 0 : ClonedMessageData message;
108 :
109 0 : if ((!(Read((&(message)), (&(msg__)), (&(iter__)))))) {
110 0 : FatalError("Error deserializing 'ClonedMessageData'");
111 0 : return MsgValueError;
112 : }
113 : // Sentinel = 'message'
114 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1366108954)))) {
115 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData'");
116 0 : return MsgValueError;
117 : }
118 0 : (msg__).EndRead(iter__, (msg__).type());
119 0 : PBroadcastChannel::Transition(PBroadcastChannel::Msg_Notify__ID, (&(mState)));
120 0 : if ((!(RecvNotify(mozilla::Move(message))))) {
121 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
122 : // Error handled in mozilla::ipc::IPCResult
123 0 : return MsgProcessingError;
124 : }
125 :
126 0 : return MsgProcessed;
127 : }
128 : case PBroadcastChannel::Msg___delete____ID:
129 : {
130 0 : if (mozilla::ipc::LoggingEnabledFor("PBroadcastChannelChild")) {
131 0 : mozilla::ipc::LogMessageForProtocol("PBroadcastChannelChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
132 : }
133 0 : AUTO_PROFILER_LABEL("PBroadcastChannel::Msg___delete__", OTHER);
134 :
135 0 : PickleIterator iter__(msg__);
136 : PBroadcastChannelChild* actor;
137 :
138 0 : if ((!(Read((&(actor)), (&(msg__)), (&(iter__)), false)))) {
139 0 : FatalError("Error deserializing 'PBroadcastChannelChild'");
140 0 : return MsgValueError;
141 : }
142 : // Sentinel = 'actor'
143 0 : if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
144 0 : mozilla::ipc::SentinelReadError("Error deserializing 'PBroadcastChannelChild'");
145 0 : return MsgValueError;
146 : }
147 0 : (msg__).EndRead(iter__, (msg__).type());
148 0 : PBroadcastChannel::Transition(PBroadcastChannel::Msg___delete____ID, (&(mState)));
149 0 : if ((!(Recv__delete__()))) {
150 0 : mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
151 : // Error handled in mozilla::ipc::IPCResult
152 0 : return MsgProcessingError;
153 : }
154 :
155 :
156 0 : IProtocol* mgr = (actor)->Manager();
157 0 : (actor)->DestroySubtree(Deletion);
158 0 : (actor)->DeallocSubtree();
159 0 : (mgr)->RemoveManagee(PBroadcastChannelMsgStart, actor);
160 :
161 0 : return MsgProcessed;
162 : }
163 : default:
164 : {
165 0 : return MsgNotKnown;
166 : }
167 : }
168 : }
169 :
170 0 : auto PBroadcastChannelChild::OnMessageReceived(
171 : const Message& msg__,
172 : Message*& reply__) -> PBroadcastChannelChild::Result
173 : {
174 0 : return MsgNotKnown;
175 : }
176 :
177 0 : auto PBroadcastChannelChild::OnCallReceived(
178 : const Message& msg__,
179 : Message*& reply__) -> PBroadcastChannelChild::Result
180 : {
181 0 : MOZ_ASSERT_UNREACHABLE("message protocol not supported");
182 : return MsgNotKnown;
183 : }
184 :
185 0 : auto PBroadcastChannelChild::GetProtocolTypeId() -> int32_t
186 : {
187 0 : return PBroadcastChannelMsgStart;
188 : }
189 :
190 0 : auto PBroadcastChannelChild::ProtocolName() const -> const char*
191 : {
192 0 : return "PBroadcastChannelChild";
193 : }
194 :
195 0 : auto PBroadcastChannelChild::DestroySubtree(ActorDestroyReason why) -> void
196 : {
197 : // Unregister from our manager.
198 0 : Unregister(Id());
199 :
200 : // Reject owning pending promises.
201 0 : (GetIPCChannel())->RejectPendingPromisesForActor(this);
202 :
203 : // Finally, destroy "us".
204 0 : ActorDestroy(why);
205 0 : }
206 :
207 0 : auto PBroadcastChannelChild::DeallocSubtree() -> void
208 : {
209 0 : }
210 :
211 0 : auto PBroadcastChannelChild::Write(
212 : const nsTArray<InputStreamParams>& v__,
213 : Message* msg__) -> void
214 : {
215 0 : uint32_t length = (v__).Length();
216 0 : Write(length, msg__);
217 : // Sentinel = ('length', 'InputStreamParams[]')
218 0 : (msg__)->WriteSentinel(348334258);
219 :
220 0 : for (auto& elem : v__) {
221 0 : Write(elem, msg__);
222 : // Sentinel = 'InputStreamParams[]'
223 0 : (msg__)->WriteSentinel(2927715197);
224 : }
225 0 : }
226 :
227 0 : auto PBroadcastChannelChild::Read(
228 : nsTArray<InputStreamParams>* v__,
229 : const Message* msg__,
230 : PickleIterator* iter__) -> bool
231 : {
232 0 : nsTArray<InputStreamParams> fa;
233 : uint32_t length;
234 0 : if ((!(Read((&(length)), msg__, iter__)))) {
235 0 : mozilla::ipc::ArrayLengthReadError("InputStreamParams[]");
236 0 : return false;
237 : }
238 : // Sentinel = ('length', 'InputStreamParams[]')
239 0 : if ((!((msg__)->ReadSentinel(iter__, 348334258)))) {
240 0 : mozilla::ipc::SentinelReadError("InputStreamParams[]");
241 0 : return false;
242 : }
243 :
244 0 : InputStreamParams* elems = (fa).AppendElements(length);
245 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
246 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
247 0 : FatalError("Error deserializing 'InputStreamParams[i]'");
248 0 : return false;
249 : }
250 : // Sentinel = 'InputStreamParams[]'
251 0 : if ((!((msg__)->ReadSentinel(iter__, 2927715197)))) {
252 0 : mozilla::ipc::SentinelReadError("Error deserializing 'InputStreamParams[i]'");
253 0 : return false;
254 : }
255 : }
256 0 : (v__)->SwapElements(fa);
257 0 : return true;
258 : }
259 :
260 0 : auto PBroadcastChannelChild::Write(
261 : const nsTArray<FileDescriptor>& v__,
262 : Message* msg__) -> void
263 : {
264 0 : uint32_t length = (v__).Length();
265 0 : Write(length, msg__);
266 : // Sentinel = ('length', 'FileDescriptor[]')
267 0 : (msg__)->WriteSentinel(1697726450);
268 :
269 0 : for (auto& elem : v__) {
270 0 : Write(elem, msg__);
271 : // Sentinel = 'FileDescriptor[]'
272 0 : (msg__)->WriteSentinel(1630221245);
273 : }
274 0 : }
275 :
276 0 : auto PBroadcastChannelChild::Read(
277 : nsTArray<FileDescriptor>* v__,
278 : const Message* msg__,
279 : PickleIterator* iter__) -> bool
280 : {
281 0 : nsTArray<FileDescriptor> fa;
282 : uint32_t length;
283 0 : if ((!(Read((&(length)), msg__, iter__)))) {
284 0 : mozilla::ipc::ArrayLengthReadError("FileDescriptor[]");
285 0 : return false;
286 : }
287 : // Sentinel = ('length', 'FileDescriptor[]')
288 0 : if ((!((msg__)->ReadSentinel(iter__, 1697726450)))) {
289 0 : mozilla::ipc::SentinelReadError("FileDescriptor[]");
290 0 : return false;
291 : }
292 :
293 0 : FileDescriptor* elems = (fa).AppendElements(length);
294 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
295 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
296 0 : FatalError("Error deserializing 'FileDescriptor[i]'");
297 0 : return false;
298 : }
299 : // Sentinel = 'FileDescriptor[]'
300 0 : if ((!((msg__)->ReadSentinel(iter__, 1630221245)))) {
301 0 : mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor[i]'");
302 0 : return false;
303 : }
304 : }
305 0 : (v__)->SwapElements(fa);
306 0 : return true;
307 : }
308 :
309 0 : auto PBroadcastChannelChild::Write(
310 : const nsTArray<MessagePortIdentifier>& v__,
311 : Message* msg__) -> void
312 : {
313 0 : uint32_t length = (v__).Length();
314 0 : Write(length, msg__);
315 : // Sentinel = ('length', 'MessagePortIdentifier[]')
316 0 : (msg__)->WriteSentinel(680130807);
317 :
318 0 : for (auto& elem : v__) {
319 0 : Write(elem, msg__);
320 : // Sentinel = 'MessagePortIdentifier[]'
321 0 : (msg__)->WriteSentinel(1200404786);
322 : }
323 0 : }
324 :
325 0 : auto PBroadcastChannelChild::Read(
326 : nsTArray<MessagePortIdentifier>* v__,
327 : const Message* msg__,
328 : PickleIterator* iter__) -> bool
329 : {
330 0 : nsTArray<MessagePortIdentifier> fa;
331 : uint32_t length;
332 0 : if ((!(Read((&(length)), msg__, iter__)))) {
333 0 : mozilla::ipc::ArrayLengthReadError("MessagePortIdentifier[]");
334 0 : return false;
335 : }
336 : // Sentinel = ('length', 'MessagePortIdentifier[]')
337 0 : if ((!((msg__)->ReadSentinel(iter__, 680130807)))) {
338 0 : mozilla::ipc::SentinelReadError("MessagePortIdentifier[]");
339 0 : return false;
340 : }
341 :
342 0 : MessagePortIdentifier* elems = (fa).AppendElements(length);
343 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
344 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
345 0 : FatalError("Error deserializing 'MessagePortIdentifier[i]'");
346 0 : return false;
347 : }
348 : // Sentinel = 'MessagePortIdentifier[]'
349 0 : if ((!((msg__)->ReadSentinel(iter__, 1200404786)))) {
350 0 : mozilla::ipc::SentinelReadError("Error deserializing 'MessagePortIdentifier[i]'");
351 0 : return false;
352 : }
353 : }
354 0 : (v__)->SwapElements(fa);
355 0 : return true;
356 : }
357 :
358 0 : auto PBroadcastChannelChild::Write(
359 : const OptionalInputStreamParams& v__,
360 : Message* msg__) -> void
361 : {
362 : typedef OptionalInputStreamParams type__;
363 0 : Write(int((v__).type()), msg__);
364 : // Sentinel = 'OptionalInputStreamParams'
365 0 : (msg__)->WriteSentinel(1355174443);
366 :
367 0 : switch ((v__).type()) {
368 : case type__::Tvoid_t:
369 : {
370 0 : Write((v__).get_void_t(), msg__);
371 : // Sentinel = 'Tvoid_t'
372 0 : (msg__)->WriteSentinel(3041273328);
373 0 : return;
374 : }
375 : case type__::TInputStreamParams:
376 : {
377 0 : Write((v__).get_InputStreamParams(), msg__);
378 : // Sentinel = 'TInputStreamParams'
379 0 : (msg__)->WriteSentinel(55652096);
380 0 : return;
381 : }
382 : default:
383 : {
384 0 : FatalError("unknown union type");
385 0 : return;
386 : }
387 : }
388 : }
389 :
390 0 : auto PBroadcastChannelChild::Read(
391 : OptionalInputStreamParams* v__,
392 : const Message* msg__,
393 : PickleIterator* iter__) -> bool
394 : {
395 : typedef OptionalInputStreamParams type__;
396 : int type;
397 0 : if ((!(Read((&(type)), msg__, iter__)))) {
398 0 : mozilla::ipc::UnionTypeReadError("OptionalInputStreamParams");
399 0 : return false;
400 : }
401 : // Sentinel = 'OptionalInputStreamParams'
402 0 : if ((!((msg__)->ReadSentinel(iter__, 1355174443)))) {
403 0 : mozilla::ipc::SentinelReadError("OptionalInputStreamParams");
404 0 : return false;
405 : }
406 :
407 0 : switch (type) {
408 : case type__::Tvoid_t:
409 : {
410 : void_t tmp = void_t();
411 0 : (*(v__)) = tmp;
412 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
413 0 : FatalError("Error deserializing Union type");
414 0 : return false;
415 : }
416 : // Sentinel = 'Tvoid_t'
417 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
418 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
419 0 : return false;
420 : }
421 0 : return true;
422 : }
423 : case type__::TInputStreamParams:
424 : {
425 0 : InputStreamParams tmp = InputStreamParams();
426 0 : (*(v__)) = tmp;
427 0 : if ((!(Read((&((v__)->get_InputStreamParams())), msg__, iter__)))) {
428 0 : FatalError("Error deserializing Union type");
429 0 : return false;
430 : }
431 : // Sentinel = 'TInputStreamParams'
432 0 : if ((!((msg__)->ReadSentinel(iter__, 55652096)))) {
433 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
434 0 : return false;
435 : }
436 0 : return true;
437 : }
438 : default:
439 : {
440 0 : FatalError("unknown union type");
441 0 : return false;
442 : }
443 : }
444 : }
445 :
446 0 : auto PBroadcastChannelChild::Write(
447 : const IPCRemoteStream& v__,
448 : Message* msg__) -> void
449 : {
450 0 : Write((v__).delayedStart(), msg__);
451 : // Sentinel = 'delayedStart'
452 0 : (msg__)->WriteSentinel(1491822294);
453 0 : Write((v__).stream(), msg__);
454 : // Sentinel = 'stream'
455 0 : (msg__)->WriteSentinel(4152748422);
456 0 : }
457 :
458 0 : auto PBroadcastChannelChild::Read(
459 : IPCRemoteStream* v__,
460 : const Message* msg__,
461 : PickleIterator* iter__) -> bool
462 : {
463 0 : if ((!(Read((&((v__)->delayedStart())), msg__, iter__)))) {
464 0 : FatalError("Error deserializing 'delayedStart' (bool) member of 'IPCRemoteStream'");
465 0 : return false;
466 : }
467 : // Sentinel = 'delayedStart'
468 0 : if ((!((msg__)->ReadSentinel(iter__, 1491822294)))) {
469 0 : mozilla::ipc::SentinelReadError("Error deserializing 'delayedStart' (bool) member of 'IPCRemoteStream'");
470 0 : return false;
471 : }
472 0 : if ((!(Read((&((v__)->stream())), msg__, iter__)))) {
473 0 : FatalError("Error deserializing 'stream' (IPCRemoteStreamType) member of 'IPCRemoteStream'");
474 0 : return false;
475 : }
476 : // Sentinel = 'stream'
477 0 : if ((!((msg__)->ReadSentinel(iter__, 4152748422)))) {
478 0 : mozilla::ipc::SentinelReadError("Error deserializing 'stream' (IPCRemoteStreamType) member of 'IPCRemoteStream'");
479 0 : return false;
480 : }
481 0 : return true;
482 : }
483 :
484 0 : auto PBroadcastChannelChild::Write(
485 : const FileInputStreamParams& v__,
486 : Message* msg__) -> void
487 : {
488 0 : Write((v__).fileDescriptorIndex(), msg__);
489 : // Sentinel = 'fileDescriptorIndex'
490 0 : (msg__)->WriteSentinel(587329112);
491 0 : Write((v__).behaviorFlags(), msg__);
492 : // Sentinel = 'behaviorFlags'
493 0 : (msg__)->WriteSentinel(2404401962);
494 0 : Write((v__).ioFlags(), msg__);
495 : // Sentinel = 'ioFlags'
496 0 : (msg__)->WriteSentinel(1483009730);
497 0 : }
498 :
499 0 : auto PBroadcastChannelChild::Read(
500 : FileInputStreamParams* v__,
501 : const Message* msg__,
502 : PickleIterator* iter__) -> bool
503 : {
504 0 : if ((!(Read((&((v__)->fileDescriptorIndex())), msg__, iter__)))) {
505 0 : FatalError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'FileInputStreamParams'");
506 0 : return false;
507 : }
508 : // Sentinel = 'fileDescriptorIndex'
509 0 : if ((!((msg__)->ReadSentinel(iter__, 587329112)))) {
510 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'FileInputStreamParams'");
511 0 : return false;
512 : }
513 0 : if ((!(Read((&((v__)->behaviorFlags())), msg__, iter__)))) {
514 0 : FatalError("Error deserializing 'behaviorFlags' (int32_t) member of 'FileInputStreamParams'");
515 0 : return false;
516 : }
517 : // Sentinel = 'behaviorFlags'
518 0 : if ((!((msg__)->ReadSentinel(iter__, 2404401962)))) {
519 0 : mozilla::ipc::SentinelReadError("Error deserializing 'behaviorFlags' (int32_t) member of 'FileInputStreamParams'");
520 0 : return false;
521 : }
522 0 : if ((!(Read((&((v__)->ioFlags())), msg__, iter__)))) {
523 0 : FatalError("Error deserializing 'ioFlags' (int32_t) member of 'FileInputStreamParams'");
524 0 : return false;
525 : }
526 : // Sentinel = 'ioFlags'
527 0 : if ((!((msg__)->ReadSentinel(iter__, 1483009730)))) {
528 0 : mozilla::ipc::SentinelReadError("Error deserializing 'ioFlags' (int32_t) member of 'FileInputStreamParams'");
529 0 : return false;
530 : }
531 0 : return true;
532 : }
533 :
534 0 : auto PBroadcastChannelChild::Write(
535 : const IPCBlobInputStreamParams& v__,
536 : Message* msg__) -> void
537 : {
538 0 : Write((v__).id(), msg__);
539 : // Sentinel = 'id'
540 0 : (msg__)->WriteSentinel(2794505629);
541 0 : }
542 :
543 0 : auto PBroadcastChannelChild::Read(
544 : IPCBlobInputStreamParams* v__,
545 : const Message* msg__,
546 : PickleIterator* iter__) -> bool
547 : {
548 0 : if ((!(Read((&((v__)->id())), msg__, iter__)))) {
549 0 : FatalError("Error deserializing 'id' (nsID) member of 'IPCBlobInputStreamParams'");
550 0 : return false;
551 : }
552 : // Sentinel = 'id'
553 0 : if ((!((msg__)->ReadSentinel(iter__, 2794505629)))) {
554 0 : mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsID) member of 'IPCBlobInputStreamParams'");
555 0 : return false;
556 : }
557 0 : return true;
558 : }
559 :
560 0 : auto PBroadcastChannelChild::Write(
561 : const IPCFile& v__,
562 : Message* msg__) -> void
563 : {
564 0 : Write((v__).name(), msg__);
565 : // Sentinel = 'name'
566 0 : (msg__)->WriteSentinel(15034981);
567 0 : Write((v__).lastModified(), msg__);
568 : // Sentinel = 'lastModified'
569 0 : (msg__)->WriteSentinel(3456113257);
570 0 : Write((v__).DOMPath(), msg__);
571 : // Sentinel = 'DOMPath'
572 0 : (msg__)->WriteSentinel(1724352494);
573 0 : Write((v__).fullPath(), msg__);
574 : // Sentinel = 'fullPath'
575 0 : (msg__)->WriteSentinel(385652698);
576 0 : Write((v__).isDirectory(), msg__);
577 : // Sentinel = 'isDirectory'
578 0 : (msg__)->WriteSentinel(2309743506);
579 0 : }
580 :
581 0 : auto PBroadcastChannelChild::Read(
582 : IPCFile* v__,
583 : const Message* msg__,
584 : PickleIterator* iter__) -> bool
585 : {
586 0 : if ((!(Read((&((v__)->name())), msg__, iter__)))) {
587 0 : FatalError("Error deserializing 'name' (nsString) member of 'IPCFile'");
588 0 : return false;
589 : }
590 : // Sentinel = 'name'
591 0 : if ((!((msg__)->ReadSentinel(iter__, 15034981)))) {
592 0 : mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'IPCFile'");
593 0 : return false;
594 : }
595 0 : if ((!(Read((&((v__)->lastModified())), msg__, iter__)))) {
596 0 : FatalError("Error deserializing 'lastModified' (int64_t) member of 'IPCFile'");
597 0 : return false;
598 : }
599 : // Sentinel = 'lastModified'
600 0 : if ((!((msg__)->ReadSentinel(iter__, 3456113257)))) {
601 0 : mozilla::ipc::SentinelReadError("Error deserializing 'lastModified' (int64_t) member of 'IPCFile'");
602 0 : return false;
603 : }
604 0 : if ((!(Read((&((v__)->DOMPath())), msg__, iter__)))) {
605 0 : FatalError("Error deserializing 'DOMPath' (nsString) member of 'IPCFile'");
606 0 : return false;
607 : }
608 : // Sentinel = 'DOMPath'
609 0 : if ((!((msg__)->ReadSentinel(iter__, 1724352494)))) {
610 0 : mozilla::ipc::SentinelReadError("Error deserializing 'DOMPath' (nsString) member of 'IPCFile'");
611 0 : return false;
612 : }
613 0 : if ((!(Read((&((v__)->fullPath())), msg__, iter__)))) {
614 0 : FatalError("Error deserializing 'fullPath' (nsString) member of 'IPCFile'");
615 0 : return false;
616 : }
617 : // Sentinel = 'fullPath'
618 0 : if ((!((msg__)->ReadSentinel(iter__, 385652698)))) {
619 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fullPath' (nsString) member of 'IPCFile'");
620 0 : return false;
621 : }
622 0 : if ((!(Read((&((v__)->isDirectory())), msg__, iter__)))) {
623 0 : FatalError("Error deserializing 'isDirectory' (bool) member of 'IPCFile'");
624 0 : return false;
625 : }
626 : // Sentinel = 'isDirectory'
627 0 : if ((!((msg__)->ReadSentinel(iter__, 2309743506)))) {
628 0 : mozilla::ipc::SentinelReadError("Error deserializing 'isDirectory' (bool) member of 'IPCFile'");
629 0 : return false;
630 : }
631 0 : return true;
632 : }
633 :
634 0 : auto PBroadcastChannelChild::Write(
635 : const IPCFileUnion& v__,
636 : Message* msg__) -> void
637 : {
638 : typedef IPCFileUnion type__;
639 0 : Write(int((v__).type()), msg__);
640 : // Sentinel = 'IPCFileUnion'
641 0 : (msg__)->WriteSentinel(1913022529);
642 :
643 0 : switch ((v__).type()) {
644 : case type__::Tvoid_t:
645 : {
646 0 : Write((v__).get_void_t(), msg__);
647 : // Sentinel = 'Tvoid_t'
648 0 : (msg__)->WriteSentinel(3041273328);
649 0 : return;
650 : }
651 : case type__::TIPCFile:
652 : {
653 0 : Write((v__).get_IPCFile(), msg__);
654 : // Sentinel = 'TIPCFile'
655 0 : (msg__)->WriteSentinel(3562676876);
656 0 : return;
657 : }
658 : default:
659 : {
660 0 : FatalError("unknown union type");
661 0 : return;
662 : }
663 : }
664 : }
665 :
666 0 : auto PBroadcastChannelChild::Read(
667 : IPCFileUnion* v__,
668 : const Message* msg__,
669 : PickleIterator* iter__) -> bool
670 : {
671 : typedef IPCFileUnion type__;
672 : int type;
673 0 : if ((!(Read((&(type)), msg__, iter__)))) {
674 0 : mozilla::ipc::UnionTypeReadError("IPCFileUnion");
675 0 : return false;
676 : }
677 : // Sentinel = 'IPCFileUnion'
678 0 : if ((!((msg__)->ReadSentinel(iter__, 1913022529)))) {
679 0 : mozilla::ipc::SentinelReadError("IPCFileUnion");
680 0 : return false;
681 : }
682 :
683 0 : switch (type) {
684 : case type__::Tvoid_t:
685 : {
686 : void_t tmp = void_t();
687 0 : (*(v__)) = tmp;
688 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
689 0 : FatalError("Error deserializing Union type");
690 0 : return false;
691 : }
692 : // Sentinel = 'Tvoid_t'
693 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
694 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
695 0 : return false;
696 : }
697 0 : return true;
698 : }
699 : case type__::TIPCFile:
700 : {
701 0 : IPCFile tmp = IPCFile();
702 0 : (*(v__)) = tmp;
703 0 : if ((!(Read((&((v__)->get_IPCFile())), msg__, iter__)))) {
704 0 : FatalError("Error deserializing Union type");
705 0 : return false;
706 : }
707 : // Sentinel = 'TIPCFile'
708 0 : if ((!((msg__)->ReadSentinel(iter__, 3562676876)))) {
709 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
710 0 : return false;
711 : }
712 0 : return true;
713 : }
714 : default:
715 : {
716 0 : FatalError("unknown union type");
717 0 : return false;
718 : }
719 : }
720 : }
721 :
722 0 : auto PBroadcastChannelChild::Write(
723 : const MessagePortIdentifier& v__,
724 : Message* msg__) -> void
725 : {
726 0 : Write((v__).uuid(), msg__);
727 : // Sentinel = 'uuid'
728 0 : (msg__)->WriteSentinel(1982267941);
729 0 : Write((v__).destinationUuid(), msg__);
730 : // Sentinel = 'destinationUuid'
731 0 : (msg__)->WriteSentinel(372087918);
732 0 : Write((v__).sequenceId(), msg__);
733 : // Sentinel = 'sequenceId'
734 0 : (msg__)->WriteSentinel(2743535618);
735 0 : Write((v__).neutered(), msg__);
736 : // Sentinel = 'neutered'
737 0 : (msg__)->WriteSentinel(520678014);
738 0 : }
739 :
740 0 : auto PBroadcastChannelChild::Read(
741 : MessagePortIdentifier* v__,
742 : const Message* msg__,
743 : PickleIterator* iter__) -> bool
744 : {
745 0 : if ((!(Read((&((v__)->uuid())), msg__, iter__)))) {
746 0 : FatalError("Error deserializing 'uuid' (nsID) member of 'MessagePortIdentifier'");
747 0 : return false;
748 : }
749 : // Sentinel = 'uuid'
750 0 : if ((!((msg__)->ReadSentinel(iter__, 1982267941)))) {
751 0 : mozilla::ipc::SentinelReadError("Error deserializing 'uuid' (nsID) member of 'MessagePortIdentifier'");
752 0 : return false;
753 : }
754 0 : if ((!(Read((&((v__)->destinationUuid())), msg__, iter__)))) {
755 0 : FatalError("Error deserializing 'destinationUuid' (nsID) member of 'MessagePortIdentifier'");
756 0 : return false;
757 : }
758 : // Sentinel = 'destinationUuid'
759 0 : if ((!((msg__)->ReadSentinel(iter__, 372087918)))) {
760 0 : mozilla::ipc::SentinelReadError("Error deserializing 'destinationUuid' (nsID) member of 'MessagePortIdentifier'");
761 0 : return false;
762 : }
763 0 : if ((!(Read((&((v__)->sequenceId())), msg__, iter__)))) {
764 0 : FatalError("Error deserializing 'sequenceId' (uint32_t) member of 'MessagePortIdentifier'");
765 0 : return false;
766 : }
767 : // Sentinel = 'sequenceId'
768 0 : if ((!((msg__)->ReadSentinel(iter__, 2743535618)))) {
769 0 : mozilla::ipc::SentinelReadError("Error deserializing 'sequenceId' (uint32_t) member of 'MessagePortIdentifier'");
770 0 : return false;
771 : }
772 0 : if ((!(Read((&((v__)->neutered())), msg__, iter__)))) {
773 0 : FatalError("Error deserializing 'neutered' (bool) member of 'MessagePortIdentifier'");
774 0 : return false;
775 : }
776 : // Sentinel = 'neutered'
777 0 : if ((!((msg__)->ReadSentinel(iter__, 520678014)))) {
778 0 : mozilla::ipc::SentinelReadError("Error deserializing 'neutered' (bool) member of 'MessagePortIdentifier'");
779 0 : return false;
780 : }
781 0 : return true;
782 : }
783 :
784 0 : auto PBroadcastChannelChild::Write(
785 : const InputStreamParamsWithFds& v__,
786 : Message* msg__) -> void
787 : {
788 0 : Write((v__).stream(), msg__);
789 : // Sentinel = 'stream'
790 0 : (msg__)->WriteSentinel(4152748422);
791 0 : Write((v__).optionalFds(), msg__);
792 : // Sentinel = 'optionalFds'
793 0 : (msg__)->WriteSentinel(1021803302);
794 0 : }
795 :
796 0 : auto PBroadcastChannelChild::Read(
797 : InputStreamParamsWithFds* v__,
798 : const Message* msg__,
799 : PickleIterator* iter__) -> bool
800 : {
801 0 : if ((!(Read((&((v__)->stream())), msg__, iter__)))) {
802 0 : FatalError("Error deserializing 'stream' (InputStreamParams) member of 'InputStreamParamsWithFds'");
803 0 : return false;
804 : }
805 : // Sentinel = 'stream'
806 0 : if ((!((msg__)->ReadSentinel(iter__, 4152748422)))) {
807 0 : mozilla::ipc::SentinelReadError("Error deserializing 'stream' (InputStreamParams) member of 'InputStreamParamsWithFds'");
808 0 : return false;
809 : }
810 0 : if ((!(Read((&((v__)->optionalFds())), msg__, iter__)))) {
811 0 : FatalError("Error deserializing 'optionalFds' (OptionalFileDescriptorSet) member of 'InputStreamParamsWithFds'");
812 0 : return false;
813 : }
814 : // Sentinel = 'optionalFds'
815 0 : if ((!((msg__)->ReadSentinel(iter__, 1021803302)))) {
816 0 : mozilla::ipc::SentinelReadError("Error deserializing 'optionalFds' (OptionalFileDescriptorSet) member of 'InputStreamParamsWithFds'");
817 0 : return false;
818 : }
819 0 : return true;
820 : }
821 :
822 0 : auto PBroadcastChannelChild::Write(
823 : const IPCBlobStream& v__,
824 : Message* msg__) -> void
825 : {
826 : typedef IPCBlobStream type__;
827 0 : Write(int((v__).type()), msg__);
828 : // Sentinel = 'IPCBlobStream'
829 0 : (msg__)->WriteSentinel(2926762354);
830 :
831 0 : switch ((v__).type()) {
832 : case type__::TPIPCBlobInputStreamParent:
833 : {
834 0 : FatalError("wrong side!");
835 0 : return;
836 : }
837 : case type__::TPIPCBlobInputStreamChild:
838 : {
839 0 : Write((v__).get_PIPCBlobInputStreamChild(), msg__, false);
840 : // Sentinel = 'TPIPCBlobInputStreamChild'
841 0 : (msg__)->WriteSentinel(3349556844);
842 0 : return;
843 : }
844 : case type__::TIPCStream:
845 : {
846 0 : Write((v__).get_IPCStream(), msg__);
847 : // Sentinel = 'TIPCStream'
848 0 : (msg__)->WriteSentinel(40701900);
849 0 : return;
850 : }
851 : default:
852 : {
853 0 : FatalError("unknown union type");
854 0 : return;
855 : }
856 : }
857 : }
858 :
859 0 : auto PBroadcastChannelChild::Read(
860 : IPCBlobStream* v__,
861 : const Message* msg__,
862 : PickleIterator* iter__) -> bool
863 : {
864 : typedef IPCBlobStream type__;
865 : int type;
866 0 : if ((!(Read((&(type)), msg__, iter__)))) {
867 0 : mozilla::ipc::UnionTypeReadError("IPCBlobStream");
868 0 : return false;
869 : }
870 : // Sentinel = 'IPCBlobStream'
871 0 : if ((!((msg__)->ReadSentinel(iter__, 2926762354)))) {
872 0 : mozilla::ipc::SentinelReadError("IPCBlobStream");
873 0 : return false;
874 : }
875 :
876 0 : switch (type) {
877 : case type__::TPIPCBlobInputStreamParent:
878 : {
879 0 : PIPCBlobInputStreamChild* tmp = nullptr;
880 0 : (*(v__)) = tmp;
881 0 : if ((!(Read((&((v__)->get_PIPCBlobInputStreamChild())), msg__, iter__, false)))) {
882 0 : FatalError("Error deserializing Union type");
883 0 : return false;
884 : }
885 : // Sentinel = 'TPIPCBlobInputStreamParent'
886 0 : if ((!((msg__)->ReadSentinel(iter__, 2944059743)))) {
887 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
888 0 : return false;
889 : }
890 0 : return true;
891 : }
892 : case type__::TPIPCBlobInputStreamChild:
893 : {
894 0 : return false;
895 : }
896 : case type__::TIPCStream:
897 : {
898 0 : IPCStream tmp = IPCStream();
899 0 : (*(v__)) = tmp;
900 0 : if ((!(Read((&((v__)->get_IPCStream())), msg__, iter__)))) {
901 0 : FatalError("Error deserializing Union type");
902 0 : return false;
903 : }
904 : // Sentinel = 'TIPCStream'
905 0 : if ((!((msg__)->ReadSentinel(iter__, 40701900)))) {
906 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
907 0 : return false;
908 : }
909 0 : return true;
910 : }
911 : default:
912 : {
913 0 : FatalError("unknown union type");
914 0 : return false;
915 : }
916 : }
917 : }
918 :
919 0 : auto PBroadcastChannelChild::Write(
920 : const nsTArray<IPCBlob>& v__,
921 : Message* msg__) -> void
922 : {
923 0 : uint32_t length = (v__).Length();
924 0 : Write(length, msg__);
925 : // Sentinel = ('length', 'IPCBlob[]')
926 0 : (msg__)->WriteSentinel(894413667);
927 :
928 0 : for (auto& elem : v__) {
929 0 : Write(elem, msg__);
930 : // Sentinel = 'IPCBlob[]'
931 0 : (msg__)->WriteSentinel(3337464726);
932 : }
933 0 : }
934 :
935 0 : auto PBroadcastChannelChild::Read(
936 : nsTArray<IPCBlob>* v__,
937 : const Message* msg__,
938 : PickleIterator* iter__) -> bool
939 : {
940 0 : nsTArray<IPCBlob> fa;
941 : uint32_t length;
942 0 : if ((!(Read((&(length)), msg__, iter__)))) {
943 0 : mozilla::ipc::ArrayLengthReadError("IPCBlob[]");
944 0 : return false;
945 : }
946 : // Sentinel = ('length', 'IPCBlob[]')
947 0 : if ((!((msg__)->ReadSentinel(iter__, 894413667)))) {
948 0 : mozilla::ipc::SentinelReadError("IPCBlob[]");
949 0 : return false;
950 : }
951 :
952 0 : IPCBlob* elems = (fa).AppendElements(length);
953 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
954 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
955 0 : FatalError("Error deserializing 'IPCBlob[i]'");
956 0 : return false;
957 : }
958 : // Sentinel = 'IPCBlob[]'
959 0 : if ((!((msg__)->ReadSentinel(iter__, 3337464726)))) {
960 0 : mozilla::ipc::SentinelReadError("Error deserializing 'IPCBlob[i]'");
961 0 : return false;
962 : }
963 : }
964 0 : (v__)->SwapElements(fa);
965 0 : return true;
966 : }
967 :
968 0 : auto PBroadcastChannelChild::Write(
969 : const ClonedMessageData& v__,
970 : Message* msg__) -> void
971 : {
972 0 : Write((v__).data(), msg__);
973 : // Sentinel = 'data'
974 0 : (msg__)->WriteSentinel(843352540);
975 0 : Write((v__).blobs(), msg__);
976 : // Sentinel = 'blobs'
977 0 : (msg__)->WriteSentinel(635500709);
978 0 : Write((v__).inputStreams(), msg__);
979 : // Sentinel = 'inputStreams'
980 0 : (msg__)->WriteSentinel(435739475);
981 0 : Write((v__).identfiers(), msg__);
982 : // Sentinel = 'identfiers'
983 0 : (msg__)->WriteSentinel(3130566733);
984 0 : }
985 :
986 0 : auto PBroadcastChannelChild::Read(
987 : ClonedMessageData* v__,
988 : const Message* msg__,
989 : PickleIterator* iter__) -> bool
990 : {
991 0 : if ((!(Read((&((v__)->data())), msg__, iter__)))) {
992 0 : FatalError("Error deserializing 'data' (SerializedStructuredCloneBuffer) member of 'ClonedMessageData'");
993 0 : return false;
994 : }
995 : // Sentinel = 'data'
996 0 : if ((!((msg__)->ReadSentinel(iter__, 843352540)))) {
997 0 : mozilla::ipc::SentinelReadError("Error deserializing 'data' (SerializedStructuredCloneBuffer) member of 'ClonedMessageData'");
998 0 : return false;
999 : }
1000 0 : if ((!(Read((&((v__)->blobs())), msg__, iter__)))) {
1001 0 : FatalError("Error deserializing 'blobs' (IPCBlob[]) member of 'ClonedMessageData'");
1002 0 : return false;
1003 : }
1004 : // Sentinel = 'blobs'
1005 0 : if ((!((msg__)->ReadSentinel(iter__, 635500709)))) {
1006 0 : mozilla::ipc::SentinelReadError("Error deserializing 'blobs' (IPCBlob[]) member of 'ClonedMessageData'");
1007 0 : return false;
1008 : }
1009 0 : if ((!(Read((&((v__)->inputStreams())), msg__, iter__)))) {
1010 0 : FatalError("Error deserializing 'inputStreams' (IPCStream[]) member of 'ClonedMessageData'");
1011 0 : return false;
1012 : }
1013 : // Sentinel = 'inputStreams'
1014 0 : if ((!((msg__)->ReadSentinel(iter__, 435739475)))) {
1015 0 : mozilla::ipc::SentinelReadError("Error deserializing 'inputStreams' (IPCStream[]) member of 'ClonedMessageData'");
1016 0 : return false;
1017 : }
1018 0 : if ((!(Read((&((v__)->identfiers())), msg__, iter__)))) {
1019 0 : FatalError("Error deserializing 'identfiers' (MessagePortIdentifier[]) member of 'ClonedMessageData'");
1020 0 : return false;
1021 : }
1022 : // Sentinel = 'identfiers'
1023 0 : if ((!((msg__)->ReadSentinel(iter__, 3130566733)))) {
1024 0 : mozilla::ipc::SentinelReadError("Error deserializing 'identfiers' (MessagePortIdentifier[]) member of 'ClonedMessageData'");
1025 0 : return false;
1026 : }
1027 0 : return true;
1028 : }
1029 :
1030 0 : auto PBroadcastChannelChild::Write(
1031 : const nsTArray<HeaderEntry>& v__,
1032 : Message* msg__) -> void
1033 : {
1034 0 : uint32_t length = (v__).Length();
1035 0 : Write(length, msg__);
1036 : // Sentinel = ('length', 'HeaderEntry[]')
1037 0 : (msg__)->WriteSentinel(2689457705);
1038 :
1039 0 : for (auto& elem : v__) {
1040 0 : Write(elem, msg__);
1041 : // Sentinel = 'HeaderEntry[]'
1042 0 : (msg__)->WriteSentinel(454836120);
1043 : }
1044 0 : }
1045 :
1046 0 : auto PBroadcastChannelChild::Read(
1047 : nsTArray<HeaderEntry>* v__,
1048 : const Message* msg__,
1049 : PickleIterator* iter__) -> bool
1050 : {
1051 0 : nsTArray<HeaderEntry> fa;
1052 : uint32_t length;
1053 0 : if ((!(Read((&(length)), msg__, iter__)))) {
1054 0 : mozilla::ipc::ArrayLengthReadError("HeaderEntry[]");
1055 0 : return false;
1056 : }
1057 : // Sentinel = ('length', 'HeaderEntry[]')
1058 0 : if ((!((msg__)->ReadSentinel(iter__, 2689457705)))) {
1059 0 : mozilla::ipc::SentinelReadError("HeaderEntry[]");
1060 0 : return false;
1061 : }
1062 :
1063 0 : HeaderEntry* elems = (fa).AppendElements(length);
1064 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
1065 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
1066 0 : FatalError("Error deserializing 'HeaderEntry[i]'");
1067 0 : return false;
1068 : }
1069 : // Sentinel = 'HeaderEntry[]'
1070 0 : if ((!((msg__)->ReadSentinel(iter__, 454836120)))) {
1071 0 : mozilla::ipc::SentinelReadError("Error deserializing 'HeaderEntry[i]'");
1072 0 : return false;
1073 : }
1074 : }
1075 0 : (v__)->SwapElements(fa);
1076 0 : return true;
1077 : }
1078 :
1079 0 : auto PBroadcastChannelChild::Write(
1080 : const SlicedInputStreamParams& v__,
1081 : Message* msg__) -> void
1082 : {
1083 0 : Write((v__).stream(), msg__);
1084 : // Sentinel = 'stream'
1085 0 : (msg__)->WriteSentinel(4152748422);
1086 0 : Write((v__).start(), msg__);
1087 : // Sentinel = 'start'
1088 0 : (msg__)->WriteSentinel(2088644401);
1089 0 : Write((v__).length(), msg__);
1090 : // Sentinel = 'length'
1091 0 : (msg__)->WriteSentinel(1726618354);
1092 0 : Write((v__).curPos(), msg__);
1093 : // Sentinel = 'curPos'
1094 0 : (msg__)->WriteSentinel(4042140974);
1095 0 : Write((v__).closed(), msg__);
1096 : // Sentinel = 'closed'
1097 0 : (msg__)->WriteSentinel(561249462);
1098 0 : }
1099 :
1100 0 : auto PBroadcastChannelChild::Read(
1101 : SlicedInputStreamParams* v__,
1102 : const Message* msg__,
1103 : PickleIterator* iter__) -> bool
1104 : {
1105 0 : if ((!(Read((&((v__)->stream())), msg__, iter__)))) {
1106 0 : FatalError("Error deserializing 'stream' (InputStreamParams) member of 'SlicedInputStreamParams'");
1107 0 : return false;
1108 : }
1109 : // Sentinel = 'stream'
1110 0 : if ((!((msg__)->ReadSentinel(iter__, 4152748422)))) {
1111 0 : mozilla::ipc::SentinelReadError("Error deserializing 'stream' (InputStreamParams) member of 'SlicedInputStreamParams'");
1112 0 : return false;
1113 : }
1114 0 : if ((!(Read((&((v__)->start())), msg__, iter__)))) {
1115 0 : FatalError("Error deserializing 'start' (uint64_t) member of 'SlicedInputStreamParams'");
1116 0 : return false;
1117 : }
1118 : // Sentinel = 'start'
1119 0 : if ((!((msg__)->ReadSentinel(iter__, 2088644401)))) {
1120 0 : mozilla::ipc::SentinelReadError("Error deserializing 'start' (uint64_t) member of 'SlicedInputStreamParams'");
1121 0 : return false;
1122 : }
1123 0 : if ((!(Read((&((v__)->length())), msg__, iter__)))) {
1124 0 : FatalError("Error deserializing 'length' (uint64_t) member of 'SlicedInputStreamParams'");
1125 0 : return false;
1126 : }
1127 : // Sentinel = 'length'
1128 0 : if ((!((msg__)->ReadSentinel(iter__, 1726618354)))) {
1129 0 : mozilla::ipc::SentinelReadError("Error deserializing 'length' (uint64_t) member of 'SlicedInputStreamParams'");
1130 0 : return false;
1131 : }
1132 0 : if ((!(Read((&((v__)->curPos())), msg__, iter__)))) {
1133 0 : FatalError("Error deserializing 'curPos' (uint64_t) member of 'SlicedInputStreamParams'");
1134 0 : return false;
1135 : }
1136 : // Sentinel = 'curPos'
1137 0 : if ((!((msg__)->ReadSentinel(iter__, 4042140974)))) {
1138 0 : mozilla::ipc::SentinelReadError("Error deserializing 'curPos' (uint64_t) member of 'SlicedInputStreamParams'");
1139 0 : return false;
1140 : }
1141 0 : if ((!(Read((&((v__)->closed())), msg__, iter__)))) {
1142 0 : FatalError("Error deserializing 'closed' (bool) member of 'SlicedInputStreamParams'");
1143 0 : return false;
1144 : }
1145 : // Sentinel = 'closed'
1146 0 : if ((!((msg__)->ReadSentinel(iter__, 561249462)))) {
1147 0 : mozilla::ipc::SentinelReadError("Error deserializing 'closed' (bool) member of 'SlicedInputStreamParams'");
1148 0 : return false;
1149 : }
1150 0 : return true;
1151 : }
1152 :
1153 0 : auto PBroadcastChannelChild::Write(
1154 : const IPCRemoteStreamType& v__,
1155 : Message* msg__) -> void
1156 : {
1157 : typedef IPCRemoteStreamType type__;
1158 0 : Write(int((v__).type()), msg__);
1159 : // Sentinel = 'IPCRemoteStreamType'
1160 0 : (msg__)->WriteSentinel(391674895);
1161 :
1162 0 : switch ((v__).type()) {
1163 : case type__::TPChildToParentStreamParent:
1164 : {
1165 0 : FatalError("wrong side!");
1166 0 : return;
1167 : }
1168 : case type__::TPChildToParentStreamChild:
1169 : {
1170 0 : Write((v__).get_PChildToParentStreamChild(), msg__, false);
1171 : // Sentinel = 'TPChildToParentStreamChild'
1172 0 : (msg__)->WriteSentinel(1882094295);
1173 0 : return;
1174 : }
1175 : case type__::TPParentToChildStreamParent:
1176 : {
1177 0 : FatalError("wrong side!");
1178 0 : return;
1179 : }
1180 : case type__::TPParentToChildStreamChild:
1181 : {
1182 0 : Write((v__).get_PParentToChildStreamChild(), msg__, false);
1183 : // Sentinel = 'TPParentToChildStreamChild'
1184 0 : (msg__)->WriteSentinel(190098493);
1185 0 : return;
1186 : }
1187 : default:
1188 : {
1189 0 : FatalError("unknown union type");
1190 0 : return;
1191 : }
1192 : }
1193 : }
1194 :
1195 0 : auto PBroadcastChannelChild::Read(
1196 : IPCRemoteStreamType* v__,
1197 : const Message* msg__,
1198 : PickleIterator* iter__) -> bool
1199 : {
1200 : typedef IPCRemoteStreamType type__;
1201 : int type;
1202 0 : if ((!(Read((&(type)), msg__, iter__)))) {
1203 0 : mozilla::ipc::UnionTypeReadError("IPCRemoteStreamType");
1204 0 : return false;
1205 : }
1206 : // Sentinel = 'IPCRemoteStreamType'
1207 0 : if ((!((msg__)->ReadSentinel(iter__, 391674895)))) {
1208 0 : mozilla::ipc::SentinelReadError("IPCRemoteStreamType");
1209 0 : return false;
1210 : }
1211 :
1212 0 : switch (type) {
1213 : case type__::TPChildToParentStreamParent:
1214 : {
1215 0 : PChildToParentStreamChild* tmp = nullptr;
1216 0 : (*(v__)) = tmp;
1217 0 : if ((!(Read((&((v__)->get_PChildToParentStreamChild())), msg__, iter__, false)))) {
1218 0 : FatalError("Error deserializing Union type");
1219 0 : return false;
1220 : }
1221 : // Sentinel = 'TPChildToParentStreamParent'
1222 0 : if ((!((msg__)->ReadSentinel(iter__, 2724777622)))) {
1223 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1224 0 : return false;
1225 : }
1226 0 : return true;
1227 : }
1228 : case type__::TPChildToParentStreamChild:
1229 : {
1230 0 : return false;
1231 : }
1232 : case type__::TPParentToChildStreamParent:
1233 : {
1234 0 : PParentToChildStreamChild* tmp = nullptr;
1235 0 : (*(v__)) = tmp;
1236 0 : if ((!(Read((&((v__)->get_PParentToChildStreamChild())), msg__, iter__, false)))) {
1237 0 : FatalError("Error deserializing Union type");
1238 0 : return false;
1239 : }
1240 : // Sentinel = 'TPParentToChildStreamParent'
1241 0 : if ((!((msg__)->ReadSentinel(iter__, 3335986876)))) {
1242 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1243 0 : return false;
1244 : }
1245 0 : return true;
1246 : }
1247 : case type__::TPParentToChildStreamChild:
1248 : {
1249 0 : return false;
1250 : }
1251 : default:
1252 : {
1253 0 : FatalError("unknown union type");
1254 0 : return false;
1255 : }
1256 : }
1257 : }
1258 :
1259 0 : auto PBroadcastChannelChild::Write(
1260 : const TemporaryFileInputStreamParams& v__,
1261 : Message* msg__) -> void
1262 : {
1263 0 : Write((v__).fileDescriptorIndex(), msg__);
1264 : // Sentinel = 'fileDescriptorIndex'
1265 0 : (msg__)->WriteSentinel(587329112);
1266 0 : Write((v__).startPos(), msg__);
1267 : // Sentinel = 'startPos'
1268 0 : (msg__)->WriteSentinel(557207962);
1269 0 : Write((v__).endPos(), msg__);
1270 : // Sentinel = 'endPos'
1271 0 : (msg__)->WriteSentinel(881536245);
1272 0 : }
1273 :
1274 0 : auto PBroadcastChannelChild::Read(
1275 : TemporaryFileInputStreamParams* v__,
1276 : const Message* msg__,
1277 : PickleIterator* iter__) -> bool
1278 : {
1279 0 : if ((!(Read((&((v__)->fileDescriptorIndex())), msg__, iter__)))) {
1280 0 : FatalError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'TemporaryFileInputStreamParams'");
1281 0 : return false;
1282 : }
1283 : // Sentinel = 'fileDescriptorIndex'
1284 0 : if ((!((msg__)->ReadSentinel(iter__, 587329112)))) {
1285 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fileDescriptorIndex' (uint32_t) member of 'TemporaryFileInputStreamParams'");
1286 0 : return false;
1287 : }
1288 0 : if ((!(Read((&((v__)->startPos())), msg__, iter__)))) {
1289 0 : FatalError("Error deserializing 'startPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
1290 0 : return false;
1291 : }
1292 : // Sentinel = 'startPos'
1293 0 : if ((!((msg__)->ReadSentinel(iter__, 557207962)))) {
1294 0 : mozilla::ipc::SentinelReadError("Error deserializing 'startPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
1295 0 : return false;
1296 : }
1297 0 : if ((!(Read((&((v__)->endPos())), msg__, iter__)))) {
1298 0 : FatalError("Error deserializing 'endPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
1299 0 : return false;
1300 : }
1301 : // Sentinel = 'endPos'
1302 0 : if ((!((msg__)->ReadSentinel(iter__, 881536245)))) {
1303 0 : mozilla::ipc::SentinelReadError("Error deserializing 'endPos' (uint64_t) member of 'TemporaryFileInputStreamParams'");
1304 0 : return false;
1305 : }
1306 0 : return true;
1307 : }
1308 :
1309 0 : auto PBroadcastChannelChild::Write(
1310 : const MIMEInputStreamParams& v__,
1311 : Message* msg__) -> void
1312 : {
1313 0 : Write((v__).optionalStream(), msg__);
1314 : // Sentinel = 'optionalStream'
1315 0 : (msg__)->WriteSentinel(1003718562);
1316 0 : Write((v__).headers(), msg__);
1317 : // Sentinel = 'headers'
1318 0 : (msg__)->WriteSentinel(4284175217);
1319 0 : Write((v__).startedReading(), msg__);
1320 : // Sentinel = 'startedReading'
1321 0 : (msg__)->WriteSentinel(1906875903);
1322 0 : }
1323 :
1324 0 : auto PBroadcastChannelChild::Read(
1325 : MIMEInputStreamParams* v__,
1326 : const Message* msg__,
1327 : PickleIterator* iter__) -> bool
1328 : {
1329 0 : if ((!(Read((&((v__)->optionalStream())), msg__, iter__)))) {
1330 0 : FatalError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'MIMEInputStreamParams'");
1331 0 : return false;
1332 : }
1333 : // Sentinel = 'optionalStream'
1334 0 : if ((!((msg__)->ReadSentinel(iter__, 1003718562)))) {
1335 0 : mozilla::ipc::SentinelReadError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'MIMEInputStreamParams'");
1336 0 : return false;
1337 : }
1338 0 : if ((!(Read((&((v__)->headers())), msg__, iter__)))) {
1339 0 : FatalError("Error deserializing 'headers' (HeaderEntry[]) member of 'MIMEInputStreamParams'");
1340 0 : return false;
1341 : }
1342 : // Sentinel = 'headers'
1343 0 : if ((!((msg__)->ReadSentinel(iter__, 4284175217)))) {
1344 0 : mozilla::ipc::SentinelReadError("Error deserializing 'headers' (HeaderEntry[]) member of 'MIMEInputStreamParams'");
1345 0 : return false;
1346 : }
1347 0 : if ((!(Read((&((v__)->startedReading())), msg__, iter__)))) {
1348 0 : FatalError("Error deserializing 'startedReading' (bool) member of 'MIMEInputStreamParams'");
1349 0 : return false;
1350 : }
1351 : // Sentinel = 'startedReading'
1352 0 : if ((!((msg__)->ReadSentinel(iter__, 1906875903)))) {
1353 0 : mozilla::ipc::SentinelReadError("Error deserializing 'startedReading' (bool) member of 'MIMEInputStreamParams'");
1354 0 : return false;
1355 : }
1356 0 : return true;
1357 : }
1358 :
1359 0 : auto PBroadcastChannelChild::Write(
1360 : const PBroadcastChannelChild* v__,
1361 : Message* msg__,
1362 : bool nullable__) -> void
1363 : {
1364 : int32_t id;
1365 0 : if ((!(v__))) {
1366 0 : if ((!(nullable__))) {
1367 0 : FatalError("NULL actor value passed to non-nullable param");
1368 : }
1369 0 : id = 0;
1370 : }
1371 : else {
1372 0 : id = (v__)->Id();
1373 0 : if ((1) == (id)) {
1374 0 : FatalError("actor has been |delete|d");
1375 : }
1376 : }
1377 :
1378 0 : Write(id, msg__);
1379 0 : }
1380 :
1381 0 : auto PBroadcastChannelChild::Read(
1382 : PBroadcastChannelChild** v__,
1383 : const Message* msg__,
1384 : PickleIterator* iter__,
1385 : bool nullable__) -> bool
1386 : {
1387 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PBroadcastChannel", PBroadcastChannelMsgStart);
1388 0 : if ((actor).isNothing()) {
1389 0 : return false;
1390 : }
1391 :
1392 0 : (*(v__)) = static_cast<PBroadcastChannelChild*>((actor).value());
1393 0 : return true;
1394 : }
1395 :
1396 0 : auto PBroadcastChannelChild::Write(
1397 : const InputStreamParams& v__,
1398 : Message* msg__) -> void
1399 : {
1400 : typedef InputStreamParams type__;
1401 0 : Write(int((v__).type()), msg__);
1402 : // Sentinel = 'InputStreamParams'
1403 0 : (msg__)->WriteSentinel(4114814015);
1404 :
1405 0 : switch ((v__).type()) {
1406 : case type__::TStringInputStreamParams:
1407 : {
1408 0 : Write((v__).get_StringInputStreamParams(), msg__);
1409 : // Sentinel = 'TStringInputStreamParams'
1410 0 : (msg__)->WriteSentinel(3395831651);
1411 0 : return;
1412 : }
1413 : case type__::TFileInputStreamParams:
1414 : {
1415 0 : Write((v__).get_FileInputStreamParams(), msg__);
1416 : // Sentinel = 'TFileInputStreamParams'
1417 0 : (msg__)->WriteSentinel(2543620282);
1418 0 : return;
1419 : }
1420 : case type__::TTemporaryFileInputStreamParams:
1421 : {
1422 0 : Write((v__).get_TemporaryFileInputStreamParams(), msg__);
1423 : // Sentinel = 'TTemporaryFileInputStreamParams'
1424 0 : (msg__)->WriteSentinel(587771548);
1425 0 : return;
1426 : }
1427 : case type__::TBufferedInputStreamParams:
1428 : {
1429 0 : Write((v__).get_BufferedInputStreamParams(), msg__);
1430 : // Sentinel = 'TBufferedInputStreamParams'
1431 0 : (msg__)->WriteSentinel(1698289307);
1432 0 : return;
1433 : }
1434 : case type__::TMIMEInputStreamParams:
1435 : {
1436 0 : Write((v__).get_MIMEInputStreamParams(), msg__);
1437 : // Sentinel = 'TMIMEInputStreamParams'
1438 0 : (msg__)->WriteSentinel(1948001964);
1439 0 : return;
1440 : }
1441 : case type__::TMultiplexInputStreamParams:
1442 : {
1443 0 : Write((v__).get_MultiplexInputStreamParams(), msg__);
1444 : // Sentinel = 'TMultiplexInputStreamParams'
1445 0 : (msg__)->WriteSentinel(3317853213);
1446 0 : return;
1447 : }
1448 : case type__::TSlicedInputStreamParams:
1449 : {
1450 0 : Write((v__).get_SlicedInputStreamParams(), msg__);
1451 : // Sentinel = 'TSlicedInputStreamParams'
1452 0 : (msg__)->WriteSentinel(445810472);
1453 0 : return;
1454 : }
1455 : case type__::TIPCBlobInputStreamParams:
1456 : {
1457 0 : Write((v__).get_IPCBlobInputStreamParams(), msg__);
1458 : // Sentinel = 'TIPCBlobInputStreamParams'
1459 0 : (msg__)->WriteSentinel(2436989998);
1460 0 : return;
1461 : }
1462 : default:
1463 : {
1464 0 : FatalError("unknown union type");
1465 0 : return;
1466 : }
1467 : }
1468 : }
1469 :
1470 0 : auto PBroadcastChannelChild::Read(
1471 : InputStreamParams* v__,
1472 : const Message* msg__,
1473 : PickleIterator* iter__) -> bool
1474 : {
1475 : typedef InputStreamParams type__;
1476 : int type;
1477 0 : if ((!(Read((&(type)), msg__, iter__)))) {
1478 0 : mozilla::ipc::UnionTypeReadError("InputStreamParams");
1479 0 : return false;
1480 : }
1481 : // Sentinel = 'InputStreamParams'
1482 0 : if ((!((msg__)->ReadSentinel(iter__, 4114814015)))) {
1483 0 : mozilla::ipc::SentinelReadError("InputStreamParams");
1484 0 : return false;
1485 : }
1486 :
1487 0 : switch (type) {
1488 : case type__::TStringInputStreamParams:
1489 : {
1490 0 : StringInputStreamParams tmp = StringInputStreamParams();
1491 0 : (*(v__)) = tmp;
1492 0 : if ((!(Read((&((v__)->get_StringInputStreamParams())), msg__, iter__)))) {
1493 0 : FatalError("Error deserializing Union type");
1494 0 : return false;
1495 : }
1496 : // Sentinel = 'TStringInputStreamParams'
1497 0 : if ((!((msg__)->ReadSentinel(iter__, 3395831651)))) {
1498 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1499 0 : return false;
1500 : }
1501 0 : return true;
1502 : }
1503 : case type__::TFileInputStreamParams:
1504 : {
1505 0 : FileInputStreamParams tmp = FileInputStreamParams();
1506 0 : (*(v__)) = tmp;
1507 0 : if ((!(Read((&((v__)->get_FileInputStreamParams())), msg__, iter__)))) {
1508 0 : FatalError("Error deserializing Union type");
1509 0 : return false;
1510 : }
1511 : // Sentinel = 'TFileInputStreamParams'
1512 0 : if ((!((msg__)->ReadSentinel(iter__, 2543620282)))) {
1513 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1514 0 : return false;
1515 : }
1516 0 : return true;
1517 : }
1518 : case type__::TTemporaryFileInputStreamParams:
1519 : {
1520 0 : TemporaryFileInputStreamParams tmp = TemporaryFileInputStreamParams();
1521 0 : (*(v__)) = tmp;
1522 0 : if ((!(Read((&((v__)->get_TemporaryFileInputStreamParams())), msg__, iter__)))) {
1523 0 : FatalError("Error deserializing Union type");
1524 0 : return false;
1525 : }
1526 : // Sentinel = 'TTemporaryFileInputStreamParams'
1527 0 : if ((!((msg__)->ReadSentinel(iter__, 587771548)))) {
1528 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1529 0 : return false;
1530 : }
1531 0 : return true;
1532 : }
1533 : case type__::TBufferedInputStreamParams:
1534 : {
1535 0 : BufferedInputStreamParams tmp = BufferedInputStreamParams();
1536 0 : (*(v__)) = tmp;
1537 0 : if ((!(Read((&((v__)->get_BufferedInputStreamParams())), msg__, iter__)))) {
1538 0 : FatalError("Error deserializing Union type");
1539 0 : return false;
1540 : }
1541 : // Sentinel = 'TBufferedInputStreamParams'
1542 0 : if ((!((msg__)->ReadSentinel(iter__, 1698289307)))) {
1543 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1544 0 : return false;
1545 : }
1546 0 : return true;
1547 : }
1548 : case type__::TMIMEInputStreamParams:
1549 : {
1550 0 : MIMEInputStreamParams tmp = MIMEInputStreamParams();
1551 0 : (*(v__)) = tmp;
1552 0 : if ((!(Read((&((v__)->get_MIMEInputStreamParams())), msg__, iter__)))) {
1553 0 : FatalError("Error deserializing Union type");
1554 0 : return false;
1555 : }
1556 : // Sentinel = 'TMIMEInputStreamParams'
1557 0 : if ((!((msg__)->ReadSentinel(iter__, 1948001964)))) {
1558 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1559 0 : return false;
1560 : }
1561 0 : return true;
1562 : }
1563 : case type__::TMultiplexInputStreamParams:
1564 : {
1565 0 : MultiplexInputStreamParams tmp = MultiplexInputStreamParams();
1566 0 : (*(v__)) = tmp;
1567 0 : if ((!(Read((&((v__)->get_MultiplexInputStreamParams())), msg__, iter__)))) {
1568 0 : FatalError("Error deserializing Union type");
1569 0 : return false;
1570 : }
1571 : // Sentinel = 'TMultiplexInputStreamParams'
1572 0 : if ((!((msg__)->ReadSentinel(iter__, 3317853213)))) {
1573 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1574 0 : return false;
1575 : }
1576 0 : return true;
1577 : }
1578 : case type__::TSlicedInputStreamParams:
1579 : {
1580 0 : SlicedInputStreamParams tmp = SlicedInputStreamParams();
1581 0 : (*(v__)) = tmp;
1582 0 : if ((!(Read((&((v__)->get_SlicedInputStreamParams())), msg__, iter__)))) {
1583 0 : FatalError("Error deserializing Union type");
1584 0 : return false;
1585 : }
1586 : // Sentinel = 'TSlicedInputStreamParams'
1587 0 : if ((!((msg__)->ReadSentinel(iter__, 445810472)))) {
1588 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1589 0 : return false;
1590 : }
1591 0 : return true;
1592 : }
1593 : case type__::TIPCBlobInputStreamParams:
1594 : {
1595 0 : IPCBlobInputStreamParams tmp = IPCBlobInputStreamParams();
1596 0 : (*(v__)) = tmp;
1597 0 : if ((!(Read((&((v__)->get_IPCBlobInputStreamParams())), msg__, iter__)))) {
1598 0 : FatalError("Error deserializing Union type");
1599 0 : return false;
1600 : }
1601 : // Sentinel = 'TIPCBlobInputStreamParams'
1602 0 : if ((!((msg__)->ReadSentinel(iter__, 2436989998)))) {
1603 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1604 0 : return false;
1605 : }
1606 0 : return true;
1607 : }
1608 : default:
1609 : {
1610 0 : FatalError("unknown union type");
1611 0 : return false;
1612 : }
1613 : }
1614 : }
1615 :
1616 0 : auto PBroadcastChannelChild::Write(
1617 : const PParentToChildStreamChild* v__,
1618 : Message* msg__,
1619 : bool nullable__) -> void
1620 : {
1621 : int32_t id;
1622 0 : if ((!(v__))) {
1623 0 : if ((!(nullable__))) {
1624 0 : FatalError("NULL actor value passed to non-nullable param");
1625 : }
1626 0 : id = 0;
1627 : }
1628 : else {
1629 0 : id = (v__)->Id();
1630 0 : if ((1) == (id)) {
1631 0 : FatalError("actor has been |delete|d");
1632 : }
1633 : }
1634 :
1635 0 : Write(id, msg__);
1636 0 : }
1637 :
1638 0 : auto PBroadcastChannelChild::Read(
1639 : PParentToChildStreamChild** v__,
1640 : const Message* msg__,
1641 : PickleIterator* iter__,
1642 : bool nullable__) -> bool
1643 : {
1644 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PParentToChildStream", PParentToChildStreamMsgStart);
1645 0 : if ((actor).isNothing()) {
1646 0 : return false;
1647 : }
1648 :
1649 0 : (*(v__)) = static_cast<PParentToChildStreamChild*>((actor).value());
1650 0 : return true;
1651 : }
1652 :
1653 0 : auto PBroadcastChannelChild::Write(
1654 : const IPCStream& v__,
1655 : Message* msg__) -> void
1656 : {
1657 : typedef IPCStream type__;
1658 0 : Write(int((v__).type()), msg__);
1659 : // Sentinel = 'IPCStream'
1660 0 : (msg__)->WriteSentinel(442610715);
1661 :
1662 0 : switch ((v__).type()) {
1663 : case type__::TInputStreamParamsWithFds:
1664 : {
1665 0 : Write((v__).get_InputStreamParamsWithFds(), msg__);
1666 : // Sentinel = 'TInputStreamParamsWithFds'
1667 0 : (msg__)->WriteSentinel(2170706066);
1668 0 : return;
1669 : }
1670 : case type__::TIPCRemoteStream:
1671 : {
1672 0 : Write((v__).get_IPCRemoteStream(), msg__);
1673 : // Sentinel = 'TIPCRemoteStream'
1674 0 : (msg__)->WriteSentinel(2978132448);
1675 0 : return;
1676 : }
1677 : default:
1678 : {
1679 0 : FatalError("unknown union type");
1680 0 : return;
1681 : }
1682 : }
1683 : }
1684 :
1685 0 : auto PBroadcastChannelChild::Read(
1686 : IPCStream* v__,
1687 : const Message* msg__,
1688 : PickleIterator* iter__) -> bool
1689 : {
1690 : typedef IPCStream type__;
1691 : int type;
1692 0 : if ((!(Read((&(type)), msg__, iter__)))) {
1693 0 : mozilla::ipc::UnionTypeReadError("IPCStream");
1694 0 : return false;
1695 : }
1696 : // Sentinel = 'IPCStream'
1697 0 : if ((!((msg__)->ReadSentinel(iter__, 442610715)))) {
1698 0 : mozilla::ipc::SentinelReadError("IPCStream");
1699 0 : return false;
1700 : }
1701 :
1702 0 : switch (type) {
1703 : case type__::TInputStreamParamsWithFds:
1704 : {
1705 0 : InputStreamParamsWithFds tmp = InputStreamParamsWithFds();
1706 0 : (*(v__)) = tmp;
1707 0 : if ((!(Read((&((v__)->get_InputStreamParamsWithFds())), msg__, iter__)))) {
1708 0 : FatalError("Error deserializing Union type");
1709 0 : return false;
1710 : }
1711 : // Sentinel = 'TInputStreamParamsWithFds'
1712 0 : if ((!((msg__)->ReadSentinel(iter__, 2170706066)))) {
1713 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1714 0 : return false;
1715 : }
1716 0 : return true;
1717 : }
1718 : case type__::TIPCRemoteStream:
1719 : {
1720 0 : IPCRemoteStream tmp = IPCRemoteStream();
1721 0 : (*(v__)) = tmp;
1722 0 : if ((!(Read((&((v__)->get_IPCRemoteStream())), msg__, iter__)))) {
1723 0 : FatalError("Error deserializing Union type");
1724 0 : return false;
1725 : }
1726 : // Sentinel = 'TIPCRemoteStream'
1727 0 : if ((!((msg__)->ReadSentinel(iter__, 2978132448)))) {
1728 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1729 0 : return false;
1730 : }
1731 0 : return true;
1732 : }
1733 : default:
1734 : {
1735 0 : FatalError("unknown union type");
1736 0 : return false;
1737 : }
1738 : }
1739 : }
1740 :
1741 0 : auto PBroadcastChannelChild::Write(
1742 : const StringInputStreamParams& v__,
1743 : Message* msg__) -> void
1744 : {
1745 0 : Write((v__).data(), msg__);
1746 : // Sentinel = 'data'
1747 0 : (msg__)->WriteSentinel(843352540);
1748 0 : }
1749 :
1750 0 : auto PBroadcastChannelChild::Read(
1751 : StringInputStreamParams* v__,
1752 : const Message* msg__,
1753 : PickleIterator* iter__) -> bool
1754 : {
1755 0 : if ((!(Read((&((v__)->data())), msg__, iter__)))) {
1756 0 : FatalError("Error deserializing 'data' (nsCString) member of 'StringInputStreamParams'");
1757 0 : return false;
1758 : }
1759 : // Sentinel = 'data'
1760 0 : if ((!((msg__)->ReadSentinel(iter__, 843352540)))) {
1761 0 : mozilla::ipc::SentinelReadError("Error deserializing 'data' (nsCString) member of 'StringInputStreamParams'");
1762 0 : return false;
1763 : }
1764 0 : return true;
1765 : }
1766 :
1767 0 : auto PBroadcastChannelChild::Write(
1768 : const MultiplexInputStreamParams& v__,
1769 : Message* msg__) -> void
1770 : {
1771 0 : Write((v__).streams(), msg__);
1772 : // Sentinel = 'streams'
1773 0 : (msg__)->WriteSentinel(4240383220);
1774 0 : Write((v__).currentStream(), msg__);
1775 : // Sentinel = 'currentStream'
1776 0 : (msg__)->WriteSentinel(682778074);
1777 0 : Write((v__).status(), msg__);
1778 : // Sentinel = 'status'
1779 0 : (msg__)->WriteSentinel(3714608576);
1780 0 : Write((v__).startedReadingCurrent(), msg__);
1781 : // Sentinel = 'startedReadingCurrent'
1782 0 : (msg__)->WriteSentinel(970542033);
1783 0 : }
1784 :
1785 0 : auto PBroadcastChannelChild::Read(
1786 : MultiplexInputStreamParams* v__,
1787 : const Message* msg__,
1788 : PickleIterator* iter__) -> bool
1789 : {
1790 0 : if ((!(Read((&((v__)->streams())), msg__, iter__)))) {
1791 0 : FatalError("Error deserializing 'streams' (InputStreamParams[]) member of 'MultiplexInputStreamParams'");
1792 0 : return false;
1793 : }
1794 : // Sentinel = 'streams'
1795 0 : if ((!((msg__)->ReadSentinel(iter__, 4240383220)))) {
1796 0 : mozilla::ipc::SentinelReadError("Error deserializing 'streams' (InputStreamParams[]) member of 'MultiplexInputStreamParams'");
1797 0 : return false;
1798 : }
1799 0 : if ((!(Read((&((v__)->currentStream())), msg__, iter__)))) {
1800 0 : FatalError("Error deserializing 'currentStream' (uint32_t) member of 'MultiplexInputStreamParams'");
1801 0 : return false;
1802 : }
1803 : // Sentinel = 'currentStream'
1804 0 : if ((!((msg__)->ReadSentinel(iter__, 682778074)))) {
1805 0 : mozilla::ipc::SentinelReadError("Error deserializing 'currentStream' (uint32_t) member of 'MultiplexInputStreamParams'");
1806 0 : return false;
1807 : }
1808 0 : if ((!(Read((&((v__)->status())), msg__, iter__)))) {
1809 0 : FatalError("Error deserializing 'status' (nsresult) member of 'MultiplexInputStreamParams'");
1810 0 : return false;
1811 : }
1812 : // Sentinel = 'status'
1813 0 : if ((!((msg__)->ReadSentinel(iter__, 3714608576)))) {
1814 0 : mozilla::ipc::SentinelReadError("Error deserializing 'status' (nsresult) member of 'MultiplexInputStreamParams'");
1815 0 : return false;
1816 : }
1817 0 : if ((!(Read((&((v__)->startedReadingCurrent())), msg__, iter__)))) {
1818 0 : FatalError("Error deserializing 'startedReadingCurrent' (bool) member of 'MultiplexInputStreamParams'");
1819 0 : return false;
1820 : }
1821 : // Sentinel = 'startedReadingCurrent'
1822 0 : if ((!((msg__)->ReadSentinel(iter__, 970542033)))) {
1823 0 : mozilla::ipc::SentinelReadError("Error deserializing 'startedReadingCurrent' (bool) member of 'MultiplexInputStreamParams'");
1824 0 : return false;
1825 : }
1826 0 : return true;
1827 : }
1828 :
1829 0 : auto PBroadcastChannelChild::Write(
1830 : const PFileDescriptorSetChild* v__,
1831 : Message* msg__,
1832 : bool nullable__) -> void
1833 : {
1834 : int32_t id;
1835 0 : if ((!(v__))) {
1836 0 : if ((!(nullable__))) {
1837 0 : FatalError("NULL actor value passed to non-nullable param");
1838 : }
1839 0 : id = 0;
1840 : }
1841 : else {
1842 0 : id = (v__)->Id();
1843 0 : if ((1) == (id)) {
1844 0 : FatalError("actor has been |delete|d");
1845 : }
1846 : }
1847 :
1848 0 : Write(id, msg__);
1849 0 : }
1850 :
1851 0 : auto PBroadcastChannelChild::Read(
1852 : PFileDescriptorSetChild** v__,
1853 : const Message* msg__,
1854 : PickleIterator* iter__,
1855 : bool nullable__) -> bool
1856 : {
1857 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PFileDescriptorSet", PFileDescriptorSetMsgStart);
1858 0 : if ((actor).isNothing()) {
1859 0 : return false;
1860 : }
1861 :
1862 0 : (*(v__)) = static_cast<PFileDescriptorSetChild*>((actor).value());
1863 0 : return true;
1864 : }
1865 :
1866 0 : auto PBroadcastChannelChild::Write(
1867 : const PIPCBlobInputStreamChild* v__,
1868 : Message* msg__,
1869 : bool nullable__) -> void
1870 : {
1871 : int32_t id;
1872 0 : if ((!(v__))) {
1873 0 : if ((!(nullable__))) {
1874 0 : FatalError("NULL actor value passed to non-nullable param");
1875 : }
1876 0 : id = 0;
1877 : }
1878 : else {
1879 0 : id = (v__)->Id();
1880 0 : if ((1) == (id)) {
1881 0 : FatalError("actor has been |delete|d");
1882 : }
1883 : }
1884 :
1885 0 : Write(id, msg__);
1886 0 : }
1887 :
1888 0 : auto PBroadcastChannelChild::Read(
1889 : PIPCBlobInputStreamChild** v__,
1890 : const Message* msg__,
1891 : PickleIterator* iter__,
1892 : bool nullable__) -> bool
1893 : {
1894 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PIPCBlobInputStream", PIPCBlobInputStreamMsgStart);
1895 0 : if ((actor).isNothing()) {
1896 0 : return false;
1897 : }
1898 :
1899 0 : (*(v__)) = static_cast<PIPCBlobInputStreamChild*>((actor).value());
1900 0 : return true;
1901 : }
1902 :
1903 0 : auto PBroadcastChannelChild::Write(
1904 : const OptionalFileDescriptorSet& v__,
1905 : Message* msg__) -> void
1906 : {
1907 : typedef OptionalFileDescriptorSet type__;
1908 0 : Write(int((v__).type()), msg__);
1909 : // Sentinel = 'OptionalFileDescriptorSet'
1910 0 : (msg__)->WriteSentinel(955222862);
1911 :
1912 0 : switch ((v__).type()) {
1913 : case type__::TPFileDescriptorSetParent:
1914 : {
1915 0 : FatalError("wrong side!");
1916 0 : return;
1917 : }
1918 : case type__::TPFileDescriptorSetChild:
1919 : {
1920 0 : Write((v__).get_PFileDescriptorSetChild(), msg__, false);
1921 : // Sentinel = 'TPFileDescriptorSetChild'
1922 0 : (msg__)->WriteSentinel(3477929935);
1923 0 : return;
1924 : }
1925 : case type__::TArrayOfFileDescriptor:
1926 : {
1927 0 : Write((v__).get_ArrayOfFileDescriptor(), msg__);
1928 : // Sentinel = 'TArrayOfFileDescriptor'
1929 0 : (msg__)->WriteSentinel(2366096715);
1930 0 : return;
1931 : }
1932 : case type__::Tvoid_t:
1933 : {
1934 0 : Write((v__).get_void_t(), msg__);
1935 : // Sentinel = 'Tvoid_t'
1936 0 : (msg__)->WriteSentinel(3041273328);
1937 0 : return;
1938 : }
1939 : default:
1940 : {
1941 0 : FatalError("unknown union type");
1942 0 : return;
1943 : }
1944 : }
1945 : }
1946 :
1947 0 : auto PBroadcastChannelChild::Read(
1948 : OptionalFileDescriptorSet* v__,
1949 : const Message* msg__,
1950 : PickleIterator* iter__) -> bool
1951 : {
1952 : typedef OptionalFileDescriptorSet type__;
1953 : int type;
1954 0 : if ((!(Read((&(type)), msg__, iter__)))) {
1955 0 : mozilla::ipc::UnionTypeReadError("OptionalFileDescriptorSet");
1956 0 : return false;
1957 : }
1958 : // Sentinel = 'OptionalFileDescriptorSet'
1959 0 : if ((!((msg__)->ReadSentinel(iter__, 955222862)))) {
1960 0 : mozilla::ipc::SentinelReadError("OptionalFileDescriptorSet");
1961 0 : return false;
1962 : }
1963 :
1964 0 : switch (type) {
1965 : case type__::TPFileDescriptorSetParent:
1966 : {
1967 0 : PFileDescriptorSetChild* tmp = nullptr;
1968 0 : (*(v__)) = tmp;
1969 0 : if ((!(Read((&((v__)->get_PFileDescriptorSetChild())), msg__, iter__, false)))) {
1970 0 : FatalError("Error deserializing Union type");
1971 0 : return false;
1972 : }
1973 : // Sentinel = 'TPFileDescriptorSetParent'
1974 0 : if ((!((msg__)->ReadSentinel(iter__, 143041934)))) {
1975 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1976 0 : return false;
1977 : }
1978 0 : return true;
1979 : }
1980 : case type__::TPFileDescriptorSetChild:
1981 : {
1982 0 : return false;
1983 : }
1984 : case type__::TArrayOfFileDescriptor:
1985 : {
1986 0 : nsTArray<FileDescriptor> tmp;
1987 0 : (*(v__)) = tmp;
1988 0 : if ((!(Read((&((v__)->get_ArrayOfFileDescriptor())), msg__, iter__)))) {
1989 0 : FatalError("Error deserializing Union type");
1990 0 : return false;
1991 : }
1992 : // Sentinel = 'TArrayOfFileDescriptor'
1993 0 : if ((!((msg__)->ReadSentinel(iter__, 2366096715)))) {
1994 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
1995 0 : return false;
1996 : }
1997 0 : return true;
1998 : }
1999 : case type__::Tvoid_t:
2000 : {
2001 : void_t tmp = void_t();
2002 0 : (*(v__)) = tmp;
2003 0 : if ((!(Read((&((v__)->get_void_t())), msg__, iter__)))) {
2004 0 : FatalError("Error deserializing Union type");
2005 0 : return false;
2006 : }
2007 : // Sentinel = 'Tvoid_t'
2008 0 : if ((!((msg__)->ReadSentinel(iter__, 3041273328)))) {
2009 0 : mozilla::ipc::SentinelReadError("Error deserializing Union type");
2010 0 : return false;
2011 : }
2012 0 : return true;
2013 : }
2014 : default:
2015 : {
2016 0 : FatalError("unknown union type");
2017 0 : return false;
2018 : }
2019 : }
2020 : }
2021 :
2022 0 : auto PBroadcastChannelChild::Write(
2023 : const nsTArray<IPCStream>& v__,
2024 : Message* msg__) -> void
2025 : {
2026 0 : uint32_t length = (v__).Length();
2027 0 : Write(length, msg__);
2028 : // Sentinel = ('length', 'IPCStream[]')
2029 0 : (msg__)->WriteSentinel(790413678);
2030 :
2031 0 : for (auto& elem : v__) {
2032 0 : Write(elem, msg__);
2033 : // Sentinel = 'IPCStream[]'
2034 0 : (msg__)->WriteSentinel(117417041);
2035 : }
2036 0 : }
2037 :
2038 0 : auto PBroadcastChannelChild::Read(
2039 : nsTArray<IPCStream>* v__,
2040 : const Message* msg__,
2041 : PickleIterator* iter__) -> bool
2042 : {
2043 0 : nsTArray<IPCStream> fa;
2044 : uint32_t length;
2045 0 : if ((!(Read((&(length)), msg__, iter__)))) {
2046 0 : mozilla::ipc::ArrayLengthReadError("IPCStream[]");
2047 0 : return false;
2048 : }
2049 : // Sentinel = ('length', 'IPCStream[]')
2050 0 : if ((!((msg__)->ReadSentinel(iter__, 790413678)))) {
2051 0 : mozilla::ipc::SentinelReadError("IPCStream[]");
2052 0 : return false;
2053 : }
2054 :
2055 0 : IPCStream* elems = (fa).AppendElements(length);
2056 0 : for (uint32_t i = 0; (i) < (length); (++(i))) {
2057 0 : if ((!(Read((&(elems[i])), msg__, iter__)))) {
2058 0 : FatalError("Error deserializing 'IPCStream[i]'");
2059 0 : return false;
2060 : }
2061 : // Sentinel = 'IPCStream[]'
2062 0 : if ((!((msg__)->ReadSentinel(iter__, 117417041)))) {
2063 0 : mozilla::ipc::SentinelReadError("Error deserializing 'IPCStream[i]'");
2064 0 : return false;
2065 : }
2066 : }
2067 0 : (v__)->SwapElements(fa);
2068 0 : return true;
2069 : }
2070 :
2071 0 : auto PBroadcastChannelChild::Write(
2072 : const IPCBlob& v__,
2073 : Message* msg__) -> void
2074 : {
2075 0 : Write((v__).type(), msg__);
2076 : // Sentinel = 'type'
2077 0 : (msg__)->WriteSentinel(2982068540);
2078 0 : Write((v__).size(), msg__);
2079 : // Sentinel = 'size'
2080 0 : (msg__)->WriteSentinel(931048223);
2081 0 : Write((v__).inputStream(), msg__);
2082 : // Sentinel = 'inputStream'
2083 0 : (msg__)->WriteSentinel(2684883823);
2084 0 : Write((v__).file(), msg__);
2085 : // Sentinel = 'file'
2086 0 : (msg__)->WriteSentinel(224874390);
2087 0 : Write((v__).fileId(), msg__);
2088 : // Sentinel = 'fileId'
2089 0 : (msg__)->WriteSentinel(108004447);
2090 0 : }
2091 :
2092 0 : auto PBroadcastChannelChild::Read(
2093 : IPCBlob* v__,
2094 : const Message* msg__,
2095 : PickleIterator* iter__) -> bool
2096 : {
2097 0 : if ((!(Read((&((v__)->type())), msg__, iter__)))) {
2098 0 : FatalError("Error deserializing 'type' (nsString) member of 'IPCBlob'");
2099 0 : return false;
2100 : }
2101 : // Sentinel = 'type'
2102 0 : if ((!((msg__)->ReadSentinel(iter__, 2982068540)))) {
2103 0 : mozilla::ipc::SentinelReadError("Error deserializing 'type' (nsString) member of 'IPCBlob'");
2104 0 : return false;
2105 : }
2106 0 : if ((!(Read((&((v__)->size())), msg__, iter__)))) {
2107 0 : FatalError("Error deserializing 'size' (uint64_t) member of 'IPCBlob'");
2108 0 : return false;
2109 : }
2110 : // Sentinel = 'size'
2111 0 : if ((!((msg__)->ReadSentinel(iter__, 931048223)))) {
2112 0 : mozilla::ipc::SentinelReadError("Error deserializing 'size' (uint64_t) member of 'IPCBlob'");
2113 0 : return false;
2114 : }
2115 0 : if ((!(Read((&((v__)->inputStream())), msg__, iter__)))) {
2116 0 : FatalError("Error deserializing 'inputStream' (IPCBlobStream) member of 'IPCBlob'");
2117 0 : return false;
2118 : }
2119 : // Sentinel = 'inputStream'
2120 0 : if ((!((msg__)->ReadSentinel(iter__, 2684883823)))) {
2121 0 : mozilla::ipc::SentinelReadError("Error deserializing 'inputStream' (IPCBlobStream) member of 'IPCBlob'");
2122 0 : return false;
2123 : }
2124 0 : if ((!(Read((&((v__)->file())), msg__, iter__)))) {
2125 0 : FatalError("Error deserializing 'file' (IPCFileUnion) member of 'IPCBlob'");
2126 0 : return false;
2127 : }
2128 : // Sentinel = 'file'
2129 0 : if ((!((msg__)->ReadSentinel(iter__, 224874390)))) {
2130 0 : mozilla::ipc::SentinelReadError("Error deserializing 'file' (IPCFileUnion) member of 'IPCBlob'");
2131 0 : return false;
2132 : }
2133 0 : if ((!(Read((&((v__)->fileId())), msg__, iter__)))) {
2134 0 : FatalError("Error deserializing 'fileId' (int64_t) member of 'IPCBlob'");
2135 0 : return false;
2136 : }
2137 : // Sentinel = 'fileId'
2138 0 : if ((!((msg__)->ReadSentinel(iter__, 108004447)))) {
2139 0 : mozilla::ipc::SentinelReadError("Error deserializing 'fileId' (int64_t) member of 'IPCBlob'");
2140 0 : return false;
2141 : }
2142 0 : return true;
2143 : }
2144 :
2145 0 : auto PBroadcastChannelChild::Write(
2146 : const FileDescriptor& v__,
2147 : Message* msg__) -> void
2148 : {
2149 0 : FileDescriptor::PickleType pfd = (v__).ShareTo(FileDescriptor::IPDLPrivate(), OtherPid());
2150 0 : IPC::WriteParam(msg__, pfd);
2151 0 : }
2152 :
2153 0 : auto PBroadcastChannelChild::Read(
2154 : FileDescriptor* v__,
2155 : const Message* msg__,
2156 : PickleIterator* iter__) -> bool
2157 : {
2158 0 : FileDescriptor::PickleType pfd;
2159 0 : if ((!(IPC::ReadParam(msg__, iter__, (&(pfd)))))) {
2160 0 : return false;
2161 : }
2162 :
2163 0 : FileDescriptor fd = FileDescriptor(FileDescriptor::IPDLPrivate(), pfd);
2164 0 : if ((!((fd).IsValid()))) {
2165 0 : mozilla::ipc::ProtocolErrorBreakpoint("[PBroadcastChannelChild] Received an invalid file descriptor!");
2166 : }
2167 :
2168 0 : (*(v__)) = fd;
2169 0 : return true;
2170 : }
2171 :
2172 0 : auto PBroadcastChannelChild::Write(
2173 : const BufferedInputStreamParams& v__,
2174 : Message* msg__) -> void
2175 : {
2176 0 : Write((v__).optionalStream(), msg__);
2177 : // Sentinel = 'optionalStream'
2178 0 : (msg__)->WriteSentinel(1003718562);
2179 0 : Write((v__).bufferSize(), msg__);
2180 : // Sentinel = 'bufferSize'
2181 0 : (msg__)->WriteSentinel(3444538779);
2182 0 : }
2183 :
2184 0 : auto PBroadcastChannelChild::Read(
2185 : BufferedInputStreamParams* v__,
2186 : const Message* msg__,
2187 : PickleIterator* iter__) -> bool
2188 : {
2189 0 : if ((!(Read((&((v__)->optionalStream())), msg__, iter__)))) {
2190 0 : FatalError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'BufferedInputStreamParams'");
2191 0 : return false;
2192 : }
2193 : // Sentinel = 'optionalStream'
2194 0 : if ((!((msg__)->ReadSentinel(iter__, 1003718562)))) {
2195 0 : mozilla::ipc::SentinelReadError("Error deserializing 'optionalStream' (OptionalInputStreamParams) member of 'BufferedInputStreamParams'");
2196 0 : return false;
2197 : }
2198 0 : if ((!(Read((&((v__)->bufferSize())), msg__, iter__)))) {
2199 0 : FatalError("Error deserializing 'bufferSize' (uint32_t) member of 'BufferedInputStreamParams'");
2200 0 : return false;
2201 : }
2202 : // Sentinel = 'bufferSize'
2203 0 : if ((!((msg__)->ReadSentinel(iter__, 3444538779)))) {
2204 0 : mozilla::ipc::SentinelReadError("Error deserializing 'bufferSize' (uint32_t) member of 'BufferedInputStreamParams'");
2205 0 : return false;
2206 : }
2207 0 : return true;
2208 : }
2209 :
2210 0 : auto PBroadcastChannelChild::Write(
2211 : const HeaderEntry& v__,
2212 : Message* msg__) -> void
2213 : {
2214 0 : Write((v__).name(), msg__);
2215 : // Sentinel = 'name'
2216 0 : (msg__)->WriteSentinel(15034981);
2217 0 : Write((v__).value(), msg__);
2218 : // Sentinel = 'value'
2219 0 : (msg__)->WriteSentinel(3456818542);
2220 0 : }
2221 :
2222 0 : auto PBroadcastChannelChild::Read(
2223 : HeaderEntry* v__,
2224 : const Message* msg__,
2225 : PickleIterator* iter__) -> bool
2226 : {
2227 0 : if ((!(Read((&((v__)->name())), msg__, iter__)))) {
2228 0 : FatalError("Error deserializing 'name' (nsCString) member of 'HeaderEntry'");
2229 0 : return false;
2230 : }
2231 : // Sentinel = 'name'
2232 0 : if ((!((msg__)->ReadSentinel(iter__, 15034981)))) {
2233 0 : mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsCString) member of 'HeaderEntry'");
2234 0 : return false;
2235 : }
2236 0 : if ((!(Read((&((v__)->value())), msg__, iter__)))) {
2237 0 : FatalError("Error deserializing 'value' (nsCString) member of 'HeaderEntry'");
2238 0 : return false;
2239 : }
2240 : // Sentinel = 'value'
2241 0 : if ((!((msg__)->ReadSentinel(iter__, 3456818542)))) {
2242 0 : mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsCString) member of 'HeaderEntry'");
2243 0 : return false;
2244 : }
2245 0 : return true;
2246 : }
2247 :
2248 0 : auto PBroadcastChannelChild::Write(
2249 : const PChildToParentStreamChild* v__,
2250 : Message* msg__,
2251 : bool nullable__) -> void
2252 : {
2253 : int32_t id;
2254 0 : if ((!(v__))) {
2255 0 : if ((!(nullable__))) {
2256 0 : FatalError("NULL actor value passed to non-nullable param");
2257 : }
2258 0 : id = 0;
2259 : }
2260 : else {
2261 0 : id = (v__)->Id();
2262 0 : if ((1) == (id)) {
2263 0 : FatalError("actor has been |delete|d");
2264 : }
2265 : }
2266 :
2267 0 : Write(id, msg__);
2268 0 : }
2269 :
2270 0 : auto PBroadcastChannelChild::Read(
2271 : PChildToParentStreamChild** v__,
2272 : const Message* msg__,
2273 : PickleIterator* iter__,
2274 : bool nullable__) -> bool
2275 : {
2276 0 : Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PChildToParentStream", PChildToParentStreamMsgStart);
2277 0 : if ((actor).isNothing()) {
2278 0 : return false;
2279 : }
2280 :
2281 0 : (*(v__)) = static_cast<PChildToParentStreamChild*>((actor).value());
2282 0 : return true;
2283 : }
2284 :
2285 :
2286 :
2287 : } // namespace dom
2288 : } // namespace mozilla
|
