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' (38 padding bytes, where 6 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_, hasStreamBody_, 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/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-10-17-231001-351276-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' (38 padding bytes, where 6 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_, hasStreamBody_, 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 bool& _hasStreamBody,
696 const nsCString& _fragment,
697 const mozilla::Maybe<PrincipalInfo>& _principalInfo,
698 const mozilla::Maybe<PrincipalInfo>& _interceptionTriggeringPrincipalInfo,
699 const nsContentPolicyType& _interceptionContentPolicyType,
700 const nsTArray<RedirectHistoryEntryInfo>& _interceptionRedirectChain,
701 const bool& _interceptionFromThirdParty,
702 const CrossOriginEmbedderPolicy& _embedderPolicy) :
703 method_(_method),
704 urlList_(_urlList),
705 headersGuard_(_headersGuard),
706 headers_(_headers),
707 body_(_body),
708 preferredAlternativeDataType_(_preferredAlternativeDataType),
709 contentPolicyType_(_contentPolicyType),
710 referrer_(_referrer),
711 referrerPolicy_(_referrerPolicy),
712 environmentReferrerPolicy_(_environmentReferrerPolicy),
713 requestMode_(_requestMode),
714 requestCredentials_(_requestCredentials),
715 cacheMode_(_cacheMode),
716 requestRedirect_(_requestRedirect),
717 requestPriority_(_requestPriority),
718 integrity_(_integrity),
719 keepalive_(_keepalive),
720 hasStreamBody_(_hasStreamBody),
721 fragment_(_fragment),
722 principalInfo_(_principalInfo),
723 interceptionTriggeringPrincipalInfo_(_interceptionTriggeringPrincipalInfo),
724 interceptionContentPolicyType_(_interceptionContentPolicyType),
725 interceptionRedirectChain_(_interceptionRedirectChain),
726 interceptionFromThirdParty_(_interceptionFromThirdParty),
727 embedderPolicy_(_embedderPolicy),
728 bodySize_(_bodySize),
729 internalPriority_(_internalPriority)
730 {
731 }
732
733 MOZ_IMPLICIT IPCInternalRequest(
734 nsCString&& _method,
735 nsTArray<mozilla::NotNull<RefPtr<nsIURI>>>&& _urlList,
736 HeadersGuardEnum&& _headersGuard,
737 nsTArray<HeadersEntry>&& _headers,
738 mozilla::Maybe<BodyStreamVariant>&& _body,
739 int64_t&& _bodySize,
740 nsCString&& _preferredAlternativeDataType,
741 nsContentPolicyType&& _contentPolicyType,
742 int32_t&& _internalPriority,
743 nsCString&& _referrer,
744 ReferrerPolicy&& _referrerPolicy,
745 ReferrerPolicy&& _environmentReferrerPolicy,
746 RequestMode&& _requestMode,
747 RequestCredentials&& _requestCredentials,
748 RequestCache&& _cacheMode,
749 RequestRedirect&& _requestRedirect,
750 RequestPriority&& _requestPriority,
751 nsString&& _integrity,
752 bool&& _keepalive,
753 bool&& _hasStreamBody,
754 nsCString&& _fragment,
755 mozilla::Maybe<PrincipalInfo>&& _principalInfo,
756 mozilla::Maybe<PrincipalInfo>&& _interceptionTriggeringPrincipalInfo,
757 nsContentPolicyType&& _interceptionContentPolicyType,
758 nsTArray<RedirectHistoryEntryInfo>&& _interceptionRedirectChain,
759 bool&& _interceptionFromThirdParty,
760 CrossOriginEmbedderPolicy&& _embedderPolicy) :
761 method_(std::move(_method)),
762 urlList_(std::move(_urlList)),
763 headersGuard_(std::move(_headersGuard)),
764 headers_(std::move(_headers)),
765 body_(std::move(_body)),
766 preferredAlternativeDataType_(std::move(_preferredAlternativeDataType)),
767 contentPolicyType_(std::move(_contentPolicyType)),
768 referrer_(std::move(_referrer)),
769 referrerPolicy_(std::move(_referrerPolicy)),
770 environmentReferrerPolicy_(std::move(_environmentReferrerPolicy)),
771 requestMode_(std::move(_requestMode)),
772 requestCredentials_(std::move(_requestCredentials)),
773 cacheMode_(std::move(_cacheMode)),
774 requestRedirect_(std::move(_requestRedirect)),
775 requestPriority_(std::move(_requestPriority)),
776 integrity_(std::move(_integrity)),
777 keepalive_(std::move(_keepalive)),
778 hasStreamBody_(std::move(_hasStreamBody)),
779 fragment_(std::move(_fragment)),
780 principalInfo_(std::move(_principalInfo)),
781 interceptionTriggeringPrincipalInfo_(std::move(_interceptionTriggeringPrincipalInfo)),
782 interceptionContentPolicyType_(std::move(_interceptionContentPolicyType)),
783 interceptionRedirectChain_(std::move(_interceptionRedirectChain)),
784 interceptionFromThirdParty_(std::move(_interceptionFromThirdParty)),
785 embedderPolicy_(std::move(_embedderPolicy)),
786 bodySize_(std::move(_bodySize)),
787 internalPriority_(std::move(_internalPriority))
788 {
789 }
790
791 nsCString&
792 method()
793 {
794 return method_;
795 }
796 const nsCString&
797 method() const
798 {
799 return method_;
800 }
801
802 nsTArray<mozilla::NotNull<RefPtr<nsIURI>>>&
803 urlList()
804 {
805 return urlList_;
806 }
807 const nsTArray<mozilla::NotNull<RefPtr<nsIURI>>>&
808 urlList() const
809 {
810 return urlList_;
811 }
812
813 HeadersGuardEnum&
814 headersGuard()
815 {
816 return headersGuard_;
817 }
818 const HeadersGuardEnum&
819 headersGuard() const
820 {
821 return headersGuard_;
822 }
823
824 nsTArray<HeadersEntry>&
825 headers()
826 {
827 return headers_;
828 }
829 const nsTArray<HeadersEntry>&
830 headers() const
831 {
832 return headers_;
833 }
834
835 mozilla::Maybe<BodyStreamVariant>&
836 body()
837 {
838 return body_;
839 }
840 const mozilla::Maybe<BodyStreamVariant>&
841 body() const
842 {
843 return body_;
844 }
845
846 int64_t&
847 bodySize()
848 {
849 return bodySize_;
850 }
851 const int64_t&
852 bodySize() const
853 {
854 return bodySize_;
855 }
856
857 nsCString&
858 preferredAlternativeDataType()
859 {
860 return preferredAlternativeDataType_;
861 }
862 const nsCString&
863 preferredAlternativeDataType() const
864 {
865 return preferredAlternativeDataType_;
866 }
867
868 nsContentPolicyType&
869 contentPolicyType()
870 {
871 return contentPolicyType_;
872 }
873 const nsContentPolicyType&
874 contentPolicyType() const
875 {
876 return contentPolicyType_;
877 }
878
879 int32_t&
880 internalPriority()
881 {
882 return internalPriority_;
883 }
884 const int32_t&
885 internalPriority() const
886 {
887 return internalPriority_;
888 }
889
890 nsCString&
891 referrer()
892 {
893 return referrer_;
894 }
895 const nsCString&
896 referrer() const
897 {
898 return referrer_;
899 }
900
901 ReferrerPolicy&
902 referrerPolicy()
903 {
904 return referrerPolicy_;
905 }
906 const ReferrerPolicy&
907 referrerPolicy() const
908 {
909 return referrerPolicy_;
910 }
911
912 ReferrerPolicy&
913 environmentReferrerPolicy()
914 {
915 return environmentReferrerPolicy_;
916 }
917 const ReferrerPolicy&
918 environmentReferrerPolicy() const
919 {
920 return environmentReferrerPolicy_;
921 }
922
923 RequestMode&
924 requestMode()
925 {
926 return requestMode_;
927 }
928 const RequestMode&
929 requestMode() const
930 {
931 return requestMode_;
932 }
933
934 RequestCredentials&
935 requestCredentials()
936 {
937 return requestCredentials_;
938 }
939 const RequestCredentials&
940 requestCredentials() const
941 {
942 return requestCredentials_;
943 }
944
945 RequestCache&
946 cacheMode()
947 {
948 return cacheMode_;
949 }
950 const RequestCache&
951 cacheMode() const
952 {
953 return cacheMode_;
954 }
955
956 RequestRedirect&
957 requestRedirect()
958 {
959 return requestRedirect_;
960 }
961 const RequestRedirect&
962 requestRedirect() const
963 {
964 return requestRedirect_;
965 }
966
967 RequestPriority&
968 requestPriority()
969 {
970 return requestPriority_;
971 }
972 const RequestPriority&
973 requestPriority() const
974 {
975 return requestPriority_;
976 }
977
978 nsString&
979 integrity()
980 {
981 return integrity_;
982 }
983 const nsString&
984 integrity() const
985 {
986 return integrity_;
987 }
988
989 bool&
990 keepalive()
991 {
992 return keepalive_;
993 }
994 const bool&
995 keepalive() const
996 {
997 return keepalive_;
998 }
999
1000 bool&
1001 hasStreamBody()
1002 {
1003 return hasStreamBody_;
1004 }
1005 const bool&
1006 hasStreamBody() const
1007 {
1008 return hasStreamBody_;
1009 }
1010
1011 nsCString&
1012 fragment()
1013 {
1014 return fragment_;
1015 }
1016 const nsCString&
1017 fragment() const
1018 {
1019 return fragment_;
1020 }
1021
1022 mozilla::Maybe<PrincipalInfo>&
1023 principalInfo()
1024 {
1025 return principalInfo_;
1026 }
1027 const mozilla::Maybe<PrincipalInfo>&
1028 principalInfo() const
1029 {
1030 return principalInfo_;
1031 }
1032
1033 mozilla::Maybe<PrincipalInfo>&
1034 interceptionTriggeringPrincipalInfo()
1035 {
1036 return interceptionTriggeringPrincipalInfo_;
1037 }
1038 const mozilla::Maybe<PrincipalInfo>&
1039 interceptionTriggeringPrincipalInfo() const
1040 {
1041 return interceptionTriggeringPrincipalInfo_;
1042 }
1043
1044 nsContentPolicyType&
1045 interceptionContentPolicyType()
1046 {
1047 return interceptionContentPolicyType_;
1048 }
1049 const nsContentPolicyType&
1050 interceptionContentPolicyType() const
1051 {
1052 return interceptionContentPolicyType_;
1053 }
1054
1055 nsTArray<RedirectHistoryEntryInfo>&
1056 interceptionRedirectChain()
1057 {
1058 return interceptionRedirectChain_;
1059 }
1060 const nsTArray<RedirectHistoryEntryInfo>&
1061 interceptionRedirectChain() const
1062 {
1063 return interceptionRedirectChain_;
1064 }
1065
1066 bool&
1067 interceptionFromThirdParty()
1068 {
1069 return interceptionFromThirdParty_;
1070 }
1071 const bool&
1072 interceptionFromThirdParty() const
1073 {
1074 return interceptionFromThirdParty_;
1075 }
1076
1077 CrossOriginEmbedderPolicy&
1078 embedderPolicy()
1079 {
1080 return embedderPolicy_;
1081 }
1082 const CrossOriginEmbedderPolicy&
1083 embedderPolicy() const
1084 {
1085 return embedderPolicy_;
1086 }
1087
1088private:
1089 ::mozilla::ipc::IPDLStructMember<nsCString> method_;
1090 ::mozilla::ipc::IPDLStructMember<CopyableTArray<mozilla::NotNull<RefPtr<nsIURI>>>> urlList_;
1091 ::mozilla::ipc::IPDLStructMember<HeadersGuardEnum> headersGuard_;
1092 ::mozilla::ipc::IPDLStructMember<CopyableTArray<HeadersEntry>> headers_;
1093 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<BodyStreamVariant>> body_;
1094 ::mozilla::ipc::IPDLStructMember<nsCString> preferredAlternativeDataType_;
1095 ::mozilla::ipc::IPDLStructMember<nsContentPolicyType> contentPolicyType_;
1096 ::mozilla::ipc::IPDLStructMember<nsCString> referrer_;
1097 ::mozilla::ipc::IPDLStructMember<ReferrerPolicy> referrerPolicy_;
1098 ::mozilla::ipc::IPDLStructMember<ReferrerPolicy> environmentReferrerPolicy_;
1099 ::mozilla::ipc::IPDLStructMember<RequestMode> requestMode_;
1100 ::mozilla::ipc::IPDLStructMember<RequestCredentials> requestCredentials_;
1101 ::mozilla::ipc::IPDLStructMember<RequestCache> cacheMode_;
1102 ::mozilla::ipc::IPDLStructMember<RequestRedirect> requestRedirect_;
1103 ::mozilla::ipc::IPDLStructMember<RequestPriority> requestPriority_;
1104 ::mozilla::ipc::IPDLStructMember<nsString> integrity_;
1105 ::mozilla::ipc::IPDLStructMember<bool> keepalive_;
1106 ::mozilla::ipc::IPDLStructMember<bool> hasStreamBody_;
1107 ::mozilla::ipc::IPDLStructMember<nsCString> fragment_;
1108 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> principalInfo_;
1109 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> interceptionTriggeringPrincipalInfo_;
1110 ::mozilla::ipc::IPDLStructMember<nsContentPolicyType> interceptionContentPolicyType_;
1111 ::mozilla::ipc::IPDLStructMember<CopyableTArray<RedirectHistoryEntryInfo>> interceptionRedirectChain_;
1112 ::mozilla::ipc::IPDLStructMember<bool> interceptionFromThirdParty_;
1113 ::mozilla::ipc::IPDLStructMember<CrossOriginEmbedderPolicy> embedderPolicy_;
1114 ::mozilla::ipc::IPDLStructMember<int64_t> bodySize_;
1115 ::mozilla::ipc::IPDLStructMember<int32_t> internalPriority_;
1116};
1117} // namespace dom
1118} // namespace mozilla
1119
1120namespace IPC {
1121template<>
1122struct ParamTraits <::mozilla::dom::IPCInternalRequest>
1123{
1124 typedef ::mozilla::dom::IPCInternalRequest paramType;
1125 static void
1126 Write(
1127 IPC::MessageWriter* aWriter,
1128 const paramType& aVar);
1129 static IPC::ReadResult<paramType>
1130 Read(IPC::MessageReader* aReader);
1131};
1132} // namespace IPC
1133
1134
1135//-----------------------------------------------------------------------------
1136// Declaration of the IPDL type |struct InternalResponseMetadata|
1137//
1138namespace mozilla {
1139namespace dom {
1140class InternalResponseMetadata final
1141{
1142private:
1143 typedef ::mozilla::dom::ResponseType ResponseType;
1144 typedef ::nsIURI nsIURI;
1145 typedef ::uint16_t uint16_t;
1146 typedef ::nsCString nsCString;
1147 typedef ::mozilla::dom::HeadersGuardEnum HeadersGuardEnum;
1148 typedef ::mozilla::dom::HeadersEntry HeadersEntry;
1149 typedef ::nsresult nsresult;
1150 typedef ::nsITransportSecurityInfo nsITransportSecurityInfo;
1151 typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
1152 typedef ::mozilla::dom::BlobImpl BlobImpl;
1153 typedef ::nsString nsString;
1154 typedef ::mozilla::dom::RequestCredentials RequestCredentials;
1155
1156public:
1157#ifdef __clang__1
1158# pragma clang diagnostic push
1159# if __has_warning("-Wdefaulted-function-deleted")1
1160# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
1161# endif
1162#endif
1163 InternalResponseMetadata() = default;
1164#ifdef __clang__1
1165# pragma clang diagnostic pop
1166#endif
1167
1168 MOZ_IMPLICIT InternalResponseMetadata(
1169 const ResponseType& _type,
1170 const nsTArray<mozilla::NotNull<RefPtr<nsIURI>>>& _urlList,
1171 const uint16_t& _status,
1172 const nsCString& _statusText,
1173 const HeadersGuardEnum& _headersGuard,
1174 const nsTArray<HeadersEntry>& _headers,
1175 const nsresult& _errorCode,
1176 const nsCString& _alternativeDataType,
1177 nsITransportSecurityInfo* _securityInfo,
1178 const mozilla::Maybe<PrincipalInfo>& _principalInfo,
1179 BlobImpl* _bodyBlobImpl,
1180 const nsString& _bodyLocalPath,
1181 const RequestCredentials& _credentialsMode) :
1182 type_(_type),
1183 urlList_(_urlList),
1184 statusText_(_statusText),
1185 headersGuard_(_headersGuard),
1186 headers_(_headers),
1187 errorCode_(_errorCode),
1188 alternativeDataType_(_alternativeDataType),
1189 securityInfo_(_securityInfo),
1190 principalInfo_(_principalInfo),
1191 bodyBlobImpl_(_bodyBlobImpl),
1192 bodyLocalPath_(_bodyLocalPath),
1193 credentialsMode_(_credentialsMode),
1194 status_(_status)
1195 {
1196 }
1197
1198 MOZ_IMPLICIT InternalResponseMetadata(
1199 ResponseType&& _type,
1200 nsTArray<mozilla::NotNull<RefPtr<nsIURI>>>&& _urlList,
1201 uint16_t&& _status,
1202 nsCString&& _statusText,
1203 HeadersGuardEnum&& _headersGuard,
1204 nsTArray<HeadersEntry>&& _headers,
1205 nsresult&& _errorCode,
1206 nsCString&& _alternativeDataType,
1207 RefPtr<nsITransportSecurityInfo>&& _securityInfo,
1208 mozilla::Maybe<PrincipalInfo>&& _principalInfo,
1209 RefPtr<BlobImpl>&& _bodyBlobImpl,
1210 nsString&& _bodyLocalPath,
1211 RequestCredentials&& _credentialsMode) :
1212 type_(std::move(_type)),
1213 urlList_(std::move(_urlList)),
1214 statusText_(std::move(_statusText)),
1215 headersGuard_(std::move(_headersGuard)),
1216 headers_(std::move(_headers)),
1217 errorCode_(std::move(_errorCode)),
1218 alternativeDataType_(std::move(_alternativeDataType)),
1219 securityInfo_(std::move(_securityInfo)),
1220 principalInfo_(std::move(_principalInfo)),
1221 bodyBlobImpl_(std::move(_bodyBlobImpl)),
1222 bodyLocalPath_(std::move(_bodyLocalPath)),
1223 credentialsMode_(std::move(_credentialsMode)),
1224 status_(std::move(_status))
1225 {
1226 }
1227
1228 ResponseType&
1229 type()
1230 {
1231 return type_;
1232 }
1233 const ResponseType&
1234 type() const
1235 {
1236 return type_;
1237 }
1238
1239 nsTArray<mozilla::NotNull<RefPtr<nsIURI>>>&
1240 urlList()
1241 {
1242 return urlList_;
1243 }
1244 const nsTArray<mozilla::NotNull<RefPtr<nsIURI>>>&
1245 urlList() const
1246 {
1247 return urlList_;
1248 }
1249
1250 uint16_t&
1251 status()
1252 {
1253 return status_;
1254 }
1255 const uint16_t&
1256 status() const
1257 {
1258 return status_;
1259 }
1260
1261 nsCString&
1262 statusText()
1263 {
1264 return statusText_;
1265 }
1266 const nsCString&
1267 statusText() const
1268 {
1269 return statusText_;
1270 }
1271
1272 HeadersGuardEnum&
1273 headersGuard()
1274 {
1275 return headersGuard_;
1276 }
1277 const HeadersGuardEnum&
1278 headersGuard() const
1279 {
1280 return headersGuard_;
1281 }
1282
1283 nsTArray<HeadersEntry>&
1284 headers()
1285 {
1286 return headers_;
1287 }
1288 const nsTArray<HeadersEntry>&
1289 headers() const
1290 {
1291 return headers_;
1292 }
1293
1294 nsresult&
1295 errorCode()
1296 {
1297 return errorCode_;
1298 }
1299 const nsresult&
1300 errorCode() const
1301 {
1302 return errorCode_;
1303 }
1304
1305 nsCString&
1306 alternativeDataType()
1307 {
1308 return alternativeDataType_;
1309 }
1310 const nsCString&
1311 alternativeDataType() const
1312 {
1313 return alternativeDataType_;
1314 }
1315
1316 RefPtr<nsITransportSecurityInfo>&
1317 securityInfo()
1318 {
1319 return securityInfo_;
1320 }
1321 nsITransportSecurityInfo*
1322 securityInfo() const
1323 {
1324 return securityInfo_;
1325 }
1326
1327 mozilla::Maybe<PrincipalInfo>&
1328 principalInfo()
1329 {
1330 return principalInfo_;
1331 }
1332 const mozilla::Maybe<PrincipalInfo>&
1333 principalInfo() const
1334 {
1335 return principalInfo_;
1336 }
1337
1338 RefPtr<BlobImpl>&
1339 bodyBlobImpl()
1340 {
1341 return bodyBlobImpl_;
1342 }
1343 BlobImpl*
1344 bodyBlobImpl() const
1345 {
1346 return bodyBlobImpl_;
1347 }
1348
1349 nsString&
1350 bodyLocalPath()
1351 {
1352 return bodyLocalPath_;
1353 }
1354 const nsString&
1355 bodyLocalPath() const
1356 {
1357 return bodyLocalPath_;
1358 }
1359
1360 RequestCredentials&
1361 credentialsMode()
1362 {
1363 return credentialsMode_;
1364 }
1365 const RequestCredentials&
1366 credentialsMode() const
1367 {
1368 return credentialsMode_;
1369 }
1370
1371private:
1372 ::mozilla::ipc::IPDLStructMember<ResponseType> type_;
1373 ::mozilla::ipc::IPDLStructMember<CopyableTArray<mozilla::NotNull<RefPtr<nsIURI>>>> urlList_;
1374 ::mozilla::ipc::IPDLStructMember<nsCString> statusText_;
1375 ::mozilla::ipc::IPDLStructMember<HeadersGuardEnum> headersGuard_;
1376 ::mozilla::ipc::IPDLStructMember<CopyableTArray<HeadersEntry>> headers_;
1377 ::mozilla::ipc::IPDLStructMember<nsresult> errorCode_;
1378 ::mozilla::ipc::IPDLStructMember<nsCString> alternativeDataType_;
1379 ::mozilla::ipc::IPDLStructMember<RefPtr<nsITransportSecurityInfo>> securityInfo_;
1380 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> principalInfo_;
1381 ::mozilla::ipc::IPDLStructMember<RefPtr<BlobImpl>> bodyBlobImpl_;
1382 ::mozilla::ipc::IPDLStructMember<nsString> bodyLocalPath_;
1383 ::mozilla::ipc::IPDLStructMember<RequestCredentials> credentialsMode_;
1384 ::mozilla::ipc::IPDLStructMember<uint16_t> status_;
1385};
1386} // namespace dom
1387} // namespace mozilla
1388
1389namespace IPC {
1390template<>
1391struct ParamTraits <::mozilla::dom::InternalResponseMetadata>
1392{
1393 typedef ::mozilla::dom::InternalResponseMetadata paramType;
1394 static void
1395 Write(
1396 IPC::MessageWriter* aWriter,
1397 const paramType& aVar);
1398 static IPC::ReadResult<paramType>
1399 Read(IPC::MessageReader* aReader);
1400};
1401} // namespace IPC
1402
1403
1404//-----------------------------------------------------------------------------
1405// Declaration of the IPDL type |struct ParentToParentInternalResponse|
1406//
1407namespace mozilla {
1408namespace dom {
1409class ParentToParentInternalResponse final
1410{
1411private:
1412 typedef ::mozilla::dom::InternalResponseMetadata InternalResponseMetadata;
1413 typedef ::mozilla::dom::ParentToParentStream ParentToParentStream;
1414 typedef ::int64_t int64_t;
1415
1416public:
1417#ifdef __clang__1
1418# pragma clang diagnostic push
1419# if __has_warning("-Wdefaulted-function-deleted")1
1420# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
1421# endif
1422#endif
1423 ParentToParentInternalResponse() = default;
1424#ifdef __clang__1
1425# pragma clang diagnostic pop
1426#endif
1427
1428 MOZ_IMPLICIT ParentToParentInternalResponse(
1429 const InternalResponseMetadata& _metadata,
1430 const mozilla::Maybe<ParentToParentStream>& _body,
1431 const int64_t& _bodySize,
1432 const mozilla::Maybe<ParentToParentStream>& _alternativeBody) :
1433 metadata_(_metadata),
1434 body_(_body),
1435 alternativeBody_(_alternativeBody),
1436 bodySize_(_bodySize)
1437 {
1438 }
1439
1440 MOZ_IMPLICIT ParentToParentInternalResponse(
1441 InternalResponseMetadata&& _metadata,
1442 mozilla::Maybe<ParentToParentStream>&& _body,
1443 int64_t&& _bodySize,
1444 mozilla::Maybe<ParentToParentStream>&& _alternativeBody) :
1445 metadata_(std::move(_metadata)),
1446 body_(std::move(_body)),
1447 alternativeBody_(std::move(_alternativeBody)),
1448 bodySize_(std::move(_bodySize))
1449 {
1450 }
1451
1452 InternalResponseMetadata&
1453 metadata()
1454 {
1455 return metadata_;
1456 }
1457 const InternalResponseMetadata&
1458 metadata() const
1459 {
1460 return metadata_;
1461 }
1462
1463 mozilla::Maybe<ParentToParentStream>&
1464 body()
1465 {
1466 return body_;
1467 }
1468 const mozilla::Maybe<ParentToParentStream>&
1469 body() const
1470 {
1471 return body_;
1472 }
1473
1474 int64_t&
1475 bodySize()
1476 {
1477 return bodySize_;
1478 }
1479 const int64_t&
1480 bodySize() const
1481 {
1482 return bodySize_;
1483 }
1484
1485 mozilla::Maybe<ParentToParentStream>&
1486 alternativeBody()
1487 {
1488 return alternativeBody_;
1489 }
1490 const mozilla::Maybe<ParentToParentStream>&
1491 alternativeBody() const
1492 {
1493 return alternativeBody_;
1494 }
1495
1496private:
1497 ::mozilla::ipc::IPDLStructMember<InternalResponseMetadata> metadata_;
1498 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ParentToParentStream>> body_;
1499 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ParentToParentStream>> alternativeBody_;
1500 ::mozilla::ipc::IPDLStructMember<int64_t> bodySize_;
1501};
1502} // namespace dom
1503} // namespace mozilla
1504
1505namespace IPC {
1506template<>
1507struct ParamTraits <::mozilla::dom::ParentToParentInternalResponse>
1508{
1509 typedef ::mozilla::dom::ParentToParentInternalResponse paramType;
1510 static void
1511 Write(
1512 IPC::MessageWriter* aWriter,
1513 const paramType& aVar);
1514 static IPC::ReadResult<paramType>
1515 Read(IPC::MessageReader* aReader);
1516};
1517} // namespace IPC
1518
1519
1520//-----------------------------------------------------------------------------
1521// Declaration of the IPDL type |struct ParentToChildInternalResponse|
1522//
1523namespace mozilla {
1524namespace dom {
1525class ParentToChildInternalResponse final
1526{
1527private:
1528 typedef ::mozilla::dom::InternalResponseMetadata InternalResponseMetadata;
1529 typedef ::mozilla::dom::ParentToChildStream ParentToChildStream;
1530 typedef ::int64_t int64_t;
1531
1532public:
1533#ifdef __clang__1
1534# pragma clang diagnostic push
1535# if __has_warning("-Wdefaulted-function-deleted")1
1536# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
1537# endif
1538#endif
1539 ParentToChildInternalResponse() = default;
1540#ifdef __clang__1
1541# pragma clang diagnostic pop
1542#endif
1543
1544 MOZ_IMPLICIT ParentToChildInternalResponse(
1545 const InternalResponseMetadata& _metadata,
1546 const mozilla::Maybe<ParentToChildStream>& _body,
1547 const int64_t& _bodySize,
1548 const mozilla::Maybe<ParentToChildStream>& _alternativeBody) :
1549 metadata_(_metadata),
1550 body_(_body),
1551 alternativeBody_(_alternativeBody),
1552 bodySize_(_bodySize)
1553 {
1554 }
1555
1556 MOZ_IMPLICIT ParentToChildInternalResponse(
1557 InternalResponseMetadata&& _metadata,
1558 mozilla::Maybe<ParentToChildStream>&& _body,
1559 int64_t&& _bodySize,
1560 mozilla::Maybe<ParentToChildStream>&& _alternativeBody) :
1561 metadata_(std::move(_metadata)),
1562 body_(std::move(_body)),
1563 alternativeBody_(std::move(_alternativeBody)),
1564 bodySize_(std::move(_bodySize))
1565 {
1566 }
1567
1568 InternalResponseMetadata&
1569 metadata()
1570 {
1571 return metadata_;
1572 }
1573 const InternalResponseMetadata&
1574 metadata() const
1575 {
1576 return metadata_;
1577 }
1578
1579 mozilla::Maybe<ParentToChildStream>&
1580 body()
1581 {
1582 return body_;
1583 }
1584 const mozilla::Maybe<ParentToChildStream>&
1585 body() const
1586 {
1587 return body_;
1588 }
1589
1590 int64_t&
1591 bodySize()
1592 {
1593 return bodySize_;
1594 }
1595 const int64_t&
1596 bodySize() const
1597 {
1598 return bodySize_;
1599 }
1600
1601 mozilla::Maybe<ParentToChildStream>&
1602 alternativeBody()
1603 {
1604 return alternativeBody_;
1605 }
1606 const mozilla::Maybe<ParentToChildStream>&
1607 alternativeBody() const
1608 {
1609 return alternativeBody_;
1610 }
1611
1612private:
1613 ::mozilla::ipc::IPDLStructMember<InternalResponseMetadata> metadata_;
1614 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ParentToChildStream>> body_;
1615 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ParentToChildStream>> alternativeBody_;
1616 ::mozilla::ipc::IPDLStructMember<int64_t> bodySize_;
1617};
1618} // namespace dom
1619} // namespace mozilla
1620
1621namespace IPC {
1622template<>
1623struct ParamTraits <::mozilla::dom::ParentToChildInternalResponse>
1624{
1625 typedef ::mozilla::dom::ParentToChildInternalResponse paramType;
1626 static void
1627 Write(
1628 IPC::MessageWriter* aWriter,
1629 const paramType& aVar);
1630 static IPC::ReadResult<paramType>
1631 Read(IPC::MessageReader* aReader);
1632};
1633} // namespace IPC
1634
1635
1636//-----------------------------------------------------------------------------
1637// Declaration of the IPDL type |struct ChildToParentInternalResponse|
1638//
1639namespace mozilla {
1640namespace dom {
1641class ChildToParentInternalResponse final
1642{
1643private:
1644 typedef ::mozilla::dom::InternalResponseMetadata InternalResponseMetadata;
1645 typedef ::mozilla::dom::ChildToParentStream ChildToParentStream;
1646 typedef ::int64_t int64_t;
1647
1648public:
1649#ifdef __clang__1
1650# pragma clang diagnostic push
1651# if __has_warning("-Wdefaulted-function-deleted")1
1652# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
1653# endif
1654#endif
1655 ChildToParentInternalResponse() = default;
1656#ifdef __clang__1
1657# pragma clang diagnostic pop
1658#endif
1659
1660 MOZ_IMPLICIT ChildToParentInternalResponse(
1661 const InternalResponseMetadata& _metadata,
1662 const mozilla::Maybe<ChildToParentStream>& _body,
1663 const int64_t& _bodySize,
1664 const mozilla::Maybe<ChildToParentStream>& _alternativeBody) :
1665 metadata_(_metadata),
1666 body_(_body),
1667 alternativeBody_(_alternativeBody),
1668 bodySize_(_bodySize)
1669 {
1670 }
1671
1672 MOZ_IMPLICIT ChildToParentInternalResponse(
1673 InternalResponseMetadata&& _metadata,
1674 mozilla::Maybe<ChildToParentStream>&& _body,
1675 int64_t&& _bodySize,
1676 mozilla::Maybe<ChildToParentStream>&& _alternativeBody) :
1677 metadata_(std::move(_metadata)),
1678 body_(std::move(_body)),
1679 alternativeBody_(std::move(_alternativeBody)),
1680 bodySize_(std::move(_bodySize))
1681 {
1682 }
1683
1684 InternalResponseMetadata&
1685 metadata()
1686 {
1687 return metadata_;
1688 }
1689 const InternalResponseMetadata&
1690 metadata() const
1691 {
1692 return metadata_;
1693 }
1694
1695 mozilla::Maybe<ChildToParentStream>&
1696 body()
1697 {
1698 return body_;
1699 }
1700 const mozilla::Maybe<ChildToParentStream>&
1701 body() const
1702 {
1703 return body_;
1704 }
1705
1706 int64_t&
1707 bodySize()
1708 {
1709 return bodySize_;
1710 }
1711 const int64_t&
1712 bodySize() const
1713 {
1714 return bodySize_;
1715 }
1716
1717 mozilla::Maybe<ChildToParentStream>&
1718 alternativeBody()
1719 {
1720 return alternativeBody_;
1721 }
1722 const mozilla::Maybe<ChildToParentStream>&
1723 alternativeBody() const
1724 {
1725 return alternativeBody_;
1726 }
1727
1728private:
1729 ::mozilla::ipc::IPDLStructMember<InternalResponseMetadata> metadata_;
1730 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ChildToParentStream>> body_;
1731 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ChildToParentStream>> alternativeBody_;
1732 ::mozilla::ipc::IPDLStructMember<int64_t> bodySize_;
1733};
1734} // namespace dom
1735} // namespace mozilla
1736
1737namespace IPC {
1738template<>
1739struct ParamTraits <::mozilla::dom::ChildToParentInternalResponse>
1740{
1741 typedef ::mozilla::dom::ChildToParentInternalResponse paramType;
1742 static void
1743 Write(
1744 IPC::MessageWriter* aWriter,
1745 const paramType& aVar);
1746 static IPC::ReadResult<paramType>
1747 Read(IPC::MessageReader* aReader);
1748};
1749} // namespace IPC
1750
1751
1752//-----------------------------------------------------------------------------
1753// Declaration of the IPDL type |struct ResponseTiming|
1754//
1755namespace mozilla {
1756namespace dom {
1757class ResponseTiming final
1758{
1759private:
1760 typedef ::mozilla::dom::IPCPerformanceTimingData IPCPerformanceTimingData;
1761 typedef ::nsString nsString;
1762
1763public:
1764#ifdef __clang__1
1765# pragma clang diagnostic push
1766# if __has_warning("-Wdefaulted-function-deleted")1
1767# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
1768# endif
1769#endif
1770 ResponseTiming() = default;
1771#ifdef __clang__1
1772# pragma clang diagnostic pop
1773#endif
1774
1775 MOZ_IMPLICIT ResponseTiming(
1776 const IPCPerformanceTimingData& _timingData,
1777 const nsString& _initiatorType,
1778 const nsString& _entryName) :
1779 timingData_(_timingData),
1780 initiatorType_(_initiatorType),
1781 entryName_(_entryName)
1782 {
1783 }
1784
1785 MOZ_IMPLICIT ResponseTiming(
1786 IPCPerformanceTimingData&& _timingData,
1787 nsString&& _initiatorType,
1788 nsString&& _entryName) :
1789 timingData_(std::move(_timingData)),
1790 initiatorType_(std::move(_initiatorType)),
1791 entryName_(std::move(_entryName))
1792 {
1793 }
1794
1795 IPCPerformanceTimingData&
1796 timingData()
1797 {
1798 return timingData_;
1799 }
1800 const IPCPerformanceTimingData&
1801 timingData() const
1802 {
1803 return timingData_;
1804 }
1805
1806 nsString&
1807 initiatorType()
1808 {
1809 return initiatorType_;
1810 }
1811 const nsString&
1812 initiatorType() const
1813 {
1814 return initiatorType_;
1815 }
1816
1817 nsString&
1818 entryName()
1819 {
1820 return entryName_;
1821 }
1822 const nsString&
1823 entryName() const
1824 {
1825 return entryName_;
1826 }
1827
1828private:
1829 ::mozilla::ipc::IPDLStructMember<IPCPerformanceTimingData> timingData_;
1830 ::mozilla::ipc::IPDLStructMember<nsString> initiatorType_;
1831 ::mozilla::ipc::IPDLStructMember<nsString> entryName_;
1832};
1833} // namespace dom
1834} // namespace mozilla
1835
1836namespace IPC {
1837template<>
1838struct ParamTraits <::mozilla::dom::ResponseTiming>
1839{
1840 typedef ::mozilla::dom::ResponseTiming paramType;
1841 static void
1842 Write(
1843 IPC::MessageWriter* aWriter,
1844 const paramType& aVar);
1845 static IPC::ReadResult<paramType>
1846 Read(IPC::MessageReader* aReader);
1847};
1848} // namespace IPC
1849
1850
1851//-----------------------------------------------------------------------------
1852// Declaration of the IPDL type |struct ResponseEndArgs|
1853//
1854namespace mozilla {
1855namespace dom {
1856class ResponseEndArgs final
1857{
1858private:
1859 typedef ::mozilla::dom::FetchDriverObserver::EndReason EndReason;
1860
1861public:
1862#ifdef __clang__1
1863# pragma clang diagnostic push
1864# if __has_warning("-Wdefaulted-function-deleted")1
1865# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
1866# endif
1867#endif
1868 ResponseEndArgs() = default;
1869#ifdef __clang__1
1870# pragma clang diagnostic pop
1871#endif
1872
1873 MOZ_IMPLICIT ResponseEndArgs(const EndReason& _endReason) :
1874 endReason_(_endReason)
1875 {
1876 }
1877
1878 MOZ_IMPLICIT ResponseEndArgs(EndReason&& _endReason) :
1879 endReason_(std::move(_endReason))
1880 {
1881 }
1882
1883 EndReason&
1884 endReason()
1885 {
1886 return endReason_;
1887 }
1888 const EndReason&
1889 endReason() const
1890 {
1891 return endReason_;
1892 }
1893
1894private:
1895 ::mozilla::ipc::IPDLStructMember<EndReason> endReason_;
1896};
1897} // namespace dom
1898} // namespace mozilla
1899
1900namespace IPC {
1901template<>
1902struct ParamTraits <::mozilla::dom::ResponseEndArgs>
1903{
1904 typedef ::mozilla::dom::ResponseEndArgs paramType;
1905 static void
1906 Write(
1907 IPC::MessageWriter* aWriter,
1908 const paramType& aVar);
1909 static IPC::ReadResult<paramType>
1910 Read(IPC::MessageReader* aReader);
1911};
1912} // namespace IPC
1913
1914#endif // ifndef FetchTypes_h