Bug Summary

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