Line data Source code
1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 :
7 : #include "mozilla/net/NeckoChannelParams.h"
8 :
9 :
10 : //-----------------------------------------------------------------------------
11 : // Method definitions for the IPDL type |struct RedirectHistoryEntryInfo|
12 : //
13 : namespace mozilla {
14 : namespace net {
15 0 : MOZ_IMPLICIT RedirectHistoryEntryInfo::RedirectHistoryEntryInfo() :
16 0 : remoteAddress_()
17 : {
18 0 : Init();
19 0 : }
20 :
21 0 : RedirectHistoryEntryInfo::~RedirectHistoryEntryInfo()
22 : {
23 0 : }
24 :
25 0 : auto RedirectHistoryEntryInfo::operator==(const RedirectHistoryEntryInfo& _o) const -> bool
26 : {
27 0 : if ((!((principalInfo()) == ((_o).principalInfo())))) {
28 0 : return false;
29 : }
30 0 : if ((!((referrerUri()) == ((_o).referrerUri())))) {
31 0 : return false;
32 : }
33 0 : if ((!((remoteAddress()) == ((_o).remoteAddress())))) {
34 0 : return false;
35 : }
36 0 : return true;
37 : }
38 :
39 0 : auto RedirectHistoryEntryInfo::operator!=(const RedirectHistoryEntryInfo& _o) const -> bool
40 : {
41 0 : return (!(operator==(_o)));
42 : }
43 :
44 0 : auto RedirectHistoryEntryInfo::Init() -> void
45 : {
46 0 : }
47 :
48 0 : auto RedirectHistoryEntryInfo::Assign(
49 : const PrincipalInfo& _principalInfo,
50 : const OptionalURIParams& _referrerUri,
51 : const nsCString& _remoteAddress) -> void
52 : {
53 0 : principalInfo_ = _principalInfo;
54 0 : referrerUri_ = _referrerUri;
55 0 : remoteAddress_ = _remoteAddress;
56 0 : }
57 :
58 : } // namespace net
59 : } // namespace mozilla
60 :
61 : //-----------------------------------------------------------------------------
62 : // Method definitions for the IPDL type |struct LoadInfoArgs|
63 : //
64 : namespace mozilla {
65 : namespace net {
66 12 : MOZ_IMPLICIT LoadInfoArgs::LoadInfoArgs() :
67 : securityFlags_(),
68 : contentPolicyType_(),
69 : tainting_(),
70 : upgradeInsecureRequests_(),
71 : verifySignedContent_(),
72 : enforceSRI_(),
73 : forceInheritPrincipalDropped_(),
74 : innerWindowID_(),
75 : outerWindowID_(),
76 : parentOuterWindowID_(),
77 : frameOuterWindowID_(),
78 : enforceSecurity_(),
79 : initialSecurityCheckDone_(),
80 : isInThirdPartyContext_(),
81 : originAttributes_(),
82 : forcePreflight_(),
83 : isPreflight_(),
84 : forceHSTSPriming_(),
85 : mixedContentWouldBlock_(),
86 : isHSTSPriming_(),
87 12 : isHSTSPrimingUpgrade_()
88 : {
89 12 : Init();
90 12 : }
91 :
92 18 : LoadInfoArgs::~LoadInfoArgs()
93 : {
94 18 : }
95 :
96 0 : auto LoadInfoArgs::operator==(const LoadInfoArgs& _o) const -> bool
97 : {
98 0 : if ((!((requestingPrincipalInfo()) == ((_o).requestingPrincipalInfo())))) {
99 0 : return false;
100 : }
101 0 : if ((!((triggeringPrincipalInfo()) == ((_o).triggeringPrincipalInfo())))) {
102 0 : return false;
103 : }
104 0 : if ((!((principalToInheritInfo()) == ((_o).principalToInheritInfo())))) {
105 0 : return false;
106 : }
107 0 : if ((!((sandboxedLoadingPrincipalInfo()) == ((_o).sandboxedLoadingPrincipalInfo())))) {
108 0 : return false;
109 : }
110 0 : if ((!((resultPrincipalURI()) == ((_o).resultPrincipalURI())))) {
111 0 : return false;
112 : }
113 0 : if ((!((securityFlags()) == ((_o).securityFlags())))) {
114 0 : return false;
115 : }
116 0 : if ((!((contentPolicyType()) == ((_o).contentPolicyType())))) {
117 0 : return false;
118 : }
119 0 : if ((!((tainting()) == ((_o).tainting())))) {
120 0 : return false;
121 : }
122 0 : if ((!((upgradeInsecureRequests()) == ((_o).upgradeInsecureRequests())))) {
123 0 : return false;
124 : }
125 0 : if ((!((verifySignedContent()) == ((_o).verifySignedContent())))) {
126 0 : return false;
127 : }
128 0 : if ((!((enforceSRI()) == ((_o).enforceSRI())))) {
129 0 : return false;
130 : }
131 0 : if ((!((forceInheritPrincipalDropped()) == ((_o).forceInheritPrincipalDropped())))) {
132 0 : return false;
133 : }
134 0 : if ((!((innerWindowID()) == ((_o).innerWindowID())))) {
135 0 : return false;
136 : }
137 0 : if ((!((outerWindowID()) == ((_o).outerWindowID())))) {
138 0 : return false;
139 : }
140 0 : if ((!((parentOuterWindowID()) == ((_o).parentOuterWindowID())))) {
141 0 : return false;
142 : }
143 0 : if ((!((frameOuterWindowID()) == ((_o).frameOuterWindowID())))) {
144 0 : return false;
145 : }
146 0 : if ((!((enforceSecurity()) == ((_o).enforceSecurity())))) {
147 0 : return false;
148 : }
149 0 : if ((!((initialSecurityCheckDone()) == ((_o).initialSecurityCheckDone())))) {
150 0 : return false;
151 : }
152 0 : if ((!((isInThirdPartyContext()) == ((_o).isInThirdPartyContext())))) {
153 0 : return false;
154 : }
155 0 : if ((!((originAttributes()) == ((_o).originAttributes())))) {
156 0 : return false;
157 : }
158 0 : if ((!((redirectChainIncludingInternalRedirects()) == ((_o).redirectChainIncludingInternalRedirects())))) {
159 0 : return false;
160 : }
161 0 : if ((!((redirectChain()) == ((_o).redirectChain())))) {
162 0 : return false;
163 : }
164 0 : if ((!((corsUnsafeHeaders()) == ((_o).corsUnsafeHeaders())))) {
165 0 : return false;
166 : }
167 0 : if ((!((forcePreflight()) == ((_o).forcePreflight())))) {
168 0 : return false;
169 : }
170 0 : if ((!((isPreflight()) == ((_o).isPreflight())))) {
171 0 : return false;
172 : }
173 0 : if ((!((forceHSTSPriming()) == ((_o).forceHSTSPriming())))) {
174 0 : return false;
175 : }
176 0 : if ((!((mixedContentWouldBlock()) == ((_o).mixedContentWouldBlock())))) {
177 0 : return false;
178 : }
179 0 : if ((!((isHSTSPriming()) == ((_o).isHSTSPriming())))) {
180 0 : return false;
181 : }
182 0 : if ((!((isHSTSPrimingUpgrade()) == ((_o).isHSTSPrimingUpgrade())))) {
183 0 : return false;
184 : }
185 0 : return true;
186 : }
187 :
188 0 : auto LoadInfoArgs::operator!=(const LoadInfoArgs& _o) const -> bool
189 : {
190 0 : return (!(operator==(_o)));
191 : }
192 :
193 18 : auto LoadInfoArgs::Init() -> void
194 : {
195 18 : }
196 :
197 15 : auto LoadInfoArgs::Assign(
198 : const OptionalPrincipalInfo& _requestingPrincipalInfo,
199 : const PrincipalInfo& _triggeringPrincipalInfo,
200 : const OptionalPrincipalInfo& _principalToInheritInfo,
201 : const OptionalPrincipalInfo& _sandboxedLoadingPrincipalInfo,
202 : const OptionalURIParams& _resultPrincipalURI,
203 : const uint32_t& _securityFlags,
204 : const uint32_t& _contentPolicyType,
205 : const uint32_t& _tainting,
206 : const bool& _upgradeInsecureRequests,
207 : const bool& _verifySignedContent,
208 : const bool& _enforceSRI,
209 : const bool& _forceInheritPrincipalDropped,
210 : const uint64_t& _innerWindowID,
211 : const uint64_t& _outerWindowID,
212 : const uint64_t& _parentOuterWindowID,
213 : const uint64_t& _frameOuterWindowID,
214 : const bool& _enforceSecurity,
215 : const bool& _initialSecurityCheckDone,
216 : const bool& _isInThirdPartyContext,
217 : const OriginAttributes& _originAttributes,
218 : const nsTArray<RedirectHistoryEntryInfo>& _redirectChainIncludingInternalRedirects,
219 : const nsTArray<RedirectHistoryEntryInfo>& _redirectChain,
220 : const nsTArray<nsCString>& _corsUnsafeHeaders,
221 : const bool& _forcePreflight,
222 : const bool& _isPreflight,
223 : const bool& _forceHSTSPriming,
224 : const bool& _mixedContentWouldBlock,
225 : const bool& _isHSTSPriming,
226 : const bool& _isHSTSPrimingUpgrade) -> void
227 : {
228 15 : requestingPrincipalInfo_ = _requestingPrincipalInfo;
229 15 : triggeringPrincipalInfo_ = _triggeringPrincipalInfo;
230 15 : principalToInheritInfo_ = _principalToInheritInfo;
231 15 : sandboxedLoadingPrincipalInfo_ = _sandboxedLoadingPrincipalInfo;
232 15 : resultPrincipalURI_ = _resultPrincipalURI;
233 15 : securityFlags_ = _securityFlags;
234 15 : contentPolicyType_ = _contentPolicyType;
235 15 : tainting_ = _tainting;
236 15 : upgradeInsecureRequests_ = _upgradeInsecureRequests;
237 15 : verifySignedContent_ = _verifySignedContent;
238 15 : enforceSRI_ = _enforceSRI;
239 15 : forceInheritPrincipalDropped_ = _forceInheritPrincipalDropped;
240 15 : innerWindowID_ = _innerWindowID;
241 15 : outerWindowID_ = _outerWindowID;
242 15 : parentOuterWindowID_ = _parentOuterWindowID;
243 15 : frameOuterWindowID_ = _frameOuterWindowID;
244 15 : enforceSecurity_ = _enforceSecurity;
245 15 : initialSecurityCheckDone_ = _initialSecurityCheckDone;
246 15 : isInThirdPartyContext_ = _isInThirdPartyContext;
247 15 : originAttributes_ = _originAttributes;
248 15 : redirectChainIncludingInternalRedirects_ = _redirectChainIncludingInternalRedirects;
249 15 : redirectChain_ = _redirectChain;
250 15 : corsUnsafeHeaders_ = _corsUnsafeHeaders;
251 15 : forcePreflight_ = _forcePreflight;
252 15 : isPreflight_ = _isPreflight;
253 15 : forceHSTSPriming_ = _forceHSTSPriming;
254 15 : mixedContentWouldBlock_ = _mixedContentWouldBlock;
255 15 : isHSTSPriming_ = _isHSTSPriming;
256 15 : isHSTSPrimingUpgrade_ = _isHSTSPrimingUpgrade;
257 15 : }
258 :
259 : } // namespace net
260 : } // namespace mozilla
261 :
262 : //-----------------------------------------------------------------------------
263 : // Method definitions for the IPDL type |union OptionalLoadInfoArgs|
264 : //
265 : namespace mozilla {
266 : namespace net {
267 27 : auto OptionalLoadInfoArgs::MaybeDestroy(Type aNewType) -> bool
268 : {
269 27 : if ((mType) == (T__None)) {
270 15 : return true;
271 : }
272 12 : if ((mType) == (aNewType)) {
273 0 : return false;
274 : }
275 12 : switch (mType) {
276 : case Tvoid_t:
277 : {
278 0 : (ptr_void_t())->~void_t__tdef();
279 0 : break;
280 : }
281 : case TLoadInfoArgs:
282 : {
283 12 : (ptr_LoadInfoArgs())->~LoadInfoArgs__tdef();
284 12 : break;
285 : }
286 : default:
287 : {
288 0 : mozilla::ipc::LogicError("not reached");
289 0 : break;
290 : }
291 : }
292 12 : return true;
293 : }
294 :
295 0 : MOZ_IMPLICIT OptionalLoadInfoArgs::OptionalLoadInfoArgs(const void_t& aOther)
296 : {
297 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
298 0 : mType = Tvoid_t;
299 0 : }
300 :
301 0 : MOZ_IMPLICIT OptionalLoadInfoArgs::OptionalLoadInfoArgs(const LoadInfoArgs& aOther)
302 : {
303 0 : new (mozilla::KnownNotNull, ptr_LoadInfoArgs()) LoadInfoArgs(aOther);
304 0 : mType = TLoadInfoArgs;
305 0 : }
306 :
307 3 : MOZ_IMPLICIT OptionalLoadInfoArgs::OptionalLoadInfoArgs(const OptionalLoadInfoArgs& aOther)
308 : {
309 3 : (aOther).AssertSanity();
310 3 : switch ((aOther).type()) {
311 : case Tvoid_t:
312 : {
313 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
314 0 : break;
315 : }
316 : case TLoadInfoArgs:
317 : {
318 3 : new (mozilla::KnownNotNull, ptr_LoadInfoArgs()) LoadInfoArgs((aOther).get_LoadInfoArgs());
319 3 : break;
320 : }
321 : case T__None:
322 : {
323 0 : break;
324 : }
325 : default:
326 : {
327 0 : mozilla::ipc::LogicError("unreached");
328 0 : return;
329 : }
330 : }
331 3 : mType = (aOther).type();
332 : }
333 :
334 30 : OptionalLoadInfoArgs::~OptionalLoadInfoArgs()
335 : {
336 15 : static_cast<void>(MaybeDestroy(T__None));
337 15 : }
338 :
339 0 : auto OptionalLoadInfoArgs::operator=(const void_t& aRhs) -> OptionalLoadInfoArgs&
340 : {
341 0 : if (MaybeDestroy(Tvoid_t)) {
342 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
343 : }
344 0 : (*(ptr_void_t())) = aRhs;
345 0 : mType = Tvoid_t;
346 0 : return (*(this));
347 : }
348 :
349 6 : auto OptionalLoadInfoArgs::operator=(const LoadInfoArgs& aRhs) -> OptionalLoadInfoArgs&
350 : {
351 6 : if (MaybeDestroy(TLoadInfoArgs)) {
352 6 : new (mozilla::KnownNotNull, ptr_LoadInfoArgs()) LoadInfoArgs;
353 : }
354 6 : (*(ptr_LoadInfoArgs())) = aRhs;
355 6 : mType = TLoadInfoArgs;
356 6 : return (*(this));
357 : }
358 :
359 6 : auto OptionalLoadInfoArgs::operator=(const OptionalLoadInfoArgs& aRhs) -> OptionalLoadInfoArgs&
360 : {
361 6 : (aRhs).AssertSanity();
362 6 : Type t = (aRhs).type();
363 6 : switch (t) {
364 : case Tvoid_t:
365 : {
366 0 : if (MaybeDestroy(t)) {
367 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
368 : }
369 0 : (*(ptr_void_t())) = (aRhs).get_void_t();
370 0 : break;
371 : }
372 : case TLoadInfoArgs:
373 : {
374 3 : if (MaybeDestroy(t)) {
375 3 : new (mozilla::KnownNotNull, ptr_LoadInfoArgs()) LoadInfoArgs;
376 : }
377 3 : (*(ptr_LoadInfoArgs())) = (aRhs).get_LoadInfoArgs();
378 3 : break;
379 : }
380 : case T__None:
381 : {
382 3 : static_cast<void>(MaybeDestroy(t));
383 3 : break;
384 : }
385 : default:
386 : {
387 0 : mozilla::ipc::LogicError("unreached");
388 0 : break;
389 : }
390 : }
391 6 : mType = t;
392 6 : return (*(this));
393 : }
394 :
395 0 : auto OptionalLoadInfoArgs::operator==(const void_t& aRhs) const -> bool
396 : {
397 0 : return (get_void_t()) == (aRhs);
398 : }
399 :
400 0 : auto OptionalLoadInfoArgs::operator==(const LoadInfoArgs& aRhs) const -> bool
401 : {
402 0 : return (get_LoadInfoArgs()) == (aRhs);
403 : }
404 :
405 0 : auto OptionalLoadInfoArgs::operator==(const OptionalLoadInfoArgs& aRhs) const -> bool
406 : {
407 0 : if ((type()) != ((aRhs).type())) {
408 0 : return false;
409 : }
410 :
411 0 : switch (type()) {
412 : case Tvoid_t:
413 : {
414 0 : return (get_void_t()) == ((aRhs).get_void_t());
415 : }
416 : case TLoadInfoArgs:
417 : {
418 0 : return (get_LoadInfoArgs()) == ((aRhs).get_LoadInfoArgs());
419 : }
420 : default:
421 : {
422 0 : mozilla::ipc::LogicError("unreached");
423 0 : return false;
424 : }
425 : }
426 : }
427 :
428 0 : auto OptionalLoadInfoArgs::get(void_t* aOutValue) const -> void
429 : {
430 0 : (*(aOutValue)) = get_void_t();
431 0 : }
432 :
433 0 : auto OptionalLoadInfoArgs::get(LoadInfoArgs* aOutValue) const -> void
434 : {
435 0 : (*(aOutValue)) = get_LoadInfoArgs();
436 0 : }
437 :
438 : } // namespace net
439 : } // namespace mozilla
440 :
441 : //-----------------------------------------------------------------------------
442 : // Method definitions for the IPDL type |union OptionalHttpResponseHead|
443 : //
444 : namespace mozilla {
445 : namespace net {
446 24 : auto OptionalHttpResponseHead::MaybeDestroy(Type aNewType) -> bool
447 : {
448 24 : if ((mType) == (T__None)) {
449 15 : return true;
450 : }
451 9 : if ((mType) == (aNewType)) {
452 0 : return false;
453 : }
454 9 : switch (mType) {
455 : case Tvoid_t:
456 : {
457 9 : (ptr_void_t())->~void_t__tdef();
458 9 : break;
459 : }
460 : case TnsHttpResponseHead:
461 : {
462 0 : (ptr_nsHttpResponseHead())->~nsHttpResponseHead__tdef();
463 0 : break;
464 : }
465 : default:
466 : {
467 0 : mozilla::ipc::LogicError("not reached");
468 0 : break;
469 : }
470 : }
471 9 : return true;
472 : }
473 :
474 0 : MOZ_IMPLICIT OptionalHttpResponseHead::OptionalHttpResponseHead(const void_t& aOther)
475 : {
476 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
477 0 : mType = Tvoid_t;
478 0 : }
479 :
480 0 : MOZ_IMPLICIT OptionalHttpResponseHead::OptionalHttpResponseHead(const nsHttpResponseHead& aOther)
481 : {
482 0 : new (mozilla::KnownNotNull, ptr_nsHttpResponseHead()) nsHttpResponseHead(aOther);
483 0 : mType = TnsHttpResponseHead;
484 0 : }
485 :
486 0 : MOZ_IMPLICIT OptionalHttpResponseHead::OptionalHttpResponseHead(const OptionalHttpResponseHead& aOther)
487 : {
488 0 : (aOther).AssertSanity();
489 0 : switch ((aOther).type()) {
490 : case Tvoid_t:
491 : {
492 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
493 0 : break;
494 : }
495 : case TnsHttpResponseHead:
496 : {
497 0 : new (mozilla::KnownNotNull, ptr_nsHttpResponseHead()) nsHttpResponseHead((aOther).get_nsHttpResponseHead());
498 0 : break;
499 : }
500 : case T__None:
501 : {
502 0 : break;
503 : }
504 : default:
505 : {
506 0 : mozilla::ipc::LogicError("unreached");
507 0 : return;
508 : }
509 : }
510 0 : mType = (aOther).type();
511 : }
512 :
513 24 : OptionalHttpResponseHead::~OptionalHttpResponseHead()
514 : {
515 12 : static_cast<void>(MaybeDestroy(T__None));
516 12 : }
517 :
518 6 : auto OptionalHttpResponseHead::operator=(const void_t& aRhs) -> OptionalHttpResponseHead&
519 : {
520 6 : if (MaybeDestroy(Tvoid_t)) {
521 6 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
522 : }
523 6 : (*(ptr_void_t())) = aRhs;
524 6 : mType = Tvoid_t;
525 6 : return (*(this));
526 : }
527 :
528 0 : auto OptionalHttpResponseHead::operator=(const nsHttpResponseHead& aRhs) -> OptionalHttpResponseHead&
529 : {
530 0 : if (MaybeDestroy(TnsHttpResponseHead)) {
531 0 : new (mozilla::KnownNotNull, ptr_nsHttpResponseHead()) nsHttpResponseHead;
532 : }
533 0 : (*(ptr_nsHttpResponseHead())) = aRhs;
534 0 : mType = TnsHttpResponseHead;
535 0 : return (*(this));
536 : }
537 :
538 6 : auto OptionalHttpResponseHead::operator=(const OptionalHttpResponseHead& aRhs) -> OptionalHttpResponseHead&
539 : {
540 6 : (aRhs).AssertSanity();
541 6 : Type t = (aRhs).type();
542 6 : switch (t) {
543 : case Tvoid_t:
544 : {
545 3 : if (MaybeDestroy(t)) {
546 3 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
547 : }
548 3 : (*(ptr_void_t())) = (aRhs).get_void_t();
549 3 : break;
550 : }
551 : case TnsHttpResponseHead:
552 : {
553 0 : if (MaybeDestroy(t)) {
554 0 : new (mozilla::KnownNotNull, ptr_nsHttpResponseHead()) nsHttpResponseHead;
555 : }
556 0 : (*(ptr_nsHttpResponseHead())) = (aRhs).get_nsHttpResponseHead();
557 0 : break;
558 : }
559 : case T__None:
560 : {
561 3 : static_cast<void>(MaybeDestroy(t));
562 3 : break;
563 : }
564 : default:
565 : {
566 0 : mozilla::ipc::LogicError("unreached");
567 0 : break;
568 : }
569 : }
570 6 : mType = t;
571 6 : return (*(this));
572 : }
573 :
574 0 : auto OptionalHttpResponseHead::operator==(const void_t& aRhs) const -> bool
575 : {
576 0 : return (get_void_t()) == (aRhs);
577 : }
578 :
579 0 : auto OptionalHttpResponseHead::operator==(const nsHttpResponseHead& aRhs) const -> bool
580 : {
581 0 : return (get_nsHttpResponseHead()) == (aRhs);
582 : }
583 :
584 0 : auto OptionalHttpResponseHead::operator==(const OptionalHttpResponseHead& aRhs) const -> bool
585 : {
586 0 : if ((type()) != ((aRhs).type())) {
587 0 : return false;
588 : }
589 :
590 0 : switch (type()) {
591 : case Tvoid_t:
592 : {
593 0 : return (get_void_t()) == ((aRhs).get_void_t());
594 : }
595 : case TnsHttpResponseHead:
596 : {
597 0 : return (get_nsHttpResponseHead()) == ((aRhs).get_nsHttpResponseHead());
598 : }
599 : default:
600 : {
601 0 : mozilla::ipc::LogicError("unreached");
602 0 : return false;
603 : }
604 : }
605 : }
606 :
607 0 : auto OptionalHttpResponseHead::get(void_t* aOutValue) const -> void
608 : {
609 0 : (*(aOutValue)) = get_void_t();
610 0 : }
611 :
612 0 : auto OptionalHttpResponseHead::get(nsHttpResponseHead* aOutValue) const -> void
613 : {
614 0 : (*(aOutValue)) = get_nsHttpResponseHead();
615 0 : }
616 :
617 : } // namespace net
618 : } // namespace mozilla
619 :
620 : //-----------------------------------------------------------------------------
621 : // Method definitions for the IPDL type |struct CorsPreflightArgs|
622 : //
623 : namespace mozilla {
624 : namespace net {
625 0 : MOZ_IMPLICIT CorsPreflightArgs::CorsPreflightArgs()
626 : {
627 0 : Init();
628 0 : }
629 :
630 0 : CorsPreflightArgs::~CorsPreflightArgs()
631 : {
632 0 : }
633 :
634 0 : auto CorsPreflightArgs::operator==(const CorsPreflightArgs& _o) const -> bool
635 : {
636 0 : if ((!((unsafeHeaders()) == ((_o).unsafeHeaders())))) {
637 0 : return false;
638 : }
639 0 : return true;
640 : }
641 :
642 0 : auto CorsPreflightArgs::operator!=(const CorsPreflightArgs& _o) const -> bool
643 : {
644 0 : return (!(operator==(_o)));
645 : }
646 :
647 0 : auto CorsPreflightArgs::Init() -> void
648 : {
649 0 : }
650 :
651 0 : auto CorsPreflightArgs::Assign(const nsTArray<nsCString>& _unsafeHeaders) -> void
652 : {
653 0 : unsafeHeaders_ = _unsafeHeaders;
654 0 : }
655 :
656 : } // namespace net
657 : } // namespace mozilla
658 :
659 : //-----------------------------------------------------------------------------
660 : // Method definitions for the IPDL type |union OptionalCorsPreflightArgs|
661 : //
662 : namespace mozilla {
663 : namespace net {
664 30 : auto OptionalCorsPreflightArgs::MaybeDestroy(Type aNewType) -> bool
665 : {
666 30 : if ((mType) == (T__None)) {
667 18 : return true;
668 : }
669 12 : if ((mType) == (aNewType)) {
670 0 : return false;
671 : }
672 12 : switch (mType) {
673 : case Tvoid_t:
674 : {
675 12 : (ptr_void_t())->~void_t__tdef();
676 12 : break;
677 : }
678 : case TCorsPreflightArgs:
679 : {
680 0 : (ptr_CorsPreflightArgs())->~CorsPreflightArgs__tdef();
681 0 : break;
682 : }
683 : default:
684 : {
685 0 : mozilla::ipc::LogicError("not reached");
686 0 : break;
687 : }
688 : }
689 12 : return true;
690 : }
691 :
692 0 : MOZ_IMPLICIT OptionalCorsPreflightArgs::OptionalCorsPreflightArgs(const void_t& aOther)
693 : {
694 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
695 0 : mType = Tvoid_t;
696 0 : }
697 :
698 0 : MOZ_IMPLICIT OptionalCorsPreflightArgs::OptionalCorsPreflightArgs(const CorsPreflightArgs& aOther)
699 : {
700 0 : new (mozilla::KnownNotNull, ptr_CorsPreflightArgs()) CorsPreflightArgs(aOther);
701 0 : mType = TCorsPreflightArgs;
702 0 : }
703 :
704 0 : MOZ_IMPLICIT OptionalCorsPreflightArgs::OptionalCorsPreflightArgs(const OptionalCorsPreflightArgs& aOther)
705 : {
706 0 : (aOther).AssertSanity();
707 0 : switch ((aOther).type()) {
708 : case Tvoid_t:
709 : {
710 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
711 0 : break;
712 : }
713 : case TCorsPreflightArgs:
714 : {
715 0 : new (mozilla::KnownNotNull, ptr_CorsPreflightArgs()) CorsPreflightArgs((aOther).get_CorsPreflightArgs());
716 0 : break;
717 : }
718 : case T__None:
719 : {
720 0 : break;
721 : }
722 : default:
723 : {
724 0 : mozilla::ipc::LogicError("unreached");
725 0 : return;
726 : }
727 : }
728 0 : mType = (aOther).type();
729 : }
730 :
731 30 : OptionalCorsPreflightArgs::~OptionalCorsPreflightArgs()
732 : {
733 15 : static_cast<void>(MaybeDestroy(T__None));
734 15 : }
735 :
736 6 : auto OptionalCorsPreflightArgs::operator=(const void_t& aRhs) -> OptionalCorsPreflightArgs&
737 : {
738 6 : if (MaybeDestroy(Tvoid_t)) {
739 6 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
740 : }
741 6 : (*(ptr_void_t())) = aRhs;
742 6 : mType = Tvoid_t;
743 6 : return (*(this));
744 : }
745 :
746 0 : auto OptionalCorsPreflightArgs::operator=(const CorsPreflightArgs& aRhs) -> OptionalCorsPreflightArgs&
747 : {
748 0 : if (MaybeDestroy(TCorsPreflightArgs)) {
749 0 : new (mozilla::KnownNotNull, ptr_CorsPreflightArgs()) CorsPreflightArgs;
750 : }
751 0 : (*(ptr_CorsPreflightArgs())) = aRhs;
752 0 : mType = TCorsPreflightArgs;
753 0 : return (*(this));
754 : }
755 :
756 9 : auto OptionalCorsPreflightArgs::operator=(const OptionalCorsPreflightArgs& aRhs) -> OptionalCorsPreflightArgs&
757 : {
758 9 : (aRhs).AssertSanity();
759 9 : Type t = (aRhs).type();
760 9 : switch (t) {
761 : case Tvoid_t:
762 : {
763 6 : if (MaybeDestroy(t)) {
764 6 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
765 : }
766 6 : (*(ptr_void_t())) = (aRhs).get_void_t();
767 6 : break;
768 : }
769 : case TCorsPreflightArgs:
770 : {
771 0 : if (MaybeDestroy(t)) {
772 0 : new (mozilla::KnownNotNull, ptr_CorsPreflightArgs()) CorsPreflightArgs;
773 : }
774 0 : (*(ptr_CorsPreflightArgs())) = (aRhs).get_CorsPreflightArgs();
775 0 : break;
776 : }
777 : case T__None:
778 : {
779 3 : static_cast<void>(MaybeDestroy(t));
780 3 : break;
781 : }
782 : default:
783 : {
784 0 : mozilla::ipc::LogicError("unreached");
785 0 : break;
786 : }
787 : }
788 9 : mType = t;
789 9 : return (*(this));
790 : }
791 :
792 0 : auto OptionalCorsPreflightArgs::operator==(const void_t& aRhs) const -> bool
793 : {
794 0 : return (get_void_t()) == (aRhs);
795 : }
796 :
797 0 : auto OptionalCorsPreflightArgs::operator==(const CorsPreflightArgs& aRhs) const -> bool
798 : {
799 0 : return (get_CorsPreflightArgs()) == (aRhs);
800 : }
801 :
802 0 : auto OptionalCorsPreflightArgs::operator==(const OptionalCorsPreflightArgs& aRhs) const -> bool
803 : {
804 0 : if ((type()) != ((aRhs).type())) {
805 0 : return false;
806 : }
807 :
808 0 : switch (type()) {
809 : case Tvoid_t:
810 : {
811 0 : return (get_void_t()) == ((aRhs).get_void_t());
812 : }
813 : case TCorsPreflightArgs:
814 : {
815 0 : return (get_CorsPreflightArgs()) == ((aRhs).get_CorsPreflightArgs());
816 : }
817 : default:
818 : {
819 0 : mozilla::ipc::LogicError("unreached");
820 0 : return false;
821 : }
822 : }
823 : }
824 :
825 0 : auto OptionalCorsPreflightArgs::get(void_t* aOutValue) const -> void
826 : {
827 0 : (*(aOutValue)) = get_void_t();
828 0 : }
829 :
830 0 : auto OptionalCorsPreflightArgs::get(CorsPreflightArgs* aOutValue) const -> void
831 : {
832 0 : (*(aOutValue)) = get_CorsPreflightArgs();
833 0 : }
834 :
835 : } // namespace net
836 : } // namespace mozilla
837 :
838 : //-----------------------------------------------------------------------------
839 : // Method definitions for the IPDL type |struct HttpChannelOpenArgs|
840 : //
841 : namespace mozilla {
842 : namespace net {
843 9 : MOZ_IMPLICIT HttpChannelOpenArgs::HttpChannelOpenArgs() :
844 : referrerPolicy_(),
845 : loadFlags_(),
846 : requestHeaders_(),
847 : requestMethod_(),
848 : uploadStreamHasHeaders_(),
849 : priority_(),
850 : classOfService_(),
851 : redirectionLimit_(),
852 : allowSTS_(),
853 : thirdPartyFlags_(),
854 : resumeAt_(),
855 : startPos_(),
856 : entityID_(),
857 : chooseApplicationCache_(),
858 : appCacheClientID_(),
859 : allowSpdy_(),
860 : allowAltSvc_(),
861 : beConservative_(),
862 : synthesizedSecurityInfoSerialization_(),
863 : cacheKey_(),
864 : requestContextID_(),
865 : initialRwin_(),
866 : blockAuthPrompt_(),
867 : suspendAfterSynthesizeResponse_(),
868 : allowStaleCacheContent_(),
869 : contentTypeHint_(),
870 : channelId_(),
871 : contentWindowId_(),
872 : preferredAlternativeType_(),
873 : topLevelOuterContentWindowId_(),
874 : launchServiceWorkerStart_(),
875 : launchServiceWorkerEnd_(),
876 : dispatchFetchEventStart_(),
877 : dispatchFetchEventEnd_(),
878 : handleFetchEventStart_(),
879 9 : handleFetchEventEnd_()
880 : {
881 9 : Init();
882 9 : }
883 :
884 12 : HttpChannelOpenArgs::~HttpChannelOpenArgs()
885 : {
886 12 : }
887 :
888 0 : auto HttpChannelOpenArgs::operator==(const HttpChannelOpenArgs& _o) const -> bool
889 : {
890 0 : if ((!((uri()) == ((_o).uri())))) {
891 0 : return false;
892 : }
893 0 : if ((!((original()) == ((_o).original())))) {
894 0 : return false;
895 : }
896 0 : if ((!((doc()) == ((_o).doc())))) {
897 0 : return false;
898 : }
899 0 : if ((!((referrer()) == ((_o).referrer())))) {
900 0 : return false;
901 : }
902 0 : if ((!((referrerPolicy()) == ((_o).referrerPolicy())))) {
903 0 : return false;
904 : }
905 0 : if ((!((apiRedirectTo()) == ((_o).apiRedirectTo())))) {
906 0 : return false;
907 : }
908 0 : if ((!((topWindowURI()) == ((_o).topWindowURI())))) {
909 0 : return false;
910 : }
911 0 : if ((!((loadFlags()) == ((_o).loadFlags())))) {
912 0 : return false;
913 : }
914 0 : if ((!((requestHeaders()) == ((_o).requestHeaders())))) {
915 0 : return false;
916 : }
917 0 : if ((!((requestMethod()) == ((_o).requestMethod())))) {
918 0 : return false;
919 : }
920 0 : if ((!((uploadStream()) == ((_o).uploadStream())))) {
921 0 : return false;
922 : }
923 0 : if ((!((uploadStreamHasHeaders()) == ((_o).uploadStreamHasHeaders())))) {
924 0 : return false;
925 : }
926 0 : if ((!((priority()) == ((_o).priority())))) {
927 0 : return false;
928 : }
929 0 : if ((!((classOfService()) == ((_o).classOfService())))) {
930 0 : return false;
931 : }
932 0 : if ((!((redirectionLimit()) == ((_o).redirectionLimit())))) {
933 0 : return false;
934 : }
935 0 : if ((!((allowSTS()) == ((_o).allowSTS())))) {
936 0 : return false;
937 : }
938 0 : if ((!((thirdPartyFlags()) == ((_o).thirdPartyFlags())))) {
939 0 : return false;
940 : }
941 0 : if ((!((resumeAt()) == ((_o).resumeAt())))) {
942 0 : return false;
943 : }
944 0 : if ((!((startPos()) == ((_o).startPos())))) {
945 0 : return false;
946 : }
947 0 : if ((!((entityID()) == ((_o).entityID())))) {
948 0 : return false;
949 : }
950 0 : if ((!((chooseApplicationCache()) == ((_o).chooseApplicationCache())))) {
951 0 : return false;
952 : }
953 0 : if ((!((appCacheClientID()) == ((_o).appCacheClientID())))) {
954 0 : return false;
955 : }
956 0 : if ((!((allowSpdy()) == ((_o).allowSpdy())))) {
957 0 : return false;
958 : }
959 0 : if ((!((allowAltSvc()) == ((_o).allowAltSvc())))) {
960 0 : return false;
961 : }
962 0 : if ((!((beConservative()) == ((_o).beConservative())))) {
963 0 : return false;
964 : }
965 0 : if ((!((loadInfo()) == ((_o).loadInfo())))) {
966 0 : return false;
967 : }
968 0 : if ((!((synthesizedResponseHead()) == ((_o).synthesizedResponseHead())))) {
969 0 : return false;
970 : }
971 0 : if ((!((synthesizedSecurityInfoSerialization()) == ((_o).synthesizedSecurityInfoSerialization())))) {
972 0 : return false;
973 : }
974 0 : if ((!((cacheKey()) == ((_o).cacheKey())))) {
975 0 : return false;
976 : }
977 0 : if ((!((requestContextID()) == ((_o).requestContextID())))) {
978 0 : return false;
979 : }
980 0 : if ((!((preflightArgs()) == ((_o).preflightArgs())))) {
981 0 : return false;
982 : }
983 0 : if ((!((initialRwin()) == ((_o).initialRwin())))) {
984 0 : return false;
985 : }
986 0 : if ((!((blockAuthPrompt()) == ((_o).blockAuthPrompt())))) {
987 0 : return false;
988 : }
989 0 : if ((!((suspendAfterSynthesizeResponse()) == ((_o).suspendAfterSynthesizeResponse())))) {
990 0 : return false;
991 : }
992 0 : if ((!((allowStaleCacheContent()) == ((_o).allowStaleCacheContent())))) {
993 0 : return false;
994 : }
995 0 : if ((!((contentTypeHint()) == ((_o).contentTypeHint())))) {
996 0 : return false;
997 : }
998 0 : if ((!((channelId()) == ((_o).channelId())))) {
999 0 : return false;
1000 : }
1001 0 : if ((!((contentWindowId()) == ((_o).contentWindowId())))) {
1002 0 : return false;
1003 : }
1004 0 : if ((!((preferredAlternativeType()) == ((_o).preferredAlternativeType())))) {
1005 0 : return false;
1006 : }
1007 0 : if ((!((topLevelOuterContentWindowId()) == ((_o).topLevelOuterContentWindowId())))) {
1008 0 : return false;
1009 : }
1010 0 : if ((!((launchServiceWorkerStart()) == ((_o).launchServiceWorkerStart())))) {
1011 0 : return false;
1012 : }
1013 0 : if ((!((launchServiceWorkerEnd()) == ((_o).launchServiceWorkerEnd())))) {
1014 0 : return false;
1015 : }
1016 0 : if ((!((dispatchFetchEventStart()) == ((_o).dispatchFetchEventStart())))) {
1017 0 : return false;
1018 : }
1019 0 : if ((!((dispatchFetchEventEnd()) == ((_o).dispatchFetchEventEnd())))) {
1020 0 : return false;
1021 : }
1022 0 : if ((!((handleFetchEventStart()) == ((_o).handleFetchEventStart())))) {
1023 0 : return false;
1024 : }
1025 0 : if ((!((handleFetchEventEnd()) == ((_o).handleFetchEventEnd())))) {
1026 0 : return false;
1027 : }
1028 0 : return true;
1029 : }
1030 :
1031 0 : auto HttpChannelOpenArgs::operator!=(const HttpChannelOpenArgs& _o) const -> bool
1032 : {
1033 0 : return (!(operator==(_o)));
1034 : }
1035 :
1036 12 : auto HttpChannelOpenArgs::Init() -> void
1037 : {
1038 12 : }
1039 :
1040 6 : auto HttpChannelOpenArgs::Assign(
1041 : const URIParams& _uri,
1042 : const OptionalURIParams& _original,
1043 : const OptionalURIParams& _doc,
1044 : const OptionalURIParams& _referrer,
1045 : const uint32_t& _referrerPolicy,
1046 : const OptionalURIParams& _apiRedirectTo,
1047 : const OptionalURIParams& _topWindowURI,
1048 : const uint32_t& _loadFlags,
1049 : const RequestHeaderTuples& _requestHeaders,
1050 : const nsCString& _requestMethod,
1051 : const OptionalIPCStream& _uploadStream,
1052 : const bool& _uploadStreamHasHeaders,
1053 : const int16_t& _priority,
1054 : const uint32_t& _classOfService,
1055 : const uint8_t& _redirectionLimit,
1056 : const bool& _allowSTS,
1057 : const uint32_t& _thirdPartyFlags,
1058 : const bool& _resumeAt,
1059 : const uint64_t& _startPos,
1060 : const nsCString& _entityID,
1061 : const bool& _chooseApplicationCache,
1062 : const nsCString& _appCacheClientID,
1063 : const bool& _allowSpdy,
1064 : const bool& _allowAltSvc,
1065 : const bool& _beConservative,
1066 : const OptionalLoadInfoArgs& _loadInfo,
1067 : const OptionalHttpResponseHead& _synthesizedResponseHead,
1068 : const nsCString& _synthesizedSecurityInfoSerialization,
1069 : const uint32_t& _cacheKey,
1070 : const uint64_t& _requestContextID,
1071 : const OptionalCorsPreflightArgs& _preflightArgs,
1072 : const uint32_t& _initialRwin,
1073 : const bool& _blockAuthPrompt,
1074 : const bool& _suspendAfterSynthesizeResponse,
1075 : const bool& _allowStaleCacheContent,
1076 : const nsCString& _contentTypeHint,
1077 : const uint64_t& _channelId,
1078 : const uint64_t& _contentWindowId,
1079 : const nsCString& _preferredAlternativeType,
1080 : const uint64_t& _topLevelOuterContentWindowId,
1081 : const TimeStamp& _launchServiceWorkerStart,
1082 : const TimeStamp& _launchServiceWorkerEnd,
1083 : const TimeStamp& _dispatchFetchEventStart,
1084 : const TimeStamp& _dispatchFetchEventEnd,
1085 : const TimeStamp& _handleFetchEventStart,
1086 : const TimeStamp& _handleFetchEventEnd) -> void
1087 : {
1088 6 : uri_ = _uri;
1089 6 : original_ = _original;
1090 6 : doc_ = _doc;
1091 6 : referrer_ = _referrer;
1092 6 : referrerPolicy_ = _referrerPolicy;
1093 6 : apiRedirectTo_ = _apiRedirectTo;
1094 6 : topWindowURI_ = _topWindowURI;
1095 6 : loadFlags_ = _loadFlags;
1096 6 : requestHeaders_ = _requestHeaders;
1097 6 : requestMethod_ = _requestMethod;
1098 6 : uploadStream_ = _uploadStream;
1099 6 : uploadStreamHasHeaders_ = _uploadStreamHasHeaders;
1100 6 : priority_ = _priority;
1101 6 : classOfService_ = _classOfService;
1102 6 : redirectionLimit_ = _redirectionLimit;
1103 6 : allowSTS_ = _allowSTS;
1104 6 : thirdPartyFlags_ = _thirdPartyFlags;
1105 6 : resumeAt_ = _resumeAt;
1106 6 : startPos_ = _startPos;
1107 6 : entityID_ = _entityID;
1108 6 : chooseApplicationCache_ = _chooseApplicationCache;
1109 6 : appCacheClientID_ = _appCacheClientID;
1110 6 : allowSpdy_ = _allowSpdy;
1111 6 : allowAltSvc_ = _allowAltSvc;
1112 6 : beConservative_ = _beConservative;
1113 6 : loadInfo_ = _loadInfo;
1114 6 : synthesizedResponseHead_ = _synthesizedResponseHead;
1115 6 : synthesizedSecurityInfoSerialization_ = _synthesizedSecurityInfoSerialization;
1116 6 : cacheKey_ = _cacheKey;
1117 6 : requestContextID_ = _requestContextID;
1118 6 : preflightArgs_ = _preflightArgs;
1119 6 : initialRwin_ = _initialRwin;
1120 6 : blockAuthPrompt_ = _blockAuthPrompt;
1121 6 : suspendAfterSynthesizeResponse_ = _suspendAfterSynthesizeResponse;
1122 6 : allowStaleCacheContent_ = _allowStaleCacheContent;
1123 6 : contentTypeHint_ = _contentTypeHint;
1124 6 : channelId_ = _channelId;
1125 6 : contentWindowId_ = _contentWindowId;
1126 6 : preferredAlternativeType_ = _preferredAlternativeType;
1127 6 : topLevelOuterContentWindowId_ = _topLevelOuterContentWindowId;
1128 6 : launchServiceWorkerStart_ = _launchServiceWorkerStart;
1129 6 : launchServiceWorkerEnd_ = _launchServiceWorkerEnd;
1130 6 : dispatchFetchEventStart_ = _dispatchFetchEventStart;
1131 6 : dispatchFetchEventEnd_ = _dispatchFetchEventEnd;
1132 6 : handleFetchEventStart_ = _handleFetchEventStart;
1133 6 : handleFetchEventEnd_ = _handleFetchEventEnd;
1134 6 : }
1135 :
1136 : } // namespace net
1137 : } // namespace mozilla
1138 :
1139 : //-----------------------------------------------------------------------------
1140 : // Method definitions for the IPDL type |struct HttpChannelConnectArgs|
1141 : //
1142 : namespace mozilla {
1143 : namespace net {
1144 0 : MOZ_IMPLICIT HttpChannelConnectArgs::HttpChannelConnectArgs() :
1145 : registrarId_(),
1146 0 : shouldIntercept_()
1147 : {
1148 0 : Init();
1149 0 : }
1150 :
1151 0 : HttpChannelConnectArgs::~HttpChannelConnectArgs()
1152 : {
1153 0 : }
1154 :
1155 0 : auto HttpChannelConnectArgs::operator==(const HttpChannelConnectArgs& _o) const -> bool
1156 : {
1157 0 : if ((!((registrarId()) == ((_o).registrarId())))) {
1158 0 : return false;
1159 : }
1160 0 : if ((!((shouldIntercept()) == ((_o).shouldIntercept())))) {
1161 0 : return false;
1162 : }
1163 0 : return true;
1164 : }
1165 :
1166 0 : auto HttpChannelConnectArgs::operator!=(const HttpChannelConnectArgs& _o) const -> bool
1167 : {
1168 0 : return (!(operator==(_o)));
1169 : }
1170 :
1171 0 : auto HttpChannelConnectArgs::Init() -> void
1172 : {
1173 0 : }
1174 :
1175 0 : auto HttpChannelConnectArgs::Assign(
1176 : const uint32_t& _registrarId,
1177 : const bool& _shouldIntercept) -> void
1178 : {
1179 0 : registrarId_ = _registrarId;
1180 0 : shouldIntercept_ = _shouldIntercept;
1181 0 : }
1182 :
1183 : } // namespace net
1184 : } // namespace mozilla
1185 :
1186 : //-----------------------------------------------------------------------------
1187 : // Method definitions for the IPDL type |union HttpChannelCreationArgs|
1188 : //
1189 : namespace mozilla {
1190 : namespace net {
1191 9 : auto HttpChannelCreationArgs::MaybeDestroy(Type aNewType) -> bool
1192 : {
1193 9 : if ((mType) == (T__None)) {
1194 3 : return true;
1195 : }
1196 6 : if ((mType) == (aNewType)) {
1197 0 : return false;
1198 : }
1199 6 : switch (mType) {
1200 : case THttpChannelOpenArgs:
1201 : {
1202 6 : (ptr_HttpChannelOpenArgs())->~HttpChannelOpenArgs__tdef();
1203 6 : break;
1204 : }
1205 : case THttpChannelConnectArgs:
1206 : {
1207 0 : (ptr_HttpChannelConnectArgs())->~HttpChannelConnectArgs__tdef();
1208 0 : break;
1209 : }
1210 : default:
1211 : {
1212 0 : mozilla::ipc::LogicError("not reached");
1213 0 : break;
1214 : }
1215 : }
1216 6 : return true;
1217 : }
1218 :
1219 3 : MOZ_IMPLICIT HttpChannelCreationArgs::HttpChannelCreationArgs(const HttpChannelOpenArgs& aOther)
1220 : {
1221 3 : new (mozilla::KnownNotNull, ptr_HttpChannelOpenArgs()) HttpChannelOpenArgs(aOther);
1222 3 : mType = THttpChannelOpenArgs;
1223 3 : }
1224 :
1225 0 : MOZ_IMPLICIT HttpChannelCreationArgs::HttpChannelCreationArgs(const HttpChannelConnectArgs& aOther)
1226 : {
1227 0 : new (mozilla::KnownNotNull, ptr_HttpChannelConnectArgs()) HttpChannelConnectArgs(aOther);
1228 0 : mType = THttpChannelConnectArgs;
1229 0 : }
1230 :
1231 0 : MOZ_IMPLICIT HttpChannelCreationArgs::HttpChannelCreationArgs(const HttpChannelCreationArgs& aOther)
1232 : {
1233 0 : (aOther).AssertSanity();
1234 0 : switch ((aOther).type()) {
1235 : case THttpChannelOpenArgs:
1236 : {
1237 0 : new (mozilla::KnownNotNull, ptr_HttpChannelOpenArgs()) HttpChannelOpenArgs((aOther).get_HttpChannelOpenArgs());
1238 0 : break;
1239 : }
1240 : case THttpChannelConnectArgs:
1241 : {
1242 0 : new (mozilla::KnownNotNull, ptr_HttpChannelConnectArgs()) HttpChannelConnectArgs((aOther).get_HttpChannelConnectArgs());
1243 0 : break;
1244 : }
1245 : case T__None:
1246 : {
1247 0 : break;
1248 : }
1249 : default:
1250 : {
1251 0 : mozilla::ipc::LogicError("unreached");
1252 0 : return;
1253 : }
1254 : }
1255 0 : mType = (aOther).type();
1256 : }
1257 :
1258 12 : HttpChannelCreationArgs::~HttpChannelCreationArgs()
1259 : {
1260 6 : static_cast<void>(MaybeDestroy(T__None));
1261 6 : }
1262 :
1263 3 : auto HttpChannelCreationArgs::operator=(const HttpChannelOpenArgs& aRhs) -> HttpChannelCreationArgs&
1264 : {
1265 3 : if (MaybeDestroy(THttpChannelOpenArgs)) {
1266 3 : new (mozilla::KnownNotNull, ptr_HttpChannelOpenArgs()) HttpChannelOpenArgs;
1267 : }
1268 3 : (*(ptr_HttpChannelOpenArgs())) = aRhs;
1269 3 : mType = THttpChannelOpenArgs;
1270 3 : return (*(this));
1271 : }
1272 :
1273 0 : auto HttpChannelCreationArgs::operator=(const HttpChannelConnectArgs& aRhs) -> HttpChannelCreationArgs&
1274 : {
1275 0 : if (MaybeDestroy(THttpChannelConnectArgs)) {
1276 0 : new (mozilla::KnownNotNull, ptr_HttpChannelConnectArgs()) HttpChannelConnectArgs;
1277 : }
1278 0 : (*(ptr_HttpChannelConnectArgs())) = aRhs;
1279 0 : mType = THttpChannelConnectArgs;
1280 0 : return (*(this));
1281 : }
1282 :
1283 0 : auto HttpChannelCreationArgs::operator=(const HttpChannelCreationArgs& aRhs) -> HttpChannelCreationArgs&
1284 : {
1285 0 : (aRhs).AssertSanity();
1286 0 : Type t = (aRhs).type();
1287 0 : switch (t) {
1288 : case THttpChannelOpenArgs:
1289 : {
1290 0 : if (MaybeDestroy(t)) {
1291 0 : new (mozilla::KnownNotNull, ptr_HttpChannelOpenArgs()) HttpChannelOpenArgs;
1292 : }
1293 0 : (*(ptr_HttpChannelOpenArgs())) = (aRhs).get_HttpChannelOpenArgs();
1294 0 : break;
1295 : }
1296 : case THttpChannelConnectArgs:
1297 : {
1298 0 : if (MaybeDestroy(t)) {
1299 0 : new (mozilla::KnownNotNull, ptr_HttpChannelConnectArgs()) HttpChannelConnectArgs;
1300 : }
1301 0 : (*(ptr_HttpChannelConnectArgs())) = (aRhs).get_HttpChannelConnectArgs();
1302 0 : break;
1303 : }
1304 : case T__None:
1305 : {
1306 0 : static_cast<void>(MaybeDestroy(t));
1307 0 : break;
1308 : }
1309 : default:
1310 : {
1311 0 : mozilla::ipc::LogicError("unreached");
1312 0 : break;
1313 : }
1314 : }
1315 0 : mType = t;
1316 0 : return (*(this));
1317 : }
1318 :
1319 0 : auto HttpChannelCreationArgs::operator==(const HttpChannelOpenArgs& aRhs) const -> bool
1320 : {
1321 0 : return (get_HttpChannelOpenArgs()) == (aRhs);
1322 : }
1323 :
1324 0 : auto HttpChannelCreationArgs::operator==(const HttpChannelConnectArgs& aRhs) const -> bool
1325 : {
1326 0 : return (get_HttpChannelConnectArgs()) == (aRhs);
1327 : }
1328 :
1329 0 : auto HttpChannelCreationArgs::operator==(const HttpChannelCreationArgs& aRhs) const -> bool
1330 : {
1331 0 : if ((type()) != ((aRhs).type())) {
1332 0 : return false;
1333 : }
1334 :
1335 0 : switch (type()) {
1336 : case THttpChannelOpenArgs:
1337 : {
1338 0 : return (get_HttpChannelOpenArgs()) == ((aRhs).get_HttpChannelOpenArgs());
1339 : }
1340 : case THttpChannelConnectArgs:
1341 : {
1342 0 : return (get_HttpChannelConnectArgs()) == ((aRhs).get_HttpChannelConnectArgs());
1343 : }
1344 : default:
1345 : {
1346 0 : mozilla::ipc::LogicError("unreached");
1347 0 : return false;
1348 : }
1349 : }
1350 : }
1351 :
1352 0 : auto HttpChannelCreationArgs::get(HttpChannelOpenArgs* aOutValue) const -> void
1353 : {
1354 0 : (*(aOutValue)) = get_HttpChannelOpenArgs();
1355 0 : }
1356 :
1357 0 : auto HttpChannelCreationArgs::get(HttpChannelConnectArgs* aOutValue) const -> void
1358 : {
1359 0 : (*(aOutValue)) = get_HttpChannelConnectArgs();
1360 0 : }
1361 :
1362 : } // namespace net
1363 : } // namespace mozilla
1364 :
1365 : //-----------------------------------------------------------------------------
1366 : // Method definitions for the IPDL type |struct FTPChannelOpenArgs|
1367 : //
1368 : namespace mozilla {
1369 : namespace net {
1370 0 : MOZ_IMPLICIT FTPChannelOpenArgs::FTPChannelOpenArgs() :
1371 : startPos_(),
1372 0 : entityID_()
1373 : {
1374 0 : Init();
1375 0 : }
1376 :
1377 0 : FTPChannelOpenArgs::~FTPChannelOpenArgs()
1378 : {
1379 0 : }
1380 :
1381 0 : auto FTPChannelOpenArgs::operator==(const FTPChannelOpenArgs& _o) const -> bool
1382 : {
1383 0 : if ((!((uri()) == ((_o).uri())))) {
1384 0 : return false;
1385 : }
1386 0 : if ((!((startPos()) == ((_o).startPos())))) {
1387 0 : return false;
1388 : }
1389 0 : if ((!((entityID()) == ((_o).entityID())))) {
1390 0 : return false;
1391 : }
1392 0 : if ((!((uploadStream()) == ((_o).uploadStream())))) {
1393 0 : return false;
1394 : }
1395 0 : if ((!((loadInfo()) == ((_o).loadInfo())))) {
1396 0 : return false;
1397 : }
1398 0 : return true;
1399 : }
1400 :
1401 0 : auto FTPChannelOpenArgs::operator!=(const FTPChannelOpenArgs& _o) const -> bool
1402 : {
1403 0 : return (!(operator==(_o)));
1404 : }
1405 :
1406 0 : auto FTPChannelOpenArgs::Init() -> void
1407 : {
1408 0 : }
1409 :
1410 0 : auto FTPChannelOpenArgs::Assign(
1411 : const URIParams& _uri,
1412 : const uint64_t& _startPos,
1413 : const nsCString& _entityID,
1414 : const OptionalIPCStream& _uploadStream,
1415 : const OptionalLoadInfoArgs& _loadInfo) -> void
1416 : {
1417 0 : uri_ = _uri;
1418 0 : startPos_ = _startPos;
1419 0 : entityID_ = _entityID;
1420 0 : uploadStream_ = _uploadStream;
1421 0 : loadInfo_ = _loadInfo;
1422 0 : }
1423 :
1424 : } // namespace net
1425 : } // namespace mozilla
1426 :
1427 : //-----------------------------------------------------------------------------
1428 : // Method definitions for the IPDL type |struct FTPChannelConnectArgs|
1429 : //
1430 : namespace mozilla {
1431 : namespace net {
1432 0 : MOZ_IMPLICIT FTPChannelConnectArgs::FTPChannelConnectArgs() :
1433 0 : channelId_()
1434 : {
1435 0 : Init();
1436 0 : }
1437 :
1438 0 : FTPChannelConnectArgs::~FTPChannelConnectArgs()
1439 : {
1440 0 : }
1441 :
1442 0 : auto FTPChannelConnectArgs::operator==(const FTPChannelConnectArgs& _o) const -> bool
1443 : {
1444 0 : if ((!((channelId()) == ((_o).channelId())))) {
1445 0 : return false;
1446 : }
1447 0 : return true;
1448 : }
1449 :
1450 0 : auto FTPChannelConnectArgs::operator!=(const FTPChannelConnectArgs& _o) const -> bool
1451 : {
1452 0 : return (!(operator==(_o)));
1453 : }
1454 :
1455 0 : auto FTPChannelConnectArgs::Init() -> void
1456 : {
1457 0 : }
1458 :
1459 0 : auto FTPChannelConnectArgs::Assign(const uint32_t& _channelId) -> void
1460 : {
1461 0 : channelId_ = _channelId;
1462 0 : }
1463 :
1464 : } // namespace net
1465 : } // namespace mozilla
1466 :
1467 : //-----------------------------------------------------------------------------
1468 : // Method definitions for the IPDL type |union FTPChannelCreationArgs|
1469 : //
1470 : namespace mozilla {
1471 : namespace net {
1472 0 : auto FTPChannelCreationArgs::MaybeDestroy(Type aNewType) -> bool
1473 : {
1474 0 : if ((mType) == (T__None)) {
1475 0 : return true;
1476 : }
1477 0 : if ((mType) == (aNewType)) {
1478 0 : return false;
1479 : }
1480 0 : switch (mType) {
1481 : case TFTPChannelOpenArgs:
1482 : {
1483 0 : (ptr_FTPChannelOpenArgs())->~FTPChannelOpenArgs__tdef();
1484 0 : break;
1485 : }
1486 : case TFTPChannelConnectArgs:
1487 : {
1488 0 : (ptr_FTPChannelConnectArgs())->~FTPChannelConnectArgs__tdef();
1489 0 : break;
1490 : }
1491 : default:
1492 : {
1493 0 : mozilla::ipc::LogicError("not reached");
1494 0 : break;
1495 : }
1496 : }
1497 0 : return true;
1498 : }
1499 :
1500 0 : MOZ_IMPLICIT FTPChannelCreationArgs::FTPChannelCreationArgs(const FTPChannelOpenArgs& aOther)
1501 : {
1502 0 : new (mozilla::KnownNotNull, ptr_FTPChannelOpenArgs()) FTPChannelOpenArgs(aOther);
1503 0 : mType = TFTPChannelOpenArgs;
1504 0 : }
1505 :
1506 0 : MOZ_IMPLICIT FTPChannelCreationArgs::FTPChannelCreationArgs(const FTPChannelConnectArgs& aOther)
1507 : {
1508 0 : new (mozilla::KnownNotNull, ptr_FTPChannelConnectArgs()) FTPChannelConnectArgs(aOther);
1509 0 : mType = TFTPChannelConnectArgs;
1510 0 : }
1511 :
1512 0 : MOZ_IMPLICIT FTPChannelCreationArgs::FTPChannelCreationArgs(const FTPChannelCreationArgs& aOther)
1513 : {
1514 0 : (aOther).AssertSanity();
1515 0 : switch ((aOther).type()) {
1516 : case TFTPChannelOpenArgs:
1517 : {
1518 0 : new (mozilla::KnownNotNull, ptr_FTPChannelOpenArgs()) FTPChannelOpenArgs((aOther).get_FTPChannelOpenArgs());
1519 0 : break;
1520 : }
1521 : case TFTPChannelConnectArgs:
1522 : {
1523 0 : new (mozilla::KnownNotNull, ptr_FTPChannelConnectArgs()) FTPChannelConnectArgs((aOther).get_FTPChannelConnectArgs());
1524 0 : break;
1525 : }
1526 : case T__None:
1527 : {
1528 0 : break;
1529 : }
1530 : default:
1531 : {
1532 0 : mozilla::ipc::LogicError("unreached");
1533 0 : return;
1534 : }
1535 : }
1536 0 : mType = (aOther).type();
1537 : }
1538 :
1539 0 : FTPChannelCreationArgs::~FTPChannelCreationArgs()
1540 : {
1541 0 : static_cast<void>(MaybeDestroy(T__None));
1542 0 : }
1543 :
1544 0 : auto FTPChannelCreationArgs::operator=(const FTPChannelOpenArgs& aRhs) -> FTPChannelCreationArgs&
1545 : {
1546 0 : if (MaybeDestroy(TFTPChannelOpenArgs)) {
1547 0 : new (mozilla::KnownNotNull, ptr_FTPChannelOpenArgs()) FTPChannelOpenArgs;
1548 : }
1549 0 : (*(ptr_FTPChannelOpenArgs())) = aRhs;
1550 0 : mType = TFTPChannelOpenArgs;
1551 0 : return (*(this));
1552 : }
1553 :
1554 0 : auto FTPChannelCreationArgs::operator=(const FTPChannelConnectArgs& aRhs) -> FTPChannelCreationArgs&
1555 : {
1556 0 : if (MaybeDestroy(TFTPChannelConnectArgs)) {
1557 0 : new (mozilla::KnownNotNull, ptr_FTPChannelConnectArgs()) FTPChannelConnectArgs;
1558 : }
1559 0 : (*(ptr_FTPChannelConnectArgs())) = aRhs;
1560 0 : mType = TFTPChannelConnectArgs;
1561 0 : return (*(this));
1562 : }
1563 :
1564 0 : auto FTPChannelCreationArgs::operator=(const FTPChannelCreationArgs& aRhs) -> FTPChannelCreationArgs&
1565 : {
1566 0 : (aRhs).AssertSanity();
1567 0 : Type t = (aRhs).type();
1568 0 : switch (t) {
1569 : case TFTPChannelOpenArgs:
1570 : {
1571 0 : if (MaybeDestroy(t)) {
1572 0 : new (mozilla::KnownNotNull, ptr_FTPChannelOpenArgs()) FTPChannelOpenArgs;
1573 : }
1574 0 : (*(ptr_FTPChannelOpenArgs())) = (aRhs).get_FTPChannelOpenArgs();
1575 0 : break;
1576 : }
1577 : case TFTPChannelConnectArgs:
1578 : {
1579 0 : if (MaybeDestroy(t)) {
1580 0 : new (mozilla::KnownNotNull, ptr_FTPChannelConnectArgs()) FTPChannelConnectArgs;
1581 : }
1582 0 : (*(ptr_FTPChannelConnectArgs())) = (aRhs).get_FTPChannelConnectArgs();
1583 0 : break;
1584 : }
1585 : case T__None:
1586 : {
1587 0 : static_cast<void>(MaybeDestroy(t));
1588 0 : break;
1589 : }
1590 : default:
1591 : {
1592 0 : mozilla::ipc::LogicError("unreached");
1593 0 : break;
1594 : }
1595 : }
1596 0 : mType = t;
1597 0 : return (*(this));
1598 : }
1599 :
1600 0 : auto FTPChannelCreationArgs::operator==(const FTPChannelOpenArgs& aRhs) const -> bool
1601 : {
1602 0 : return (get_FTPChannelOpenArgs()) == (aRhs);
1603 : }
1604 :
1605 0 : auto FTPChannelCreationArgs::operator==(const FTPChannelConnectArgs& aRhs) const -> bool
1606 : {
1607 0 : return (get_FTPChannelConnectArgs()) == (aRhs);
1608 : }
1609 :
1610 0 : auto FTPChannelCreationArgs::operator==(const FTPChannelCreationArgs& aRhs) const -> bool
1611 : {
1612 0 : if ((type()) != ((aRhs).type())) {
1613 0 : return false;
1614 : }
1615 :
1616 0 : switch (type()) {
1617 : case TFTPChannelOpenArgs:
1618 : {
1619 0 : return (get_FTPChannelOpenArgs()) == ((aRhs).get_FTPChannelOpenArgs());
1620 : }
1621 : case TFTPChannelConnectArgs:
1622 : {
1623 0 : return (get_FTPChannelConnectArgs()) == ((aRhs).get_FTPChannelConnectArgs());
1624 : }
1625 : default:
1626 : {
1627 0 : mozilla::ipc::LogicError("unreached");
1628 0 : return false;
1629 : }
1630 : }
1631 : }
1632 :
1633 0 : auto FTPChannelCreationArgs::get(FTPChannelOpenArgs* aOutValue) const -> void
1634 : {
1635 0 : (*(aOutValue)) = get_FTPChannelOpenArgs();
1636 0 : }
1637 :
1638 0 : auto FTPChannelCreationArgs::get(FTPChannelConnectArgs* aOutValue) const -> void
1639 : {
1640 0 : (*(aOutValue)) = get_FTPChannelConnectArgs();
1641 0 : }
1642 :
1643 : } // namespace net
1644 : } // namespace mozilla
1645 :
1646 : //-----------------------------------------------------------------------------
1647 : // Method definitions for the IPDL type |struct HttpChannelDiverterArgs|
1648 : //
1649 : namespace mozilla {
1650 : namespace net {
1651 0 : MOZ_IMPLICIT HttpChannelDiverterArgs::HttpChannelDiverterArgs() :
1652 0 : mApplyConversion_()
1653 : {
1654 0 : Init();
1655 0 : }
1656 :
1657 0 : HttpChannelDiverterArgs::~HttpChannelDiverterArgs()
1658 : {
1659 0 : }
1660 :
1661 0 : auto HttpChannelDiverterArgs::operator==(const HttpChannelDiverterArgs& _o) const -> bool
1662 : {
1663 0 : if ((!((mChannelParent()) == ((_o).mChannelParent())))) {
1664 0 : return false;
1665 : }
1666 0 : if ((!((mChannelChild()) == ((_o).mChannelChild())))) {
1667 0 : return false;
1668 : }
1669 0 : if ((!((mApplyConversion()) == ((_o).mApplyConversion())))) {
1670 0 : return false;
1671 : }
1672 0 : return true;
1673 : }
1674 :
1675 0 : auto HttpChannelDiverterArgs::operator!=(const HttpChannelDiverterArgs& _o) const -> bool
1676 : {
1677 0 : return (!(operator==(_o)));
1678 : }
1679 :
1680 0 : auto HttpChannelDiverterArgs::Init() -> void
1681 : {
1682 0 : mChannelParent_ = nullptr;
1683 0 : mChannelChild_ = nullptr;
1684 0 : }
1685 :
1686 0 : auto HttpChannelDiverterArgs::Assign(
1687 : PHttpChannelParent* _mChannelParent,
1688 : PHttpChannelChild* _mChannelChild,
1689 : const bool& _mApplyConversion) -> void
1690 : {
1691 0 : mChannelParent_ = _mChannelParent;
1692 0 : mChannelChild_ = _mChannelChild;
1693 0 : mApplyConversion_ = _mApplyConversion;
1694 0 : }
1695 :
1696 : } // namespace net
1697 : } // namespace mozilla
1698 :
1699 : //-----------------------------------------------------------------------------
1700 : // Method definitions for the IPDL type |union ChannelDiverterArgs|
1701 : //
1702 : namespace mozilla {
1703 : namespace net {
1704 0 : auto ChannelDiverterArgs::MaybeDestroy(Type aNewType) -> bool
1705 : {
1706 0 : if ((mType) == (T__None)) {
1707 0 : return true;
1708 : }
1709 0 : if ((mType) == (aNewType)) {
1710 0 : return false;
1711 : }
1712 0 : switch (mType) {
1713 : case THttpChannelDiverterArgs:
1714 : {
1715 0 : (ptr_HttpChannelDiverterArgs())->~HttpChannelDiverterArgs__tdef();
1716 0 : break;
1717 : }
1718 : case TPFTPChannelParent:
1719 : {
1720 0 : (ptr_PFTPChannelParent())->~PFTPChannelParent__tdef();
1721 0 : break;
1722 : }
1723 : case TPFTPChannelChild:
1724 : {
1725 0 : (ptr_PFTPChannelChild())->~PFTPChannelChild__tdef();
1726 0 : break;
1727 : }
1728 : default:
1729 : {
1730 0 : mozilla::ipc::LogicError("not reached");
1731 0 : break;
1732 : }
1733 : }
1734 0 : return true;
1735 : }
1736 :
1737 0 : MOZ_IMPLICIT ChannelDiverterArgs::ChannelDiverterArgs(const HttpChannelDiverterArgs& aOther)
1738 : {
1739 0 : new (mozilla::KnownNotNull, ptr_HttpChannelDiverterArgs()) HttpChannelDiverterArgs(aOther);
1740 0 : mType = THttpChannelDiverterArgs;
1741 0 : }
1742 :
1743 0 : MOZ_IMPLICIT ChannelDiverterArgs::ChannelDiverterArgs(PFTPChannelParent* aOther)
1744 : {
1745 0 : new (mozilla::KnownNotNull, ptr_PFTPChannelParent()) PFTPChannelParent*(const_cast<PFTPChannelParent*>(aOther));
1746 0 : mType = TPFTPChannelParent;
1747 0 : }
1748 :
1749 0 : MOZ_IMPLICIT ChannelDiverterArgs::ChannelDiverterArgs(PFTPChannelChild* aOther)
1750 : {
1751 0 : new (mozilla::KnownNotNull, ptr_PFTPChannelChild()) PFTPChannelChild*(const_cast<PFTPChannelChild*>(aOther));
1752 0 : mType = TPFTPChannelChild;
1753 0 : }
1754 :
1755 0 : MOZ_IMPLICIT ChannelDiverterArgs::ChannelDiverterArgs(const ChannelDiverterArgs& aOther)
1756 : {
1757 0 : (aOther).AssertSanity();
1758 0 : switch ((aOther).type()) {
1759 : case THttpChannelDiverterArgs:
1760 : {
1761 0 : new (mozilla::KnownNotNull, ptr_HttpChannelDiverterArgs()) HttpChannelDiverterArgs((aOther).get_HttpChannelDiverterArgs());
1762 0 : break;
1763 : }
1764 : case TPFTPChannelParent:
1765 : {
1766 0 : new (mozilla::KnownNotNull, ptr_PFTPChannelParent()) PFTPChannelParent*(const_cast<PFTPChannelParent*>((aOther).get_PFTPChannelParent()));
1767 0 : break;
1768 : }
1769 : case TPFTPChannelChild:
1770 : {
1771 0 : new (mozilla::KnownNotNull, ptr_PFTPChannelChild()) PFTPChannelChild*(const_cast<PFTPChannelChild*>((aOther).get_PFTPChannelChild()));
1772 0 : break;
1773 : }
1774 : case T__None:
1775 : {
1776 0 : break;
1777 : }
1778 : default:
1779 : {
1780 0 : mozilla::ipc::LogicError("unreached");
1781 0 : return;
1782 : }
1783 : }
1784 0 : mType = (aOther).type();
1785 : }
1786 :
1787 0 : ChannelDiverterArgs::~ChannelDiverterArgs()
1788 : {
1789 0 : static_cast<void>(MaybeDestroy(T__None));
1790 0 : }
1791 :
1792 0 : auto ChannelDiverterArgs::operator=(const HttpChannelDiverterArgs& aRhs) -> ChannelDiverterArgs&
1793 : {
1794 0 : if (MaybeDestroy(THttpChannelDiverterArgs)) {
1795 0 : new (mozilla::KnownNotNull, ptr_HttpChannelDiverterArgs()) HttpChannelDiverterArgs;
1796 : }
1797 0 : (*(ptr_HttpChannelDiverterArgs())) = aRhs;
1798 0 : mType = THttpChannelDiverterArgs;
1799 0 : return (*(this));
1800 : }
1801 :
1802 0 : auto ChannelDiverterArgs::operator=(PFTPChannelParent* aRhs) -> ChannelDiverterArgs&
1803 : {
1804 0 : if (MaybeDestroy(TPFTPChannelParent)) {
1805 0 : new (mozilla::KnownNotNull, ptr_PFTPChannelParent()) PFTPChannelParent*;
1806 : }
1807 0 : (*(ptr_PFTPChannelParent())) = const_cast<PFTPChannelParent*>(aRhs);
1808 0 : mType = TPFTPChannelParent;
1809 0 : return (*(this));
1810 : }
1811 :
1812 0 : auto ChannelDiverterArgs::operator=(PFTPChannelChild* aRhs) -> ChannelDiverterArgs&
1813 : {
1814 0 : if (MaybeDestroy(TPFTPChannelChild)) {
1815 0 : new (mozilla::KnownNotNull, ptr_PFTPChannelChild()) PFTPChannelChild*;
1816 : }
1817 0 : (*(ptr_PFTPChannelChild())) = const_cast<PFTPChannelChild*>(aRhs);
1818 0 : mType = TPFTPChannelChild;
1819 0 : return (*(this));
1820 : }
1821 :
1822 0 : auto ChannelDiverterArgs::operator=(const ChannelDiverterArgs& aRhs) -> ChannelDiverterArgs&
1823 : {
1824 0 : (aRhs).AssertSanity();
1825 0 : Type t = (aRhs).type();
1826 0 : switch (t) {
1827 : case THttpChannelDiverterArgs:
1828 : {
1829 0 : if (MaybeDestroy(t)) {
1830 0 : new (mozilla::KnownNotNull, ptr_HttpChannelDiverterArgs()) HttpChannelDiverterArgs;
1831 : }
1832 0 : (*(ptr_HttpChannelDiverterArgs())) = (aRhs).get_HttpChannelDiverterArgs();
1833 0 : break;
1834 : }
1835 : case TPFTPChannelParent:
1836 : {
1837 0 : if (MaybeDestroy(t)) {
1838 0 : new (mozilla::KnownNotNull, ptr_PFTPChannelParent()) PFTPChannelParent*;
1839 : }
1840 0 : (*(ptr_PFTPChannelParent())) = const_cast<PFTPChannelParent*>((aRhs).get_PFTPChannelParent());
1841 0 : break;
1842 : }
1843 : case TPFTPChannelChild:
1844 : {
1845 0 : if (MaybeDestroy(t)) {
1846 0 : new (mozilla::KnownNotNull, ptr_PFTPChannelChild()) PFTPChannelChild*;
1847 : }
1848 0 : (*(ptr_PFTPChannelChild())) = const_cast<PFTPChannelChild*>((aRhs).get_PFTPChannelChild());
1849 0 : break;
1850 : }
1851 : case T__None:
1852 : {
1853 0 : static_cast<void>(MaybeDestroy(t));
1854 0 : break;
1855 : }
1856 : default:
1857 : {
1858 0 : mozilla::ipc::LogicError("unreached");
1859 0 : break;
1860 : }
1861 : }
1862 0 : mType = t;
1863 0 : return (*(this));
1864 : }
1865 :
1866 0 : auto ChannelDiverterArgs::operator==(const HttpChannelDiverterArgs& aRhs) const -> bool
1867 : {
1868 0 : return (get_HttpChannelDiverterArgs()) == (aRhs);
1869 : }
1870 :
1871 0 : auto ChannelDiverterArgs::operator==(PFTPChannelParent* aRhs) const -> bool
1872 : {
1873 0 : return (get_PFTPChannelParent()) == (aRhs);
1874 : }
1875 :
1876 0 : auto ChannelDiverterArgs::operator==(PFTPChannelChild* aRhs) const -> bool
1877 : {
1878 0 : return (get_PFTPChannelChild()) == (aRhs);
1879 : }
1880 :
1881 0 : auto ChannelDiverterArgs::operator==(const ChannelDiverterArgs& aRhs) const -> bool
1882 : {
1883 0 : if ((type()) != ((aRhs).type())) {
1884 0 : return false;
1885 : }
1886 :
1887 0 : switch (type()) {
1888 : case THttpChannelDiverterArgs:
1889 : {
1890 0 : return (get_HttpChannelDiverterArgs()) == ((aRhs).get_HttpChannelDiverterArgs());
1891 : }
1892 : case TPFTPChannelParent:
1893 : {
1894 0 : return (get_PFTPChannelParent()) == ((aRhs).get_PFTPChannelParent());
1895 : }
1896 : case TPFTPChannelChild:
1897 : {
1898 0 : return (get_PFTPChannelChild()) == ((aRhs).get_PFTPChannelChild());
1899 : }
1900 : default:
1901 : {
1902 0 : mozilla::ipc::LogicError("unreached");
1903 0 : return false;
1904 : }
1905 : }
1906 : }
1907 :
1908 0 : auto ChannelDiverterArgs::get(HttpChannelDiverterArgs* aOutValue) const -> void
1909 : {
1910 0 : (*(aOutValue)) = get_HttpChannelDiverterArgs();
1911 0 : }
1912 :
1913 0 : auto ChannelDiverterArgs::get(PFTPChannelParent** aOutValue) const -> void
1914 : {
1915 0 : (*(aOutValue)) = get_PFTPChannelParent();
1916 0 : }
1917 :
1918 0 : auto ChannelDiverterArgs::get(PFTPChannelChild** aOutValue) const -> void
1919 : {
1920 0 : (*(aOutValue)) = get_PFTPChannelChild();
1921 0 : }
1922 :
1923 : } // namespace net
1924 : } // namespace mozilla
1925 :
1926 : //-----------------------------------------------------------------------------
1927 : // Method definitions for the IPDL type |struct RtspChannelConnectArgs|
1928 : //
1929 : namespace mozilla {
1930 : namespace net {
1931 0 : MOZ_IMPLICIT RtspChannelConnectArgs::RtspChannelConnectArgs() :
1932 0 : channelId_()
1933 : {
1934 0 : Init();
1935 0 : }
1936 :
1937 0 : RtspChannelConnectArgs::~RtspChannelConnectArgs()
1938 : {
1939 0 : }
1940 :
1941 0 : auto RtspChannelConnectArgs::operator==(const RtspChannelConnectArgs& _o) const -> bool
1942 : {
1943 0 : if ((!((uri()) == ((_o).uri())))) {
1944 0 : return false;
1945 : }
1946 0 : if ((!((channelId()) == ((_o).channelId())))) {
1947 0 : return false;
1948 : }
1949 0 : return true;
1950 : }
1951 :
1952 0 : auto RtspChannelConnectArgs::operator!=(const RtspChannelConnectArgs& _o) const -> bool
1953 : {
1954 0 : return (!(operator==(_o)));
1955 : }
1956 :
1957 0 : auto RtspChannelConnectArgs::Init() -> void
1958 : {
1959 0 : }
1960 :
1961 0 : auto RtspChannelConnectArgs::Assign(
1962 : const URIParams& _uri,
1963 : const uint32_t& _channelId) -> void
1964 : {
1965 0 : uri_ = _uri;
1966 0 : channelId_ = _channelId;
1967 0 : }
1968 :
1969 : } // namespace net
1970 : } // namespace mozilla
|
