/*

 * DO NOT EDIT.  THIS FILE IS GENERATED FROM /src/mozilla-central/netwerk/base/nsILoadInfo.idl

 */

#ifndef __gen_nsILoadInfo_h__

#define __gen_nsILoadInfo_h__

#ifndef __gen_nsISupports_h__

#include "nsISupports.h"

#endif

#ifndef __gen_nsIContentPolicy_h__

#include "nsIContentPolicy.h"

#endif

#include "js/Value.h"

#include "mozilla/AlreadyAddRefed.h"

#include "mozilla/Assertions.h"

#include "mozilla/DebugOnly.h"

/* For IDL files that don't want to include root IDL files. */

#ifndef NS_NO_VTABLE

#define NS_NO_VTABLE

#endif

class nsIChannel; /* forward declaration */

class nsINode; /* forward declaration */

class nsIPrincipal; /* forward declaration */

class nsIRedirectHistoryEntry; /* forward declaration */

class nsIURI; /* forward declaration */

class nsIDocument; /* webidl Document */

#include "nsTArray.h"

#include "mozilla/BasePrincipal.h"

#include "mozilla/LoadTainting.h"

#include "mozilla/UniquePtr.h"

#include "mozilla/TelemetryHistogramEnums.h"

#include "nsStringFwd.h"

namespace mozilla {

namespace dom {

class ClientInfo;

class ClientSource;

class PerformanceStorage;

class ServiceWorkerDescriptor;

} // namespace dom

} // namespace mozilla

typedef uint32_t  nsSecurityFlags;

/* starting interface:    nsILoadInfo */

#define NS_ILOADINFO_IID_STR "ddc65bf9-2f60-41ab-b22a-4f1ae9efcd36"

#define NS_ILOADINFO_IID \

  {0xddc65bf9, 0x2f60, 0x41ab, \

    { 0xb2, 0x2a, 0x4f, 0x1a, 0xe9, 0xef, 0xcd, 0x36 }}

class nsILoadInfo : public nsISupports {

 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_ILOADINFO_IID)

  enum {

    SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK = 0U,

    SEC_REQUIRE_SAME_ORIGIN_DATA_INHERITS = 1U,

    SEC_REQUIRE_SAME_ORIGIN_DATA_IS_BLOCKED = 2U,

    SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS = 4U,

    SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL = 8U,

    SEC_REQUIRE_CORS_DATA_INHERITS = 16U,

    SEC_COOKIES_DEFAULT = 0U,

    SEC_COOKIES_INCLUDE = 32U,

    SEC_COOKIES_SAME_ORIGIN = 64U,

    SEC_COOKIES_OMIT = 96U,

    SEC_FORCE_INHERIT_PRINCIPAL = 128U,

    SEC_SANDBOXED = 256U,

    SEC_ABOUT_BLANK_INHERITS = 512U,

    SEC_ALLOW_CHROME = 1024U,

    SEC_DISALLOW_SCRIPT = 2048U,

    SEC_DONT_FOLLOW_REDIRECTS = 4096U,

    SEC_LOAD_ERROR_PAGE = 8192U,

    SEC_FORCE_INHERIT_PRINCIPAL_OVERRULE_OWNER = 16384U

  };

  /* readonly attribute nsIPrincipal loadingPrincipal; */

  NS_IMETHOD GetLoadingPrincipal(nsIPrincipal **aLoadingPrincipal) = 0;

  /* [binaryname(LoadingPrincipal),noscript,nostdcall,notxpcom] nsIPrincipal binaryLoadingPrincipal (); */

  virtual nsIPrincipal * LoadingPrincipal(void) = 0;

  /* readonly attribute nsIPrincipal triggeringPrincipal; */

  NS_IMETHOD GetTriggeringPrincipal(nsIPrincipal **aTriggeringPrincipal) = 0;

  /* [binaryname(TriggeringPrincipal),noscript,nostdcall,notxpcom] nsIPrincipal binaryTriggeringPrincipal (); */

  virtual nsIPrincipal * TriggeringPrincipal(void) = 0;

  /* attribute nsIPrincipal principalToInherit; */

  NS_IMETHOD GetPrincipalToInherit(nsIPrincipal **aPrincipalToInherit) = 0;

  NS_IMETHOD SetPrincipalToInherit(nsIPrincipal *aPrincipalToInherit) = 0;

  /* [binaryname(PrincipalToInherit),noscript,nostdcall,notxpcom] nsIPrincipal binaryPrincipalToInherit (); */

  virtual nsIPrincipal * PrincipalToInherit(void) = 0;

  /* [noscript,nostdcall,notxpcom] nsIPrincipal FindPrincipalToInherit (in nsIChannel aChannel); */

  virtual nsIPrincipal * FindPrincipalToInherit(nsIChannel *aChannel) = 0;

  /* readonly attribute Document loadingDocument; */

  NS_IMETHOD GetLoadingDocument(nsIDocument **aLoadingDocument) = 0;

  /* [binaryname(LoadingNode),noscript,nostdcall,notxpcom] nsINode binaryLoadingNode (); */

  virtual nsINode * LoadingNode(void) = 0;

  /* [binaryname(ContextForTopLevelLoad),noscript,nostdcall,notxpcom] LoadContextRef binaryContextForTopLevelLoad (); */

  virtual already_AddRefed<nsISupports> ContextForTopLevelLoad(void) = 0;

  /* [binaryname(LoadingContextXPCOM)] readonly attribute nsISupports loadingContext; */

  NS_IMETHOD GetLoadingContextXPCOM(nsISupports **aLoadingContext) = 0;

  /* [binaryname(GetLoadingContext),noscript,nostdcall,notxpcom] LoadContextRef binaryGetLoadingContext (); */

  virtual already_AddRefed<nsISupports> GetLoadingContext(void) = 0;

  /* readonly attribute nsSecurityFlags securityFlags; */

  NS_IMETHOD GetSecurityFlags(nsSecurityFlags *aSecurityFlags) = 0;

   inline nsSecurityFlags GetSecurityFlags()

  {

    nsSecurityFlags result;

    mozilla::DebugOnly<nsresult> rv = GetSecurityFlags(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute unsigned long securityMode; */

  NS_IMETHOD GetSecurityMode(uint32_t *aSecurityMode) = 0;

  inline uint32_t GetSecurityMode()

  {

    uint32_t result;

    mozilla::DebugOnly<nsresult> rv = GetSecurityMode(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute boolean isInThirdPartyContext; */

  NS_IMETHOD GetIsInThirdPartyContext(bool *aIsInThirdPartyContext) = 0;

  inline bool GetIsInThirdPartyContext()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetIsInThirdPartyContext(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute unsigned long cookiePolicy; */

  NS_IMETHOD GetCookiePolicy(uint32_t *aCookiePolicy) = 0;

  inline uint32_t GetCookiePolicy()

  {

    uint32_t result;

    mozilla::DebugOnly<nsresult> rv = GetCookiePolicy(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute boolean forceInheritPrincipal; */

  NS_IMETHOD GetForceInheritPrincipal(bool *aForceInheritPrincipal) = 0;

  inline bool GetForceInheritPrincipal()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetForceInheritPrincipal(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute boolean forceInheritPrincipalOverruleOwner; */

  NS_IMETHOD GetForceInheritPrincipalOverruleOwner(bool *aForceInheritPrincipalOverruleOwner) = 0;

  inline bool GetForceInheritPrincipalOverruleOwner()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetForceInheritPrincipalOverruleOwner(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute boolean loadingSandboxed; */

  NS_IMETHOD GetLoadingSandboxed(bool *aLoadingSandboxed) = 0;

  inline bool GetLoadingSandboxed()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetLoadingSandboxed(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute boolean aboutBlankInherits; */

  NS_IMETHOD GetAboutBlankInherits(bool *aAboutBlankInherits) = 0;

  inline bool GetAboutBlankInherits()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetAboutBlankInherits(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute boolean allowChrome; */

  NS_IMETHOD GetAllowChrome(bool *aAllowChrome) = 0;

  inline bool GetAllowChrome()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetAllowChrome(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute boolean disallowScript; */

  NS_IMETHOD GetDisallowScript(bool *aDisallowScript) = 0;

  inline bool GetDisallowScript()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetDisallowScript(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute boolean dontFollowRedirects; */

  NS_IMETHOD GetDontFollowRedirects(bool *aDontFollowRedirects) = 0;

  inline bool GetDontFollowRedirects()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetDontFollowRedirects(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute boolean loadErrorPage; */

  NS_IMETHOD GetLoadErrorPage(bool *aLoadErrorPage) = 0;

  inline bool GetLoadErrorPage()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetLoadErrorPage(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] attribute boolean isDocshellReload; */

  NS_IMETHOD GetIsDocshellReload(bool *aIsDocshellReload) = 0;

  inline bool GetIsDocshellReload()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetIsDocshellReload(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  NS_IMETHOD SetIsDocshellReload(bool aIsDocshellReload) = 0;

  /* readonly attribute nsContentPolicyType externalContentPolicyType; */

  NS_IMETHOD GetExternalContentPolicyType(nsContentPolicyType *aExternalContentPolicyType) = 0;

  /* [infallible] attribute boolean sendCSPViolationEvents; */

  NS_IMETHOD GetSendCSPViolationEvents(bool *aSendCSPViolationEvents) = 0;

  inline bool GetSendCSPViolationEvents()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetSendCSPViolationEvents(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  NS_IMETHOD SetSendCSPViolationEvents(bool aSendCSPViolationEvents) = 0;

   inline nsContentPolicyType GetExternalContentPolicyType()

  {

    nsContentPolicyType result;

    mozilla::DebugOnly<nsresult> rv = GetExternalContentPolicyType(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [noscript,notxpcom] nsContentPolicyType internalContentPolicyType (); */

  NS_IMETHOD_(nsContentPolicyType) InternalContentPolicyType(void) = 0;

  /* [infallible] readonly attribute boolean upgradeInsecureRequests; */

  NS_IMETHOD GetUpgradeInsecureRequests(bool *aUpgradeInsecureRequests) = 0;

  inline bool GetUpgradeInsecureRequests()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetUpgradeInsecureRequests(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute boolean browserUpgradeInsecureRequests; */

  NS_IMETHOD GetBrowserUpgradeInsecureRequests(bool *aBrowserUpgradeInsecureRequests) = 0;

  inline bool GetBrowserUpgradeInsecureRequests()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetBrowserUpgradeInsecureRequests(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute boolean browserWouldUpgradeInsecureRequests; */

  NS_IMETHOD GetBrowserWouldUpgradeInsecureRequests(bool *aBrowserWouldUpgradeInsecureRequests) = 0;

  inline bool GetBrowserWouldUpgradeInsecureRequests()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetBrowserWouldUpgradeInsecureRequests(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] attribute boolean verifySignedContent; */

  NS_IMETHOD GetVerifySignedContent(bool *aVerifySignedContent) = 0;

  inline bool GetVerifySignedContent()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetVerifySignedContent(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  NS_IMETHOD SetVerifySignedContent(bool aVerifySignedContent) = 0;

  /* [infallible] attribute boolean enforceSRI; */

  NS_IMETHOD GetEnforceSRI(bool *aEnforceSRI) = 0;

  inline bool GetEnforceSRI()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetEnforceSRI(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  NS_IMETHOD SetEnforceSRI(bool aEnforceSRI) = 0;

  /* [infallible] attribute boolean forceAllowDataURI; */

  NS_IMETHOD GetForceAllowDataURI(bool *aForceAllowDataURI) = 0;

  inline bool GetForceAllowDataURI()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetForceAllowDataURI(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  NS_IMETHOD SetForceAllowDataURI(bool aForceAllowDataURI) = 0;

  /* [infallible] attribute boolean allowInsecureRedirectToDataURI; */

  NS_IMETHOD GetAllowInsecureRedirectToDataURI(bool *aAllowInsecureRedirectToDataURI) = 0;

  inline bool GetAllowInsecureRedirectToDataURI()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetAllowInsecureRedirectToDataURI(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  NS_IMETHOD SetAllowInsecureRedirectToDataURI(bool aAllowInsecureRedirectToDataURI) = 0;

  /* [infallible] attribute boolean skipContentPolicyCheckForWebRequest; */

  NS_IMETHOD GetSkipContentPolicyCheckForWebRequest(bool *aSkipContentPolicyCheckForWebRequest) = 0;

  inline bool GetSkipContentPolicyCheckForWebRequest()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetSkipContentPolicyCheckForWebRequest(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  NS_IMETHOD SetSkipContentPolicyCheckForWebRequest(bool aSkipContentPolicyCheckForWebRequest) = 0;

  /* [infallible] attribute boolean originalFrameSrcLoad; */

  NS_IMETHOD GetOriginalFrameSrcLoad(bool *aOriginalFrameSrcLoad) = 0;

  inline bool GetOriginalFrameSrcLoad()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetOriginalFrameSrcLoad(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  NS_IMETHOD SetOriginalFrameSrcLoad(bool aOriginalFrameSrcLoad) = 0;

  /* [infallible] readonly attribute boolean forceInheritPrincipalDropped; */

  NS_IMETHOD GetForceInheritPrincipalDropped(bool *aForceInheritPrincipalDropped) = 0;

  inline bool GetForceInheritPrincipalDropped()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetForceInheritPrincipalDropped(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute unsigned long long innerWindowID; */

  NS_IMETHOD GetInnerWindowID(uint64_t *aInnerWindowID) = 0;

  inline uint64_t GetInnerWindowID()

  {

    uint64_t result;

    mozilla::DebugOnly<nsresult> rv = GetInnerWindowID(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute unsigned long long outerWindowID; */

  NS_IMETHOD GetOuterWindowID(uint64_t *aOuterWindowID) = 0;

  inline uint64_t GetOuterWindowID()

  {

    uint64_t result;

    mozilla::DebugOnly<nsresult> rv = GetOuterWindowID(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute unsigned long long parentOuterWindowID; */

  NS_IMETHOD GetParentOuterWindowID(uint64_t *aParentOuterWindowID) = 0;

  inline uint64_t GetParentOuterWindowID()

  {

    uint64_t result;

    mozilla::DebugOnly<nsresult> rv = GetParentOuterWindowID(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute unsigned long long topOuterWindowID; */

  NS_IMETHOD GetTopOuterWindowID(uint64_t *aTopOuterWindowID) = 0;

  inline uint64_t GetTopOuterWindowID()

  {

    uint64_t result;

    mozilla::DebugOnly<nsresult> rv = GetTopOuterWindowID(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute unsigned long long frameOuterWindowID; */

  NS_IMETHOD GetFrameOuterWindowID(uint64_t *aFrameOuterWindowID) = 0;

  inline uint64_t GetFrameOuterWindowID()

  {

    uint64_t result;

    mozilla::DebugOnly<nsresult> rv = GetFrameOuterWindowID(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* void resetPrincipalToInheritToNullPrincipal (); */

  NS_IMETHOD ResetPrincipalToInheritToNullPrincipal(void) = 0;

  /* [binaryname(ScriptableOriginAttributes),implicit_jscontext] attribute jsval originAttributes; */

  NS_IMETHOD GetScriptableOriginAttributes(JSContext* cx, JS::MutableHandleValue aOriginAttributes) = 0;

  NS_IMETHOD SetScriptableOriginAttributes(JSContext* cx, JS::HandleValue aOriginAttributes) = 0;

  /* [binaryname(GetOriginAttributes),noscript,nostdcall] OriginAttributes binaryGetOriginAttributes (); */

  virtual nsresult GetOriginAttributes(mozilla::OriginAttributes * _retval) = 0;

  /* [binaryname(SetOriginAttributes),noscript,nostdcall] void binarySetOriginAttributes (in const_OriginAttributesRef aOriginAttrs); */

  virtual nsresult SetOriginAttributes(const mozilla::OriginAttributes & aOriginAttrs) = 0;

   inline mozilla::OriginAttributes GetOriginAttributes()

  {

    mozilla::OriginAttributes result;

    mozilla::DebugOnly<nsresult> rv = GetOriginAttributes(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] attribute boolean enforceSecurity; */

  NS_IMETHOD GetEnforceSecurity(bool *aEnforceSecurity) = 0;

  inline bool GetEnforceSecurity()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetEnforceSecurity(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  NS_IMETHOD SetEnforceSecurity(bool aEnforceSecurity) = 0;

  /* [infallible] attribute boolean initialSecurityCheckDone; */

  NS_IMETHOD GetInitialSecurityCheckDone(bool *aInitialSecurityCheckDone) = 0;

  inline bool GetInitialSecurityCheckDone()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetInitialSecurityCheckDone(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  NS_IMETHOD SetInitialSecurityCheckDone(bool aInitialSecurityCheckDone) = 0;

  /* [infallible] attribute boolean loadTriggeredFromExternal; */

  NS_IMETHOD GetLoadTriggeredFromExternal(bool *aLoadTriggeredFromExternal) = 0;

  inline bool GetLoadTriggeredFromExternal()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetLoadTriggeredFromExternal(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  NS_IMETHOD SetLoadTriggeredFromExternal(bool aLoadTriggeredFromExternal) = 0;

  /* [infallible,noscript] readonly attribute boolean serviceWorkerTaintingSynthesized; */

  NS_IMETHOD GetServiceWorkerTaintingSynthesized(bool *aServiceWorkerTaintingSynthesized) = 0;

  inline bool GetServiceWorkerTaintingSynthesized()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetServiceWorkerTaintingSynthesized(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* void appendRedirectHistoryEntry (in nsIRedirectHistoryEntry entry, in boolean isInternalRedirect); */

  NS_IMETHOD AppendRedirectHistoryEntry(nsIRedirectHistoryEntry *entry, bool isInternalRedirect) = 0;

  /* [implicit_jscontext] readonly attribute jsval redirectChainIncludingInternalRedirects; */

  NS_IMETHOD GetRedirectChainIncludingInternalRedirects(JSContext* cx, JS::MutableHandleValue aRedirectChainIncludingInternalRedirects) = 0;

  /* [binaryname(RedirectChainIncludingInternalRedirects),noscript,nostdcall,notxpcom] nsIRedirectHistoryEntryArray binaryRedirectChainIncludingInternalRedirects (); */

  virtual const nsTArray<nsCOMPtr<nsIRedirectHistoryEntry>> & RedirectChainIncludingInternalRedirects(void) = 0;

  /* [implicit_jscontext] readonly attribute jsval redirectChain; */

  NS_IMETHOD GetRedirectChain(JSContext* cx, JS::MutableHandleValue aRedirectChain) = 0;

  /* [binaryname(RedirectChain),noscript,nostdcall,notxpcom] nsIRedirectHistoryEntryArray binaryRedirectChain (); */

  virtual const nsTArray<nsCOMPtr<nsIRedirectHistoryEntry>> & RedirectChain(void) = 0;

  /* [noscript,nostdcall,notxpcom] PrincipalArrayRef AncestorPrincipals (); */

  virtual const nsTArray<nsCOMPtr<nsIPrincipal>> & AncestorPrincipals(void) = 0;

  /* [noscript,nostdcall,notxpcom] Uint64ArrayRef AncestorOuterWindowIDs (); */

  virtual const nsTArray<uint64_t> & AncestorOuterWindowIDs(void) = 0;

  /* [noscript,nostdcall,notxpcom] void setCorsPreflightInfo (in CStringArrayRef unsafeHeaders, in boolean forcePreflight); */

  virtual void SetCorsPreflightInfo(const nsTArray<nsCString> & unsafeHeaders, bool forcePreflight) = 0;

  /* [binaryname(CorsUnsafeHeaders),noscript,nostdcall,notxpcom] CStringArrayRef corsUnsafeHeaders (); */

  virtual const nsTArray<nsCString> & CorsUnsafeHeaders(void) = 0;

  /* [infallible] readonly attribute boolean forcePreflight; */

  NS_IMETHOD GetForcePreflight(bool *aForcePreflight) = 0;

  inline bool GetForcePreflight()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetForcePreflight(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* [infallible] readonly attribute boolean isPreflight; */

  NS_IMETHOD GetIsPreflight(bool *aIsPreflight) = 0;

  inline bool GetIsPreflight()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetIsPreflight(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  enum {

    TAINTING_BASIC = 0U,

    TAINTING_CORS = 1U,

    TAINTING_OPAQUE = 2U

  };

  /* readonly attribute unsigned long tainting; */

  NS_IMETHOD GetTainting(uint32_t *aTainting) = 0;

  /* void maybeIncreaseTainting (in unsigned long aTainting); */

  NS_IMETHOD MaybeIncreaseTainting(uint32_t aTainting) = 0;

   static_assert(TAINTING_BASIC == static_cast<uint32_t>(mozilla::LoadTainting::Basic),

                "basic tainting enums should match");

  static_assert(TAINTING_CORS == static_cast<uint32_t>(mozilla::LoadTainting::CORS),

                "cors tainting enums should match");

  static_assert(TAINTING_OPAQUE == static_cast<uint32_t>(mozilla::LoadTainting::Opaque),

                "opaque tainting enums should match");

  mozilla::LoadTainting GetTainting()

  {

    uint32_t tainting = TAINTING_BASIC;

    MOZ_ALWAYS_SUCCEEDS(GetTainting(&tainting));

    return static_cast<mozilla::LoadTainting>(tainting);

  }

  void MaybeIncreaseTainting(mozilla::LoadTainting aTainting)

  {

    uint32_t tainting = static_cast<uint32_t>(aTainting);

    MOZ_ALWAYS_SUCCEEDS(MaybeIncreaseTainting(tainting));

  }

  /* [infallible] readonly attribute boolean isTopLevelLoad; */

  NS_IMETHOD GetIsTopLevelLoad(bool *aIsTopLevelLoad) = 0;

  inline bool GetIsTopLevelLoad()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetIsTopLevelLoad(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* attribute nsIURI resultPrincipalURI; */

  NS_IMETHOD GetResultPrincipalURI(nsIURI **aResultPrincipalURI) = 0;

  NS_IMETHOD SetResultPrincipalURI(nsIURI *aResultPrincipalURI) = 0;

  /* [noscript] readonly attribute nsIPrincipal sandboxedLoadingPrincipal; */

  NS_IMETHOD GetSandboxedLoadingPrincipal(nsIPrincipal **aSandboxedLoadingPrincipal) = 0;

  /* [noscript] readonly attribute nsIPrincipal topLevelPrincipal; */

  NS_IMETHOD GetTopLevelPrincipal(nsIPrincipal **aTopLevelPrincipal) = 0;

  /* [binaryname(TopLevelPrincipal),noscript,nostdcall,notxpcom] nsIPrincipal binaryTopLevelPrincipal (); */

  virtual nsIPrincipal * TopLevelPrincipal(void) = 0;

  /* [noscript] readonly attribute nsIPrincipal topLevelStorageAreaPrincipal; */

  NS_IMETHOD GetTopLevelStorageAreaPrincipal(nsIPrincipal **aTopLevelStorageAreaPrincipal) = 0;

  /* [binaryname(TopLevelStorageAreaPrincipal),noscript,nostdcall,notxpcom] nsIPrincipal binaryTopLevelStorageAreaPrincipal (); */

  virtual nsIPrincipal * TopLevelStorageAreaPrincipal(void) = 0;

  /* [noscript,nostdcall,notxpcom] void SetClientInfo (in const_ClientInfoRef aClientInfo); */

  virtual void SetClientInfo(const mozilla::dom::ClientInfo & aClientInfo) = 0;

  /* [noscript,nostdcall,notxpcom] const_MaybeClientInfoRef GetClientInfo (); */

  virtual const mozilla::Maybe<mozilla::dom::ClientInfo> & GetClientInfo(void) = 0;

  /* [noscript,nostdcall,notxpcom] void GiveReservedClientSource (in UniqueClientSourceMove aClientSource); */

  virtual void GiveReservedClientSource(mozilla::UniquePtr<mozilla::dom::ClientSource>&& aClientSource) = 0;

  /* [noscript,nostdcall,notxpcom] UniqueClientSource TakeReservedClientSource (); */

  virtual mozilla::UniquePtr<mozilla::dom::ClientSource> TakeReservedClientSource(void) = 0;

  /* [noscript,nostdcall,notxpcom] void SetReservedClientInfo (in const_ClientInfoRef aClientInfo); */

  virtual void SetReservedClientInfo(const mozilla::dom::ClientInfo & aClientInfo) = 0;

  /* [noscript,nostdcall,notxpcom] void OverrideReservedClientInfoInParent (in const_ClientInfoRef aClientInfo); */

  virtual void OverrideReservedClientInfoInParent(const mozilla::dom::ClientInfo & aClientInfo) = 0;

  /* [noscript,nostdcall,notxpcom] const_MaybeClientInfoRef GetReservedClientInfo (); */

  virtual const mozilla::Maybe<mozilla::dom::ClientInfo> & GetReservedClientInfo(void) = 0;

  /* [noscript,nostdcall,notxpcom] void SetInitialClientInfo (in const_ClientInfoRef aClientInfo); */

  virtual void SetInitialClientInfo(const mozilla::dom::ClientInfo & aClientInfo) = 0;

  /* [noscript,nostdcall,notxpcom] const_MaybeClientInfoRef GetInitialClientInfo (); */

  virtual const mozilla::Maybe<mozilla::dom::ClientInfo> & GetInitialClientInfo(void) = 0;

  /* [noscript,nostdcall,notxpcom] void SetController (in const_ServiceWorkerDescriptorRef aServiceWorker); */

  virtual void SetController(const mozilla::dom::ServiceWorkerDescriptor & aServiceWorker) = 0;

  /* [noscript,nostdcall,notxpcom] void ClearController (); */

  virtual void ClearController(void) = 0;

  /* [noscript,nostdcall,notxpcom] const_MaybeServiceWorkerDescriptorRef GetController (); */

  virtual const mozilla::Maybe<mozilla::dom::ServiceWorkerDescriptor> & GetController(void) = 0;

  /* [noscript,nostdcall,notxpcom] void SetPerformanceStorage (in PerformanceStoragePtr aPerformanceStorage); */

  virtual void SetPerformanceStorage(mozilla::dom::PerformanceStorage * aPerformanceStorage) = 0;

  /* [noscript,nostdcall,notxpcom] PerformanceStoragePtr GetPerformanceStorage (); */

  virtual mozilla::dom::PerformanceStorage * GetPerformanceStorage(void) = 0;

  /* [noscript,nostdcall,notxpcom] void SynthesizeServiceWorkerTainting (in LoadTainting aTainting); */

  virtual void SynthesizeServiceWorkerTainting(mozilla::LoadTainting aTainting) = 0;

  /* [infallible] attribute boolean isTracker; */

  NS_IMETHOD GetIsTracker(bool *aIsTracker) = 0;

  inline bool GetIsTracker()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetIsTracker(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  NS_IMETHOD SetIsTracker(bool aIsTracker) = 0;

  /* [infallible] attribute boolean isTrackerBlocked; */

  NS_IMETHOD GetIsTrackerBlocked(bool *aIsTrackerBlocked) = 0;

  inline bool GetIsTrackerBlocked()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetIsTrackerBlocked(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  NS_IMETHOD SetIsTrackerBlocked(bool aIsTrackerBlocked) = 0;

  /* attribute AnalyticsProvider trackerBlockedReason; */

  NS_IMETHOD GetTrackerBlockedReason(mozilla::Telemetry::LABELS_DOCUMENT_ANALYTICS_TRACKER_FASTBLOCKED * aTrackerBlockedReason) = 0;

  NS_IMETHOD SetTrackerBlockedReason(mozilla::Telemetry::LABELS_DOCUMENT_ANALYTICS_TRACKER_FASTBLOCKED aTrackerBlockedReason) = 0;

  /* [infallible] attribute boolean documentHasUserInteracted; */

  NS_IMETHOD GetDocumentHasUserInteracted(bool *aDocumentHasUserInteracted) = 0;

  inline bool GetDocumentHasUserInteracted()

  {

    bool result;

    mozilla::DebugOnly<nsresult> rv = GetDocumentHasUserInteracted(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  NS_IMETHOD SetDocumentHasUserInteracted(bool aDocumentHasUserInteracted) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsILoadInfo, NS_ILOADINFO_IID)

/* Use this macro when declaring classes that implement this interface. */

#define NS_DECL_NSILOADINFO \

  NS_IMETHOD GetLoadingPrincipal(nsIPrincipal **aLoadingPrincipal) override; \

  virtual nsIPrincipal * LoadingPrincipal(void) override; \

  NS_IMETHOD GetTriggeringPrincipal(nsIPrincipal **aTriggeringPrincipal) override; \

  virtual nsIPrincipal * TriggeringPrincipal(void) override; \

  NS_IMETHOD GetPrincipalToInherit(nsIPrincipal **aPrincipalToInherit) override; \

  NS_IMETHOD SetPrincipalToInherit(nsIPrincipal *aPrincipalToInherit) override; \

  virtual nsIPrincipal * PrincipalToInherit(void) override; \

  virtual nsIPrincipal * FindPrincipalToInherit(nsIChannel *aChannel) override; \

  NS_IMETHOD GetLoadingDocument(nsIDocument **aLoadingDocument) override; \

  virtual nsINode * LoadingNode(void) override; \

  virtual already_AddRefed<nsISupports> ContextForTopLevelLoad(void) override; \

  NS_IMETHOD GetLoadingContextXPCOM(nsISupports **aLoadingContext) override; \

  virtual already_AddRefed<nsISupports> GetLoadingContext(void) override; \

  NS_IMETHOD GetSecurityFlags(nsSecurityFlags *aSecurityFlags) override; \

  using nsILoadInfo::GetSecurityMode; \

  NS_IMETHOD GetSecurityMode(uint32_t *aSecurityMode) override; \

  using nsILoadInfo::GetIsInThirdPartyContext; \

  NS_IMETHOD GetIsInThirdPartyContext(bool *aIsInThirdPartyContext) override; \

  using nsILoadInfo::GetCookiePolicy; \

  NS_IMETHOD GetCookiePolicy(uint32_t *aCookiePolicy) override; \

  using nsILoadInfo::GetForceInheritPrincipal; \

  NS_IMETHOD GetForceInheritPrincipal(bool *aForceInheritPrincipal) override; \

  using nsILoadInfo::GetForceInheritPrincipalOverruleOwner; \

  NS_IMETHOD GetForceInheritPrincipalOverruleOwner(bool *aForceInheritPrincipalOverruleOwner) override; \

  using nsILoadInfo::GetLoadingSandboxed; \

  NS_IMETHOD GetLoadingSandboxed(bool *aLoadingSandboxed) override; \

  using nsILoadInfo::GetAboutBlankInherits; \

  NS_IMETHOD GetAboutBlankInherits(bool *aAboutBlankInherits) override; \

  using nsILoadInfo::GetAllowChrome; \

  NS_IMETHOD GetAllowChrome(bool *aAllowChrome) override; \

  using nsILoadInfo::GetDisallowScript; \

  NS_IMETHOD GetDisallowScript(bool *aDisallowScript) override; \

  using nsILoadInfo::GetDontFollowRedirects; \

  NS_IMETHOD GetDontFollowRedirects(bool *aDontFollowRedirects) override; \

  using nsILoadInfo::GetLoadErrorPage; \

  NS_IMETHOD GetLoadErrorPage(bool *aLoadErrorPage) override; \

  using nsILoadInfo::GetIsDocshellReload; \

  NS_IMETHOD GetIsDocshellReload(bool *aIsDocshellReload) override; \

  NS_IMETHOD SetIsDocshellReload(bool aIsDocshellReload) override; \

  NS_IMETHOD GetExternalContentPolicyType(nsContentPolicyType *aExternalContentPolicyType) override; \

  using nsILoadInfo::GetSendCSPViolationEvents; \

  NS_IMETHOD GetSendCSPViolationEvents(bool *aSendCSPViolationEvents) override; \

  NS_IMETHOD SetSendCSPViolationEvents(bool aSendCSPViolationEvents) override; \

  NS_IMETHOD_(nsContentPolicyType) InternalContentPolicyType(void) override; \

  using nsILoadInfo::GetUpgradeInsecureRequests; \

  NS_IMETHOD GetUpgradeInsecureRequests(bool *aUpgradeInsecureRequests) override; \

  using nsILoadInfo::GetBrowserUpgradeInsecureRequests; \

  NS_IMETHOD GetBrowserUpgradeInsecureRequests(bool *aBrowserUpgradeInsecureRequests) override; \

  using nsILoadInfo::GetBrowserWouldUpgradeInsecureRequests; \

  NS_IMETHOD GetBrowserWouldUpgradeInsecureRequests(bool *aBrowserWouldUpgradeInsecureRequests) override; \

  using nsILoadInfo::GetVerifySignedContent; \

  NS_IMETHOD GetVerifySignedContent(bool *aVerifySignedContent) override; \

  NS_IMETHOD SetVerifySignedContent(bool aVerifySignedContent) override; \

  using nsILoadInfo::GetEnforceSRI; \

  NS_IMETHOD GetEnforceSRI(bool *aEnforceSRI) override; \

  NS_IMETHOD SetEnforceSRI(bool aEnforceSRI) override; \

  using nsILoadInfo::GetForceAllowDataURI; \

  NS_IMETHOD GetForceAllowDataURI(bool *aForceAllowDataURI) override; \

  NS_IMETHOD SetForceAllowDataURI(bool aForceAllowDataURI) override; \

  using nsILoadInfo::GetAllowInsecureRedirectToDataURI; \

  NS_IMETHOD GetAllowInsecureRedirectToDataURI(bool *aAllowInsecureRedirectToDataURI) override; \

  NS_IMETHOD SetAllowInsecureRedirectToDataURI(bool aAllowInsecureRedirectToDataURI) override; \

  using nsILoadInfo::GetSkipContentPolicyCheckForWebRequest; \

  NS_IMETHOD GetSkipContentPolicyCheckForWebRequest(bool *aSkipContentPolicyCheckForWebRequest) override; \

  NS_IMETHOD SetSkipContentPolicyCheckForWebRequest(bool aSkipContentPolicyCheckForWebRequest) override; \

  using nsILoadInfo::GetOriginalFrameSrcLoad; \

  NS_IMETHOD GetOriginalFrameSrcLoad(bool *aOriginalFrameSrcLoad) override; \

  NS_IMETHOD SetOriginalFrameSrcLoad(bool aOriginalFrameSrcLoad) override; \

  using nsILoadInfo::GetForceInheritPrincipalDropped; \

  NS_IMETHOD GetForceInheritPrincipalDropped(bool *aForceInheritPrincipalDropped) override; \

  using nsILoadInfo::GetInnerWindowID; \

  NS_IMETHOD GetInnerWindowID(uint64_t *aInnerWindowID) override; \

  using nsILoadInfo::GetOuterWindowID; \

  NS_IMETHOD GetOuterWindowID(uint64_t *aOuterWindowID) override; \

  using nsILoadInfo::GetParentOuterWindowID; \

  NS_IMETHOD GetParentOuterWindowID(uint64_t *aParentOuterWindowID) override; \

  using nsILoadInfo::GetTopOuterWindowID; \

  NS_IMETHOD GetTopOuterWindowID(uint64_t *aTopOuterWindowID) override; \

  using nsILoadInfo::GetFrameOuterWindowID; \

  NS_IMETHOD GetFrameOuterWindowID(uint64_t *aFrameOuterWindowID) override; \

  NS_IMETHOD ResetPrincipalToInheritToNullPrincipal(void) override; \

  NS_IMETHOD GetScriptableOriginAttributes(JSContext* cx, JS::MutableHandleValue aOriginAttributes) override; \

  NS_IMETHOD SetScriptableOriginAttributes(JSContext* cx, JS::HandleValue aOriginAttributes) override; \

  virtual nsresult GetOriginAttributes(mozilla::OriginAttributes * _retval) override; \

  virtual nsresult SetOriginAttributes(const mozilla::OriginAttributes & aOriginAttrs) override; \

  using nsILoadInfo::GetEnforceSecurity; \

  NS_IMETHOD GetEnforceSecurity(bool *aEnforceSecurity) override; \

  NS_IMETHOD SetEnforceSecurity(bool aEnforceSecurity) override; \

  using nsILoadInfo::GetInitialSecurityCheckDone; \

  NS_IMETHOD GetInitialSecurityCheckDone(bool *aInitialSecurityCheckDone) override; \

  NS_IMETHOD SetInitialSecurityCheckDone(bool aInitialSecurityCheckDone) override; \

  using nsILoadInfo::GetLoadTriggeredFromExternal; \

  NS_IMETHOD GetLoadTriggeredFromExternal(bool *aLoadTriggeredFromExternal) override; \

  NS_IMETHOD SetLoadTriggeredFromExternal(bool aLoadTriggeredFromExternal) override; \

  using nsILoadInfo::GetServiceWorkerTaintingSynthesized; \

  NS_IMETHOD GetServiceWorkerTaintingSynthesized(bool *aServiceWorkerTaintingSynthesized) override; \

  NS_IMETHOD AppendRedirectHistoryEntry(nsIRedirectHistoryEntry *entry, bool isInternalRedirect) override; \

  NS_IMETHOD GetRedirectChainIncludingInternalRedirects(JSContext* cx, JS::MutableHandleValue aRedirectChainIncludingInternalRedirects) override; \

  virtual const nsTArray<nsCOMPtr<nsIRedirectHistoryEntry>> & RedirectChainIncludingInternalRedirects(void) override; \

  NS_IMETHOD GetRedirectChain(JSContext* cx, JS::MutableHandleValue aRedirectChain) override; \

  virtual const nsTArray<nsCOMPtr<nsIRedirectHistoryEntry>> & RedirectChain(void) override; \

  virtual const nsTArray<nsCOMPtr<nsIPrincipal>> & AncestorPrincipals(void) override; \

  virtual const nsTArray<uint64_t> & AncestorOuterWindowIDs(void) override; \

  virtual void SetCorsPreflightInfo(const nsTArray<nsCString> & unsafeHeaders, bool forcePreflight) override; \

  virtual const nsTArray<nsCString> & CorsUnsafeHeaders(void) override; \

  using nsILoadInfo::GetForcePreflight; \

  NS_IMETHOD GetForcePreflight(bool *aForcePreflight) override; \

  using nsILoadInfo::GetIsPreflight; \

  NS_IMETHOD GetIsPreflight(bool *aIsPreflight) override; \

  NS_IMETHOD GetTainting(uint32_t *aTainting) override; \

  NS_IMETHOD MaybeIncreaseTainting(uint32_t aTainting) override; \

  using nsILoadInfo::GetIsTopLevelLoad; \

  NS_IMETHOD GetIsTopLevelLoad(bool *aIsTopLevelLoad) override; \

  NS_IMETHOD GetResultPrincipalURI(nsIURI **aResultPrincipalURI) override; \

  NS_IMETHOD SetResultPrincipalURI(nsIURI *aResultPrincipalURI) override; \

  NS_IMETHOD GetSandboxedLoadingPrincipal(nsIPrincipal **aSandboxedLoadingPrincipal) override; \

  NS_IMETHOD GetTopLevelPrincipal(nsIPrincipal **aTopLevelPrincipal) override; \

  virtual nsIPrincipal * TopLevelPrincipal(void) override; \

  NS_IMETHOD GetTopLevelStorageAreaPrincipal(nsIPrincipal **aTopLevelStorageAreaPrincipal) override; \

  virtual nsIPrincipal * TopLevelStorageAreaPrincipal(void) override; \

  virtual void SetClientInfo(const mozilla::dom::ClientInfo & aClientInfo) override; \

  virtual const mozilla::Maybe<mozilla::dom::ClientInfo> & GetClientInfo(void) override; \

  virtual void GiveReservedClientSource(mozilla::UniquePtr<mozilla::dom::ClientSource>&& aClientSource) override; \

  virtual mozilla::UniquePtr<mozilla::dom::ClientSource> TakeReservedClientSource(void) override; \

  virtual void SetReservedClientInfo(const mozilla::dom::ClientInfo & aClientInfo) override; \

  virtual void OverrideReservedClientInfoInParent(const mozilla::dom::ClientInfo & aClientInfo) override; \

  virtual const mozilla::Maybe<mozilla::dom::ClientInfo> & GetReservedClientInfo(void) override; \

  virtual void SetInitialClientInfo(const mozilla::dom::ClientInfo & aClientInfo) override; \

  virtual const mozilla::Maybe<mozilla::dom::ClientInfo> & GetInitialClientInfo(void) override; \

  virtual void SetController(const mozilla::dom::ServiceWorkerDescriptor & aServiceWorker) override; \

  virtual void ClearController(void) override; \

  virtual const mozilla::Maybe<mozilla::dom::ServiceWorkerDescriptor> & GetController(void) override; \

  virtual void SetPerformanceStorage(mozilla::dom::PerformanceStorage * aPerformanceStorage) override; \

  virtual mozilla::dom::PerformanceStorage * GetPerformanceStorage(void) override; \

  virtual void SynthesizeServiceWorkerTainting(mozilla::LoadTainting aTainting) override; \

  using nsILoadInfo::GetIsTracker; \

  NS_IMETHOD GetIsTracker(bool *aIsTracker) override; \

  NS_IMETHOD SetIsTracker(bool aIsTracker) override; \

  using nsILoadInfo::GetIsTrackerBlocked; \

  NS_IMETHOD GetIsTrackerBlocked(bool *aIsTrackerBlocked) override; \

  NS_IMETHOD SetIsTrackerBlocked(bool aIsTrackerBlocked) override; \

  NS_IMETHOD GetTrackerBlockedReason(mozilla::Telemetry::LABELS_DOCUMENT_ANALYTICS_TRACKER_FASTBLOCKED * aTrackerBlockedReason) override; \

  NS_IMETHOD SetTrackerBlockedReason(mozilla::Telemetry::LABELS_DOCUMENT_ANALYTICS_TRACKER_FASTBLOCKED aTrackerBlockedReason) override; \

  using nsILoadInfo::GetDocumentHasUserInteracted; \

  NS_IMETHOD GetDocumentHasUserInteracted(bool *aDocumentHasUserInteracted) override; \

  NS_IMETHOD SetDocumentHasUserInteracted(bool aDocumentHasUserInteracted) override; 

/* Use this macro when declaring the members of this interface when the

   class doesn't implement the interface. This is useful for forwarding. */

#define NS_DECL_NON_VIRTUAL_NSILOADINFO \

  nsresult GetLoadingPrincipal(nsIPrincipal **aLoadingPrincipal); \

  nsIPrincipal * LoadingPrincipal(void); \

  nsresult GetTriggeringPrincipal(nsIPrincipal **aTriggeringPrincipal); \

  nsIPrincipal * TriggeringPrincipal(void); \

  nsresult GetPrincipalToInherit(nsIPrincipal **aPrincipalToInherit); \

  nsresult SetPrincipalToInherit(nsIPrincipal *aPrincipalToInherit); \

  nsIPrincipal * PrincipalToInherit(void); \

  nsIPrincipal * FindPrincipalToInherit(nsIChannel *aChannel); \

  nsresult GetLoadingDocument(nsIDocument **aLoadingDocument); \

  nsINode * LoadingNode(void); \

  already_AddRefed<nsISupports> ContextForTopLevelLoad(void); \

  nsresult GetLoadingContextXPCOM(nsISupports **aLoadingContext); \

  already_AddRefed<nsISupports> GetLoadingContext(void); \

  nsresult GetSecurityFlags(nsSecurityFlags *aSecurityFlags); \

  using nsILoadInfo::GetSecurityMode; \

  nsresult GetSecurityMode(uint32_t *aSecurityMode); \

  using nsILoadInfo::GetIsInThirdPartyContext; \

  nsresult GetIsInThirdPartyContext(bool *aIsInThirdPartyContext); \

  using nsILoadInfo::GetCookiePolicy; \

  nsresult GetCookiePolicy(uint32_t *aCookiePolicy); \

  using nsILoadInfo::GetForceInheritPrincipal; \

  nsresult GetForceInheritPrincipal(bool *aForceInheritPrincipal); \

  using nsILoadInfo::GetForceInheritPrincipalOverruleOwner; \

  nsresult GetForceInheritPrincipalOverruleOwner(bool *aForceInheritPrincipalOverruleOwner); \

  using nsILoadInfo::GetLoadingSandboxed; \

  nsresult GetLoadingSandboxed(bool *aLoadingSandboxed); \

  using nsILoadInfo::GetAboutBlankInherits; \

  nsresult GetAboutBlankInherits(bool *aAboutBlankInherits); \

  using nsILoadInfo::GetAllowChrome; \

  nsresult GetAllowChrome(bool *aAllowChrome); \

  using nsILoadInfo::GetDisallowScript; \

  nsresult GetDisallowScript(bool *aDisallowScript); \

  using nsILoadInfo::GetDontFollowRedirects; \

  nsresult GetDontFollowRedirects(bool *aDontFollowRedirects); \

  using nsILoadInfo::GetLoadErrorPage; \

  nsresult GetLoadErrorPage(bool *aLoadErrorPage); \

  using nsILoadInfo::GetIsDocshellReload; \

  nsresult GetIsDocshellReload(bool *aIsDocshellReload); \

  nsresult SetIsDocshellReload(bool aIsDocshellReload); \

  nsresult GetExternalContentPolicyType(nsContentPolicyType *aExternalContentPolicyType); \

  using nsILoadInfo::GetSendCSPViolationEvents; \

  nsresult GetSendCSPViolationEvents(bool *aSendCSPViolationEvents); \

  nsresult SetSendCSPViolationEvents(bool aSendCSPViolationEvents); \

  nsresult_(nsContentPolicyType) InternalContentPolicyType(void); \

  using nsILoadInfo::GetUpgradeInsecureRequests; \

  nsresult GetUpgradeInsecureRequests(bool *aUpgradeInsecureRequests); \

  using nsILoadInfo::GetBrowserUpgradeInsecureRequests; \

  nsresult GetBrowserUpgradeInsecureRequests(bool *aBrowserUpgradeInsecureRequests); \

  using nsILoadInfo::GetBrowserWouldUpgradeInsecureRequests; \

  nsresult GetBrowserWouldUpgradeInsecureRequests(bool *aBrowserWouldUpgradeInsecureRequests); \

  using nsILoadInfo::GetVerifySignedContent; \

  nsresult GetVerifySignedContent(bool *aVerifySignedContent); \

  nsresult SetVerifySignedContent(bool aVerifySignedContent); \

  using nsILoadInfo::GetEnforceSRI; \

  nsresult GetEnforceSRI(bool *aEnforceSRI); \

  nsresult SetEnforceSRI(bool aEnforceSRI); \

  using nsILoadInfo::GetForceAllowDataURI; \

  nsresult GetForceAllowDataURI(bool *aForceAllowDataURI); \

  nsresult SetForceAllowDataURI(bool aForceAllowDataURI); \

  using nsILoadInfo::GetAllowInsecureRedirectToDataURI; \

  nsresult GetAllowInsecureRedirectToDataURI(bool *aAllowInsecureRedirectToDataURI); \

  nsresult SetAllowInsecureRedirectToDataURI(bool aAllowInsecureRedirectToDataURI); \

  using nsILoadInfo::GetSkipContentPolicyCheckForWebRequest; \

  nsresult GetSkipContentPolicyCheckForWebRequest(bool *aSkipContentPolicyCheckForWebRequest); \

  nsresult SetSkipContentPolicyCheckForWebRequest(bool aSkipContentPolicyCheckForWebRequest); \

  using nsILoadInfo::GetOriginalFrameSrcLoad; \

  nsresult GetOriginalFrameSrcLoad(bool *aOriginalFrameSrcLoad); \

  nsresult SetOriginalFrameSrcLoad(bool aOriginalFrameSrcLoad); \

  using nsILoadInfo::GetForceInheritPrincipalDropped; \

  nsresult GetForceInheritPrincipalDropped(bool *aForceInheritPrincipalDropped); \

  using nsILoadInfo::GetInnerWindowID; \

  nsresult GetInnerWindowID(uint64_t *aInnerWindowID); \

  using nsILoadInfo::GetOuterWindowID; \

  nsresult GetOuterWindowID(uint64_t *aOuterWindowID); \

  using nsILoadInfo::GetParentOuterWindowID; \

  nsresult GetParentOuterWindowID(uint64_t *aParentOuterWindowID); \

  using nsILoadInfo::GetTopOuterWindowID; \

  nsresult GetTopOuterWindowID(uint64_t *aTopOuterWindowID); \

  using nsILoadInfo::GetFrameOuterWindowID; \

  nsresult GetFrameOuterWindowID(uint64_t *aFrameOuterWindowID); \

  nsresult ResetPrincipalToInheritToNullPrincipal(void); \

  nsresult GetScriptableOriginAttributes(JSContext* cx, JS::MutableHandleValue aOriginAttributes); \

  nsresult SetScriptableOriginAttributes(JSContext* cx, JS::HandleValue aOriginAttributes); \

  nsresult GetOriginAttributes(mozilla::OriginAttributes * _retval); \

  nsresult SetOriginAttributes(const mozilla::OriginAttributes & aOriginAttrs); \

  using nsILoadInfo::GetEnforceSecurity; \

  nsresult GetEnforceSecurity(bool *aEnforceSecurity); \

  nsresult SetEnforceSecurity(bool aEnforceSecurity); \

  using nsILoadInfo::GetInitialSecurityCheckDone; \

  nsresult GetInitialSecurityCheckDone(bool *aInitialSecurityCheckDone); \

  nsresult SetInitialSecurityCheckDone(bool aInitialSecurityCheckDone); \

  using nsILoadInfo::GetLoadTriggeredFromExternal; \

  nsresult GetLoadTriggeredFromExternal(bool *aLoadTriggeredFromExternal); \

  nsresult SetLoadTriggeredFromExternal(bool aLoadTriggeredFromExternal); \

  using nsILoadInfo::GetServiceWorkerTaintingSynthesized; \

  nsresult GetServiceWorkerTaintingSynthesized(bool *aServiceWorkerTaintingSynthesized); \

  nsresult AppendRedirectHistoryEntry(nsIRedirectHistoryEntry *entry, bool isInternalRedirect); \

  nsresult GetRedirectChainIncludingInternalRedirects(JSContext* cx, JS::MutableHandleValue aRedirectChainIncludingInternalRedirects); \

  const nsTArray<nsCOMPtr<nsIRedirectHistoryEntry>> & RedirectChainIncludingInternalRedirects(void); \

  nsresult GetRedirectChain(JSContext* cx, JS::MutableHandleValue aRedirectChain); \

  const nsTArray<nsCOMPtr<nsIRedirectHistoryEntry>> & RedirectChain(void); \

  const nsTArray<nsCOMPtr<nsIPrincipal>> & AncestorPrincipals(void); \

  const nsTArray<uint64_t> & AncestorOuterWindowIDs(void); \

  void SetCorsPreflightInfo(const nsTArray<nsCString> & unsafeHeaders, bool forcePreflight); \

  const nsTArray<nsCString> & CorsUnsafeHeaders(void); \

  using nsILoadInfo::GetForcePreflight; \

  nsresult GetForcePreflight(bool *aForcePreflight); \

  using nsILoadInfo::GetIsPreflight; \

  nsresult GetIsPreflight(bool *aIsPreflight); \

  nsresult GetTainting(uint32_t *aTainting); \

  nsresult MaybeIncreaseTainting(uint32_t aTainting); \

  using nsILoadInfo::GetIsTopLevelLoad; \

  nsresult GetIsTopLevelLoad(bool *aIsTopLevelLoad); \

  nsresult GetResultPrincipalURI(nsIURI **aResultPrincipalURI); \

  nsresult SetResultPrincipalURI(nsIURI *aResultPrincipalURI); \

  nsresult GetSandboxedLoadingPrincipal(nsIPrincipal **aSandboxedLoadingPrincipal); \

  nsresult GetTopLevelPrincipal(nsIPrincipal **aTopLevelPrincipal); \

  nsIPrincipal * TopLevelPrincipal(void); \

  nsresult GetTopLevelStorageAreaPrincipal(nsIPrincipal **aTopLevelStorageAreaPrincipal); \

  nsIPrincipal * TopLevelStorageAreaPrincipal(void); \

  void SetClientInfo(const mozilla::dom::ClientInfo & aClientInfo); \

  const mozilla::Maybe<mozilla::dom::ClientInfo> & GetClientInfo(void); \

  void GiveReservedClientSource(mozilla::UniquePtr<mozilla::dom::ClientSource>&& aClientSource); \

  mozilla::UniquePtr<mozilla::dom::ClientSource> TakeReservedClientSource(void); \

  void SetReservedClientInfo(const mozilla::dom::ClientInfo & aClientInfo); \

  void OverrideReservedClientInfoInParent(const mozilla::dom::ClientInfo & aClientInfo); \

  const mozilla::Maybe<mozilla::dom::ClientInfo> & GetReservedClientInfo(void); \

  void SetInitialClientInfo(const mozilla::dom::ClientInfo & aClientInfo); \

  const mozilla::Maybe<mozilla::dom::ClientInfo> & GetInitialClientInfo(void); \

  void SetController(const mozilla::dom::ServiceWorkerDescriptor & aServiceWorker); \

  void ClearController(void); \

  const mozilla::Maybe<mozilla::dom::ServiceWorkerDescriptor> & GetController(void); \

  void SetPerformanceStorage(mozilla::dom::PerformanceStorage * aPerformanceStorage); \

  mozilla::dom::PerformanceStorage * GetPerformanceStorage(void); \

  void SynthesizeServiceWorkerTainting(mozilla::LoadTainting aTainting); \

  using nsILoadInfo::GetIsTracker; \

  nsresult GetIsTracker(bool *aIsTracker); \

  nsresult SetIsTracker(bool aIsTracker); \

  using nsILoadInfo::GetIsTrackerBlocked; \

  nsresult GetIsTrackerBlocked(bool *aIsTrackerBlocked); \

  nsresult SetIsTrackerBlocked(bool aIsTrackerBlocked); \

  nsresult GetTrackerBlockedReason(mozilla::Telemetry::LABELS_DOCUMENT_ANALYTICS_TRACKER_FASTBLOCKED * aTrackerBlockedReason); \

  nsresult SetTrackerBlockedReason(mozilla::Telemetry::LABELS_DOCUMENT_ANALYTICS_TRACKER_FASTBLOCKED aTrackerBlockedReason); \

  using nsILoadInfo::GetDocumentHasUserInteracted; \

  nsresult GetDocumentHasUserInteracted(bool *aDocumentHasUserInteracted); \

  nsresult SetDocumentHasUserInteracted(bool aDocumentHasUserInteracted); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */

#define NS_FORWARD_NSILOADINFO(_to) \

  NS_IMETHOD GetLoadingPrincipal(nsIPrincipal **aLoadingPrincipal) override { return _to GetLoadingPrincipal(aLoadingPrincipal); } \

  virtual nsIPrincipal * LoadingPrincipal(void) override { return _to LoadingPrincipal(); } \

  NS_IMETHOD GetTriggeringPrincipal(nsIPrincipal **aTriggeringPrincipal) override { return _to GetTriggeringPrincipal(aTriggeringPrincipal); } \

  virtual nsIPrincipal * TriggeringPrincipal(void) override { return _to TriggeringPrincipal(); } \

  NS_IMETHOD GetPrincipalToInherit(nsIPrincipal **aPrincipalToInherit) override { return _to GetPrincipalToInherit(aPrincipalToInherit); } \

  NS_IMETHOD SetPrincipalToInherit(nsIPrincipal *aPrincipalToInherit) override { return _to SetPrincipalToInherit(aPrincipalToInherit); } \

  virtual nsIPrincipal * PrincipalToInherit(void) override { return _to PrincipalToInherit(); } \

  virtual nsIPrincipal * FindPrincipalToInherit(nsIChannel *aChannel) override { return _to FindPrincipalToInherit(aChannel); } \

  NS_IMETHOD GetLoadingDocument(nsIDocument **aLoadingDocument) override { return _to GetLoadingDocument(aLoadingDocument); } \

  virtual nsINode * LoadingNode(void) override { return _to LoadingNode(); } \

  virtual already_AddRefed<nsISupports> ContextForTopLevelLoad(void) override { return _to ContextForTopLevelLoad(); } \

  NS_IMETHOD GetLoadingContextXPCOM(nsISupports **aLoadingContext) override { return _to GetLoadingContextXPCOM(aLoadingContext); } \

  virtual already_AddRefed<nsISupports> GetLoadingContext(void) override { return _to GetLoadingContext(); } \

  NS_IMETHOD GetSecurityFlags(nsSecurityFlags *aSecurityFlags) override { return _to GetSecurityFlags(aSecurityFlags); } \

  using nsILoadInfo::GetSecurityMode; \

  NS_IMETHOD GetSecurityMode(uint32_t *aSecurityMode) override { return _to GetSecurityMode(aSecurityMode); } \

  using nsILoadInfo::GetIsInThirdPartyContext; \

  NS_IMETHOD GetIsInThirdPartyContext(bool *aIsInThirdPartyContext) override { return _to GetIsInThirdPartyContext(aIsInThirdPartyContext); } \

  using nsILoadInfo::GetCookiePolicy; \

  NS_IMETHOD GetCookiePolicy(uint32_t *aCookiePolicy) override { return _to GetCookiePolicy(aCookiePolicy); } \

  using nsILoadInfo::GetForceInheritPrincipal; \

  NS_IMETHOD GetForceInheritPrincipal(bool *aForceInheritPrincipal) override { return _to GetForceInheritPrincipal(aForceInheritPrincipal); } \

  using nsILoadInfo::GetForceInheritPrincipalOverruleOwner; \

  NS_IMETHOD GetForceInheritPrincipalOverruleOwner(bool *aForceInheritPrincipalOverruleOwner) override { return _to GetForceInheritPrincipalOverruleOwner(aForceInheritPrincipalOverruleOwner); } \

  using nsILoadInfo::GetLoadingSandboxed; \

  NS_IMETHOD GetLoadingSandboxed(bool *aLoadingSandboxed) override { return _to GetLoadingSandboxed(aLoadingSandboxed); } \

  using nsILoadInfo::GetAboutBlankInherits; \

  NS_IMETHOD GetAboutBlankInherits(bool *aAboutBlankInherits) override { return _to GetAboutBlankInherits(aAboutBlankInherits); } \

  using nsILoadInfo::GetAllowChrome; \

  NS_IMETHOD GetAllowChrome(bool *aAllowChrome) override { return _to GetAllowChrome(aAllowChrome); } \

  using nsILoadInfo::GetDisallowScript; \

  NS_IMETHOD GetDisallowScript(bool *aDisallowScript) override { return _to GetDisallowScript(aDisallowScript); } \

  using nsILoadInfo::GetDontFollowRedirects; \

  NS_IMETHOD GetDontFollowRedirects(bool *aDontFollowRedirects) override { return _to GetDontFollowRedirects(aDontFollowRedirects); } \

  using nsILoadInfo::GetLoadErrorPage; \

  NS_IMETHOD GetLoadErrorPage(bool *aLoadErrorPage) override { return _to GetLoadErrorPage(aLoadErrorPage); } \

  using nsILoadInfo::GetIsDocshellReload; \

  NS_IMETHOD GetIsDocshellReload(bool *aIsDocshellReload) override { return _to GetIsDocshellReload(aIsDocshellReload); } \

  NS_IMETHOD SetIsDocshellReload(bool aIsDocshellReload) override { return _to SetIsDocshellReload(aIsDocshellReload); } \

  NS_IMETHOD GetExternalContentPolicyType(nsContentPolicyType *aExternalContentPolicyType) override { return _to GetExternalContentPolicyType(aExternalContentPolicyType); } \

  using nsILoadInfo::GetSendCSPViolationEvents; \

  NS_IMETHOD GetSendCSPViolationEvents(bool *aSendCSPViolationEvents) override { return _to GetSendCSPViolationEvents(aSendCSPViolationEvents); } \

  NS_IMETHOD SetSendCSPViolationEvents(bool aSendCSPViolationEvents) override { return _to SetSendCSPViolationEvents(aSendCSPViolationEvents); } \

  NS_IMETHOD_(nsContentPolicyType) InternalContentPolicyType(void) override { return _to InternalContentPolicyType(); } \

  using nsILoadInfo::GetUpgradeInsecureRequests; \

  NS_IMETHOD GetUpgradeInsecureRequests(bool *aUpgradeInsecureRequests) override { return _to GetUpgradeInsecureRequests(aUpgradeInsecureRequests); } \

  using nsILoadInfo::GetBrowserUpgradeInsecureRequests; \

  NS_IMETHOD GetBrowserUpgradeInsecureRequests(bool *aBrowserUpgradeInsecureRequests) override { return _to GetBrowserUpgradeInsecureRequests(aBrowserUpgradeInsecureRequests); } \

  using nsILoadInfo::GetBrowserWouldUpgradeInsecureRequests; \

  NS_IMETHOD GetBrowserWouldUpgradeInsecureRequests(bool *aBrowserWouldUpgradeInsecureRequests) override { return _to GetBrowserWouldUpgradeInsecureRequests(aBrowserWouldUpgradeInsecureRequests); } \

  using nsILoadInfo::GetVerifySignedContent; \

  NS_IMETHOD GetVerifySignedContent(bool *aVerifySignedContent) override { return _to GetVerifySignedContent(aVerifySignedContent); } \

  NS_IMETHOD SetVerifySignedContent(bool aVerifySignedContent) override { return _to SetVerifySignedContent(aVerifySignedContent); } \

  using nsILoadInfo::GetEnforceSRI; \

  NS_IMETHOD GetEnforceSRI(bool *aEnforceSRI) override { return _to GetEnforceSRI(aEnforceSRI); } \

  NS_IMETHOD SetEnforceSRI(bool aEnforceSRI) override { return _to SetEnforceSRI(aEnforceSRI); } \

  using nsILoadInfo::GetForceAllowDataURI; \

  NS_IMETHOD GetForceAllowDataURI(bool *aForceAllowDataURI) override { return _to GetForceAllowDataURI(aForceAllowDataURI); } \

  NS_IMETHOD SetForceAllowDataURI(bool aForceAllowDataURI) override { return _to SetForceAllowDataURI(aForceAllowDataURI); } \

  using nsILoadInfo::GetAllowInsecureRedirectToDataURI; \

  NS_IMETHOD GetAllowInsecureRedirectToDataURI(bool *aAllowInsecureRedirectToDataURI) override { return _to GetAllowInsecureRedirectToDataURI(aAllowInsecureRedirectToDataURI); } \

  NS_IMETHOD SetAllowInsecureRedirectToDataURI(bool aAllowInsecureRedirectToDataURI) override { return _to SetAllowInsecureRedirectToDataURI(aAllowInsecureRedirectToDataURI); } \

  using nsILoadInfo::GetSkipContentPolicyCheckForWebRequest; \

  NS_IMETHOD GetSkipContentPolicyCheckForWebRequest(bool *aSkipContentPolicyCheckForWebRequest) override { return _to GetSkipContentPolicyCheckForWebRequest(aSkipContentPolicyCheckForWebRequest); } \

  NS_IMETHOD SetSkipContentPolicyCheckForWebRequest(bool aSkipContentPolicyCheckForWebRequest) override { return _to SetSkipContentPolicyCheckForWebRequest(aSkipContentPolicyCheckForWebRequest); } \

  using nsILoadInfo::GetOriginalFrameSrcLoad; \

  NS_IMETHOD GetOriginalFrameSrcLoad(bool *aOriginalFrameSrcLoad) override { return _to GetOriginalFrameSrcLoad(aOriginalFrameSrcLoad); } \

  NS_IMETHOD SetOriginalFrameSrcLoad(bool aOriginalFrameSrcLoad) override { return _to SetOriginalFrameSrcLoad(aOriginalFrameSrcLoad); } \

  using nsILoadInfo::GetForceInheritPrincipalDropped; \

  NS_IMETHOD GetForceInheritPrincipalDropped(bool *aForceInheritPrincipalDropped) override { return _to GetForceInheritPrincipalDropped(aForceInheritPrincipalDropped); } \