Bug Summary

File:root/firefox-clang/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/dom/FetchTypes.h
Warning:line 639, column 7
Excessive padding in 'class mozilla::dom::IPCInternalRequest' (39 padding bytes, where 7 is optimal). Optimal fields order: urlList_, headers_, interceptionRedirectChain_, bodySize_, method_, preferredAlternativeDataType_, referrer_, integrity_, fragment_, body_, principalInfo_, interceptionTriggeringPrincipalInfo_, internalPriority_, headersGuard_, contentPolicyType_, referrerPolicy_, environmentReferrerPolicy_, requestMode_, requestCredentials_, cacheMode_, requestRedirect_, requestPriority_, keepalive_, interceptionContentPolicyType_, interceptionFromThirdParty_, embedderPolicy_, consider reordering the fields or adding explicit padding members

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name Unified_cpp_accessible_base1.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/accessible/base -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/accessible/base -resource-dir /usr/lib/llvm-21/lib/clang/21 -include /root/firefox-clang/config/gcc_hidden.h -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/stl_wrappers -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D _GLIBCXX_ASSERTIONS -D DEBUG=1 -D MOZ_HAS_MOZGLUE -D MOZILLA_INTERNAL_API -D IMPL_LIBXUL -D MOZ_SUPPORT_LEAKCHECKING -D STATIC_EXPORTABLE_JS_API -I /root/firefox-clang/accessible/base -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/accessible/base -I /root/firefox-clang/accessible/generic -I /root/firefox-clang/accessible/html -I /root/firefox-clang/accessible/ipc -I /root/firefox-clang/dom/base -I /root/firefox-clang/dom/xul -I /root/firefox-clang/accessible/xpcom -I /root/firefox-clang/accessible/xul -I /root/firefox-clang/dom/base -I /root/firefox-clang/ipc/chromium/src -I /root/firefox-clang/layout/generic -I /root/firefox-clang/layout/style -I /root/firefox-clang/layout/xul -I /root/firefox-clang/layout/xul/tree -I /root/firefox-clang/accessible/atk -I /root/firefox-clang/gfx/cairo/cairo/src -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders -I /root/firefox-clang/ipc/chromium/src -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-error=pessimizing-move -Wno-error=large-by-value-copy=128 -Wno-error=implicit-int-float-conversion -Wno-error=thread-safety-analysis -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-deprecated-this-capture -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -fdeprecated-macro -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fno-rtti -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2025-06-27-100320-3286336-1 -x c++ Unified_cpp_accessible_base1.cpp
1//
2// Automatically generated by ipdlc.
3// Edit at your own risk
4//
5
6#ifndef FetchTypes_h
7#define FetchTypes_h
8
9#include "mozilla/Attributes.h"
10#include "IPCMessageStart.h"
11#include "mozilla/RefPtr.h"
12#include "nsString.h"
13#include "nsTArray.h"
14#include "nsTHashtable.h"
15#include "mozilla/MozPromise.h"
16#include "mozilla/OperatorNewExtensions.h"
17#include "mozilla/UniquePtr.h"
18#include "mozilla/ipc/ByteBuf.h"
19#include "mozilla/ipc/FileDescriptor.h"
20#include "mozilla/ipc/IPCForwards.h"
21#include "mozilla/ipc/Shmem.h"
22
23// Headers for typedefs
24#include "mozilla/RemoteLazyInputStream.h"
25#include "mozilla/dom/FetchDriver.h"
26#include "mozilla/dom/HeadersBinding.h"
27#include "mozilla/dom/ReferrerPolicyBinding.h"
28#include "mozilla/dom/RequestBinding.h"
29#include "mozilla/dom/ResponseBinding.h"
30#include "mozilla/ipc/IPDLStructMember.h"
31#include "nsIContentPolicy.h"
32#include "nsID.h"
33#include "nsILoadInfo.h"
34#include "nsITransportSecurityInfo.h"
35#include "mozilla/ipc/IPCStream.h"
36#include "mozilla/ipc/PBackgroundSharedTypes.h"
37#include "mozilla/dom/PerformanceTimingTypes.h"
38#include "mozilla/net/NeckoChannelParams.h"
39
40
41//-----------------------------------------------------------------------------
42// Declaration of the IPDL type |struct HeadersEntry|
43//
44namespace mozilla {
45namespace dom {
46class HeadersEntry final
47{
48private:
49 typedef ::nsCString nsCString;
50
51public:
52#ifdef __clang__1
53# pragma clang diagnostic push
54# if __has_warning("-Wdefaulted-function-deleted")1
55# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
56# endif
57#endif
58 HeadersEntry() = default;
59#ifdef __clang__1
60# pragma clang diagnostic pop
61#endif
62
63 MOZ_IMPLICIT HeadersEntry(
64 const nsCString& _name,
65 const nsCString& _value) :
66 name_(_name),
67 value_(_value)
68 {
69 }
70
71 MOZ_IMPLICIT HeadersEntry(
72 nsCString&& _name,
73 nsCString&& _value) :
74 name_(std::move(_name)),
75 value_(std::move(_value))
76 {
77 }
78
79 nsCString&
80 name()
81 {
82 return name_;
83 }
84 const nsCString&
85 name() const
86 {
87 return name_;
88 }
89
90 nsCString&
91 value()
92 {
93 return value_;
94 }
95 const nsCString&
96 value() const
97 {
98 return value_;
99 }
100
101private:
102 ::mozilla::ipc::IPDLStructMember<nsCString> name_;
103 ::mozilla::ipc::IPDLStructMember<nsCString> value_;
104};
105} // namespace dom
106} // namespace mozilla
107
108namespace IPC {
109template<>
110struct ParamTraits <::mozilla::dom::HeadersEntry>
111{
112 typedef ::mozilla::dom::HeadersEntry paramType;
113 static void
114 Write(
115 IPC::MessageWriter* aWriter,
116 const paramType& aVar);
117 static IPC::ReadResult<paramType>
118 Read(IPC::MessageReader* aReader);
119};
120} // namespace IPC
121
122
123//-----------------------------------------------------------------------------
124// Declaration of the IPDL type |struct ParentToParentStream|
125//
126namespace mozilla {
127namespace dom {
128class ParentToParentStream final
129{
130private:
131 typedef ::nsID nsID;
132
133public:
134#ifdef __clang__1
135# pragma clang diagnostic push
136# if __has_warning("-Wdefaulted-function-deleted")1
137# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
138# endif
139#endif
140 ParentToParentStream() = default;
141#ifdef __clang__1
142# pragma clang diagnostic pop
143#endif
144
145 MOZ_IMPLICIT ParentToParentStream(const nsID& _uuid) :
146 uuid_(_uuid)
147 {
148 }
149
150 MOZ_IMPLICIT ParentToParentStream(nsID&& _uuid) :
151 uuid_(std::move(_uuid))
152 {
153 }
154
155 nsID&
156 uuid()
157 {
158 return uuid_;
159 }
160 const nsID&
161 uuid() const
162 {
163 return uuid_;
164 }
165
166private:
167 ::mozilla::ipc::IPDLStructMember<nsID> uuid_;
168};
169} // namespace dom
170} // namespace mozilla
171
172namespace IPC {
173template<>
174struct ParamTraits <::mozilla::dom::ParentToParentStream>
175{
176 typedef ::mozilla::dom::ParentToParentStream paramType;
177 static void
178 Write(
179 IPC::MessageWriter* aWriter,
180 const paramType& aVar);
181 static IPC::ReadResult<paramType>
182 Read(IPC::MessageReader* aReader);
183};
184} // namespace IPC
185
186
187//-----------------------------------------------------------------------------
188// Declaration of the IPDL type |union ParentToChildStream|
189//
190namespace mozilla {
191namespace dom {
192class ParentToChildStream final
193{
194public:
195 enum Type {
196 T__None,
197 TRemoteLazyInputStream = 1,
198 TIPCStream,
199 T__Last = TIPCStream
200 };
201
202private:
203 typedef ::mozilla::RemoteLazyInputStream RemoteLazyInputStream;
204 typedef ::mozilla::ipc::IPCStream IPCStream;
205 typedef RefPtr<RemoteLazyInputStream> RemoteLazyInputStream__tdef;
206 typedef IPCStream IPCStream__tdef;
207
208 RefPtr<RemoteLazyInputStream>*
209 ptr_RemoteLazyInputStream()
210 {
211 return (&(mVRemoteLazyInputStream));
212 }
213 const RefPtr<RemoteLazyInputStream>*
214 constptr_RemoteLazyInputStream() const
215 {
216 return (&(mVRemoteLazyInputStream));
217 }
218 IPCStream*
219 ptr_IPCStream()
220 {
221 return (&(mVIPCStream));
222 }
223 const IPCStream*
224 constptr_IPCStream() const
225 {
226 return (&(mVIPCStream));
227 }
228
229 void
230 MaybeDestroy();
231
232 void
233 AssertSanity() const
234 {
235 MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag")do { static_assert( mozilla::detail::AssertionConditionType<
decltype((T__None) <= (mType))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!((T__None) <= (mType)))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("(T__None) <= (mType)"
" (" "invalid type tag" ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/dom/FetchTypes.h"
, 235); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(T__None) <= (mType)"
") (" "invalid type tag" ")"); do { MOZ_CrashSequence(__null
, 235); __attribute__((nomerge)) ::abort(); } while (false); }
} while (false);
236 MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag")do { static_assert( mozilla::detail::AssertionConditionType<
decltype((mType) <= (T__Last))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!((mType) <= (T__Last)))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("(mType) <= (T__Last)"
" (" "invalid type tag" ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/dom/FetchTypes.h"
, 236); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(mType) <= (T__Last)"
") (" "invalid type tag" ")"); do { MOZ_CrashSequence(__null
, 236); __attribute__((nomerge)) ::abort(); } while (false); }
} while (false);
237 }
238 void
239 AssertSanity(Type aType) const
240 {
241 AssertSanity();
242 MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag")do { static_assert( mozilla::detail::AssertionConditionType<
decltype((mType) == (aType))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!((mType) == (aType)))), 0))) {
do { } while (false); MOZ_ReportAssertionFailure("(mType) == (aType)"
" (" "unexpected type tag" ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/dom/FetchTypes.h"
, 242); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(mType) == (aType)"
") (" "unexpected type tag" ")"); do { MOZ_CrashSequence(__null
, 242); __attribute__((nomerge)) ::abort(); } while (false); }
} while (false);
243 }
244
245public:
246 MOZ_IMPLICIT ParentToChildStream() :
247 mType(T__None)
248 {
249 }
250
251 MOZ_IMPLICIT ParentToChildStream(RemoteLazyInputStream* aOther);
252
253 MOZ_IMPLICIT ParentToChildStream(RefPtr<RemoteLazyInputStream>&& aOther);
254
255 MOZ_IMPLICIT ParentToChildStream(const IPCStream& aOther);
256
257 MOZ_IMPLICIT ParentToChildStream(IPCStream&& aOther);
258
259 MOZ_IMPLICIT ParentToChildStream(const ParentToChildStream& aOther);
260
261 MOZ_IMPLICIT ParentToChildStream(ParentToChildStream&& aOther);
262
263 ~ParentToChildStream();
264
265 Type
266 type() const
267 {
268 return mType;
269 }
270
271 ParentToChildStream&
272 operator=(RemoteLazyInputStream* aRhs);
273
274 ParentToChildStream&
275 operator=(RefPtr<RemoteLazyInputStream>&& aRhs);
276
277 ParentToChildStream&
278 operator=(const IPCStream& aRhs);
279
280 ParentToChildStream&
281 operator=(IPCStream&& aRhs);
282
283 ParentToChildStream&
284 operator=(const ParentToChildStream& aRhs);
285
286 ParentToChildStream&
287 operator=(ParentToChildStream&& aRhs);
288
289 RefPtr<RemoteLazyInputStream>&
290 get_RemoteLazyInputStream()
291 {
292 AssertSanity(TRemoteLazyInputStream);
293 return (*(ptr_RemoteLazyInputStream()));
294 }
295 RemoteLazyInputStream*
296 get_RemoteLazyInputStream() const
297 {
298 AssertSanity(TRemoteLazyInputStream);
299 return (*(constptr_RemoteLazyInputStream()));
300 }
301 operator RefPtr<RemoteLazyInputStream>&()
302 {
303 return get_RemoteLazyInputStream();
304 }
305 operator RemoteLazyInputStream*() const
306 {
307 return get_RemoteLazyInputStream();
308 }
309
310 IPCStream&
311 get_IPCStream()
312 {
313 AssertSanity(TIPCStream);
314 return (*(ptr_IPCStream()));
315 }
316 const IPCStream&
317 get_IPCStream() const
318 {
319 AssertSanity(TIPCStream);
320 return (*(constptr_IPCStream()));
321 }
322 operator IPCStream&()
323 {
324 return get_IPCStream();
325 }
326 operator const IPCStream&() const
327 {
328 return get_IPCStream();
329 }
330
331private:
332 union {
333 RefPtr<RemoteLazyInputStream> mVRemoteLazyInputStream;
334 IPCStream mVIPCStream;
335 };
336 Type mType;
337};
338} // namespace dom
339} // namespace mozilla
340
341namespace IPC {
342template<>
343struct ParamTraits <::mozilla::dom::ParentToChildStream>
344{
345 typedef ::mozilla::dom::ParentToChildStream paramType;
346 static void
347 Write(
348 IPC::MessageWriter* aWriter,
349 const paramType& aVar);
350 static IPC::ReadResult<paramType>
351 Read(IPC::MessageReader* aReader);
352};
353} // namespace IPC
354
355
356//-----------------------------------------------------------------------------
357// Declaration of the IPDL type |struct ChildToParentStream|
358//
359namespace mozilla {
360namespace dom {
361class ChildToParentStream final
362{
363private:
364 typedef ::mozilla::ipc::IPCStream IPCStream;
365
366public:
367#ifdef __clang__1
368# pragma clang diagnostic push
369# if __has_warning("-Wdefaulted-function-deleted")1
370# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
371# endif
372#endif
373 ChildToParentStream() = default;
374#ifdef __clang__1
375# pragma clang diagnostic pop
376#endif
377
378 MOZ_IMPLICIT ChildToParentStream(const IPCStream& _stream) :
379 stream_(_stream)
380 {
381 }
382
383 MOZ_IMPLICIT ChildToParentStream(IPCStream&& _stream) :
384 stream_(std::move(_stream))
385 {
386 }
387
388 IPCStream&
389 stream()
390 {
391 return stream_;
392 }
393 const IPCStream&
394 stream() const
395 {
396 return stream_;
397 }
398
399private:
400 ::mozilla::ipc::IPDLStructMember<IPCStream> stream_;
401};
402} // namespace dom
403} // namespace mozilla
404
405namespace IPC {
406template<>
407struct ParamTraits <::mozilla::dom::ChildToParentStream>
408{
409 typedef ::mozilla::dom::ChildToParentStream paramType;
410 static void
411 Write(
412 IPC::MessageWriter* aWriter,
413 const paramType& aVar);
414 static IPC::ReadResult<paramType>
415 Read(IPC::MessageReader* aReader);
416};
417} // namespace IPC
418
419
420//-----------------------------------------------------------------------------
421// Declaration of the IPDL type |union BodyStreamVariant|
422//
423namespace mozilla {
424namespace dom {
425class BodyStreamVariant final
426{
427public:
428 enum Type {
429 T__None,
430 TParentToParentStream = 1,
431 TParentToChildStream,
432 TChildToParentStream,
433 T__Last = TChildToParentStream
434 };
435
436private:
437 typedef ::mozilla::dom::ParentToParentStream ParentToParentStream;
438 typedef ::mozilla::dom::ParentToChildStream ParentToChildStream;
439 typedef ::mozilla::dom::ChildToParentStream ChildToParentStream;
440 typedef ParentToParentStream ParentToParentStream__tdef;
441 typedef ParentToChildStream ParentToChildStream__tdef;
442 typedef ChildToParentStream ChildToParentStream__tdef;
443
444 ParentToParentStream*
445 ptr_ParentToParentStream()
446 {
447 return (&(mVParentToParentStream));
448 }
449 const ParentToParentStream*
450 constptr_ParentToParentStream() const
451 {
452 return (&(mVParentToParentStream));
453 }
454 ParentToChildStream*
455 ptr_ParentToChildStream()
456 {
457 return (&(mVParentToChildStream));
458 }
459 const ParentToChildStream*
460 constptr_ParentToChildStream() const
461 {
462 return (&(mVParentToChildStream));
463 }
464 ChildToParentStream*
465 ptr_ChildToParentStream()
466 {
467 return (&(mVChildToParentStream));
468 }
469 const ChildToParentStream*
470 constptr_ChildToParentStream() const
471 {
472 return (&(mVChildToParentStream));
473 }
474
475 void
476 MaybeDestroy();
477
478 void
479 AssertSanity() const
480 {
481 MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag")do { static_assert( mozilla::detail::AssertionConditionType<
decltype((T__None) <= (mType))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!((T__None) <= (mType)))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("(T__None) <= (mType)"
" (" "invalid type tag" ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/dom/FetchTypes.h"
, 481); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(T__None) <= (mType)"
") (" "invalid type tag" ")"); do { MOZ_CrashSequence(__null
, 481); __attribute__((nomerge)) ::abort(); } while (false); }
} while (false);
482 MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag")do { static_assert( mozilla::detail::AssertionConditionType<
decltype((mType) <= (T__Last))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!((mType) <= (T__Last)))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("(mType) <= (T__Last)"
" (" "invalid type tag" ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/dom/FetchTypes.h"
, 482); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(mType) <= (T__Last)"
") (" "invalid type tag" ")"); do { MOZ_CrashSequence(__null
, 482); __attribute__((nomerge)) ::abort(); } while (false); }
} while (false);
483 }
484 void
485 AssertSanity(Type aType) const
486 {
487 AssertSanity();
488 MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag")do { static_assert( mozilla::detail::AssertionConditionType<
decltype((mType) == (aType))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!((mType) == (aType)))), 0))) {
do { } while (false); MOZ_ReportAssertionFailure("(mType) == (aType)"
" (" "unexpected type tag" ")", "/root/firefox-clang/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/dom/FetchTypes.h"
, 488); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(mType) == (aType)"
") (" "unexpected type tag" ")"); do { MOZ_CrashSequence(__null
, 488); __attribute__((nomerge)) ::abort(); } while (false); }
} while (false);
489 }
490
491public:
492 MOZ_IMPLICIT BodyStreamVariant() :
493 mType(T__None)
494 {
495 }
496
497 MOZ_IMPLICIT BodyStreamVariant(const ParentToParentStream& aOther);
498
499 MOZ_IMPLICIT BodyStreamVariant(ParentToParentStream&& aOther);
500
501 MOZ_IMPLICIT BodyStreamVariant(const ParentToChildStream& aOther);
502
503 MOZ_IMPLICIT BodyStreamVariant(ParentToChildStream&& aOther);
504
505 MOZ_IMPLICIT BodyStreamVariant(const ChildToParentStream& aOther);
506
507 MOZ_IMPLICIT BodyStreamVariant(ChildToParentStream&& aOther);
508
509 MOZ_IMPLICIT BodyStreamVariant(const BodyStreamVariant& aOther);
510
511 MOZ_IMPLICIT BodyStreamVariant(BodyStreamVariant&& aOther);
512
513 ~BodyStreamVariant();
514
515 Type
516 type() const
517 {
518 return mType;
519 }
520
521 BodyStreamVariant&
522 operator=(const ParentToParentStream& aRhs);
523
524 BodyStreamVariant&
525 operator=(ParentToParentStream&& aRhs);
526
527 BodyStreamVariant&
528 operator=(const ParentToChildStream& aRhs);
529
530 BodyStreamVariant&
531 operator=(ParentToChildStream&& aRhs);
532
533 BodyStreamVariant&
534 operator=(const ChildToParentStream& aRhs);
535
536 BodyStreamVariant&
537 operator=(ChildToParentStream&& aRhs);
538
539 BodyStreamVariant&
540 operator=(const BodyStreamVariant& aRhs);
541
542 BodyStreamVariant&
543 operator=(BodyStreamVariant&& aRhs);
544
545 ParentToParentStream&
546 get_ParentToParentStream()
547 {
548 AssertSanity(TParentToParentStream);
549 return (*(ptr_ParentToParentStream()));
550 }
551 const ParentToParentStream&
552 get_ParentToParentStream() const
553 {
554 AssertSanity(TParentToParentStream);
555 return (*(constptr_ParentToParentStream()));
556 }
557 operator ParentToParentStream&()
558 {
559 return get_ParentToParentStream();
560 }
561 operator const ParentToParentStream&() const
562 {
563 return get_ParentToParentStream();
564 }
565
566 ParentToChildStream&
567 get_ParentToChildStream()
568 {
569 AssertSanity(TParentToChildStream);
570 return (*(ptr_ParentToChildStream()));
571 }
572 const ParentToChildStream&
573 get_ParentToChildStream() const
574 {
575 AssertSanity(TParentToChildStream);
576 return (*(constptr_ParentToChildStream()));
577 }
578 operator ParentToChildStream&()
579 {
580 return get_ParentToChildStream();
581 }
582 operator const ParentToChildStream&() const
583 {
584 return get_ParentToChildStream();
585 }
586
587 ChildToParentStream&
588 get_ChildToParentStream()
589 {
590 AssertSanity(TChildToParentStream);
591 return (*(ptr_ChildToParentStream()));
592 }
593 const ChildToParentStream&
594 get_ChildToParentStream() const
595 {
596 AssertSanity(TChildToParentStream);
597 return (*(constptr_ChildToParentStream()));
598 }
599 operator ChildToParentStream&()
600 {
601 return get_ChildToParentStream();
602 }
603 operator const ChildToParentStream&() const
604 {
605 return get_ChildToParentStream();
606 }
607
608private:
609 union {
610 ParentToParentStream mVParentToParentStream;
611 ParentToChildStream mVParentToChildStream;
612 ChildToParentStream mVChildToParentStream;
613 };
614 Type mType;
615};
616} // namespace dom
617} // namespace mozilla
618
619namespace IPC {
620template<>
621struct ParamTraits <::mozilla::dom::BodyStreamVariant>
622{
623 typedef ::mozilla::dom::BodyStreamVariant paramType;
624 static void
625 Write(
626 IPC::MessageWriter* aWriter,
627 const paramType& aVar);
628 static IPC::ReadResult<paramType>
629 Read(IPC::MessageReader* aReader);
630};
631} // namespace IPC
632
633
634//-----------------------------------------------------------------------------
635// Declaration of the IPDL type |struct IPCInternalRequest|
636//
637namespace mozilla {
638namespace dom {
639class IPCInternalRequest final
Excessive padding in 'class mozilla::dom::IPCInternalRequest' (39 padding bytes, where 7 is optimal). Optimal fields order: urlList_, headers_, interceptionRedirectChain_, bodySize_, method_, preferredAlternativeDataType_, referrer_, integrity_, fragment_, body_, principalInfo_, interceptionTriggeringPrincipalInfo_, internalPriority_, headersGuard_, contentPolicyType_, referrerPolicy_, environmentReferrerPolicy_, requestMode_, requestCredentials_, cacheMode_, requestRedirect_, requestPriority_, keepalive_, interceptionContentPolicyType_, interceptionFromThirdParty_, embedderPolicy_, consider reordering the fields or adding explicit padding members
640{
641private:
642 typedef ::nsCString nsCString;
643 typedef ::mozilla::dom::HeadersGuardEnum HeadersGuardEnum;
644 typedef ::mozilla::dom::HeadersEntry HeadersEntry;
645 typedef ::mozilla::dom::BodyStreamVariant BodyStreamVariant;
646 typedef ::int64_t int64_t;
647 typedef ::nsContentPolicyType nsContentPolicyType;
648 typedef ::int32_t int32_t;
649 typedef ::mozilla::dom::ReferrerPolicy ReferrerPolicy;
650 typedef ::mozilla::dom::RequestMode RequestMode;
651 typedef ::mozilla::dom::RequestCredentials RequestCredentials;
652 typedef ::mozilla::dom::RequestCache RequestCache;
653 typedef ::mozilla::dom::RequestRedirect RequestRedirect;
654 typedef ::mozilla::dom::RequestPriority RequestPriority;
655 typedef ::nsString nsString;
656 typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
657 typedef ::mozilla::net::RedirectHistoryEntryInfo RedirectHistoryEntryInfo;
658 typedef ::nsILoadInfo::CrossOriginEmbedderPolicy CrossOriginEmbedderPolicy;
659
660public:
661#ifdef __clang__1
662# pragma clang diagnostic push
663# if __has_warning("-Wdefaulted-function-deleted")1
664# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
665# endif
666#endif
667 IPCInternalRequest() = default;
668#ifdef __clang__1
669# pragma clang diagnostic pop
670#endif
671
672 MOZ_IMPLICIT IPCInternalRequest(
673 const nsCString& _method,
674 const nsTArray<nsCString>& _urlList,
675 const HeadersGuardEnum& _headersGuard,
676 const nsTArray<HeadersEntry>& _headers,
677 const mozilla::Maybe<BodyStreamVariant>& _body,
678 const int64_t& _bodySize,
679 const nsCString& _preferredAlternativeDataType,
680 const nsContentPolicyType& _contentPolicyType,
681 const int32_t& _internalPriority,
682 const nsCString& _referrer,
683 const ReferrerPolicy& _referrerPolicy,
684 const ReferrerPolicy& _environmentReferrerPolicy,
685 const RequestMode& _requestMode,
686 const RequestCredentials& _requestCredentials,
687 const RequestCache& _cacheMode,
688 const RequestRedirect& _requestRedirect,
689 const RequestPriority& _requestPriority,
690 const nsString& _integrity,
691 const bool& _keepalive,
692 const nsCString& _fragment,
693 const mozilla::Maybe<PrincipalInfo>& _principalInfo,
694 const mozilla::Maybe<PrincipalInfo>& _interceptionTriggeringPrincipalInfo,
695 const nsContentPolicyType& _interceptionContentPolicyType,
696 const nsTArray<RedirectHistoryEntryInfo>& _interceptionRedirectChain,
697 const bool& _interceptionFromThirdParty,
698 const CrossOriginEmbedderPolicy& _embedderPolicy) :
699 method_(_method),
700 urlList_(_urlList),
701 headersGuard_(_headersGuard),
702 headers_(_headers),
703 body_(_body),
704 preferredAlternativeDataType_(_preferredAlternativeDataType),
705 contentPolicyType_(_contentPolicyType),
706 referrer_(_referrer),
707 referrerPolicy_(_referrerPolicy),
708 environmentReferrerPolicy_(_environmentReferrerPolicy),
709 requestMode_(_requestMode),
710 requestCredentials_(_requestCredentials),
711 cacheMode_(_cacheMode),
712 requestRedirect_(_requestRedirect),
713 requestPriority_(_requestPriority),
714 integrity_(_integrity),
715 keepalive_(_keepalive),
716 fragment_(_fragment),
717 principalInfo_(_principalInfo),
718 interceptionTriggeringPrincipalInfo_(_interceptionTriggeringPrincipalInfo),
719 interceptionContentPolicyType_(_interceptionContentPolicyType),
720 interceptionRedirectChain_(_interceptionRedirectChain),
721 interceptionFromThirdParty_(_interceptionFromThirdParty),
722 embedderPolicy_(_embedderPolicy),
723 bodySize_(_bodySize),
724 internalPriority_(_internalPriority)
725 {
726 }
727
728 MOZ_IMPLICIT IPCInternalRequest(
729 nsCString&& _method,
730 nsTArray<nsCString>&& _urlList,
731 HeadersGuardEnum&& _headersGuard,
732 nsTArray<HeadersEntry>&& _headers,
733 mozilla::Maybe<BodyStreamVariant>&& _body,
734 int64_t&& _bodySize,
735 nsCString&& _preferredAlternativeDataType,
736 nsContentPolicyType&& _contentPolicyType,
737 int32_t&& _internalPriority,
738 nsCString&& _referrer,
739 ReferrerPolicy&& _referrerPolicy,
740 ReferrerPolicy&& _environmentReferrerPolicy,
741 RequestMode&& _requestMode,
742 RequestCredentials&& _requestCredentials,
743 RequestCache&& _cacheMode,
744 RequestRedirect&& _requestRedirect,
745 RequestPriority&& _requestPriority,
746 nsString&& _integrity,
747 bool&& _keepalive,
748 nsCString&& _fragment,
749 mozilla::Maybe<PrincipalInfo>&& _principalInfo,
750 mozilla::Maybe<PrincipalInfo>&& _interceptionTriggeringPrincipalInfo,
751 nsContentPolicyType&& _interceptionContentPolicyType,
752 nsTArray<RedirectHistoryEntryInfo>&& _interceptionRedirectChain,
753 bool&& _interceptionFromThirdParty,
754 CrossOriginEmbedderPolicy&& _embedderPolicy) :
755 method_(std::move(_method)),
756 urlList_(std::move(_urlList)),
757 headersGuard_(std::move(_headersGuard)),
758 headers_(std::move(_headers)),
759 body_(std::move(_body)),
760 preferredAlternativeDataType_(std::move(_preferredAlternativeDataType)),
761 contentPolicyType_(std::move(_contentPolicyType)),
762 referrer_(std::move(_referrer)),
763 referrerPolicy_(std::move(_referrerPolicy)),
764 environmentReferrerPolicy_(std::move(_environmentReferrerPolicy)),
765 requestMode_(std::move(_requestMode)),
766 requestCredentials_(std::move(_requestCredentials)),
767 cacheMode_(std::move(_cacheMode)),
768 requestRedirect_(std::move(_requestRedirect)),
769 requestPriority_(std::move(_requestPriority)),
770 integrity_(std::move(_integrity)),
771 keepalive_(std::move(_keepalive)),
772 fragment_(std::move(_fragment)),
773 principalInfo_(std::move(_principalInfo)),
774 interceptionTriggeringPrincipalInfo_(std::move(_interceptionTriggeringPrincipalInfo)),
775 interceptionContentPolicyType_(std::move(_interceptionContentPolicyType)),
776 interceptionRedirectChain_(std::move(_interceptionRedirectChain)),
777 interceptionFromThirdParty_(std::move(_interceptionFromThirdParty)),
778 embedderPolicy_(std::move(_embedderPolicy)),
779 bodySize_(std::move(_bodySize)),
780 internalPriority_(std::move(_internalPriority))
781 {
782 }
783
784 nsCString&
785 method()
786 {
787 return method_;
788 }
789 const nsCString&
790 method() const
791 {
792 return method_;
793 }
794
795 nsTArray<nsCString>&
796 urlList()
797 {
798 return urlList_;
799 }
800 const nsTArray<nsCString>&
801 urlList() const
802 {
803 return urlList_;
804 }
805
806 HeadersGuardEnum&
807 headersGuard()
808 {
809 return headersGuard_;
810 }
811 const HeadersGuardEnum&
812 headersGuard() const
813 {
814 return headersGuard_;
815 }
816
817 nsTArray<HeadersEntry>&
818 headers()
819 {
820 return headers_;
821 }
822 const nsTArray<HeadersEntry>&
823 headers() const
824 {
825 return headers_;
826 }
827
828 mozilla::Maybe<BodyStreamVariant>&
829 body()
830 {
831 return body_;
832 }
833 const mozilla::Maybe<BodyStreamVariant>&
834 body() const
835 {
836 return body_;
837 }
838
839 int64_t&
840 bodySize()
841 {
842 return bodySize_;
843 }
844 const int64_t&
845 bodySize() const
846 {
847 return bodySize_;
848 }
849
850 nsCString&
851 preferredAlternativeDataType()
852 {
853 return preferredAlternativeDataType_;
854 }
855 const nsCString&
856 preferredAlternativeDataType() const
857 {
858 return preferredAlternativeDataType_;
859 }
860
861 nsContentPolicyType&
862 contentPolicyType()
863 {
864 return contentPolicyType_;
865 }
866 const nsContentPolicyType&
867 contentPolicyType() const
868 {
869 return contentPolicyType_;
870 }
871
872 int32_t&
873 internalPriority()
874 {
875 return internalPriority_;
876 }
877 const int32_t&
878 internalPriority() const
879 {
880 return internalPriority_;
881 }
882
883 nsCString&
884 referrer()
885 {
886 return referrer_;
887 }
888 const nsCString&
889 referrer() const
890 {
891 return referrer_;
892 }
893
894 ReferrerPolicy&
895 referrerPolicy()
896 {
897 return referrerPolicy_;
898 }
899 const ReferrerPolicy&
900 referrerPolicy() const
901 {
902 return referrerPolicy_;
903 }
904
905 ReferrerPolicy&
906 environmentReferrerPolicy()
907 {
908 return environmentReferrerPolicy_;
909 }
910 const ReferrerPolicy&
911 environmentReferrerPolicy() const
912 {
913 return environmentReferrerPolicy_;
914 }
915
916 RequestMode&
917 requestMode()
918 {
919 return requestMode_;
920 }
921 const RequestMode&
922 requestMode() const
923 {
924 return requestMode_;
925 }
926
927 RequestCredentials&
928 requestCredentials()
929 {
930 return requestCredentials_;
931 }
932 const RequestCredentials&
933 requestCredentials() const
934 {
935 return requestCredentials_;
936 }
937
938 RequestCache&
939 cacheMode()
940 {
941 return cacheMode_;
942 }
943 const RequestCache&
944 cacheMode() const
945 {
946 return cacheMode_;
947 }
948
949 RequestRedirect&
950 requestRedirect()
951 {
952 return requestRedirect_;
953 }
954 const RequestRedirect&
955 requestRedirect() const
956 {
957 return requestRedirect_;
958 }
959
960 RequestPriority&
961 requestPriority()
962 {
963 return requestPriority_;
964 }
965 const RequestPriority&
966 requestPriority() const
967 {
968 return requestPriority_;
969 }
970
971 nsString&
972 integrity()
973 {
974 return integrity_;
975 }
976 const nsString&
977 integrity() const
978 {
979 return integrity_;
980 }
981
982 bool&
983 keepalive()
984 {
985 return keepalive_;
986 }
987 const bool&
988 keepalive() const
989 {
990 return keepalive_;
991 }
992
993 nsCString&
994 fragment()
995 {
996 return fragment_;
997 }
998 const nsCString&
999 fragment() const
1000 {
1001 return fragment_;
1002 }
1003
1004 mozilla::Maybe<PrincipalInfo>&
1005 principalInfo()
1006 {
1007 return principalInfo_;
1008 }
1009 const mozilla::Maybe<PrincipalInfo>&
1010 principalInfo() const
1011 {
1012 return principalInfo_;
1013 }
1014
1015 mozilla::Maybe<PrincipalInfo>&
1016 interceptionTriggeringPrincipalInfo()
1017 {
1018 return interceptionTriggeringPrincipalInfo_;
1019 }
1020 const mozilla::Maybe<PrincipalInfo>&
1021 interceptionTriggeringPrincipalInfo() const
1022 {
1023 return interceptionTriggeringPrincipalInfo_;
1024 }
1025
1026 nsContentPolicyType&
1027 interceptionContentPolicyType()
1028 {
1029 return interceptionContentPolicyType_;
1030 }
1031 const nsContentPolicyType&
1032 interceptionContentPolicyType() const
1033 {
1034 return interceptionContentPolicyType_;
1035 }
1036
1037 nsTArray<RedirectHistoryEntryInfo>&
1038 interceptionRedirectChain()
1039 {
1040 return interceptionRedirectChain_;
1041 }
1042 const nsTArray<RedirectHistoryEntryInfo>&
1043 interceptionRedirectChain() const
1044 {
1045 return interceptionRedirectChain_;
1046 }
1047
1048 bool&
1049 interceptionFromThirdParty()
1050 {
1051 return interceptionFromThirdParty_;
1052 }
1053 const bool&
1054 interceptionFromThirdParty() const
1055 {
1056 return interceptionFromThirdParty_;
1057 }
1058
1059 CrossOriginEmbedderPolicy&
1060 embedderPolicy()
1061 {
1062 return embedderPolicy_;
1063 }
1064 const CrossOriginEmbedderPolicy&
1065 embedderPolicy() const
1066 {
1067 return embedderPolicy_;
1068 }
1069
1070private:
1071 ::mozilla::ipc::IPDLStructMember<nsCString> method_;
1072 ::mozilla::ipc::IPDLStructMember<CopyableTArray<nsCString>> urlList_;
1073 ::mozilla::ipc::IPDLStructMember<HeadersGuardEnum> headersGuard_;
1074 ::mozilla::ipc::IPDLStructMember<CopyableTArray<HeadersEntry>> headers_;
1075 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<BodyStreamVariant>> body_;
1076 ::mozilla::ipc::IPDLStructMember<nsCString> preferredAlternativeDataType_;
1077 ::mozilla::ipc::IPDLStructMember<nsContentPolicyType> contentPolicyType_;
1078 ::mozilla::ipc::IPDLStructMember<nsCString> referrer_;
1079 ::mozilla::ipc::IPDLStructMember<ReferrerPolicy> referrerPolicy_;
1080 ::mozilla::ipc::IPDLStructMember<ReferrerPolicy> environmentReferrerPolicy_;
1081 ::mozilla::ipc::IPDLStructMember<RequestMode> requestMode_;
1082 ::mozilla::ipc::IPDLStructMember<RequestCredentials> requestCredentials_;
1083 ::mozilla::ipc::IPDLStructMember<RequestCache> cacheMode_;
1084 ::mozilla::ipc::IPDLStructMember<RequestRedirect> requestRedirect_;
1085 ::mozilla::ipc::IPDLStructMember<RequestPriority> requestPriority_;
1086 ::mozilla::ipc::IPDLStructMember<nsString> integrity_;
1087 ::mozilla::ipc::IPDLStructMember<bool> keepalive_;
1088 ::mozilla::ipc::IPDLStructMember<nsCString> fragment_;
1089 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> principalInfo_;
1090 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> interceptionTriggeringPrincipalInfo_;
1091 ::mozilla::ipc::IPDLStructMember<nsContentPolicyType> interceptionContentPolicyType_;
1092 ::mozilla::ipc::IPDLStructMember<CopyableTArray<RedirectHistoryEntryInfo>> interceptionRedirectChain_;
1093 ::mozilla::ipc::IPDLStructMember<bool> interceptionFromThirdParty_;
1094 ::mozilla::ipc::IPDLStructMember<CrossOriginEmbedderPolicy> embedderPolicy_;
1095 ::mozilla::ipc::IPDLStructMember<int64_t> bodySize_;
1096 ::mozilla::ipc::IPDLStructMember<int32_t> internalPriority_;
1097};
1098} // namespace dom
1099} // namespace mozilla
1100
1101namespace IPC {
1102template<>
1103struct ParamTraits <::mozilla::dom::IPCInternalRequest>
1104{
1105 typedef ::mozilla::dom::IPCInternalRequest paramType;
1106 static void
1107 Write(
1108 IPC::MessageWriter* aWriter,
1109 const paramType& aVar);
1110 static IPC::ReadResult<paramType>
1111 Read(IPC::MessageReader* aReader);
1112};
1113} // namespace IPC
1114
1115
1116//-----------------------------------------------------------------------------
1117// Declaration of the IPDL type |struct InternalResponseMetadata|
1118//
1119namespace mozilla {
1120namespace dom {
1121class InternalResponseMetadata final
1122{
1123private:
1124 typedef ::mozilla::dom::ResponseType ResponseType;
1125 typedef ::nsCString nsCString;
1126 typedef ::uint16_t uint16_t;
1127 typedef ::mozilla::dom::HeadersGuardEnum HeadersGuardEnum;
1128 typedef ::mozilla::dom::HeadersEntry HeadersEntry;
1129 typedef ::nsresult nsresult;
1130 typedef ::nsITransportSecurityInfo nsITransportSecurityInfo;
1131 typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
1132 typedef ::nsString nsString;
1133 typedef ::mozilla::dom::RequestCredentials RequestCredentials;
1134
1135public:
1136#ifdef __clang__1
1137# pragma clang diagnostic push
1138# if __has_warning("-Wdefaulted-function-deleted")1
1139# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
1140# endif
1141#endif
1142 InternalResponseMetadata() = default;
1143#ifdef __clang__1
1144# pragma clang diagnostic pop
1145#endif
1146
1147 MOZ_IMPLICIT InternalResponseMetadata(
1148 const ResponseType& _type,
1149 const nsTArray<nsCString>& _urlList,
1150 const uint16_t& _status,
1151 const nsCString& _statusText,
1152 const HeadersGuardEnum& _headersGuard,
1153 const nsTArray<HeadersEntry>& _headers,
1154 const nsresult& _errorCode,
1155 const nsCString& _alternativeDataType,
1156 nsITransportSecurityInfo* _securityInfo,
1157 const mozilla::Maybe<PrincipalInfo>& _principalInfo,
1158 const nsCString& _bodyBlobURISpec,
1159 const nsString& _bodyLocalPath,
1160 const RequestCredentials& _credentialsMode) :
1161 type_(_type),
1162 urlList_(_urlList),
1163 statusText_(_statusText),
1164 headersGuard_(_headersGuard),
1165 headers_(_headers),
1166 errorCode_(_errorCode),
1167 alternativeDataType_(_alternativeDataType),
1168 securityInfo_(_securityInfo),
1169 principalInfo_(_principalInfo),
1170 bodyBlobURISpec_(_bodyBlobURISpec),
1171 bodyLocalPath_(_bodyLocalPath),
1172 credentialsMode_(_credentialsMode),
1173 status_(_status)
1174 {
1175 }
1176
1177 MOZ_IMPLICIT InternalResponseMetadata(
1178 ResponseType&& _type,
1179 nsTArray<nsCString>&& _urlList,
1180 uint16_t&& _status,
1181 nsCString&& _statusText,
1182 HeadersGuardEnum&& _headersGuard,
1183 nsTArray<HeadersEntry>&& _headers,
1184 nsresult&& _errorCode,
1185 nsCString&& _alternativeDataType,
1186 RefPtr<nsITransportSecurityInfo>&& _securityInfo,
1187 mozilla::Maybe<PrincipalInfo>&& _principalInfo,
1188 nsCString&& _bodyBlobURISpec,
1189 nsString&& _bodyLocalPath,
1190 RequestCredentials&& _credentialsMode) :
1191 type_(std::move(_type)),
1192 urlList_(std::move(_urlList)),
1193 statusText_(std::move(_statusText)),
1194 headersGuard_(std::move(_headersGuard)),
1195 headers_(std::move(_headers)),
1196 errorCode_(std::move(_errorCode)),
1197 alternativeDataType_(std::move(_alternativeDataType)),
1198 securityInfo_(std::move(_securityInfo)),
1199 principalInfo_(std::move(_principalInfo)),
1200 bodyBlobURISpec_(std::move(_bodyBlobURISpec)),
1201 bodyLocalPath_(std::move(_bodyLocalPath)),
1202 credentialsMode_(std::move(_credentialsMode)),
1203 status_(std::move(_status))
1204 {
1205 }
1206
1207 ResponseType&
1208 type()
1209 {
1210 return type_;
1211 }
1212 const ResponseType&
1213 type() const
1214 {
1215 return type_;
1216 }
1217
1218 nsTArray<nsCString>&
1219 urlList()
1220 {
1221 return urlList_;
1222 }
1223 const nsTArray<nsCString>&
1224 urlList() const
1225 {
1226 return urlList_;
1227 }
1228
1229 uint16_t&
1230 status()
1231 {
1232 return status_;
1233 }
1234 const uint16_t&
1235 status() const
1236 {
1237 return status_;
1238 }
1239
1240 nsCString&
1241 statusText()
1242 {
1243 return statusText_;
1244 }
1245 const nsCString&
1246 statusText() const
1247 {
1248 return statusText_;
1249 }
1250
1251 HeadersGuardEnum&
1252 headersGuard()
1253 {
1254 return headersGuard_;
1255 }
1256 const HeadersGuardEnum&
1257 headersGuard() const
1258 {
1259 return headersGuard_;
1260 }
1261
1262 nsTArray<HeadersEntry>&
1263 headers()
1264 {
1265 return headers_;
1266 }
1267 const nsTArray<HeadersEntry>&
1268 headers() const
1269 {
1270 return headers_;
1271 }
1272
1273 nsresult&
1274 errorCode()
1275 {
1276 return errorCode_;
1277 }
1278 const nsresult&
1279 errorCode() const
1280 {
1281 return errorCode_;
1282 }
1283
1284 nsCString&
1285 alternativeDataType()
1286 {
1287 return alternativeDataType_;
1288 }
1289 const nsCString&
1290 alternativeDataType() const
1291 {
1292 return alternativeDataType_;
1293 }
1294
1295 RefPtr<nsITransportSecurityInfo>&
1296 securityInfo()
1297 {
1298 return securityInfo_;
1299 }
1300 nsITransportSecurityInfo*
1301 securityInfo() const
1302 {
1303 return securityInfo_;
1304 }
1305
1306 mozilla::Maybe<PrincipalInfo>&
1307 principalInfo()
1308 {
1309 return principalInfo_;
1310 }
1311 const mozilla::Maybe<PrincipalInfo>&
1312 principalInfo() const
1313 {
1314 return principalInfo_;
1315 }
1316
1317 nsCString&
1318 bodyBlobURISpec()
1319 {
1320 return bodyBlobURISpec_;
1321 }
1322 const nsCString&
1323 bodyBlobURISpec() const
1324 {
1325 return bodyBlobURISpec_;
1326 }
1327
1328 nsString&
1329 bodyLocalPath()
1330 {
1331 return bodyLocalPath_;
1332 }
1333 const nsString&
1334 bodyLocalPath() const
1335 {
1336 return bodyLocalPath_;
1337 }
1338
1339 RequestCredentials&
1340 credentialsMode()
1341 {
1342 return credentialsMode_;
1343 }
1344 const RequestCredentials&
1345 credentialsMode() const
1346 {
1347 return credentialsMode_;
1348 }
1349
1350private:
1351 ::mozilla::ipc::IPDLStructMember<ResponseType> type_;
1352 ::mozilla::ipc::IPDLStructMember<CopyableTArray<nsCString>> urlList_;
1353 ::mozilla::ipc::IPDLStructMember<nsCString> statusText_;
1354 ::mozilla::ipc::IPDLStructMember<HeadersGuardEnum> headersGuard_;
1355 ::mozilla::ipc::IPDLStructMember<CopyableTArray<HeadersEntry>> headers_;
1356 ::mozilla::ipc::IPDLStructMember<nsresult> errorCode_;
1357 ::mozilla::ipc::IPDLStructMember<nsCString> alternativeDataType_;
1358 ::mozilla::ipc::IPDLStructMember<RefPtr<nsITransportSecurityInfo>> securityInfo_;
1359 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> principalInfo_;
1360 ::mozilla::ipc::IPDLStructMember<nsCString> bodyBlobURISpec_;
1361 ::mozilla::ipc::IPDLStructMember<nsString> bodyLocalPath_;
1362 ::mozilla::ipc::IPDLStructMember<RequestCredentials> credentialsMode_;
1363 ::mozilla::ipc::IPDLStructMember<uint16_t> status_;
1364};
1365} // namespace dom
1366} // namespace mozilla
1367
1368namespace IPC {
1369template<>
1370struct ParamTraits <::mozilla::dom::InternalResponseMetadata>
1371{
1372 typedef ::mozilla::dom::InternalResponseMetadata paramType;
1373 static void
1374 Write(
1375 IPC::MessageWriter* aWriter,
1376 const paramType& aVar);
1377 static IPC::ReadResult<paramType>
1378 Read(IPC::MessageReader* aReader);
1379};
1380} // namespace IPC
1381
1382
1383//-----------------------------------------------------------------------------
1384// Declaration of the IPDL type |struct ParentToParentInternalResponse|
1385//
1386namespace mozilla {
1387namespace dom {
1388class ParentToParentInternalResponse final
1389{
1390private:
1391 typedef ::mozilla::dom::InternalResponseMetadata InternalResponseMetadata;
1392 typedef ::mozilla::dom::ParentToParentStream ParentToParentStream;
1393 typedef ::int64_t int64_t;
1394
1395public:
1396#ifdef __clang__1
1397# pragma clang diagnostic push
1398# if __has_warning("-Wdefaulted-function-deleted")1
1399# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
1400# endif
1401#endif
1402 ParentToParentInternalResponse() = default;
1403#ifdef __clang__1
1404# pragma clang diagnostic pop
1405#endif
1406
1407 MOZ_IMPLICIT ParentToParentInternalResponse(
1408 const InternalResponseMetadata& _metadata,
1409 const mozilla::Maybe<ParentToParentStream>& _body,
1410 const int64_t& _bodySize,
1411 const mozilla::Maybe<ParentToParentStream>& _alternativeBody) :
1412 metadata_(_metadata),
1413 body_(_body),
1414 alternativeBody_(_alternativeBody),
1415 bodySize_(_bodySize)
1416 {
1417 }
1418
1419 MOZ_IMPLICIT ParentToParentInternalResponse(
1420 InternalResponseMetadata&& _metadata,
1421 mozilla::Maybe<ParentToParentStream>&& _body,
1422 int64_t&& _bodySize,
1423 mozilla::Maybe<ParentToParentStream>&& _alternativeBody) :
1424 metadata_(std::move(_metadata)),
1425 body_(std::move(_body)),
1426 alternativeBody_(std::move(_alternativeBody)),
1427 bodySize_(std::move(_bodySize))
1428 {
1429 }
1430
1431 InternalResponseMetadata&
1432 metadata()
1433 {
1434 return metadata_;
1435 }
1436 const InternalResponseMetadata&
1437 metadata() const
1438 {
1439 return metadata_;
1440 }
1441
1442 mozilla::Maybe<ParentToParentStream>&
1443 body()
1444 {
1445 return body_;
1446 }
1447 const mozilla::Maybe<ParentToParentStream>&
1448 body() const
1449 {
1450 return body_;
1451 }
1452
1453 int64_t&
1454 bodySize()
1455 {
1456 return bodySize_;
1457 }
1458 const int64_t&
1459 bodySize() const
1460 {
1461 return bodySize_;
1462 }
1463
1464 mozilla::Maybe<ParentToParentStream>&
1465 alternativeBody()
1466 {
1467 return alternativeBody_;
1468 }
1469 const mozilla::Maybe<ParentToParentStream>&
1470 alternativeBody() const
1471 {
1472 return alternativeBody_;
1473 }
1474
1475private:
1476 ::mozilla::ipc::IPDLStructMember<InternalResponseMetadata> metadata_;
1477 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ParentToParentStream>> body_;
1478 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ParentToParentStream>> alternativeBody_;
1479 ::mozilla::ipc::IPDLStructMember<int64_t> bodySize_;
1480};
1481} // namespace dom
1482} // namespace mozilla
1483
1484namespace IPC {
1485template<>
1486struct ParamTraits <::mozilla::dom::ParentToParentInternalResponse>
1487{
1488 typedef ::mozilla::dom::ParentToParentInternalResponse paramType;
1489 static void
1490 Write(
1491 IPC::MessageWriter* aWriter,
1492 const paramType& aVar);
1493 static IPC::ReadResult<paramType>
1494 Read(IPC::MessageReader* aReader);
1495};
1496} // namespace IPC
1497
1498
1499//-----------------------------------------------------------------------------
1500// Declaration of the IPDL type |struct ParentToChildInternalResponse|
1501//
1502namespace mozilla {
1503namespace dom {
1504class ParentToChildInternalResponse final
1505{
1506private:
1507 typedef ::mozilla::dom::InternalResponseMetadata InternalResponseMetadata;
1508 typedef ::mozilla::dom::ParentToChildStream ParentToChildStream;
1509 typedef ::int64_t int64_t;
1510
1511public:
1512#ifdef __clang__1
1513# pragma clang diagnostic push
1514# if __has_warning("-Wdefaulted-function-deleted")1
1515# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
1516# endif
1517#endif
1518 ParentToChildInternalResponse() = default;
1519#ifdef __clang__1
1520# pragma clang diagnostic pop
1521#endif
1522
1523 MOZ_IMPLICIT ParentToChildInternalResponse(
1524 const InternalResponseMetadata& _metadata,
1525 const mozilla::Maybe<ParentToChildStream>& _body,
1526 const int64_t& _bodySize,
1527 const mozilla::Maybe<ParentToChildStream>& _alternativeBody) :
1528 metadata_(_metadata),
1529 body_(_body),
1530 alternativeBody_(_alternativeBody),
1531 bodySize_(_bodySize)
1532 {
1533 }
1534
1535 MOZ_IMPLICIT ParentToChildInternalResponse(
1536 InternalResponseMetadata&& _metadata,
1537 mozilla::Maybe<ParentToChildStream>&& _body,
1538 int64_t&& _bodySize,
1539 mozilla::Maybe<ParentToChildStream>&& _alternativeBody) :
1540 metadata_(std::move(_metadata)),
1541 body_(std::move(_body)),
1542 alternativeBody_(std::move(_alternativeBody)),
1543 bodySize_(std::move(_bodySize))
1544 {
1545 }
1546
1547 InternalResponseMetadata&
1548 metadata()
1549 {
1550 return metadata_;
1551 }
1552 const InternalResponseMetadata&
1553 metadata() const
1554 {
1555 return metadata_;
1556 }
1557
1558 mozilla::Maybe<ParentToChildStream>&
1559 body()
1560 {
1561 return body_;
1562 }
1563 const mozilla::Maybe<ParentToChildStream>&
1564 body() const
1565 {
1566 return body_;
1567 }
1568
1569 int64_t&
1570 bodySize()
1571 {
1572 return bodySize_;
1573 }
1574 const int64_t&
1575 bodySize() const
1576 {
1577 return bodySize_;
1578 }
1579
1580 mozilla::Maybe<ParentToChildStream>&
1581 alternativeBody()
1582 {
1583 return alternativeBody_;
1584 }
1585 const mozilla::Maybe<ParentToChildStream>&
1586 alternativeBody() const
1587 {
1588 return alternativeBody_;
1589 }
1590
1591private:
1592 ::mozilla::ipc::IPDLStructMember<InternalResponseMetadata> metadata_;
1593 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ParentToChildStream>> body_;
1594 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ParentToChildStream>> alternativeBody_;
1595 ::mozilla::ipc::IPDLStructMember<int64_t> bodySize_;
1596};
1597} // namespace dom
1598} // namespace mozilla
1599
1600namespace IPC {
1601template<>
1602struct ParamTraits <::mozilla::dom::ParentToChildInternalResponse>
1603{
1604 typedef ::mozilla::dom::ParentToChildInternalResponse paramType;
1605 static void
1606 Write(
1607 IPC::MessageWriter* aWriter,
1608 const paramType& aVar);
1609 static IPC::ReadResult<paramType>
1610 Read(IPC::MessageReader* aReader);
1611};
1612} // namespace IPC
1613
1614
1615//-----------------------------------------------------------------------------
1616// Declaration of the IPDL type |struct ChildToParentInternalResponse|
1617//
1618namespace mozilla {
1619namespace dom {
1620class ChildToParentInternalResponse final
1621{
1622private:
1623 typedef ::mozilla::dom::InternalResponseMetadata InternalResponseMetadata;
1624 typedef ::mozilla::dom::ChildToParentStream ChildToParentStream;
1625 typedef ::int64_t int64_t;
1626
1627public:
1628#ifdef __clang__1
1629# pragma clang diagnostic push
1630# if __has_warning("-Wdefaulted-function-deleted")1
1631# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
1632# endif
1633#endif
1634 ChildToParentInternalResponse() = default;
1635#ifdef __clang__1
1636# pragma clang diagnostic pop
1637#endif
1638
1639 MOZ_IMPLICIT ChildToParentInternalResponse(
1640 const InternalResponseMetadata& _metadata,
1641 const mozilla::Maybe<ChildToParentStream>& _body,
1642 const int64_t& _bodySize,
1643 const mozilla::Maybe<ChildToParentStream>& _alternativeBody) :
1644 metadata_(_metadata),
1645 body_(_body),
1646 alternativeBody_(_alternativeBody),
1647 bodySize_(_bodySize)
1648 {
1649 }
1650
1651 MOZ_IMPLICIT ChildToParentInternalResponse(
1652 InternalResponseMetadata&& _metadata,
1653 mozilla::Maybe<ChildToParentStream>&& _body,
1654 int64_t&& _bodySize,
1655 mozilla::Maybe<ChildToParentStream>&& _alternativeBody) :
1656 metadata_(std::move(_metadata)),
1657 body_(std::move(_body)),
1658 alternativeBody_(std::move(_alternativeBody)),
1659 bodySize_(std::move(_bodySize))
1660 {
1661 }
1662
1663 InternalResponseMetadata&
1664 metadata()
1665 {
1666 return metadata_;
1667 }
1668 const InternalResponseMetadata&
1669 metadata() const
1670 {
1671 return metadata_;
1672 }
1673
1674 mozilla::Maybe<ChildToParentStream>&
1675 body()
1676 {
1677 return body_;
1678 }
1679 const mozilla::Maybe<ChildToParentStream>&
1680 body() const
1681 {
1682 return body_;
1683 }
1684
1685 int64_t&
1686 bodySize()
1687 {
1688 return bodySize_;
1689 }
1690 const int64_t&
1691 bodySize() const
1692 {
1693 return bodySize_;
1694 }
1695
1696 mozilla::Maybe<ChildToParentStream>&
1697 alternativeBody()
1698 {
1699 return alternativeBody_;
1700 }
1701 const mozilla::Maybe<ChildToParentStream>&
1702 alternativeBody() const
1703 {
1704 return alternativeBody_;
1705 }
1706
1707private:
1708 ::mozilla::ipc::IPDLStructMember<InternalResponseMetadata> metadata_;
1709 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ChildToParentStream>> body_;
1710 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ChildToParentStream>> alternativeBody_;
1711 ::mozilla::ipc::IPDLStructMember<int64_t> bodySize_;
1712};
1713} // namespace dom
1714} // namespace mozilla
1715
1716namespace IPC {
1717template<>
1718struct ParamTraits <::mozilla::dom::ChildToParentInternalResponse>
1719{
1720 typedef ::mozilla::dom::ChildToParentInternalResponse paramType;
1721 static void
1722 Write(
1723 IPC::MessageWriter* aWriter,
1724 const paramType& aVar);
1725 static IPC::ReadResult<paramType>
1726 Read(IPC::MessageReader* aReader);
1727};
1728} // namespace IPC
1729
1730
1731//-----------------------------------------------------------------------------
1732// Declaration of the IPDL type |struct ResponseTiming|
1733//
1734namespace mozilla {
1735namespace dom {
1736class ResponseTiming final
1737{
1738private:
1739 typedef ::mozilla::dom::IPCPerformanceTimingData IPCPerformanceTimingData;
1740 typedef ::nsString nsString;
1741
1742public:
1743#ifdef __clang__1
1744# pragma clang diagnostic push
1745# if __has_warning("-Wdefaulted-function-deleted")1
1746# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
1747# endif
1748#endif
1749 ResponseTiming() = default;
1750#ifdef __clang__1
1751# pragma clang diagnostic pop
1752#endif
1753
1754 MOZ_IMPLICIT ResponseTiming(
1755 const IPCPerformanceTimingData& _timingData,
1756 const nsString& _initiatorType,
1757 const nsString& _entryName) :
1758 timingData_(_timingData),
1759 initiatorType_(_initiatorType),
1760 entryName_(_entryName)
1761 {
1762 }
1763
1764 MOZ_IMPLICIT ResponseTiming(
1765 IPCPerformanceTimingData&& _timingData,
1766 nsString&& _initiatorType,
1767 nsString&& _entryName) :
1768 timingData_(std::move(_timingData)),
1769 initiatorType_(std::move(_initiatorType)),
1770 entryName_(std::move(_entryName))
1771 {
1772 }
1773
1774 IPCPerformanceTimingData&
1775 timingData()
1776 {
1777 return timingData_;
1778 }
1779 const IPCPerformanceTimingData&
1780 timingData() const
1781 {
1782 return timingData_;
1783 }
1784
1785 nsString&
1786 initiatorType()
1787 {
1788 return initiatorType_;
1789 }
1790 const nsString&
1791 initiatorType() const
1792 {
1793 return initiatorType_;
1794 }
1795
1796 nsString&
1797 entryName()
1798 {
1799 return entryName_;
1800 }
1801 const nsString&
1802 entryName() const
1803 {
1804 return entryName_;
1805 }
1806
1807private:
1808 ::mozilla::ipc::IPDLStructMember<IPCPerformanceTimingData> timingData_;
1809 ::mozilla::ipc::IPDLStructMember<nsString> initiatorType_;
1810 ::mozilla::ipc::IPDLStructMember<nsString> entryName_;
1811};
1812} // namespace dom
1813} // namespace mozilla
1814
1815namespace IPC {
1816template<>
1817struct ParamTraits <::mozilla::dom::ResponseTiming>
1818{
1819 typedef ::mozilla::dom::ResponseTiming paramType;
1820 static void
1821 Write(
1822 IPC::MessageWriter* aWriter,
1823 const paramType& aVar);
1824 static IPC::ReadResult<paramType>
1825 Read(IPC::MessageReader* aReader);
1826};
1827} // namespace IPC
1828
1829
1830//-----------------------------------------------------------------------------
1831// Declaration of the IPDL type |struct ResponseEndArgs|
1832//
1833namespace mozilla {
1834namespace dom {
1835class ResponseEndArgs final
1836{
1837private:
1838 typedef ::mozilla::dom::FetchDriverObserver::EndReason EndReason;
1839
1840public:
1841#ifdef __clang__1
1842# pragma clang diagnostic push
1843# if __has_warning("-Wdefaulted-function-deleted")1
1844# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
1845# endif
1846#endif
1847 ResponseEndArgs() = default;
1848#ifdef __clang__1
1849# pragma clang diagnostic pop
1850#endif
1851
1852 MOZ_IMPLICIT ResponseEndArgs(const EndReason& _endReason) :
1853 endReason_(_endReason)
1854 {
1855 }
1856
1857 MOZ_IMPLICIT ResponseEndArgs(EndReason&& _endReason) :
1858 endReason_(std::move(_endReason))
1859 {
1860 }
1861
1862 EndReason&
1863 endReason()
1864 {
1865 return endReason_;
1866 }
1867 const EndReason&
1868 endReason() const
1869 {
1870 return endReason_;
1871 }
1872
1873private:
1874 ::mozilla::ipc::IPDLStructMember<EndReason> endReason_;
1875};
1876} // namespace dom
1877} // namespace mozilla
1878
1879namespace IPC {
1880template<>
1881struct ParamTraits <::mozilla::dom::ResponseEndArgs>
1882{
1883 typedef ::mozilla::dom::ResponseEndArgs paramType;
1884 static void
1885 Write(
1886 IPC::MessageWriter* aWriter,
1887 const paramType& aVar);
1888 static IPC::ReadResult<paramType>
1889 Read(IPC::MessageReader* aReader);
1890};
1891} // namespace IPC
1892
1893#endif // ifndef FetchTypes_h