Bug Summary

File:var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/net/NeckoChannelParams.h
Warning:line 664, column 7
Excessive padding in 'class mozilla::net::LoadInfoArgs' (33 padding bytes, where 1 is optimal). Optimal fields order: redirectChainIncludingInternalRedirects_, redirectChain_, corsUnsafeHeaders_, unstrippedURI_, triggeringWindowId_, innerWindowID_, browsingContextID_, frameBrowsingContextID_, triggeringRemoteType_, cspNonce_, integrityMetadata_, overriddenFingerprintingSettings_, originAttributes_, cookieJarSettings_, triggeringPrincipalInfo_, resultPrincipalURI_, requestingPrincipalInfo_, principalToInheritInfo_, topLevelPrincipalInfo_, interceptionInfo_, cspToInheritInfo_, controller_, clientInfo_, reservedClientInfo_, initialClientInfo_, httpsUpgradeTelemetry_, securityFlags_, sandboxFlags_, triggeringSandboxFlags_, tainting_, httpsOnlyStatus_, requestBlockingReason_, sandboxedNullPrincipalID_, triggeringStorageAccess_, contentPolicyType_, blockAllMixedContent_, upgradeInsecureRequests_, browserUpgradeInsecureRequests_, browserDidUpgradeInsecureRequests_, browserWouldUpgradeInsecureRequests_, forceAllowDataURI_, allowInsecureRedirectToDataURI_, skipContentPolicyCheckForWebRequest_, originalFrameSrcLoad_, forceInheritPrincipalDropped_, initialSecurityCheckDone_, isInThirdPartyContext_, isFormSubmission_, sendCSPViolationEvents_, hasInjectedCookieForCookieBannerHandling_, wasSchemelessInput_, forcePreflight_, isPreflight_, loadTriggeredFromExternal_, serviceWorkerTaintingSynthesized_, documentHasUserInteracted_, allowListFutureDocumentsCreatedFromThisRedirectChain_, needForCheckingAntiTrackingHeuristic_, skipContentSniffing_, hstsStatus_, hasValidUserGestureActivation_, textDirectiveUserActivation_, allowDeprecatedSystemRequests_, isInDevToolsContext_, parserCreatedScript_, isFromProcessingFrameAttributes_, isMediaRequest_, isMediaInitialRequest_, isFromObjectOrEmbed_, storagePermission_, isMetaRefresh_, loadingEmbedderPolicy_, originTrialCoepCredentiallessEnabledForTopLevel_, isNewWindowTarget_, isThirdPartyContextToTopWindow_, consider reordering the fields or adding explicit padding members

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name AccessibleWrap.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=/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/accessible/atk -fcoverage-compilation-dir=/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/accessible/atk -resource-dir /usr/lib/llvm-19/lib/clang/19 -include /var/lib/jenkins/workspace/firefox-scan-build/config/gcc_hidden.h -include /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/stl_wrappers -I /var/lib/jenkins/workspace/firefox-scan-build/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 /var/lib/jenkins/workspace/firefox-scan-build/accessible/atk -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/accessible/atk -I /var/lib/jenkins/workspace/firefox-scan-build/accessible/base -I /var/lib/jenkins/workspace/firefox-scan-build/accessible/generic -I /var/lib/jenkins/workspace/firefox-scan-build/accessible/html -I /var/lib/jenkins/workspace/firefox-scan-build/accessible/ipc -I /var/lib/jenkins/workspace/firefox-scan-build/accessible/xpcom -I /var/lib/jenkins/workspace/firefox-scan-build/accessible/xul -I /var/lib/jenkins/workspace/firefox-scan-build/layout/generic -I /var/lib/jenkins/workspace/firefox-scan-build/other-licenses/atk-1.0 -I /var/lib/jenkins/workspace/firefox-scan-build/widget -I /var/lib/jenkins/workspace/firefox-scan-build/widget/gtk -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders -I /var/lib/jenkins/workspace/firefox-scan-build/ipc/chromium/src -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -I /usr/include/gtk-3.0 -I /usr/include/pango-1.0 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/gio-unix-2.0 -I /usr/include/cloudproviders -I /usr/include/atk-1.0 -I /usr/include/at-spi2-atk/2.0 -I /usr/include/at-spi-2.0 -I /usr/include/dbus-1.0 -I /usr/lib/x86_64-linux-gnu/dbus-1.0/include -I /usr/include/gtk-3.0/unix-print -I /usr/include/dbus-1.0 -I /usr/lib/x86_64-linux-gnu/dbus-1.0/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-deprecated-this-capture -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -Wno-error=unused-function -Wno-unused-local-typedefs -fdeprecated-macro -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fno-rtti -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2024-09-22-115206-3586786-1 -x c++ /var/lib/jenkins/workspace/firefox-scan-build/accessible/atk/AccessibleWrap.cpp
1//
2// Automatically generated by ipdlc.
3// Edit at your own risk
4//
5
6#ifndef NeckoChannelParams_h
7#define NeckoChannelParams_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/TimeStamp.h"
25#include "mozilla/dom/FeaturePolicy.h"
26#include "mozilla/dom/RequestBinding.h"
27#include "mozilla/dom/SessionHistoryEntry.h"
28#include "mozilla/ipc/BackgroundUtils.h"
29#include "mozilla/ipc/IPDLStructMember.h"
30#include "mozilla/net/PHttpChannelParams.h"
31#include "nsDOMNavigationTiming.h"
32#include "nsDocShellLoadState.h"
33#include "nsICacheInfoChannel.h"
34#include "nsIContentPolicy.h"
35#include "nsILoadInfo.h"
36#include "nsIPropertyBag2.h"
37#include "nsNetUtil.h"
38#include "mozilla/dom/ClientIPCTypes.h"
39#include "mozilla/ipc/URIParams.h"
40#include "mozilla/dom/IPCServiceWorkerDescriptor.h"
41#include "mozilla/ipc/IPCStream.h"
42#include "mozilla/ipc/PBackgroundSharedTypes.h"
43#include "mozilla/dom/DOMTypes.h"
44#include "mozilla/ipc/ProtocolTypes.h"
45
46
47//-----------------------------------------------------------------------------
48// Declaration of the IPDL type |struct CookiePermissionData|
49//
50namespace mozilla {
51namespace net {
52class CookiePermissionData final
53{
54private:
55 typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
56 typedef ::uint32_t uint32_t;
57
58public:
59#ifdef __clang__1
60# pragma clang diagnostic push
61# if __has_warning("-Wdefaulted-function-deleted")1
62# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
63# endif
64#endif
65 CookiePermissionData() = default;
66#ifdef __clang__1
67# pragma clang diagnostic pop
68#endif
69
70 MOZ_IMPLICIT CookiePermissionData(
71 const PrincipalInfo& _principalInfo,
72 const uint32_t& _cookiePermission) :
73 principalInfo_(_principalInfo),
74 cookiePermission_(_cookiePermission)
75 {
76 }
77
78 MOZ_IMPLICIT CookiePermissionData(
79 PrincipalInfo&& _principalInfo,
80 uint32_t&& _cookiePermission) :
81 principalInfo_(std::move(_principalInfo)),
82 cookiePermission_(std::move(_cookiePermission))
83 {
84 }
85
86 PrincipalInfo&
87 principalInfo()
88 {
89 return principalInfo_;
90 }
91 const PrincipalInfo&
92 principalInfo() const
93 {
94 return principalInfo_;
95 }
96
97 uint32_t&
98 cookiePermission()
99 {
100 return cookiePermission_;
101 }
102 const uint32_t&
103 cookiePermission() const
104 {
105 return cookiePermission_;
106 }
107
108private:
109 ::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
110 ::mozilla::ipc::IPDLStructMember<uint32_t> cookiePermission_;
111};
112} // namespace net
113} // namespace mozilla
114
115namespace IPC {
116template<>
117struct ParamTraits <::mozilla::net::CookiePermissionData>
118{
119 typedef ::mozilla::net::CookiePermissionData paramType;
120 static void
121 Write(
122 IPC::MessageWriter* aWriter,
123 const paramType& aVar);
124 static IPC::ReadResult<paramType>
125 Read(IPC::MessageReader* aReader);
126};
127} // namespace IPC
128
129
130//-----------------------------------------------------------------------------
131// Declaration of the IPDL type |struct CookieJarSettingsArgs|
132//
133namespace mozilla {
134namespace net {
135class CookieJarSettingsArgs final
136{
137private:
138 typedef ::uint32_t uint32_t;
139 typedef ::mozilla::net::CookiePermissionData CookiePermissionData;
140 typedef ::nsString nsString;
141 typedef ::uint8_t uint8_t;
142 typedef ::uint64_t uint64_t;
143
144public:
145#ifdef __clang__1
146# pragma clang diagnostic push
147# if __has_warning("-Wdefaulted-function-deleted")1
148# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
149# endif
150#endif
151 CookieJarSettingsArgs() = default;
152#ifdef __clang__1
153# pragma clang diagnostic pop
154#endif
155
156 MOZ_IMPLICIT CookieJarSettingsArgs(
157 const uint32_t& _cookieBehavior,
158 const bool& _isFirstPartyIsolated,
159 const bool& _shouldResistFingerprinting,
160 const bool& _isOnContentBlockingAllowList,
161 const nsTArray<CookiePermissionData>& _cookiePermissions,
162 const bool& _isFixed,
163 const nsString& _partitionKey,
164 const bool& _hasFingerprintingRandomizationKey,
165 const nsTArray<uint8_t>& _fingerprintingRandomizationKey,
166 const uint64_t& _topLevelWindowContextId) :
167 isFirstPartyIsolated_(_isFirstPartyIsolated),
168 shouldResistFingerprinting_(_shouldResistFingerprinting),
169 isOnContentBlockingAllowList_(_isOnContentBlockingAllowList),
170 cookiePermissions_(_cookiePermissions),
171 isFixed_(_isFixed),
172 partitionKey_(_partitionKey),
173 hasFingerprintingRandomizationKey_(_hasFingerprintingRandomizationKey),
174 fingerprintingRandomizationKey_(_fingerprintingRandomizationKey),
175 topLevelWindowContextId_(_topLevelWindowContextId),
176 cookieBehavior_(_cookieBehavior)
177 {
178 }
179
180 MOZ_IMPLICIT CookieJarSettingsArgs(
181 uint32_t&& _cookieBehavior,
182 bool&& _isFirstPartyIsolated,
183 bool&& _shouldResistFingerprinting,
184 bool&& _isOnContentBlockingAllowList,
185 nsTArray<CookiePermissionData>&& _cookiePermissions,
186 bool&& _isFixed,
187 nsString&& _partitionKey,
188 bool&& _hasFingerprintingRandomizationKey,
189 nsTArray<uint8_t>&& _fingerprintingRandomizationKey,
190 uint64_t&& _topLevelWindowContextId) :
191 isFirstPartyIsolated_(std::move(_isFirstPartyIsolated)),
192 shouldResistFingerprinting_(std::move(_shouldResistFingerprinting)),
193 isOnContentBlockingAllowList_(std::move(_isOnContentBlockingAllowList)),
194 cookiePermissions_(std::move(_cookiePermissions)),
195 isFixed_(std::move(_isFixed)),
196 partitionKey_(std::move(_partitionKey)),
197 hasFingerprintingRandomizationKey_(std::move(_hasFingerprintingRandomizationKey)),
198 fingerprintingRandomizationKey_(std::move(_fingerprintingRandomizationKey)),
199 topLevelWindowContextId_(std::move(_topLevelWindowContextId)),
200 cookieBehavior_(std::move(_cookieBehavior))
201 {
202 }
203
204 uint32_t&
205 cookieBehavior()
206 {
207 return cookieBehavior_;
208 }
209 const uint32_t&
210 cookieBehavior() const
211 {
212 return cookieBehavior_;
213 }
214
215 bool&
216 isFirstPartyIsolated()
217 {
218 return isFirstPartyIsolated_;
219 }
220 const bool&
221 isFirstPartyIsolated() const
222 {
223 return isFirstPartyIsolated_;
224 }
225
226 bool&
227 shouldResistFingerprinting()
228 {
229 return shouldResistFingerprinting_;
230 }
231 const bool&
232 shouldResistFingerprinting() const
233 {
234 return shouldResistFingerprinting_;
235 }
236
237 bool&
238 isOnContentBlockingAllowList()
239 {
240 return isOnContentBlockingAllowList_;
241 }
242 const bool&
243 isOnContentBlockingAllowList() const
244 {
245 return isOnContentBlockingAllowList_;
246 }
247
248 nsTArray<CookiePermissionData>&
249 cookiePermissions()
250 {
251 return cookiePermissions_;
252 }
253 const nsTArray<CookiePermissionData>&
254 cookiePermissions() const
255 {
256 return cookiePermissions_;
257 }
258
259 bool&
260 isFixed()
261 {
262 return isFixed_;
263 }
264 const bool&
265 isFixed() const
266 {
267 return isFixed_;
268 }
269
270 nsString&
271 partitionKey()
272 {
273 return partitionKey_;
274 }
275 const nsString&
276 partitionKey() const
277 {
278 return partitionKey_;
279 }
280
281 bool&
282 hasFingerprintingRandomizationKey()
283 {
284 return hasFingerprintingRandomizationKey_;
285 }
286 const bool&
287 hasFingerprintingRandomizationKey() const
288 {
289 return hasFingerprintingRandomizationKey_;
290 }
291
292 nsTArray<uint8_t>&
293 fingerprintingRandomizationKey()
294 {
295 return fingerprintingRandomizationKey_;
296 }
297 const nsTArray<uint8_t>&
298 fingerprintingRandomizationKey() const
299 {
300 return fingerprintingRandomizationKey_;
301 }
302
303 uint64_t&
304 topLevelWindowContextId()
305 {
306 return topLevelWindowContextId_;
307 }
308 const uint64_t&
309 topLevelWindowContextId() const
310 {
311 return topLevelWindowContextId_;
312 }
313
314private:
315 ::mozilla::ipc::IPDLStructMember<bool> isFirstPartyIsolated_;
316 ::mozilla::ipc::IPDLStructMember<bool> shouldResistFingerprinting_;
317 ::mozilla::ipc::IPDLStructMember<bool> isOnContentBlockingAllowList_;
318 ::mozilla::ipc::IPDLStructMember<CopyableTArray<CookiePermissionData>> cookiePermissions_;
319 ::mozilla::ipc::IPDLStructMember<bool> isFixed_;
320 ::mozilla::ipc::IPDLStructMember<nsString> partitionKey_;
321 ::mozilla::ipc::IPDLStructMember<bool> hasFingerprintingRandomizationKey_;
322 ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> fingerprintingRandomizationKey_;
323 ::mozilla::ipc::IPDLStructMember<uint64_t> topLevelWindowContextId_;
324 ::mozilla::ipc::IPDLStructMember<uint32_t> cookieBehavior_;
325};
326} // namespace net
327} // namespace mozilla
328
329namespace IPC {
330template<>
331struct ParamTraits <::mozilla::net::CookieJarSettingsArgs>
332{
333 typedef ::mozilla::net::CookieJarSettingsArgs paramType;
334 static void
335 Write(
336 IPC::MessageWriter* aWriter,
337 const paramType& aVar);
338 static IPC::ReadResult<paramType>
339 Read(IPC::MessageReader* aReader);
340};
341} // namespace IPC
342
343
344//-----------------------------------------------------------------------------
345// Declaration of the IPDL type |struct PreferredAlternativeDataTypeParams|
346//
347namespace mozilla {
348namespace net {
349class PreferredAlternativeDataTypeParams final
350{
351private:
352 typedef ::nsCString nsCString;
353 typedef ::mozilla::net::PreferredAlternativeDataDeliveryTypeIPC PreferredAlternativeDataDeliveryTypeIPC;
354
355public:
356#ifdef __clang__1
357# pragma clang diagnostic push
358# if __has_warning("-Wdefaulted-function-deleted")1
359# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
360# endif
361#endif
362 PreferredAlternativeDataTypeParams() = default;
363#ifdef __clang__1
364# pragma clang diagnostic pop
365#endif
366
367 MOZ_IMPLICIT PreferredAlternativeDataTypeParams(
368 const nsCString& _type,
369 const nsCString& _contentType,
370 const PreferredAlternativeDataDeliveryTypeIPC& _deliverAltData) :
371 type_(_type),
372 contentType_(_contentType),
373 deliverAltData_(_deliverAltData)
374 {
375 }
376
377 MOZ_IMPLICIT PreferredAlternativeDataTypeParams(
378 nsCString&& _type,
379 nsCString&& _contentType,
380 PreferredAlternativeDataDeliveryTypeIPC&& _deliverAltData) :
381 type_(std::move(_type)),
382 contentType_(std::move(_contentType)),
383 deliverAltData_(std::move(_deliverAltData))
384 {
385 }
386
387 nsCString&
388 type()
389 {
390 return type_;
391 }
392 const nsCString&
393 type() const
394 {
395 return type_;
396 }
397
398 nsCString&
399 contentType()
400 {
401 return contentType_;
402 }
403 const nsCString&
404 contentType() const
405 {
406 return contentType_;
407 }
408
409 PreferredAlternativeDataDeliveryTypeIPC&
410 deliverAltData()
411 {
412 return deliverAltData_;
413 }
414 const PreferredAlternativeDataDeliveryTypeIPC&
415 deliverAltData() const
416 {
417 return deliverAltData_;
418 }
419
420private:
421 ::mozilla::ipc::IPDLStructMember<nsCString> type_;
422 ::mozilla::ipc::IPDLStructMember<nsCString> contentType_;
423 ::mozilla::ipc::IPDLStructMember<PreferredAlternativeDataDeliveryTypeIPC> deliverAltData_;
424};
425} // namespace net
426} // namespace mozilla
427
428namespace IPC {
429template<>
430struct ParamTraits <::mozilla::net::PreferredAlternativeDataTypeParams>
431{
432 typedef ::mozilla::net::PreferredAlternativeDataTypeParams paramType;
433 static void
434 Write(
435 IPC::MessageWriter* aWriter,
436 const paramType& aVar);
437 static IPC::ReadResult<paramType>
438 Read(IPC::MessageReader* aReader);
439};
440} // namespace IPC
441
442
443//-----------------------------------------------------------------------------
444// Declaration of the IPDL type |struct RedirectHistoryEntryInfo|
445//
446namespace mozilla {
447namespace net {
448class RedirectHistoryEntryInfo final
449{
450private:
451 typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
452 typedef ::mozilla::ipc::URIParams URIParams;
453 typedef ::nsCString nsCString;
454
455public:
456#ifdef __clang__1
457# pragma clang diagnostic push
458# if __has_warning("-Wdefaulted-function-deleted")1
459# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
460# endif
461#endif
462 RedirectHistoryEntryInfo() = default;
463#ifdef __clang__1
464# pragma clang diagnostic pop
465#endif
466
467 MOZ_IMPLICIT RedirectHistoryEntryInfo(
468 const PrincipalInfo& _principalInfo,
469 const mozilla::Maybe<URIParams>& _referrerUri,
470 const nsCString& _remoteAddress) :
471 principalInfo_(_principalInfo),
472 referrerUri_(_referrerUri),
473 remoteAddress_(_remoteAddress)
474 {
475 }
476
477 MOZ_IMPLICIT RedirectHistoryEntryInfo(
478 PrincipalInfo&& _principalInfo,
479 mozilla::Maybe<URIParams>&& _referrerUri,
480 nsCString&& _remoteAddress) :
481 principalInfo_(std::move(_principalInfo)),
482 referrerUri_(std::move(_referrerUri)),
483 remoteAddress_(std::move(_remoteAddress))
484 {
485 }
486
487 PrincipalInfo&
488 principalInfo()
489 {
490 return principalInfo_;
491 }
492 const PrincipalInfo&
493 principalInfo() const
494 {
495 return principalInfo_;
496 }
497
498 mozilla::Maybe<URIParams>&
499 referrerUri()
500 {
501 return referrerUri_;
502 }
503 const mozilla::Maybe<URIParams>&
504 referrerUri() const
505 {
506 return referrerUri_;
507 }
508
509 nsCString&
510 remoteAddress()
511 {
512 return remoteAddress_;
513 }
514 const nsCString&
515 remoteAddress() const
516 {
517 return remoteAddress_;
518 }
519
520private:
521 ::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
522 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<URIParams>> referrerUri_;
523 ::mozilla::ipc::IPDLStructMember<nsCString> remoteAddress_;
524};
525} // namespace net
526} // namespace mozilla
527
528namespace IPC {
529template<>
530struct ParamTraits <::mozilla::net::RedirectHistoryEntryInfo>
531{
532 typedef ::mozilla::net::RedirectHistoryEntryInfo paramType;
533 static void
534 Write(
535 IPC::MessageWriter* aWriter,
536 const paramType& aVar);
537 static IPC::ReadResult<paramType>
538 Read(IPC::MessageReader* aReader);
539};
540} // namespace IPC
541
542
543//-----------------------------------------------------------------------------
544// Declaration of the IPDL type |struct InterceptionInfoArg|
545//
546namespace mozilla {
547namespace net {
548class InterceptionInfoArg final
549{
550private:
551 typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
552 typedef ::nsContentPolicyType nsContentPolicyType;
553 typedef ::mozilla::net::RedirectHistoryEntryInfo RedirectHistoryEntryInfo;
554
555public:
556#ifdef __clang__1
557# pragma clang diagnostic push
558# if __has_warning("-Wdefaulted-function-deleted")1
559# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
560# endif
561#endif
562 InterceptionInfoArg() = default;
563#ifdef __clang__1
564# pragma clang diagnostic pop
565#endif
566
567 MOZ_IMPLICIT InterceptionInfoArg(
568 const mozilla::Maybe<PrincipalInfo>& _triggeringPrincipalInfo,
569 const nsContentPolicyType& _contentPolicyType,
570 const nsTArray<RedirectHistoryEntryInfo>& _redirectChain,
571 const bool& _fromThirdParty) :
572 triggeringPrincipalInfo_(_triggeringPrincipalInfo),
573 contentPolicyType_(_contentPolicyType),
574 redirectChain_(_redirectChain),
575 fromThirdParty_(_fromThirdParty)
576 {
577 }
578
579 MOZ_IMPLICIT InterceptionInfoArg(
580 mozilla::Maybe<PrincipalInfo>&& _triggeringPrincipalInfo,
581 nsContentPolicyType&& _contentPolicyType,
582 nsTArray<RedirectHistoryEntryInfo>&& _redirectChain,
583 bool&& _fromThirdParty) :
584 triggeringPrincipalInfo_(std::move(_triggeringPrincipalInfo)),
585 contentPolicyType_(std::move(_contentPolicyType)),
586 redirectChain_(std::move(_redirectChain)),
587 fromThirdParty_(std::move(_fromThirdParty))
588 {
589 }
590
591 mozilla::Maybe<PrincipalInfo>&
592 triggeringPrincipalInfo()
593 {
594 return triggeringPrincipalInfo_;
595 }
596 const mozilla::Maybe<PrincipalInfo>&
597 triggeringPrincipalInfo() const
598 {
599 return triggeringPrincipalInfo_;
600 }
601
602 nsContentPolicyType&
603 contentPolicyType()
604 {
605 return contentPolicyType_;
606 }
607 const nsContentPolicyType&
608 contentPolicyType() const
609 {
610 return contentPolicyType_;
611 }
612
613 nsTArray<RedirectHistoryEntryInfo>&
614 redirectChain()
615 {
616 return redirectChain_;
617 }
618 const nsTArray<RedirectHistoryEntryInfo>&
619 redirectChain() const
620 {
621 return redirectChain_;
622 }
623
624 bool&
625 fromThirdParty()
626 {
627 return fromThirdParty_;
628 }
629 const bool&
630 fromThirdParty() const
631 {
632 return fromThirdParty_;
633 }
634
635private:
636 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> triggeringPrincipalInfo_;
637 ::mozilla::ipc::IPDLStructMember<nsContentPolicyType> contentPolicyType_;
638 ::mozilla::ipc::IPDLStructMember<CopyableTArray<RedirectHistoryEntryInfo>> redirectChain_;
639 ::mozilla::ipc::IPDLStructMember<bool> fromThirdParty_;
640};
641} // namespace net
642} // namespace mozilla
643
644namespace IPC {
645template<>
646struct ParamTraits <::mozilla::net::InterceptionInfoArg>
647{
648 typedef ::mozilla::net::InterceptionInfoArg paramType;
649 static void
650 Write(
651 IPC::MessageWriter* aWriter,
652 const paramType& aVar);
653 static IPC::ReadResult<paramType>
654 Read(IPC::MessageReader* aReader);
655};
656} // namespace IPC
657
658
659//-----------------------------------------------------------------------------
660// Declaration of the IPDL type |struct LoadInfoArgs|
661//
662namespace mozilla {
663namespace net {
664class LoadInfoArgs final
Excessive padding in 'class mozilla::net::LoadInfoArgs' (33 padding bytes, where 1 is optimal). Optimal fields order: redirectChainIncludingInternalRedirects_, redirectChain_, corsUnsafeHeaders_, unstrippedURI_, triggeringWindowId_, innerWindowID_, browsingContextID_, frameBrowsingContextID_, triggeringRemoteType_, cspNonce_, integrityMetadata_, overriddenFingerprintingSettings_, originAttributes_, cookieJarSettings_, triggeringPrincipalInfo_, resultPrincipalURI_, requestingPrincipalInfo_, principalToInheritInfo_, topLevelPrincipalInfo_, interceptionInfo_, cspToInheritInfo_, controller_, clientInfo_, reservedClientInfo_, initialClientInfo_, httpsUpgradeTelemetry_, securityFlags_, sandboxFlags_, triggeringSandboxFlags_, tainting_, httpsOnlyStatus_, requestBlockingReason_, sandboxedNullPrincipalID_, triggeringStorageAccess_, contentPolicyType_, blockAllMixedContent_, upgradeInsecureRequests_, browserUpgradeInsecureRequests_, browserDidUpgradeInsecureRequests_, browserWouldUpgradeInsecureRequests_, forceAllowDataURI_, allowInsecureRedirectToDataURI_, skipContentPolicyCheckForWebRequest_, originalFrameSrcLoad_, forceInheritPrincipalDropped_, initialSecurityCheckDone_, isInThirdPartyContext_, isFormSubmission_, sendCSPViolationEvents_, hasInjectedCookieForCookieBannerHandling_, wasSchemelessInput_, forcePreflight_, isPreflight_, loadTriggeredFromExternal_, serviceWorkerTaintingSynthesized_, documentHasUserInteracted_, allowListFutureDocumentsCreatedFromThisRedirectChain_, needForCheckingAntiTrackingHeuristic_, skipContentSniffing_, hstsStatus_, hasValidUserGestureActivation_, textDirectiveUserActivation_, allowDeprecatedSystemRequests_, isInDevToolsContext_, parserCreatedScript_, isFromProcessingFrameAttributes_, isMediaRequest_, isMediaInitialRequest_, isFromObjectOrEmbed_, storagePermission_, isMetaRefresh_, loadingEmbedderPolicy_, originTrialCoepCredentiallessEnabledForTopLevel_, isNewWindowTarget_, isThirdPartyContextToTopWindow_, consider reordering the fields or adding explicit padding members
665{
666private:
667 typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
668 typedef ::mozilla::ipc::URIParams URIParams;
669 typedef ::nsCString nsCString;
670 typedef ::nsID nsID;
671 typedef ::uint32_t uint32_t;
672 typedef ::uint64_t uint64_t;
673 typedef ::nsContentPolicyType nsContentPolicyType;
674 typedef ::mozilla::OriginAttributes OriginAttributes;
675 typedef ::mozilla::net::RedirectHistoryEntryInfo RedirectHistoryEntryInfo;
676 typedef ::nsILoadInfo::HTTPSUpgradeTelemetryType HTTPSUpgradeTelemetryType;
677 typedef ::mozilla::dom::IPCClientInfo IPCClientInfo;
678 typedef ::mozilla::dom::IPCServiceWorkerDescriptor IPCServiceWorkerDescriptor;
679 typedef ::nsString nsString;
680 typedef ::mozilla::net::CookieJarSettingsArgs CookieJarSettingsArgs;
681 typedef ::mozilla::ipc::CSPInfo CSPInfo;
682 typedef ::nsILoadInfo::StoragePermissionState StoragePermissionState;
683 typedef ::nsILoadInfo::CrossOriginEmbedderPolicy CrossOriginEmbedderPolicy;
684 typedef ::nsIURI nsIURI;
685 typedef ::mozilla::net::InterceptionInfoArg InterceptionInfoArg;
686
687public:
688#ifdef __clang__1
689# pragma clang diagnostic push
690# if __has_warning("-Wdefaulted-function-deleted")1
691# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
692# endif
693#endif
694 LoadInfoArgs() = default;
695#ifdef __clang__1
696# pragma clang diagnostic pop
697#endif
698
699 MOZ_IMPLICIT LoadInfoArgs(
700 const mozilla::Maybe<PrincipalInfo>& _requestingPrincipalInfo,
701 const PrincipalInfo& _triggeringPrincipalInfo,
702 const mozilla::Maybe<PrincipalInfo>& _principalToInheritInfo,
703 const mozilla::Maybe<PrincipalInfo>& _topLevelPrincipalInfo,
704 const mozilla::Maybe<URIParams>& _resultPrincipalURI,
705 const nsCString& _triggeringRemoteType,
706 const nsID& _sandboxedNullPrincipalID,
707 const uint32_t& _securityFlags,
708 const uint32_t& _sandboxFlags,
709 const uint32_t& _triggeringSandboxFlags,
710 const uint64_t& _triggeringWindowId,
711 const bool& _triggeringStorageAccess,
712 const nsContentPolicyType& _contentPolicyType,
713 const uint32_t& _tainting,
714 const bool& _blockAllMixedContent,
715 const bool& _upgradeInsecureRequests,
716 const bool& _browserUpgradeInsecureRequests,
717 const bool& _browserDidUpgradeInsecureRequests,
718 const bool& _browserWouldUpgradeInsecureRequests,
719 const bool& _forceAllowDataURI,
720 const bool& _allowInsecureRedirectToDataURI,
721 const bool& _skipContentPolicyCheckForWebRequest,
722 const bool& _originalFrameSrcLoad,
723 const bool& _forceInheritPrincipalDropped,
724 const uint64_t& _innerWindowID,
725 const uint64_t& _browsingContextID,
726 const uint64_t& _frameBrowsingContextID,
727 const bool& _initialSecurityCheckDone,
728 const bool& _isInThirdPartyContext,
729 const mozilla::Maybe<bool>& _isThirdPartyContextToTopWindow,
730 const bool& _isFormSubmission,
731 const bool& _sendCSPViolationEvents,
732 const OriginAttributes& _originAttributes,
733 const nsTArray<RedirectHistoryEntryInfo>& _redirectChainIncludingInternalRedirects,
734 const nsTArray<RedirectHistoryEntryInfo>& _redirectChain,
735 const bool& _hasInjectedCookieForCookieBannerHandling,
736 const bool& _wasSchemelessInput,
737 const HTTPSUpgradeTelemetryType& _httpsUpgradeTelemetry,
738 const mozilla::Maybe<IPCClientInfo>& _clientInfo,
739 const mozilla::Maybe<IPCClientInfo>& _reservedClientInfo,
740 const mozilla::Maybe<IPCClientInfo>& _initialClientInfo,
741 const mozilla::Maybe<IPCServiceWorkerDescriptor>& _controller,
742 const nsTArray<nsCString>& _corsUnsafeHeaders,
743 const bool& _forcePreflight,
744 const bool& _isPreflight,
745 const bool& _loadTriggeredFromExternal,
746 const bool& _serviceWorkerTaintingSynthesized,
747 const bool& _documentHasUserInteracted,
748 const bool& _allowListFutureDocumentsCreatedFromThisRedirectChain,
749 const bool& _needForCheckingAntiTrackingHeuristic,
750 const nsString& _cspNonce,
751 const nsString& _integrityMetadata,
752 const bool& _skipContentSniffing,
753 const uint32_t& _httpsOnlyStatus,
754 const bool& _hstsStatus,
755 const bool& _hasValidUserGestureActivation,
756 const bool& _textDirectiveUserActivation,
757 const bool& _allowDeprecatedSystemRequests,
758 const bool& _isInDevToolsContext,
759 const bool& _parserCreatedScript,
760 const bool& _isFromProcessingFrameAttributes,
761 const bool& _isMediaRequest,
762 const bool& _isMediaInitialRequest,
763 const bool& _isFromObjectOrEmbed,
764 const CookieJarSettingsArgs& _cookieJarSettings,
765 const uint32_t& _requestBlockingReason,
766 const mozilla::Maybe<CSPInfo>& _cspToInheritInfo,
767 const StoragePermissionState& _storagePermission,
768 const mozilla::Maybe<uint64_t>& _overriddenFingerprintingSettings,
769 const bool& _isMetaRefresh,
770 const CrossOriginEmbedderPolicy& _loadingEmbedderPolicy,
771 const bool& _originTrialCoepCredentiallessEnabledForTopLevel,
772 nsIURI* _unstrippedURI,
773 const mozilla::Maybe<InterceptionInfoArg>& _interceptionInfo,
774 const bool& _isNewWindowTarget) :
775 requestingPrincipalInfo_(_requestingPrincipalInfo),
776 triggeringPrincipalInfo_(_triggeringPrincipalInfo),
777 principalToInheritInfo_(_principalToInheritInfo),
778 topLevelPrincipalInfo_(_topLevelPrincipalInfo),
779 resultPrincipalURI_(_resultPrincipalURI),
780 triggeringRemoteType_(_triggeringRemoteType),
781 sandboxedNullPrincipalID_(_sandboxedNullPrincipalID),
782 triggeringStorageAccess_(_triggeringStorageAccess),
783 contentPolicyType_(_contentPolicyType),
784 blockAllMixedContent_(_blockAllMixedContent),
785 upgradeInsecureRequests_(_upgradeInsecureRequests),
786 browserUpgradeInsecureRequests_(_browserUpgradeInsecureRequests),
787 browserDidUpgradeInsecureRequests_(_browserDidUpgradeInsecureRequests),
788 browserWouldUpgradeInsecureRequests_(_browserWouldUpgradeInsecureRequests),
789 forceAllowDataURI_(_forceAllowDataURI),
790 allowInsecureRedirectToDataURI_(_allowInsecureRedirectToDataURI),
791 skipContentPolicyCheckForWebRequest_(_skipContentPolicyCheckForWebRequest),
792 originalFrameSrcLoad_(_originalFrameSrcLoad),
793 forceInheritPrincipalDropped_(_forceInheritPrincipalDropped),
794 initialSecurityCheckDone_(_initialSecurityCheckDone),
795 isInThirdPartyContext_(_isInThirdPartyContext),
796 isThirdPartyContextToTopWindow_(_isThirdPartyContextToTopWindow),
797 isFormSubmission_(_isFormSubmission),
798 sendCSPViolationEvents_(_sendCSPViolationEvents),
799 originAttributes_(_originAttributes),
800 redirectChainIncludingInternalRedirects_(_redirectChainIncludingInternalRedirects),
801 redirectChain_(_redirectChain),
802 hasInjectedCookieForCookieBannerHandling_(_hasInjectedCookieForCookieBannerHandling),
803 wasSchemelessInput_(_wasSchemelessInput),
804 httpsUpgradeTelemetry_(_httpsUpgradeTelemetry),
805 clientInfo_(_clientInfo),
806 reservedClientInfo_(_reservedClientInfo),
807 initialClientInfo_(_initialClientInfo),
808 controller_(_controller),
809 corsUnsafeHeaders_(_corsUnsafeHeaders),
810 forcePreflight_(_forcePreflight),
811 isPreflight_(_isPreflight),
812 loadTriggeredFromExternal_(_loadTriggeredFromExternal),
813 serviceWorkerTaintingSynthesized_(_serviceWorkerTaintingSynthesized),
814 documentHasUserInteracted_(_documentHasUserInteracted),
815 allowListFutureDocumentsCreatedFromThisRedirectChain_(_allowListFutureDocumentsCreatedFromThisRedirectChain),
816 needForCheckingAntiTrackingHeuristic_(_needForCheckingAntiTrackingHeuristic),
817 cspNonce_(_cspNonce),
818 integrityMetadata_(_integrityMetadata),
819 skipContentSniffing_(_skipContentSniffing),
820 hstsStatus_(_hstsStatus),
821 hasValidUserGestureActivation_(_hasValidUserGestureActivation),
822 textDirectiveUserActivation_(_textDirectiveUserActivation),
823 allowDeprecatedSystemRequests_(_allowDeprecatedSystemRequests),
824 isInDevToolsContext_(_isInDevToolsContext),
825 parserCreatedScript_(_parserCreatedScript),
826 isFromProcessingFrameAttributes_(_isFromProcessingFrameAttributes),
827 isMediaRequest_(_isMediaRequest),
828 isMediaInitialRequest_(_isMediaInitialRequest),
829 isFromObjectOrEmbed_(_isFromObjectOrEmbed),
830 cookieJarSettings_(_cookieJarSettings),
831 cspToInheritInfo_(_cspToInheritInfo),
832 storagePermission_(_storagePermission),
833 overriddenFingerprintingSettings_(_overriddenFingerprintingSettings),
834 isMetaRefresh_(_isMetaRefresh),
835 loadingEmbedderPolicy_(_loadingEmbedderPolicy),
836 originTrialCoepCredentiallessEnabledForTopLevel_(_originTrialCoepCredentiallessEnabledForTopLevel),
837 unstrippedURI_(_unstrippedURI),
838 interceptionInfo_(_interceptionInfo),
839 isNewWindowTarget_(_isNewWindowTarget),
840 triggeringWindowId_(_triggeringWindowId),
841 innerWindowID_(_innerWindowID),
842 browsingContextID_(_browsingContextID),
843 frameBrowsingContextID_(_frameBrowsingContextID),
844 securityFlags_(_securityFlags),
845 sandboxFlags_(_sandboxFlags),
846 triggeringSandboxFlags_(_triggeringSandboxFlags),
847 tainting_(_tainting),
848 httpsOnlyStatus_(_httpsOnlyStatus),
849 requestBlockingReason_(_requestBlockingReason)
850 {
851 }
852
853 MOZ_IMPLICIT LoadInfoArgs(
854 mozilla::Maybe<PrincipalInfo>&& _requestingPrincipalInfo,
855 PrincipalInfo&& _triggeringPrincipalInfo,
856 mozilla::Maybe<PrincipalInfo>&& _principalToInheritInfo,
857 mozilla::Maybe<PrincipalInfo>&& _topLevelPrincipalInfo,
858 mozilla::Maybe<URIParams>&& _resultPrincipalURI,
859 nsCString&& _triggeringRemoteType,
860 nsID&& _sandboxedNullPrincipalID,
861 uint32_t&& _securityFlags,
862 uint32_t&& _sandboxFlags,
863 uint32_t&& _triggeringSandboxFlags,
864 uint64_t&& _triggeringWindowId,
865 bool&& _triggeringStorageAccess,
866 nsContentPolicyType&& _contentPolicyType,
867 uint32_t&& _tainting,
868 bool&& _blockAllMixedContent,
869 bool&& _upgradeInsecureRequests,
870 bool&& _browserUpgradeInsecureRequests,
871 bool&& _browserDidUpgradeInsecureRequests,
872 bool&& _browserWouldUpgradeInsecureRequests,
873 bool&& _forceAllowDataURI,
874 bool&& _allowInsecureRedirectToDataURI,
875 bool&& _skipContentPolicyCheckForWebRequest,
876 bool&& _originalFrameSrcLoad,
877 bool&& _forceInheritPrincipalDropped,
878 uint64_t&& _innerWindowID,
879 uint64_t&& _browsingContextID,
880 uint64_t&& _frameBrowsingContextID,
881 bool&& _initialSecurityCheckDone,
882 bool&& _isInThirdPartyContext,
883 mozilla::Maybe<bool>&& _isThirdPartyContextToTopWindow,
884 bool&& _isFormSubmission,
885 bool&& _sendCSPViolationEvents,
886 OriginAttributes&& _originAttributes,
887 nsTArray<RedirectHistoryEntryInfo>&& _redirectChainIncludingInternalRedirects,
888 nsTArray<RedirectHistoryEntryInfo>&& _redirectChain,
889 bool&& _hasInjectedCookieForCookieBannerHandling,
890 bool&& _wasSchemelessInput,
891 HTTPSUpgradeTelemetryType&& _httpsUpgradeTelemetry,
892 mozilla::Maybe<IPCClientInfo>&& _clientInfo,
893 mozilla::Maybe<IPCClientInfo>&& _reservedClientInfo,
894 mozilla::Maybe<IPCClientInfo>&& _initialClientInfo,
895 mozilla::Maybe<IPCServiceWorkerDescriptor>&& _controller,
896 nsTArray<nsCString>&& _corsUnsafeHeaders,
897 bool&& _forcePreflight,
898 bool&& _isPreflight,
899 bool&& _loadTriggeredFromExternal,
900 bool&& _serviceWorkerTaintingSynthesized,
901 bool&& _documentHasUserInteracted,
902 bool&& _allowListFutureDocumentsCreatedFromThisRedirectChain,
903 bool&& _needForCheckingAntiTrackingHeuristic,
904 nsString&& _cspNonce,
905 nsString&& _integrityMetadata,
906 bool&& _skipContentSniffing,
907 uint32_t&& _httpsOnlyStatus,
908 bool&& _hstsStatus,
909 bool&& _hasValidUserGestureActivation,
910 bool&& _textDirectiveUserActivation,
911 bool&& _allowDeprecatedSystemRequests,
912 bool&& _isInDevToolsContext,
913 bool&& _parserCreatedScript,
914 bool&& _isFromProcessingFrameAttributes,
915 bool&& _isMediaRequest,
916 bool&& _isMediaInitialRequest,
917 bool&& _isFromObjectOrEmbed,
918 CookieJarSettingsArgs&& _cookieJarSettings,
919 uint32_t&& _requestBlockingReason,
920 mozilla::Maybe<CSPInfo>&& _cspToInheritInfo,
921 StoragePermissionState&& _storagePermission,
922 mozilla::Maybe<uint64_t>&& _overriddenFingerprintingSettings,
923 bool&& _isMetaRefresh,
924 CrossOriginEmbedderPolicy&& _loadingEmbedderPolicy,
925 bool&& _originTrialCoepCredentiallessEnabledForTopLevel,
926 RefPtr<nsIURI>&& _unstrippedURI,
927 mozilla::Maybe<InterceptionInfoArg>&& _interceptionInfo,
928 bool&& _isNewWindowTarget) :
929 requestingPrincipalInfo_(std::move(_requestingPrincipalInfo)),
930 triggeringPrincipalInfo_(std::move(_triggeringPrincipalInfo)),
931 principalToInheritInfo_(std::move(_principalToInheritInfo)),
932 topLevelPrincipalInfo_(std::move(_topLevelPrincipalInfo)),
933 resultPrincipalURI_(std::move(_resultPrincipalURI)),
934 triggeringRemoteType_(std::move(_triggeringRemoteType)),
935 sandboxedNullPrincipalID_(std::move(_sandboxedNullPrincipalID)),
936 triggeringStorageAccess_(std::move(_triggeringStorageAccess)),
937 contentPolicyType_(std::move(_contentPolicyType)),
938 blockAllMixedContent_(std::move(_blockAllMixedContent)),
939 upgradeInsecureRequests_(std::move(_upgradeInsecureRequests)),
940 browserUpgradeInsecureRequests_(std::move(_browserUpgradeInsecureRequests)),
941 browserDidUpgradeInsecureRequests_(std::move(_browserDidUpgradeInsecureRequests)),
942 browserWouldUpgradeInsecureRequests_(std::move(_browserWouldUpgradeInsecureRequests)),
943 forceAllowDataURI_(std::move(_forceAllowDataURI)),
944 allowInsecureRedirectToDataURI_(std::move(_allowInsecureRedirectToDataURI)),
945 skipContentPolicyCheckForWebRequest_(std::move(_skipContentPolicyCheckForWebRequest)),
946 originalFrameSrcLoad_(std::move(_originalFrameSrcLoad)),
947 forceInheritPrincipalDropped_(std::move(_forceInheritPrincipalDropped)),
948 initialSecurityCheckDone_(std::move(_initialSecurityCheckDone)),
949 isInThirdPartyContext_(std::move(_isInThirdPartyContext)),
950 isThirdPartyContextToTopWindow_(std::move(_isThirdPartyContextToTopWindow)),
951 isFormSubmission_(std::move(_isFormSubmission)),
952 sendCSPViolationEvents_(std::move(_sendCSPViolationEvents)),
953 originAttributes_(std::move(_originAttributes)),
954 redirectChainIncludingInternalRedirects_(std::move(_redirectChainIncludingInternalRedirects)),
955 redirectChain_(std::move(_redirectChain)),
956 hasInjectedCookieForCookieBannerHandling_(std::move(_hasInjectedCookieForCookieBannerHandling)),
957 wasSchemelessInput_(std::move(_wasSchemelessInput)),
958 httpsUpgradeTelemetry_(std::move(_httpsUpgradeTelemetry)),
959 clientInfo_(std::move(_clientInfo)),
960 reservedClientInfo_(std::move(_reservedClientInfo)),
961 initialClientInfo_(std::move(_initialClientInfo)),
962 controller_(std::move(_controller)),
963 corsUnsafeHeaders_(std::move(_corsUnsafeHeaders)),
964 forcePreflight_(std::move(_forcePreflight)),
965 isPreflight_(std::move(_isPreflight)),
966 loadTriggeredFromExternal_(std::move(_loadTriggeredFromExternal)),
967 serviceWorkerTaintingSynthesized_(std::move(_serviceWorkerTaintingSynthesized)),
968 documentHasUserInteracted_(std::move(_documentHasUserInteracted)),
969 allowListFutureDocumentsCreatedFromThisRedirectChain_(std::move(_allowListFutureDocumentsCreatedFromThisRedirectChain)),
970 needForCheckingAntiTrackingHeuristic_(std::move(_needForCheckingAntiTrackingHeuristic)),
971 cspNonce_(std::move(_cspNonce)),
972 integrityMetadata_(std::move(_integrityMetadata)),
973 skipContentSniffing_(std::move(_skipContentSniffing)),
974 hstsStatus_(std::move(_hstsStatus)),
975 hasValidUserGestureActivation_(std::move(_hasValidUserGestureActivation)),
976 textDirectiveUserActivation_(std::move(_textDirectiveUserActivation)),
977 allowDeprecatedSystemRequests_(std::move(_allowDeprecatedSystemRequests)),
978 isInDevToolsContext_(std::move(_isInDevToolsContext)),
979 parserCreatedScript_(std::move(_parserCreatedScript)),
980 isFromProcessingFrameAttributes_(std::move(_isFromProcessingFrameAttributes)),
981 isMediaRequest_(std::move(_isMediaRequest)),
982 isMediaInitialRequest_(std::move(_isMediaInitialRequest)),
983 isFromObjectOrEmbed_(std::move(_isFromObjectOrEmbed)),
984 cookieJarSettings_(std::move(_cookieJarSettings)),
985 cspToInheritInfo_(std::move(_cspToInheritInfo)),
986 storagePermission_(std::move(_storagePermission)),
987 overriddenFingerprintingSettings_(std::move(_overriddenFingerprintingSettings)),
988 isMetaRefresh_(std::move(_isMetaRefresh)),
989 loadingEmbedderPolicy_(std::move(_loadingEmbedderPolicy)),
990 originTrialCoepCredentiallessEnabledForTopLevel_(std::move(_originTrialCoepCredentiallessEnabledForTopLevel)),
991 unstrippedURI_(std::move(_unstrippedURI)),
992 interceptionInfo_(std::move(_interceptionInfo)),
993 isNewWindowTarget_(std::move(_isNewWindowTarget)),
994 triggeringWindowId_(std::move(_triggeringWindowId)),
995 innerWindowID_(std::move(_innerWindowID)),
996 browsingContextID_(std::move(_browsingContextID)),
997 frameBrowsingContextID_(std::move(_frameBrowsingContextID)),
998 securityFlags_(std::move(_securityFlags)),
999 sandboxFlags_(std::move(_sandboxFlags)),
1000 triggeringSandboxFlags_(std::move(_triggeringSandboxFlags)),
1001 tainting_(std::move(_tainting)),
1002 httpsOnlyStatus_(std::move(_httpsOnlyStatus)),
1003 requestBlockingReason_(std::move(_requestBlockingReason))
1004 {
1005 }
1006
1007 mozilla::Maybe<PrincipalInfo>&
1008 requestingPrincipalInfo()
1009 {
1010 return requestingPrincipalInfo_;
1011 }
1012 const mozilla::Maybe<PrincipalInfo>&
1013 requestingPrincipalInfo() const
1014 {
1015 return requestingPrincipalInfo_;
1016 }
1017
1018 PrincipalInfo&
1019 triggeringPrincipalInfo()
1020 {
1021 return triggeringPrincipalInfo_;
1022 }
1023 const PrincipalInfo&
1024 triggeringPrincipalInfo() const
1025 {
1026 return triggeringPrincipalInfo_;
1027 }
1028
1029 mozilla::Maybe<PrincipalInfo>&
1030 principalToInheritInfo()
1031 {
1032 return principalToInheritInfo_;
1033 }
1034 const mozilla::Maybe<PrincipalInfo>&
1035 principalToInheritInfo() const
1036 {
1037 return principalToInheritInfo_;
1038 }
1039
1040 mozilla::Maybe<PrincipalInfo>&
1041 topLevelPrincipalInfo()
1042 {
1043 return topLevelPrincipalInfo_;
1044 }
1045 const mozilla::Maybe<PrincipalInfo>&
1046 topLevelPrincipalInfo() const
1047 {
1048 return topLevelPrincipalInfo_;
1049 }
1050
1051 mozilla::Maybe<URIParams>&
1052 resultPrincipalURI()
1053 {
1054 return resultPrincipalURI_;
1055 }
1056 const mozilla::Maybe<URIParams>&
1057 resultPrincipalURI() const
1058 {
1059 return resultPrincipalURI_;
1060 }
1061
1062 nsCString&
1063 triggeringRemoteType()
1064 {
1065 return triggeringRemoteType_;
1066 }
1067 const nsCString&
1068 triggeringRemoteType() const
1069 {
1070 return triggeringRemoteType_;
1071 }
1072
1073 nsID&
1074 sandboxedNullPrincipalID()
1075 {
1076 return sandboxedNullPrincipalID_;
1077 }
1078 const nsID&
1079 sandboxedNullPrincipalID() const
1080 {
1081 return sandboxedNullPrincipalID_;
1082 }
1083
1084 uint32_t&
1085 securityFlags()
1086 {
1087 return securityFlags_;
1088 }
1089 const uint32_t&
1090 securityFlags() const
1091 {
1092 return securityFlags_;
1093 }
1094
1095 uint32_t&
1096 sandboxFlags()
1097 {
1098 return sandboxFlags_;
1099 }
1100 const uint32_t&
1101 sandboxFlags() const
1102 {
1103 return sandboxFlags_;
1104 }
1105
1106 uint32_t&
1107 triggeringSandboxFlags()
1108 {
1109 return triggeringSandboxFlags_;
1110 }
1111 const uint32_t&
1112 triggeringSandboxFlags() const
1113 {
1114 return triggeringSandboxFlags_;
1115 }
1116
1117 uint64_t&
1118 triggeringWindowId()
1119 {
1120 return triggeringWindowId_;
1121 }
1122 const uint64_t&
1123 triggeringWindowId() const
1124 {
1125 return triggeringWindowId_;
1126 }
1127
1128 bool&
1129 triggeringStorageAccess()
1130 {
1131 return triggeringStorageAccess_;
1132 }
1133 const bool&
1134 triggeringStorageAccess() const
1135 {
1136 return triggeringStorageAccess_;
1137 }
1138
1139 nsContentPolicyType&
1140 contentPolicyType()
1141 {
1142 return contentPolicyType_;
1143 }
1144 const nsContentPolicyType&
1145 contentPolicyType() const
1146 {
1147 return contentPolicyType_;
1148 }
1149
1150 uint32_t&
1151 tainting()
1152 {
1153 return tainting_;
1154 }
1155 const uint32_t&
1156 tainting() const
1157 {
1158 return tainting_;
1159 }
1160
1161 bool&
1162 blockAllMixedContent()
1163 {
1164 return blockAllMixedContent_;
1165 }
1166 const bool&
1167 blockAllMixedContent() const
1168 {
1169 return blockAllMixedContent_;
1170 }
1171
1172 bool&
1173 upgradeInsecureRequests()
1174 {
1175 return upgradeInsecureRequests_;
1176 }
1177 const bool&
1178 upgradeInsecureRequests() const
1179 {
1180 return upgradeInsecureRequests_;
1181 }
1182
1183 bool&
1184 browserUpgradeInsecureRequests()
1185 {
1186 return browserUpgradeInsecureRequests_;
1187 }
1188 const bool&
1189 browserUpgradeInsecureRequests() const
1190 {
1191 return browserUpgradeInsecureRequests_;
1192 }
1193
1194 bool&
1195 browserDidUpgradeInsecureRequests()
1196 {
1197 return browserDidUpgradeInsecureRequests_;
1198 }
1199 const bool&
1200 browserDidUpgradeInsecureRequests() const
1201 {
1202 return browserDidUpgradeInsecureRequests_;
1203 }
1204
1205 bool&
1206 browserWouldUpgradeInsecureRequests()
1207 {
1208 return browserWouldUpgradeInsecureRequests_;
1209 }
1210 const bool&
1211 browserWouldUpgradeInsecureRequests() const
1212 {
1213 return browserWouldUpgradeInsecureRequests_;
1214 }
1215
1216 bool&
1217 forceAllowDataURI()
1218 {
1219 return forceAllowDataURI_;
1220 }
1221 const bool&
1222 forceAllowDataURI() const
1223 {
1224 return forceAllowDataURI_;
1225 }
1226
1227 bool&
1228 allowInsecureRedirectToDataURI()
1229 {
1230 return allowInsecureRedirectToDataURI_;
1231 }
1232 const bool&
1233 allowInsecureRedirectToDataURI() const
1234 {
1235 return allowInsecureRedirectToDataURI_;
1236 }
1237
1238 bool&
1239 skipContentPolicyCheckForWebRequest()
1240 {
1241 return skipContentPolicyCheckForWebRequest_;
1242 }
1243 const bool&
1244 skipContentPolicyCheckForWebRequest() const
1245 {
1246 return skipContentPolicyCheckForWebRequest_;
1247 }
1248
1249 bool&
1250 originalFrameSrcLoad()
1251 {
1252 return originalFrameSrcLoad_;
1253 }
1254 const bool&
1255 originalFrameSrcLoad() const
1256 {
1257 return originalFrameSrcLoad_;
1258 }
1259
1260 bool&
1261 forceInheritPrincipalDropped()
1262 {
1263 return forceInheritPrincipalDropped_;
1264 }
1265 const bool&
1266 forceInheritPrincipalDropped() const
1267 {
1268 return forceInheritPrincipalDropped_;
1269 }
1270
1271 uint64_t&
1272 innerWindowID()
1273 {
1274 return innerWindowID_;
1275 }
1276 const uint64_t&
1277 innerWindowID() const
1278 {
1279 return innerWindowID_;
1280 }
1281
1282 uint64_t&
1283 browsingContextID()
1284 {
1285 return browsingContextID_;
1286 }
1287 const uint64_t&
1288 browsingContextID() const
1289 {
1290 return browsingContextID_;
1291 }
1292
1293 uint64_t&
1294 frameBrowsingContextID()
1295 {
1296 return frameBrowsingContextID_;
1297 }
1298 const uint64_t&
1299 frameBrowsingContextID() const
1300 {
1301 return frameBrowsingContextID_;
1302 }
1303
1304 bool&
1305 initialSecurityCheckDone()
1306 {
1307 return initialSecurityCheckDone_;
1308 }
1309 const bool&
1310 initialSecurityCheckDone() const
1311 {
1312 return initialSecurityCheckDone_;
1313 }
1314
1315 bool&
1316 isInThirdPartyContext()
1317 {
1318 return isInThirdPartyContext_;
1319 }
1320 const bool&
1321 isInThirdPartyContext() const
1322 {
1323 return isInThirdPartyContext_;
1324 }
1325
1326 mozilla::Maybe<bool>&
1327 isThirdPartyContextToTopWindow()
1328 {
1329 return isThirdPartyContextToTopWindow_;
1330 }
1331 const mozilla::Maybe<bool>&
1332 isThirdPartyContextToTopWindow() const
1333 {
1334 return isThirdPartyContextToTopWindow_;
1335 }
1336
1337 bool&
1338 isFormSubmission()
1339 {
1340 return isFormSubmission_;
1341 }
1342 const bool&
1343 isFormSubmission() const
1344 {
1345 return isFormSubmission_;
1346 }
1347
1348 bool&
1349 sendCSPViolationEvents()
1350 {
1351 return sendCSPViolationEvents_;
1352 }
1353 const bool&
1354 sendCSPViolationEvents() const
1355 {
1356 return sendCSPViolationEvents_;
1357 }
1358
1359 OriginAttributes&
1360 originAttributes()
1361 {
1362 return originAttributes_;
1363 }
1364 const OriginAttributes&
1365 originAttributes() const
1366 {
1367 return originAttributes_;
1368 }
1369
1370 nsTArray<RedirectHistoryEntryInfo>&
1371 redirectChainIncludingInternalRedirects()
1372 {
1373 return redirectChainIncludingInternalRedirects_;
1374 }
1375 const nsTArray<RedirectHistoryEntryInfo>&
1376 redirectChainIncludingInternalRedirects() const
1377 {
1378 return redirectChainIncludingInternalRedirects_;
1379 }
1380
1381 nsTArray<RedirectHistoryEntryInfo>&
1382 redirectChain()
1383 {
1384 return redirectChain_;
1385 }
1386 const nsTArray<RedirectHistoryEntryInfo>&
1387 redirectChain() const
1388 {
1389 return redirectChain_;
1390 }
1391
1392 bool&
1393 hasInjectedCookieForCookieBannerHandling()
1394 {
1395 return hasInjectedCookieForCookieBannerHandling_;
1396 }
1397 const bool&
1398 hasInjectedCookieForCookieBannerHandling() const
1399 {
1400 return hasInjectedCookieForCookieBannerHandling_;
1401 }
1402
1403 bool&
1404 wasSchemelessInput()
1405 {
1406 return wasSchemelessInput_;
1407 }
1408 const bool&
1409 wasSchemelessInput() const
1410 {
1411 return wasSchemelessInput_;
1412 }
1413
1414 HTTPSUpgradeTelemetryType&
1415 httpsUpgradeTelemetry()
1416 {
1417 return httpsUpgradeTelemetry_;
1418 }
1419 const HTTPSUpgradeTelemetryType&
1420 httpsUpgradeTelemetry() const
1421 {
1422 return httpsUpgradeTelemetry_;
1423 }
1424
1425 mozilla::Maybe<IPCClientInfo>&
1426 clientInfo()
1427 {
1428 return clientInfo_;
1429 }
1430 const mozilla::Maybe<IPCClientInfo>&
1431 clientInfo() const
1432 {
1433 return clientInfo_;
1434 }
1435
1436 mozilla::Maybe<IPCClientInfo>&
1437 reservedClientInfo()
1438 {
1439 return reservedClientInfo_;
1440 }
1441 const mozilla::Maybe<IPCClientInfo>&
1442 reservedClientInfo() const
1443 {
1444 return reservedClientInfo_;
1445 }
1446
1447 mozilla::Maybe<IPCClientInfo>&
1448 initialClientInfo()
1449 {
1450 return initialClientInfo_;
1451 }
1452 const mozilla::Maybe<IPCClientInfo>&
1453 initialClientInfo() const
1454 {
1455 return initialClientInfo_;
1456 }
1457
1458 mozilla::Maybe<IPCServiceWorkerDescriptor>&
1459 controller()
1460 {
1461 return controller_;
1462 }
1463 const mozilla::Maybe<IPCServiceWorkerDescriptor>&
1464 controller() const
1465 {
1466 return controller_;
1467 }
1468
1469 nsTArray<nsCString>&
1470 corsUnsafeHeaders()
1471 {
1472 return corsUnsafeHeaders_;
1473 }
1474 const nsTArray<nsCString>&
1475 corsUnsafeHeaders() const
1476 {
1477 return corsUnsafeHeaders_;
1478 }
1479
1480 bool&
1481 forcePreflight()
1482 {
1483 return forcePreflight_;
1484 }
1485 const bool&
1486 forcePreflight() const
1487 {
1488 return forcePreflight_;
1489 }
1490
1491 bool&
1492 isPreflight()
1493 {
1494 return isPreflight_;
1495 }
1496 const bool&
1497 isPreflight() const
1498 {
1499 return isPreflight_;
1500 }
1501
1502 bool&
1503 loadTriggeredFromExternal()
1504 {
1505 return loadTriggeredFromExternal_;
1506 }
1507 const bool&
1508 loadTriggeredFromExternal() const
1509 {
1510 return loadTriggeredFromExternal_;
1511 }
1512
1513 bool&
1514 serviceWorkerTaintingSynthesized()
1515 {
1516 return serviceWorkerTaintingSynthesized_;
1517 }
1518 const bool&
1519 serviceWorkerTaintingSynthesized() const
1520 {
1521 return serviceWorkerTaintingSynthesized_;
1522 }
1523
1524 bool&
1525 documentHasUserInteracted()
1526 {
1527 return documentHasUserInteracted_;
1528 }
1529 const bool&
1530 documentHasUserInteracted() const
1531 {
1532 return documentHasUserInteracted_;
1533 }
1534
1535 bool&
1536 allowListFutureDocumentsCreatedFromThisRedirectChain()
1537 {
1538 return allowListFutureDocumentsCreatedFromThisRedirectChain_;
1539 }
1540 const bool&
1541 allowListFutureDocumentsCreatedFromThisRedirectChain() const
1542 {
1543 return allowListFutureDocumentsCreatedFromThisRedirectChain_;
1544 }
1545
1546 bool&
1547 needForCheckingAntiTrackingHeuristic()
1548 {
1549 return needForCheckingAntiTrackingHeuristic_;
1550 }
1551 const bool&
1552 needForCheckingAntiTrackingHeuristic() const
1553 {
1554 return needForCheckingAntiTrackingHeuristic_;
1555 }
1556
1557 nsString&
1558 cspNonce()
1559 {
1560 return cspNonce_;
1561 }
1562 const nsString&
1563 cspNonce() const
1564 {
1565 return cspNonce_;
1566 }
1567
1568 nsString&
1569 integrityMetadata()
1570 {
1571 return integrityMetadata_;
1572 }
1573 const nsString&
1574 integrityMetadata() const
1575 {
1576 return integrityMetadata_;
1577 }
1578
1579 bool&
1580 skipContentSniffing()
1581 {
1582 return skipContentSniffing_;
1583 }
1584 const bool&
1585 skipContentSniffing() const
1586 {
1587 return skipContentSniffing_;
1588 }
1589
1590 uint32_t&
1591 httpsOnlyStatus()
1592 {
1593 return httpsOnlyStatus_;
1594 }
1595 const uint32_t&
1596 httpsOnlyStatus() const
1597 {
1598 return httpsOnlyStatus_;
1599 }
1600
1601 bool&
1602 hstsStatus()
1603 {
1604 return hstsStatus_;
1605 }
1606 const bool&
1607 hstsStatus() const
1608 {
1609 return hstsStatus_;
1610 }
1611
1612 bool&
1613 hasValidUserGestureActivation()
1614 {
1615 return hasValidUserGestureActivation_;
1616 }
1617 const bool&
1618 hasValidUserGestureActivation() const
1619 {
1620 return hasValidUserGestureActivation_;
1621 }
1622
1623 bool&
1624 textDirectiveUserActivation()
1625 {
1626 return textDirectiveUserActivation_;
1627 }
1628 const bool&
1629 textDirectiveUserActivation() const
1630 {
1631 return textDirectiveUserActivation_;
1632 }
1633
1634 bool&
1635 allowDeprecatedSystemRequests()
1636 {
1637 return allowDeprecatedSystemRequests_;
1638 }
1639 const bool&
1640 allowDeprecatedSystemRequests() const
1641 {
1642 return allowDeprecatedSystemRequests_;
1643 }
1644
1645 bool&
1646 isInDevToolsContext()
1647 {
1648 return isInDevToolsContext_;
1649 }
1650 const bool&
1651 isInDevToolsContext() const
1652 {
1653 return isInDevToolsContext_;
1654 }
1655
1656 bool&
1657 parserCreatedScript()
1658 {
1659 return parserCreatedScript_;
1660 }
1661 const bool&
1662 parserCreatedScript() const
1663 {
1664 return parserCreatedScript_;
1665 }
1666
1667 bool&
1668 isFromProcessingFrameAttributes()
1669 {
1670 return isFromProcessingFrameAttributes_;
1671 }
1672 const bool&
1673 isFromProcessingFrameAttributes() const
1674 {
1675 return isFromProcessingFrameAttributes_;
1676 }
1677
1678 bool&
1679 isMediaRequest()
1680 {
1681 return isMediaRequest_;
1682 }
1683 const bool&
1684 isMediaRequest() const
1685 {
1686 return isMediaRequest_;
1687 }
1688
1689 bool&
1690 isMediaInitialRequest()
1691 {
1692 return isMediaInitialRequest_;
1693 }
1694 const bool&
1695 isMediaInitialRequest() const
1696 {
1697 return isMediaInitialRequest_;
1698 }
1699
1700 bool&
1701 isFromObjectOrEmbed()
1702 {
1703 return isFromObjectOrEmbed_;
1704 }
1705 const bool&
1706 isFromObjectOrEmbed() const
1707 {
1708 return isFromObjectOrEmbed_;
1709 }
1710
1711 CookieJarSettingsArgs&
1712 cookieJarSettings()
1713 {
1714 return cookieJarSettings_;
1715 }
1716 const CookieJarSettingsArgs&
1717 cookieJarSettings() const
1718 {
1719 return cookieJarSettings_;
1720 }
1721
1722 uint32_t&
1723 requestBlockingReason()
1724 {
1725 return requestBlockingReason_;
1726 }
1727 const uint32_t&
1728 requestBlockingReason() const
1729 {
1730 return requestBlockingReason_;
1731 }
1732
1733 mozilla::Maybe<CSPInfo>&
1734 cspToInheritInfo()
1735 {
1736 return cspToInheritInfo_;
1737 }
1738 const mozilla::Maybe<CSPInfo>&
1739 cspToInheritInfo() const
1740 {
1741 return cspToInheritInfo_;
1742 }
1743
1744 StoragePermissionState&
1745 storagePermission()
1746 {
1747 return storagePermission_;
1748 }
1749 const StoragePermissionState&
1750 storagePermission() const
1751 {
1752 return storagePermission_;
1753 }
1754
1755 mozilla::Maybe<uint64_t>&
1756 overriddenFingerprintingSettings()
1757 {
1758 return overriddenFingerprintingSettings_;
1759 }
1760 const mozilla::Maybe<uint64_t>&
1761 overriddenFingerprintingSettings() const
1762 {
1763 return overriddenFingerprintingSettings_;
1764 }
1765
1766 bool&
1767 isMetaRefresh()
1768 {
1769 return isMetaRefresh_;
1770 }
1771 const bool&
1772 isMetaRefresh() const
1773 {
1774 return isMetaRefresh_;
1775 }
1776
1777 CrossOriginEmbedderPolicy&
1778 loadingEmbedderPolicy()
1779 {
1780 return loadingEmbedderPolicy_;
1781 }
1782 const CrossOriginEmbedderPolicy&
1783 loadingEmbedderPolicy() const
1784 {
1785 return loadingEmbedderPolicy_;
1786 }
1787
1788 bool&
1789 originTrialCoepCredentiallessEnabledForTopLevel()
1790 {
1791 return originTrialCoepCredentiallessEnabledForTopLevel_;
1792 }
1793 const bool&
1794 originTrialCoepCredentiallessEnabledForTopLevel() const
1795 {
1796 return originTrialCoepCredentiallessEnabledForTopLevel_;
1797 }
1798
1799 RefPtr<nsIURI>&
1800 unstrippedURI()
1801 {
1802 return unstrippedURI_;
1803 }
1804 nsIURI*
1805 unstrippedURI() const
1806 {
1807 return unstrippedURI_;
1808 }
1809
1810 mozilla::Maybe<InterceptionInfoArg>&
1811 interceptionInfo()
1812 {
1813 return interceptionInfo_;
1814 }
1815 const mozilla::Maybe<InterceptionInfoArg>&
1816 interceptionInfo() const
1817 {
1818 return interceptionInfo_;
1819 }
1820
1821 bool&
1822 isNewWindowTarget()
1823 {
1824 return isNewWindowTarget_;
1825 }
1826 const bool&
1827 isNewWindowTarget() const
1828 {
1829 return isNewWindowTarget_;
1830 }
1831
1832private:
1833 void
1834 StaticAssertions() const;
1835 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> requestingPrincipalInfo_;
1836 ::mozilla::ipc::IPDLStructMember<PrincipalInfo> triggeringPrincipalInfo_;
1837 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> principalToInheritInfo_;
1838 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> topLevelPrincipalInfo_;
1839 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<URIParams>> resultPrincipalURI_;
1840 ::mozilla::ipc::IPDLStructMember<nsCString> triggeringRemoteType_;
1841 ::mozilla::ipc::IPDLStructMember<nsID> sandboxedNullPrincipalID_;
1842 ::mozilla::ipc::IPDLStructMember<bool> triggeringStorageAccess_;
1843 ::mozilla::ipc::IPDLStructMember<nsContentPolicyType> contentPolicyType_;
1844 ::mozilla::ipc::IPDLStructMember<bool> blockAllMixedContent_;
1845 ::mozilla::ipc::IPDLStructMember<bool> upgradeInsecureRequests_;
1846 ::mozilla::ipc::IPDLStructMember<bool> browserUpgradeInsecureRequests_;
1847 ::mozilla::ipc::IPDLStructMember<bool> browserDidUpgradeInsecureRequests_;
1848 ::mozilla::ipc::IPDLStructMember<bool> browserWouldUpgradeInsecureRequests_;
1849 ::mozilla::ipc::IPDLStructMember<bool> forceAllowDataURI_;
1850 ::mozilla::ipc::IPDLStructMember<bool> allowInsecureRedirectToDataURI_;
1851 ::mozilla::ipc::IPDLStructMember<bool> skipContentPolicyCheckForWebRequest_;
1852 ::mozilla::ipc::IPDLStructMember<bool> originalFrameSrcLoad_;
1853 ::mozilla::ipc::IPDLStructMember<bool> forceInheritPrincipalDropped_;
1854 ::mozilla::ipc::IPDLStructMember<bool> initialSecurityCheckDone_;
1855 ::mozilla::ipc::IPDLStructMember<bool> isInThirdPartyContext_;
1856 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<bool>> isThirdPartyContextToTopWindow_;
1857 ::mozilla::ipc::IPDLStructMember<bool> isFormSubmission_;
1858 ::mozilla::ipc::IPDLStructMember<bool> sendCSPViolationEvents_;
1859 ::mozilla::ipc::IPDLStructMember<OriginAttributes> originAttributes_;
1860 ::mozilla::ipc::IPDLStructMember<CopyableTArray<RedirectHistoryEntryInfo>> redirectChainIncludingInternalRedirects_;
1861 ::mozilla::ipc::IPDLStructMember<CopyableTArray<RedirectHistoryEntryInfo>> redirectChain_;
1862 ::mozilla::ipc::IPDLStructMember<bool> hasInjectedCookieForCookieBannerHandling_;
1863 ::mozilla::ipc::IPDLStructMember<bool> wasSchemelessInput_;
1864 ::mozilla::ipc::IPDLStructMember<HTTPSUpgradeTelemetryType> httpsUpgradeTelemetry_;
1865 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> clientInfo_;
1866 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> reservedClientInfo_;
1867 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> initialClientInfo_;
1868 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCServiceWorkerDescriptor>> controller_;
1869 ::mozilla::ipc::IPDLStructMember<CopyableTArray<nsCString>> corsUnsafeHeaders_;
1870 ::mozilla::ipc::IPDLStructMember<bool> forcePreflight_;
1871 ::mozilla::ipc::IPDLStructMember<bool> isPreflight_;
1872 ::mozilla::ipc::IPDLStructMember<bool> loadTriggeredFromExternal_;
1873 ::mozilla::ipc::IPDLStructMember<bool> serviceWorkerTaintingSynthesized_;
1874 ::mozilla::ipc::IPDLStructMember<bool> documentHasUserInteracted_;
1875 ::mozilla::ipc::IPDLStructMember<bool> allowListFutureDocumentsCreatedFromThisRedirectChain_;
1876 ::mozilla::ipc::IPDLStructMember<bool> needForCheckingAntiTrackingHeuristic_;
1877 ::mozilla::ipc::IPDLStructMember<nsString> cspNonce_;
1878 ::mozilla::ipc::IPDLStructMember<nsString> integrityMetadata_;
1879 ::mozilla::ipc::IPDLStructMember<bool> skipContentSniffing_;
1880 ::mozilla::ipc::IPDLStructMember<bool> hstsStatus_;
1881 ::mozilla::ipc::IPDLStructMember<bool> hasValidUserGestureActivation_;
1882 ::mozilla::ipc::IPDLStructMember<bool> textDirectiveUserActivation_;
1883 ::mozilla::ipc::IPDLStructMember<bool> allowDeprecatedSystemRequests_;
1884 ::mozilla::ipc::IPDLStructMember<bool> isInDevToolsContext_;
1885 ::mozilla::ipc::IPDLStructMember<bool> parserCreatedScript_;
1886 ::mozilla::ipc::IPDLStructMember<bool> isFromProcessingFrameAttributes_;
1887 ::mozilla::ipc::IPDLStructMember<bool> isMediaRequest_;
1888 ::mozilla::ipc::IPDLStructMember<bool> isMediaInitialRequest_;
1889 ::mozilla::ipc::IPDLStructMember<bool> isFromObjectOrEmbed_;
1890 ::mozilla::ipc::IPDLStructMember<CookieJarSettingsArgs> cookieJarSettings_;
1891 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<CSPInfo>> cspToInheritInfo_;
1892 ::mozilla::ipc::IPDLStructMember<StoragePermissionState> storagePermission_;
1893 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<uint64_t>> overriddenFingerprintingSettings_;
1894 ::mozilla::ipc::IPDLStructMember<bool> isMetaRefresh_;
1895 ::mozilla::ipc::IPDLStructMember<CrossOriginEmbedderPolicy> loadingEmbedderPolicy_;
1896 ::mozilla::ipc::IPDLStructMember<bool> originTrialCoepCredentiallessEnabledForTopLevel_;
1897 ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> unstrippedURI_;
1898 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<InterceptionInfoArg>> interceptionInfo_;
1899 ::mozilla::ipc::IPDLStructMember<bool> isNewWindowTarget_;
1900 ::mozilla::ipc::IPDLStructMember<uint64_t> triggeringWindowId_;
1901 ::mozilla::ipc::IPDLStructMember<uint64_t> innerWindowID_;
1902 ::mozilla::ipc::IPDLStructMember<uint64_t> browsingContextID_;
1903 ::mozilla::ipc::IPDLStructMember<uint64_t> frameBrowsingContextID_;
1904 ::mozilla::ipc::IPDLStructMember<uint32_t> securityFlags_;
1905 ::mozilla::ipc::IPDLStructMember<uint32_t> sandboxFlags_;
1906 ::mozilla::ipc::IPDLStructMember<uint32_t> triggeringSandboxFlags_;
1907 ::mozilla::ipc::IPDLStructMember<uint32_t> tainting_;
1908 ::mozilla::ipc::IPDLStructMember<uint32_t> httpsOnlyStatus_;
1909 ::mozilla::ipc::IPDLStructMember<uint32_t> requestBlockingReason_;
1910};
1911} // namespace net
1912} // namespace mozilla
1913
1914namespace IPC {
1915template<>
1916struct ParamTraits <::mozilla::net::LoadInfoArgs>
1917{
1918 typedef ::mozilla::net::LoadInfoArgs paramType;
1919 static void
1920 Write(
1921 IPC::MessageWriter* aWriter,
1922 const paramType& aVar);
1923 static IPC::ReadResult<paramType>
1924 Read(IPC::MessageReader* aReader);
1925};
1926} // namespace IPC
1927
1928
1929//-----------------------------------------------------------------------------
1930// Declaration of the IPDL type |struct ParentLoadInfoForwarderArgs|
1931//
1932namespace mozilla {
1933namespace net {
1934class ParentLoadInfoForwarderArgs final
1935{
1936private:
1937 typedef ::mozilla::dom::IPCServiceWorkerDescriptor IPCServiceWorkerDescriptor;
1938 typedef ::uint32_t uint32_t;
1939 typedef ::nsILoadInfo::HTTPSUpgradeTelemetryType HTTPSUpgradeTelemetryType;
1940 typedef ::uint64_t uint64_t;
1941 typedef ::mozilla::net::CookieJarSettingsArgs CookieJarSettingsArgs;
1942 typedef ::mozilla::dom::FeaturePolicyInfo FeaturePolicyInfo;
1943 typedef ::nsILoadInfo::StoragePermissionState StoragePermissionState;
1944 typedef ::nsIURI nsIURI;
1945
1946public:
1947#ifdef __clang__1
1948# pragma clang diagnostic push
1949# if __has_warning("-Wdefaulted-function-deleted")1
1950# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
1951# endif
1952#endif
1953 ParentLoadInfoForwarderArgs() = default;
1954#ifdef __clang__1
1955# pragma clang diagnostic pop
1956#endif
1957
1958 MOZ_IMPLICIT ParentLoadInfoForwarderArgs(
1959 const bool& _allowInsecureRedirectToDataURI,
1960 const mozilla::Maybe<IPCServiceWorkerDescriptor>& _controller,
1961 const uint32_t& _tainting,
1962 const bool& _skipContentSniffing,
1963 const uint32_t& _httpsOnlyStatus,
1964 const bool& _wasSchemelessInput,
1965 const HTTPSUpgradeTelemetryType& _httpsUpgradeTelemetry,
1966 const bool& _hstsStatus,
1967 const bool& _hasValidUserGestureActivation,
1968 const bool& _textDirectiveUserActivation,
1969 const bool& _allowDeprecatedSystemRequests,
1970 const bool& _isInDevToolsContext,
1971 const bool& _parserCreatedScript,
1972 const uint32_t& _triggeringSandboxFlags,
1973 const uint64_t& _triggeringWindowId,
1974 const bool& _triggeringStorageAccess,
1975 const bool& _serviceWorkerTaintingSynthesized,
1976 const bool& _documentHasUserInteracted,
1977 const bool& _allowListFutureDocumentsCreatedFromThisRedirectChain,
1978 const mozilla::Maybe<CookieJarSettingsArgs>& _cookieJarSettings,
1979 const mozilla::Maybe<FeaturePolicyInfo>& _containerFeaturePolicyInfo,
1980 const uint32_t& _requestBlockingReason,
1981 const StoragePermissionState& _storagePermission,
1982 const mozilla::Maybe<uint64_t>& _overriddenFingerprintingSettings,
1983 const bool& _isMetaRefresh,
1984 const mozilla::Maybe<bool>& _isThirdPartyContextToTopWindow,
1985 const bool& _isInThirdPartyContext,
1986 nsIURI* _unstrippedURI) :
1987 allowInsecureRedirectToDataURI_(_allowInsecureRedirectToDataURI),
1988 controller_(_controller),
1989 skipContentSniffing_(_skipContentSniffing),
1990 wasSchemelessInput_(_wasSchemelessInput),
1991 httpsUpgradeTelemetry_(_httpsUpgradeTelemetry),
1992 hstsStatus_(_hstsStatus),
1993 hasValidUserGestureActivation_(_hasValidUserGestureActivation),
1994 textDirectiveUserActivation_(_textDirectiveUserActivation),
1995 allowDeprecatedSystemRequests_(_allowDeprecatedSystemRequests),
1996 isInDevToolsContext_(_isInDevToolsContext),
1997 parserCreatedScript_(_parserCreatedScript),
1998 triggeringStorageAccess_(_triggeringStorageAccess),
1999 serviceWorkerTaintingSynthesized_(_serviceWorkerTaintingSynthesized),
2000 documentHasUserInteracted_(_documentHasUserInteracted),
2001 allowListFutureDocumentsCreatedFromThisRedirectChain_(_allowListFutureDocumentsCreatedFromThisRedirectChain),
2002 cookieJarSettings_(_cookieJarSettings),
2003 containerFeaturePolicyInfo_(_containerFeaturePolicyInfo),
2004 storagePermission_(_storagePermission),
2005 overriddenFingerprintingSettings_(_overriddenFingerprintingSettings),
2006 isMetaRefresh_(_isMetaRefresh),
2007 isThirdPartyContextToTopWindow_(_isThirdPartyContextToTopWindow),
2008 isInThirdPartyContext_(_isInThirdPartyContext),
2009 unstrippedURI_(_unstrippedURI),
2010 triggeringWindowId_(_triggeringWindowId),
2011 tainting_(_tainting),
2012 httpsOnlyStatus_(_httpsOnlyStatus),
2013 triggeringSandboxFlags_(_triggeringSandboxFlags),
2014 requestBlockingReason_(_requestBlockingReason)
2015 {
2016 }
2017
2018 MOZ_IMPLICIT ParentLoadInfoForwarderArgs(
2019 bool&& _allowInsecureRedirectToDataURI,
2020 mozilla::Maybe<IPCServiceWorkerDescriptor>&& _controller,
2021 uint32_t&& _tainting,
2022 bool&& _skipContentSniffing,
2023 uint32_t&& _httpsOnlyStatus,
2024 bool&& _wasSchemelessInput,
2025 HTTPSUpgradeTelemetryType&& _httpsUpgradeTelemetry,
2026 bool&& _hstsStatus,
2027 bool&& _hasValidUserGestureActivation,
2028 bool&& _textDirectiveUserActivation,
2029 bool&& _allowDeprecatedSystemRequests,
2030 bool&& _isInDevToolsContext,
2031 bool&& _parserCreatedScript,
2032 uint32_t&& _triggeringSandboxFlags,
2033 uint64_t&& _triggeringWindowId,
2034 bool&& _triggeringStorageAccess,
2035 bool&& _serviceWorkerTaintingSynthesized,
2036 bool&& _documentHasUserInteracted,
2037 bool&& _allowListFutureDocumentsCreatedFromThisRedirectChain,
2038 mozilla::Maybe<CookieJarSettingsArgs>&& _cookieJarSettings,
2039 mozilla::Maybe<FeaturePolicyInfo>&& _containerFeaturePolicyInfo,
2040 uint32_t&& _requestBlockingReason,
2041 StoragePermissionState&& _storagePermission,
2042 mozilla::Maybe<uint64_t>&& _overriddenFingerprintingSettings,
2043 bool&& _isMetaRefresh,
2044 mozilla::Maybe<bool>&& _isThirdPartyContextToTopWindow,
2045 bool&& _isInThirdPartyContext,
2046 RefPtr<nsIURI>&& _unstrippedURI) :
2047 allowInsecureRedirectToDataURI_(std::move(_allowInsecureRedirectToDataURI)),
2048 controller_(std::move(_controller)),
2049 skipContentSniffing_(std::move(_skipContentSniffing)),
2050 wasSchemelessInput_(std::move(_wasSchemelessInput)),
2051 httpsUpgradeTelemetry_(std::move(_httpsUpgradeTelemetry)),
2052 hstsStatus_(std::move(_hstsStatus)),
2053 hasValidUserGestureActivation_(std::move(_hasValidUserGestureActivation)),
2054 textDirectiveUserActivation_(std::move(_textDirectiveUserActivation)),
2055 allowDeprecatedSystemRequests_(std::move(_allowDeprecatedSystemRequests)),
2056 isInDevToolsContext_(std::move(_isInDevToolsContext)),
2057 parserCreatedScript_(std::move(_parserCreatedScript)),
2058 triggeringStorageAccess_(std::move(_triggeringStorageAccess)),
2059 serviceWorkerTaintingSynthesized_(std::move(_serviceWorkerTaintingSynthesized)),
2060 documentHasUserInteracted_(std::move(_documentHasUserInteracted)),
2061 allowListFutureDocumentsCreatedFromThisRedirectChain_(std::move(_allowListFutureDocumentsCreatedFromThisRedirectChain)),
2062 cookieJarSettings_(std::move(_cookieJarSettings)),
2063 containerFeaturePolicyInfo_(std::move(_containerFeaturePolicyInfo)),
2064 storagePermission_(std::move(_storagePermission)),
2065 overriddenFingerprintingSettings_(std::move(_overriddenFingerprintingSettings)),
2066 isMetaRefresh_(std::move(_isMetaRefresh)),
2067 isThirdPartyContextToTopWindow_(std::move(_isThirdPartyContextToTopWindow)),
2068 isInThirdPartyContext_(std::move(_isInThirdPartyContext)),
2069 unstrippedURI_(std::move(_unstrippedURI)),
2070 triggeringWindowId_(std::move(_triggeringWindowId)),
2071 tainting_(std::move(_tainting)),
2072 httpsOnlyStatus_(std::move(_httpsOnlyStatus)),
2073 triggeringSandboxFlags_(std::move(_triggeringSandboxFlags)),
2074 requestBlockingReason_(std::move(_requestBlockingReason))
2075 {
2076 }
2077
2078 bool&
2079 allowInsecureRedirectToDataURI()
2080 {
2081 return allowInsecureRedirectToDataURI_;
2082 }
2083 const bool&
2084 allowInsecureRedirectToDataURI() const
2085 {
2086 return allowInsecureRedirectToDataURI_;
2087 }
2088
2089 mozilla::Maybe<IPCServiceWorkerDescriptor>&
2090 controller()
2091 {
2092 return controller_;
2093 }
2094 const mozilla::Maybe<IPCServiceWorkerDescriptor>&
2095 controller() const
2096 {
2097 return controller_;
2098 }
2099
2100 uint32_t&
2101 tainting()
2102 {
2103 return tainting_;
2104 }
2105 const uint32_t&
2106 tainting() const
2107 {
2108 return tainting_;
2109 }
2110
2111 bool&
2112 skipContentSniffing()
2113 {
2114 return skipContentSniffing_;
2115 }
2116 const bool&
2117 skipContentSniffing() const
2118 {
2119 return skipContentSniffing_;
2120 }
2121
2122 uint32_t&
2123 httpsOnlyStatus()
2124 {
2125 return httpsOnlyStatus_;
2126 }
2127 const uint32_t&
2128 httpsOnlyStatus() const
2129 {
2130 return httpsOnlyStatus_;
2131 }
2132
2133 bool&
2134 wasSchemelessInput()
2135 {
2136 return wasSchemelessInput_;
2137 }
2138 const bool&
2139 wasSchemelessInput() const
2140 {
2141 return wasSchemelessInput_;
2142 }
2143
2144 HTTPSUpgradeTelemetryType&
2145 httpsUpgradeTelemetry()
2146 {
2147 return httpsUpgradeTelemetry_;
2148 }
2149 const HTTPSUpgradeTelemetryType&
2150 httpsUpgradeTelemetry() const
2151 {
2152 return httpsUpgradeTelemetry_;
2153 }
2154
2155 bool&
2156 hstsStatus()
2157 {
2158 return hstsStatus_;
2159 }
2160 const bool&
2161 hstsStatus() const
2162 {
2163 return hstsStatus_;
2164 }
2165
2166 bool&
2167 hasValidUserGestureActivation()
2168 {
2169 return hasValidUserGestureActivation_;
2170 }
2171 const bool&
2172 hasValidUserGestureActivation() const
2173 {
2174 return hasValidUserGestureActivation_;
2175 }
2176
2177 bool&
2178 textDirectiveUserActivation()
2179 {
2180 return textDirectiveUserActivation_;
2181 }
2182 const bool&
2183 textDirectiveUserActivation() const
2184 {
2185 return textDirectiveUserActivation_;
2186 }
2187
2188 bool&
2189 allowDeprecatedSystemRequests()
2190 {
2191 return allowDeprecatedSystemRequests_;
2192 }
2193 const bool&
2194 allowDeprecatedSystemRequests() const
2195 {
2196 return allowDeprecatedSystemRequests_;
2197 }
2198
2199 bool&
2200 isInDevToolsContext()
2201 {
2202 return isInDevToolsContext_;
2203 }
2204 const bool&
2205 isInDevToolsContext() const
2206 {
2207 return isInDevToolsContext_;
2208 }
2209
2210 bool&
2211 parserCreatedScript()
2212 {
2213 return parserCreatedScript_;
2214 }
2215 const bool&
2216 parserCreatedScript() const
2217 {
2218 return parserCreatedScript_;
2219 }
2220
2221 uint32_t&
2222 triggeringSandboxFlags()
2223 {
2224 return triggeringSandboxFlags_;
2225 }
2226 const uint32_t&
2227 triggeringSandboxFlags() const
2228 {
2229 return triggeringSandboxFlags_;
2230 }
2231
2232 uint64_t&
2233 triggeringWindowId()
2234 {
2235 return triggeringWindowId_;
2236 }
2237 const uint64_t&
2238 triggeringWindowId() const
2239 {
2240 return triggeringWindowId_;
2241 }
2242
2243 bool&
2244 triggeringStorageAccess()
2245 {
2246 return triggeringStorageAccess_;
2247 }
2248 const bool&
2249 triggeringStorageAccess() const
2250 {
2251 return triggeringStorageAccess_;
2252 }
2253
2254 bool&
2255 serviceWorkerTaintingSynthesized()
2256 {
2257 return serviceWorkerTaintingSynthesized_;
2258 }
2259 const bool&
2260 serviceWorkerTaintingSynthesized() const
2261 {
2262 return serviceWorkerTaintingSynthesized_;
2263 }
2264
2265 bool&
2266 documentHasUserInteracted()
2267 {
2268 return documentHasUserInteracted_;
2269 }
2270 const bool&
2271 documentHasUserInteracted() const
2272 {
2273 return documentHasUserInteracted_;
2274 }
2275
2276 bool&
2277 allowListFutureDocumentsCreatedFromThisRedirectChain()
2278 {
2279 return allowListFutureDocumentsCreatedFromThisRedirectChain_;
2280 }
2281 const bool&
2282 allowListFutureDocumentsCreatedFromThisRedirectChain() const
2283 {
2284 return allowListFutureDocumentsCreatedFromThisRedirectChain_;
2285 }
2286
2287 mozilla::Maybe<CookieJarSettingsArgs>&
2288 cookieJarSettings()
2289 {
2290 return cookieJarSettings_;
2291 }
2292 const mozilla::Maybe<CookieJarSettingsArgs>&
2293 cookieJarSettings() const
2294 {
2295 return cookieJarSettings_;
2296 }
2297
2298 mozilla::Maybe<FeaturePolicyInfo>&
2299 containerFeaturePolicyInfo()
2300 {
2301 return containerFeaturePolicyInfo_;
2302 }
2303 const mozilla::Maybe<FeaturePolicyInfo>&
2304 containerFeaturePolicyInfo() const
2305 {
2306 return containerFeaturePolicyInfo_;
2307 }
2308
2309 uint32_t&
2310 requestBlockingReason()
2311 {
2312 return requestBlockingReason_;
2313 }
2314 const uint32_t&
2315 requestBlockingReason() const
2316 {
2317 return requestBlockingReason_;
2318 }
2319
2320 StoragePermissionState&
2321 storagePermission()
2322 {
2323 return storagePermission_;
2324 }
2325 const StoragePermissionState&
2326 storagePermission() const
2327 {
2328 return storagePermission_;
2329 }
2330
2331 mozilla::Maybe<uint64_t>&
2332 overriddenFingerprintingSettings()
2333 {
2334 return overriddenFingerprintingSettings_;
2335 }
2336 const mozilla::Maybe<uint64_t>&
2337 overriddenFingerprintingSettings() const
2338 {
2339 return overriddenFingerprintingSettings_;
2340 }
2341
2342 bool&
2343 isMetaRefresh()
2344 {
2345 return isMetaRefresh_;
2346 }
2347 const bool&
2348 isMetaRefresh() const
2349 {
2350 return isMetaRefresh_;
2351 }
2352
2353 mozilla::Maybe<bool>&
2354 isThirdPartyContextToTopWindow()
2355 {
2356 return isThirdPartyContextToTopWindow_;
2357 }
2358 const mozilla::Maybe<bool>&
2359 isThirdPartyContextToTopWindow() const
2360 {
2361 return isThirdPartyContextToTopWindow_;
2362 }
2363
2364 bool&
2365 isInThirdPartyContext()
2366 {
2367 return isInThirdPartyContext_;
2368 }
2369 const bool&
2370 isInThirdPartyContext() const
2371 {
2372 return isInThirdPartyContext_;
2373 }
2374
2375 RefPtr<nsIURI>&
2376 unstrippedURI()
2377 {
2378 return unstrippedURI_;
2379 }
2380 nsIURI*
2381 unstrippedURI() const
2382 {
2383 return unstrippedURI_;
2384 }
2385
2386private:
2387 void
2388 StaticAssertions() const;
2389 ::mozilla::ipc::IPDLStructMember<bool> allowInsecureRedirectToDataURI_;
2390 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCServiceWorkerDescriptor>> controller_;
2391 ::mozilla::ipc::IPDLStructMember<bool> skipContentSniffing_;
2392 ::mozilla::ipc::IPDLStructMember<bool> wasSchemelessInput_;
2393 ::mozilla::ipc::IPDLStructMember<HTTPSUpgradeTelemetryType> httpsUpgradeTelemetry_;
2394 ::mozilla::ipc::IPDLStructMember<bool> hstsStatus_;
2395 ::mozilla::ipc::IPDLStructMember<bool> hasValidUserGestureActivation_;
2396 ::mozilla::ipc::IPDLStructMember<bool> textDirectiveUserActivation_;
2397 ::mozilla::ipc::IPDLStructMember<bool> allowDeprecatedSystemRequests_;
2398 ::mozilla::ipc::IPDLStructMember<bool> isInDevToolsContext_;
2399 ::mozilla::ipc::IPDLStructMember<bool> parserCreatedScript_;
2400 ::mozilla::ipc::IPDLStructMember<bool> triggeringStorageAccess_;
2401 ::mozilla::ipc::IPDLStructMember<bool> serviceWorkerTaintingSynthesized_;
2402 ::mozilla::ipc::IPDLStructMember<bool> documentHasUserInteracted_;
2403 ::mozilla::ipc::IPDLStructMember<bool> allowListFutureDocumentsCreatedFromThisRedirectChain_;
2404 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<CookieJarSettingsArgs>> cookieJarSettings_;
2405 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<FeaturePolicyInfo>> containerFeaturePolicyInfo_;
2406 ::mozilla::ipc::IPDLStructMember<StoragePermissionState> storagePermission_;
2407 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<uint64_t>> overriddenFingerprintingSettings_;
2408 ::mozilla::ipc::IPDLStructMember<bool> isMetaRefresh_;
2409 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<bool>> isThirdPartyContextToTopWindow_;
2410 ::mozilla::ipc::IPDLStructMember<bool> isInThirdPartyContext_;
2411 ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> unstrippedURI_;
2412 ::mozilla::ipc::IPDLStructMember<uint64_t> triggeringWindowId_;
2413 ::mozilla::ipc::IPDLStructMember<uint32_t> tainting_;
2414 ::mozilla::ipc::IPDLStructMember<uint32_t> httpsOnlyStatus_;
2415 ::mozilla::ipc::IPDLStructMember<uint32_t> triggeringSandboxFlags_;
2416 ::mozilla::ipc::IPDLStructMember<uint32_t> requestBlockingReason_;
2417};
2418} // namespace net
2419} // namespace mozilla
2420
2421namespace IPC {
2422template<>
2423struct ParamTraits <::mozilla::net::ParentLoadInfoForwarderArgs>
2424{
2425 typedef ::mozilla::net::ParentLoadInfoForwarderArgs paramType;
2426 static void
2427 Write(
2428 IPC::MessageWriter* aWriter,
2429 const paramType& aVar);
2430 static IPC::ReadResult<paramType>
2431 Read(IPC::MessageReader* aReader);
2432};
2433} // namespace IPC
2434
2435
2436//-----------------------------------------------------------------------------
2437// Declaration of the IPDL type |struct ChildLoadInfoForwarderArgs|
2438//
2439namespace mozilla {
2440namespace net {
2441class ChildLoadInfoForwarderArgs final
2442{
2443private:
2444 typedef ::mozilla::dom::IPCClientInfo IPCClientInfo;
2445 typedef ::mozilla::dom::IPCServiceWorkerDescriptor IPCServiceWorkerDescriptor;
2446 typedef ::uint32_t uint32_t;
2447
2448public:
2449#ifdef __clang__1
2450# pragma clang diagnostic push
2451# if __has_warning("-Wdefaulted-function-deleted")1
2452# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
2453# endif
2454#endif
2455 ChildLoadInfoForwarderArgs() = default;
2456#ifdef __clang__1
2457# pragma clang diagnostic pop
2458#endif
2459
2460 MOZ_IMPLICIT ChildLoadInfoForwarderArgs(
2461 const mozilla::Maybe<IPCClientInfo>& _reservedClientInfo,
2462 const mozilla::Maybe<IPCClientInfo>& _initialClientInfo,
2463 const mozilla::Maybe<IPCServiceWorkerDescriptor>& _controller,
2464 const uint32_t& _requestBlockingReason) :
2465 reservedClientInfo_(_reservedClientInfo),
2466 initialClientInfo_(_initialClientInfo),
2467 controller_(_controller),
2468 requestBlockingReason_(_requestBlockingReason)
2469 {
2470 }
2471
2472 MOZ_IMPLICIT ChildLoadInfoForwarderArgs(
2473 mozilla::Maybe<IPCClientInfo>&& _reservedClientInfo,
2474 mozilla::Maybe<IPCClientInfo>&& _initialClientInfo,
2475 mozilla::Maybe<IPCServiceWorkerDescriptor>&& _controller,
2476 uint32_t&& _requestBlockingReason) :
2477 reservedClientInfo_(std::move(_reservedClientInfo)),
2478 initialClientInfo_(std::move(_initialClientInfo)),
2479 controller_(std::move(_controller)),
2480 requestBlockingReason_(std::move(_requestBlockingReason))
2481 {
2482 }
2483
2484 mozilla::Maybe<IPCClientInfo>&
2485 reservedClientInfo()
2486 {
2487 return reservedClientInfo_;
2488 }
2489 const mozilla::Maybe<IPCClientInfo>&
2490 reservedClientInfo() const
2491 {
2492 return reservedClientInfo_;
2493 }
2494
2495 mozilla::Maybe<IPCClientInfo>&
2496 initialClientInfo()
2497 {
2498 return initialClientInfo_;
2499 }
2500 const mozilla::Maybe<IPCClientInfo>&
2501 initialClientInfo() const
2502 {
2503 return initialClientInfo_;
2504 }
2505
2506 mozilla::Maybe<IPCServiceWorkerDescriptor>&
2507 controller()
2508 {
2509 return controller_;
2510 }
2511 const mozilla::Maybe<IPCServiceWorkerDescriptor>&
2512 controller() const
2513 {
2514 return controller_;
2515 }
2516
2517 uint32_t&
2518 requestBlockingReason()
2519 {
2520 return requestBlockingReason_;
2521 }
2522 const uint32_t&
2523 requestBlockingReason() const
2524 {
2525 return requestBlockingReason_;
2526 }
2527
2528private:
2529 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> reservedClientInfo_;
2530 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> initialClientInfo_;
2531 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCServiceWorkerDescriptor>> controller_;
2532 ::mozilla::ipc::IPDLStructMember<uint32_t> requestBlockingReason_;
2533};
2534} // namespace net
2535} // namespace mozilla
2536
2537namespace IPC {
2538template<>
2539struct ParamTraits <::mozilla::net::ChildLoadInfoForwarderArgs>
2540{
2541 typedef ::mozilla::net::ChildLoadInfoForwarderArgs paramType;
2542 static void
2543 Write(
2544 IPC::MessageWriter* aWriter,
2545 const paramType& aVar);
2546 static IPC::ReadResult<paramType>
2547 Read(IPC::MessageReader* aReader);
2548};
2549} // namespace IPC
2550
2551
2552//-----------------------------------------------------------------------------
2553// Declaration of the IPDL type |struct CorsPreflightArgs|
2554//
2555namespace mozilla {
2556namespace net {
2557class CorsPreflightArgs final
2558{
2559private:
2560 typedef ::nsCString nsCString;
2561
2562public:
2563#ifdef __clang__1
2564# pragma clang diagnostic push
2565# if __has_warning("-Wdefaulted-function-deleted")1
2566# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
2567# endif
2568#endif
2569 CorsPreflightArgs() = default;
2570#ifdef __clang__1
2571# pragma clang diagnostic pop
2572#endif
2573
2574 MOZ_IMPLICIT CorsPreflightArgs(const nsTArray<nsCString>& _unsafeHeaders) :
2575 unsafeHeaders_(_unsafeHeaders)
2576 {
2577 }
2578
2579 MOZ_IMPLICIT CorsPreflightArgs(nsTArray<nsCString>&& _unsafeHeaders) :
2580 unsafeHeaders_(std::move(_unsafeHeaders))
2581 {
2582 }
2583
2584 nsTArray<nsCString>&
2585 unsafeHeaders()
2586 {
2587 return unsafeHeaders_;
2588 }
2589 const nsTArray<nsCString>&
2590 unsafeHeaders() const
2591 {
2592 return unsafeHeaders_;
2593 }
2594
2595private:
2596 ::mozilla::ipc::IPDLStructMember<CopyableTArray<nsCString>> unsafeHeaders_;
2597};
2598} // namespace net
2599} // namespace mozilla
2600
2601namespace IPC {
2602template<>
2603struct ParamTraits <::mozilla::net::CorsPreflightArgs>
2604{
2605 typedef ::mozilla::net::CorsPreflightArgs paramType;
2606 static void
2607 Write(
2608 IPC::MessageWriter* aWriter,
2609 const paramType& aVar);
2610 static IPC::ReadResult<paramType>
2611 Read(IPC::MessageReader* aReader);
2612};
2613} // namespace IPC
2614
2615
2616//-----------------------------------------------------------------------------
2617// Declaration of the IPDL type |struct HttpChannelOpenArgs|
2618//
2619namespace mozilla {
2620namespace net {
2621class HttpChannelOpenArgs final
2622{
2623private:
2624 typedef ::nsIURI nsIURI;
2625 typedef ::nsIReferrerInfo nsIReferrerInfo;
2626 typedef ::mozilla::net::RequestHeaderTuples RequestHeaderTuples;
2627 typedef ::mozilla::net::PreferredAlternativeDataTypeParams PreferredAlternativeDataTypeParams;
2628 typedef ::mozilla::TimeStamp TimeStamp;
2629 typedef ::uint64_t uint64_t;
2630 typedef ::nsCString nsCString;
2631 typedef ::mozilla::net::ClassOfService ClassOfService;
2632 typedef ::mozilla::net::CorsPreflightArgs CorsPreflightArgs;
2633 typedef ::nsString nsString;
2634 typedef ::mozilla::ipc::IPCStream IPCStream;
2635 typedef ::mozilla::net::LoadInfoArgs LoadInfoArgs;
2636 typedef ::uint32_t uint32_t;
2637 typedef ::int16_t int16_t;
2638 typedef ::mozilla::dom::RequestMode RequestMode;
2639 typedef ::uint8_t uint8_t;
2640
2641public:
2642#ifdef __clang__1
2643# pragma clang diagnostic push
2644# if __has_warning("-Wdefaulted-function-deleted")1
2645# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
2646# endif
2647#endif
2648 HttpChannelOpenArgs() = default;
2649#ifdef __clang__1
2650# pragma clang diagnostic pop
2651#endif
2652
2653 MOZ_IMPLICIT HttpChannelOpenArgs(
2654 nsIURI* _uri,
2655 nsIURI* _original,
2656 nsIURI* _doc,
2657 nsIReferrerInfo* _referrerInfo,
2658 nsIURI* _apiRedirectTo,
2659 nsIURI* _topWindowURI,
2660 const RequestHeaderTuples& _requestHeaders,
2661 const nsTArray<PreferredAlternativeDataTypeParams>& _preferredAlternativeTypes,
2662 const TimeStamp& _launchServiceWorkerStart,
2663 const TimeStamp& _launchServiceWorkerEnd,
2664 const TimeStamp& _dispatchFetchEventStart,
2665 const TimeStamp& _dispatchFetchEventEnd,
2666 const TimeStamp& _handleFetchEventStart,
2667 const TimeStamp& _handleFetchEventEnd,
2668 const TimeStamp& _navigationStartTimeStamp,
2669 const uint64_t& _startPos,
2670 const uint64_t& _requestContextID,
2671 const uint64_t& _channelId,
2672 const uint64_t& _contentWindowId,
2673 const uint64_t& _browserId,
2674 const uint64_t& _earlyHintPreloaderId,
2675 const nsCString& _requestMethod,
2676 const ClassOfService& _classOfService,
2677 const nsCString& _entityID,
2678 const nsCString& _appCacheClientID,
2679 const mozilla::Maybe<CorsPreflightArgs>& _preflightArgs,
2680 const nsCString& _contentTypeHint,
2681 const nsString& _integrityMetadata,
2682 const mozilla::Maybe<IPCStream>& _uploadStream,
2683 const LoadInfoArgs& _loadInfo,
2684 const uint32_t& _loadFlags,
2685 const uint32_t& _thirdPartyFlags,
2686 const uint32_t& _tlsFlags,
2687 const uint32_t& _cacheKey,
2688 const uint32_t& _initialRwin,
2689 const uint32_t& _redirectMode,
2690 const int16_t& _priority,
2691 const bool& _uploadStreamHasHeaders,
2692 const bool& _allowSTS,
2693 const bool& _resumeAt,
2694 const bool& _allowSpdy,
2695 const bool& _allowHttp3,
2696 const bool& _allowAltSvc,
2697 const bool& _beConservative,
2698 const bool& _bypassProxy,
2699 const bool& _blockAuthPrompt,
2700 const bool& _allowStaleCacheContent,
2701 const RequestMode& _requestMode,
2702 const bool& _forceValidateCacheContent,
2703 const bool& _preferCacheLoadOverBypass,
2704 const bool& _forceMainDocumentChannel,
2705 const uint8_t& _redirectionLimit,
2706 const nsString& _classicScriptHintCharset,
2707 const nsString& _documentCharacterSet,
2708 const bool& _isUserAgentHeaderModified) :
2709 uri_(_uri),
2710 original_(_original),
2711 doc_(_doc),
2712 referrerInfo_(_referrerInfo),
2713 apiRedirectTo_(_apiRedirectTo),
2714 topWindowURI_(_topWindowURI),
2715 requestHeaders_(_requestHeaders),
2716 preferredAlternativeTypes_(_preferredAlternativeTypes),
2717 launchServiceWorkerStart_(_launchServiceWorkerStart),
2718 launchServiceWorkerEnd_(_launchServiceWorkerEnd),
2719 dispatchFetchEventStart_(_dispatchFetchEventStart),
2720 dispatchFetchEventEnd_(_dispatchFetchEventEnd),
2721 handleFetchEventStart_(_handleFetchEventStart),
2722 handleFetchEventEnd_(_handleFetchEventEnd),
2723 navigationStartTimeStamp_(_navigationStartTimeStamp),
2724 requestMethod_(_requestMethod),
2725 classOfService_(_classOfService),
2726 entityID_(_entityID),
2727 appCacheClientID_(_appCacheClientID),
2728 preflightArgs_(_preflightArgs),
2729 contentTypeHint_(_contentTypeHint),
2730 integrityMetadata_(_integrityMetadata),
2731 uploadStream_(_uploadStream),
2732 loadInfo_(_loadInfo),
2733 uploadStreamHasHeaders_(_uploadStreamHasHeaders),
2734 allowSTS_(_allowSTS),
2735 resumeAt_(_resumeAt),
2736 allowSpdy_(_allowSpdy),
2737 allowHttp3_(_allowHttp3),
2738 allowAltSvc_(_allowAltSvc),
2739 beConservative_(_beConservative),
2740 bypassProxy_(_bypassProxy),
2741 blockAuthPrompt_(_blockAuthPrompt),
2742 allowStaleCacheContent_(_allowStaleCacheContent),
2743 requestMode_(_requestMode),
2744 forceValidateCacheContent_(_forceValidateCacheContent),
2745 preferCacheLoadOverBypass_(_preferCacheLoadOverBypass),
2746 forceMainDocumentChannel_(_forceMainDocumentChannel),
2747 classicScriptHintCharset_(_classicScriptHintCharset),
2748 documentCharacterSet_(_documentCharacterSet),
2749 isUserAgentHeaderModified_(_isUserAgentHeaderModified),
2750 startPos_(_startPos),
2751 requestContextID_(_requestContextID),
2752 channelId_(_channelId),
2753 contentWindowId_(_contentWindowId),
2754 browserId_(_browserId),
2755 earlyHintPreloaderId_(_earlyHintPreloaderId),
2756 loadFlags_(_loadFlags),
2757 thirdPartyFlags_(_thirdPartyFlags),
2758 tlsFlags_(_tlsFlags),
2759 cacheKey_(_cacheKey),
2760 initialRwin_(_initialRwin),
2761 redirectMode_(_redirectMode),
2762 priority_(_priority),
2763 redirectionLimit_(_redirectionLimit)
2764 {
2765 }
2766
2767 MOZ_IMPLICIT HttpChannelOpenArgs(
2768 RefPtr<nsIURI>&& _uri,
2769 RefPtr<nsIURI>&& _original,
2770 RefPtr<nsIURI>&& _doc,
2771 RefPtr<nsIReferrerInfo>&& _referrerInfo,
2772 RefPtr<nsIURI>&& _apiRedirectTo,
2773 RefPtr<nsIURI>&& _topWindowURI,
2774 RequestHeaderTuples&& _requestHeaders,
2775 nsTArray<PreferredAlternativeDataTypeParams>&& _preferredAlternativeTypes,
2776 TimeStamp&& _launchServiceWorkerStart,
2777 TimeStamp&& _launchServiceWorkerEnd,
2778 TimeStamp&& _dispatchFetchEventStart,
2779 TimeStamp&& _dispatchFetchEventEnd,
2780 TimeStamp&& _handleFetchEventStart,
2781 TimeStamp&& _handleFetchEventEnd,
2782 TimeStamp&& _navigationStartTimeStamp,
2783 uint64_t&& _startPos,
2784 uint64_t&& _requestContextID,
2785 uint64_t&& _channelId,
2786 uint64_t&& _contentWindowId,
2787 uint64_t&& _browserId,
2788 uint64_t&& _earlyHintPreloaderId,
2789 nsCString&& _requestMethod,
2790 ClassOfService&& _classOfService,
2791 nsCString&& _entityID,
2792 nsCString&& _appCacheClientID,
2793 mozilla::Maybe<CorsPreflightArgs>&& _preflightArgs,
2794 nsCString&& _contentTypeHint,
2795 nsString&& _integrityMetadata,
2796 mozilla::Maybe<IPCStream>&& _uploadStream,
2797 LoadInfoArgs&& _loadInfo,
2798 uint32_t&& _loadFlags,
2799 uint32_t&& _thirdPartyFlags,
2800 uint32_t&& _tlsFlags,
2801 uint32_t&& _cacheKey,
2802 uint32_t&& _initialRwin,
2803 uint32_t&& _redirectMode,
2804 int16_t&& _priority,
2805 bool&& _uploadStreamHasHeaders,
2806 bool&& _allowSTS,
2807 bool&& _resumeAt,
2808 bool&& _allowSpdy,
2809 bool&& _allowHttp3,
2810 bool&& _allowAltSvc,
2811 bool&& _beConservative,
2812 bool&& _bypassProxy,
2813 bool&& _blockAuthPrompt,
2814 bool&& _allowStaleCacheContent,
2815 RequestMode&& _requestMode,
2816 bool&& _forceValidateCacheContent,
2817 bool&& _preferCacheLoadOverBypass,
2818 bool&& _forceMainDocumentChannel,
2819 uint8_t&& _redirectionLimit,
2820 nsString&& _classicScriptHintCharset,
2821 nsString&& _documentCharacterSet,
2822 bool&& _isUserAgentHeaderModified) :
2823 uri_(std::move(_uri)),
2824 original_(std::move(_original)),
2825 doc_(std::move(_doc)),
2826 referrerInfo_(std::move(_referrerInfo)),
2827 apiRedirectTo_(std::move(_apiRedirectTo)),
2828 topWindowURI_(std::move(_topWindowURI)),
2829 requestHeaders_(std::move(_requestHeaders)),
2830 preferredAlternativeTypes_(std::move(_preferredAlternativeTypes)),
2831 launchServiceWorkerStart_(std::move(_launchServiceWorkerStart)),
2832 launchServiceWorkerEnd_(std::move(_launchServiceWorkerEnd)),
2833 dispatchFetchEventStart_(std::move(_dispatchFetchEventStart)),
2834 dispatchFetchEventEnd_(std::move(_dispatchFetchEventEnd)),
2835 handleFetchEventStart_(std::move(_handleFetchEventStart)),
2836 handleFetchEventEnd_(std::move(_handleFetchEventEnd)),
2837 navigationStartTimeStamp_(std::move(_navigationStartTimeStamp)),
2838 requestMethod_(std::move(_requestMethod)),
2839 classOfService_(std::move(_classOfService)),
2840 entityID_(std::move(_entityID)),
2841 appCacheClientID_(std::move(_appCacheClientID)),
2842 preflightArgs_(std::move(_preflightArgs)),
2843 contentTypeHint_(std::move(_contentTypeHint)),
2844 integrityMetadata_(std::move(_integrityMetadata)),
2845 uploadStream_(std::move(_uploadStream)),
2846 loadInfo_(std::move(_loadInfo)),
2847 uploadStreamHasHeaders_(std::move(_uploadStreamHasHeaders)),
2848 allowSTS_(std::move(_allowSTS)),
2849 resumeAt_(std::move(_resumeAt)),
2850 allowSpdy_(std::move(_allowSpdy)),
2851 allowHttp3_(std::move(_allowHttp3)),
2852 allowAltSvc_(std::move(_allowAltSvc)),
2853 beConservative_(std::move(_beConservative)),
2854 bypassProxy_(std::move(_bypassProxy)),
2855 blockAuthPrompt_(std::move(_blockAuthPrompt)),
2856 allowStaleCacheContent_(std::move(_allowStaleCacheContent)),
2857 requestMode_(std::move(_requestMode)),
2858 forceValidateCacheContent_(std::move(_forceValidateCacheContent)),
2859 preferCacheLoadOverBypass_(std::move(_preferCacheLoadOverBypass)),
2860 forceMainDocumentChannel_(std::move(_forceMainDocumentChannel)),
2861 classicScriptHintCharset_(std::move(_classicScriptHintCharset)),
2862 documentCharacterSet_(std::move(_documentCharacterSet)),
2863 isUserAgentHeaderModified_(std::move(_isUserAgentHeaderModified)),
2864 startPos_(std::move(_startPos)),
2865 requestContextID_(std::move(_requestContextID)),
2866 channelId_(std::move(_channelId)),
2867 contentWindowId_(std::move(_contentWindowId)),
2868 browserId_(std::move(_browserId)),
2869 earlyHintPreloaderId_(std::move(_earlyHintPreloaderId)),
2870 loadFlags_(std::move(_loadFlags)),
2871 thirdPartyFlags_(std::move(_thirdPartyFlags)),
2872 tlsFlags_(std::move(_tlsFlags)),
2873 cacheKey_(std::move(_cacheKey)),
2874 initialRwin_(std::move(_initialRwin)),
2875 redirectMode_(std::move(_redirectMode)),
2876 priority_(std::move(_priority)),
2877 redirectionLimit_(std::move(_redirectionLimit))
2878 {
2879 }
2880
2881 RefPtr<nsIURI>&
2882 uri()
2883 {
2884 return uri_;
2885 }
2886 nsIURI*
2887 uri() const
2888 {
2889 return uri_;
2890 }
2891
2892 RefPtr<nsIURI>&
2893 original()
2894 {
2895 return original_;
2896 }
2897 nsIURI*
2898 original() const
2899 {
2900 return original_;
2901 }
2902
2903 RefPtr<nsIURI>&
2904 doc()
2905 {
2906 return doc_;
2907 }
2908 nsIURI*
2909 doc() const
2910 {
2911 return doc_;
2912 }
2913
2914 RefPtr<nsIReferrerInfo>&
2915 referrerInfo()
2916 {
2917 return referrerInfo_;
2918 }
2919 nsIReferrerInfo*
2920 referrerInfo() const
2921 {
2922 return referrerInfo_;
2923 }
2924
2925 RefPtr<nsIURI>&
2926 apiRedirectTo()
2927 {
2928 return apiRedirectTo_;
2929 }
2930 nsIURI*
2931 apiRedirectTo() const
2932 {
2933 return apiRedirectTo_;
2934 }
2935
2936 RefPtr<nsIURI>&
2937 topWindowURI()
2938 {
2939 return topWindowURI_;
2940 }
2941 nsIURI*
2942 topWindowURI() const
2943 {
2944 return topWindowURI_;
2945 }
2946
2947 RequestHeaderTuples&
2948 requestHeaders()
2949 {
2950 return requestHeaders_;
2951 }
2952 const RequestHeaderTuples&
2953 requestHeaders() const
2954 {
2955 return requestHeaders_;
2956 }
2957
2958 nsTArray<PreferredAlternativeDataTypeParams>&
2959 preferredAlternativeTypes()
2960 {
2961 return preferredAlternativeTypes_;
2962 }
2963 const nsTArray<PreferredAlternativeDataTypeParams>&
2964 preferredAlternativeTypes() const
2965 {
2966 return preferredAlternativeTypes_;
2967 }
2968
2969 TimeStamp&
2970 launchServiceWorkerStart()
2971 {
2972 return launchServiceWorkerStart_;
2973 }
2974 const TimeStamp&
2975 launchServiceWorkerStart() const
2976 {
2977 return launchServiceWorkerStart_;
2978 }
2979
2980 TimeStamp&
2981 launchServiceWorkerEnd()
2982 {
2983 return launchServiceWorkerEnd_;
2984 }
2985 const TimeStamp&
2986 launchServiceWorkerEnd() const
2987 {
2988 return launchServiceWorkerEnd_;
2989 }
2990
2991 TimeStamp&
2992 dispatchFetchEventStart()
2993 {
2994 return dispatchFetchEventStart_;
2995 }
2996 const TimeStamp&
2997 dispatchFetchEventStart() const
2998 {
2999 return dispatchFetchEventStart_;
3000 }
3001
3002 TimeStamp&
3003 dispatchFetchEventEnd()
3004 {
3005 return dispatchFetchEventEnd_;
3006 }
3007 const TimeStamp&
3008 dispatchFetchEventEnd() const
3009 {
3010 return dispatchFetchEventEnd_;
3011 }
3012
3013 TimeStamp&
3014 handleFetchEventStart()
3015 {
3016 return handleFetchEventStart_;
3017 }
3018 const TimeStamp&
3019 handleFetchEventStart() const
3020 {
3021 return handleFetchEventStart_;
3022 }
3023
3024 TimeStamp&
3025 handleFetchEventEnd()
3026 {
3027 return handleFetchEventEnd_;
3028 }
3029 const TimeStamp&
3030 handleFetchEventEnd() const
3031 {
3032 return handleFetchEventEnd_;
3033 }
3034
3035 TimeStamp&
3036 navigationStartTimeStamp()
3037 {
3038 return navigationStartTimeStamp_;
3039 }
3040 const TimeStamp&
3041 navigationStartTimeStamp() const
3042 {
3043 return navigationStartTimeStamp_;
3044 }
3045
3046 uint64_t&
3047 startPos()
3048 {
3049 return startPos_;
3050 }
3051 const uint64_t&
3052 startPos() const
3053 {
3054 return startPos_;
3055 }
3056
3057 uint64_t&
3058 requestContextID()
3059 {
3060 return requestContextID_;
3061 }
3062 const uint64_t&
3063 requestContextID() const
3064 {
3065 return requestContextID_;
3066 }
3067
3068 uint64_t&
3069 channelId()
3070 {
3071 return channelId_;
3072 }
3073 const uint64_t&
3074 channelId() const
3075 {
3076 return channelId_;
3077 }
3078
3079 uint64_t&
3080 contentWindowId()
3081 {
3082 return contentWindowId_;
3083 }
3084 const uint64_t&
3085 contentWindowId() const
3086 {
3087 return contentWindowId_;
3088 }
3089
3090 uint64_t&
3091 browserId()
3092 {
3093 return browserId_;
3094 }
3095 const uint64_t&
3096 browserId() const
3097 {
3098 return browserId_;
3099 }
3100
3101 uint64_t&
3102 earlyHintPreloaderId()
3103 {
3104 return earlyHintPreloaderId_;
3105 }
3106 const uint64_t&
3107 earlyHintPreloaderId() const
3108 {
3109 return earlyHintPreloaderId_;
3110 }
3111
3112 nsCString&
3113 requestMethod()
3114 {
3115 return requestMethod_;
3116 }
3117 const nsCString&
3118 requestMethod() const
3119 {
3120 return requestMethod_;
3121 }
3122
3123 ClassOfService&
3124 classOfService()
3125 {
3126 return classOfService_;
3127 }
3128 const ClassOfService&
3129 classOfService() const
3130 {
3131 return classOfService_;
3132 }
3133
3134 nsCString&
3135 entityID()
3136 {
3137 return entityID_;
3138 }
3139 const nsCString&
3140 entityID() const
3141 {
3142 return entityID_;
3143 }
3144
3145 nsCString&
3146 appCacheClientID()
3147 {
3148 return appCacheClientID_;
3149 }
3150 const nsCString&
3151 appCacheClientID() const
3152 {
3153 return appCacheClientID_;
3154 }
3155
3156 mozilla::Maybe<CorsPreflightArgs>&
3157 preflightArgs()
3158 {
3159 return preflightArgs_;
3160 }
3161 const mozilla::Maybe<CorsPreflightArgs>&
3162 preflightArgs() const
3163 {
3164 return preflightArgs_;
3165 }
3166
3167 nsCString&
3168 contentTypeHint()
3169 {
3170 return contentTypeHint_;
3171 }
3172 const nsCString&
3173 contentTypeHint() const
3174 {
3175 return contentTypeHint_;
3176 }
3177
3178 nsString&
3179 integrityMetadata()
3180 {
3181 return integrityMetadata_;
3182 }
3183 const nsString&
3184 integrityMetadata() const
3185 {
3186 return integrityMetadata_;
3187 }
3188
3189 mozilla::Maybe<IPCStream>&
3190 uploadStream()
3191 {
3192 return uploadStream_;
3193 }
3194 const mozilla::Maybe<IPCStream>&
3195 uploadStream() const
3196 {
3197 return uploadStream_;
3198 }
3199
3200 LoadInfoArgs&
3201 loadInfo()
3202 {
3203 return loadInfo_;
3204 }
3205 const LoadInfoArgs&
3206 loadInfo() const
3207 {
3208 return loadInfo_;
3209 }
3210
3211 uint32_t&
3212 loadFlags()
3213 {
3214 return loadFlags_;
3215 }
3216 const uint32_t&
3217 loadFlags() const
3218 {
3219 return loadFlags_;
3220 }
3221
3222 uint32_t&
3223 thirdPartyFlags()
3224 {
3225 return thirdPartyFlags_;
3226 }
3227 const uint32_t&
3228 thirdPartyFlags() const
3229 {
3230 return thirdPartyFlags_;
3231 }
3232
3233 uint32_t&
3234 tlsFlags()
3235 {
3236 return tlsFlags_;
3237 }
3238 const uint32_t&
3239 tlsFlags() const
3240 {
3241 return tlsFlags_;
3242 }
3243
3244 uint32_t&
3245 cacheKey()
3246 {
3247 return cacheKey_;
3248 }
3249 const uint32_t&
3250 cacheKey() const
3251 {
3252 return cacheKey_;
3253 }
3254
3255 uint32_t&
3256 initialRwin()
3257 {
3258 return initialRwin_;
3259 }
3260 const uint32_t&
3261 initialRwin() const
3262 {
3263 return initialRwin_;
3264 }
3265
3266 uint32_t&
3267 redirectMode()
3268 {
3269 return redirectMode_;
3270 }
3271 const uint32_t&
3272 redirectMode() const
3273 {
3274 return redirectMode_;
3275 }
3276
3277 int16_t&
3278 priority()
3279 {
3280 return priority_;
3281 }
3282 const int16_t&
3283 priority() const
3284 {
3285 return priority_;
3286 }
3287
3288 bool&
3289 uploadStreamHasHeaders()
3290 {
3291 return uploadStreamHasHeaders_;
3292 }
3293 const bool&
3294 uploadStreamHasHeaders() const
3295 {
3296 return uploadStreamHasHeaders_;
3297 }
3298
3299 bool&
3300 allowSTS()
3301 {
3302 return allowSTS_;
3303 }
3304 const bool&
3305 allowSTS() const
3306 {
3307 return allowSTS_;
3308 }
3309
3310 bool&
3311 resumeAt()
3312 {
3313 return resumeAt_;
3314 }
3315 const bool&
3316 resumeAt() const
3317 {
3318 return resumeAt_;
3319 }
3320
3321 bool&
3322 allowSpdy()
3323 {
3324 return allowSpdy_;
3325 }
3326 const bool&
3327 allowSpdy() const
3328 {
3329 return allowSpdy_;
3330 }
3331
3332 bool&
3333 allowHttp3()
3334 {
3335 return allowHttp3_;
3336 }
3337 const bool&
3338 allowHttp3() const
3339 {
3340 return allowHttp3_;
3341 }
3342
3343 bool&
3344 allowAltSvc()
3345 {
3346 return allowAltSvc_;
3347 }
3348 const bool&
3349 allowAltSvc() const
3350 {
3351 return allowAltSvc_;
3352 }
3353
3354 bool&
3355 beConservative()
3356 {
3357 return beConservative_;
3358 }
3359 const bool&
3360 beConservative() const
3361 {
3362 return beConservative_;
3363 }
3364
3365 bool&
3366 bypassProxy()
3367 {
3368 return bypassProxy_;
3369 }
3370 const bool&
3371 bypassProxy() const
3372 {
3373 return bypassProxy_;
3374 }
3375
3376 bool&
3377 blockAuthPrompt()
3378 {
3379 return blockAuthPrompt_;
3380 }
3381 const bool&
3382 blockAuthPrompt() const
3383 {
3384 return blockAuthPrompt_;
3385 }
3386
3387 bool&
3388 allowStaleCacheContent()
3389 {
3390 return allowStaleCacheContent_;
3391 }
3392 const bool&
3393 allowStaleCacheContent() const
3394 {
3395 return allowStaleCacheContent_;
3396 }
3397
3398 RequestMode&
3399 requestMode()
3400 {
3401 return requestMode_;
3402 }
3403 const RequestMode&
3404 requestMode() const
3405 {
3406 return requestMode_;
3407 }
3408
3409 bool&
3410 forceValidateCacheContent()
3411 {
3412 return forceValidateCacheContent_;
3413 }
3414 const bool&
3415 forceValidateCacheContent() const
3416 {
3417 return forceValidateCacheContent_;
3418 }
3419
3420 bool&
3421 preferCacheLoadOverBypass()
3422 {
3423 return preferCacheLoadOverBypass_;
3424 }
3425 const bool&
3426 preferCacheLoadOverBypass() const
3427 {
3428 return preferCacheLoadOverBypass_;
3429 }
3430
3431 bool&
3432 forceMainDocumentChannel()
3433 {
3434 return forceMainDocumentChannel_;
3435 }
3436 const bool&
3437 forceMainDocumentChannel() const
3438 {
3439 return forceMainDocumentChannel_;
3440 }
3441
3442 uint8_t&
3443 redirectionLimit()
3444 {
3445 return redirectionLimit_;
3446 }
3447 const uint8_t&
3448 redirectionLimit() const
3449 {
3450 return redirectionLimit_;
3451 }
3452
3453 nsString&
3454 classicScriptHintCharset()
3455 {
3456 return classicScriptHintCharset_;
3457 }
3458 const nsString&
3459 classicScriptHintCharset() const
3460 {
3461 return classicScriptHintCharset_;
3462 }
3463
3464 nsString&
3465 documentCharacterSet()
3466 {
3467 return documentCharacterSet_;
3468 }
3469 const nsString&
3470 documentCharacterSet() const
3471 {
3472 return documentCharacterSet_;
3473 }
3474
3475 bool&
3476 isUserAgentHeaderModified()
3477 {
3478 return isUserAgentHeaderModified_;
3479 }
3480 const bool&
3481 isUserAgentHeaderModified() const
3482 {
3483 return isUserAgentHeaderModified_;
3484 }
3485
3486private:
3487 void
3488 StaticAssertions() const;
3489 ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> uri_;
3490 ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> original_;
3491 ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> doc_;
3492 ::mozilla::ipc::IPDLStructMember<RefPtr<nsIReferrerInfo>> referrerInfo_;
3493 ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> apiRedirectTo_;
3494 ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> topWindowURI_;
3495 ::mozilla::ipc::IPDLStructMember<RequestHeaderTuples> requestHeaders_;
3496 ::mozilla::ipc::IPDLStructMember<CopyableTArray<PreferredAlternativeDataTypeParams>> preferredAlternativeTypes_;
3497 ::mozilla::ipc::IPDLStructMember<TimeStamp> launchServiceWorkerStart_;
3498 ::mozilla::ipc::IPDLStructMember<TimeStamp> launchServiceWorkerEnd_;
3499 ::mozilla::ipc::IPDLStructMember<TimeStamp> dispatchFetchEventStart_;
3500 ::mozilla::ipc::IPDLStructMember<TimeStamp> dispatchFetchEventEnd_;
3501 ::mozilla::ipc::IPDLStructMember<TimeStamp> handleFetchEventStart_;
3502 ::mozilla::ipc::IPDLStructMember<TimeStamp> handleFetchEventEnd_;
3503 ::mozilla::ipc::IPDLStructMember<TimeStamp> navigationStartTimeStamp_;
3504 ::mozilla::ipc::IPDLStructMember<nsCString> requestMethod_;
3505 ::mozilla::ipc::IPDLStructMember<ClassOfService> classOfService_;
3506 ::mozilla::ipc::IPDLStructMember<nsCString> entityID_;
3507 ::mozilla::ipc::IPDLStructMember<nsCString> appCacheClientID_;
3508 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<CorsPreflightArgs>> preflightArgs_;
3509 ::mozilla::ipc::IPDLStructMember<nsCString> contentTypeHint_;
3510 ::mozilla::ipc::IPDLStructMember<nsString> integrityMetadata_;
3511 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCStream>> uploadStream_;
3512 ::mozilla::ipc::IPDLStructMember<LoadInfoArgs> loadInfo_;
3513 ::mozilla::ipc::IPDLStructMember<bool> uploadStreamHasHeaders_;
3514 ::mozilla::ipc::IPDLStructMember<bool> allowSTS_;
3515 ::mozilla::ipc::IPDLStructMember<bool> resumeAt_;
3516 ::mozilla::ipc::IPDLStructMember<bool> allowSpdy_;
3517 ::mozilla::ipc::IPDLStructMember<bool> allowHttp3_;
3518 ::mozilla::ipc::IPDLStructMember<bool> allowAltSvc_;
3519 ::mozilla::ipc::IPDLStructMember<bool> beConservative_;
3520 ::mozilla::ipc::IPDLStructMember<bool> bypassProxy_;
3521 ::mozilla::ipc::IPDLStructMember<bool> blockAuthPrompt_;
3522 ::mozilla::ipc::IPDLStructMember<bool> allowStaleCacheContent_;
3523 ::mozilla::ipc::IPDLStructMember<RequestMode> requestMode_;
3524 ::mozilla::ipc::IPDLStructMember<bool> forceValidateCacheContent_;
3525 ::mozilla::ipc::IPDLStructMember<bool> preferCacheLoadOverBypass_;
3526 ::mozilla::ipc::IPDLStructMember<bool> forceMainDocumentChannel_;
3527 ::mozilla::ipc::IPDLStructMember<nsString> classicScriptHintCharset_;
3528 ::mozilla::ipc::IPDLStructMember<nsString> documentCharacterSet_;
3529 ::mozilla::ipc::IPDLStructMember<bool> isUserAgentHeaderModified_;
3530 ::mozilla::ipc::IPDLStructMember<uint64_t> startPos_;
3531 ::mozilla::ipc::IPDLStructMember<uint64_t> requestContextID_;
3532 ::mozilla::ipc::IPDLStructMember<uint64_t> channelId_;
3533 ::mozilla::ipc::IPDLStructMember<uint64_t> contentWindowId_;
3534 ::mozilla::ipc::IPDLStructMember<uint64_t> browserId_;
3535 ::mozilla::ipc::IPDLStructMember<uint64_t> earlyHintPreloaderId_;
3536 ::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
3537 ::mozilla::ipc::IPDLStructMember<uint32_t> thirdPartyFlags_;
3538 ::mozilla::ipc::IPDLStructMember<uint32_t> tlsFlags_;
3539 ::mozilla::ipc::IPDLStructMember<uint32_t> cacheKey_;
3540 ::mozilla::ipc::IPDLStructMember<uint32_t> initialRwin_;
3541 ::mozilla::ipc::IPDLStructMember<uint32_t> redirectMode_;
3542 ::mozilla::ipc::IPDLStructMember<int16_t> priority_;
3543 ::mozilla::ipc::IPDLStructMember<uint8_t> redirectionLimit_;
3544};
3545} // namespace net
3546} // namespace mozilla
3547
3548namespace IPC {
3549template<>
3550struct ParamTraits <::mozilla::net::HttpChannelOpenArgs>
3551{
3552 typedef ::mozilla::net::HttpChannelOpenArgs paramType;
3553 static void
3554 Write(
3555 IPC::MessageWriter* aWriter,
3556 const paramType& aVar);
3557 static IPC::ReadResult<paramType>
3558 Read(IPC::MessageReader* aReader);
3559};
3560} // namespace IPC
3561
3562
3563//-----------------------------------------------------------------------------
3564// Declaration of the IPDL type |struct HttpChannelConnectArgs|
3565//
3566namespace mozilla {
3567namespace net {
3568class HttpChannelConnectArgs final
3569{
3570private:
3571 typedef ::uint32_t uint32_t;
3572
3573public:
3574#ifdef __clang__1
3575# pragma clang diagnostic push
3576# if __has_warning("-Wdefaulted-function-deleted")1
3577# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
3578# endif
3579#endif
3580 HttpChannelConnectArgs() = default;
3581#ifdef __clang__1
3582# pragma clang diagnostic pop
3583#endif
3584
3585 MOZ_IMPLICIT HttpChannelConnectArgs(const uint32_t& _registrarId) :
3586 registrarId_(_registrarId)
3587 {
3588 }
3589
3590 MOZ_IMPLICIT HttpChannelConnectArgs(uint32_t&& _registrarId) :
3591 registrarId_(std::move(_registrarId))
3592 {
3593 }
3594
3595 uint32_t&
3596 registrarId()
3597 {
3598 return registrarId_;
3599 }
3600 const uint32_t&
3601 registrarId() const
3602 {
3603 return registrarId_;
3604 }
3605
3606private:
3607 ::mozilla::ipc::IPDLStructMember<uint32_t> registrarId_;
3608};
3609} // namespace net
3610} // namespace mozilla
3611
3612namespace IPC {
3613template<>
3614struct ParamTraits <::mozilla::net::HttpChannelConnectArgs>
3615{
3616 typedef ::mozilla::net::HttpChannelConnectArgs paramType;
3617 static void
3618 Write(
3619 IPC::MessageWriter* aWriter,
3620 const paramType& aVar);
3621 static IPC::ReadResult<paramType>
3622 Read(IPC::MessageReader* aReader);
3623};
3624} // namespace IPC
3625
3626
3627//-----------------------------------------------------------------------------
3628// Declaration of the IPDL type |union HttpChannelCreationArgs|
3629//
3630namespace mozilla {
3631namespace net {
3632class HttpChannelCreationArgs final
3633{
3634public:
3635 enum Type {
3636 T__None,
3637 THttpChannelOpenArgs = 1,
3638 THttpChannelConnectArgs,
3639 T__Last = THttpChannelConnectArgs
3640 };
3641
3642private:
3643 typedef ::mozilla::net::HttpChannelOpenArgs HttpChannelOpenArgs;
3644 typedef ::mozilla::net::HttpChannelConnectArgs HttpChannelConnectArgs;
3645 typedef HttpChannelOpenArgs HttpChannelOpenArgs__tdef;
3646 typedef HttpChannelConnectArgs HttpChannelConnectArgs__tdef;
3647
3648 HttpChannelOpenArgs*
3649 ptr_HttpChannelOpenArgs()
3650 {
3651 return (&(mVHttpChannelOpenArgs));
3652 }
3653 const HttpChannelOpenArgs*
3654 constptr_HttpChannelOpenArgs() const
3655 {
3656 return (&(mVHttpChannelOpenArgs));
3657 }
3658 HttpChannelConnectArgs*
3659 ptr_HttpChannelConnectArgs()
3660 {
3661 return (&(mVHttpChannelConnectArgs));
3662 }
3663 const HttpChannelConnectArgs*
3664 constptr_HttpChannelConnectArgs() const
3665 {
3666 return (&(mVHttpChannelConnectArgs));
3667 }
3668
3669 void
3670 MaybeDestroy();
3671
3672 void
3673 AssertSanity() const
3674 {
3675 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" ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/net/NeckoChannelParams.h"
, 3675); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(T__None) <= (mType)"
") (" "invalid type tag" ")"); do { *((volatile int*)__null)
= 3675; __attribute__((nomerge)) ::abort(); } while (false);
} } while (false)
;
3676 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" ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/net/NeckoChannelParams.h"
, 3676); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(mType) <= (T__Last)"
") (" "invalid type tag" ")"); do { *((volatile int*)__null)
= 3676; __attribute__((nomerge)) ::abort(); } while (false);
} } while (false)
;
3677 }
3678 void
3679 AssertSanity(Type aType) const
3680 {
3681 AssertSanity();
3682 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" ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/net/NeckoChannelParams.h"
, 3682); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(mType) == (aType)"
") (" "unexpected type tag" ")"); do { *((volatile int*)__null
) = 3682; __attribute__((nomerge)) ::abort(); } while (false)
; } } while (false)
;
3683 }
3684
3685public:
3686 MOZ_IMPLICIT HttpChannelCreationArgs() :
3687 mType(T__None)
3688 {
3689 }
3690
3691 MOZ_IMPLICIT HttpChannelCreationArgs(const HttpChannelOpenArgs& aOther);
3692
3693 MOZ_IMPLICIT HttpChannelCreationArgs(HttpChannelOpenArgs&& aOther);
3694
3695 MOZ_IMPLICIT HttpChannelCreationArgs(const HttpChannelConnectArgs& aOther);
3696
3697 MOZ_IMPLICIT HttpChannelCreationArgs(HttpChannelConnectArgs&& aOther);
3698
3699 MOZ_IMPLICIT HttpChannelCreationArgs(const HttpChannelCreationArgs& aOther);
3700
3701 MOZ_IMPLICIT HttpChannelCreationArgs(HttpChannelCreationArgs&& aOther);
3702
3703 ~HttpChannelCreationArgs();
3704
3705 Type
3706 type() const
3707 {
3708 return mType;
3709 }
3710
3711 HttpChannelCreationArgs&
3712 operator=(const HttpChannelOpenArgs& aRhs);
3713
3714 HttpChannelCreationArgs&
3715 operator=(HttpChannelOpenArgs&& aRhs);
3716
3717 HttpChannelCreationArgs&
3718 operator=(const HttpChannelConnectArgs& aRhs);
3719
3720 HttpChannelCreationArgs&
3721 operator=(HttpChannelConnectArgs&& aRhs);
3722
3723 HttpChannelCreationArgs&
3724 operator=(const HttpChannelCreationArgs& aRhs);
3725
3726 HttpChannelCreationArgs&
3727 operator=(HttpChannelCreationArgs&& aRhs);
3728
3729 HttpChannelOpenArgs&
3730 get_HttpChannelOpenArgs()
3731 {
3732 AssertSanity(THttpChannelOpenArgs);
3733 return (*(ptr_HttpChannelOpenArgs()));
3734 }
3735 const HttpChannelOpenArgs&
3736 get_HttpChannelOpenArgs() const
3737 {
3738 AssertSanity(THttpChannelOpenArgs);
3739 return (*(constptr_HttpChannelOpenArgs()));
3740 }
3741 operator HttpChannelOpenArgs&()
3742 {
3743 return get_HttpChannelOpenArgs();
3744 }
3745 operator const HttpChannelOpenArgs&() const
3746 {
3747 return get_HttpChannelOpenArgs();
3748 }
3749
3750 HttpChannelConnectArgs&
3751 get_HttpChannelConnectArgs()
3752 {
3753 AssertSanity(THttpChannelConnectArgs);
3754 return (*(ptr_HttpChannelConnectArgs()));
3755 }
3756 const HttpChannelConnectArgs&
3757 get_HttpChannelConnectArgs() const
3758 {
3759 AssertSanity(THttpChannelConnectArgs);
3760 return (*(constptr_HttpChannelConnectArgs()));
3761 }
3762 operator HttpChannelConnectArgs&()
3763 {
3764 return get_HttpChannelConnectArgs();
3765 }
3766 operator const HttpChannelConnectArgs&() const
3767 {
3768 return get_HttpChannelConnectArgs();
3769 }
3770
3771private:
3772 union {
3773 HttpChannelOpenArgs mVHttpChannelOpenArgs;
3774 HttpChannelConnectArgs mVHttpChannelConnectArgs;
3775 };
3776 Type mType;
3777};
3778} // namespace net
3779} // namespace mozilla
3780
3781namespace IPC {
3782template<>
3783struct ParamTraits <::mozilla::net::HttpChannelCreationArgs>
3784{
3785 typedef ::mozilla::net::HttpChannelCreationArgs paramType;
3786 static void
3787 Write(
3788 IPC::MessageWriter* aWriter,
3789 const paramType& aVar);
3790 static IPC::ReadResult<paramType>
3791 Read(IPC::MessageReader* aReader);
3792};
3793} // namespace IPC
3794
3795
3796//-----------------------------------------------------------------------------
3797// Declaration of the IPDL type |struct ProxyInfoCloneArgs|
3798//
3799namespace mozilla {
3800namespace net {
3801class ProxyInfoCloneArgs final
3802{
3803private:
3804 typedef ::nsCString nsCString;
3805 typedef ::int32_t int32_t;
3806 typedef ::uint32_t uint32_t;
3807
3808public:
3809#ifdef __clang__1
3810# pragma clang diagnostic push
3811# if __has_warning("-Wdefaulted-function-deleted")1
3812# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
3813# endif
3814#endif
3815 ProxyInfoCloneArgs() = default;
3816#ifdef __clang__1
3817# pragma clang diagnostic pop
3818#endif
3819
3820 MOZ_IMPLICIT ProxyInfoCloneArgs(
3821 const nsCString& _type,
3822 const nsCString& _host,
3823 const int32_t& _port,
3824 const nsCString& _username,
3825 const nsCString& _password,
3826 const uint32_t& _flags,
3827 const uint32_t& _timeout,
3828 const uint32_t& _resolveFlags,
3829 const nsCString& _proxyAuthorizationHeader,
3830 const nsCString& _connectionIsolationKey) :
3831 type_(_type),
3832 host_(_host),
3833 username_(_username),
3834 password_(_password),
3835 proxyAuthorizationHeader_(_proxyAuthorizationHeader),
3836 connectionIsolationKey_(_connectionIsolationKey),
3837 port_(_port),
3838 flags_(_flags),
3839 timeout_(_timeout),
3840 resolveFlags_(_resolveFlags)
3841 {
3842 }
3843
3844 MOZ_IMPLICIT ProxyInfoCloneArgs(
3845 nsCString&& _type,
3846 nsCString&& _host,
3847 int32_t&& _port,
3848 nsCString&& _username,
3849 nsCString&& _password,
3850 uint32_t&& _flags,
3851 uint32_t&& _timeout,
3852 uint32_t&& _resolveFlags,
3853 nsCString&& _proxyAuthorizationHeader,
3854 nsCString&& _connectionIsolationKey) :
3855 type_(std::move(_type)),
3856 host_(std::move(_host)),
3857 username_(std::move(_username)),
3858 password_(std::move(_password)),
3859 proxyAuthorizationHeader_(std::move(_proxyAuthorizationHeader)),
3860 connectionIsolationKey_(std::move(_connectionIsolationKey)),
3861 port_(std::move(_port)),
3862 flags_(std::move(_flags)),
3863 timeout_(std::move(_timeout)),
3864 resolveFlags_(std::move(_resolveFlags))
3865 {
3866 }
3867
3868 nsCString&
3869 type()
3870 {
3871 return type_;
3872 }
3873 const nsCString&
3874 type() const
3875 {
3876 return type_;
3877 }
3878
3879 nsCString&
3880 host()
3881 {
3882 return host_;
3883 }
3884 const nsCString&
3885 host() const
3886 {
3887 return host_;
3888 }
3889
3890 int32_t&
3891 port()
3892 {
3893 return port_;
3894 }
3895 const int32_t&
3896 port() const
3897 {
3898 return port_;
3899 }
3900
3901 nsCString&
3902 username()
3903 {
3904 return username_;
3905 }
3906 const nsCString&
3907 username() const
3908 {
3909 return username_;
3910 }
3911
3912 nsCString&
3913 password()
3914 {
3915 return password_;
3916 }
3917 const nsCString&
3918 password() const
3919 {
3920 return password_;
3921 }
3922
3923 uint32_t&
3924 flags()
3925 {
3926 return flags_;
3927 }
3928 const uint32_t&
3929 flags() const
3930 {
3931 return flags_;
3932 }
3933
3934 uint32_t&
3935 timeout()
3936 {
3937 return timeout_;
3938 }
3939 const uint32_t&
3940 timeout() const
3941 {
3942 return timeout_;
3943 }
3944
3945 uint32_t&
3946 resolveFlags()
3947 {
3948 return resolveFlags_;
3949 }
3950 const uint32_t&
3951 resolveFlags() const
3952 {
3953 return resolveFlags_;
3954 }
3955
3956 nsCString&
3957 proxyAuthorizationHeader()
3958 {
3959 return proxyAuthorizationHeader_;
3960 }
3961 const nsCString&
3962 proxyAuthorizationHeader() const
3963 {
3964 return proxyAuthorizationHeader_;
3965 }
3966
3967 nsCString&
3968 connectionIsolationKey()
3969 {
3970 return connectionIsolationKey_;
3971 }
3972 const nsCString&
3973 connectionIsolationKey() const
3974 {
3975 return connectionIsolationKey_;
3976 }
3977
3978private:
3979 void
3980 StaticAssertions() const;
3981 ::mozilla::ipc::IPDLStructMember<nsCString> type_;
3982 ::mozilla::ipc::IPDLStructMember<nsCString> host_;
3983 ::mozilla::ipc::IPDLStructMember<nsCString> username_;
3984 ::mozilla::ipc::IPDLStructMember<nsCString> password_;
3985 ::mozilla::ipc::IPDLStructMember<nsCString> proxyAuthorizationHeader_;
3986 ::mozilla::ipc::IPDLStructMember<nsCString> connectionIsolationKey_;
3987 ::mozilla::ipc::IPDLStructMember<int32_t> port_;
3988 ::mozilla::ipc::IPDLStructMember<uint32_t> flags_;
3989 ::mozilla::ipc::IPDLStructMember<uint32_t> timeout_;
3990 ::mozilla::ipc::IPDLStructMember<uint32_t> resolveFlags_;
3991};
3992} // namespace net
3993} // namespace mozilla
3994
3995namespace IPC {
3996template<>
3997struct ParamTraits <::mozilla::net::ProxyInfoCloneArgs>
3998{
3999 typedef ::mozilla::net::ProxyInfoCloneArgs paramType;
4000 static void
4001 Write(
4002 IPC::MessageWriter* aWriter,
4003 const paramType& aVar);
4004 static IPC::ReadResult<paramType>
4005 Read(IPC::MessageReader* aReader);
4006};
4007} // namespace IPC
4008
4009
4010//-----------------------------------------------------------------------------
4011// Declaration of the IPDL type |struct HttpConnectionInfoCloneArgs|
4012//
4013namespace mozilla {
4014namespace net {
4015class HttpConnectionInfoCloneArgs final
4016{
4017private:
4018 typedef ::nsCString nsCString;
4019 typedef ::int32_t int32_t;
4020 typedef ::mozilla::OriginAttributes OriginAttributes;
4021 typedef ::uint32_t uint32_t;
4022 typedef ::uint8_t uint8_t;
4023 typedef ::uint64_t uint64_t;
4024 typedef ::mozilla::net::ProxyInfoCloneArgs ProxyInfoCloneArgs;
4025
4026public:
4027#ifdef __clang__1
4028# pragma clang diagnostic push
4029# if __has_warning("-Wdefaulted-function-deleted")1
4030# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
4031# endif
4032#endif
4033 HttpConnectionInfoCloneArgs() = default;
4034#ifdef __clang__1
4035# pragma clang diagnostic pop
4036#endif
4037
4038 MOZ_IMPLICIT HttpConnectionInfoCloneArgs(
4039 const nsCString& _host,
4040 const int32_t& _port,
4041 const nsCString& _npnToken,
4042 const nsCString& _username,
4043 const OriginAttributes& _originAttributes,
4044 const bool& _endToEndSSL,
4045 const nsCString& _routedHost,
4046 const int32_t& _routedPort,
4047 const bool& _anonymous,
4048 const bool& _aPrivate,
4049 const bool& _insecureScheme,
4050 const bool& _noSpdy,
4051 const bool& _beConservative,
4052 const bool& _bypassProxy,
4053 const bool& _anonymousAllowClientCert,
4054 const bool& _fallbackConnection,
4055 const uint32_t& _tlsFlags,
4056 const bool& _isolated,
4057 const bool& _isTrrServiceChannel,
4058 const uint8_t& _trrMode,
4059 const bool& _isIPv4Disabled,
4060 const bool& _isIPv6Disabled,
4061 const nsCString& _topWindowOrigin,
4062 const bool& _isHttp3,
4063 const bool& _webTransport,
4064 const uint64_t& _webTransportId,
4065 const bool& _hasIPHintAddress,
4066 const nsCString& _echConfig,
4067 const nsTArray<ProxyInfoCloneArgs>& _proxyInfo) :
4068 host_(_host),
4069 npnToken_(_npnToken),
4070 username_(_username),
4071 originAttributes_(_originAttributes),
4072 endToEndSSL_(_endToEndSSL),
4073 routedHost_(_routedHost),
4074 anonymous_(_anonymous),
4075 aPrivate_(_aPrivate),
4076 insecureScheme_(_insecureScheme),
4077 noSpdy_(_noSpdy),
4078 beConservative_(_beConservative),
4079 bypassProxy_(_bypassProxy),
4080 anonymousAllowClientCert_(_anonymousAllowClientCert),
4081 fallbackConnection_(_fallbackConnection),
4082 isolated_(_isolated),
4083 isTrrServiceChannel_(_isTrrServiceChannel),
4084 isIPv4Disabled_(_isIPv4Disabled),
4085 isIPv6Disabled_(_isIPv6Disabled),
4086 topWindowOrigin_(_topWindowOrigin),
4087 isHttp3_(_isHttp3),
4088 webTransport_(_webTransport),
4089 hasIPHintAddress_(_hasIPHintAddress),
4090 echConfig_(_echConfig),
4091 proxyInfo_(_proxyInfo),
4092 webTransportId_(_webTransportId),
4093 port_(_port),
4094 routedPort_(_routedPort),
4095 tlsFlags_(_tlsFlags),
4096 trrMode_(_trrMode)
4097 {
4098 }
4099
4100 MOZ_IMPLICIT HttpConnectionInfoCloneArgs(
4101 nsCString&& _host,
4102 int32_t&& _port,
4103 nsCString&& _npnToken,
4104 nsCString&& _username,
4105 OriginAttributes&& _originAttributes,
4106 bool&& _endToEndSSL,
4107 nsCString&& _routedHost,
4108 int32_t&& _routedPort,
4109 bool&& _anonymous,
4110 bool&& _aPrivate,
4111 bool&& _insecureScheme,
4112 bool&& _noSpdy,
4113 bool&& _beConservative,
4114 bool&& _bypassProxy,
4115 bool&& _anonymousAllowClientCert,
4116 bool&& _fallbackConnection,
4117 uint32_t&& _tlsFlags,
4118 bool&& _isolated,
4119 bool&& _isTrrServiceChannel,
4120 uint8_t&& _trrMode,
4121 bool&& _isIPv4Disabled,
4122 bool&& _isIPv6Disabled,
4123 nsCString&& _topWindowOrigin,
4124 bool&& _isHttp3,
4125 bool&& _webTransport,
4126 uint64_t&& _webTransportId,
4127 bool&& _hasIPHintAddress,
4128 nsCString&& _echConfig,
4129 nsTArray<ProxyInfoCloneArgs>&& _proxyInfo) :
4130 host_(std::move(_host)),
4131 npnToken_(std::move(_npnToken)),
4132 username_(std::move(_username)),
4133 originAttributes_(std::move(_originAttributes)),
4134 endToEndSSL_(std::move(_endToEndSSL)),
4135 routedHost_(std::move(_routedHost)),
4136 anonymous_(std::move(_anonymous)),
4137 aPrivate_(std::move(_aPrivate)),
4138 insecureScheme_(std::move(_insecureScheme)),
4139 noSpdy_(std::move(_noSpdy)),
4140 beConservative_(std::move(_beConservative)),
4141 bypassProxy_(std::move(_bypassProxy)),
4142 anonymousAllowClientCert_(std::move(_anonymousAllowClientCert)),
4143 fallbackConnection_(std::move(_fallbackConnection)),
4144 isolated_(std::move(_isolated)),
4145 isTrrServiceChannel_(std::move(_isTrrServiceChannel)),
4146 isIPv4Disabled_(std::move(_isIPv4Disabled)),
4147 isIPv6Disabled_(std::move(_isIPv6Disabled)),
4148 topWindowOrigin_(std::move(_topWindowOrigin)),
4149 isHttp3_(std::move(_isHttp3)),
4150 webTransport_(std::move(_webTransport)),
4151 hasIPHintAddress_(std::move(_hasIPHintAddress)),
4152 echConfig_(std::move(_echConfig)),
4153 proxyInfo_(std::move(_proxyInfo)),
4154 webTransportId_(std::move(_webTransportId)),
4155 port_(std::move(_port)),
4156 routedPort_(std::move(_routedPort)),
4157 tlsFlags_(std::move(_tlsFlags)),
4158 trrMode_(std::move(_trrMode))
4159 {
4160 }
4161
4162 nsCString&
4163 host()
4164 {
4165 return host_;
4166 }
4167 const nsCString&
4168 host() const
4169 {
4170 return host_;
4171 }
4172
4173 int32_t&
4174 port()
4175 {
4176 return port_;
4177 }
4178 const int32_t&
4179 port() const
4180 {
4181 return port_;
4182 }
4183
4184 nsCString&
4185 npnToken()
4186 {
4187 return npnToken_;
4188 }
4189 const nsCString&
4190 npnToken() const
4191 {
4192 return npnToken_;
4193 }
4194
4195 nsCString&
4196 username()
4197 {
4198 return username_;
4199 }
4200 const nsCString&
4201 username() const
4202 {
4203 return username_;
4204 }
4205
4206 OriginAttributes&
4207 originAttributes()
4208 {
4209 return originAttributes_;
4210 }
4211 const OriginAttributes&
4212 originAttributes() const
4213 {
4214 return originAttributes_;
4215 }
4216
4217 bool&
4218 endToEndSSL()
4219 {
4220 return endToEndSSL_;
4221 }
4222 const bool&
4223 endToEndSSL() const
4224 {
4225 return endToEndSSL_;
4226 }
4227
4228 nsCString&
4229 routedHost()
4230 {
4231 return routedHost_;
4232 }
4233 const nsCString&
4234 routedHost() const
4235 {
4236 return routedHost_;
4237 }
4238
4239 int32_t&
4240 routedPort()
4241 {
4242 return routedPort_;
4243 }
4244 const int32_t&
4245 routedPort() const
4246 {
4247 return routedPort_;
4248 }
4249
4250 bool&
4251 anonymous()
4252 {
4253 return anonymous_;
4254 }
4255 const bool&
4256 anonymous() const
4257 {
4258 return anonymous_;
4259 }
4260
4261 bool&
4262 aPrivate()
4263 {
4264 return aPrivate_;
4265 }
4266 const bool&
4267 aPrivate() const
4268 {
4269 return aPrivate_;
4270 }
4271
4272 bool&
4273 insecureScheme()
4274 {
4275 return insecureScheme_;
4276 }
4277 const bool&
4278 insecureScheme() const
4279 {
4280 return insecureScheme_;
4281 }
4282
4283 bool&
4284 noSpdy()
4285 {
4286 return noSpdy_;
4287 }
4288 const bool&
4289 noSpdy() const
4290 {
4291 return noSpdy_;
4292 }
4293
4294 bool&
4295 beConservative()
4296 {
4297 return beConservative_;
4298 }
4299 const bool&
4300 beConservative() const
4301 {
4302 return beConservative_;
4303 }
4304
4305 bool&
4306 bypassProxy()
4307 {
4308 return bypassProxy_;
4309 }
4310 const bool&
4311 bypassProxy() const
4312 {
4313 return bypassProxy_;
4314 }
4315
4316 bool&
4317 anonymousAllowClientCert()
4318 {
4319 return anonymousAllowClientCert_;
4320 }
4321 const bool&
4322 anonymousAllowClientCert() const
4323 {
4324 return anonymousAllowClientCert_;
4325 }
4326
4327 bool&
4328 fallbackConnection()
4329 {
4330 return fallbackConnection_;
4331 }
4332 const bool&
4333 fallbackConnection() const
4334 {
4335 return fallbackConnection_;
4336 }
4337
4338 uint32_t&
4339 tlsFlags()
4340 {
4341 return tlsFlags_;
4342 }
4343 const uint32_t&
4344 tlsFlags() const
4345 {
4346 return tlsFlags_;
4347 }
4348
4349 bool&
4350 isolated()
4351 {
4352 return isolated_;
4353 }
4354 const bool&
4355 isolated() const
4356 {
4357 return isolated_;
4358 }
4359
4360 bool&
4361 isTrrServiceChannel()
4362 {
4363 return isTrrServiceChannel_;
4364 }
4365 const bool&
4366 isTrrServiceChannel() const
4367 {
4368 return isTrrServiceChannel_;
4369 }
4370
4371 uint8_t&
4372 trrMode()
4373 {
4374 return trrMode_;
4375 }
4376 const uint8_t&
4377 trrMode() const
4378 {
4379 return trrMode_;
4380 }
4381
4382 bool&
4383 isIPv4Disabled()
4384 {
4385 return isIPv4Disabled_;
4386 }
4387 const bool&
4388 isIPv4Disabled() const
4389 {
4390 return isIPv4Disabled_;
4391 }
4392
4393 bool&
4394 isIPv6Disabled()
4395 {
4396 return isIPv6Disabled_;
4397 }
4398 const bool&
4399 isIPv6Disabled() const
4400 {
4401 return isIPv6Disabled_;
4402 }
4403
4404 nsCString&
4405 topWindowOrigin()
4406 {
4407 return topWindowOrigin_;
4408 }
4409 const nsCString&
4410 topWindowOrigin() const
4411 {
4412 return topWindowOrigin_;
4413 }
4414
4415 bool&
4416 isHttp3()
4417 {
4418 return isHttp3_;
4419 }
4420 const bool&
4421 isHttp3() const
4422 {
4423 return isHttp3_;
4424 }
4425
4426 bool&
4427 webTransport()
4428 {
4429 return webTransport_;
4430 }
4431 const bool&
4432 webTransport() const
4433 {
4434 return webTransport_;
4435 }
4436
4437 uint64_t&
4438 webTransportId()
4439 {
4440 return webTransportId_;
4441 }
4442 const uint64_t&
4443 webTransportId() const
4444 {
4445 return webTransportId_;
4446 }
4447
4448 bool&
4449 hasIPHintAddress()
4450 {
4451 return hasIPHintAddress_;
4452 }
4453 const bool&
4454 hasIPHintAddress() const
4455 {
4456 return hasIPHintAddress_;
4457 }
4458
4459 nsCString&
4460 echConfig()
4461 {
4462 return echConfig_;
4463 }
4464 const nsCString&
4465 echConfig() const
4466 {
4467 return echConfig_;
4468 }
4469
4470 nsTArray<ProxyInfoCloneArgs>&
4471 proxyInfo()
4472 {
4473 return proxyInfo_;
4474 }
4475 const nsTArray<ProxyInfoCloneArgs>&
4476 proxyInfo() const
4477 {
4478 return proxyInfo_;
4479 }
4480
4481private:
4482 void
4483 StaticAssertions() const;
4484 ::mozilla::ipc::IPDLStructMember<nsCString> host_;
4485 ::mozilla::ipc::IPDLStructMember<nsCString> npnToken_;
4486 ::mozilla::ipc::IPDLStructMember<nsCString> username_;
4487 ::mozilla::ipc::IPDLStructMember<OriginAttributes> originAttributes_;
4488 ::mozilla::ipc::IPDLStructMember<bool> endToEndSSL_;
4489 ::mozilla::ipc::IPDLStructMember<nsCString> routedHost_;
4490 ::mozilla::ipc::IPDLStructMember<bool> anonymous_;
4491 ::mozilla::ipc::IPDLStructMember<bool> aPrivate_;
4492 ::mozilla::ipc::IPDLStructMember<bool> insecureScheme_;
4493 ::mozilla::ipc::IPDLStructMember<bool> noSpdy_;
4494 ::mozilla::ipc::IPDLStructMember<bool> beConservative_;
4495 ::mozilla::ipc::IPDLStructMember<bool> bypassProxy_;
4496 ::mozilla::ipc::IPDLStructMember<bool> anonymousAllowClientCert_;
4497 ::mozilla::ipc::IPDLStructMember<bool> fallbackConnection_;
4498 ::mozilla::ipc::IPDLStructMember<bool> isolated_;
4499 ::mozilla::ipc::IPDLStructMember<bool> isTrrServiceChannel_;
4500 ::mozilla::ipc::IPDLStructMember<bool> isIPv4Disabled_;
4501 ::mozilla::ipc::IPDLStructMember<bool> isIPv6Disabled_;
4502 ::mozilla::ipc::IPDLStructMember<nsCString> topWindowOrigin_;
4503 ::mozilla::ipc::IPDLStructMember<bool> isHttp3_;
4504 ::mozilla::ipc::IPDLStructMember<bool> webTransport_;
4505 ::mozilla::ipc::IPDLStructMember<bool> hasIPHintAddress_;
4506 ::mozilla::ipc::IPDLStructMember<nsCString> echConfig_;
4507 ::mozilla::ipc::IPDLStructMember<CopyableTArray<ProxyInfoCloneArgs>> proxyInfo_;
4508 ::mozilla::ipc::IPDLStructMember<uint64_t> webTransportId_;
4509 ::mozilla::ipc::IPDLStructMember<int32_t> port_;
4510 ::mozilla::ipc::IPDLStructMember<int32_t> routedPort_;
4511 ::mozilla::ipc::IPDLStructMember<uint32_t> tlsFlags_;
4512 ::mozilla::ipc::IPDLStructMember<uint8_t> trrMode_;
4513};
4514} // namespace net
4515} // namespace mozilla
4516
4517namespace IPC {
4518template<>
4519struct ParamTraits <::mozilla::net::HttpConnectionInfoCloneArgs>
4520{
4521 typedef ::mozilla::net::HttpConnectionInfoCloneArgs paramType;
4522 static void
4523 Write(
4524 IPC::MessageWriter* aWriter,
4525 const paramType& aVar);
4526 static IPC::ReadResult<paramType>
4527 Read(IPC::MessageReader* aReader);
4528};
4529} // namespace IPC
4530
4531
4532//-----------------------------------------------------------------------------
4533// Declaration of the IPDL type |struct ConsoleReportCollected|
4534//
4535namespace mozilla {
4536namespace net {
4537class ConsoleReportCollected final
4538{
4539private:
4540 typedef ::uint32_t uint32_t;
4541 typedef ::nsCString nsCString;
4542 typedef ::nsString nsString;
4543
4544public:
4545#ifdef __clang__1
4546# pragma clang diagnostic push
4547# if __has_warning("-Wdefaulted-function-deleted")1
4548# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
4549# endif
4550#endif
4551 ConsoleReportCollected() = default;
4552#ifdef __clang__1
4553# pragma clang diagnostic pop
4554#endif
4555
4556 MOZ_IMPLICIT ConsoleReportCollected(
4557 const uint32_t& _errorFlags,
4558 const nsCString& _category,
4559 const uint32_t& _propertiesFile,
4560 const nsCString& _sourceFileURI,
4561 const uint32_t& _lineNumber,
4562 const uint32_t& _columnNumber,
4563 const nsCString& _messageName,
4564 const nsTArray<nsString>& _stringParams) :
4565 category_(_category),
4566 sourceFileURI_(_sourceFileURI),
4567 messageName_(_messageName),
4568 stringParams_(_stringParams),
4569 errorFlags_(_errorFlags),
4570 propertiesFile_(_propertiesFile),
4571 lineNumber_(_lineNumber),
4572 columnNumber_(_columnNumber)
4573 {
4574 }
4575
4576 MOZ_IMPLICIT ConsoleReportCollected(
4577 uint32_t&& _errorFlags,
4578 nsCString&& _category,
4579 uint32_t&& _propertiesFile,
4580 nsCString&& _sourceFileURI,
4581 uint32_t&& _lineNumber,
4582 uint32_t&& _columnNumber,
4583 nsCString&& _messageName,
4584 nsTArray<nsString>&& _stringParams) :
4585 category_(std::move(_category)),
4586 sourceFileURI_(std::move(_sourceFileURI)),
4587 messageName_(std::move(_messageName)),
4588 stringParams_(std::move(_stringParams)),
4589 errorFlags_(std::move(_errorFlags)),
4590 propertiesFile_(std::move(_propertiesFile)),
4591 lineNumber_(std::move(_lineNumber)),
4592 columnNumber_(std::move(_columnNumber))
4593 {
4594 }
4595
4596 uint32_t&
4597 errorFlags()
4598 {
4599 return errorFlags_;
4600 }
4601 const uint32_t&
4602 errorFlags() const
4603 {
4604 return errorFlags_;
4605 }
4606
4607 nsCString&
4608 category()
4609 {
4610 return category_;
4611 }
4612 const nsCString&
4613 category() const
4614 {
4615 return category_;
4616 }
4617
4618 uint32_t&
4619 propertiesFile()
4620 {
4621 return propertiesFile_;
4622 }
4623 const uint32_t&
4624 propertiesFile() const
4625 {
4626 return propertiesFile_;
4627 }
4628
4629 nsCString&
4630 sourceFileURI()
4631 {
4632 return sourceFileURI_;
4633 }
4634 const nsCString&
4635 sourceFileURI() const
4636 {
4637 return sourceFileURI_;
4638 }
4639
4640 uint32_t&
4641 lineNumber()
4642 {
4643 return lineNumber_;
4644 }
4645 const uint32_t&
4646 lineNumber() const
4647 {
4648 return lineNumber_;
4649 }
4650
4651 uint32_t&
4652 columnNumber()
4653 {
4654 return columnNumber_;
4655 }
4656 const uint32_t&
4657 columnNumber() const
4658 {
4659 return columnNumber_;
4660 }
4661
4662 nsCString&
4663 messageName()
4664 {
4665 return messageName_;
4666 }
4667 const nsCString&
4668 messageName() const
4669 {
4670 return messageName_;
4671 }
4672
4673 nsTArray<nsString>&
4674 stringParams()
4675 {
4676 return stringParams_;
4677 }
4678 const nsTArray<nsString>&
4679 stringParams() const
4680 {
4681 return stringParams_;
4682 }
4683
4684private:
4685 void
4686 StaticAssertions() const;
4687 ::mozilla::ipc::IPDLStructMember<nsCString> category_;
4688 ::mozilla::ipc::IPDLStructMember<nsCString> sourceFileURI_;
4689 ::mozilla::ipc::IPDLStructMember<nsCString> messageName_;
4690 ::mozilla::ipc::IPDLStructMember<CopyableTArray<nsString>> stringParams_;
4691 ::mozilla::ipc::IPDLStructMember<uint32_t> errorFlags_;
4692 ::mozilla::ipc::IPDLStructMember<uint32_t> propertiesFile_;
4693 ::mozilla::ipc::IPDLStructMember<uint32_t> lineNumber_;
4694 ::mozilla::ipc::IPDLStructMember<uint32_t> columnNumber_;
4695};
4696} // namespace net
4697} // namespace mozilla
4698
4699namespace IPC {
4700template<>
4701struct ParamTraits <::mozilla::net::ConsoleReportCollected>
4702{
4703 typedef ::mozilla::net::ConsoleReportCollected paramType;
4704 static void
4705 Write(
4706 IPC::MessageWriter* aWriter,
4707 const paramType& aVar);
4708 static IPC::ReadResult<paramType>
4709 Read(IPC::MessageReader* aReader);
4710};
4711} // namespace IPC
4712
4713
4714//-----------------------------------------------------------------------------
4715// Declaration of the IPDL type |struct CookieStruct|
4716//
4717namespace mozilla {
4718namespace net {
4719class CookieStruct final
4720{
4721private:
4722 typedef ::nsCString nsCString;
4723 typedef ::int64_t int64_t;
4724 typedef ::int32_t int32_t;
4725 typedef ::uint8_t uint8_t;
4726
4727public:
4728#ifdef __clang__1
4729# pragma clang diagnostic push
4730# if __has_warning("-Wdefaulted-function-deleted")1
4731# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
4732# endif
4733#endif
4734 CookieStruct() = default;
4735#ifdef __clang__1
4736# pragma clang diagnostic pop
4737#endif
4738
4739 MOZ_IMPLICIT CookieStruct(
4740 const nsCString& _name,
4741 const nsCString& _value,
4742 const nsCString& _host,
4743 const nsCString& _path,
4744 const int64_t& _expiry,
4745 const int64_t& _lastAccessed,
4746 const int64_t& _creationTime,
4747 const bool& _isHttpOnly,
4748 const bool& _isSession,
4749 const bool& _isSecure,
4750 const bool& _isPartitioned,
4751 const int32_t& _sameSite,
4752 const int32_t& _rawSameSite,
4753 const uint8_t& _schemeMap) :
4754 name_(_name),
4755 value_(_value),
4756 host_(_host),
4757 path_(_path),
4758 isHttpOnly_(_isHttpOnly),
4759 isSession_(_isSession),
4760 isSecure_(_isSecure),
4761 isPartitioned_(_isPartitioned),
4762 expiry_(_expiry),
4763 lastAccessed_(_lastAccessed),
4764 creationTime_(_creationTime),
4765 sameSite_(_sameSite),
4766 rawSameSite_(_rawSameSite),
4767 schemeMap_(_schemeMap)
4768 {
4769 }
4770
4771 MOZ_IMPLICIT CookieStruct(
4772 nsCString&& _name,
4773 nsCString&& _value,
4774 nsCString&& _host,
4775 nsCString&& _path,
4776 int64_t&& _expiry,
4777 int64_t&& _lastAccessed,
4778 int64_t&& _creationTime,
4779 bool&& _isHttpOnly,
4780 bool&& _isSession,
4781 bool&& _isSecure,
4782 bool&& _isPartitioned,
4783 int32_t&& _sameSite,
4784 int32_t&& _rawSameSite,
4785 uint8_t&& _schemeMap) :
4786 name_(std::move(_name)),
4787 value_(std::move(_value)),
4788 host_(std::move(_host)),
4789 path_(std::move(_path)),
4790 isHttpOnly_(std::move(_isHttpOnly)),
4791 isSession_(std::move(_isSession)),
4792 isSecure_(std::move(_isSecure)),
4793 isPartitioned_(std::move(_isPartitioned)),
4794 expiry_(std::move(_expiry)),
4795 lastAccessed_(std::move(_lastAccessed)),
4796 creationTime_(std::move(_creationTime)),
4797 sameSite_(std::move(_sameSite)),
4798 rawSameSite_(std::move(_rawSameSite)),
4799 schemeMap_(std::move(_schemeMap))
4800 {
4801 }
4802
4803 nsCString&
4804 name()
4805 {
4806 return name_;
4807 }
4808 const nsCString&
4809 name() const
4810 {
4811 return name_;
4812 }
4813
4814 nsCString&
4815 value()
4816 {
4817 return value_;
4818 }
4819 const nsCString&
4820 value() const
4821 {
4822 return value_;
4823 }
4824
4825 nsCString&
4826 host()
4827 {
4828 return host_;
4829 }
4830 const nsCString&
4831 host() const
4832 {
4833 return host_;
4834 }
4835
4836 nsCString&
4837 path()
4838 {
4839 return path_;
4840 }
4841 const nsCString&
4842 path() const
4843 {
4844 return path_;
4845 }
4846
4847 int64_t&
4848 expiry()
4849 {
4850 return expiry_;
4851 }
4852 const int64_t&
4853 expiry() const
4854 {
4855 return expiry_;
4856 }
4857
4858 int64_t&
4859 lastAccessed()
4860 {
4861 return lastAccessed_;
4862 }
4863 const int64_t&
4864 lastAccessed() const
4865 {
4866 return lastAccessed_;
4867 }
4868
4869 int64_t&
4870 creationTime()
4871 {
4872 return creationTime_;
4873 }
4874 const int64_t&
4875 creationTime() const
4876 {
4877 return creationTime_;
4878 }
4879
4880 bool&
4881 isHttpOnly()
4882 {
4883 return isHttpOnly_;
4884 }
4885 const bool&
4886 isHttpOnly() const
4887 {
4888 return isHttpOnly_;
4889 }
4890
4891 bool&
4892 isSession()
4893 {
4894 return isSession_;
4895 }
4896 const bool&
4897 isSession() const
4898 {
4899 return isSession_;
4900 }
4901
4902 bool&
4903 isSecure()
4904 {
4905 return isSecure_;
4906 }
4907 const bool&
4908 isSecure() const
4909 {
4910 return isSecure_;
4911 }
4912
4913 bool&
4914 isPartitioned()
4915 {
4916 return isPartitioned_;
4917 }
4918 const bool&
4919 isPartitioned() const
4920 {
4921 return isPartitioned_;
4922 }
4923
4924 int32_t&
4925 sameSite()
4926 {
4927 return sameSite_;
4928 }
4929 const int32_t&
4930 sameSite() const
4931 {
4932 return sameSite_;
4933 }
4934
4935 int32_t&
4936 rawSameSite()
4937 {
4938 return rawSameSite_;
4939 }
4940 const int32_t&
4941 rawSameSite() const
4942 {
4943 return rawSameSite_;
4944 }
4945
4946 uint8_t&
4947 schemeMap()
4948 {
4949 return schemeMap_;
4950 }
4951 const uint8_t&
4952 schemeMap() const
4953 {
4954 return schemeMap_;
4955 }
4956
4957private:
4958 void
4959 StaticAssertions() const;
4960 ::mozilla::ipc::IPDLStructMember<nsCString> name_;
4961 ::mozilla::ipc::IPDLStructMember<nsCString> value_;
4962 ::mozilla::ipc::IPDLStructMember<nsCString> host_;
4963 ::mozilla::ipc::IPDLStructMember<nsCString> path_;
4964 ::mozilla::ipc::IPDLStructMember<bool> isHttpOnly_;
4965 ::mozilla::ipc::IPDLStructMember<bool> isSession_;
4966 ::mozilla::ipc::IPDLStructMember<bool> isSecure_;
4967 ::mozilla::ipc::IPDLStructMember<bool> isPartitioned_;
4968 ::mozilla::ipc::IPDLStructMember<int64_t> expiry_;
4969 ::mozilla::ipc::IPDLStructMember<int64_t> lastAccessed_;
4970 ::mozilla::ipc::IPDLStructMember<int64_t> creationTime_;
4971 ::mozilla::ipc::IPDLStructMember<int32_t> sameSite_;
4972 ::mozilla::ipc::IPDLStructMember<int32_t> rawSameSite_;
4973 ::mozilla::ipc::IPDLStructMember<uint8_t> schemeMap_;
4974};
4975} // namespace net
4976} // namespace mozilla
4977
4978namespace IPC {
4979template<>
4980struct ParamTraits <::mozilla::net::CookieStruct>
4981{
4982 typedef ::mozilla::net::CookieStruct paramType;
4983 static void
4984 Write(
4985 IPC::MessageWriter* aWriter,
4986 const paramType& aVar);
4987 static IPC::ReadResult<paramType>
4988 Read(IPC::MessageReader* aReader);
4989};
4990} // namespace IPC
4991
4992
4993//-----------------------------------------------------------------------------
4994// Declaration of the IPDL type |struct CookieStructTable|
4995//
4996namespace mozilla {
4997namespace net {
4998class CookieStructTable final
4999{
5000private:
5001 typedef ::mozilla::OriginAttributes OriginAttributes;
5002 typedef ::mozilla::net::CookieStruct CookieStruct;
5003
5004public:
5005#ifdef __clang__1
5006# pragma clang diagnostic push
5007# if __has_warning("-Wdefaulted-function-deleted")1
5008# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
5009# endif
5010#endif
5011 CookieStructTable() = default;
5012#ifdef __clang__1
5013# pragma clang diagnostic pop
5014#endif
5015
5016 MOZ_IMPLICIT CookieStructTable(
5017 const OriginAttributes& _attrs,
5018 const nsTArray<CookieStruct>& _cookies) :
5019 attrs_(_attrs),
5020 cookies_(_cookies)
5021 {
5022 }
5023
5024 MOZ_IMPLICIT CookieStructTable(
5025 OriginAttributes&& _attrs,
5026 nsTArray<CookieStruct>&& _cookies) :
5027 attrs_(std::move(_attrs)),
5028 cookies_(std::move(_cookies))
5029 {
5030 }
5031
5032 OriginAttributes&
5033 attrs()
5034 {
5035 return attrs_;
5036 }
5037 const OriginAttributes&
5038 attrs() const
5039 {
5040 return attrs_;
5041 }
5042
5043 nsTArray<CookieStruct>&
5044 cookies()
5045 {
5046 return cookies_;
5047 }
5048 const nsTArray<CookieStruct>&
5049 cookies() const
5050 {
5051 return cookies_;
5052 }
5053
5054private:
5055 ::mozilla::ipc::IPDLStructMember<OriginAttributes> attrs_;
5056 ::mozilla::ipc::IPDLStructMember<CopyableTArray<CookieStruct>> cookies_;
5057};
5058} // namespace net
5059} // namespace mozilla
5060
5061namespace IPC {
5062template<>
5063struct ParamTraits <::mozilla::net::CookieStructTable>
5064{
5065 typedef ::mozilla::net::CookieStructTable paramType;
5066 static void
5067 Write(
5068 IPC::MessageWriter* aWriter,
5069 const paramType& aVar);
5070 static IPC::ReadResult<paramType>
5071 Read(IPC::MessageReader* aReader);
5072};
5073} // namespace IPC
5074
5075
5076//-----------------------------------------------------------------------------
5077// Declaration of the IPDL type |struct DocumentCreationArgs|
5078//
5079namespace mozilla {
5080namespace net {
5081class DocumentCreationArgs final
5082{
5083private:
5084
5085public:
5086#ifdef __clang__1
5087# pragma clang diagnostic push
5088# if __has_warning("-Wdefaulted-function-deleted")1
5089# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
5090# endif
5091#endif
5092 DocumentCreationArgs() = default;
5093#ifdef __clang__1
5094# pragma clang diagnostic pop
5095#endif
5096
5097 MOZ_IMPLICIT DocumentCreationArgs(
5098 const bool& _uriModified,
5099 const bool& _isEmbeddingBlockedError) :
5100 uriModified_(_uriModified),
5101 isEmbeddingBlockedError_(_isEmbeddingBlockedError)
5102 {
5103 }
5104
5105 MOZ_IMPLICIT DocumentCreationArgs(
5106 bool&& _uriModified,
5107 bool&& _isEmbeddingBlockedError) :
5108 uriModified_(std::move(_uriModified)),
5109 isEmbeddingBlockedError_(std::move(_isEmbeddingBlockedError))
5110 {
5111 }
5112
5113 bool&
5114 uriModified()
5115 {
5116 return uriModified_;
5117 }
5118 const bool&
5119 uriModified() const
5120 {
5121 return uriModified_;
5122 }
5123
5124 bool&
5125 isEmbeddingBlockedError()
5126 {
5127 return isEmbeddingBlockedError_;
5128 }
5129 const bool&
5130 isEmbeddingBlockedError() const
5131 {
5132 return isEmbeddingBlockedError_;
5133 }
5134
5135private:
5136 ::mozilla::ipc::IPDLStructMember<bool> uriModified_;
5137 ::mozilla::ipc::IPDLStructMember<bool> isEmbeddingBlockedError_;
5138};
5139} // namespace net
5140} // namespace mozilla
5141
5142namespace IPC {
5143template<>
5144struct ParamTraits <::mozilla::net::DocumentCreationArgs>
5145{
5146 typedef ::mozilla::net::DocumentCreationArgs paramType;
5147 static void
5148 Write(
5149 IPC::MessageWriter* aWriter,
5150 const paramType& aVar);
5151 static IPC::ReadResult<paramType>
5152 Read(IPC::MessageReader* aReader);
5153};
5154} // namespace IPC
5155
5156
5157//-----------------------------------------------------------------------------
5158// Declaration of the IPDL type |struct ObjectCreationArgs|
5159//
5160namespace mozilla {
5161namespace net {
5162class ObjectCreationArgs final
5163{
5164private:
5165 typedef ::uint64_t uint64_t;
5166 typedef ::uint32_t uint32_t;
5167 typedef ::nsContentPolicyType nsContentPolicyType;
5168
5169public:
5170#ifdef __clang__1
5171# pragma clang diagnostic push
5172# if __has_warning("-Wdefaulted-function-deleted")1
5173# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
5174# endif
5175#endif
5176 ObjectCreationArgs() = default;
5177#ifdef __clang__1
5178# pragma clang diagnostic pop
5179#endif
5180
5181 MOZ_IMPLICIT ObjectCreationArgs(
5182 const uint64_t& _embedderInnerWindowId,
5183 const uint32_t& _loadFlags,
5184 const nsContentPolicyType& _contentPolicyType,
5185 const bool& _isUrgentStart) :
5186 contentPolicyType_(_contentPolicyType),
5187 isUrgentStart_(_isUrgentStart),
5188 embedderInnerWindowId_(_embedderInnerWindowId),
5189 loadFlags_(_loadFlags)
5190 {
5191 }
5192
5193 MOZ_IMPLICIT ObjectCreationArgs(
5194 uint64_t&& _embedderInnerWindowId,
5195 uint32_t&& _loadFlags,
5196 nsContentPolicyType&& _contentPolicyType,
5197 bool&& _isUrgentStart) :
5198 contentPolicyType_(std::move(_contentPolicyType)),
5199 isUrgentStart_(std::move(_isUrgentStart)),
5200 embedderInnerWindowId_(std::move(_embedderInnerWindowId)),
5201 loadFlags_(std::move(_loadFlags))
5202 {
5203 }
5204
5205 uint64_t&
5206 embedderInnerWindowId()
5207 {
5208 return embedderInnerWindowId_;
5209 }
5210 const uint64_t&
5211 embedderInnerWindowId() const
5212 {
5213 return embedderInnerWindowId_;
5214 }
5215
5216 uint32_t&
5217 loadFlags()
5218 {
5219 return loadFlags_;
5220 }
5221 const uint32_t&
5222 loadFlags() const
5223 {
5224 return loadFlags_;
5225 }
5226
5227 nsContentPolicyType&
5228 contentPolicyType()
5229 {
5230 return contentPolicyType_;
5231 }
5232 const nsContentPolicyType&
5233 contentPolicyType() const
5234 {
5235 return contentPolicyType_;
5236 }
5237
5238 bool&
5239 isUrgentStart()
5240 {
5241 return isUrgentStart_;
5242 }
5243 const bool&
5244 isUrgentStart() const
5245 {
5246 return isUrgentStart_;
5247 }
5248
5249private:
5250 ::mozilla::ipc::IPDLStructMember<nsContentPolicyType> contentPolicyType_;
5251 ::mozilla::ipc::IPDLStructMember<bool> isUrgentStart_;
5252 ::mozilla::ipc::IPDLStructMember<uint64_t> embedderInnerWindowId_;
5253 ::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
5254};
5255} // namespace net
5256} // namespace mozilla
5257
5258namespace IPC {
5259template<>
5260struct ParamTraits <::mozilla::net::ObjectCreationArgs>
5261{
5262 typedef ::mozilla::net::ObjectCreationArgs paramType;
5263 static void
5264 Write(
5265 IPC::MessageWriter* aWriter,
5266 const paramType& aVar);
5267 static IPC::ReadResult<paramType>
5268 Read(IPC::MessageReader* aReader);
5269};
5270} // namespace IPC
5271
5272
5273//-----------------------------------------------------------------------------
5274// Declaration of the IPDL type |union DocumentChannelElementCreationArgs|
5275//
5276namespace mozilla {
5277namespace net {
5278class DocumentChannelElementCreationArgs final
5279{
5280public:
5281 enum Type {
5282 T__None,
5283 TDocumentCreationArgs = 1,
5284 TObjectCreationArgs,
5285 T__Last = TObjectCreationArgs
5286 };
5287
5288private:
5289 typedef ::mozilla::net::DocumentCreationArgs DocumentCreationArgs;
5290 typedef ::mozilla::net::ObjectCreationArgs ObjectCreationArgs;
5291 typedef DocumentCreationArgs DocumentCreationArgs__tdef;
5292 typedef ObjectCreationArgs ObjectCreationArgs__tdef;
5293
5294 DocumentCreationArgs*
5295 ptr_DocumentCreationArgs()
5296 {
5297 return (&(mVDocumentCreationArgs));
5298 }
5299 const DocumentCreationArgs*
5300 constptr_DocumentCreationArgs() const
5301 {
5302 return (&(mVDocumentCreationArgs));
5303 }
5304 ObjectCreationArgs*
5305 ptr_ObjectCreationArgs()
5306 {
5307 return (&(mVObjectCreationArgs));
5308 }
5309 const ObjectCreationArgs*
5310 constptr_ObjectCreationArgs() const
5311 {
5312 return (&(mVObjectCreationArgs));
5313 }
5314
5315 void
5316 MaybeDestroy();
5317
5318 void
5319 AssertSanity() const
5320 {
5321 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" ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/net/NeckoChannelParams.h"
, 5321); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(T__None) <= (mType)"
") (" "invalid type tag" ")"); do { *((volatile int*)__null)
= 5321; __attribute__((nomerge)) ::abort(); } while (false);
} } while (false)
;
5322 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" ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/net/NeckoChannelParams.h"
, 5322); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(mType) <= (T__Last)"
") (" "invalid type tag" ")"); do { *((volatile int*)__null)
= 5322; __attribute__((nomerge)) ::abort(); } while (false);
} } while (false)
;
5323 }
5324 void
5325 AssertSanity(Type aType) const
5326 {
5327 AssertSanity();
5328 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" ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/net/NeckoChannelParams.h"
, 5328); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(mType) == (aType)"
") (" "unexpected type tag" ")"); do { *((volatile int*)__null
) = 5328; __attribute__((nomerge)) ::abort(); } while (false)
; } } while (false)
;
5329 }
5330
5331public:
5332 MOZ_IMPLICIT DocumentChannelElementCreationArgs() :
5333 mType(T__None)
5334 {
5335 }
5336
5337 MOZ_IMPLICIT DocumentChannelElementCreationArgs(const DocumentCreationArgs& aOther);
5338
5339 MOZ_IMPLICIT DocumentChannelElementCreationArgs(DocumentCreationArgs&& aOther);
5340
5341 MOZ_IMPLICIT DocumentChannelElementCreationArgs(const ObjectCreationArgs& aOther);
5342
5343 MOZ_IMPLICIT DocumentChannelElementCreationArgs(ObjectCreationArgs&& aOther);
5344
5345 MOZ_IMPLICIT DocumentChannelElementCreationArgs(const DocumentChannelElementCreationArgs& aOther);
5346
5347 MOZ_IMPLICIT DocumentChannelElementCreationArgs(DocumentChannelElementCreationArgs&& aOther);
5348
5349 ~DocumentChannelElementCreationArgs();
5350
5351 Type
5352 type() const
5353 {
5354 return mType;
5355 }
5356
5357 DocumentChannelElementCreationArgs&
5358 operator=(const DocumentCreationArgs& aRhs);
5359
5360 DocumentChannelElementCreationArgs&
5361 operator=(DocumentCreationArgs&& aRhs);
5362
5363 DocumentChannelElementCreationArgs&
5364 operator=(const ObjectCreationArgs& aRhs);
5365
5366 DocumentChannelElementCreationArgs&
5367 operator=(ObjectCreationArgs&& aRhs);
5368
5369 DocumentChannelElementCreationArgs&
5370 operator=(const DocumentChannelElementCreationArgs& aRhs);
5371
5372 DocumentChannelElementCreationArgs&
5373 operator=(DocumentChannelElementCreationArgs&& aRhs);
5374
5375 DocumentCreationArgs&
5376 get_DocumentCreationArgs()
5377 {
5378 AssertSanity(TDocumentCreationArgs);
5379 return (*(ptr_DocumentCreationArgs()));
5380 }
5381 const DocumentCreationArgs&
5382 get_DocumentCreationArgs() const
5383 {
5384 AssertSanity(TDocumentCreationArgs);
5385 return (*(constptr_DocumentCreationArgs()));
5386 }
5387 operator DocumentCreationArgs&()
5388 {
5389 return get_DocumentCreationArgs();
5390 }
5391 operator const DocumentCreationArgs&() const
5392 {
5393 return get_DocumentCreationArgs();
5394 }
5395
5396 ObjectCreationArgs&
5397 get_ObjectCreationArgs()
5398 {
5399 AssertSanity(TObjectCreationArgs);
5400 return (*(ptr_ObjectCreationArgs()));
5401 }
5402 const ObjectCreationArgs&
5403 get_ObjectCreationArgs() const
5404 {
5405 AssertSanity(TObjectCreationArgs);
5406 return (*(constptr_ObjectCreationArgs()));
5407 }
5408 operator ObjectCreationArgs&()
5409 {
5410 return get_ObjectCreationArgs();
5411 }
5412 operator const ObjectCreationArgs&() const
5413 {
5414 return get_ObjectCreationArgs();
5415 }
5416
5417private:
5418 union {
5419 DocumentCreationArgs mVDocumentCreationArgs;
5420 ObjectCreationArgs mVObjectCreationArgs;
5421 };
5422 Type mType;
5423};
5424} // namespace net
5425} // namespace mozilla
5426
5427namespace IPC {
5428template<>
5429struct ParamTraits <::mozilla::net::DocumentChannelElementCreationArgs>
5430{
5431 typedef ::mozilla::net::DocumentChannelElementCreationArgs paramType;
5432 static void
5433 Write(
5434 IPC::MessageWriter* aWriter,
5435 const paramType& aVar);
5436 static IPC::ReadResult<paramType>
5437 Read(IPC::MessageReader* aReader);
5438};
5439} // namespace IPC
5440
5441
5442//-----------------------------------------------------------------------------
5443// Declaration of the IPDL type |struct DocumentChannelCreationArgs|
5444//
5445namespace mozilla {
5446namespace net {
5447class DocumentChannelCreationArgs final
5448{
5449private:
5450 typedef ::nsDocShellLoadState nsDocShellLoadState;
5451 typedef ::mozilla::TimeStamp TimeStamp;
5452 typedef ::uint64_t uint64_t;
5453 typedef ::uint32_t uint32_t;
5454 typedef ::nsDOMNavigationTiming nsDOMNavigationTiming;
5455 typedef ::mozilla::dom::IPCClientInfo IPCClientInfo;
5456 typedef ::mozilla::net::DocumentChannelElementCreationArgs DocumentChannelElementCreationArgs;
5457
5458public:
5459#ifdef __clang__1
5460# pragma clang diagnostic push
5461# if __has_warning("-Wdefaulted-function-deleted")1
5462# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
5463# endif
5464#endif
5465 DocumentChannelCreationArgs() = default;
5466#ifdef __clang__1
5467# pragma clang diagnostic pop
5468#endif
5469
5470 MOZ_IMPLICIT DocumentChannelCreationArgs(
5471 mozilla::NotNull<nsDocShellLoadState*> _loadState,
5472 const TimeStamp& _asyncOpenTime,
5473 const uint64_t& _channelId,
5474 const uint32_t& _cacheKey,
5475 nsDOMNavigationTiming* _timing,
5476 const mozilla::Maybe<IPCClientInfo>& _initialClientInfo,
5477 const DocumentChannelElementCreationArgs& _elementCreationArgs,
5478 const uint64_t& _parentInitiatedNavigationEpoch) :
5479 loadState_(_loadState),
5480 asyncOpenTime_(_asyncOpenTime),
5481 timing_(_timing),
5482 initialClientInfo_(_initialClientInfo),
5483 elementCreationArgs_(_elementCreationArgs),
5484 channelId_(_channelId),
5485 parentInitiatedNavigationEpoch_(_parentInitiatedNavigationEpoch),
5486 cacheKey_(_cacheKey)
5487 {
5488 }
5489
5490 MOZ_IMPLICIT DocumentChannelCreationArgs(
5491 mozilla::NotNull<RefPtr<nsDocShellLoadState>>&& _loadState,
5492 TimeStamp&& _asyncOpenTime,
5493 uint64_t&& _channelId,
5494 uint32_t&& _cacheKey,
5495 RefPtr<nsDOMNavigationTiming>&& _timing,
5496 mozilla::Maybe<IPCClientInfo>&& _initialClientInfo,
5497 DocumentChannelElementCreationArgs&& _elementCreationArgs,
5498 uint64_t&& _parentInitiatedNavigationEpoch) :
5499 loadState_(std::move(_loadState)),
5500 asyncOpenTime_(std::move(_asyncOpenTime)),
5501 timing_(std::move(_timing)),
5502 initialClientInfo_(std::move(_initialClientInfo)),
5503 elementCreationArgs_(std::move(_elementCreationArgs)),
5504 channelId_(std::move(_channelId)),
5505 parentInitiatedNavigationEpoch_(std::move(_parentInitiatedNavigationEpoch)),
5506 cacheKey_(std::move(_cacheKey))
5507 {
5508 }
5509
5510 mozilla::NotNull<RefPtr<nsDocShellLoadState>>&
5511 loadState()
5512 {
5513 return loadState_;
5514 }
5515 mozilla::NotNull<nsDocShellLoadState*>
5516 loadState() const
5517 {
5518 return loadState_;
5519 }
5520
5521 TimeStamp&
5522 asyncOpenTime()
5523 {
5524 return asyncOpenTime_;
5525 }
5526 const TimeStamp&
5527 asyncOpenTime() const
5528 {
5529 return asyncOpenTime_;
5530 }
5531
5532 uint64_t&
5533 channelId()
5534 {
5535 return channelId_;
5536 }
5537 const uint64_t&
5538 channelId() const
5539 {
5540 return channelId_;
5541 }
5542
5543 uint32_t&
5544 cacheKey()
5545 {
5546 return cacheKey_;
5547 }
5548 const uint32_t&
5549 cacheKey() const
5550 {
5551 return cacheKey_;
5552 }
5553
5554 RefPtr<nsDOMNavigationTiming>&
5555 timing()
5556 {
5557 return timing_;
5558 }
5559 nsDOMNavigationTiming*
5560 timing() const
5561 {
5562 return timing_;
5563 }
5564
5565 mozilla::Maybe<IPCClientInfo>&
5566 initialClientInfo()
5567 {
5568 return initialClientInfo_;
5569 }
5570 const mozilla::Maybe<IPCClientInfo>&
5571 initialClientInfo() const
5572 {
5573 return initialClientInfo_;
5574 }
5575
5576 DocumentChannelElementCreationArgs&
5577 elementCreationArgs()
5578 {
5579 return elementCreationArgs_;
5580 }
5581 const DocumentChannelElementCreationArgs&
5582 elementCreationArgs() const
5583 {
5584 return elementCreationArgs_;
5585 }
5586
5587 uint64_t&
5588 parentInitiatedNavigationEpoch()
5589 {
5590 return parentInitiatedNavigationEpoch_;
5591 }
5592 const uint64_t&
5593 parentInitiatedNavigationEpoch() const
5594 {
5595 return parentInitiatedNavigationEpoch_;
5596 }
5597
5598private:
5599 void
5600 StaticAssertions() const;
5601 ::mozilla::ipc::IPDLStructMember<mozilla::NotNull<RefPtr<nsDocShellLoadState>>> loadState_;
5602 ::mozilla::ipc::IPDLStructMember<TimeStamp> asyncOpenTime_;
5603 ::mozilla::ipc::IPDLStructMember<RefPtr<nsDOMNavigationTiming>> timing_;
5604 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> initialClientInfo_;
5605 ::mozilla::ipc::IPDLStructMember<DocumentChannelElementCreationArgs> elementCreationArgs_;
5606 ::mozilla::ipc::IPDLStructMember<uint64_t> channelId_;
5607 ::mozilla::ipc::IPDLStructMember<uint64_t> parentInitiatedNavigationEpoch_;
5608 ::mozilla::ipc::IPDLStructMember<uint32_t> cacheKey_;
5609};
5610} // namespace net
5611} // namespace mozilla
5612
5613namespace IPC {
5614template<>
5615struct ParamTraits <::mozilla::net::DocumentChannelCreationArgs>
5616{
5617 typedef ::mozilla::net::DocumentChannelCreationArgs paramType;
5618 static void
5619 Write(
5620 IPC::MessageWriter* aWriter,
5621 const paramType& aVar);
5622 static IPC::ReadResult<paramType>
5623 Read(IPC::MessageReader* aReader);
5624};
5625} // namespace IPC
5626
5627
5628//-----------------------------------------------------------------------------
5629// Declaration of the IPDL type |struct EarlyHintConnectArgs|
5630//
5631namespace mozilla {
5632namespace net {
5633class EarlyHintConnectArgs final
5634{
5635private:
5636 typedef ::mozilla::net::LinkHeader LinkHeader;
5637 typedef ::uint64_t uint64_t;
5638
5639public:
5640#ifdef __clang__1
5641# pragma clang diagnostic push
5642# if __has_warning("-Wdefaulted-function-deleted")1
5643# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
5644# endif
5645#endif
5646 EarlyHintConnectArgs() = default;
5647#ifdef __clang__1
5648# pragma clang diagnostic pop
5649#endif
5650
5651 MOZ_IMPLICIT EarlyHintConnectArgs(
5652 const LinkHeader& _link,
5653 const uint64_t& _earlyHintPreloaderId) :
5654 link_(_link),
5655 earlyHintPreloaderId_(_earlyHintPreloaderId)
5656 {
5657 }
5658
5659 MOZ_IMPLICIT EarlyHintConnectArgs(
5660 LinkHeader&& _link,
5661 uint64_t&& _earlyHintPreloaderId) :
5662 link_(std::move(_link)),
5663 earlyHintPreloaderId_(std::move(_earlyHintPreloaderId))
5664 {
5665 }
5666
5667 LinkHeader&
5668 link()
5669 {
5670 return link_;
5671 }
5672 const LinkHeader&
5673 link() const
5674 {
5675 return link_;
5676 }
5677
5678 uint64_t&
5679 earlyHintPreloaderId()
5680 {
5681 return earlyHintPreloaderId_;
5682 }
5683 const uint64_t&
5684 earlyHintPreloaderId() const
5685 {
5686 return earlyHintPreloaderId_;
5687 }
5688
5689private:
5690 ::mozilla::ipc::IPDLStructMember<LinkHeader> link_;
5691 ::mozilla::ipc::IPDLStructMember<uint64_t> earlyHintPreloaderId_;
5692};
5693} // namespace net
5694} // namespace mozilla
5695
5696namespace IPC {
5697template<>
5698struct ParamTraits <::mozilla::net::EarlyHintConnectArgs>
5699{
5700 typedef ::mozilla::net::EarlyHintConnectArgs paramType;
5701 static void
5702 Write(
5703 IPC::MessageWriter* aWriter,
5704 const paramType& aVar);
5705 static IPC::ReadResult<paramType>
5706 Read(IPC::MessageReader* aReader);
5707};
5708} // namespace IPC
5709
5710
5711//-----------------------------------------------------------------------------
5712// Declaration of the IPDL type |struct RedirectToRealChannelArgs|
5713//
5714namespace mozilla {
5715namespace net {
5716class RedirectToRealChannelArgs final
5717{
5718private:
5719 typedef ::uint32_t uint32_t;
5720 typedef ::nsIURI nsIURI;
5721 typedef ::mozilla::dom::ReplacementChannelConfigInit ReplacementChannelConfigInit;
5722 typedef ::mozilla::net::LoadInfoArgs LoadInfoArgs;
5723 typedef ::uint64_t uint64_t;
5724 typedef ::nsString nsString;
5725 typedef ::nsIPropertyBag2 nsIPropertyBag2;
5726 typedef ::nsDOMNavigationTiming nsDOMNavigationTiming;
5727 typedef ::mozilla::dom::LoadingSessionHistoryInfo LoadingSessionHistoryInfo;
5728 typedef ::nsCString nsCString;
5729 typedef ::mozilla::net::EarlyHintConnectArgs EarlyHintConnectArgs;
5730
5731public:
5732#ifdef __clang__1
5733# pragma clang diagnostic push
5734# if __has_warning("-Wdefaulted-function-deleted")1
5735# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
5736# endif
5737#endif
5738 RedirectToRealChannelArgs() = default;
5739#ifdef __clang__1
5740# pragma clang diagnostic pop
5741#endif
5742
5743 MOZ_IMPLICIT RedirectToRealChannelArgs(
5744 const uint32_t& _registrarId,
5745 nsIURI* _uri,
5746 const uint32_t& _newLoadFlags,
5747 const mozilla::Maybe<ReplacementChannelConfigInit>& _init,
5748 const LoadInfoArgs& _loadInfo,
5749 const uint64_t& _channelId,
5750 nsIURI* _originalURI,
5751 const uint32_t& _redirectMode,
5752 const uint32_t& _redirectFlags,
5753 const mozilla::Maybe<uint32_t>& _contentDisposition,
5754 const mozilla::Maybe<nsString>& _contentDispositionFilename,
5755 nsIPropertyBag2* _properties,
5756 const uint32_t& _loadStateExternalLoadFlags,
5757 const uint32_t& _loadStateInternalLoadFlags,
5758 const uint32_t& _loadStateLoadType,
5759 nsDOMNavigationTiming* _timing,
5760 const nsString& _srcdocData,
5761 nsIURI* _baseUri,
5762 const mozilla::Maybe<LoadingSessionHistoryInfo>& _loadingSessionHistoryInfo,
5763 const uint64_t& _loadIdentifier,
5764 const mozilla::Maybe<nsCString>& _originalUriString,
5765 const nsTArray<EarlyHintConnectArgs>& _earlyHints,
5766 const uint32_t& _earlyHintLinkType) :
5767 uri_(_uri),
5768 init_(_init),
5769 loadInfo_(_loadInfo),
5770 originalURI_(_originalURI),
5771 contentDisposition_(_contentDisposition),
5772 contentDispositionFilename_(_contentDispositionFilename),
5773 properties_(_properties),
5774 timing_(_timing),
5775 srcdocData_(_srcdocData),
5776 baseUri_(_baseUri),
5777 loadingSessionHistoryInfo_(_loadingSessionHistoryInfo),
5778 originalUriString_(_originalUriString),
5779 earlyHints_(_earlyHints),
5780 channelId_(_channelId),
5781 loadIdentifier_(_loadIdentifier),
5782 registrarId_(_registrarId),
5783 newLoadFlags_(_newLoadFlags),
5784 redirectMode_(_redirectMode),
5785 redirectFlags_(_redirectFlags),
5786 loadStateExternalLoadFlags_(_loadStateExternalLoadFlags),
5787 loadStateInternalLoadFlags_(_loadStateInternalLoadFlags),
5788 loadStateLoadType_(_loadStateLoadType),
5789 earlyHintLinkType_(_earlyHintLinkType)
5790 {
5791 }
5792
5793 MOZ_IMPLICIT RedirectToRealChannelArgs(
5794 uint32_t&& _registrarId,
5795 RefPtr<nsIURI>&& _uri,
5796 uint32_t&& _newLoadFlags,
5797 mozilla::Maybe<ReplacementChannelConfigInit>&& _init,
5798 LoadInfoArgs&& _loadInfo,
5799 uint64_t&& _channelId,
5800 RefPtr<nsIURI>&& _originalURI,
5801 uint32_t&& _redirectMode,
5802 uint32_t&& _redirectFlags,
5803 mozilla::Maybe<uint32_t>&& _contentDisposition,
5804 mozilla::Maybe<nsString>&& _contentDispositionFilename,
5805 RefPtr<nsIPropertyBag2>&& _properties,
5806 uint32_t&& _loadStateExternalLoadFlags,
5807 uint32_t&& _loadStateInternalLoadFlags,
5808 uint32_t&& _loadStateLoadType,
5809 RefPtr<nsDOMNavigationTiming>&& _timing,
5810 nsString&& _srcdocData,
5811 RefPtr<nsIURI>&& _baseUri,
5812 mozilla::Maybe<LoadingSessionHistoryInfo>&& _loadingSessionHistoryInfo,
5813 uint64_t&& _loadIdentifier,
5814 mozilla::Maybe<nsCString>&& _originalUriString,
5815 nsTArray<EarlyHintConnectArgs>&& _earlyHints,
5816 uint32_t&& _earlyHintLinkType) :
5817 uri_(std::move(_uri)),
5818 init_(std::move(_init)),
5819 loadInfo_(std::move(_loadInfo)),
5820 originalURI_(std::move(_originalURI)),
5821 contentDisposition_(std::move(_contentDisposition)),
5822 contentDispositionFilename_(std::move(_contentDispositionFilename)),
5823 properties_(std::move(_properties)),
5824 timing_(std::move(_timing)),
5825 srcdocData_(std::move(_srcdocData)),
5826 baseUri_(std::move(_baseUri)),
5827 loadingSessionHistoryInfo_(std::move(_loadingSessionHistoryInfo)),
5828 originalUriString_(std::move(_originalUriString)),
5829 earlyHints_(std::move(_earlyHints)),
5830 channelId_(std::move(_channelId)),
5831 loadIdentifier_(std::move(_loadIdentifier)),
5832 registrarId_(std::move(_registrarId)),
5833 newLoadFlags_(std::move(_newLoadFlags)),
5834 redirectMode_(std::move(_redirectMode)),
5835 redirectFlags_(std::move(_redirectFlags)),
5836 loadStateExternalLoadFlags_(std::move(_loadStateExternalLoadFlags)),
5837 loadStateInternalLoadFlags_(std::move(_loadStateInternalLoadFlags)),
5838 loadStateLoadType_(std::move(_loadStateLoadType)),
5839 earlyHintLinkType_(std::move(_earlyHintLinkType))
5840 {
5841 }
5842
5843 uint32_t&
5844 registrarId()
5845 {
5846 return registrarId_;
5847 }
5848 const uint32_t&
5849 registrarId() const
5850 {
5851 return registrarId_;
5852 }
5853
5854 RefPtr<nsIURI>&
5855 uri()
5856 {
5857 return uri_;
5858 }
5859 nsIURI*
5860 uri() const
5861 {
5862 return uri_;
5863 }
5864
5865 uint32_t&
5866 newLoadFlags()
5867 {
5868 return newLoadFlags_;
5869 }
5870 const uint32_t&
5871 newLoadFlags() const
5872 {
5873 return newLoadFlags_;
5874 }
5875
5876 mozilla::Maybe<ReplacementChannelConfigInit>&
5877 init()
5878 {
5879 return init_;
5880 }
5881 const mozilla::Maybe<ReplacementChannelConfigInit>&
5882 init() const
5883 {
5884 return init_;
5885 }
5886
5887 LoadInfoArgs&
5888 loadInfo()
5889 {
5890 return loadInfo_;
5891 }
5892 const LoadInfoArgs&
5893 loadInfo() const
5894 {
5895 return loadInfo_;
5896 }
5897
5898 uint64_t&
5899 channelId()
5900 {
5901 return channelId_;
5902 }
5903 const uint64_t&
5904 channelId() const
5905 {
5906 return channelId_;
5907 }
5908
5909 RefPtr<nsIURI>&
5910 originalURI()
5911 {
5912 return originalURI_;
5913 }
5914 nsIURI*
5915 originalURI() const
5916 {
5917 return originalURI_;
5918 }
5919
5920 uint32_t&
5921 redirectMode()
5922 {
5923 return redirectMode_;
5924 }
5925 const uint32_t&
5926 redirectMode() const
5927 {
5928 return redirectMode_;
5929 }
5930
5931 uint32_t&
5932 redirectFlags()
5933 {
5934 return redirectFlags_;
5935 }
5936 const uint32_t&
5937 redirectFlags() const
5938 {
5939 return redirectFlags_;
5940 }
5941
5942 mozilla::Maybe<uint32_t>&
5943 contentDisposition()
5944 {
5945 return contentDisposition_;
5946 }
5947 const mozilla::Maybe<uint32_t>&
5948 contentDisposition() const
5949 {
5950 return contentDisposition_;
5951 }
5952
5953 mozilla::Maybe<nsString>&
5954 contentDispositionFilename()
5955 {
5956 return contentDispositionFilename_;
5957 }
5958 const mozilla::Maybe<nsString>&
5959 contentDispositionFilename() const
5960 {
5961 return contentDispositionFilename_;
5962 }
5963
5964 RefPtr<nsIPropertyBag2>&
5965 properties()
5966 {
5967 return properties_;
5968 }
5969 nsIPropertyBag2*
5970 properties() const
5971 {
5972 return properties_;
5973 }
5974
5975 uint32_t&
5976 loadStateExternalLoadFlags()
5977 {
5978 return loadStateExternalLoadFlags_;
5979 }
5980 const uint32_t&
5981 loadStateExternalLoadFlags() const
5982 {
5983 return loadStateExternalLoadFlags_;
5984 }
5985
5986 uint32_t&
5987 loadStateInternalLoadFlags()
5988 {
5989 return loadStateInternalLoadFlags_;
5990 }
5991 const uint32_t&
5992 loadStateInternalLoadFlags() const
5993 {
5994 return loadStateInternalLoadFlags_;
5995 }
5996
5997 uint32_t&
5998 loadStateLoadType()
5999 {
6000 return loadStateLoadType_;
6001 }
6002 const uint32_t&
6003 loadStateLoadType() const
6004 {
6005 return loadStateLoadType_;
6006 }
6007
6008 RefPtr<nsDOMNavigationTiming>&
6009 timing()
6010 {
6011 return timing_;
6012 }
6013 nsDOMNavigationTiming*
6014 timing() const
6015 {
6016 return timing_;
6017 }
6018
6019 nsString&
6020 srcdocData()
6021 {
6022 return srcdocData_;
6023 }
6024 const nsString&
6025 srcdocData() const
6026 {
6027 return srcdocData_;
6028 }
6029
6030 RefPtr<nsIURI>&
6031 baseUri()
6032 {
6033 return baseUri_;
6034 }
6035 nsIURI*
6036 baseUri() const
6037 {
6038 return baseUri_;
6039 }
6040
6041 mozilla::Maybe<LoadingSessionHistoryInfo>&
6042 loadingSessionHistoryInfo()
6043 {
6044 return loadingSessionHistoryInfo_;
6045 }
6046 const mozilla::Maybe<LoadingSessionHistoryInfo>&
6047 loadingSessionHistoryInfo() const
6048 {
6049 return loadingSessionHistoryInfo_;
6050 }
6051
6052 uint64_t&
6053 loadIdentifier()
6054 {
6055 return loadIdentifier_;
6056 }
6057 const uint64_t&
6058 loadIdentifier() const
6059 {
6060 return loadIdentifier_;
6061 }
6062
6063 mozilla::Maybe<nsCString>&
6064 originalUriString()
6065 {
6066 return originalUriString_;
6067 }
6068 const mozilla::Maybe<nsCString>&
6069 originalUriString() const
6070 {
6071 return originalUriString_;
6072 }
6073
6074 nsTArray<EarlyHintConnectArgs>&
6075 earlyHints()
6076 {
6077 return earlyHints_;
6078 }
6079 const nsTArray<EarlyHintConnectArgs>&
6080 earlyHints() const
6081 {
6082 return earlyHints_;
6083 }
6084
6085 uint32_t&
6086 earlyHintLinkType()
6087 {
6088 return earlyHintLinkType_;
6089 }
6090 const uint32_t&
6091 earlyHintLinkType() const
6092 {
6093 return earlyHintLinkType_;
6094 }
6095
6096private:
6097 void
6098 StaticAssertions() const;
6099 ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> uri_;
6100 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ReplacementChannelConfigInit>> init_;
6101 ::mozilla::ipc::IPDLStructMember<LoadInfoArgs> loadInfo_;
6102 ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> originalURI_;
6103 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<uint32_t>> contentDisposition_;
6104 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsString>> contentDispositionFilename_;
6105 ::mozilla::ipc::IPDLStructMember<RefPtr<nsIPropertyBag2>> properties_;
6106 ::mozilla::ipc::IPDLStructMember<RefPtr<nsDOMNavigationTiming>> timing_;
6107 ::mozilla::ipc::IPDLStructMember<nsString> srcdocData_;
6108 ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> baseUri_;
6109 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<LoadingSessionHistoryInfo>> loadingSessionHistoryInfo_;
6110 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsCString>> originalUriString_;
6111 ::mozilla::ipc::IPDLStructMember<CopyableTArray<EarlyHintConnectArgs>> earlyHints_;
6112 ::mozilla::ipc::IPDLStructMember<uint64_t> channelId_;
6113 ::mozilla::ipc::IPDLStructMember<uint64_t> loadIdentifier_;
6114 ::mozilla::ipc::IPDLStructMember<uint32_t> registrarId_;
6115 ::mozilla::ipc::IPDLStructMember<uint32_t> newLoadFlags_;
6116 ::mozilla::ipc::IPDLStructMember<uint32_t> redirectMode_;
6117 ::mozilla::ipc::IPDLStructMember<uint32_t> redirectFlags_;
6118 ::mozilla::ipc::IPDLStructMember<uint32_t> loadStateExternalLoadFlags_;
6119 ::mozilla::ipc::IPDLStructMember<uint32_t> loadStateInternalLoadFlags_;
6120 ::mozilla::ipc::IPDLStructMember<uint32_t> loadStateLoadType_;
6121 ::mozilla::ipc::IPDLStructMember<uint32_t> earlyHintLinkType_;
6122};
6123} // namespace net
6124} // namespace mozilla
6125
6126namespace IPC {
6127template<>
6128struct ParamTraits <::mozilla::net::RedirectToRealChannelArgs>
6129{
6130 typedef ::mozilla::net::RedirectToRealChannelArgs paramType;
6131 static void
6132 Write(
6133 IPC::MessageWriter* aWriter,
6134 const paramType& aVar);
6135 static IPC::ReadResult<paramType>
6136 Read(IPC::MessageReader* aReader);
6137};
6138} // namespace IPC
6139
6140
6141//-----------------------------------------------------------------------------
6142// Declaration of the IPDL type |struct TimingStructArgs|
6143//
6144namespace mozilla {
6145namespace net {
6146class TimingStructArgs final
6147{
6148private:
6149 typedef ::mozilla::TimeStamp TimeStamp;
6150
6151public:
6152#ifdef __clang__1
6153# pragma clang diagnostic push
6154# if __has_warning("-Wdefaulted-function-deleted")1
6155# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
6156# endif
6157#endif
6158 TimingStructArgs() = default;
6159#ifdef __clang__1
6160# pragma clang diagnostic pop
6161#endif
6162
6163 MOZ_IMPLICIT TimingStructArgs(
6164 const TimeStamp& _domainLookupStart,
6165 const TimeStamp& _domainLookupEnd,
6166 const TimeStamp& _connectStart,
6167 const TimeStamp& _tcpConnectEnd,
6168 const TimeStamp& _secureConnectionStart,
6169 const TimeStamp& _connectEnd,
6170 const TimeStamp& _requestStart,
6171 const TimeStamp& _responseStart,
6172 const TimeStamp& _responseEnd,
6173 const TimeStamp& _transactionPending) :
6174 domainLookupStart_(_domainLookupStart),
6175 domainLookupEnd_(_domainLookupEnd),
6176 connectStart_(_connectStart),
6177 tcpConnectEnd_(_tcpConnectEnd),
6178 secureConnectionStart_(_secureConnectionStart),
6179 connectEnd_(_connectEnd),
6180 requestStart_(_requestStart),
6181 responseStart_(_responseStart),
6182 responseEnd_(_responseEnd),
6183 transactionPending_(_transactionPending)
6184 {
6185 }
6186
6187 MOZ_IMPLICIT TimingStructArgs(
6188 TimeStamp&& _domainLookupStart,
6189 TimeStamp&& _domainLookupEnd,
6190 TimeStamp&& _connectStart,
6191 TimeStamp&& _tcpConnectEnd,
6192 TimeStamp&& _secureConnectionStart,
6193 TimeStamp&& _connectEnd,
6194 TimeStamp&& _requestStart,
6195 TimeStamp&& _responseStart,
6196 TimeStamp&& _responseEnd,
6197 TimeStamp&& _transactionPending) :
6198 domainLookupStart_(std::move(_domainLookupStart)),
6199 domainLookupEnd_(std::move(_domainLookupEnd)),
6200 connectStart_(std::move(_connectStart)),
6201 tcpConnectEnd_(std::move(_tcpConnectEnd)),
6202 secureConnectionStart_(std::move(_secureConnectionStart)),
6203 connectEnd_(std::move(_connectEnd)),
6204 requestStart_(std::move(_requestStart)),
6205 responseStart_(std::move(_responseStart)),
6206 responseEnd_(std::move(_responseEnd)),
6207 transactionPending_(std::move(_transactionPending))
6208 {
6209 }
6210
6211 TimeStamp&
6212 domainLookupStart()
6213 {
6214 return domainLookupStart_;
6215 }
6216 const TimeStamp&
6217 domainLookupStart() const
6218 {
6219 return domainLookupStart_;
6220 }
6221
6222 TimeStamp&
6223 domainLookupEnd()
6224 {
6225 return domainLookupEnd_;
6226 }
6227 const TimeStamp&
6228 domainLookupEnd() const
6229 {
6230 return domainLookupEnd_;
6231 }
6232
6233 TimeStamp&
6234 connectStart()
6235 {
6236 return connectStart_;
6237 }
6238 const TimeStamp&
6239 connectStart() const
6240 {
6241 return connectStart_;
6242 }
6243
6244 TimeStamp&
6245 tcpConnectEnd()
6246 {
6247 return tcpConnectEnd_;
6248 }
6249 const TimeStamp&
6250 tcpConnectEnd() const
6251 {
6252 return tcpConnectEnd_;
6253 }
6254
6255 TimeStamp&
6256 secureConnectionStart()
6257 {
6258 return secureConnectionStart_;
6259 }
6260 const TimeStamp&
6261 secureConnectionStart() const
6262 {
6263 return secureConnectionStart_;
6264 }
6265
6266 TimeStamp&
6267 connectEnd()
6268 {
6269 return connectEnd_;
6270 }
6271 const TimeStamp&
6272 connectEnd() const
6273 {
6274 return connectEnd_;
6275 }
6276
6277 TimeStamp&
6278 requestStart()
6279 {
6280 return requestStart_;
6281 }
6282 const TimeStamp&
6283 requestStart() const
6284 {
6285 return requestStart_;
6286 }
6287
6288 TimeStamp&
6289 responseStart()
6290 {
6291 return responseStart_;
6292 }
6293 const TimeStamp&
6294 responseStart() const
6295 {
6296 return responseStart_;
6297 }
6298
6299 TimeStamp&
6300 responseEnd()
6301 {
6302 return responseEnd_;
6303 }
6304 const TimeStamp&
6305 responseEnd() const
6306 {
6307 return responseEnd_;
6308 }
6309
6310 TimeStamp&
6311 transactionPending()
6312 {
6313 return transactionPending_;
6314 }
6315 const TimeStamp&
6316 transactionPending() const
6317 {
6318 return transactionPending_;
6319 }
6320
6321private:
6322 ::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupStart_;
6323 ::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupEnd_;
6324 ::mozilla::ipc::IPDLStructMember<TimeStamp> connectStart_;
6325 ::mozilla::ipc::IPDLStructMember<TimeStamp> tcpConnectEnd_;
6326 ::mozilla::ipc::IPDLStructMember<TimeStamp> secureConnectionStart_;
6327 ::mozilla::ipc::IPDLStructMember<TimeStamp> connectEnd_;
6328 ::mozilla::ipc::IPDLStructMember<TimeStamp> requestStart_;
6329 ::mozilla::ipc::IPDLStructMember<TimeStamp> responseStart_;
6330 ::mozilla::ipc::IPDLStructMember<TimeStamp> responseEnd_;
6331 ::mozilla::ipc::IPDLStructMember<TimeStamp> transactionPending_;
6332};
6333} // namespace net
6334} // namespace mozilla
6335
6336namespace IPC {
6337template<>
6338struct ParamTraits <::mozilla::net::TimingStructArgs>
6339{
6340 typedef ::mozilla::net::TimingStructArgs paramType;
6341 static void
6342 Write(
6343 IPC::MessageWriter* aWriter,
6344 const paramType& aVar);
6345 static IPC::ReadResult<paramType>
6346 Read(IPC::MessageReader* aReader);
6347};
6348} // namespace IPC
6349
6350
6351//-----------------------------------------------------------------------------
6352// Declaration of the IPDL type |struct ResourceTimingStructArgs|
6353//
6354namespace mozilla {
6355namespace net {
6356class ResourceTimingStructArgs final
6357{
6358private:
6359 typedef ::mozilla::TimeStamp TimeStamp;
6360 typedef ::uint64_t uint64_t;
6361
6362public:
6363#ifdef __clang__1
6364# pragma clang diagnostic push
6365# if __has_warning("-Wdefaulted-function-deleted")1
6366# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
6367# endif
6368#endif
6369 ResourceTimingStructArgs() = default;
6370#ifdef __clang__1
6371# pragma clang diagnostic pop
6372#endif
6373
6374 MOZ_IMPLICIT ResourceTimingStructArgs(
6375 const TimeStamp& _domainLookupStart,
6376 const TimeStamp& _domainLookupEnd,
6377 const TimeStamp& _connectStart,
6378 const TimeStamp& _tcpConnectEnd,
6379 const TimeStamp& _secureConnectionStart,
6380 const TimeStamp& _connectEnd,
6381 const TimeStamp& _requestStart,
6382 const TimeStamp& _responseStart,
6383 const TimeStamp& _responseEnd,
6384 const TimeStamp& _fetchStart,
6385 const TimeStamp& _redirectStart,
6386 const TimeStamp& _redirectEnd,
6387 const uint64_t& _transferSize,
6388 const uint64_t& _encodedBodySize,
6389 const TimeStamp& _cacheReadStart,
6390 const TimeStamp& _cacheReadEnd,
6391 const TimeStamp& _transactionPending) :
6392 domainLookupStart_(_domainLookupStart),
6393 domainLookupEnd_(_domainLookupEnd),
6394 connectStart_(_connectStart),
6395 tcpConnectEnd_(_tcpConnectEnd),
6396 secureConnectionStart_(_secureConnectionStart),
6397 connectEnd_(_connectEnd),
6398 requestStart_(_requestStart),
6399 responseStart_(_responseStart),
6400 responseEnd_(_responseEnd),
6401 fetchStart_(_fetchStart),
6402 redirectStart_(_redirectStart),
6403 redirectEnd_(_redirectEnd),
6404 cacheReadStart_(_cacheReadStart),
6405 cacheReadEnd_(_cacheReadEnd),
6406 transactionPending_(_transactionPending),
6407 transferSize_(_transferSize),
6408 encodedBodySize_(_encodedBodySize)
6409 {
6410 }
6411
6412 MOZ_IMPLICIT ResourceTimingStructArgs(
6413 TimeStamp&& _domainLookupStart,
6414 TimeStamp&& _domainLookupEnd,
6415 TimeStamp&& _connectStart,
6416 TimeStamp&& _tcpConnectEnd,
6417 TimeStamp&& _secureConnectionStart,
6418 TimeStamp&& _connectEnd,
6419 TimeStamp&& _requestStart,
6420 TimeStamp&& _responseStart,
6421 TimeStamp&& _responseEnd,
6422 TimeStamp&& _fetchStart,
6423 TimeStamp&& _redirectStart,
6424 TimeStamp&& _redirectEnd,
6425 uint64_t&& _transferSize,
6426 uint64_t&& _encodedBodySize,
6427 TimeStamp&& _cacheReadStart,
6428 TimeStamp&& _cacheReadEnd,
6429 TimeStamp&& _transactionPending) :
6430 domainLookupStart_(std::move(_domainLookupStart)),
6431 domainLookupEnd_(std::move(_domainLookupEnd)),
6432 connectStart_(std::move(_connectStart)),
6433 tcpConnectEnd_(std::move(_tcpConnectEnd)),
6434 secureConnectionStart_(std::move(_secureConnectionStart)),
6435 connectEnd_(std::move(_connectEnd)),
6436 requestStart_(std::move(_requestStart)),
6437 responseStart_(std::move(_responseStart)),
6438 responseEnd_(std::move(_responseEnd)),
6439 fetchStart_(std::move(_fetchStart)),
6440 redirectStart_(std::move(_redirectStart)),
6441 redirectEnd_(std::move(_redirectEnd)),
6442 cacheReadStart_(std::move(_cacheReadStart)),
6443 cacheReadEnd_(std::move(_cacheReadEnd)),
6444 transactionPending_(std::move(_transactionPending)),
6445 transferSize_(std::move(_transferSize)),
6446 encodedBodySize_(std::move(_encodedBodySize))
6447 {
6448 }
6449
6450 TimeStamp&
6451 domainLookupStart()
6452 {
6453 return domainLookupStart_;
6454 }
6455 const TimeStamp&
6456 domainLookupStart() const
6457 {
6458 return domainLookupStart_;
6459 }
6460
6461 TimeStamp&
6462 domainLookupEnd()
6463 {
6464 return domainLookupEnd_;
6465 }
6466 const TimeStamp&
6467 domainLookupEnd() const
6468 {
6469 return domainLookupEnd_;
6470 }
6471
6472 TimeStamp&
6473 connectStart()
6474 {
6475 return connectStart_;
6476 }
6477 const TimeStamp&
6478 connectStart() const
6479 {
6480 return connectStart_;
6481 }
6482
6483 TimeStamp&
6484 tcpConnectEnd()
6485 {
6486 return tcpConnectEnd_;
6487 }
6488 const TimeStamp&
6489 tcpConnectEnd() const
6490 {
6491 return tcpConnectEnd_;
6492 }
6493
6494 TimeStamp&
6495 secureConnectionStart()
6496 {
6497 return secureConnectionStart_;
6498 }
6499 const TimeStamp&
6500 secureConnectionStart() const
6501 {
6502 return secureConnectionStart_;
6503 }
6504
6505 TimeStamp&
6506 connectEnd()
6507 {
6508 return connectEnd_;
6509 }
6510 const TimeStamp&
6511 connectEnd() const
6512 {
6513 return connectEnd_;
6514 }
6515
6516 TimeStamp&
6517 requestStart()
6518 {
6519 return requestStart_;
6520 }
6521 const TimeStamp&
6522 requestStart() const
6523 {
6524 return requestStart_;
6525 }
6526
6527 TimeStamp&
6528 responseStart()
6529 {
6530 return responseStart_;
6531 }
6532 const TimeStamp&
6533 responseStart() const
6534 {
6535 return responseStart_;
6536 }
6537
6538 TimeStamp&
6539 responseEnd()
6540 {
6541 return responseEnd_;
6542 }
6543 const TimeStamp&
6544 responseEnd() const
6545 {
6546 return responseEnd_;
6547 }
6548
6549 TimeStamp&
6550 fetchStart()
6551 {
6552 return fetchStart_;
6553 }
6554 const TimeStamp&
6555 fetchStart() const
6556 {
6557 return fetchStart_;
6558 }
6559
6560 TimeStamp&
6561 redirectStart()
6562 {
6563 return redirectStart_;
6564 }
6565 const TimeStamp&
6566 redirectStart() const
6567 {
6568 return redirectStart_;
6569 }
6570
6571 TimeStamp&
6572 redirectEnd()
6573 {
6574 return redirectEnd_;
6575 }
6576 const TimeStamp&
6577 redirectEnd() const
6578 {
6579 return redirectEnd_;
6580 }
6581
6582 uint64_t&
6583 transferSize()
6584 {
6585 return transferSize_;
6586 }
6587 const uint64_t&
6588 transferSize() const
6589 {
6590 return transferSize_;
6591 }
6592
6593 uint64_t&
6594 encodedBodySize()
6595 {
6596 return encodedBodySize_;
6597 }
6598 const uint64_t&
6599 encodedBodySize() const
6600 {
6601 return encodedBodySize_;
6602 }
6603
6604 TimeStamp&
6605 cacheReadStart()
6606 {
6607 return cacheReadStart_;
6608 }
6609 const TimeStamp&
6610 cacheReadStart() const
6611 {
6612 return cacheReadStart_;
6613 }
6614
6615 TimeStamp&
6616 cacheReadEnd()
6617 {
6618 return cacheReadEnd_;
6619 }
6620 const TimeStamp&
6621 cacheReadEnd() const
6622 {
6623 return cacheReadEnd_;
6624 }
6625
6626 TimeStamp&
6627 transactionPending()
6628 {
6629 return transactionPending_;
6630 }
6631 const TimeStamp&
6632 transactionPending() const
6633 {
6634 return transactionPending_;
6635 }
6636
6637private:
6638 void
6639 StaticAssertions() const;
6640 ::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupStart_;
6641 ::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupEnd_;
6642 ::mozilla::ipc::IPDLStructMember<TimeStamp> connectStart_;
6643 ::mozilla::ipc::IPDLStructMember<TimeStamp> tcpConnectEnd_;
6644 ::mozilla::ipc::IPDLStructMember<TimeStamp> secureConnectionStart_;
6645 ::mozilla::ipc::IPDLStructMember<TimeStamp> connectEnd_;
6646 ::mozilla::ipc::IPDLStructMember<TimeStamp> requestStart_;
6647 ::mozilla::ipc::IPDLStructMember<TimeStamp> responseStart_;
6648 ::mozilla::ipc::IPDLStructMember<TimeStamp> responseEnd_;
6649 ::mozilla::ipc::IPDLStructMember<TimeStamp> fetchStart_;
6650 ::mozilla::ipc::IPDLStructMember<TimeStamp> redirectStart_;
6651 ::mozilla::ipc::IPDLStructMember<TimeStamp> redirectEnd_;
6652 ::mozilla::ipc::IPDLStructMember<TimeStamp> cacheReadStart_;
6653 ::mozilla::ipc::IPDLStructMember<TimeStamp> cacheReadEnd_;
6654 ::mozilla::ipc::IPDLStructMember<TimeStamp> transactionPending_;
6655 ::mozilla::ipc::IPDLStructMember<uint64_t> transferSize_;
6656 ::mozilla::ipc::IPDLStructMember<uint64_t> encodedBodySize_;
6657};
6658} // namespace net
6659} // namespace mozilla
6660
6661namespace IPC {
6662template<>
6663struct ParamTraits <::mozilla::net::ResourceTimingStructArgs>
6664{
6665 typedef ::mozilla::net::ResourceTimingStructArgs paramType;
6666 static void
6667 Write(
6668 IPC::MessageWriter* aWriter,
6669 const paramType& aVar);
6670 static IPC::ReadResult<paramType>
6671 Read(IPC::MessageReader* aReader);
6672};
6673} // namespace IPC
6674
6675
6676//-----------------------------------------------------------------------------
6677// Declaration of the IPDL type |struct HttpActivity|
6678//
6679namespace mozilla {
6680namespace net {
6681class HttpActivity final
6682{
6683private:
6684 typedef ::nsCString nsCString;
6685 typedef ::int32_t int32_t;
6686
6687public:
6688#ifdef __clang__1
6689# pragma clang diagnostic push
6690# if __has_warning("-Wdefaulted-function-deleted")1
6691# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
6692# endif
6693#endif
6694 HttpActivity() = default;
6695#ifdef __clang__1
6696# pragma clang diagnostic pop
6697#endif
6698
6699 MOZ_IMPLICIT HttpActivity(
6700 const nsCString& _host,
6701 const int32_t& _port,
6702 const bool& _endToEndSSL) :
6703 host_(_host),
6704 endToEndSSL_(_endToEndSSL),
6705 port_(_port)
6706 {
6707 }
6708
6709 MOZ_IMPLICIT HttpActivity(
6710 nsCString&& _host,
6711 int32_t&& _port,
6712 bool&& _endToEndSSL) :
6713 host_(std::move(_host)),
6714 endToEndSSL_(std::move(_endToEndSSL)),
6715 port_(std::move(_port))
6716 {
6717 }
6718
6719 nsCString&
6720 host()
6721 {
6722 return host_;
6723 }
6724 const nsCString&
6725 host() const
6726 {
6727 return host_;
6728 }
6729
6730 int32_t&
6731 port()
6732 {
6733 return port_;
6734 }
6735 const int32_t&
6736 port() const
6737 {
6738 return port_;
6739 }
6740
6741 bool&
6742 endToEndSSL()
6743 {
6744 return endToEndSSL_;
6745 }
6746 const bool&
6747 endToEndSSL() const
6748 {
6749 return endToEndSSL_;
6750 }
6751
6752private:
6753 ::mozilla::ipc::IPDLStructMember<nsCString> host_;
6754 ::mozilla::ipc::IPDLStructMember<bool> endToEndSSL_;
6755 ::mozilla::ipc::IPDLStructMember<int32_t> port_;
6756};
6757} // namespace net
6758} // namespace mozilla
6759
6760namespace IPC {
6761template<>
6762struct ParamTraits <::mozilla::net::HttpActivity>
6763{
6764 typedef ::mozilla::net::HttpActivity paramType;
6765 static void
6766 Write(
6767 IPC::MessageWriter* aWriter,
6768 const paramType& aVar);
6769 static IPC::ReadResult<paramType>
6770 Read(IPC::MessageReader* aReader);
6771};
6772} // namespace IPC
6773
6774
6775//-----------------------------------------------------------------------------
6776// Declaration of the IPDL type |struct HttpConnectionActivity|
6777//
6778namespace mozilla {
6779namespace net {
6780class HttpConnectionActivity final
6781{
6782private:
6783 typedef ::nsCString nsCString;
6784 typedef ::int32_t int32_t;
6785
6786public:
6787#ifdef __clang__1
6788# pragma clang diagnostic push
6789# if __has_warning("-Wdefaulted-function-deleted")1
6790# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
6791# endif
6792#endif
6793 HttpConnectionActivity() = default;
6794#ifdef __clang__1
6795# pragma clang diagnostic pop
6796#endif
6797
6798 MOZ_IMPLICIT HttpConnectionActivity(
6799 const nsCString& _connInfoKey,
6800 const nsCString& _host,
6801 const int32_t& _port,
6802 const bool& _ssl,
6803 const bool& _hasECH,
6804 const bool& _isHttp3) :
6805 connInfoKey_(_connInfoKey),
6806 host_(_host),
6807 ssl_(_ssl),
6808 hasECH_(_hasECH),
6809 isHttp3_(_isHttp3),
6810 port_(_port)
6811 {
6812 }
6813
6814 MOZ_IMPLICIT HttpConnectionActivity(
6815 nsCString&& _connInfoKey,
6816 nsCString&& _host,
6817 int32_t&& _port,
6818 bool&& _ssl,
6819 bool&& _hasECH,
6820 bool&& _isHttp3) :
6821 connInfoKey_(std::move(_connInfoKey)),
6822 host_(std::move(_host)),
6823 ssl_(std::move(_ssl)),
6824 hasECH_(std::move(_hasECH)),
6825 isHttp3_(std::move(_isHttp3)),
6826 port_(std::move(_port))
6827 {
6828 }
6829
6830 nsCString&
6831 connInfoKey()
6832 {
6833 return connInfoKey_;
6834 }
6835 const nsCString&
6836 connInfoKey() const
6837 {
6838 return connInfoKey_;
6839 }
6840
6841 nsCString&
6842 host()
6843 {
6844 return host_;
6845 }
6846 const nsCString&
6847 host() const
6848 {
6849 return host_;
6850 }
6851
6852 int32_t&
6853 port()
6854 {
6855 return port_;
6856 }
6857 const int32_t&
6858 port() const
6859 {
6860 return port_;
6861 }
6862
6863 bool&
6864 ssl()
6865 {
6866 return ssl_;
6867 }
6868 const bool&
6869 ssl() const
6870 {
6871 return ssl_;
6872 }
6873
6874 bool&
6875 hasECH()
6876 {
6877 return hasECH_;
6878 }
6879 const bool&
6880 hasECH() const
6881 {
6882 return hasECH_;
6883 }
6884
6885 bool&
6886 isHttp3()
6887 {
6888 return isHttp3_;
6889 }
6890 const bool&
6891 isHttp3() const
6892 {
6893 return isHttp3_;
6894 }
6895
6896private:
6897 ::mozilla::ipc::IPDLStructMember<nsCString> connInfoKey_;
6898 ::mozilla::ipc::IPDLStructMember<nsCString> host_;
6899 ::mozilla::ipc::IPDLStructMember<bool> ssl_;
6900 ::mozilla::ipc::IPDLStructMember<bool> hasECH_;
6901 ::mozilla::ipc::IPDLStructMember<bool> isHttp3_;
6902 ::mozilla::ipc::IPDLStructMember<int32_t> port_;
6903};
6904} // namespace net
6905} // namespace mozilla
6906
6907namespace IPC {
6908template<>
6909struct ParamTraits <::mozilla::net::HttpConnectionActivity>
6910{
6911 typedef ::mozilla::net::HttpConnectionActivity paramType;
6912 static void
6913 Write(
6914 IPC::MessageWriter* aWriter,
6915 const paramType& aVar);
6916 static IPC::ReadResult<paramType>
6917 Read(IPC::MessageReader* aReader);
6918};
6919} // namespace IPC
6920
6921
6922//-----------------------------------------------------------------------------
6923// Declaration of the IPDL type |union HttpActivityArgs|
6924//
6925namespace mozilla {
6926namespace net {
6927class HttpActivityArgs final
6928{
6929public:
6930 enum Type {
6931 T__None,
6932 Tuint64_t = 1,
6933 THttpActivity,
6934 THttpConnectionActivity,
6935 T__Last = THttpConnectionActivity
6936 };
6937
6938private:
6939 typedef ::uint64_t uint64_t;
6940 typedef ::mozilla::net::HttpActivity HttpActivity;
6941 typedef ::mozilla::net::HttpConnectionActivity HttpConnectionActivity;
6942 typedef uint64_t uint64_t__tdef;
6943 typedef HttpActivity HttpActivity__tdef;
6944 typedef HttpConnectionActivity HttpConnectionActivity__tdef;
6945
6946 uint64_t*
6947 ptr_uint64_t()
6948 {
6949 return (&(mVuint64_t));
6950 }
6951 const uint64_t*
6952 constptr_uint64_t() const
6953 {
6954 return (&(mVuint64_t));
6955 }
6956 HttpActivity*
6957 ptr_HttpActivity()
6958 {
6959 return (&(mVHttpActivity));
6960 }
6961 const HttpActivity*
6962 constptr_HttpActivity() const
6963 {
6964 return (&(mVHttpActivity));
6965 }
6966 HttpConnectionActivity*
6967 ptr_HttpConnectionActivity()
6968 {
6969 return (&(mVHttpConnectionActivity));
6970 }
6971 const HttpConnectionActivity*
6972 constptr_HttpConnectionActivity() const
6973 {
6974 return (&(mVHttpConnectionActivity));
6975 }
6976
6977 void
6978 MaybeDestroy();
6979
6980 void
6981 AssertSanity() const
6982 {
6983 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" ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/net/NeckoChannelParams.h"
, 6983); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(T__None) <= (mType)"
") (" "invalid type tag" ")"); do { *((volatile int*)__null)
= 6983; __attribute__((nomerge)) ::abort(); } while (false);
} } while (false)
;
6984 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" ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/net/NeckoChannelParams.h"
, 6984); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(mType) <= (T__Last)"
") (" "invalid type tag" ")"); do { *((volatile int*)__null)
= 6984; __attribute__((nomerge)) ::abort(); } while (false);
} } while (false)
;
6985 }
6986 void
6987 AssertSanity(Type aType) const
6988 {
6989 AssertSanity();
6990 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" ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/net/NeckoChannelParams.h"
, 6990); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(mType) == (aType)"
") (" "unexpected type tag" ")"); do { *((volatile int*)__null
) = 6990; __attribute__((nomerge)) ::abort(); } while (false)
; } } while (false)
;
6991 }
6992
6993public:
6994 MOZ_IMPLICIT HttpActivityArgs() :
6995 mType(T__None)
6996 {
6997 }
6998
6999 MOZ_IMPLICIT HttpActivityArgs(const uint64_t& aOther);
7000
7001 MOZ_IMPLICIT HttpActivityArgs(uint64_t&& aOther);
7002
7003 MOZ_IMPLICIT HttpActivityArgs(const HttpActivity& aOther);
7004
7005 MOZ_IMPLICIT HttpActivityArgs(HttpActivity&& aOther);
7006
7007 MOZ_IMPLICIT HttpActivityArgs(const HttpConnectionActivity& aOther);
7008
7009 MOZ_IMPLICIT HttpActivityArgs(HttpConnectionActivity&& aOther);
7010
7011 MOZ_IMPLICIT HttpActivityArgs(const HttpActivityArgs& aOther);
7012
7013 MOZ_IMPLICIT HttpActivityArgs(HttpActivityArgs&& aOther);
7014
7015 ~HttpActivityArgs();
7016
7017 Type
7018 type() const
7019 {
7020 return mType;
7021 }
7022
7023 HttpActivityArgs&
7024 operator=(const uint64_t& aRhs);
7025
7026 HttpActivityArgs&
7027 operator=(uint64_t&& aRhs);
7028
7029 HttpActivityArgs&
7030 operator=(const HttpActivity& aRhs);
7031
7032 HttpActivityArgs&
7033 operator=(HttpActivity&& aRhs);
7034
7035 HttpActivityArgs&
7036 operator=(const HttpConnectionActivity& aRhs);
7037
7038 HttpActivityArgs&
7039 operator=(HttpConnectionActivity&& aRhs);
7040
7041 HttpActivityArgs&
7042 operator=(const HttpActivityArgs& aRhs);
7043
7044 HttpActivityArgs&
7045 operator=(HttpActivityArgs&& aRhs);
7046
7047 uint64_t&
7048 get_uint64_t()
7049 {
7050 AssertSanity(Tuint64_t);
7051 return (*(ptr_uint64_t()));
7052 }
7053 const uint64_t&
7054 get_uint64_t() const
7055 {
7056 AssertSanity(Tuint64_t);
7057 return (*(constptr_uint64_t()));
7058 }
7059 operator uint64_t&()
7060 {
7061 return get_uint64_t();
7062 }
7063 operator const uint64_t&() const
7064 {
7065 return get_uint64_t();
7066 }
7067
7068 HttpActivity&
7069 get_HttpActivity()
7070 {
7071 AssertSanity(THttpActivity);
7072 return (*(ptr_HttpActivity()));
7073 }
7074 const HttpActivity&
7075 get_HttpActivity() const
7076 {
7077 AssertSanity(THttpActivity);
7078 return (*(constptr_HttpActivity()));
7079 }
7080 operator HttpActivity&()
7081 {
7082 return get_HttpActivity();
7083 }
7084 operator const HttpActivity&() const
7085 {
7086 return get_HttpActivity();
7087 }
7088
7089 HttpConnectionActivity&
7090 get_HttpConnectionActivity()
7091 {
7092 AssertSanity(THttpConnectionActivity);
7093 return (*(ptr_HttpConnectionActivity()));
7094 }
7095 const HttpConnectionActivity&
7096 get_HttpConnectionActivity() const
7097 {
7098 AssertSanity(THttpConnectionActivity);
7099 return (*(constptr_HttpConnectionActivity()));
7100 }
7101 operator HttpConnectionActivity&()
7102 {
7103 return get_HttpConnectionActivity();
7104 }
7105 operator const HttpConnectionActivity&() const
7106 {
7107 return get_HttpConnectionActivity();
7108 }
7109
7110private:
7111 union {
7112 uint64_t mVuint64_t;
7113 HttpActivity mVHttpActivity;
7114 HttpConnectionActivity mVHttpConnectionActivity;
7115 };
7116 Type mType;
7117};
7118} // namespace net
7119} // namespace mozilla
7120
7121namespace IPC {
7122template<>
7123struct ParamTraits <::mozilla::net::HttpActivityArgs>
7124{
7125 typedef ::mozilla::net::HttpActivityArgs paramType;
7126 static void
7127 Write(
7128 IPC::MessageWriter* aWriter,
7129 const paramType& aVar);
7130 static IPC::ReadResult<paramType>
7131 Read(IPC::MessageReader* aReader);
7132};
7133} // namespace IPC
7134
7135
7136//-----------------------------------------------------------------------------
7137// Declaration of the IPDL type |struct TransactionObserverResult|
7138//
7139namespace mozilla {
7140namespace net {
7141class TransactionObserverResult final
7142{
7143private:
7144 typedef ::nsresult nsresult;
7145
7146public:
7147#ifdef __clang__1
7148# pragma clang diagnostic push
7149# if __has_warning("-Wdefaulted-function-deleted")1
7150# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
7151# endif
7152#endif
7153 TransactionObserverResult() = default;
7154#ifdef __clang__1
7155# pragma clang diagnostic pop
7156#endif
7157
7158 MOZ_IMPLICIT TransactionObserverResult(
7159 const bool& _versionOk,
7160 const bool& _authOk,
7161 const nsresult& _closeReason) :
7162 versionOk_(_versionOk),
7163 authOk_(_authOk),
7164 closeReason_(_closeReason)
7165 {
7166 }
7167
7168 MOZ_IMPLICIT TransactionObserverResult(
7169 bool&& _versionOk,
7170 bool&& _authOk,
7171 nsresult&& _closeReason) :
7172 versionOk_(std::move(_versionOk)),
7173 authOk_(std::move(_authOk)),
7174 closeReason_(std::move(_closeReason))
7175 {
7176 }
7177
7178 bool&
7179 versionOk()
7180 {
7181 return versionOk_;
7182 }
7183 const bool&
7184 versionOk() const
7185 {
7186 return versionOk_;
7187 }
7188
7189 bool&
7190 authOk()
7191 {
7192 return authOk_;
7193 }
7194 const bool&
7195 authOk() const
7196 {
7197 return authOk_;
7198 }
7199
7200 nsresult&
7201 closeReason()
7202 {
7203 return closeReason_;
7204 }
7205 const nsresult&
7206 closeReason() const
7207 {
7208 return closeReason_;
7209 }
7210
7211private:
7212 ::mozilla::ipc::IPDLStructMember<bool> versionOk_;
7213 ::mozilla::ipc::IPDLStructMember<bool> authOk_;
7214 ::mozilla::ipc::IPDLStructMember<nsresult> closeReason_;
7215};
7216} // namespace net
7217} // namespace mozilla
7218
7219namespace IPC {
7220template<>
7221struct ParamTraits <::mozilla::net::TransactionObserverResult>
7222{
7223 typedef ::mozilla::net::TransactionObserverResult paramType;
7224 static void
7225 Write(
7226 IPC::MessageWriter* aWriter,
7227 const paramType& aVar);
7228 static IPC::ReadResult<paramType>
7229 Read(IPC::MessageReader* aReader);
7230};
7231} // namespace IPC
7232
7233
7234//-----------------------------------------------------------------------------
7235// Declaration of the IPDL type |struct SpeculativeConnectionOverriderArgs|
7236//
7237namespace mozilla {
7238namespace net {
7239class SpeculativeConnectionOverriderArgs final
7240{
7241private:
7242 typedef ::uint32_t uint32_t;
7243
7244public:
7245#ifdef __clang__1
7246# pragma clang diagnostic push
7247# if __has_warning("-Wdefaulted-function-deleted")1
7248# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
7249# endif
7250#endif
7251 SpeculativeConnectionOverriderArgs() = default;
7252#ifdef __clang__1
7253# pragma clang diagnostic pop
7254#endif
7255
7256 MOZ_IMPLICIT SpeculativeConnectionOverriderArgs(
7257 const uint32_t& _parallelSpeculativeConnectLimit,
7258 const bool& _ignoreIdle,
7259 const bool& _isFromPredictor,
7260 const bool& _allow1918) :
7261 ignoreIdle_(_ignoreIdle),
7262 isFromPredictor_(_isFromPredictor),
7263 allow1918_(_allow1918),
7264 parallelSpeculativeConnectLimit_(_parallelSpeculativeConnectLimit)
7265 {
7266 }
7267
7268 MOZ_IMPLICIT SpeculativeConnectionOverriderArgs(
7269 uint32_t&& _parallelSpeculativeConnectLimit,
7270 bool&& _ignoreIdle,
7271 bool&& _isFromPredictor,
7272 bool&& _allow1918) :
7273 ignoreIdle_(std::move(_ignoreIdle)),
7274 isFromPredictor_(std::move(_isFromPredictor)),
7275 allow1918_(std::move(_allow1918)),
7276 parallelSpeculativeConnectLimit_(std::move(_parallelSpeculativeConnectLimit))
7277 {
7278 }
7279
7280 uint32_t&
7281 parallelSpeculativeConnectLimit()
7282 {
7283 return parallelSpeculativeConnectLimit_;
7284 }
7285 const uint32_t&
7286 parallelSpeculativeConnectLimit() const
7287 {
7288 return parallelSpeculativeConnectLimit_;
7289 }
7290
7291 bool&
7292 ignoreIdle()
7293 {
7294 return ignoreIdle_;
7295 }
7296 const bool&
7297 ignoreIdle() const
7298 {
7299 return ignoreIdle_;
7300 }
7301
7302 bool&
7303 isFromPredictor()
7304 {
7305 return isFromPredictor_;
7306 }
7307 const bool&
7308 isFromPredictor() const
7309 {
7310 return isFromPredictor_;
7311 }
7312
7313 bool&
7314 allow1918()
7315 {
7316 return allow1918_;
7317 }
7318 const bool&
7319 allow1918() const
7320 {
7321 return allow1918_;
7322 }
7323
7324private:
7325 ::mozilla::ipc::IPDLStructMember<bool> ignoreIdle_;
7326 ::mozilla::ipc::IPDLStructMember<bool> isFromPredictor_;
7327 ::mozilla::ipc::IPDLStructMember<bool> allow1918_;
7328 ::mozilla::ipc::IPDLStructMember<uint32_t> parallelSpeculativeConnectLimit_;
7329};
7330} // namespace net
7331} // namespace mozilla
7332
7333namespace IPC {
7334template<>
7335struct ParamTraits <::mozilla::net::SpeculativeConnectionOverriderArgs>
7336{
7337 typedef ::mozilla::net::SpeculativeConnectionOverriderArgs paramType;
7338 static void
7339 Write(
7340 IPC::MessageWriter* aWriter,
7341 const paramType& aVar);
7342 static IPC::ReadResult<paramType>
7343 Read(IPC::MessageReader* aReader);
7344};
7345} // namespace IPC
7346
7347
7348//-----------------------------------------------------------------------------
7349// Declaration of the IPDL type |struct GIOChannelOpenArgs|
7350//
7351namespace mozilla {
7352namespace net {
7353class GIOChannelOpenArgs final
7354{
7355private:
7356 typedef ::mozilla::ipc::URIParams URIParams;
7357 typedef ::uint64_t uint64_t;
7358 typedef ::nsCString nsCString;
7359 typedef ::mozilla::ipc::IPCStream IPCStream;
7360 typedef ::mozilla::net::LoadInfoArgs LoadInfoArgs;
7361 typedef ::uint32_t uint32_t;
7362
7363public:
7364#ifdef __clang__1
7365# pragma clang diagnostic push
7366# if __has_warning("-Wdefaulted-function-deleted")1
7367# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
7368# endif
7369#endif
7370 GIOChannelOpenArgs() = default;
7371#ifdef __clang__1
7372# pragma clang diagnostic pop
7373#endif
7374
7375 MOZ_IMPLICIT GIOChannelOpenArgs(
7376 const URIParams& _uri,
7377 const uint64_t& _startPos,
7378 const nsCString& _entityID,
7379 const mozilla::Maybe<IPCStream>& _uploadStream,
7380 const LoadInfoArgs& _loadInfo,
7381 const uint32_t& _loadFlags) :
7382 uri_(_uri),
7383 entityID_(_entityID),
7384 uploadStream_(_uploadStream),
7385 loadInfo_(_loadInfo),
7386 startPos_(_startPos),
7387 loadFlags_(_loadFlags)
7388 {
7389 }
7390
7391 MOZ_IMPLICIT GIOChannelOpenArgs(
7392 URIParams&& _uri,
7393 uint64_t&& _startPos,
7394 nsCString&& _entityID,
7395 mozilla::Maybe<IPCStream>&& _uploadStream,
7396 LoadInfoArgs&& _loadInfo,
7397 uint32_t&& _loadFlags) :
7398 uri_(std::move(_uri)),
7399 entityID_(std::move(_entityID)),
7400 uploadStream_(std::move(_uploadStream)),
7401 loadInfo_(std::move(_loadInfo)),
7402 startPos_(std::move(_startPos)),
7403 loadFlags_(std::move(_loadFlags))
7404 {
7405 }
7406
7407 URIParams&
7408 uri()
7409 {
7410 return uri_;
7411 }
7412 const URIParams&
7413 uri() const
7414 {
7415 return uri_;
7416 }
7417
7418 uint64_t&
7419 startPos()
7420 {
7421 return startPos_;
7422 }
7423 const uint64_t&
7424 startPos() const
7425 {
7426 return startPos_;
7427 }
7428
7429 nsCString&
7430 entityID()
7431 {
7432 return entityID_;
7433 }
7434 const nsCString&
7435 entityID() const
7436 {
7437 return entityID_;
7438 }
7439
7440 mozilla::Maybe<IPCStream>&
7441 uploadStream()
7442 {
7443 return uploadStream_;
7444 }
7445 const mozilla::Maybe<IPCStream>&
7446 uploadStream() const
7447 {
7448 return uploadStream_;
7449 }
7450
7451 LoadInfoArgs&
7452 loadInfo()
7453 {
7454 return loadInfo_;
7455 }
7456 const LoadInfoArgs&
7457 loadInfo() const
7458 {
7459 return loadInfo_;
7460 }
7461
7462 uint32_t&
7463 loadFlags()
7464 {
7465 return loadFlags_;
7466 }
7467 const uint32_t&
7468 loadFlags() const
7469 {
7470 return loadFlags_;
7471 }
7472
7473private:
7474 ::mozilla::ipc::IPDLStructMember<URIParams> uri_;
7475 ::mozilla::ipc::IPDLStructMember<nsCString> entityID_;
7476 ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCStream>> uploadStream_;
7477 ::mozilla::ipc::IPDLStructMember<LoadInfoArgs> loadInfo_;
7478 ::mozilla::ipc::IPDLStructMember<uint64_t> startPos_;
7479 ::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
7480};
7481} // namespace net
7482} // namespace mozilla
7483
7484namespace IPC {
7485template<>
7486struct ParamTraits <::mozilla::net::GIOChannelOpenArgs>
7487{
7488 typedef ::mozilla::net::GIOChannelOpenArgs paramType;
7489 static void
7490 Write(
7491 IPC::MessageWriter* aWriter,
7492 const paramType& aVar);
7493 static IPC::ReadResult<paramType>
7494 Read(IPC::MessageReader* aReader);
7495};
7496} // namespace IPC
7497
7498
7499//-----------------------------------------------------------------------------
7500// Declaration of the IPDL type |struct GIOChannelConnectArgs|
7501//
7502namespace mozilla {
7503namespace net {
7504class GIOChannelConnectArgs final
7505{
7506private:
7507 typedef ::uint32_t uint32_t;
7508
7509public:
7510#ifdef __clang__1
7511# pragma clang diagnostic push
7512# if __has_warning("-Wdefaulted-function-deleted")1
7513# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
7514# endif
7515#endif
7516 GIOChannelConnectArgs() = default;
7517#ifdef __clang__1
7518# pragma clang diagnostic pop
7519#endif
7520
7521 MOZ_IMPLICIT GIOChannelConnectArgs(const uint32_t& _channelId) :
7522 channelId_(_channelId)
7523 {
7524 }
7525
7526 MOZ_IMPLICIT GIOChannelConnectArgs(uint32_t&& _channelId) :
7527 channelId_(std::move(_channelId))
7528 {
7529 }
7530
7531 uint32_t&
7532 channelId()
7533 {
7534 return channelId_;
7535 }
7536 const uint32_t&
7537 channelId() const
7538 {
7539 return channelId_;
7540 }
7541
7542private:
7543 ::mozilla::ipc::IPDLStructMember<uint32_t> channelId_;
7544};
7545} // namespace net
7546} // namespace mozilla
7547
7548namespace IPC {
7549template<>
7550struct ParamTraits <::mozilla::net::GIOChannelConnectArgs>
7551{
7552 typedef ::mozilla::net::GIOChannelConnectArgs paramType;
7553 static void
7554 Write(
7555 IPC::MessageWriter* aWriter,
7556 const paramType& aVar);
7557 static IPC::ReadResult<paramType>
7558 Read(IPC::MessageReader* aReader);
7559};
7560} // namespace IPC
7561
7562
7563//-----------------------------------------------------------------------------
7564// Declaration of the IPDL type |union GIOChannelCreationArgs|
7565//
7566namespace mozilla {
7567namespace net {
7568class GIOChannelCreationArgs final
7569{
7570public:
7571 enum Type {
7572 T__None,
7573 TGIOChannelOpenArgs = 1,
7574 TGIOChannelConnectArgs,
7575 T__Last = TGIOChannelConnectArgs
7576 };
7577
7578private:
7579 typedef ::mozilla::net::GIOChannelOpenArgs GIOChannelOpenArgs;
7580 typedef ::mozilla::net::GIOChannelConnectArgs GIOChannelConnectArgs;
7581 typedef GIOChannelOpenArgs GIOChannelOpenArgs__tdef;
7582 typedef GIOChannelConnectArgs GIOChannelConnectArgs__tdef;
7583
7584 GIOChannelOpenArgs*
7585 ptr_GIOChannelOpenArgs()
7586 {
7587 return (&(mVGIOChannelOpenArgs));
7588 }
7589 const GIOChannelOpenArgs*
7590 constptr_GIOChannelOpenArgs() const
7591 {
7592 return (&(mVGIOChannelOpenArgs));
7593 }
7594 GIOChannelConnectArgs*
7595 ptr_GIOChannelConnectArgs()
7596 {
7597 return (&(mVGIOChannelConnectArgs));
7598 }
7599 const GIOChannelConnectArgs*
7600 constptr_GIOChannelConnectArgs() const
7601 {
7602 return (&(mVGIOChannelConnectArgs));
7603 }
7604
7605 void
7606 MaybeDestroy();
7607
7608 void
7609 AssertSanity() const
7610 {
7611 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" ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/net/NeckoChannelParams.h"
, 7611); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(T__None) <= (mType)"
") (" "invalid type tag" ")"); do { *((volatile int*)__null)
= 7611; __attribute__((nomerge)) ::abort(); } while (false);
} } while (false)
;
7612 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" ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/net/NeckoChannelParams.h"
, 7612); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(mType) <= (T__Last)"
") (" "invalid type tag" ")"); do { *((volatile int*)__null)
= 7612; __attribute__((nomerge)) ::abort(); } while (false);
} } while (false)
;
7613 }
7614 void
7615 AssertSanity(Type aType) const
7616 {
7617 AssertSanity();
7618 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" ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders/mozilla/net/NeckoChannelParams.h"
, 7618); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "(mType) == (aType)"
") (" "unexpected type tag" ")"); do { *((volatile int*)__null
) = 7618; __attribute__((nomerge)) ::abort(); } while (false)
; } } while (false)
;
7619 }
7620
7621public:
7622 MOZ_IMPLICIT GIOChannelCreationArgs() :
7623 mType(T__None)
7624 {
7625 }
7626
7627 MOZ_IMPLICIT GIOChannelCreationArgs(const GIOChannelOpenArgs& aOther);
7628
7629 MOZ_IMPLICIT GIOChannelCreationArgs(GIOChannelOpenArgs&& aOther);
7630
7631 MOZ_IMPLICIT GIOChannelCreationArgs(const GIOChannelConnectArgs& aOther);
7632
7633 MOZ_IMPLICIT GIOChannelCreationArgs(GIOChannelConnectArgs&& aOther);
7634
7635 MOZ_IMPLICIT GIOChannelCreationArgs(const GIOChannelCreationArgs& aOther);
7636
7637 MOZ_IMPLICIT GIOChannelCreationArgs(GIOChannelCreationArgs&& aOther);
7638
7639 ~GIOChannelCreationArgs();
7640
7641 Type
7642 type() const
7643 {
7644 return mType;
7645 }
7646
7647 GIOChannelCreationArgs&
7648 operator=(const GIOChannelOpenArgs& aRhs);
7649
7650 GIOChannelCreationArgs&
7651 operator=(GIOChannelOpenArgs&& aRhs);
7652
7653 GIOChannelCreationArgs&
7654 operator=(const GIOChannelConnectArgs& aRhs);
7655
7656 GIOChannelCreationArgs&
7657 operator=(GIOChannelConnectArgs&& aRhs);
7658
7659 GIOChannelCreationArgs&
7660 operator=(const GIOChannelCreationArgs& aRhs);
7661
7662 GIOChannelCreationArgs&
7663 operator=(GIOChannelCreationArgs&& aRhs);
7664
7665 GIOChannelOpenArgs&
7666 get_GIOChannelOpenArgs()
7667 {
7668 AssertSanity(TGIOChannelOpenArgs);
7669 return (*(ptr_GIOChannelOpenArgs()));
7670 }
7671 const GIOChannelOpenArgs&
7672 get_GIOChannelOpenArgs() const
7673 {
7674 AssertSanity(TGIOChannelOpenArgs);
7675 return (*(constptr_GIOChannelOpenArgs()));
7676 }
7677 operator GIOChannelOpenArgs&()
7678 {
7679 return get_GIOChannelOpenArgs();
7680 }
7681 operator const GIOChannelOpenArgs&() const
7682 {
7683 return get_GIOChannelOpenArgs();
7684 }
7685
7686 GIOChannelConnectArgs&
7687 get_GIOChannelConnectArgs()
7688 {
7689 AssertSanity(TGIOChannelConnectArgs);
7690 return (*(ptr_GIOChannelConnectArgs()));
7691 }
7692 const GIOChannelConnectArgs&
7693 get_GIOChannelConnectArgs() const
7694 {
7695 AssertSanity(TGIOChannelConnectArgs);
7696 return (*(constptr_GIOChannelConnectArgs()));
7697 }
7698 operator GIOChannelConnectArgs&()
7699 {
7700 return get_GIOChannelConnectArgs();
7701 }
7702 operator const GIOChannelConnectArgs&() const
7703 {
7704 return get_GIOChannelConnectArgs();
7705 }
7706
7707private:
7708 union {
7709 GIOChannelOpenArgs mVGIOChannelOpenArgs;
7710 GIOChannelConnectArgs mVGIOChannelConnectArgs;
7711 };
7712 Type mType;
7713};
7714} // namespace net
7715} // namespace mozilla
7716
7717namespace IPC {
7718template<>
7719struct ParamTraits <::mozilla::net::GIOChannelCreationArgs>
7720{
7721 typedef ::mozilla::net::GIOChannelCreationArgs paramType;
7722 static void
7723 Write(
7724 IPC::MessageWriter* aWriter,
7725 const paramType& aVar);
7726 static IPC::ReadResult<paramType>
7727 Read(IPC::MessageReader* aReader);
7728};
7729} // namespace IPC
7730
7731
7732//-----------------------------------------------------------------------------
7733// Declaration of the IPDL type |struct DataChannelInfo|
7734//
7735namespace mozilla {
7736namespace net {
7737class DataChannelInfo final
7738{
7739private:
7740 typedef ::nsIURI nsIURI;
7741 typedef ::uint32_t uint32_t;
7742 typedef ::mozilla::net::LoadInfoArgs LoadInfoArgs;
7743 typedef ::nsCString nsCString;
7744
7745public:
7746#ifdef __clang__1
7747# pragma clang diagnostic push
7748# if __has_warning("-Wdefaulted-function-deleted")1
7749# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
7750# endif
7751#endif
7752 DataChannelInfo() = default;
7753#ifdef __clang__1
7754# pragma clang diagnostic pop
7755#endif
7756
7757 MOZ_IMPLICIT DataChannelInfo(
7758 nsIURI* _uri,
7759 const uint32_t& _loadFlags,
7760 const LoadInfoArgs& _loadInfo,
7761 const nsCString& _contentType) :
7762 uri_(_uri),
7763 loadInfo_(_loadInfo),
7764 contentType_(_contentType),
7765 loadFlags_(_loadFlags)
7766 {
7767 }
7768
7769 MOZ_IMPLICIT DataChannelInfo(
7770 RefPtr<nsIURI>&& _uri,
7771 uint32_t&& _loadFlags,
7772 LoadInfoArgs&& _loadInfo,
7773 nsCString&& _contentType) :
7774 uri_(std::move(_uri)),
7775 loadInfo_(std::move(_loadInfo)),
7776 contentType_(std::move(_contentType)),
7777 loadFlags_(std::move(_loadFlags))
7778 {
7779 }
7780
7781 RefPtr<nsIURI>&
7782 uri()
7783 {
7784 return uri_;
7785 }
7786 nsIURI*
7787 uri() const
7788 {
7789 return uri_;
7790 }
7791
7792 uint32_t&
7793 loadFlags()
7794 {
7795 return loadFlags_;
7796 }
7797 const uint32_t&
7798 loadFlags() const
7799 {
7800 return loadFlags_;
7801 }
7802
7803 LoadInfoArgs&
7804 loadInfo()
7805 {
7806 return loadInfo_;
7807 }
7808 const LoadInfoArgs&
7809 loadInfo() const
7810 {
7811 return loadInfo_;
7812 }
7813
7814 nsCString&
7815 contentType()
7816 {
7817 return contentType_;
7818 }
7819 const nsCString&
7820 contentType() const
7821 {
7822 return contentType_;
7823 }
7824
7825private:
7826 ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> uri_;
7827 ::mozilla::ipc::IPDLStructMember<LoadInfoArgs> loadInfo_;
7828 ::mozilla::ipc::IPDLStructMember<nsCString> contentType_;
7829 ::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
7830};
7831} // namespace net
7832} // namespace mozilla
7833
7834namespace IPC {
7835template<>
7836struct ParamTraits <::mozilla::net::DataChannelInfo>
7837{
7838 typedef ::mozilla::net::DataChannelInfo paramType;
7839 static void
7840 Write(
7841 IPC::MessageWriter* aWriter,
7842 const paramType& aVar);
7843 static IPC::ReadResult<paramType>
7844 Read(IPC::MessageReader* aReader);
7845};
7846} // namespace IPC
7847
7848
7849//-----------------------------------------------------------------------------
7850// Declaration of the IPDL type |struct RemoteStreamInfo|
7851//
7852namespace mozilla {
7853namespace net {
7854class RemoteStreamInfo final
7855{
7856private:
7857 typedef ::nsIInputStream nsIInputStream;
7858 typedef ::nsCString nsCString;
7859 typedef ::int64_t int64_t;
7860
7861public:
7862#ifdef __clang__1
7863# pragma clang diagnostic push
7864# if __has_warning("-Wdefaulted-function-deleted")1
7865# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
7866# endif
7867#endif
7868 RemoteStreamInfo() = default;
7869#ifdef __clang__1
7870# pragma clang diagnostic pop
7871#endif
7872
7873 MOZ_IMPLICIT RemoteStreamInfo(
7874 nsIInputStream* _inputStream,
7875 const nsCString& _contentType,
7876 const int64_t& _contentLength) :
7877 inputStream_(_inputStream),
7878 contentType_(_contentType),
7879 contentLength_(_contentLength)
7880 {
7881 }
7882
7883 MOZ_IMPLICIT RemoteStreamInfo(
7884 RefPtr<nsIInputStream>&& _inputStream,
7885 nsCString&& _contentType,
7886 int64_t&& _contentLength) :
7887 inputStream_(std::move(_inputStream)),
7888 contentType_(std::move(_contentType)),
7889 contentLength_(std::move(_contentLength))
7890 {
7891 }
7892
7893 RefPtr<nsIInputStream>&
7894 inputStream()
7895 {
7896 return inputStream_;
7897 }
7898 nsIInputStream*
7899 inputStream() const
7900 {
7901 return inputStream_;
7902 }
7903
7904 nsCString&
7905 contentType()
7906 {
7907 return contentType_;
7908 }
7909 const nsCString&
7910 contentType() const
7911 {
7912 return contentType_;
7913 }
7914
7915 int64_t&
7916 contentLength()
7917 {
7918 return contentLength_;
7919 }
7920 const int64_t&
7921 contentLength() const
7922 {
7923 return contentLength_;
7924 }
7925
7926private:
7927 ::mozilla::ipc::IPDLStructMember<RefPtr<nsIInputStream>> inputStream_;
7928 ::mozilla::ipc::IPDLStructMember<nsCString> contentType_;
7929 ::mozilla::ipc::IPDLStructMember<int64_t> contentLength_;
7930};
7931} // namespace net
7932} // namespace mozilla
7933
7934namespace IPC {
7935template<>
7936struct ParamTraits <::mozilla::net::RemoteStreamInfo>
7937{
7938 typedef ::mozilla::net::RemoteStreamInfo paramType;
7939 static void
7940 Write(
7941 IPC::MessageWriter* aWriter,
7942 const paramType& aVar);
7943 static IPC::ReadResult<paramType>
7944 Read(IPC::MessageReader* aReader);
7945};
7946} // namespace IPC
7947
7948#endif // ifndef NeckoChannelParams_h