[ tor-browser ].git.dasho

BackgroundUtils.cpp (44583B)
      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
      5 * You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #include "BackgroundUtils.h"
      8 
      9 #include "MainThreadUtils.h"
     10 #include "mozilla/Assertions.h"
     11 #include "mozilla/BasePrincipal.h"
     12 #include "mozilla/ContentPrincipal.h"
     13 #include "mozilla/NullPrincipal.h"
     14 #include "mozilla/SystemPrincipal.h"
     15 #include "mozilla/ipc/PBackgroundSharedTypes.h"
     16 #include "mozilla/ipc/URIUtils.h"
     17 #include "mozilla/net/CookieJarSettings.h"
     18 #include "mozilla/net/InterceptionInfo.h"
     19 #include "mozilla/net/NeckoChannelParams.h"
     20 #include "ExpandedPrincipal.h"
     21 #include "nsIContentPolicy.h"
     22 #include "nsIScriptSecurityManager.h"
     23 #include "nsIURI.h"
     24 #include "nsNetUtil.h"
     25 #include "mozilla/LoadInfo.h"
     26 #include "nsContentUtils.h"
     27 #include "nsString.h"
     28 #include "nsTArray.h"
     29 #include "mozilla/nsRedirectHistoryEntry.h"
     30 #include "mozilla/dom/nsCSPUtils.h"
     31 #include "mozilla/dom/nsCSPContext.h"
     32 #include "mozilla/dom/BrowsingContext.h"
     33 #include "mozilla/dom/CanonicalBrowsingContext.h"
     34 #include "mozilla/dom/Document.h"
     35 #include "mozilla/dom/PolicyContainer.h"
     36 #include "mozilla/dom/WindowGlobalParent.h"
     37 #include "mozilla/LoadInfo.h"
     38 
     39 using namespace mozilla::dom;
     40 using namespace mozilla::net;
     41 
     42 namespace mozilla {
     43 
     44 namespace ipc {
     45 
     46 Result<nsCOMPtr<nsIPrincipal>, nsresult> PrincipalInfoToPrincipal(
     47    const PrincipalInfo& aPrincipalInfo) {
     48  MOZ_ASSERT(aPrincipalInfo.type() != PrincipalInfo::T__None);
     49 
     50  nsCOMPtr<nsIPrincipal> principal;
     51  nsresult rv;
     52 
     53  switch (aPrincipalInfo.type()) {
     54    case PrincipalInfo::TSystemPrincipalInfo: {
     55      principal = SystemPrincipal::Get();
     56      if (NS_WARN_IF(!principal)) {
     57        return Err(NS_ERROR_NOT_INITIALIZED);
     58      }
     59 
     60      return principal;
     61    }
     62 
     63    case PrincipalInfo::TNullPrincipalInfo: {
     64      const NullPrincipalInfo& info = aPrincipalInfo.get_NullPrincipalInfo();
     65 
     66      nsCOMPtr<nsIURI> uri;
     67      rv = NS_NewURI(getter_AddRefs(uri), info.spec());
     68      if (NS_WARN_IF(NS_FAILED(rv))) {
     69        return Err(rv);
     70      }
     71 
     72      if (!uri->SchemeIs(NS_NULLPRINCIPAL_SCHEME)) {
     73        return Err(NS_ERROR_ILLEGAL_VALUE);
     74      }
     75 
     76      principal = NullPrincipal::Create(info.attrs(), uri);
     77      return principal;
     78    }
     79 
     80    case PrincipalInfo::TContentPrincipalInfo: {
     81      const ContentPrincipalInfo& info =
     82          aPrincipalInfo.get_ContentPrincipalInfo();
     83 
     84      nsCOMPtr<nsIURI> uri;
     85      rv = NS_NewURI(getter_AddRefs(uri), info.spec());
     86      if (NS_WARN_IF(NS_FAILED(rv))) {
     87        return Err(rv);
     88      }
     89 
     90      nsCOMPtr<nsIURI> domain;
     91      if (info.domain()) {
     92        rv = NS_NewURI(getter_AddRefs(domain), *info.domain());
     93        if (NS_WARN_IF(NS_FAILED(rv))) {
     94          return Err(rv);
     95        }
     96      }
     97 
     98      principal =
     99          BasePrincipal::CreateContentPrincipal(uri, info.attrs(), domain);
    100      if (NS_WARN_IF(!principal)) {
    101        return Err(NS_ERROR_NULL_POINTER);
    102      }
    103 
    104      // Origin must match what the_new_principal.getOrigin returns.
    105      nsAutoCString originNoSuffix;
    106      rv = principal->GetOriginNoSuffix(originNoSuffix);
    107      if (NS_WARN_IF(NS_FAILED(rv))) {
    108        return Err(rv);
    109      }
    110 
    111      if (NS_WARN_IF(!info.originNoSuffix().Equals(originNoSuffix))) {
    112        return Err(NS_ERROR_FAILURE);
    113      }
    114 
    115      if (!info.baseDomain().IsVoid()) {
    116        nsAutoCString baseDomain;
    117        rv = principal->GetBaseDomain(baseDomain);
    118        if (NS_WARN_IF(NS_FAILED(rv))) {
    119          return Err(rv);
    120        }
    121 
    122        if (NS_WARN_IF(!info.baseDomain().Equals(baseDomain))) {
    123          return Err(NS_ERROR_FAILURE);
    124        }
    125      }
    126      return principal;
    127    }
    128 
    129    case PrincipalInfo::TExpandedPrincipalInfo: {
    130      const ExpandedPrincipalInfo& info =
    131          aPrincipalInfo.get_ExpandedPrincipalInfo();
    132 
    133      nsTArray<nsCOMPtr<nsIPrincipal>> allowlist;
    134      nsCOMPtr<nsIPrincipal> alPrincipal;
    135 
    136      for (uint32_t i = 0; i < info.allowlist().Length(); i++) {
    137        auto principalOrErr = PrincipalInfoToPrincipal(info.allowlist()[i]);
    138        if (NS_WARN_IF(principalOrErr.isErr())) {
    139          nsresult ret = principalOrErr.unwrapErr();
    140          return Err(ret);
    141        }
    142        // append that principal to the allowlist
    143        allowlist.AppendElement(principalOrErr.unwrap());
    144      }
    145 
    146      RefPtr<ExpandedPrincipal> expandedPrincipal =
    147          ExpandedPrincipal::Create(allowlist, info.attrs());
    148      if (!expandedPrincipal) {
    149        return Err(NS_ERROR_FAILURE);
    150      }
    151 
    152      principal = expandedPrincipal;
    153      return principal;
    154    }
    155 
    156    default:
    157      return Err(NS_ERROR_FAILURE);
    158  }
    159 }
    160 
    161 bool StorageKeysEqual(const PrincipalInfo& aLeft, const PrincipalInfo& aRight) {
    162  MOZ_RELEASE_ASSERT(aLeft.type() == PrincipalInfo::TContentPrincipalInfo ||
    163                     aLeft.type() == PrincipalInfo::TSystemPrincipalInfo);
    164  MOZ_RELEASE_ASSERT(aRight.type() == PrincipalInfo::TContentPrincipalInfo ||
    165                     aRight.type() == PrincipalInfo::TSystemPrincipalInfo);
    166 
    167  if (aLeft.type() != aRight.type()) {
    168    return false;
    169  }
    170 
    171  if (aLeft.type() == PrincipalInfo::TContentPrincipalInfo) {
    172    const ContentPrincipalInfo& leftContent = aLeft.get_ContentPrincipalInfo();
    173    const ContentPrincipalInfo& rightContent =
    174        aRight.get_ContentPrincipalInfo();
    175 
    176    return leftContent.attrs() == rightContent.attrs() &&
    177           leftContent.originNoSuffix() == rightContent.originNoSuffix();
    178  }
    179 
    180  // Storage keys for the System principal always equal.
    181  return true;
    182 }
    183 
    184 already_AddRefed<nsIContentSecurityPolicy> CSPInfoToCSP(
    185    const CSPInfo& aCSPInfo, Document* aRequestingDoc,
    186    nsresult* aOptionalResult) {
    187  MOZ_ASSERT(NS_IsMainThread());
    188 
    189  nsresult stackResult;
    190  nsresult& rv = aOptionalResult ? *aOptionalResult : stackResult;
    191 
    192  RefPtr<nsCSPContext> csp = new nsCSPContext();
    193 
    194  if (aRequestingDoc) {
    195    rv = csp->SetRequestContextWithDocument(aRequestingDoc);
    196    if (NS_WARN_IF(NS_FAILED(rv))) {
    197      return nullptr;
    198    }
    199  } else {
    200    auto principalOrErr =
    201        PrincipalInfoToPrincipal(aCSPInfo.requestPrincipalInfo());
    202    if (NS_WARN_IF(principalOrErr.isErr())) {
    203      return nullptr;
    204    }
    205 
    206    nsCOMPtr<nsIURI> selfURI;
    207    if (!aCSPInfo.selfURISpec().IsEmpty()) {
    208      rv = NS_NewURI(getter_AddRefs(selfURI), aCSPInfo.selfURISpec());
    209      if (NS_WARN_IF(NS_FAILED(rv))) {
    210        return nullptr;
    211      }
    212    }
    213 
    214    nsCOMPtr<nsIPrincipal> principal = principalOrErr.unwrap();
    215 
    216    rv = csp->SetRequestContextWithPrincipal(
    217        principal, selfURI, aCSPInfo.referrer(), aCSPInfo.innerWindowID());
    218    if (NS_WARN_IF(NS_FAILED(rv))) {
    219      return nullptr;
    220    }
    221  }
    222  csp->SetSkipAllowInlineStyleCheck(aCSPInfo.skipAllowInlineStyleCheck());
    223 
    224  for (uint32_t i = 0; i < aCSPInfo.policyInfos().Length(); i++) {
    225    csp->AddIPCPolicy(aCSPInfo.policyInfos()[i]);
    226  }
    227  return csp.forget();
    228 }
    229 
    230 nsresult CSPToCSPInfo(nsIContentSecurityPolicy* aCSP, CSPInfo* aCSPInfo) {
    231  MOZ_ASSERT(NS_IsMainThread());
    232  MOZ_ASSERT(aCSP);
    233  MOZ_ASSERT(aCSPInfo);
    234 
    235  if (!aCSP || !aCSPInfo) {
    236    return NS_ERROR_FAILURE;
    237  }
    238 
    239  nsCOMPtr<nsIPrincipal> requestPrincipal = aCSP->GetRequestPrincipal();
    240 
    241  PrincipalInfo requestingPrincipalInfo;
    242  nsresult rv =
    243      PrincipalToPrincipalInfo(requestPrincipal, &requestingPrincipalInfo);
    244  if (NS_WARN_IF(NS_FAILED(rv))) {
    245    return rv;
    246  }
    247 
    248  nsCOMPtr<nsIURI> selfURI = aCSP->GetSelfURI();
    249  nsAutoCString selfURISpec;
    250  if (selfURI) {
    251    selfURI->GetSpec(selfURISpec);
    252  }
    253 
    254  nsAutoCString referrer;
    255  aCSP->GetReferrer(referrer);
    256 
    257  uint64_t windowID = aCSP->GetInnerWindowID();
    258  bool skipAllowInlineStyleCheck = aCSP->GetSkipAllowInlineStyleCheck();
    259 
    260  RequireTrustedTypesForDirectiveState requireTrustedTypesForDirectiveState =
    261      aCSP->GetRequireTrustedTypesForDirectiveState();
    262 
    263  nsTArray<ContentSecurityPolicy> policies;
    264  static_cast<nsCSPContext*>(aCSP)->SerializePolicies(policies);
    265 
    266  *aCSPInfo = CSPInfo(std::move(policies), requestingPrincipalInfo, selfURISpec,
    267                      referrer, windowID, requireTrustedTypesForDirectiveState,
    268                      skipAllowInlineStyleCheck);
    269  return NS_OK;
    270 }
    271 
    272 nsresult PrincipalToPrincipalInfo(nsIPrincipal* aPrincipal,
    273                                  PrincipalInfo* aPrincipalInfo,
    274                                  bool aSkipBaseDomain) {
    275  MOZ_ASSERT(aPrincipal);
    276  MOZ_ASSERT(aPrincipalInfo);
    277 
    278  nsresult rv;
    279  if (aPrincipal->GetIsNullPrincipal()) {
    280    nsAutoCString spec;
    281    rv = aPrincipal->GetAsciiSpec(spec);
    282    if (NS_WARN_IF(NS_FAILED(rv))) {
    283      return rv;
    284    }
    285 
    286    *aPrincipalInfo =
    287        NullPrincipalInfo(aPrincipal->OriginAttributesRef(), spec);
    288    return NS_OK;
    289  }
    290 
    291  if (aPrincipal->IsSystemPrincipal()) {
    292    *aPrincipalInfo = SystemPrincipalInfo();
    293    return NS_OK;
    294  }
    295 
    296  // might be an expanded principal
    297  auto* basePrin = BasePrincipal::Cast(aPrincipal);
    298  if (basePrin->Is<ExpandedPrincipal>()) {
    299    auto* expanded = basePrin->As<ExpandedPrincipal>();
    300 
    301    nsTArray<PrincipalInfo> allowlistInfo;
    302    PrincipalInfo info;
    303 
    304    for (auto& prin : expanded->AllowList()) {
    305      rv = PrincipalToPrincipalInfo(prin, &info, aSkipBaseDomain);
    306      if (NS_WARN_IF(NS_FAILED(rv))) {
    307        return rv;
    308      }
    309      // append that spec to the allowlist
    310      allowlistInfo.AppendElement(info);
    311    }
    312 
    313    *aPrincipalInfo = ExpandedPrincipalInfo(aPrincipal->OriginAttributesRef(),
    314                                            std::move(allowlistInfo));
    315    return NS_OK;
    316  }
    317 
    318  nsAutoCString spec;
    319  rv = aPrincipal->GetAsciiSpec(spec);
    320  if (NS_WARN_IF(NS_FAILED(rv))) {
    321    return rv;
    322  }
    323 
    324  nsCString originNoSuffix;
    325  rv = aPrincipal->GetOriginNoSuffix(originNoSuffix);
    326  if (NS_WARN_IF(NS_FAILED(rv))) {
    327    return rv;
    328  }
    329 
    330  nsCOMPtr<nsIURI> domainUri;
    331  rv = aPrincipal->GetDomain(getter_AddRefs(domainUri));
    332  if (NS_WARN_IF(NS_FAILED(rv))) {
    333    return rv;
    334  }
    335 
    336  Maybe<nsCString> domain;
    337  if (domainUri) {
    338    domain.emplace();
    339    rv = domainUri->GetSpec(domain.ref());
    340    if (NS_WARN_IF(NS_FAILED(rv))) {
    341      return rv;
    342    }
    343  }
    344 
    345  // This attribute is not crucial.
    346  nsCString baseDomain;
    347  if (aSkipBaseDomain) {
    348    baseDomain.SetIsVoid(true);
    349  } else {
    350    if (NS_FAILED(aPrincipal->GetBaseDomain(baseDomain))) {
    351      // No warning here. Some principal URLs do not have a base-domain.
    352      baseDomain.SetIsVoid(true);
    353    }
    354  }
    355 
    356  *aPrincipalInfo =
    357      ContentPrincipalInfo(aPrincipal->OriginAttributesRef(), originNoSuffix,
    358                           spec, domain, baseDomain);
    359  return NS_OK;
    360 }
    361 
    362 bool IsPrincipalInfoPrivate(const PrincipalInfo& aPrincipalInfo) {
    363  if (aPrincipalInfo.type() != ipc::PrincipalInfo::TContentPrincipalInfo) {
    364    return false;
    365  }
    366 
    367  const ContentPrincipalInfo& info = aPrincipalInfo.get_ContentPrincipalInfo();
    368  return info.attrs().IsPrivateBrowsing();
    369 }
    370 
    371 already_AddRefed<nsIRedirectHistoryEntry> RHEntryInfoToRHEntry(
    372    const RedirectHistoryEntryInfo& aRHEntryInfo) {
    373  auto principalOrErr = PrincipalInfoToPrincipal(aRHEntryInfo.principalInfo());
    374  if (NS_WARN_IF(principalOrErr.isErr())) {
    375    return nullptr;
    376  }
    377 
    378  nsCOMPtr<nsIPrincipal> principal = principalOrErr.unwrap();
    379  nsCOMPtr<nsIURI> referrerUri = DeserializeURI(aRHEntryInfo.referrerUri());
    380 
    381  nsCOMPtr<nsIRedirectHistoryEntry> entry = new nsRedirectHistoryEntry(
    382      principal, referrerUri, aRHEntryInfo.remoteAddress());
    383 
    384  return entry.forget();
    385 }
    386 
    387 nsresult RHEntryToRHEntryInfo(nsIRedirectHistoryEntry* aRHEntry,
    388                              RedirectHistoryEntryInfo* aRHEntryInfo) {
    389  MOZ_ASSERT(aRHEntry);
    390  MOZ_ASSERT(aRHEntryInfo);
    391 
    392  nsresult rv;
    393  aRHEntry->GetRemoteAddress(aRHEntryInfo->remoteAddress());
    394 
    395  nsCOMPtr<nsIURI> referrerUri;
    396  rv = aRHEntry->GetReferrerURI(getter_AddRefs(referrerUri));
    397  NS_ENSURE_SUCCESS(rv, rv);
    398  SerializeURI(referrerUri, aRHEntryInfo->referrerUri());
    399 
    400  nsCOMPtr<nsIPrincipal> principal;
    401  rv = aRHEntry->GetPrincipal(getter_AddRefs(principal));
    402  NS_ENSURE_SUCCESS(rv, rv);
    403 
    404  return PrincipalToPrincipalInfo(principal, &aRHEntryInfo->principalInfo());
    405 }
    406 
    407 nsresult LoadInfoToLoadInfoArgs(nsILoadInfo* aLoadInfo,
    408                                LoadInfoArgs* outLoadInfoArgs) {
    409  nsresult rv = NS_OK;
    410  Maybe<PrincipalInfo> loadingPrincipalInfo;
    411  if (nsIPrincipal* loadingPrin = aLoadInfo->GetLoadingPrincipal()) {
    412    loadingPrincipalInfo.emplace();
    413    rv = PrincipalToPrincipalInfo(loadingPrin, loadingPrincipalInfo.ptr());
    414    NS_ENSURE_SUCCESS(rv, rv);
    415  }
    416 
    417  PrincipalInfo triggeringPrincipalInfo;
    418  rv = PrincipalToPrincipalInfo(aLoadInfo->TriggeringPrincipal(),
    419                                &triggeringPrincipalInfo);
    420  NS_ENSURE_SUCCESS(rv, rv);
    421 
    422  Maybe<PrincipalInfo> principalToInheritInfo;
    423  if (nsIPrincipal* principalToInherit = aLoadInfo->PrincipalToInherit()) {
    424    principalToInheritInfo.emplace();
    425    rv = PrincipalToPrincipalInfo(principalToInherit,
    426                                  principalToInheritInfo.ptr());
    427    NS_ENSURE_SUCCESS(rv, rv);
    428  }
    429 
    430  Maybe<PrincipalInfo> topLevelPrincipalInfo;
    431  if (nsIPrincipal* topLevenPrin = aLoadInfo->GetTopLevelPrincipal()) {
    432    topLevelPrincipalInfo.emplace();
    433    rv = PrincipalToPrincipalInfo(topLevenPrin, topLevelPrincipalInfo.ptr());
    434    NS_ENSURE_SUCCESS(rv, rv);
    435  }
    436 
    437  Maybe<URIParams> optionalResultPrincipalURI;
    438  nsCOMPtr<nsIURI> resultPrincipalURI;
    439  (void)aLoadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI));
    440  if (resultPrincipalURI) {
    441    SerializeURI(resultPrincipalURI, optionalResultPrincipalURI);
    442  }
    443 
    444  nsCString triggeringRemoteType;
    445  rv = aLoadInfo->GetTriggeringRemoteType(triggeringRemoteType);
    446  NS_ENSURE_SUCCESS(rv, rv);
    447 
    448  nsTArray<RedirectHistoryEntryInfo> redirectChainIncludingInternalRedirects;
    449  for (const nsCOMPtr<nsIRedirectHistoryEntry>& redirectEntry :
    450       aLoadInfo->RedirectChainIncludingInternalRedirects()) {
    451    RedirectHistoryEntryInfo* entry =
    452        redirectChainIncludingInternalRedirects.AppendElement();
    453    rv = RHEntryToRHEntryInfo(redirectEntry, entry);
    454    NS_ENSURE_SUCCESS(rv, rv);
    455  }
    456 
    457  nsTArray<RedirectHistoryEntryInfo> redirectChain;
    458  for (const nsCOMPtr<nsIRedirectHistoryEntry>& redirectEntry :
    459       aLoadInfo->RedirectChain()) {
    460    RedirectHistoryEntryInfo* entry = redirectChain.AppendElement();
    461    rv = RHEntryToRHEntryInfo(redirectEntry, entry);
    462    NS_ENSURE_SUCCESS(rv, rv);
    463  }
    464 
    465  Maybe<IPCClientInfo> ipcClientInfo;
    466  const Maybe<ClientInfo>& clientInfo = aLoadInfo->GetClientInfo();
    467  if (clientInfo.isSome()) {
    468    ipcClientInfo.emplace(clientInfo.ref().ToIPC());
    469  }
    470 
    471  Maybe<IPCClientInfo> ipcReservedClientInfo;
    472  const Maybe<ClientInfo>& reservedClientInfo =
    473      aLoadInfo->GetReservedClientInfo();
    474  if (reservedClientInfo.isSome()) {
    475    ipcReservedClientInfo.emplace(reservedClientInfo.ref().ToIPC());
    476  }
    477 
    478  Maybe<IPCClientInfo> ipcInitialClientInfo;
    479  const Maybe<ClientInfo>& initialClientInfo =
    480      aLoadInfo->GetInitialClientInfo();
    481  if (initialClientInfo.isSome()) {
    482    ipcInitialClientInfo.emplace(initialClientInfo.ref().ToIPC());
    483  }
    484 
    485  Maybe<IPCServiceWorkerDescriptor> ipcController;
    486  const Maybe<ServiceWorkerDescriptor>& controller = aLoadInfo->GetController();
    487  if (controller.isSome()) {
    488    ipcController.emplace(controller.ref().ToIPC());
    489  }
    490 
    491  nsAutoString cspNonce;
    492  (void)NS_WARN_IF(NS_FAILED(aLoadInfo->GetCspNonce(cspNonce)));
    493 
    494  nsAutoString integrityMetadata;
    495  (void)NS_WARN_IF(
    496      NS_FAILED(aLoadInfo->GetIntegrityMetadata(integrityMetadata)));
    497 
    498  nsCOMPtr<nsICookieJarSettings> cookieJarSettings;
    499  rv = aLoadInfo->GetCookieJarSettings(getter_AddRefs(cookieJarSettings));
    500  NS_ENSURE_SUCCESS(rv, rv);
    501 
    502  CookieJarSettingsArgs cookieJarSettingsArgs;
    503  static_cast<CookieJarSettings*>(cookieJarSettings.get())
    504      ->Serialize(cookieJarSettingsArgs);
    505 
    506  nsCOMPtr<nsIURI> unstrippedURI;
    507  (void)aLoadInfo->GetUnstrippedURI(getter_AddRefs(unstrippedURI));
    508 
    509  Maybe<bool> isThirdPartyContextToTopWindow;
    510  if (static_cast<LoadInfo*>(aLoadInfo)
    511          ->HasIsThirdPartyContextToTopWindowSet()) {
    512    isThirdPartyContextToTopWindow.emplace(
    513        aLoadInfo->GetIsThirdPartyContextToTopWindow());
    514  }
    515 
    516  Maybe<InterceptionInfoArg> interceptionInfoArg;
    517  nsIInterceptionInfo* interceptionInfo = aLoadInfo->InterceptionInfo();
    518  if (interceptionInfo) {
    519    Maybe<PrincipalInfo> triggeringPrincipalInfo;
    520    if (interceptionInfo->TriggeringPrincipal()) {
    521      triggeringPrincipalInfo.emplace();
    522      rv = PrincipalToPrincipalInfo(interceptionInfo->TriggeringPrincipal(),
    523                                    triggeringPrincipalInfo.ptr());
    524    }
    525 
    526    nsTArray<RedirectHistoryEntryInfo> redirectChain;
    527    for (const nsCOMPtr<nsIRedirectHistoryEntry>& redirectEntry :
    528         interceptionInfo->RedirectChain()) {
    529      RedirectHistoryEntryInfo* entry = redirectChain.AppendElement();
    530      rv = RHEntryToRHEntryInfo(redirectEntry, entry);
    531      NS_ENSURE_SUCCESS(rv, rv);
    532    }
    533 
    534    interceptionInfoArg = Some(InterceptionInfoArg(
    535        triggeringPrincipalInfo, interceptionInfo->ContentPolicyType(),
    536        redirectChain, interceptionInfo->FromThirdParty()));
    537  }
    538 
    539  Maybe<RFPTargetSet> overriddenFingerprintingSettingsArg;
    540  Maybe<RFPTargetSet> overriddenFingerprintingSettings =
    541      aLoadInfo->GetOverriddenFingerprintingSettings();
    542 
    543  if (overriddenFingerprintingSettings) {
    544    overriddenFingerprintingSettingsArg =
    545        Some(overriddenFingerprintingSettings.ref());
    546  }
    547 
    548  Maybe<RequestMode> requestMode;
    549  aLoadInfo->GetRequestMode(&requestMode);
    550 
    551  Maybe<PolicyContainerArgs> maybePolicyContainerToInherit;
    552  nsCOMPtr<nsIPolicyContainer> policyContainerToInherit =
    553      aLoadInfo->GetPolicyContainerToInherit();
    554  if (policyContainerToInherit) {
    555    PolicyContainerArgs args;
    556    PolicyContainer::ToArgs(PolicyContainer::Cast(policyContainerToInherit),
    557                            args);
    558    maybePolicyContainerToInherit.emplace(args);
    559  }
    560 
    561  *outLoadInfoArgs = LoadInfoArgs(
    562      loadingPrincipalInfo, triggeringPrincipalInfo, principalToInheritInfo,
    563      topLevelPrincipalInfo, optionalResultPrincipalURI, triggeringRemoteType,
    564      aLoadInfo->GetSandboxedNullPrincipalID(), aLoadInfo->GetSecurityFlags(),
    565      aLoadInfo->GetSandboxFlags(), aLoadInfo->GetTriggeringSandboxFlags(),
    566      aLoadInfo->GetTriggeringWindowId(),
    567      aLoadInfo->GetTriggeringStorageAccess(),
    568      aLoadInfo->GetTriggeringFirstPartyClassificationFlags(),
    569      aLoadInfo->GetTriggeringThirdPartyClassificationFlags(),
    570      aLoadInfo->InternalContentPolicyType(),
    571      static_cast<uint32_t>(aLoadInfo->GetTainting()),
    572      aLoadInfo->GetBlockAllMixedContent(),
    573      aLoadInfo->GetUpgradeInsecureRequests(),
    574      aLoadInfo->GetBrowserUpgradeInsecureRequests(),
    575      aLoadInfo->GetBrowserDidUpgradeInsecureRequests(),
    576      aLoadInfo->GetBrowserWouldUpgradeInsecureRequests(),
    577      aLoadInfo->GetForceAllowDataURI(),
    578      aLoadInfo->GetAllowInsecureRedirectToDataURI(),
    579      aLoadInfo->GetForceMediaDocument(),
    580      aLoadInfo->GetSkipContentPolicyCheckForWebRequest(),
    581      aLoadInfo->GetOriginalFrameSrcLoad(),
    582      aLoadInfo->GetForceInheritPrincipalDropped(),
    583      aLoadInfo->GetInnerWindowID(), aLoadInfo->GetBrowsingContextID(),
    584      aLoadInfo->GetFrameBrowsingContextID(),
    585      aLoadInfo->GetInitialSecurityCheckDone(),
    586      aLoadInfo->GetIsInThirdPartyContext(), isThirdPartyContextToTopWindow,
    587      aLoadInfo->GetIsOn3PCBExceptionList(), aLoadInfo->GetIsFormSubmission(),
    588      aLoadInfo->GetIsGETRequest(), aLoadInfo->GetSendCSPViolationEvents(),
    589      aLoadInfo->GetOriginAttributes(), redirectChainIncludingInternalRedirects,
    590      redirectChain, aLoadInfo->GetHasInjectedCookieForCookieBannerHandling(),
    591      aLoadInfo->GetSchemelessInput(), aLoadInfo->GetHttpsUpgradeTelemetry(),
    592      ipcClientInfo, ipcReservedClientInfo, ipcInitialClientInfo, ipcController,
    593      aLoadInfo->CorsUnsafeHeaders(), aLoadInfo->GetForcePreflight(),
    594      aLoadInfo->GetIsPreflight(), aLoadInfo->GetLoadTriggeredFromExternal(),
    595      aLoadInfo->GetServiceWorkerTaintingSynthesized(),
    596      aLoadInfo->GetDocumentHasUserInteracted(),
    597      aLoadInfo->GetAllowListFutureDocumentsCreatedFromThisRedirectChain(),
    598      aLoadInfo->GetNeedForCheckingAntiTrackingHeuristic(), cspNonce,
    599      integrityMetadata, aLoadInfo->GetSkipContentSniffing(),
    600      aLoadInfo->GetHttpsOnlyStatus(), aLoadInfo->GetHstsStatus(),
    601      aLoadInfo->GetHasValidUserGestureActivation(),
    602      aLoadInfo->GetTextDirectiveUserActivation(),
    603      aLoadInfo->GetAllowDeprecatedSystemRequests(),
    604      aLoadInfo->GetIsInDevToolsContext(), aLoadInfo->GetParserCreatedScript(),
    605      requestMode, aLoadInfo->GetIsFromProcessingFrameAttributes(),
    606      aLoadInfo->GetIsMediaRequest(), aLoadInfo->GetIsMediaInitialRequest(),
    607      aLoadInfo->GetIsFromObjectOrEmbed(), cookieJarSettingsArgs,
    608      aLoadInfo->GetRequestBlockingReason(), maybePolicyContainerToInherit,
    609      aLoadInfo->GetStoragePermission(), aLoadInfo->GetParentIpAddressSpace(),
    610      aLoadInfo->GetIpAddressSpace(), overriddenFingerprintingSettingsArg,
    611      aLoadInfo->GetIsMetaRefresh(), aLoadInfo->GetLoadingEmbedderPolicy(),
    612      aLoadInfo->GetIsOriginTrialCoepCredentiallessEnabledForTopLevel(),
    613      unstrippedURI, interceptionInfoArg, aLoadInfo->GetIsNewWindowTarget(),
    614      aLoadInfo->GetUserNavigationInvolvement(),
    615      aLoadInfo->GetContainerFeaturePolicyInfo(), {});
    616 
    617  return NS_OK;
    618 }
    619 
    620 nsresult LoadInfoArgsToLoadInfo(const LoadInfoArgs& aLoadInfoArgs,
    621                                const nsACString& aOriginRemoteType,
    622                                nsILoadInfo** outLoadInfo) {
    623  return LoadInfoArgsToLoadInfo(aLoadInfoArgs, aOriginRemoteType, nullptr,
    624                                outLoadInfo);
    625 }
    626 nsresult LoadInfoArgsToLoadInfo(const LoadInfoArgs& aLoadInfoArgs,
    627                                const nsACString& aOriginRemoteType,
    628                                nsINode* aCspToInheritLoadingContext,
    629                                nsILoadInfo** outLoadInfo) {
    630  RefPtr<LoadInfo> loadInfo;
    631  nsresult rv = LoadInfoArgsToLoadInfo(aLoadInfoArgs, aOriginRemoteType,
    632                                       aCspToInheritLoadingContext,
    633                                       getter_AddRefs(loadInfo));
    634  NS_ENSURE_SUCCESS(rv, rv);
    635 
    636  loadInfo.forget(outLoadInfo);
    637  return NS_OK;
    638 }
    639 
    640 nsresult LoadInfoArgsToLoadInfo(const LoadInfoArgs& aLoadInfoArgs,
    641                                const nsACString& aOriginRemoteType,
    642                                LoadInfo** outLoadInfo) {
    643  return LoadInfoArgsToLoadInfo(aLoadInfoArgs, aOriginRemoteType, nullptr,
    644                                outLoadInfo);
    645 }
    646 nsresult LoadInfoArgsToLoadInfo(const LoadInfoArgs& loadInfoArgs,
    647                                const nsACString& aOriginRemoteType,
    648                                nsINode* aCspToInheritLoadingContext,
    649                                LoadInfo** outLoadInfo) {
    650  nsCOMPtr<nsIPrincipal> loadingPrincipal;
    651  if (loadInfoArgs.requestingPrincipalInfo().isSome()) {
    652    auto loadingPrincipalOrErr =
    653        PrincipalInfoToPrincipal(loadInfoArgs.requestingPrincipalInfo().ref());
    654    if (NS_WARN_IF(loadingPrincipalOrErr.isErr())) {
    655      return loadingPrincipalOrErr.unwrapErr();
    656    }
    657    loadingPrincipal = loadingPrincipalOrErr.unwrap();
    658  }
    659 
    660  auto triggeringPrincipalOrErr =
    661      PrincipalInfoToPrincipal(loadInfoArgs.triggeringPrincipalInfo());
    662  if (NS_WARN_IF(triggeringPrincipalOrErr.isErr())) {
    663    return triggeringPrincipalOrErr.unwrapErr();
    664  }
    665  nsCOMPtr<nsIPrincipal> triggeringPrincipal =
    666      triggeringPrincipalOrErr.unwrap();
    667 
    668  nsCOMPtr<nsIPrincipal> principalToInherit;
    669  nsCOMPtr<nsIPrincipal> flattenedPrincipalToInherit;
    670  if (loadInfoArgs.principalToInheritInfo().isSome()) {
    671    auto principalToInheritOrErr =
    672        PrincipalInfoToPrincipal(loadInfoArgs.principalToInheritInfo().ref());
    673    if (NS_WARN_IF(principalToInheritOrErr.isErr())) {
    674      return principalToInheritOrErr.unwrapErr();
    675    }
    676    flattenedPrincipalToInherit = principalToInheritOrErr.unwrap();
    677  }
    678 
    679  if (XRE_IsContentProcess()) {
    680    auto targetBrowsingContextId = loadInfoArgs.frameBrowsingContextID()
    681                                       ? loadInfoArgs.frameBrowsingContextID()
    682                                       : loadInfoArgs.browsingContextID();
    683    if (RefPtr<BrowsingContext> bc =
    684            BrowsingContext::Get(targetBrowsingContextId)) {
    685      auto [originalTriggeringPrincipal, originalPrincipalToInherit] =
    686          bc->GetTriggeringAndInheritPrincipalsForCurrentLoad();
    687 
    688      if (originalTriggeringPrincipal &&
    689          originalTriggeringPrincipal->Equals(triggeringPrincipal)) {
    690        triggeringPrincipal = originalTriggeringPrincipal;
    691      }
    692      if (originalPrincipalToInherit &&
    693          (loadInfoArgs.securityFlags() &
    694           nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL) &&
    695          originalPrincipalToInherit->Equals(flattenedPrincipalToInherit)) {
    696        principalToInherit = originalPrincipalToInherit;
    697      }
    698    }
    699  }
    700  if (!principalToInherit && loadInfoArgs.principalToInheritInfo().isSome()) {
    701    principalToInherit = flattenedPrincipalToInherit;
    702  }
    703 
    704  nsCOMPtr<nsIPrincipal> topLevelPrincipal;
    705  if (loadInfoArgs.topLevelPrincipalInfo().isSome()) {
    706    auto topLevelPrincipalOrErr =
    707        PrincipalInfoToPrincipal(loadInfoArgs.topLevelPrincipalInfo().ref());
    708    if (NS_WARN_IF(topLevelPrincipalOrErr.isErr())) {
    709      return topLevelPrincipalOrErr.unwrapErr();
    710    }
    711    topLevelPrincipal = topLevelPrincipalOrErr.unwrap();
    712  }
    713 
    714  nsCOMPtr<nsIURI> resultPrincipalURI;
    715  if (loadInfoArgs.resultPrincipalURI().isSome()) {
    716    resultPrincipalURI = DeserializeURI(loadInfoArgs.resultPrincipalURI());
    717    NS_ENSURE_TRUE(resultPrincipalURI, NS_ERROR_UNEXPECTED);
    718  }
    719 
    720  // If we received this message from a content process, reset
    721  // triggeringRemoteType to the process which sent us the message. If the
    722  // parent sent us the message, we trust it to provide the correct triggering
    723  // remote type.
    724  //
    725  // This means that the triggering remote type will be reset if a LoadInfo is
    726  // bounced through a content process, as the LoadInfo can no longer be
    727  // validated to be coming from the originally specified remote type.
    728  nsCString triggeringRemoteType = loadInfoArgs.triggeringRemoteType();
    729  if (aOriginRemoteType != NOT_REMOTE_TYPE &&
    730      aOriginRemoteType != triggeringRemoteType) {
    731    triggeringRemoteType = aOriginRemoteType;
    732  }
    733 
    734  RedirectHistoryArray redirectChainIncludingInternalRedirects;
    735  for (const RedirectHistoryEntryInfo& entryInfo :
    736       loadInfoArgs.redirectChainIncludingInternalRedirects()) {
    737    nsCOMPtr<nsIRedirectHistoryEntry> redirectHistoryEntry =
    738        RHEntryInfoToRHEntry(entryInfo);
    739    NS_ENSURE_TRUE(redirectHistoryEntry, NS_ERROR_UNEXPECTED);
    740    redirectChainIncludingInternalRedirects.AppendElement(
    741        redirectHistoryEntry.forget());
    742  }
    743 
    744  RedirectHistoryArray redirectChain;
    745  for (const RedirectHistoryEntryInfo& entryInfo :
    746       loadInfoArgs.redirectChain()) {
    747    nsCOMPtr<nsIRedirectHistoryEntry> redirectHistoryEntry =
    748        RHEntryInfoToRHEntry(entryInfo);
    749    NS_ENSURE_TRUE(redirectHistoryEntry, NS_ERROR_UNEXPECTED);
    750    redirectChain.AppendElement(redirectHistoryEntry.forget());
    751  }
    752  nsTArray<nsCOMPtr<nsIPrincipal>> ancestorPrincipals;
    753  nsTArray<uint64_t> ancestorBrowsingContextIDs;
    754  if (XRE_IsParentProcess() &&
    755      (nsContentUtils::InternalContentPolicyTypeToExternal(
    756           loadInfoArgs.contentPolicyType()) !=
    757       ExtContentPolicy::TYPE_DOCUMENT)) {
    758    // Only fill out ancestor principals and browsing context IDs when we
    759    // are deserializing LoadInfoArgs to be LoadInfo for a subresource
    760    RefPtr<BrowsingContext> parentBC =
    761        BrowsingContext::Get(loadInfoArgs.browsingContextID());
    762    if (parentBC) {
    763      LoadInfo::ComputeAncestors(parentBC->Canonical(), ancestorPrincipals,
    764                                 ancestorBrowsingContextIDs);
    765    }
    766  } else {
    767    // Fill out (possibly redacted) ancestor principals for
    768    // Location.ancestorOrigins
    769    for (const auto& principalInfo : loadInfoArgs.ancestorOrigins()) {
    770      if (principalInfo.isNothing()) {
    771        ancestorPrincipals.AppendElement(nullptr);
    772      } else {
    773        auto principal = PrincipalInfoToPrincipal(principalInfo.value());
    774        // If this operation fail, we censor the origin.
    775        ancestorPrincipals.AppendElement(principal.unwrapOr(nullptr));
    776      }
    777    }
    778  }
    779 
    780  Maybe<ClientInfo> clientInfo;
    781  if (loadInfoArgs.clientInfo().isSome()) {
    782    clientInfo.emplace(ClientInfo(loadInfoArgs.clientInfo().ref()));
    783  }
    784 
    785  Maybe<ClientInfo> reservedClientInfo;
    786  if (loadInfoArgs.reservedClientInfo().isSome()) {
    787    reservedClientInfo.emplace(
    788        ClientInfo(loadInfoArgs.reservedClientInfo().ref()));
    789  }
    790 
    791  Maybe<ClientInfo> initialClientInfo;
    792  if (loadInfoArgs.initialClientInfo().isSome()) {
    793    initialClientInfo.emplace(
    794        ClientInfo(loadInfoArgs.initialClientInfo().ref()));
    795  }
    796 
    797  // We can have an initial client info or a reserved client info, but not both.
    798  MOZ_DIAGNOSTIC_ASSERT(reservedClientInfo.isNothing() ||
    799                        initialClientInfo.isNothing());
    800  NS_ENSURE_TRUE(
    801      reservedClientInfo.isNothing() || initialClientInfo.isNothing(),
    802      NS_ERROR_UNEXPECTED);
    803 
    804  Maybe<ServiceWorkerDescriptor> controller;
    805  if (loadInfoArgs.controller().isSome()) {
    806    controller.emplace(
    807        ServiceWorkerDescriptor(loadInfoArgs.controller().ref()));
    808  }
    809 
    810  nsCOMPtr<nsICookieJarSettings> cookieJarSettings;
    811  CookieJarSettings::Deserialize(loadInfoArgs.cookieJarSettings(),
    812                                 getter_AddRefs(cookieJarSettings));
    813 
    814  Maybe<RFPTargetSet> overriddenFingerprintingSettings;
    815  if (loadInfoArgs.overriddenFingerprintingSettings().isSome()) {
    816    overriddenFingerprintingSettings.emplace(
    817        loadInfoArgs.overriddenFingerprintingSettings().ref());
    818  }
    819 
    820  // Restore the loadingContext for frames using the BrowsingContext's
    821  // embedder element. Note that this only works if the embedder is
    822  // same-process, so won't be fission compatible.
    823  nsCOMPtr<nsINode> loadingContext;
    824  RefPtr<BrowsingContext> frameBrowsingContext =
    825      BrowsingContext::Get(loadInfoArgs.frameBrowsingContextID());
    826  if (frameBrowsingContext) {
    827    loadingContext = frameBrowsingContext->GetEmbedderElement();
    828  }
    829 
    830  Maybe<bool> isThirdPartyContextToTopWindow;
    831  if (loadInfoArgs.isThirdPartyContextToTopWindow().isSome()) {
    832    isThirdPartyContextToTopWindow.emplace(
    833        loadInfoArgs.isThirdPartyContextToTopWindow().ref());
    834  }
    835 
    836  nsCOMPtr<nsIInterceptionInfo> interceptionInfo;
    837  if (loadInfoArgs.interceptionInfo().isSome()) {
    838    const InterceptionInfoArg& interceptionInfoArg =
    839        loadInfoArgs.interceptionInfo().ref();
    840    nsCOMPtr<nsIPrincipal> triggeringPrincipal;
    841    if (interceptionInfoArg.triggeringPrincipalInfo().isSome()) {
    842      auto triggeringPrincipalOrErr = PrincipalInfoToPrincipal(
    843          interceptionInfoArg.triggeringPrincipalInfo().ref());
    844      if (NS_WARN_IF(triggeringPrincipalOrErr.isErr())) {
    845        return triggeringPrincipalOrErr.unwrapErr();
    846      }
    847      triggeringPrincipal = triggeringPrincipalOrErr.unwrap();
    848    }
    849 
    850    RedirectHistoryArray redirectChain;
    851    for (const RedirectHistoryEntryInfo& entryInfo :
    852         interceptionInfoArg.redirectChain()) {
    853      nsCOMPtr<nsIRedirectHistoryEntry> redirectHistoryEntry =
    854          RHEntryInfoToRHEntry(entryInfo);
    855      NS_ENSURE_TRUE(redirectHistoryEntry, NS_ERROR_UNEXPECTED);
    856      redirectChain.AppendElement(redirectHistoryEntry.forget());
    857    }
    858 
    859    interceptionInfo = new InterceptionInfo(
    860        triggeringPrincipal, interceptionInfoArg.contentPolicyType(),
    861        redirectChain, interceptionInfoArg.fromThirdParty());
    862  }
    863 
    864  RefPtr<PolicyContainer> policyContainerToInherit;
    865  const auto& policyContainerToInheritArgs =
    866      loadInfoArgs.policyContainerToInherit();
    867  if (policyContainerToInheritArgs.isSome()) {
    868    nsCOMPtr<Document> doc = do_QueryInterface(aCspToInheritLoadingContext);
    869    PolicyContainer::FromArgs(policyContainerToInheritArgs.ref(), doc,
    870                              getter_AddRefs(policyContainerToInherit));
    871  }
    872 
    873  RefPtr<mozilla::net::LoadInfo> loadInfo = new mozilla::net::LoadInfo(
    874      loadingPrincipal, triggeringPrincipal, principalToInherit,
    875      topLevelPrincipal, resultPrincipalURI, cookieJarSettings,
    876      policyContainerToInherit, loadInfoArgs.containerFeaturePolicyInfo(),
    877      triggeringRemoteType, loadInfoArgs.sandboxedNullPrincipalID(), clientInfo,
    878      reservedClientInfo, initialClientInfo, controller,
    879      loadInfoArgs.securityFlags(), loadInfoArgs.sandboxFlags(),
    880      loadInfoArgs.contentPolicyType(),
    881      static_cast<LoadTainting>(loadInfoArgs.tainting()),
    882 
    883 #define DEFINE_ARGUMENT(_t, _n, name, _d) loadInfoArgs.name(),
    884      LOADINFO_FOR_EACH_FIELD(DEFINE_ARGUMENT, LOADINFO_DUMMY_SETTER)
    885 #undef DEFINE_ARGUMENT
    886 
    887          loadInfoArgs.initialSecurityCheckDone(),
    888      loadInfoArgs.isInThirdPartyContext(), isThirdPartyContextToTopWindow,
    889      loadInfoArgs.originAttributes(),
    890      std::move(redirectChainIncludingInternalRedirects),
    891      std::move(redirectChain), std::move(ancestorPrincipals),
    892      ancestorBrowsingContextIDs, loadInfoArgs.corsUnsafeHeaders(),
    893      loadInfoArgs.loadTriggeredFromExternal(), loadInfoArgs.cspNonce(),
    894      loadInfoArgs.integrityMetadata(),
    895      // This function is only called for moving LoadInfo across processes.
    896      // Same-document navigation won't cross process boundaries.
    897      /* aIsSameDocumentNavigation */ false, overriddenFingerprintingSettings,
    898      loadingContext, loadInfoArgs.unstrippedURI(), interceptionInfo,
    899      loadInfoArgs.schemelessInput(), loadInfoArgs.userNavigationInvolvement());
    900 
    901  loadInfo.forget(outLoadInfo);
    902  return NS_OK;
    903 }
    904 
    905 void LoadInfoToParentLoadInfoForwarder(
    906    nsILoadInfo* aLoadInfo, ParentLoadInfoForwarderArgs* aForwarderArgsOut) {
    907  Maybe<IPCServiceWorkerDescriptor> ipcController;
    908  Maybe<ServiceWorkerDescriptor> controller(aLoadInfo->GetController());
    909  if (controller.isSome()) {
    910    ipcController.emplace(controller.ref().ToIPC());
    911  }
    912 
    913  uint32_t tainting = nsILoadInfo::TAINTING_BASIC;
    914  (void)aLoadInfo->GetTainting(&tainting);
    915 
    916  Maybe<CookieJarSettingsArgs> cookieJarSettingsArgs;
    917 
    918  nsCOMPtr<nsICookieJarSettings> cookieJarSettings;
    919  nsresult rv =
    920      aLoadInfo->GetCookieJarSettings(getter_AddRefs(cookieJarSettings));
    921  CookieJarSettings* cs =
    922      static_cast<CookieJarSettings*>(cookieJarSettings.get());
    923  if (NS_SUCCEEDED(rv) && cookieJarSettings && cs->HasBeenChanged()) {
    924    CookieJarSettingsArgs args;
    925    cs->Serialize(args);
    926    cookieJarSettingsArgs = Some(args);
    927  }
    928 
    929  nsCOMPtr<nsIURI> unstrippedURI;
    930  (void)aLoadInfo->GetUnstrippedURI(getter_AddRefs(unstrippedURI));
    931 
    932  Maybe<bool> isThirdPartyContextToTopWindow;
    933  if (static_cast<LoadInfo*>(aLoadInfo)
    934          ->HasIsThirdPartyContextToTopWindowSet()) {
    935    isThirdPartyContextToTopWindow.emplace(
    936        aLoadInfo->GetIsThirdPartyContextToTopWindow());
    937  }
    938 
    939  Maybe<RFPTargetSet> overriddenFingerprintingSettingsArg;
    940  Maybe<RFPTargetSet> overriddenFingerprintingSettings =
    941      aLoadInfo->GetOverriddenFingerprintingSettings();
    942 
    943  if (overriddenFingerprintingSettings) {
    944    overriddenFingerprintingSettingsArg =
    945        Some(overriddenFingerprintingSettings.ref());
    946  }
    947 
    948  Maybe<RequestMode> requestMode;
    949  aLoadInfo->GetRequestMode(&requestMode);
    950 
    951  *aForwarderArgsOut = ParentLoadInfoForwarderArgs(
    952      aLoadInfo->GetAllowInsecureRedirectToDataURI(), ipcController, tainting,
    953      aLoadInfo->GetSkipContentSniffing(), aLoadInfo->GetHttpsOnlyStatus(),
    954      aLoadInfo->GetSchemelessInput(), aLoadInfo->GetHttpsUpgradeTelemetry(),
    955      aLoadInfo->GetHstsStatus(), aLoadInfo->GetHasValidUserGestureActivation(),
    956      aLoadInfo->GetTextDirectiveUserActivation(),
    957      aLoadInfo->GetAllowDeprecatedSystemRequests(),
    958      aLoadInfo->GetIsInDevToolsContext(), aLoadInfo->GetParserCreatedScript(),
    959      requestMode, aLoadInfo->GetTriggeringSandboxFlags(),
    960      aLoadInfo->GetTriggeringWindowId(),
    961      aLoadInfo->GetTriggeringStorageAccess(),
    962      aLoadInfo->GetServiceWorkerTaintingSynthesized(),
    963      aLoadInfo->GetDocumentHasUserInteracted(),
    964      aLoadInfo->GetAllowListFutureDocumentsCreatedFromThisRedirectChain(),
    965      cookieJarSettingsArgs, aLoadInfo->GetContainerFeaturePolicyInfo(),
    966      aLoadInfo->GetRequestBlockingReason(), aLoadInfo->GetStoragePermission(),
    967      overriddenFingerprintingSettingsArg, aLoadInfo->GetIsMetaRefresh(),
    968      isThirdPartyContextToTopWindow, aLoadInfo->GetIsInThirdPartyContext(),
    969      aLoadInfo->GetIsOn3PCBExceptionList(), unstrippedURI,
    970      aLoadInfo->GetUserNavigationInvolvement());
    971 }
    972 
    973 nsresult MergeParentLoadInfoForwarder(
    974    ParentLoadInfoForwarderArgs const& aForwarderArgs, nsILoadInfo* aLoadInfo) {
    975  nsresult rv;
    976 
    977  rv = aLoadInfo->SetAllowInsecureRedirectToDataURI(
    978      aForwarderArgs.allowInsecureRedirectToDataURI());
    979  NS_ENSURE_SUCCESS(rv, rv);
    980 
    981  aLoadInfo->ClearController();
    982  auto& controller = aForwarderArgs.controller();
    983  if (controller.isSome()) {
    984    aLoadInfo->SetController(ServiceWorkerDescriptor(controller.ref()));
    985  }
    986 
    987  if (aForwarderArgs.serviceWorkerTaintingSynthesized()) {
    988    aLoadInfo->SynthesizeServiceWorkerTainting(
    989        static_cast<LoadTainting>(aForwarderArgs.tainting()));
    990  } else {
    991    aLoadInfo->MaybeIncreaseTainting(aForwarderArgs.tainting());
    992  }
    993  rv = aLoadInfo->SetTextDirectiveUserActivation(
    994      aForwarderArgs.textDirectiveUserActivation());
    995  NS_ENSURE_SUCCESS(rv, rv);
    996 
    997  rv = aLoadInfo->SetSkipContentSniffing(aForwarderArgs.skipContentSniffing());
    998  NS_ENSURE_SUCCESS(rv, rv);
    999 
   1000  rv = aLoadInfo->SetHttpsOnlyStatus(aForwarderArgs.httpsOnlyStatus());
   1001  NS_ENSURE_SUCCESS(rv, rv);
   1002 
   1003  rv = aLoadInfo->SetSchemelessInput(aForwarderArgs.schemelessInput());
   1004  NS_ENSURE_SUCCESS(rv, rv);
   1005 
   1006  rv = aLoadInfo->SetHttpsUpgradeTelemetry(
   1007      aForwarderArgs.httpsUpgradeTelemetry());
   1008  NS_ENSURE_SUCCESS(rv, rv);
   1009 
   1010  rv = aLoadInfo->SetHstsStatus(aForwarderArgs.hstsStatus());
   1011  NS_ENSURE_SUCCESS(rv, rv);
   1012 
   1013  rv = aLoadInfo->SetTriggeringSandboxFlags(
   1014      aForwarderArgs.triggeringSandboxFlags());
   1015  NS_ENSURE_SUCCESS(rv, rv);
   1016 
   1017  rv = aLoadInfo->SetTriggeringWindowId(aForwarderArgs.triggeringWindowId());
   1018  NS_ENSURE_SUCCESS(rv, rv);
   1019 
   1020  rv = aLoadInfo->SetTriggeringStorageAccess(
   1021      aForwarderArgs.triggeringStorageAccess());
   1022  NS_ENSURE_SUCCESS(rv, rv);
   1023 
   1024  rv = aLoadInfo->SetHasValidUserGestureActivation(
   1025      aForwarderArgs.hasValidUserGestureActivation());
   1026  NS_ENSURE_SUCCESS(rv, rv);
   1027 
   1028  rv = aLoadInfo->SetAllowDeprecatedSystemRequests(
   1029      aForwarderArgs.allowDeprecatedSystemRequests());
   1030  NS_ENSURE_SUCCESS(rv, rv);
   1031 
   1032  rv = aLoadInfo->SetIsInDevToolsContext(aForwarderArgs.isInDevToolsContext());
   1033  NS_ENSURE_SUCCESS(rv, rv);
   1034 
   1035  rv = aLoadInfo->SetParserCreatedScript(aForwarderArgs.parserCreatedScript());
   1036  NS_ENSURE_SUCCESS(rv, rv);
   1037 
   1038  rv = aLoadInfo->SetRequestMode(aForwarderArgs.requestMode());
   1039  NS_ENSURE_SUCCESS(rv, rv);
   1040 
   1041  MOZ_ALWAYS_SUCCEEDS(aLoadInfo->SetDocumentHasUserInteracted(
   1042      aForwarderArgs.documentHasUserInteracted()));
   1043  MOZ_ALWAYS_SUCCEEDS(
   1044      aLoadInfo->SetAllowListFutureDocumentsCreatedFromThisRedirectChain(
   1045          aForwarderArgs
   1046              .allowListFutureDocumentsCreatedFromThisRedirectChain()));
   1047  MOZ_ALWAYS_SUCCEEDS(aLoadInfo->SetRequestBlockingReason(
   1048      aForwarderArgs.requestBlockingReason()));
   1049 
   1050  const Maybe<CookieJarSettingsArgs>& cookieJarSettingsArgs =
   1051      aForwarderArgs.cookieJarSettings();
   1052  if (cookieJarSettingsArgs.isSome()) {
   1053    nsCOMPtr<nsICookieJarSettings> cookieJarSettings;
   1054    nsresult rv =
   1055        aLoadInfo->GetCookieJarSettings(getter_AddRefs(cookieJarSettings));
   1056    if (NS_SUCCEEDED(rv) && cookieJarSettings) {
   1057      nsCOMPtr<nsICookieJarSettings> mergedCookieJarSettings;
   1058      mergedCookieJarSettings =
   1059          static_cast<CookieJarSettings*>(cookieJarSettings.get())
   1060              ->Merge(cookieJarSettingsArgs.ref());
   1061      aLoadInfo->SetCookieJarSettings(mergedCookieJarSettings);
   1062    }
   1063  }
   1064 
   1065  rv = aLoadInfo->SetStoragePermission(aForwarderArgs.storagePermission());
   1066  NS_ENSURE_SUCCESS(rv, rv);
   1067 
   1068  rv = aLoadInfo->SetIsMetaRefresh(aForwarderArgs.isMetaRefresh());
   1069  NS_ENSURE_SUCCESS(rv, rv);
   1070 
   1071  const Maybe<RFPTargetSet> overriddenFingerprintingSettings =
   1072      aForwarderArgs.overriddenFingerprintingSettings();
   1073  if (overriddenFingerprintingSettings.isSome()) {
   1074    aLoadInfo->SetOverriddenFingerprintingSettings(
   1075        overriddenFingerprintingSettings.ref());
   1076  }
   1077 
   1078  static_cast<LoadInfo*>(aLoadInfo)->ClearIsThirdPartyContextToTopWindow();
   1079  if (aForwarderArgs.isThirdPartyContextToTopWindow().isSome()) {
   1080    rv = aLoadInfo->SetIsThirdPartyContextToTopWindow(
   1081        aForwarderArgs.isThirdPartyContextToTopWindow().ref());
   1082  }
   1083  NS_ENSURE_SUCCESS(rv, rv);
   1084 
   1085  rv = aLoadInfo->SetIsInThirdPartyContext(
   1086      aForwarderArgs.isInThirdPartyContext());
   1087  NS_ENSURE_SUCCESS(rv, rv);
   1088 
   1089  rv = aLoadInfo->SetIsOn3PCBExceptionList(
   1090      aForwarderArgs.isOn3PCBExceptionList());
   1091  NS_ENSURE_SUCCESS(rv, rv);
   1092 
   1093  rv = aLoadInfo->SetUnstrippedURI(aForwarderArgs.unstrippedURI());
   1094  NS_ENSURE_SUCCESS(rv, rv);
   1095 
   1096  if (aForwarderArgs.containerFeaturePolicyInfo()) {
   1097    aLoadInfo->SetContainerFeaturePolicyInfo(
   1098        *aForwarderArgs.containerFeaturePolicyInfo());
   1099  }
   1100 
   1101  aLoadInfo->SetUserNavigationInvolvement(
   1102      uint8_t(aForwarderArgs.userNavigationInvolvement()));
   1103 
   1104  return NS_OK;
   1105 }
   1106 
   1107 void LoadInfoToChildLoadInfoForwarder(
   1108    nsILoadInfo* aLoadInfo, ChildLoadInfoForwarderArgs* aForwarderArgsOut) {
   1109  Maybe<IPCClientInfo> ipcReserved;
   1110  Maybe<ClientInfo> reserved(aLoadInfo->GetReservedClientInfo());
   1111  if (reserved.isSome()) {
   1112    ipcReserved.emplace(reserved.ref().ToIPC());
   1113  }
   1114 
   1115  Maybe<IPCClientInfo> ipcInitial;
   1116  Maybe<ClientInfo> initial(aLoadInfo->GetInitialClientInfo());
   1117  if (initial.isSome()) {
   1118    ipcInitial.emplace(initial.ref().ToIPC());
   1119  }
   1120 
   1121  Maybe<IPCServiceWorkerDescriptor> ipcController;
   1122  Maybe<ServiceWorkerDescriptor> controller(aLoadInfo->GetController());
   1123  if (controller.isSome()) {
   1124    ipcController.emplace(controller.ref().ToIPC());
   1125  }
   1126 
   1127  *aForwarderArgsOut =
   1128      ChildLoadInfoForwarderArgs(ipcReserved, ipcInitial, ipcController,
   1129                                 aLoadInfo->GetRequestBlockingReason());
   1130 }
   1131 
   1132 nsresult MergeChildLoadInfoForwarder(
   1133    const ChildLoadInfoForwarderArgs& aForwarderArgs, nsILoadInfo* aLoadInfo) {
   1134  Maybe<ClientInfo> reservedClientInfo;
   1135  auto& ipcReserved = aForwarderArgs.reservedClientInfo();
   1136  if (ipcReserved.isSome()) {
   1137    reservedClientInfo.emplace(ClientInfo(ipcReserved.ref()));
   1138  }
   1139 
   1140  Maybe<ClientInfo> initialClientInfo;
   1141  auto& ipcInitial = aForwarderArgs.initialClientInfo();
   1142  if (ipcInitial.isSome()) {
   1143    initialClientInfo.emplace(ClientInfo(ipcInitial.ref()));
   1144  }
   1145 
   1146  // There should only be at most one reserved or initial ClientInfo.
   1147  if (NS_WARN_IF(reservedClientInfo.isSome() && initialClientInfo.isSome())) {
   1148    return NS_ERROR_FAILURE;
   1149  }
   1150 
   1151  // If we received no reserved or initial ClientInfo, then we must not
   1152  // already have one set.  There are no use cases where this should
   1153  // happen and we don't have a way to clear the current value.
   1154  if (NS_WARN_IF(reservedClientInfo.isNothing() &&
   1155                 initialClientInfo.isNothing() &&
   1156                 (aLoadInfo->GetReservedClientInfo().isSome() ||
   1157                  aLoadInfo->GetInitialClientInfo().isSome()))) {
   1158    return NS_ERROR_FAILURE;
   1159  }
   1160 
   1161  if (reservedClientInfo.isSome()) {
   1162    // We need to override here instead of simply set the value.  This
   1163    // allows us to change the reserved client.  This is necessary when
   1164    // the ClientChannelHelper created a new reserved client in the
   1165    // child-side of the redirect.
   1166    aLoadInfo->OverrideReservedClientInfoInParent(reservedClientInfo.ref());
   1167  } else if (initialClientInfo.isSome()) {
   1168    aLoadInfo->SetInitialClientInfo(initialClientInfo.ref());
   1169  }
   1170 
   1171  aLoadInfo->ClearController();
   1172  auto& controller = aForwarderArgs.controller();
   1173  if (controller.isSome()) {
   1174    aLoadInfo->SetController(ServiceWorkerDescriptor(controller.ref()));
   1175  }
   1176 
   1177  uint32_t blockingReason = aForwarderArgs.requestBlockingReason();
   1178  if (blockingReason) {
   1179    // We only want to override when non-null, so that any earlier set non-null
   1180    // value is not reverted to 0.
   1181    aLoadInfo->SetRequestBlockingReason(blockingReason);
   1182  }
   1183 
   1184  return NS_OK;
   1185 }
   1186 
   1187 }  // namespace ipc
   1188 }  // namespace mozilla
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE