nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity

Bug 1528677: Remove nullchecks for loadinfo since we have loadinfo on all channels. r=baku

Browse source
This commit is contained in:
Christoph Kerschbaumer 2019-02-20 13:27:25 +01:00
parent 14c58f6fa7
commit 54df1cb98c
68 changed files with 407 additions and 685 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

102
caps/nsScriptSecurityManager.cpp
View file

@ -253,9 +253,9 @@ static void InheritAndSetCSPOnPrincipalIfNeeded(nsIChannel* aChannel,
return; return;
} }
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (!loadInfo || loadInfo->GetExternalContentPolicyType() != if (loadInfo->GetExternalContentPolicyType() !=
nsIContentPolicy::TYPE_SUBDOCUMENT) { nsIContentPolicy::TYPE_SUBDOCUMENT) {
return; return;
} }
@ -302,8 +302,8 @@ nsresult nsScriptSecurityManager::GetChannelResultPrincipal(
MOZ_ASSERT(aChannel, "Must have channel!"); MOZ_ASSERT(aChannel, "Must have channel!");
// Check whether we have an nsILoadInfo that says what we should do. // Check whether we have an nsILoadInfo that says what we should do.
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo && loadInfo->GetForceInheritPrincipalOverruleOwner()) { if (loadInfo->GetForceInheritPrincipalOverruleOwner()) {
nsCOMPtr<nsIPrincipal> principalToInherit = nsCOMPtr<nsIPrincipal> principalToInherit =
loadInfo->FindPrincipalToInherit(aChannel); loadInfo->FindPrincipalToInherit(aChannel);
principalToInherit.forget(aPrincipal); principalToInherit.forget(aPrincipal);
@ -319,53 +319,51 @@ nsresult nsScriptSecurityManager::GetChannelResultPrincipal(
} }
} }
if (loadInfo) { if (!aIgnoreSandboxing && loadInfo->GetLoadingSandboxed()) {
if (!aIgnoreSandboxing && loadInfo->GetLoadingSandboxed()) { nsCOMPtr<nsIPrincipal> sandboxedLoadingPrincipal =
nsCOMPtr<nsIPrincipal> sandboxedLoadingPrincipal = loadInfo->GetSandboxedLoadingPrincipal();
loadInfo->GetSandboxedLoadingPrincipal(); MOZ_ASSERT(sandboxedLoadingPrincipal);
MOZ_ASSERT(sandboxedLoadingPrincipal); InheritAndSetCSPOnPrincipalIfNeeded(aChannel, sandboxedLoadingPrincipal);
InheritAndSetCSPOnPrincipalIfNeeded(aChannel, sandboxedLoadingPrincipal); sandboxedLoadingPrincipal.forget(aPrincipal);
sandboxedLoadingPrincipal.forget(aPrincipal); return NS_OK;
return NS_OK; }
}
bool forceInherit = loadInfo->GetForceInheritPrincipal(); bool forceInherit = loadInfo->GetForceInheritPrincipal();
if (aIgnoreSandboxing && !forceInherit) { if (aIgnoreSandboxing && !forceInherit) {
// Check if SEC_FORCE_INHERIT_PRINCIPAL was dropped because of // Check if SEC_FORCE_INHERIT_PRINCIPAL was dropped because of
// sandboxing: // sandboxing:
if (loadInfo->GetLoadingSandboxed() && if (loadInfo->GetLoadingSandboxed() &&
loadInfo->GetForceInheritPrincipalDropped()) { loadInfo->GetForceInheritPrincipalDropped()) {
forceInherit = true; forceInherit = true;
}
} }
if (forceInherit) { }
nsCOMPtr<nsIPrincipal> principalToInherit = if (forceInherit) {
loadInfo->FindPrincipalToInherit(aChannel); nsCOMPtr<nsIPrincipal> principalToInherit =
loadInfo->FindPrincipalToInherit(aChannel);
principalToInherit.forget(aPrincipal);
return NS_OK;
}
auto securityMode = loadInfo->GetSecurityMode();
// The data: inheritance flags should only apply to the initial load,
// not to loads that it might have redirected to.
if (loadInfo->RedirectChain().IsEmpty() &&
(securityMode == nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_DATA_INHERITS ||
securityMode == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS ||
securityMode == nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS)) {
nsCOMPtr<nsIURI> uri;
nsresult rv = NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIPrincipal> principalToInherit =
loadInfo->FindPrincipalToInherit(aChannel);
bool inheritForAboutBlank = loadInfo->GetAboutBlankInherits();
if (nsContentUtils::ChannelShouldInheritPrincipal(
principalToInherit, uri, inheritForAboutBlank, false)) {
principalToInherit.forget(aPrincipal); principalToInherit.forget(aPrincipal);
return NS_OK; return NS_OK;
} }
auto securityMode = loadInfo->GetSecurityMode();
// The data: inheritance flags should only apply to the initial load,
// not to loads that it might have redirected to.
if (loadInfo->RedirectChain().IsEmpty() &&
(securityMode == nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_DATA_INHERITS ||
securityMode == nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS ||
securityMode == nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS)) {
nsCOMPtr<nsIURI> uri;
nsresult rv = NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIPrincipal> principalToInherit =
loadInfo->FindPrincipalToInherit(aChannel);
bool inheritForAboutBlank = loadInfo->GetAboutBlankInherits();
if (nsContentUtils::ChannelShouldInheritPrincipal(
principalToInherit, uri, inheritForAboutBlank, false)) {
principalToInherit.forget(aPrincipal);
return NS_OK;
}
}
} }
nsresult rv = GetChannelURIPrincipal(aChannel, aPrincipal); nsresult rv = GetChannelURIPrincipal(aChannel, aPrincipal);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
@ -395,20 +393,14 @@ nsScriptSecurityManager::GetChannelURIPrincipal(nsIChannel* aChannel,
nsresult rv = NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri)); nsresult rv = NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri));
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo; nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
aChannel->GetLoadInfo(getter_AddRefs(loadInfo));
// Inherit the origin attributes from loadInfo. // Inherit the origin attributes from loadInfo.
// If this is a top-level document load, the origin attributes of the // If this is a top-level document load, the origin attributes of the
// loadInfo will be set from nsDocShell::DoURILoad. // loadInfo will be set from nsDocShell::DoURILoad.
// For subresource loading, the origin attributes of the loadInfo is from // For subresource loading, the origin attributes of the loadInfo is from
// its loadingPrincipal. // its loadingPrincipal.
OriginAttributes attrs; OriginAttributes attrs = loadInfo->GetOriginAttributes();
// For addons loadInfo might be null.
if (loadInfo) {
attrs = loadInfo->GetOriginAttributes();
}
nsCOMPtr<nsIPrincipal> prin = nsCOMPtr<nsIPrincipal> prin =
BasePrincipal::CreateCodebasePrincipal(uri, attrs); BasePrincipal::CreateCodebasePrincipal(uri, attrs);

53
docshell/base/nsDocShell.cpp
View file

@ -4576,10 +4576,8 @@ nsDocShell::Reload(uint32_t aReloadFlags) {
httpChan->GetOriginalURI(getter_AddRefs(originalURI)); httpChan->GetOriginalURI(getter_AddRefs(originalURI));
} }
nsCOMPtr<nsILoadInfo> loadInfo = chan->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
if (loadInfo) { loadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI));
loadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI));
}
} }
MOZ_ASSERT(triggeringPrincipal, "Need a valid triggeringPrincipal"); MOZ_ASSERT(triggeringPrincipal, "Need a valid triggeringPrincipal");
@ -6850,7 +6848,7 @@ nsresult nsDocShell::EndPageLoad(nsIWebProgress* aProgress,
// can increment counts from the search engine // can increment counts from the search engine
MaybeNotifyKeywordSearchLoading(keywordProviderName, keywordAsSent); MaybeNotifyKeywordSearchLoading(keywordProviderName, keywordAsSent);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
MOZ_ASSERT(loadInfo, "loadInfo is required on all channels"); MOZ_ASSERT(loadInfo, "loadInfo is required on all channels");
nsCOMPtr<nsIPrincipal> triggeringPrincipal = nsCOMPtr<nsIPrincipal> triggeringPrincipal =
loadInfo->TriggeringPrincipal(); loadInfo->TriggeringPrincipal();
@ -6902,10 +6900,8 @@ nsresult nsDocShell::EndPageLoad(nsIWebProgress* aProgress,
} }
} else if (url && NS_SUCCEEDED(aStatus)) { } else if (url && NS_SUCCEEDED(aStatus)) {
// If we have a host // If we have a host
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo) { PredictorLearnRedirect(url, aChannel, loadInfo->GetOriginAttributes());
PredictorLearnRedirect(url, aChannel, loadInfo->GetOriginAttributes());
}
} }
return NS_OK; return NS_OK;
@ -9829,8 +9825,7 @@ nsresult nsDocShell::DoURILoad(nsDocShellLoadState* aLoadState,
GetIsMozBrowser()); GetIsMozBrowser());
if (isTopLevelDoc && GetDocument() && GetDocument()->GetChannel()) { if (isTopLevelDoc && GetDocument() && GetDocument()->GetChannel()) {
nsCOMPtr<nsILoadInfo> oldLoadInfo = nsCOMPtr<nsILoadInfo> oldLoadInfo = GetDocument()->GetChannel()->LoadInfo();
GetDocument()->GetChannel()->GetLoadInfo();
loadInfo->SetOpenerPolicy(oldLoadInfo->GetOpenerPolicy()); loadInfo->SetOpenerPolicy(oldLoadInfo->GetOpenerPolicy());
} }
@ -11293,29 +11288,27 @@ nsresult nsDocShell::AddToSessionHistory(nsIURI* aURI, nsIChannel* aChannel,
discardLayoutState = ShouldDiscardLayoutState(httpChannel); discardLayoutState = ShouldDiscardLayoutState(httpChannel);
} }
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo) { if (!triggeringPrincipal) {
if (!triggeringPrincipal) { triggeringPrincipal = loadInfo->TriggeringPrincipal();
triggeringPrincipal = loadInfo->TriggeringPrincipal(); }
}
loadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI)); loadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI));
// For now keep storing just the principal in the SHEntry. // For now keep storing just the principal in the SHEntry.
if (!principalToInherit) { if (!principalToInherit) {
if (loadInfo->GetLoadingSandboxed()) { if (loadInfo->GetLoadingSandboxed()) {
if (loadInfo->LoadingPrincipal()) { if (loadInfo->LoadingPrincipal()) {
principalToInherit = NullPrincipal::CreateWithInheritedAttributes( principalToInherit = NullPrincipal::CreateWithInheritedAttributes(
loadInfo->LoadingPrincipal()); loadInfo->LoadingPrincipal());
} else {
// get the OriginAttributes
OriginAttributes attrs;
loadInfo->GetOriginAttributes(&attrs);
principalToInherit = NullPrincipal::Create(attrs);
}
} else { } else {
principalToInherit = loadInfo->PrincipalToInherit(); // get the OriginAttributes
OriginAttributes attrs;
loadInfo->GetOriginAttributes(&attrs);
principalToInherit = NullPrincipal::Create(attrs);
} }
} else {
principalToInherit = loadInfo->PrincipalToInherit();
} }
} }
} }

5
docshell/base/nsDocShellLoadState.cpp
View file

@ -93,10 +93,7 @@ nsresult nsDocShellLoadState::CreateFromPendingChannel(
} }
loadState->SetOriginalURI(originalUri); loadState->SetOriginalURI(originalUri);
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
if (NS_WARN_IF(!loadInfo)) {
return NS_ERROR_FAILURE;
}
loadState->SetTriggeringPrincipal(loadInfo->TriggeringPrincipal()); loadState->SetTriggeringPrincipal(loadInfo->TriggeringPrincipal());
// Return the newly created loadState. // Return the newly created loadState.

25
dom/base/Document.cpp
View file

@ -2419,7 +2419,7 @@ static void WarnIfSandboxIneffective(nsIDocShell* aDocShell,
} }
bool Document::IsSynthesized() { bool Document::IsSynthesized() {
nsCOMPtr<nsILoadInfo> loadInfo = mChannel ? mChannel->GetLoadInfo() : nullptr; nsCOMPtr<nsILoadInfo> loadInfo = mChannel ? mChannel->LoadInfo() : nullptr;
return loadInfo && loadInfo->GetServiceWorkerTaintingSynthesized(); return loadInfo && loadInfo->GetServiceWorkerTaintingSynthesized();
} }
@ -2519,8 +2519,8 @@ nsresult Document::StartDocumentLoad(const char* aCommand, nsIChannel* aChannel,
nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(aContainer); nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(aContainer);
// If this is an error page, don't inherit sandbox flags from docshell // If this is an error page, don't inherit sandbox flags from docshell
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (docShell && !(loadInfo && loadInfo->GetLoadErrorPage())) { if (docShell && !loadInfo->GetLoadErrorPage()) {
nsresult rv = docShell->GetSandboxFlags(&mSandboxFlags); nsresult rv = docShell->GetSandboxFlags(&mSandboxFlags);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
WarnIfSandboxIneffective(docShell, mSandboxFlags, GetChannel()); WarnIfSandboxIneffective(docShell, mSandboxFlags, GetChannel());
@ -2667,8 +2667,8 @@ nsresult Document::InitCSP(nsIChannel* aChannel) {
// Check if this is a signed content to apply default CSP. // Check if this is a signed content to apply default CSP.
bool applySignedContentCSP = false; bool applySignedContentCSP = false;
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo && loadInfo->GetVerifySignedContent()) { if (loadInfo->GetVerifySignedContent()) {
applySignedContentCSP = true; applySignedContentCSP = true;
} }
@ -7423,13 +7423,10 @@ bool Document::CanSavePresentation(nsIRequest* aNewRequest) {
// Favicon loads don't need to block caching. // Favicon loads don't need to block caching.
nsCOMPtr<nsIChannel> channel = do_QueryInterface(request); nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
if (channel) { if (channel) {
nsCOMPtr<nsILoadInfo> li; nsCOMPtr<nsILoadInfo> li = channel->LoadInfo();
channel->GetLoadInfo(getter_AddRefs(li)); if (li->InternalContentPolicyType() ==
if (li) { nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON) {
if (li->InternalContentPolicyType() == continue;
nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON) {
continue;
}
} }
} }
#ifdef DEBUG_PAGE_CACHE #ifdef DEBUG_PAGE_CACHE
@ -11721,8 +11718,8 @@ void Document::SetUserHasInteracted() {
mUserHasInteracted = true; mUserHasInteracted = true;
nsCOMPtr<nsILoadInfo> loadInfo = mChannel ? mChannel->GetLoadInfo() : nullptr; if (mChannel) {
if (loadInfo) { nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
loadInfo->SetDocumentHasUserInteracted(true); loadInfo->SetDocumentHasUserInteracted(true);
} }

2
dom/base/ThirdPartyUtil.cpp
View file

@ -240,7 +240,7 @@ ThirdPartyUtil::IsThirdPartyChannel(nsIChannel* aChannel, nsIURI* aURI,
if (NS_FAILED(rv)) return rv; if (NS_FAILED(rv)) return rv;
if (!doForce) { if (!doForce) {
if (nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo()) { if (nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo()) {
parentIsThird = loadInfo->GetIsInThirdPartyContext(); parentIsThird = loadInfo->GetIsInThirdPartyContext();
if (!parentIsThird && loadInfo->GetExternalContentPolicyType() != if (!parentIsThird && loadInfo->GetExternalContentPolicyType() !=
nsIContentPolicy::TYPE_DOCUMENT) { nsIContentPolicy::TYPE_DOCUMENT) {

10
dom/base/nsContentUtils.cpp
View file

@ -8122,10 +8122,7 @@ bool nsContentUtils::IsNonSubresourceRequest(nsIChannel* aChannel) {
return true; return true;
} }
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (!loadInfo) {
return false;
}
nsContentPolicyType type = loadInfo->InternalContentPolicyType(); nsContentPolicyType type = loadInfo->InternalContentPolicyType();
return IsNonSubresourceInternalPolicyType(type); return IsNonSubresourceInternalPolicyType(type);
} }
@ -9810,10 +9807,7 @@ nsContentUtils::LookupCustomElementDefinition(Document* aDoc, nsAtom* aNameAtom,
rv = aChannel->GetReferrer(getter_AddRefs(referrer)); rv = aChannel->GetReferrer(getter_AddRefs(referrer));
NS_ENSURE_SUCCESS(rv, false); NS_ENSURE_SUCCESS(rv, false);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (!loadInfo) {
return false;
}
nsCOMPtr<nsIPrincipal> triggeringPrincipal = loadInfo->TriggeringPrincipal(); nsCOMPtr<nsIPrincipal> triggeringPrincipal = loadInfo->TriggeringPrincipal();
// Get the channel's load flags, and use them to generate nsIWebNavigation // Get the channel's load flags, and use them to generate nsIWebNavigation

2
dom/base/nsGlobalWindowInner.cpp
View file

@ -1718,7 +1718,7 @@ nsresult nsGlobalWindowInner::EnsureClientSource() {
} }
if (!ignoreLoadInfo) { if (!ignoreLoadInfo) {
loadInfo = channel->GetLoadInfo(); loadInfo = channel->LoadInfo();
} }
} }

5
dom/base/nsGlobalWindowOuter.cpp
View file

@ -5516,11 +5516,10 @@ void nsGlobalWindowOuter::NotifyContentBlockingEvent(unsigned aEvent,
// static // static
bool nsGlobalWindowOuter::SameLoadingURI(Document* aDoc, nsIChannel* aChannel) { bool nsGlobalWindowOuter::SameLoadingURI(Document* aDoc, nsIChannel* aChannel) {
nsCOMPtr<nsIURI> docURI = aDoc->GetDocumentURI(); nsCOMPtr<nsIURI> docURI = aDoc->GetDocumentURI();
nsCOMPtr<nsILoadInfo> channelLoadInfo = aChannel->GetLoadInfo(); if (!docURI) {
if (!channelLoadInfo || !docURI) {
return false; return false;
} }
nsCOMPtr<nsILoadInfo> channelLoadInfo = aChannel->LoadInfo();
nsCOMPtr<nsIPrincipal> channelLoadingPrincipal = nsCOMPtr<nsIPrincipal> channelLoadingPrincipal =
channelLoadInfo->LoadingPrincipal(); channelLoadInfo->LoadingPrincipal();
if (!channelLoadingPrincipal) { if (!channelLoadingPrincipal) {

2
dom/base/nsNodeInfoManager.cpp
View file

@ -331,7 +331,7 @@ bool nsNodeInfoManager::InternalSVGEnabled() {
nsCOMPtr<nsIChannel> channel = mDocument->GetChannel(); nsCOMPtr<nsIChannel> channel = mDocument->GetChannel();
// We don't have a channel for SVGs constructed inside a SVG script // We don't have a channel for SVGs constructed inside a SVG script
if (channel) { if (channel) {
loadInfo = channel->GetLoadInfo(); loadInfo = channel->LoadInfo();
} }
} }
bool conclusion = bool conclusion =

3
dom/base/nsObjectLoadingContent.cpp
View file

@ -2412,8 +2412,7 @@ nsresult nsObjectLoadingContent::OpenChannel() {
nsIRequest::LOAD_HTML_OBJECT_DATA); nsIRequest::LOAD_HTML_OBJECT_DATA);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
if (inherit) { if (inherit) {
nsCOMPtr<nsILoadInfo> loadinfo = chan->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadinfo = chan->LoadInfo();
NS_ENSURE_STATE(loadinfo);
loadinfo->SetPrincipalToInherit(thisContent->NodePrincipal()); loadinfo->SetPrincipalToInherit(thisContent->NodePrincipal());
} }

14
dom/base/nsSyncLoadService.cpp
View file

@ -135,14 +135,12 @@ nsresult nsSyncLoader::LoadDocument(nsIChannel *aChannel, bool aChannelIsSync,
"text/xml,application/xml,application/xhtml+xml,*/*;q=0.1"), "text/xml,application/xml,application/xhtml+xml,*/*;q=0.1"),
false); false);
MOZ_ASSERT(NS_SUCCEEDED(rv)); MOZ_ASSERT(NS_SUCCEEDED(rv));
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo) { nsCOMPtr<nsIURI> loaderUri;
nsCOMPtr<nsIURI> loaderUri; loadInfo->TriggeringPrincipal()->GetURI(getter_AddRefs(loaderUri));
loadInfo->TriggeringPrincipal()->GetURI(getter_AddRefs(loaderUri)); if (loaderUri) {
if (loaderUri) { rv = http->SetReferrerWithPolicy(loaderUri, aReferrerPolicy);
rv = http->SetReferrerWithPolicy(loaderUri, aReferrerPolicy); MOZ_ASSERT(NS_SUCCEEDED(rv));
MOZ_ASSERT(NS_SUCCEEDED(rv));
}
} }
} }

16
dom/clients/manager/ClientChannelHelper.cpp
View file

@ -55,19 +55,14 @@ class ClientChannelHelper final : public nsIInterfaceRequestor,
nsIAsyncVerifyRedirectCallback* aCallback) override { nsIAsyncVerifyRedirectCallback* aCallback) override {
MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(NS_IsMainThread());
nsCOMPtr<nsILoadInfo> oldLoadInfo; nsresult rv = nsContentUtils::CheckSameOrigin(aOldChannel, aNewChannel);
nsresult rv = aOldChannel->GetLoadInfo(getter_AddRefs(oldLoadInfo));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> newLoadInfo;
rv = aNewChannel->GetLoadInfo(getter_AddRefs(newLoadInfo));
NS_ENSURE_SUCCESS(rv, rv);
rv = nsContentUtils::CheckSameOrigin(aOldChannel, aNewChannel);
if (NS_WARN_IF(NS_FAILED(rv) && rv != NS_ERROR_DOM_BAD_URI)) { if (NS_WARN_IF(NS_FAILED(rv) && rv != NS_ERROR_DOM_BAD_URI)) {
return rv; return rv;
} }
nsCOMPtr<nsILoadInfo> oldLoadInfo = aOldChannel->LoadInfo();
nsCOMPtr<nsILoadInfo> newLoadInfo = aNewChannel->LoadInfo();
UniquePtr<ClientSource> reservedClient = UniquePtr<ClientSource> reservedClient =
oldLoadInfo->TakeReservedClientSource(); oldLoadInfo->TakeReservedClientSource();
@ -181,8 +176,7 @@ nsresult AddClientChannelHelper(nsIChannel* aChannel,
MOZ_DIAGNOSTIC_ASSERT(reservedClientInfo.isNothing() || MOZ_DIAGNOSTIC_ASSERT(reservedClientInfo.isNothing() ||
initialClientInfo.isNothing()); initialClientInfo.isNothing());
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
NS_ENSURE_TRUE(loadInfo, NS_ERROR_FAILURE);
nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager(); nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
NS_ENSURE_TRUE(ssm, NS_ERROR_FAILURE); NS_ENSURE_TRUE(ssm, NS_ERROR_FAILURE);

22
dom/fetch/FetchDriver.cpp
View file

@ -531,11 +531,7 @@ nsresult FetchDriver::HttpFetch(
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
if (mCSPEventListener) { if (mCSPEventListener) {
nsCOMPtr<nsILoadInfo> loadInfo = chan->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
if (NS_WARN_IF(!loadInfo)) {
return NS_ERROR_UNEXPECTED;
}
rv = loadInfo->SetCspEventListener(mCSPEventListener); rv = loadInfo->SetCspEventListener(mCSPEventListener);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
} }
@ -588,7 +584,7 @@ nsresult FetchDriver::HttpFetch(
// If request’s referrer policy is the empty string, // If request’s referrer policy is the empty string,
// then set request’s referrer policy to the user-set default policy. // then set request’s referrer policy to the user-set default policy.
if (mRequest->ReferrerPolicy_() == ReferrerPolicy::_empty) { if (mRequest->ReferrerPolicy_() == ReferrerPolicy::_empty) {
nsCOMPtr<nsILoadInfo> loadInfo = httpChan->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = httpChan->LoadInfo();
bool isPrivate = loadInfo->GetOriginAttributes().mPrivateBrowsingId > 0; bool isPrivate = loadInfo->GetOriginAttributes().mPrivateBrowsingId > 0;
net::ReferrerPolicy referrerPolicy = static_cast<net::ReferrerPolicy>( net::ReferrerPolicy referrerPolicy = static_cast<net::ReferrerPolicy>(
NS_GetDefaultReferrerPolicy(isPrivate)); NS_GetDefaultReferrerPolicy(isPrivate));
@ -673,10 +669,8 @@ nsresult FetchDriver::HttpFetch(
if (mRequest->Mode() == RequestMode::Cors) { if (mRequest->Mode() == RequestMode::Cors) {
AutoTArray<nsCString, 5> unsafeHeaders; AutoTArray<nsCString, 5> unsafeHeaders;
mRequest->Headers()->GetUnsafeHeaders(unsafeHeaders); mRequest->Headers()->GetUnsafeHeaders(unsafeHeaders);
nsCOMPtr<nsILoadInfo> loadInfo = chan->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
if (loadInfo) { loadInfo->SetCorsPreflightInfo(unsafeHeaders, false);
loadInfo->SetCorsPreflightInfo(unsafeHeaders, false);
}
} }
if (mIsTrackingFetch && nsContentUtils::IsTailingEnabled() && cos) { if (mIsTrackingFetch && nsContentUtils::IsTailingEnabled() && cos) {
@ -981,13 +975,7 @@ FetchDriver::OnStartRequest(nsIRequest* aRequest, nsISupports* aContext) {
return rv; return rv;
} }
nsCOMPtr<nsILoadInfo> loadInfo; nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
rv = channel->GetLoadInfo(getter_AddRefs(loadInfo));
if (NS_WARN_IF(NS_FAILED(rv))) {
FailWithNetworkError(rv);
return rv;
}
// Propagate any tainting from the channel back to our response here. This // Propagate any tainting from the channel back to our response here. This
// step is not reflected in the spec because the spec is written such that // step is not reflected in the spec because the spec is written such that
// FetchEvent.respondWith() just passes the already-tainted Response back to // FetchEvent.respondWith() just passes the already-tainted Response back to

10
dom/html/HTMLMediaElement.cpp
View file

@ -1293,12 +1293,10 @@ class HTMLMediaElement::ChannelLoader final {
} }
if (setAttrs) { if (setAttrs) {
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
if (loadInfo) { // The function simply returns NS_OK, so we ignore the return value.
// The function simply returns NS_OK, so we ignore the return value. Unused << loadInfo->SetOriginAttributes(
Unused << loadInfo->SetOriginAttributes( triggeringPrincipal->OriginAttributesRef());
triggeringPrincipal->OriginAttributesRef());
}
} }
nsCOMPtr<nsIClassOfService> cos(do_QueryInterface(channel)); nsCOMPtr<nsIClassOfService> cos(do_QueryInterface(channel));

6
dom/html/ImageDocument.cpp
View file

@ -87,7 +87,7 @@ ImageListener::OnStartRequest(nsIRequest* request, nsISupports* ctxt) {
nsAutoCString mimeType; nsAutoCString mimeType;
channel->GetContentType(mimeType); channel->GetContentType(mimeType);
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
// query the corresponding arguments for the channel loadinfo and pass // query the corresponding arguments for the channel loadinfo and pass
// it on to the temporary loadinfo used for content policy checks. // it on to the temporary loadinfo used for content policy checks.
nsCOMPtr<nsINode> requestingNode = domWindow->GetFrameElementInternal(); nsCOMPtr<nsINode> requestingNode = domWindow->GetFrameElementInternal();
@ -100,8 +100,8 @@ ImageListener::OnStartRequest(nsIRequest* request, nsISupports* ctxt) {
} }
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new net::LoadInfo( nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new net::LoadInfo(
loadingPrincipal, loadInfo ? loadInfo->TriggeringPrincipal() : nullptr, loadingPrincipal, loadInfo->TriggeringPrincipal(), requestingNode,
requestingNode, nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK, nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
nsIContentPolicy::TYPE_INTERNAL_IMAGE); nsIContentPolicy::TYPE_INTERNAL_IMAGE);
int16_t decision = nsIContentPolicy::ACCEPT; int16_t decision = nsIContentPolicy::ACCEPT;

3
dom/html/nsHTMLDocument.cpp
View file

@ -1923,8 +1923,7 @@ nsresult nsHTMLDocument::CreateAndAddWyciwygChannel(void) {
nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL, nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL,
nsIContentPolicy::TYPE_OTHER); nsIContentPolicy::TYPE_OTHER);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
NS_ENSURE_STATE(loadInfo);
loadInfo->SetPrincipalToInherit(NodePrincipal()); loadInfo->SetPrincipalToInherit(NodePrincipal());
mWyciwygChannel = do_QueryInterface(channel); mWyciwygChannel = do_QueryInterface(channel);

7
dom/jsurl/nsJSProtocolHandler.cpp
View file

@ -144,9 +144,8 @@ nsresult nsJSThunk::EvaluateScript(
aChannel->GetOwner(getter_AddRefs(owner)); aChannel->GetOwner(getter_AddRefs(owner));
nsCOMPtr<nsIPrincipal> principal = do_QueryInterface(owner); nsCOMPtr<nsIPrincipal> principal = do_QueryInterface(owner);
if (!principal) { if (!principal) {
nsCOMPtr<nsILoadInfo> loadInfo; nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
aChannel->GetLoadInfo(getter_AddRefs(loadInfo)); if (loadInfo->GetForceInheritPrincipal()) {
if (loadInfo && loadInfo->GetForceInheritPrincipal()) {
principal = loadInfo->FindPrincipalToInherit(aChannel); principal = loadInfo->FindPrincipalToInherit(aChannel);
} else { } else {
// No execution without a principal! // No execution without a principal!
@ -509,7 +508,7 @@ nsJSChannel::AsyncOpen(nsIStreamListener* aListener) {
#ifdef DEBUG #ifdef DEBUG
{ {
nsCOMPtr<nsILoadInfo> loadInfo = nsIChannel::GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = nsIChannel::LoadInfo();
MOZ_ASSERT(!loadInfo || loadInfo->GetSecurityMode() == 0 || MOZ_ASSERT(!loadInfo || loadInfo->GetSecurityMode() == 0 ||
loadInfo->GetInitialSecurityCheckDone(), loadInfo->GetInitialSecurityCheckDone(),
"security flags in loadInfo but asyncOpen() not called"); "security flags in loadInfo but asyncOpen() not called");

10
dom/media/ChannelMediaResource.cpp
View file

@ -765,12 +765,10 @@ nsresult ChannelMediaResource::RecreateChannel() {
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
if (setAttrs) { if (setAttrs) {
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
if (loadInfo) { // The function simply returns NS_OK, so we ignore the return value.
// The function simply returns NS_OK, so we ignore the return value. Unused << loadInfo->SetOriginAttributes(
Unused << loadInfo->SetOriginAttributes( triggeringPrincipal->OriginAttributesRef());
triggeringPrincipal->OriginAttributesRef());
}
} }
nsCOMPtr<nsIClassOfService> cos(do_QueryInterface(mChannel)); nsCOMPtr<nsIClassOfService> cos(do_QueryInterface(mChannel));

6
dom/performance/PerformanceTiming.cpp
View file

@ -267,11 +267,7 @@ bool PerformanceTimingData::CheckAllowedOrigin(nsIHttpChannel* aResourceChannel,
} }
// Check that the current document passes the ckeck. // Check that the current document passes the ckeck.
nsCOMPtr<nsILoadInfo> loadInfo; nsCOMPtr<nsILoadInfo> loadInfo = aResourceChannel->LoadInfo();
aResourceChannel->GetLoadInfo(getter_AddRefs(loadInfo));
if (!loadInfo) {
return false;
}
// TYPE_DOCUMENT loads have no loadingPrincipal. // TYPE_DOCUMENT loads have no loadingPrincipal.
if (loadInfo->GetExternalContentPolicyType() == if (loadInfo->GetExternalContentPolicyType() ==

2
dom/plugins/base/nsPluginStreamListenerPeer.cpp
View file

@ -167,7 +167,7 @@ nsPluginStreamListenerPeer::OnStartRequest(nsIRequest* request,
if (NS_FAILED(rv)) return rv; if (NS_FAILED(rv)) return rv;
// Check ShouldProcess with content policy // Check ShouldProcess with content policy
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
int16_t shouldLoad = nsIContentPolicy::ACCEPT; int16_t shouldLoad = nsIContentPolicy::ACCEPT;
rv = NS_CheckContentProcessPolicy(mURL, loadInfo, contentType, &shouldLoad); rv = NS_CheckContentProcessPolicy(mURL, loadInfo, contentType, &shouldLoad);

6
dom/script/ScriptLoader.cpp
View file

@ -1275,7 +1275,7 @@ nsresult ScriptLoader::StartLoad(ScriptLoadRequest* aRequest) {
if (element && element->IsHTMLElement()) { if (element && element->IsHTMLElement()) {
nsAutoString cspNonce; nsAutoString cspNonce;
element->GetAttribute(NS_LITERAL_STRING("nonce"), cspNonce); element->GetAttribute(NS_LITERAL_STRING("nonce"), cspNonce);
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
loadInfo->SetCspNonce(cspNonce); loadInfo->SetCspNonce(cspNonce);
} }
} }
@ -3208,9 +3208,9 @@ nsresult ScriptLoader::VerifySRI(ScriptLoadRequest* aRequest,
rv = NS_ERROR_SRI_CORRUPT; rv = NS_ERROR_SRI_CORRUPT;
} }
} else { } else {
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
if (loadInfo && loadInfo->GetEnforceSRI()) { if (loadInfo->GetEnforceSRI()) {
MOZ_LOG(SRILogHelper::GetSriLog(), mozilla::LogLevel::Debug, MOZ_LOG(SRILogHelper::GetSriLog(), mozilla::LogLevel::Debug,
("ScriptLoader::OnStreamComplete, required SRI not found")); ("ScriptLoader::OnStreamComplete, required SRI not found"));
nsCOMPtr<nsIContentSecurityPolicy> csp; nsCOMPtr<nsIContentSecurityPolicy> csp;

11
dom/security/FramingChecker.cpp
View file

@ -184,10 +184,9 @@ static bool ShouldIgnoreFrameOptions(nsIChannel* aChannel,
} }
// log warning to console that xfo is ignored because of CSP // log warning to console that xfo is ignored because of CSP
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
uint64_t innerWindowID = loadInfo ? loadInfo->GetInnerWindowID() : 0; uint64_t innerWindowID = loadInfo->GetInnerWindowID();
bool privateWindow = bool privateWindow = !!loadInfo->GetOriginAttributes().mPrivateBrowsingId;
loadInfo ? !!loadInfo->GetOriginAttributes().mPrivateBrowsingId : false;
const char16_t* params[] = {u"x-frame-options", u"frame-ancestors"}; const char16_t* params[] = {u"x-frame-options", u"frame-ancestors"};
CSP_LogLocalizedStr("IgnoringSrcBecauseOfDirective", params, CSP_LogLocalizedStr("IgnoringSrcBecauseOfDirective", params,
ArrayLength(params), ArrayLength(params),
@ -252,9 +251,7 @@ static bool ShouldIgnoreFrameOptions(nsIChannel* aChannel,
if (aDocShell) { if (aDocShell) {
nsCOMPtr<nsIWebNavigation> webNav(do_QueryObject(aDocShell)); nsCOMPtr<nsIWebNavigation> webNav(do_QueryObject(aDocShell));
if (webNav) { if (webNav) {
nsCOMPtr<nsILoadInfo> loadInfo = httpChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = httpChannel->LoadInfo();
MOZ_ASSERT(loadInfo);
RefPtr<NullPrincipal> principal = RefPtr<NullPrincipal> principal =
NullPrincipal::CreateWithInheritedAttributes( NullPrincipal::CreateWithInheritedAttributes(
loadInfo->TriggeringPrincipal()); loadInfo->TriggeringPrincipal());

3
dom/security/SRICheck.cpp
View file

@ -327,8 +327,7 @@ nsresult SRICheckDataVerifier::Verify(const SRIMetadata& aMetadata,
nsresult rv = Finish(); nsresult rv = Finish();
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
NS_ENSURE_TRUE(loadInfo, NS_ERROR_FAILURE);
LoadTainting tainting = loadInfo->GetTainting(); LoadTainting tainting = loadInfo->GetTainting();
if (NS_FAILED(IsEligible(aChannel, tainting, aSourceFileURI, aReporter))) { if (NS_FAILED(IsEligible(aChannel, tainting, aSourceFileURI, aReporter))) {

8
dom/security/nsCSPService.cpp
View file

@ -260,13 +260,7 @@ CSPService::AsyncOnChannelRedirect(nsIChannel *oldChannel,
nsresult rv = newChannel->GetURI(getter_AddRefs(newUri)); nsresult rv = newChannel->GetURI(getter_AddRefs(newUri));
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = oldChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = oldChannel->LoadInfo();
// if no loadInfo on the channel, nothing for us to do
if (!loadInfo) {
return NS_OK;
}
nsCOMPtr<nsICSPEventListener> cspEventListener; nsCOMPtr<nsICSPEventListener> cspEventListener;
rv = loadInfo->GetCspEventListener(getter_AddRefs(cspEventListener)); rv = loadInfo->GetCspEventListener(getter_AddRefs(cspEventListener));
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);

49
dom/security/nsContentSecurityManager.cpp
View file

@ -45,10 +45,7 @@ static mozilla::LazyLogModule sCSMLog("CSMLog");
if (!mozilla::net::nsIOService::BlockToplevelDataUriNavigations()) { if (!mozilla::net::nsIOService::BlockToplevelDataUriNavigations()) {
return true; return true;
} }
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (!loadInfo) {
return true;
}
if (loadInfo->GetExternalContentPolicyType() != if (loadInfo->GetExternalContentPolicyType() !=
nsIContentPolicy::TYPE_DOCUMENT) { nsIContentPolicy::TYPE_DOCUMENT) {
return true; return true;
@ -115,10 +112,7 @@ static mozilla::LazyLogModule sCSMLog("CSMLog");
/* static */ bool nsContentSecurityManager::AllowInsecureRedirectToDataURI( /* static */ bool nsContentSecurityManager::AllowInsecureRedirectToDataURI(
nsIChannel* aNewChannel) { nsIChannel* aNewChannel) {
nsCOMPtr<nsILoadInfo> loadInfo = aNewChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aNewChannel->LoadInfo();
if (!loadInfo) {
return true;
}
if (loadInfo->GetExternalContentPolicyType() != if (loadInfo->GetExternalContentPolicyType() !=
nsIContentPolicy::TYPE_SCRIPT) { nsIContentPolicy::TYPE_SCRIPT) {
return true; return true;
@ -170,11 +164,7 @@ static mozilla::LazyLogModule sCSMLog("CSMLog");
return NS_OK; return NS_OK;
} }
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (!loadInfo) {
return NS_OK;
}
nsContentPolicyType type = loadInfo->GetExternalContentPolicyType(); nsContentPolicyType type = loadInfo->GetExternalContentPolicyType();
// Allow top-level FTP documents and save-as download of FTP files on // Allow top-level FTP documents and save-as download of FTP files on
@ -793,14 +783,7 @@ static void DebugDoContentSecurityCheck(nsIChannel* aChannel,
nsresult nsContentSecurityManager::doContentSecurityCheck( nsresult nsContentSecurityManager::doContentSecurityCheck(
nsIChannel* aChannel, nsCOMPtr<nsIStreamListener>& aInAndOutListener) { nsIChannel* aChannel, nsCOMPtr<nsIStreamListener>& aInAndOutListener) {
NS_ENSURE_ARG(aChannel); NS_ENSURE_ARG(aChannel);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (!loadInfo) {
MOZ_ASSERT(false,
"channel needs to have loadInfo to perform security checks");
return NS_ERROR_UNEXPECTED;
}
if (MOZ_UNLIKELY(MOZ_LOG_TEST(sCSMLog, LogLevel::Debug))) { if (MOZ_UNLIKELY(MOZ_LOG_TEST(sCSMLog, LogLevel::Debug))) {
DebugDoContentSecurityCheck(aChannel, loadInfo); DebugDoContentSecurityCheck(aChannel, loadInfo);
} }
@ -844,16 +827,14 @@ NS_IMETHODIMP
nsContentSecurityManager::AsyncOnChannelRedirect( nsContentSecurityManager::AsyncOnChannelRedirect(
nsIChannel* aOldChannel, nsIChannel* aNewChannel, uint32_t aRedirFlags, nsIChannel* aOldChannel, nsIChannel* aNewChannel, uint32_t aRedirFlags,
nsIAsyncVerifyRedirectCallback* aCb) { nsIAsyncVerifyRedirectCallback* aCb) {
nsCOMPtr<nsILoadInfo> loadInfo = aOldChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aOldChannel->LoadInfo();
if (loadInfo) { nsresult rv = CheckChannel(aNewChannel);
nsresult rv = CheckChannel(aNewChannel); if (NS_SUCCEEDED(rv)) {
if (NS_SUCCEEDED(rv)) { rv = CheckFTPSubresourceLoad(aNewChannel);
rv = CheckFTPSubresourceLoad(aNewChannel); }
} if (NS_FAILED(rv)) {
if (NS_FAILED(rv)) { aOldChannel->Cancel(rv);
aOldChannel->Cancel(rv); return rv;
return rv;
}
} }
// Also verify that the redirecting server is allowed to redirect to the // Also verify that the redirecting server is allowed to redirect to the
@ -876,7 +857,7 @@ nsContentSecurityManager::AsyncOnChannelRedirect(
const uint32_t flags = const uint32_t flags =
nsIScriptSecurityManager::LOAD_IS_AUTOMATIC_DOCUMENT_REPLACEMENT | nsIScriptSecurityManager::LOAD_IS_AUTOMATIC_DOCUMENT_REPLACEMENT |
nsIScriptSecurityManager::DISALLOW_SCRIPT; nsIScriptSecurityManager::DISALLOW_SCRIPT;
nsresult rv = nsContentUtils::GetSecurityManager()->CheckLoadURIWithPrincipal( rv = nsContentUtils::GetSecurityManager()->CheckLoadURIWithPrincipal(
oldPrincipal, newURI, flags); oldPrincipal, newURI, flags);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
@ -896,9 +877,7 @@ static void AddLoadFlags(nsIRequest* aRequest, nsLoadFlags aNewFlags) {
* if this requesst should not be permitted. * if this requesst should not be permitted.
*/ */
nsresult nsContentSecurityManager::CheckChannel(nsIChannel* aChannel) { nsresult nsContentSecurityManager::CheckChannel(nsIChannel* aChannel) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
MOZ_ASSERT(loadInfo);
nsCOMPtr<nsIURI> uri; nsCOMPtr<nsIURI> uri;
nsresult rv = NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri)); nsresult rv = NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri));
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);

2
dom/security/nsMixedContentBlocker.cpp
View file

@ -301,7 +301,7 @@ nsMixedContentBlocker::AsyncOnChannelRedirect(
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
// Get the loading Info from the old channel // Get the loading Info from the old channel
nsCOMPtr<nsILoadInfo> loadInfo = aOldChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aOldChannel->LoadInfo();
nsCOMPtr<nsIPrincipal> requestingPrincipal = loadInfo->LoadingPrincipal(); nsCOMPtr<nsIPrincipal> requestingPrincipal = loadInfo->LoadingPrincipal();
// Since we are calling shouldLoad() directly on redirects, we don't go // Since we are calling shouldLoad() directly on redirects, we don't go

4
dom/serviceworkers/ServiceWorkerEvents.cpp
View file

@ -272,9 +272,9 @@ class StartResponse final : public Runnable {
nsresult rv = mChannel->GetChannel(getter_AddRefs(underlyingChannel)); nsresult rv = mChannel->GetChannel(getter_AddRefs(underlyingChannel));
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_TRUE(underlyingChannel, NS_ERROR_UNEXPECTED); NS_ENSURE_TRUE(underlyingChannel, NS_ERROR_UNEXPECTED);
nsCOMPtr<nsILoadInfo> loadInfo = underlyingChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = underlyingChannel->LoadInfo();
if (!loadInfo || !CSPPermitsResponse(loadInfo)) { if (!CSPPermitsResponse(loadInfo)) {
mChannel->CancelInterception(NS_ERROR_CONTENT_BLOCKED); mChannel->CancelInterception(NS_ERROR_CONTENT_BLOCKED);
return NS_OK; return NS_OK;
} }

5
dom/serviceworkers/ServiceWorkerInterceptController.cpp
View file

@ -22,10 +22,7 @@ ServiceWorkerInterceptController::ShouldPrepareForIntercept(
nsIURI* aURI, nsIChannel* aChannel, bool* aShouldIntercept) { nsIURI* aURI, nsIChannel* aChannel, bool* aShouldIntercept) {
*aShouldIntercept = false; *aShouldIntercept = false;
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (!loadInfo) {
return NS_OK;
}
// For subresource requests we base our decision solely on the client's // For subresource requests we base our decision solely on the client's
// controller value. Any settings that would have blocked service worker // controller value. Any settings that would have blocked service worker

59
dom/serviceworkers/ServiceWorkerManager.cpp
View file

@ -1873,38 +1873,36 @@ class ContinueDispatchFetchEventRunnable : public Runnable {
nsString clientId; nsString clientId;
nsString resultingClientId; nsString resultingClientId;
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
if (loadInfo) { char buf[NSID_LENGTH];
char buf[NSID_LENGTH]; Maybe<ClientInfo> clientInfo = loadInfo->GetClientInfo();
Maybe<ClientInfo> clientInfo = loadInfo->GetClientInfo(); if (clientInfo.isSome()) {
if (clientInfo.isSome()) { clientInfo.ref().Id().ToProvidedString(buf);
clientInfo.ref().Id().ToProvidedString(buf); NS_ConvertASCIItoUTF16 uuid(buf);
NS_ConvertASCIItoUTF16 uuid(buf);
// Remove {} and the null terminator // Remove {} and the null terminator
clientId.Assign(Substring(uuid, 1, NSID_LENGTH - 3)); clientId.Assign(Substring(uuid, 1, NSID_LENGTH - 3));
} }
// Having an initial or reserved client are mutually exclusive events: // Having an initial or reserved client are mutually exclusive events:
// either an initial client is used upon navigating an about:blank // either an initial client is used upon navigating an about:blank
// iframe, or a new, reserved environment/client is created (e.g. // iframe, or a new, reserved environment/client is created (e.g.
// upon a top-level navigation). See step 4 of // upon a top-level navigation). See step 4 of
// https://html.spec.whatwg.org/#process-a-navigate-fetch as well as // https://html.spec.whatwg.org/#process-a-navigate-fetch as well as
// https://github.com/w3c/ServiceWorker/issues/1228#issuecomment-345132444 // https://github.com/w3c/ServiceWorker/issues/1228#issuecomment-345132444
Maybe<ClientInfo> resulting = loadInfo->GetInitialClientInfo(); Maybe<ClientInfo> resulting = loadInfo->GetInitialClientInfo();
if (resulting.isNothing()) { if (resulting.isNothing()) {
resulting = loadInfo->GetReservedClientInfo(); resulting = loadInfo->GetReservedClientInfo();
} else { } else {
MOZ_ASSERT(loadInfo->GetReservedClientInfo().isNothing()); MOZ_ASSERT(loadInfo->GetReservedClientInfo().isNothing());
} }
if (resulting.isSome()) { if (resulting.isSome()) {
resulting.ref().Id().ToProvidedString(buf); resulting.ref().Id().ToProvidedString(buf);
NS_ConvertASCIItoUTF16 uuid(buf); NS_ConvertASCIItoUTF16 uuid(buf);
resultingClientId.Assign(Substring(uuid, 1, NSID_LENGTH - 3)); resultingClientId.Assign(Substring(uuid, 1, NSID_LENGTH - 3));
}
} }
rv = mServiceWorkerPrivate->SendFetchEvent(mChannel, mLoadGroup, clientId, rv = mServiceWorkerPrivate->SendFetchEvent(mChannel, mLoadGroup, clientId,
@ -1936,12 +1934,7 @@ void ServiceWorkerManager::DispatchFetchEvent(nsIInterceptedChannel* aChannel,
return; return;
} }
nsCOMPtr<nsILoadInfo> loadInfo = internalChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = internalChannel->LoadInfo();
if (NS_WARN_IF(!loadInfo)) {
aRv.Throw(NS_ERROR_UNEXPECTED);
return;
}
RefPtr<ServiceWorkerInfo> serviceWorker; RefPtr<ServiceWorkerInfo> serviceWorker;
if (!nsContentUtils::IsNonSubresourceRequest(internalChannel)) { if (!nsContentUtils::IsNonSubresourceRequest(internalChannel)) {

10
dom/workers/ScriptLoader.cpp
View file

@ -247,11 +247,7 @@ nsresult ChannelFromScriptURL(nsIPrincipal* principal, Document* parentDoc,
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SECURITY_ERR); NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_SECURITY_ERR);
if (cspEventListener) { if (cspEventListener) {
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
if (NS_WARN_IF(!loadInfo)) {
return NS_ERROR_UNEXPECTED;
}
rv = loadInfo->SetCspEventListener(cspEventListener); rv = loadInfo->SetCspEventListener(cspEventListener);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
} }
@ -1156,8 +1152,8 @@ class ScriptLoaderRunnable final : public nsIRunnable, public nsINamed {
aLoadInfo.mURL.Assign(NS_ConvertUTF8toUTF16(filename)); aLoadInfo.mURL.Assign(NS_ConvertUTF8toUTF16(filename));
} }
nsCOMPtr<nsILoadInfo> chanLoadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> chanLoadInfo = channel->LoadInfo();
if (chanLoadInfo && chanLoadInfo->GetEnforceSRI()) { if (chanLoadInfo->GetEnforceSRI()) {
// importScripts() and the Worker constructor do not support integrity // importScripts() and the Worker constructor do not support integrity
// metadata // metadata
// (or any fetch options). Until then, we can just block. // (or any fetch options). Until then, we can just block.

42
dom/xhr/XMLHttpRequestMainThread.cpp
View file

@ -747,13 +747,7 @@ bool XMLHttpRequestMainThread::IsCrossSiteCORSRequest() const {
return false; return false;
} }
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
MOZ_ASSERT(loadInfo);
if (!loadInfo) {
return false;
}
return loadInfo->GetTainting() == LoadTainting::CORS; return loadInfo->GetTainting() == LoadTainting::CORS;
} }
@ -1478,11 +1472,8 @@ void XMLHttpRequestMainThread::SetOriginAttributes(
OriginAttributes attrs(aAttrs); OriginAttributes attrs(aAttrs);
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
MOZ_ASSERT(loadInfo); loadInfo->SetOriginAttributes(attrs);
if (loadInfo) {
loadInfo->SetOriginAttributes(attrs);
}
} }
/* /*
@ -1989,12 +1980,9 @@ XMLHttpRequestMainThread::OnStartRequest(nsIRequest* request,
mResponseXML->ForceEnableXULXBL(); mResponseXML->ForceEnableXULXBL();
} }
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
MOZ_ASSERT(loadInfo);
bool isCrossSite = false; bool isCrossSite = false;
if (loadInfo) { isCrossSite = loadInfo->GetTainting() != LoadTainting::Basic;
isCrossSite = loadInfo->GetTainting() != LoadTainting::Basic;
}
if (isCrossSite) { if (isCrossSite) {
nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(mResponseXML); nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(mResponseXML);
@ -2365,11 +2353,7 @@ nsresult XMLHttpRequestMainThread::CreateChannel() {
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
if (mCSPEventListener) { if (mCSPEventListener) {
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
if (NS_WARN_IF(!loadInfo)) {
return NS_ERROR_UNEXPECTED;
}
rv = loadInfo->SetCspEventListener(mCSPEventListener); rv = loadInfo->SetCspEventListener(mCSPEventListener);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
} }
@ -2525,10 +2509,8 @@ nsresult XMLHttpRequestMainThread::InitiateFetch(
// .withCredentials can be called after open() is called. // .withCredentials can be called after open() is called.
// Not doing this for privileged system XHRs since those don't use CORS. // Not doing this for privileged system XHRs since those don't use CORS.
if (!IsSystemXHR() && !mIsAnon && mFlagACwithCredentials) { if (!IsSystemXHR() && !mIsAnon && mFlagACwithCredentials) {
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
if (loadInfo) { static_cast<net::LoadInfo*>(loadInfo.get())->SetIncludeCookiesSecFlag();
static_cast<net::LoadInfo*>(loadInfo.get())->SetIncludeCookiesSecFlag();
}
} }
// We never let XHR be blocked by head CSS/JS loads to avoid potential // We never let XHR be blocked by head CSS/JS loads to avoid potential
@ -2591,11 +2573,9 @@ nsresult XMLHttpRequestMainThread::InitiateFetch(
if (!IsSystemXHR()) { if (!IsSystemXHR()) {
nsTArray<nsCString> CORSUnsafeHeaders; nsTArray<nsCString> CORSUnsafeHeaders;
mAuthorRequestHeaders.GetCORSUnsafeHeaders(CORSUnsafeHeaders); mAuthorRequestHeaders.GetCORSUnsafeHeaders(CORSUnsafeHeaders);
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
if (loadInfo) { loadInfo->SetCorsPreflightInfo(CORSUnsafeHeaders,
loadInfo->SetCorsPreflightInfo(CORSUnsafeHeaders, mFlagHadUploadListenersOnSend);
mFlagHadUploadListenersOnSend);
}
} }
// Hook us up to listen to redirects and the like. Only do this very late // Hook us up to listen to redirects and the like. Only do this very late

27
image/imgLoader.cpp
View file

@ -825,11 +825,9 @@ static nsresult NewImageChannel(
// triggeringPrincipal as the channel's originAttributes. This allows the // triggeringPrincipal as the channel's originAttributes. This allows the
// favicon loading from XUL will use the correct originAttributes. // favicon loading from XUL will use the correct originAttributes.
nsCOMPtr<nsILoadInfo> loadInfo = (*aResult)->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = (*aResult)->LoadInfo();
if (loadInfo) { rv = loadInfo->SetOriginAttributes(
rv = loadInfo->SetOriginAttributes( aTriggeringPrincipal->OriginAttributesRef());
aTriggeringPrincipal->OriginAttributesRef());
}
} }
} else { } else {
// either we are loading something inside a document, in which case // either we are loading something inside a document, in which case
@ -858,10 +856,8 @@ static nsresult NewImageChannel(
} }
attrs.mPrivateBrowsingId = aRespectPrivacy ? 1 : 0; attrs.mPrivateBrowsingId = aRespectPrivacy ? 1 : 0;
nsCOMPtr<nsILoadInfo> loadInfo = (*aResult)->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = (*aResult)->LoadInfo();
if (loadInfo) { rv = loadInfo->SetOriginAttributes(attrs);
rv = loadInfo->SetOriginAttributes(attrs);
}
} }
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
@ -2374,12 +2370,9 @@ nsresult imgLoader::LoadImageWithChannel(nsIChannel* channel,
nsCOMPtr<Document> doc = do_QueryInterface(aCX); nsCOMPtr<Document> doc = do_QueryInterface(aCX);
NS_ENSURE_TRUE(channel, NS_ERROR_FAILURE); NS_ENSURE_TRUE(channel, NS_ERROR_FAILURE);
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
OriginAttributes attrs; OriginAttributes attrs = loadInfo->GetOriginAttributes();
if (loadInfo) {
attrs = loadInfo->GetOriginAttributes();
}
nsresult rv; nsresult rv;
ImageCacheKey key(uri, attrs, doc, rv); ImageCacheKey key(uri, attrs, doc, rv);
@ -2420,12 +2413,10 @@ nsresult imgLoader::LoadImageWithChannel(nsIChannel* channel,
// Since aCanMakeNewChannel == false, we don't need to pass content policy // Since aCanMakeNewChannel == false, we don't need to pass content policy
// type/principal/etc // type/principal/etc
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
// if there is a loadInfo, use the right contentType, otherwise // if there is a loadInfo, use the right contentType, otherwise
// default to the internal image type // default to the internal image type
nsContentPolicyType policyType = nsContentPolicyType policyType = loadInfo->InternalContentPolicyType();
loadInfo ? loadInfo->InternalContentPolicyType()
: nsIContentPolicy::TYPE_INTERNAL_IMAGE;
if (ValidateEntry(entry, uri, nullptr, nullptr, RP_Unset, nullptr, if (ValidateEntry(entry, uri, nullptr, nullptr, RP_Unset, nullptr,
aObserver, aCX, doc, requestFlags, policyType, false, aObserver, aCX, doc, requestFlags, policyType, false,

2
image/imgRequest.cpp
View file

@ -1200,7 +1200,7 @@ imgRequest::OnRedirectVerifyCallback(nsresult result) {
// to upgrade all requests from http to https before any data is fetched // to upgrade all requests from http to https before any data is fetched
// from the network. Do not pollute mHadInsecureRedirect in case of such an // from the network. Do not pollute mHadInsecureRedirect in case of such an
// internal redirect. // internal redirect.
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
bool upgradeInsecureRequests = bool upgradeInsecureRequests =
loadInfo ? loadInfo->GetUpgradeInsecureRequests() || loadInfo ? loadInfo->GetUpgradeInsecureRequests() ||
loadInfo->GetBrowserUpgradeInsecureRequests() loadInfo->GetBrowserUpgradeInsecureRequests()

8
layout/style/Loader.cpp
View file

@ -743,8 +743,8 @@ nsresult SheetLoadData::VerifySheetReadyToParse(nsresult aStatus,
SRIMetadata sriMetadata; SRIMetadata sriMetadata;
mSheet->GetIntegrity(sriMetadata); mSheet->GetIntegrity(sriMetadata);
if (sriMetadata.IsEmpty()) { if (sriMetadata.IsEmpty()) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo && loadInfo->GetEnforceSRI()) { if (loadInfo->GetEnforceSRI()) {
LOG((" Load was blocked by SRI")); LOG((" Load was blocked by SRI"));
MOZ_LOG(gSriPRLog, mozilla::LogLevel::Debug, MOZ_LOG(gSriPRLog, mozilla::LogLevel::Debug,
("css::Loader::OnStreamComplete, required SRI not found")); ("css::Loader::OnStreamComplete, required SRI not found"));
@ -1326,7 +1326,7 @@ nsresult Loader::LoadSheet(SheetLoadData* aLoadData,
if (element && element->IsHTMLElement()) { if (element && element->IsHTMLElement()) {
nsAutoString cspNonce; nsAutoString cspNonce;
element->GetAttribute(NS_LITERAL_STRING("nonce"), cspNonce); element->GetAttribute(NS_LITERAL_STRING("nonce"), cspNonce);
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
loadInfo->SetCspNonce(cspNonce); loadInfo->SetCspNonce(cspNonce);
} }
} }
@ -1465,7 +1465,7 @@ nsresult Loader::LoadSheet(SheetLoadData* aLoadData,
if (element && element->IsHTMLElement()) { if (element && element->IsHTMLElement()) {
nsAutoString cspNonce; nsAutoString cspNonce;
element->GetAttribute(NS_LITERAL_STRING("nonce"), cspNonce); element->GetAttribute(NS_LITERAL_STRING("nonce"), cspNonce);
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
loadInfo->SetCspNonce(cspNonce); loadInfo->SetCspNonce(cspNonce);
} }
} }

6
netwerk/base/LoadInfo.cpp
View file

@ -269,10 +269,8 @@ LoadInfo::LoadInfo(
// if owner doc has content signature, we enforce SRI // if owner doc has content signature, we enforce SRI
nsCOMPtr<nsIChannel> channel = aLoadingContext->OwnerDoc()->GetChannel(); nsCOMPtr<nsIChannel> channel = aLoadingContext->OwnerDoc()->GetChannel();
if (channel) { if (channel) {
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
if (loadInfo) { mEnforceSRI = loadInfo->GetVerifySignedContent();
mEnforceSRI = loadInfo->GetVerifySignedContent();
}
} }
} }

6
netwerk/base/Predictor.cpp
View file

@ -1255,10 +1255,8 @@ nsresult Predictor::Prefetch(nsIURI *uri, nsIURI *referrer,
return rv; return rv;
} }
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
if (loadInfo) { rv = loadInfo->SetOriginAttributes(originAttributes);
rv = loadInfo->SetOriginAttributes(originAttributes);
}
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
PREDICTOR_LOG( PREDICTOR_LOG(

4
netwerk/base/nsAsyncRedirectVerifyHelper.cpp
View file

@ -74,8 +74,8 @@ nsresult nsAsyncRedirectVerifyHelper::Init(
if (!(flags & (nsIChannelEventSink::REDIRECT_INTERNAL | if (!(flags & (nsIChannelEventSink::REDIRECT_INTERNAL |
nsIChannelEventSink::REDIRECT_STS_UPGRADE))) { nsIChannelEventSink::REDIRECT_STS_UPGRADE))) {
nsCOMPtr<nsILoadInfo> loadInfo = oldChan->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = oldChan->LoadInfo();
if (loadInfo && loadInfo->GetDontFollowRedirects()) { if (loadInfo->GetDontFollowRedirects()) {
ExplicitCallback(NS_BINDING_ABORTED); ExplicitCallback(NS_BINDING_ABORTED);
return NS_OK; return NS_OK;
} }

79
netwerk/base/nsBaseChannel.cpp
View file

@ -83,55 +83,48 @@ nsresult nsBaseChannel::Redirect(nsIChannel *newChannel, uint32_t redirectFlags,
// make a copy of the loadinfo, append to the redirectchain // make a copy of the loadinfo, append to the redirectchain
// and set it on the new channel // and set it on the new channel
if (mLoadInfo) { nsSecurityFlags secFlags =
nsSecurityFlags secFlags = mLoadInfo->GetSecurityFlags() & mLoadInfo->GetSecurityFlags() & ~nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL;
~nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL; nsCOMPtr<nsILoadInfo> newLoadInfo =
nsCOMPtr<nsILoadInfo> newLoadInfo = static_cast<mozilla::net::LoadInfo *>(mLoadInfo.get())
static_cast<mozilla::net::LoadInfo *>(mLoadInfo.get()) ->CloneWithNewSecFlags(secFlags);
->CloneWithNewSecFlags(secFlags);
nsCOMPtr<nsIPrincipal> uriPrincipal; nsCOMPtr<nsIPrincipal> uriPrincipal;
nsIScriptSecurityManager *sm = nsContentUtils::GetSecurityManager(); nsIScriptSecurityManager *sm = nsContentUtils::GetSecurityManager();
sm->GetChannelURIPrincipal(this, getter_AddRefs(uriPrincipal)); sm->GetChannelURIPrincipal(this, getter_AddRefs(uriPrincipal));
bool isInternalRedirect = bool isInternalRedirect =
(redirectFlags & (nsIChannelEventSink::REDIRECT_INTERNAL | (redirectFlags & (nsIChannelEventSink::REDIRECT_INTERNAL |
nsIChannelEventSink::REDIRECT_STS_UPGRADE)); nsIChannelEventSink::REDIRECT_STS_UPGRADE));
// nsBaseChannel hst no thing to do with HttpBaseChannel, we would not care // nsBaseChannel hst no thing to do with HttpBaseChannel, we would not care
// about referrer and remote address in this case // about referrer and remote address in this case
nsCOMPtr<nsIRedirectHistoryEntry> entry = nsCOMPtr<nsIRedirectHistoryEntry> entry =
new nsRedirectHistoryEntry(uriPrincipal, nullptr, EmptyCString()); new nsRedirectHistoryEntry(uriPrincipal, nullptr, EmptyCString());
newLoadInfo->AppendRedirectHistoryEntry(entry, isInternalRedirect); newLoadInfo->AppendRedirectHistoryEntry(entry, isInternalRedirect);
// Ensure the channel's loadInfo's result principal URI so that it's // Ensure the channel's loadInfo's result principal URI so that it's
// either non-null or updated to the redirect target URI. // either non-null or updated to the redirect target URI.
// We must do this because in case the loadInfo's result principal URI // We must do this because in case the loadInfo's result principal URI
// is null, it would be taken from OriginalURI of the channel. But we // is null, it would be taken from OriginalURI of the channel. But we
// overwrite it with the whole redirect chain first URI before opening // overwrite it with the whole redirect chain first URI before opening
// the target channel, hence the information would be lost. // the target channel, hence the information would be lost.
// If the protocol handler that created the channel wants to use // If the protocol handler that created the channel wants to use
// the originalURI of the channel as the principal URI, it has left // the originalURI of the channel as the principal URI, it has left
// the result principal URI on the load info null. // the result principal URI on the load info null.
nsCOMPtr<nsIURI> resultPrincipalURI; nsCOMPtr<nsIURI> resultPrincipalURI;
nsCOMPtr<nsILoadInfo> existingLoadInfo = newChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> existingLoadInfo = newChannel->LoadInfo();
if (existingLoadInfo) { if (existingLoadInfo) {
existingLoadInfo->GetResultPrincipalURI( existingLoadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI));
getter_AddRefs(resultPrincipalURI));
}
if (!resultPrincipalURI) {
newChannel->GetOriginalURI(getter_AddRefs(resultPrincipalURI));
}
newLoadInfo->SetResultPrincipalURI(resultPrincipalURI);
newChannel->SetLoadInfo(newLoadInfo);
} else {
// the newChannel was created with a dummy loadInfo, we should clear
// it in case the original channel does not have a loadInfo
newChannel->SetLoadInfo(nullptr);
} }
if (!resultPrincipalURI) {
newChannel->GetOriginalURI(getter_AddRefs(resultPrincipalURI));
}
newLoadInfo->SetResultPrincipalURI(resultPrincipalURI);
newChannel->SetLoadInfo(newLoadInfo);
// Preserve the privacy bit if it has been overridden // Preserve the privacy bit if it has been overridden
if (mPrivateBrowsingOverriden) { if (mPrivateBrowsingOverriden) {

4
netwerk/base/nsIChannel.idl
View file

@ -356,11 +356,11 @@ interface nsIChannel : nsIRequest
return false; return false;
} }
inline already_AddRefed<nsILoadInfo> GetLoadInfo() inline already_AddRefed<nsILoadInfo> LoadInfo()
{ {
nsCOMPtr<nsILoadInfo> result; nsCOMPtr<nsILoadInfo> result;
mozilla::DebugOnly<nsresult> rv = GetLoadInfo(getter_AddRefs(result)); mozilla::DebugOnly<nsresult> rv = GetLoadInfo(getter_AddRefs(result));
MOZ_ASSERT(NS_SUCCEEDED(rv) || !result); MOZ_ASSERT(NS_SUCCEEDED(rv) && result);
return result.forget(); return result.forget();
} }
%} %}

56
netwerk/base/nsINetworkInterceptController.idl
View file

@ -192,35 +192,33 @@ interface nsIInterceptedChannel : nsISupports
GetSubresourceTimeStampKey(nsIChannel* aChannel, nsACString& aKey) GetSubresourceTimeStampKey(nsIChannel* aChannel, nsACString& aKey)
{ {
if (!nsContentUtils::IsNonSubresourceRequest(aChannel)) { if (!nsContentUtils::IsNonSubresourceRequest(aChannel)) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo) { switch(loadInfo->InternalContentPolicyType()) {
switch(loadInfo->InternalContentPolicyType()) { case nsIContentPolicy::TYPE_SCRIPT:
case nsIContentPolicy::TYPE_SCRIPT: case nsIContentPolicy::TYPE_INTERNAL_SCRIPT:
case nsIContentPolicy::TYPE_INTERNAL_SCRIPT: case nsIContentPolicy::TYPE_INTERNAL_SCRIPT_PRELOAD:
case nsIContentPolicy::TYPE_INTERNAL_SCRIPT_PRELOAD: case nsIContentPolicy::TYPE_INTERNAL_MODULE:
case nsIContentPolicy::TYPE_INTERNAL_MODULE: case nsIContentPolicy::TYPE_INTERNAL_MODULE_PRELOAD:
case nsIContentPolicy::TYPE_INTERNAL_MODULE_PRELOAD: case nsIContentPolicy::TYPE_INTERNAL_WORKER_IMPORT_SCRIPTS: {
case nsIContentPolicy::TYPE_INTERNAL_WORKER_IMPORT_SCRIPTS: { aKey = NS_LITERAL_CSTRING("subresource-script");
aKey = NS_LITERAL_CSTRING("subresource-script"); break;
break; }
} case nsIContentPolicy::TYPE_IMAGE:
case nsIContentPolicy::TYPE_IMAGE: case nsIContentPolicy::TYPE_INTERNAL_IMAGE:
case nsIContentPolicy::TYPE_INTERNAL_IMAGE: case nsIContentPolicy::TYPE_INTERNAL_IMAGE_PRELOAD:
case nsIContentPolicy::TYPE_INTERNAL_IMAGE_PRELOAD: case nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON: {
case nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON: { aKey = NS_LITERAL_CSTRING("subresource-image");
aKey = NS_LITERAL_CSTRING("subresource-image"); break;
break; }
} case nsIContentPolicy::TYPE_STYLESHEET:
case nsIContentPolicy::TYPE_STYLESHEET: case nsIContentPolicy::TYPE_INTERNAL_STYLESHEET:
case nsIContentPolicy::TYPE_INTERNAL_STYLESHEET: case nsIContentPolicy::TYPE_INTERNAL_STYLESHEET_PRELOAD: {
case nsIContentPolicy::TYPE_INTERNAL_STYLESHEET_PRELOAD: { aKey = NS_LITERAL_CSTRING("subresource-stylesheet");
aKey = NS_LITERAL_CSTRING("subresource-stylesheet"); break;
break; }
} default: {
default: { aKey = NS_LITERAL_CSTRING("subresource-other");
aKey = NS_LITERAL_CSTRING("subresource-other"); break;
break;
}
} }
} }
} }

11
netwerk/base/nsIOService.cpp
View file

@ -898,7 +898,7 @@ nsresult nsIOService::NewChannelFromURIWithProxyFlagsInternal(
aLoadingNode, aSecurityFlags, aContentPolicyType, aLoadingNode, aSecurityFlags, aContentPolicyType,
aLoadingClientInfo, aController); aLoadingClientInfo, aController);
} }
NS_ASSERTION(loadInfo, "Please pass security info when creating a channel"); MOZ_ASSERT(loadInfo, "Please pass security info when creating a channel");
return NewChannelFromURIWithProxyFlagsInternal(aURI, aProxyURI, aProxyFlags, return NewChannelFromURIWithProxyFlagsInternal(aURI, aProxyURI, aProxyFlags,
loadInfo, result); loadInfo, result);
} }
@ -935,7 +935,7 @@ nsresult nsIOService::NewChannelFromURIWithProxyFlagsInternal(
if (aLoadInfo) { if (aLoadInfo) {
// make sure we have the same instance of loadInfo on the newly created // make sure we have the same instance of loadInfo on the newly created
// channel // channel
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
if (aLoadInfo != loadInfo) { if (aLoadInfo != loadInfo) {
MOZ_ASSERT(false, "newly created channel must have a loadinfo attached"); MOZ_ASSERT(false, "newly created channel must have a loadinfo attached");
return NS_ERROR_UNEXPECTED; return NS_ERROR_UNEXPECTED;
@ -1709,11 +1709,8 @@ IOServiceProxyCallback::OnProxyAvailable(nsICancelable *request,
do_QueryInterface(handler); do_QueryInterface(handler);
if (!speculativeHandler) return NS_OK; if (!speculativeHandler) return NS_OK;
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
nsCOMPtr<nsIPrincipal> principal; nsCOMPtr<nsIPrincipal> principal = loadInfo->LoadingPrincipal();
if (loadInfo) {
principal = loadInfo->LoadingPrincipal();
}
nsLoadFlags loadFlags = 0; nsLoadFlags loadFlags = 0;
channel->GetLoadFlags(&loadFlags); channel->GetLoadFlags(&loadFlags);

64
netwerk/base/nsNetUtil.cpp
View file

@ -232,10 +232,7 @@ nsresult NS_NewChannelInternal(
} }
if (aPerformanceStorage) { if (aPerformanceStorage) {
nsCOMPtr<nsILoadInfo> loadInfo; nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
rv = channel->GetLoadInfo(getter_AddRefs(loadInfo));
NS_ENSURE_SUCCESS(rv, rv);
loadInfo->SetPerformanceStorage(aPerformanceStorage); loadInfo->SetPerformanceStorage(aPerformanceStorage);
} }
@ -387,10 +384,7 @@ nsresult NS_NewChannelInternal(
} }
if (aPerformanceStorage) { if (aPerformanceStorage) {
nsCOMPtr<nsILoadInfo> loadInfo; nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
rv = channel->GetLoadInfo(getter_AddRefs(loadInfo));
NS_ENSURE_SUCCESS(rv, rv);
loadInfo->SetPerformanceStorage(aPerformanceStorage); loadInfo->SetPerformanceStorage(aPerformanceStorage);
} }
@ -646,6 +640,7 @@ nsresult NS_NewInputStreamChannelInternal(
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
} }
MOZ_ASSERT(aLoadInfo, "need a loadinfo to create a inputstreamchannel");
channel->SetLoadInfo(aLoadInfo); channel->SetLoadInfo(aLoadInfo);
// If we're sandboxed, make sure to clear any owner the channel // If we're sandboxed, make sure to clear any owner the channel
@ -1703,12 +1698,8 @@ bool NS_UsePrivateBrowsing(nsIChannel *channel) {
bool NS_GetOriginAttributes(nsIChannel *aChannel, bool NS_GetOriginAttributes(nsIChannel *aChannel,
mozilla::OriginAttributes &aAttributes) { mozilla::OriginAttributes &aAttributes) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
// For some channels, they might not have loadInfo, like loadInfo->GetOriginAttributes(&aAttributes);
// ExternalHelperAppParent..
if (loadInfo) {
loadInfo->GetOriginAttributes(&aAttributes);
}
bool isPrivate = false; bool isPrivate = false;
nsCOMPtr<nsIPrivateBrowsingChannel> pbChannel = do_QueryInterface(aChannel); nsCOMPtr<nsIPrivateBrowsingChannel> pbChannel = do_QueryInterface(aChannel);
@ -1726,15 +1717,7 @@ bool NS_GetOriginAttributes(nsIChannel *aChannel,
} }
bool NS_HasBeenCrossOrigin(nsIChannel *aChannel, bool aReport) { bool NS_HasBeenCrossOrigin(nsIChannel *aChannel, bool aReport) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
MOZ_RELEASE_ASSERT(
loadInfo,
"Origin tracking only works for channels created with a loadinfo");
if (!loadInfo) {
return false;
}
// TYPE_DOCUMENT loads have a null LoadingPrincipal and can not be cross // TYPE_DOCUMENT loads have a null LoadingPrincipal and can not be cross
// origin. // origin.
if (!loadInfo->LoadingPrincipal()) { if (!loadInfo->LoadingPrincipal()) {
@ -1795,10 +1778,7 @@ bool NS_IsSafeTopLevelNav(nsIChannel *aChannel) {
if (!aChannel) { if (!aChannel) {
return false; return false;
} }
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (!loadInfo) {
return false;
}
if (loadInfo->GetExternalContentPolicyType() != if (loadInfo->GetExternalContentPolicyType() !=
nsIContentPolicy::TYPE_DOCUMENT) { nsIContentPolicy::TYPE_DOCUMENT) {
return false; return false;
@ -1818,11 +1798,7 @@ bool NS_IsSameSiteForeign(nsIChannel *aChannel, nsIURI *aHostURI) {
if (!aChannel) { if (!aChannel) {
return false; return false;
} }
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (!loadInfo) {
return false;
}
// Do not treat loads triggered by web extensions as foreign // Do not treat loads triggered by web extensions as foreign
nsCOMPtr<nsIURI> channelURI; nsCOMPtr<nsIURI> channelURI;
NS_GetFinalChannelURI(aChannel, getter_AddRefs(channelURI)); NS_GetFinalChannelURI(aChannel, getter_AddRefs(channelURI));
@ -2024,16 +2000,13 @@ already_AddRefed<nsIURI> NS_GetInnermostURI(nsIURI *aURI) {
nsresult NS_GetFinalChannelURI(nsIChannel *channel, nsIURI **uri) { nsresult NS_GetFinalChannelURI(nsIChannel *channel, nsIURI **uri) {
*uri = nullptr; *uri = nullptr;
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
if (loadInfo) { nsCOMPtr<nsIURI> resultPrincipalURI;
nsCOMPtr<nsIURI> resultPrincipalURI; loadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI));
loadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI)); if (resultPrincipalURI) {
if (resultPrincipalURI) { resultPrincipalURI.forget(uri);
resultPrincipalURI.forget(uri); return NS_OK;
return NS_OK;
}
} }
return channel->GetOriginalURI(uri); return channel->GetOriginalURI(uri);
} }
@ -2359,13 +2332,13 @@ nsresult NS_LinkRedirectChannels(uint32_t channelId,
nsresult NS_MaybeOpenChannelUsingOpen(nsIChannel *aChannel, nsresult NS_MaybeOpenChannelUsingOpen(nsIChannel *aChannel,
nsIInputStream **aStream) { nsIInputStream **aStream) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
return aChannel->Open(aStream); return aChannel->Open(aStream);
} }
nsresult NS_MaybeOpenChannelUsingAsyncOpen(nsIChannel *aChannel, nsresult NS_MaybeOpenChannelUsingAsyncOpen(nsIChannel *aChannel,
nsIStreamListener *aListener) { nsIStreamListener *aListener) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
return aChannel->AsyncOpen(aListener); return aChannel->AsyncOpen(aListener);
} }
@ -2688,12 +2661,11 @@ nsresult NS_GetSecureUpgradedURI(nsIURI *aURI, nsIURI **aUpgradedURI) {
} }
nsresult NS_CompareLoadInfoAndLoadContext(nsIChannel *aChannel) { nsresult NS_CompareLoadInfoAndLoadContext(nsIChannel *aChannel) {
nsCOMPtr<nsILoadInfo> loadInfo; nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
aChannel->GetLoadInfo(getter_AddRefs(loadInfo));
nsCOMPtr<nsILoadContext> loadContext; nsCOMPtr<nsILoadContext> loadContext;
NS_QueryNotificationCallbacks(aChannel, loadContext); NS_QueryNotificationCallbacks(aChannel, loadContext);
if (!loadInfo || !loadContext) { if (!loadContext) {
return NS_OK; return NS_OK;
} }

19
netwerk/cookie/CookieServiceChild.cpp
View file

@ -176,11 +176,8 @@ void CookieServiceChild::TrackCookieLoad(nsIChannel *aChannel) {
rejectedReason); rejectedReason);
} }
} }
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
mozilla::OriginAttributes attrs; mozilla::OriginAttributes attrs = loadInfo->GetOriginAttributes();
if (loadInfo) {
attrs = loadInfo->GetOriginAttributes();
}
URIParams uriParams; URIParams uriParams;
SerializeURI(uri, uriParams); SerializeURI(uri, uriParams);
bool isSafeTopLevelNav = NS_IsSafeTopLevelNav(aChannel); bool isSafeTopLevelNav = NS_IsSafeTopLevelNav(aChannel);
@ -484,10 +481,8 @@ nsresult CookieServiceChild::GetCookieStringInternal(nsIURI *aHostURI,
nsCOMPtr<nsILoadInfo> loadInfo; nsCOMPtr<nsILoadInfo> loadInfo;
mozilla::OriginAttributes attrs; mozilla::OriginAttributes attrs;
if (aChannel) { if (aChannel) {
loadInfo = aChannel->GetLoadInfo(); loadInfo = aChannel->LoadInfo();
if (loadInfo) { attrs = loadInfo->GetOriginAttributes();
attrs = loadInfo->GetOriginAttributes();
}
} }
// Asynchronously call the parent. // Asynchronously call the parent.
@ -569,10 +564,8 @@ nsresult CookieServiceChild::SetCookieStringInternal(nsIURI *aHostURI,
aChannel->GetURI(getter_AddRefs(channelURI)); aChannel->GetURI(getter_AddRefs(channelURI));
SerializeURI(channelURI, channelURIParams); SerializeURI(channelURI, channelURIParams);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo) { attrs = loadInfo->GetOriginAttributes();
attrs = loadInfo->GetOriginAttributes();
}
} else { } else {
SerializeURI(nullptr, channelURIParams); SerializeURI(nullptr, channelURIParams);
} }

7
netwerk/cookie/CookieServiceParent.cpp
View file

@ -132,11 +132,8 @@ void CookieServiceParent::TrackCookieLoad(nsIChannel *aChannel) {
nsCOMPtr<nsIURI> uri; nsCOMPtr<nsIURI> uri;
aChannel->GetURI(getter_AddRefs(uri)); aChannel->GetURI(getter_AddRefs(uri));
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
mozilla::OriginAttributes attrs; mozilla::OriginAttributes attrs = loadInfo->GetOriginAttributes();
if (loadInfo) {
attrs = loadInfo->GetOriginAttributes();
}
bool isSafeTopLevelNav = NS_IsSafeTopLevelNav(aChannel); bool isSafeTopLevelNav = NS_IsSafeTopLevelNav(aChannel);
bool aIsSameSiteForeign = NS_IsSameSiteForeign(aChannel, uri); bool aIsSameSiteForeign = NS_IsSameSiteForeign(aChannel, uri);

7
netwerk/cookie/nsCookieService.cpp
View file

@ -3390,10 +3390,9 @@ bool nsCookieService::CanSetCookie(nsIURI *aHostURI, const nsCookieKey &aKey,
if (aChannel) { if (aChannel) {
nsCOMPtr<nsIURI> channelURI; nsCOMPtr<nsIURI> channelURI;
NS_GetFinalChannelURI(aChannel, getter_AddRefs(channelURI)); NS_GetFinalChannelURI(aChannel, getter_AddRefs(channelURI));
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
addonAllowsLoad = addonAllowsLoad = BasePrincipal::Cast(loadInfo->TriggeringPrincipal())
loadInfo && BasePrincipal::Cast(loadInfo->TriggeringPrincipal()) ->AddonAllowsLoad(channelURI);
->AddonAllowsLoad(channelURI);
} }
if (!addonAllowsLoad) { if (!addonAllowsLoad) {

6
netwerk/ipc/ChannelEventQueue.cpp
View file

@ -186,11 +186,7 @@ bool ChannelEventQueue::MaybeSuspendIfEventsAreSuppressed() {
return false; return false;
} }
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
if (!loadInfo) {
return false;
}
// Figure out if this is for an XHR, if we haven't done so already. // Figure out if this is for an XHR, if we haven't done so already.
if (!mHasCheckedForXMLHttpRequest) { if (!mHasCheckedForXMLHttpRequest) {
nsContentPolicyType contentType = loadInfo->InternalContentPolicyType(); nsContentPolicyType contentType = loadInfo->InternalContentPolicyType();

28
netwerk/protocol/about/nsAboutProtocolHandler.cpp
View file

@ -204,22 +204,20 @@ nsAboutProtocolHandler::NewChannel(nsIURI *uri, nsILoadInfo *aLoadInfo,
// set the LoadInfo on the newly created channel yet, as // set the LoadInfo on the newly created channel yet, as
// an interim solution we set the LoadInfo here if not // an interim solution we set the LoadInfo here if not
// available on the channel. Bug 1087720 // available on the channel. Bug 1087720
nsCOMPtr<nsILoadInfo> loadInfo = (*result)->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = (*result)->LoadInfo();
if (aLoadInfo != loadInfo) { if (aLoadInfo != loadInfo) {
if (loadInfo) { NS_ASSERTION(false,
NS_ASSERTION(false, "nsIAboutModule->newChannel(aURI, aLoadInfo) needs to "
"nsIAboutModule->newChannel(aURI, aLoadInfo) needs to " "set LoadInfo");
"set LoadInfo"); const char16_t *params[] = {
const char16_t *params[] = { u"nsIAboutModule->newChannel(aURI)",
u"nsIAboutModule->newChannel(aURI)", u"nsIAboutModule->newChannel(aURI, aLoadInfo)"};
u"nsIAboutModule->newChannel(aURI, aLoadInfo)"}; nsContentUtils::ReportToConsole(
nsContentUtils::ReportToConsole( nsIScriptError::warningFlag,
nsIScriptError::warningFlag, NS_LITERAL_CSTRING("Security by Default"),
NS_LITERAL_CSTRING("Security by Default"), nullptr, // aDocument
nullptr, // aDocument nsContentUtils::eNECKO_PROPERTIES, "APIDeprecationWarning", params,
nsContentUtils::eNECKO_PROPERTIES, "APIDeprecationWarning", mozilla::ArrayLength(params));
params, mozilla::ArrayLength(params));
}
(*result)->SetLoadInfo(aLoadInfo); (*result)->SetLoadInfo(aLoadInfo);
} }

18
netwerk/protocol/http/HttpBaseChannel.cpp
View file

@ -2581,9 +2581,6 @@ nsresult HttpBaseChannel::AddSecurityMessage(
nsCOMPtr<nsILoadInfo> loadInfo; nsCOMPtr<nsILoadInfo> loadInfo;
GetLoadInfo(getter_AddRefs(loadInfo)); GetLoadInfo(getter_AddRefs(loadInfo));
if (!loadInfo) {
return NS_ERROR_FAILURE;
}
auto innerWindowID = loadInfo->GetInnerWindowID(); auto innerWindowID = loadInfo->GetInnerWindowID();
@ -3440,16 +3437,13 @@ nsresult HttpBaseChannel::SetupReplacementChannel(nsIURI* newURI,
// If the protocol handler that created the channel wants to use // If the protocol handler that created the channel wants to use
// the originalURI of the channel as the principal URI, this fulfills // the originalURI of the channel as the principal URI, this fulfills
// that request - newURI is the original URI of the channel. // that request - newURI is the original URI of the channel.
nsCOMPtr<nsILoadInfo> newLoadInfo = newChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> newLoadInfo = newChannel->LoadInfo();
if (newLoadInfo) { nsCOMPtr<nsIURI> resultPrincipalURI;
nsCOMPtr<nsIURI> resultPrincipalURI; rv = newLoadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI));
rv = newLoadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI)); NS_ENSURE_SUCCESS(rv, rv);
if (!resultPrincipalURI) {
rv = newLoadInfo->SetResultPrincipalURI(newURI);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
if (!resultPrincipalURI) {
rv = newLoadInfo->SetResultPrincipalURI(newURI);
NS_ENSURE_SUCCESS(rv, rv);
}
} }
uint32_t newLoadFlags = mLoadFlags | LOAD_REPLACE; uint32_t newLoadFlags = mLoadFlags | LOAD_REPLACE;

4
netwerk/protocol/http/HttpChannelParent.cpp
View file

@ -444,10 +444,6 @@ bool HttpChannelParent::DoAsyncOpen(
return SendFailedAsyncOpen(rv); return SendFailedAsyncOpen(rv);
} }
if (!loadInfo) {
return SendFailedAsyncOpen(NS_ERROR_UNEXPECTED);
}
nsCOMPtr<nsIChannel> channel; nsCOMPtr<nsIChannel> channel;
rv = NS_NewChannelInternal(getter_AddRefs(channel), uri, loadInfo, nullptr, rv = NS_NewChannelInternal(getter_AddRefs(channel), uri, loadInfo, nullptr,
nullptr, nullptr, aLoadFlags, ios); nullptr, nullptr, aLoadFlags, ios);

6
netwerk/protocol/http/TrackingDummyChannelChild.cpp
View file

@ -32,11 +32,7 @@ namespace net {
nsresult topWindowURIResult = nsresult topWindowURIResult =
httpChannelInternal->GetTopWindowURI(getter_AddRefs(topWindowURI)); httpChannelInternal->GetTopWindowURI(getter_AddRefs(topWindowURI));
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (!loadInfo) {
return false;
}
OptionalLoadInfoArgs loadInfoArgs; OptionalLoadInfoArgs loadInfoArgs;
mozilla::ipc::LoadInfoToLoadInfoArgs(loadInfo, &loadInfoArgs); mozilla::ipc::LoadInfoToLoadInfoArgs(loadInfo, &loadInfoArgs);

32
netwerk/protocol/http/nsCORSListenerProxy.cpp
View file

@ -532,8 +532,8 @@ nsresult nsCORSListenerProxy::CheckRequestApproved(nsIRequest* aRequest) {
return NS_ERROR_DOM_BAD_URI; return NS_ERROR_DOM_BAD_URI;
} }
nsCOMPtr<nsILoadInfo> loadInfo = http->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = http->LoadInfo();
if (loadInfo && loadInfo->GetServiceWorkerTaintingSynthesized()) { if (loadInfo->GetServiceWorkerTaintingSynthesized()) {
// For synthesized responses, we don't need to perform any checks. // For synthesized responses, we don't need to perform any checks.
// Note: This would be unsafe if we ever changed our behavior to allow // Note: This would be unsafe if we ever changed our behavior to allow
// service workers to intercept CORS preflights. // service workers to intercept CORS preflights.
@ -842,14 +842,7 @@ bool CheckUpgradeInsecureRequestsPreventsCORS(
return false; return false;
} }
nsCOMPtr<nsILoadInfo> loadInfo; nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
rv = aChannel->GetLoadInfo(getter_AddRefs(loadInfo));
NS_ENSURE_SUCCESS(rv, false);
if (!loadInfo) {
return false;
}
// lets see if the loadInfo indicates that the request will // lets see if the loadInfo indicates that the request will
// be upgraded before fetching any data from the netwerk. // be upgraded before fetching any data from the netwerk.
return loadInfo->GetUpgradeInsecureRequests() || return loadInfo->GetUpgradeInsecureRequests() ||
@ -865,7 +858,7 @@ nsresult nsCORSListenerProxy::UpdateChannel(nsIChannel* aChannel,
rv = aChannel->GetOriginalURI(getter_AddRefs(originalURI)); rv = aChannel->GetOriginalURI(getter_AddRefs(originalURI));
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
// exempt data URIs from the same origin check. // exempt data URIs from the same origin check.
if (aAllowDataURI == DataURIHandling::Allow && originalURI == uri) { if (aAllowDataURI == DataURIHandling::Allow && originalURI == uri) {
@ -875,7 +868,7 @@ nsresult nsCORSListenerProxy::UpdateChannel(nsIChannel* aChannel,
if (dataScheme) { if (dataScheme) {
return NS_OK; return NS_OK;
} }
if (loadInfo && loadInfo->GetAboutBlankInherits() && NS_IsAboutBlank(uri)) { if (loadInfo->GetAboutBlankInherits() && NS_IsAboutBlank(uri)) {
return NS_OK; return NS_OK;
} }
} }
@ -1001,9 +994,8 @@ nsresult nsCORSListenerProxy::CheckPreflightNeeded(nsIChannel* aChannel,
UpdateType aUpdateType) { UpdateType aUpdateType) {
// If this caller isn't using AsyncOpen, or if this *is* a preflight channel, // If this caller isn't using AsyncOpen, or if this *is* a preflight channel,
// then we shouldn't initiate preflight for this channel. // then we shouldn't initiate preflight for this channel.
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (!loadInfo || if (loadInfo->GetSecurityMode() !=
loadInfo->GetSecurityMode() !=
nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS || nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS ||
loadInfo->GetIsPreflight()) { loadInfo->GetIsPreflight()) {
return NS_OK; return NS_OK;
@ -1223,7 +1215,7 @@ nsCORSPreflightListener::OnStartRequest(nsIRequest* aRequest,
#ifdef DEBUG #ifdef DEBUG
{ {
nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest); nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
nsCOMPtr<nsILoadInfo> loadInfo = channel ? channel->GetLoadInfo() : nullptr; nsCOMPtr<nsILoadInfo> loadInfo = channel ? channel->LoadInfo() : nullptr;
MOZ_ASSERT(!loadInfo || !loadInfo->GetServiceWorkerTaintingSynthesized()); MOZ_ASSERT(!loadInfo || !loadInfo->GetServiceWorkerTaintingSynthesized());
} }
#endif #endif
@ -1398,13 +1390,7 @@ nsresult nsCORSListenerProxy::StartCORSPreflight(
nsresult rv = NS_GetFinalChannelURI(aRequestChannel, getter_AddRefs(uri)); nsresult rv = NS_GetFinalChannelURI(aRequestChannel, getter_AddRefs(uri));
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> originalLoadInfo = aRequestChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> originalLoadInfo = aRequestChannel->LoadInfo();
MOZ_ASSERT(originalLoadInfo,
"can not perform CORS preflight without a loadInfo");
if (!originalLoadInfo) {
return NS_ERROR_FAILURE;
}
MOZ_ASSERT(originalLoadInfo->GetSecurityMode() == MOZ_ASSERT(originalLoadInfo->GetSecurityMode() ==
nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS, nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS,
"how did we end up here?"); "how did we end up here?");

59
netwerk/protocol/http/nsHttpChannelAuthProvider.cpp
View file

@ -899,47 +899,44 @@ bool nsHttpChannelAuthProvider::BlockPrompt(bool proxyAuth) {
} }
nsCOMPtr<nsIChannel> chan = do_QueryInterface(mAuthChannel); nsCOMPtr<nsIChannel> chan = do_QueryInterface(mAuthChannel);
nsCOMPtr<nsILoadInfo> loadInfo; nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
chan->GetLoadInfo(getter_AddRefs(loadInfo));
// We will treat loads w/o loadInfo as a top level document. // We will treat loads w/o loadInfo as a top level document.
bool topDoc = true; bool topDoc = true;
bool xhr = false; bool xhr = false;
bool nonWebContent = false; bool nonWebContent = false;
if (loadInfo) { if (loadInfo->GetExternalContentPolicyType() !=
if (loadInfo->GetExternalContentPolicyType() != nsIContentPolicy::TYPE_DOCUMENT) {
nsIContentPolicy::TYPE_DOCUMENT) { topDoc = false;
topDoc = false; }
}
if (!topDoc) { if (!topDoc) {
nsCOMPtr<nsIPrincipal> triggeringPrinc = loadInfo->TriggeringPrincipal(); nsCOMPtr<nsIPrincipal> triggeringPrinc = loadInfo->TriggeringPrincipal();
if (nsContentUtils::IsSystemPrincipal(triggeringPrinc)) { if (nsContentUtils::IsSystemPrincipal(triggeringPrinc)) {
nonWebContent = true; nonWebContent = true;
}
}
if (loadInfo->GetExternalContentPolicyType() ==
nsIContentPolicy::TYPE_XMLHTTPREQUEST) {
xhr = true;
}
if (!topDoc && !xhr) {
nsCOMPtr<nsIURI> topURI;
Unused << chanInternal->GetTopWindowURI(getter_AddRefs(topURI));
if (!topURI) {
// If we do not have topURI try the loadingPrincipal.
nsCOMPtr<nsIPrincipal> loadingPrinc = loadInfo->LoadingPrincipal();
if (loadingPrinc) {
loadingPrinc->GetURI(getter_AddRefs(topURI));
} }
} }
if (loadInfo->GetExternalContentPolicyType() == if (!NS_SecurityCompareURIs(topURI, mURI, true)) {
nsIContentPolicy::TYPE_XMLHTTPREQUEST) { mCrossOrigin = true;
xhr = true;
}
if (!topDoc && !xhr) {
nsCOMPtr<nsIURI> topURI;
Unused << chanInternal->GetTopWindowURI(getter_AddRefs(topURI));
if (!topURI) {
// If we do not have topURI try the loadingPrincipal.
nsCOMPtr<nsIPrincipal> loadingPrinc = loadInfo->LoadingPrincipal();
if (loadingPrinc) {
loadingPrinc->GetURI(getter_AddRefs(topURI));
}
}
if (!NS_SecurityCompareURIs(topURI, mURI, true)) {
mCrossOrigin = true;
}
} }
} }

16
netwerk/protocol/viewsource/nsViewSourceChannel.cpp
View file

@ -136,11 +136,7 @@ nsresult nsViewSourceChannel::UpdateLoadInfoResultPrincipalURI() {
MOZ_ASSERT(mChannel); MOZ_ASSERT(mChannel);
nsCOMPtr<nsILoadInfo> channelLoadInfo = mChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> channelLoadInfo = mChannel->LoadInfo();
if (!channelLoadInfo) {
return NS_OK;
}
nsCOMPtr<nsIURI> channelResultPrincipalURI; nsCOMPtr<nsIURI> channelResultPrincipalURI;
rv = channelLoadInfo->GetResultPrincipalURI( rv = channelLoadInfo->GetResultPrincipalURI(
getter_AddRefs(channelResultPrincipalURI)); getter_AddRefs(channelResultPrincipalURI));
@ -290,21 +286,11 @@ nsViewSourceChannel::GetURI(nsIURI **aURI) {
NS_IMETHODIMP NS_IMETHODIMP
nsViewSourceChannel::Open(nsIInputStream **aStream) { nsViewSourceChannel::Open(nsIInputStream **aStream) {
NS_ENSURE_TRUE(mChannel, NS_ERROR_FAILURE); NS_ENSURE_TRUE(mChannel, NS_ERROR_FAILURE);
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
if (!loadInfo) {
MOZ_ASSERT(loadInfo, "can not enforce security without loadInfo");
return NS_ERROR_UNEXPECTED;
}
return Open(aStream); return Open(aStream);
} }
NS_IMETHODIMP NS_IMETHODIMP
nsViewSourceChannel::AsyncOpen(nsIStreamListener *aListener) { nsViewSourceChannel::AsyncOpen(nsIStreamListener *aListener) {
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
if (!loadInfo) {
MOZ_ASSERT(loadInfo, "can not enforce security without loadInfo");
return NS_ERROR_UNEXPECTED;
}
// We can't ensure GetInitialSecurityCheckDone here // We can't ensure GetInitialSecurityCheckDone here
NS_ENSURE_TRUE(mChannel, NS_ERROR_FAILURE); NS_ENSURE_TRUE(mChannel, NS_ERROR_FAILURE);

8
netwerk/protocol/wyciwyg/WyciwygChannelParent.cpp
View file

@ -111,10 +111,8 @@ mozilla::ipc::IPCResult WyciwygChannelParent::RecvInit(
return IPC_OK(); return IPC_OK();
} }
nsCOMPtr<nsILoadInfo> loadInfo = chan->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
if (loadInfo) { rv = loadInfo->SetPrincipalToInherit(principalToInherit);
rv = loadInfo->SetPrincipalToInherit(principalToInherit);
}
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
if (!SendCancelEarly(rv)) { if (!SendCancelEarly(rv)) {
return IPC_FAIL_NO_REASON(this); return IPC_FAIL_NO_REASON(this);
@ -212,7 +210,7 @@ mozilla::ipc::IPCResult WyciwygChannelParent::RecvAsyncOpen(
return IPC_OK(); return IPC_OK();
} }
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
rv = mChannel->AsyncOpen(this); rv = mChannel->AsyncOpen(this);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {

6
netwerk/url-classifier/UrlClassifierCommon.cpp
View file

@ -33,11 +33,7 @@ LazyLogModule UrlClassifierCommon::sLog("nsChannelClassifier");
/* static */ bool UrlClassifierCommon::AddonMayLoad(nsIChannel* aChannel, /* static */ bool UrlClassifierCommon::AddonMayLoad(nsIChannel* aChannel,
nsIURI* aURI) { nsIURI* aURI) {
nsCOMPtr<nsILoadInfo> channelLoadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> channelLoadInfo = aChannel->LoadInfo();
if (!channelLoadInfo) {
return false;
}
// loadingPrincipal is used here to ensure we are loading into an // loadingPrincipal is used here to ensure we are loading into an
// addon principal. This allows an addon, with explicit permission, to // addon principal. This allows an addon, with explicit permission, to
// call out to API endpoints that may otherwise get blocked. // call out to API endpoints that may otherwise get blocked.

5
netwerk/url-classifier/UrlClassifierFeatureFlash.cpp
View file

@ -98,10 +98,9 @@ UrlClassifierFeatureFlash::UrlClassifierFeatureFlash(
} }
// We use Flash feature just for document loading. // We use Flash feature just for document loading.
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
nsContentPolicyType contentPolicyType = nsContentPolicyType contentPolicyType =
loadInfo ? loadInfo->GetExternalContentPolicyType() loadInfo->GetExternalContentPolicyType();
: nsIContentPolicy::TYPE_INVALID;
if (contentPolicyType != nsIContentPolicy::TYPE_DOCUMENT && if (contentPolicyType != nsIContentPolicy::TYPE_DOCUMENT &&
contentPolicyType != nsIContentPolicy::TYPE_SUBDOCUMENT) { contentPolicyType != nsIContentPolicy::TYPE_SUBDOCUMENT) {

5
security/manager/ssl/nsNSSCallbacks.cpp
View file

@ -271,10 +271,7 @@ OCSPRequest::Run() {
attrs.mFirstPartyDomain = mOriginAttributes.mFirstPartyDomain; attrs.mFirstPartyDomain = mOriginAttributes.mFirstPartyDomain;
attrs.mPrivateBrowsingId = mOriginAttributes.mPrivateBrowsingId; attrs.mPrivateBrowsingId = mOriginAttributes.mPrivateBrowsingId;
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
if (!loadInfo) {
return NotifyDone(NS_ERROR_FAILURE, lock);
}
rv = loadInfo->SetOriginAttributes(attrs); rv = loadInfo->SetOriginAttributes(attrs);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
return NotifyDone(rv, lock); return NotifyDone(rv, lock);

7
toolkit/components/antitracking/AntiTrackingCommon.cpp
View file

@ -1272,12 +1272,7 @@ bool AntiTrackingCommon::IsFirstPartyStorageAccessGrantedFor(
("Computing whether channel %p has access to URI %s", aChannel, _spec), ("Computing whether channel %p has access to URI %s", aChannel, _spec),
channelURI); channelURI);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (!loadInfo) {
LOG(("No loadInfo, bail out early"));
return true;
}
// We need to find the correct principal to check the cookie permission. For // We need to find the correct principal to check the cookie permission. For
// third-party contexts, we want to check if the top-level window has a custom // third-party contexts, we want to check if the top-level window has a custom
// cookie permission. // cookie permission.

6
toolkit/components/extensions/ExtensionPolicyService.cpp
View file

@ -396,11 +396,7 @@ nsresult ExtensionPolicyService::InjectContentScripts(
// Checks a request for matching content scripts, and begins pre-loading them // Checks a request for matching content scripts, and begins pre-loading them
// if necessary. // if necessary.
void ExtensionPolicyService::CheckRequest(nsIChannel* aChannel) { void ExtensionPolicyService::CheckRequest(nsIChannel* aChannel) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (!loadInfo) {
return;
}
auto loadType = loadInfo->GetExternalContentPolicyType(); auto loadType = loadInfo->GetExternalContentPolicyType();
if (loadType != nsIContentPolicy::TYPE_DOCUMENT && if (loadType != nsIContentPolicy::TYPE_DOCUMENT &&
loadType != nsIContentPolicy::TYPE_SUBDOCUMENT) { loadType != nsIContentPolicy::TYPE_SUBDOCUMENT) {

7
toolkit/components/extensions/WebExtensionPolicy.cpp
View file

@ -745,12 +745,7 @@ bool WindowShouldMatchActiveTab(nsPIDOMWindowOuter* aWin) {
return false; return false;
} }
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
if (!loadInfo) {
return false;
}
if (!loadInfo->GetOriginalFrameSrcLoad()) { if (!loadInfo->GetOriginalFrameSrcLoad()) {
return false; return false;
} }

2
toolkit/components/extensions/webrequest/ChannelWrapper.h
View file

@ -180,7 +180,7 @@ class ChannelWrapper final : public DOMEventTargetHelper,
already_AddRefed<nsILoadInfo> GetLoadInfo() const { already_AddRefed<nsILoadInfo> GetLoadInfo() const {
nsCOMPtr<nsIChannel> chan = MaybeChannel(); nsCOMPtr<nsIChannel> chan = MaybeChannel();
if (chan) { if (chan) {
return chan->GetLoadInfo(); return chan->LoadInfo();
} }
return nullptr; return nullptr;
} }

4
toolkit/components/places/nsAnnoProtocolHandler.cpp
View file

@ -51,7 +51,7 @@ static nsresult GetDefaultIcon(nsIChannel *aOriginalChannel,
nsresult rv = NS_NewURI(getter_AddRefs(defaultIconURI), nsresult rv = NS_NewURI(getter_AddRefs(defaultIconURI),
NS_LITERAL_CSTRING(FAVICON_DEFAULT_URL)); NS_LITERAL_CSTRING(FAVICON_DEFAULT_URL));
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = aOriginalChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aOriginalChannel->LoadInfo();
rv = NS_NewChannelInternal(aChannel, defaultIconURI, loadInfo); rv = NS_NewChannelInternal(aChannel, defaultIconURI, loadInfo);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
Unused << (*aChannel)->SetContentType( Unused << (*aChannel)->SetContentType(
@ -132,7 +132,7 @@ class faviconAsyncLoader : public AsyncStatementCallback {
// Ensure we'll break possible cycles with the listener. // Ensure we'll break possible cycles with the listener.
auto cleanup = MakeScopeExit([&]() { mListener = nullptr; }); auto cleanup = MakeScopeExit([&]() { mListener = nullptr; });
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
nsCOMPtr<nsIEventTarget> target = nsCOMPtr<nsIEventTarget> target =
nsContentUtils::GetEventTargetByLoadInfo(loadInfo, TaskCategory::Other); nsContentUtils::GetEventTargetByLoadInfo(loadInfo, TaskCategory::Other);
if (!mData.IsEmpty()) { if (!mData.IsEmpty()) {

11
toolkit/components/reputationservice/ApplicationReputation.cpp
View file

@ -1592,13 +1592,10 @@ nsresult PendingLookup::SendRemoteQueryInternal(Reason& aReason) {
nsIContentPolicy::TYPE_OTHER, getter_AddRefs(mChannel)); nsIContentPolicy::TYPE_OTHER, getter_AddRefs(mChannel));
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
if (loadInfo) { mozilla::OriginAttributes attrs;
mozilla::OriginAttributes attrs; attrs.mFirstPartyDomain.AssignLiteral(NECKO_SAFEBROWSING_FIRST_PARTY_DOMAIN);
attrs.mFirstPartyDomain.AssignLiteral( loadInfo->SetOriginAttributes(attrs);
NECKO_SAFEBROWSING_FIRST_PARTY_DOMAIN);
loadInfo->SetOriginAttributes(attrs);
}
nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(mChannel, &rv)); nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(mChannel, &rv));
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);

6
toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
View file

@ -2000,12 +2000,10 @@ nsUrlClassifierDBService::SendThreatHitReport(nsIChannel* aChannel,
nullptr, loadFlags); nullptr, loadFlags);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = reportChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = reportChannel->LoadInfo();
mozilla::OriginAttributes attrs; mozilla::OriginAttributes attrs;
attrs.mFirstPartyDomain.AssignLiteral(NECKO_SAFEBROWSING_FIRST_PARTY_DOMAIN); attrs.mFirstPartyDomain.AssignLiteral(NECKO_SAFEBROWSING_FIRST_PARTY_DOMAIN);
if (loadInfo) { loadInfo->SetOriginAttributes(attrs);
loadInfo->SetOriginAttributes(attrs);
}
nsCOMPtr<nsIUploadChannel> uploadChannel(do_QueryInterface(reportChannel)); nsCOMPtr<nsIUploadChannel> uploadChannel(do_QueryInterface(reportChannel));
NS_ENSURE_TRUE(uploadChannel, NS_ERROR_FAILURE); NS_ENSURE_TRUE(uploadChannel, NS_ERROR_FAILURE);

6
toolkit/components/url-classifier/nsUrlClassifierStreamUpdater.cpp
View file

@ -140,12 +140,10 @@ nsresult nsUrlClassifierStreamUpdater::FetchUpdate(
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
mozilla::OriginAttributes attrs; mozilla::OriginAttributes attrs;
attrs.mFirstPartyDomain.AssignLiteral(NECKO_SAFEBROWSING_FIRST_PARTY_DOMAIN); attrs.mFirstPartyDomain.AssignLiteral(NECKO_SAFEBROWSING_FIRST_PARTY_DOMAIN);
if (loadInfo) { loadInfo->SetOriginAttributes(attrs);
loadInfo->SetOriginAttributes(attrs);
}
mBeganStream = false; mBeganStream = false;

10
toolkit/components/url-classifier/nsUrlClassifierUtils.cpp
View file

@ -661,8 +661,8 @@ static nsresult AddTabThreatSources(ThreatHit& aHit, nsIChannel* aChannel) {
bool isTopUri = false; bool isTopUri = false;
rv = topUri->Equals(uri, &isTopUri); rv = topUri->Equals(uri, &isTopUri);
if (NS_SUCCEEDED(rv) && !isTopUri) { if (NS_SUCCEEDED(rv) && !isTopUri) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo && loadInfo->RedirectChain().Length()) { if (loadInfo->RedirectChain().Length()) {
AddThreatSourceFromRedirectEntry(aHit, loadInfo->RedirectChain()[0], AddThreatSourceFromRedirectEntry(aHit, loadInfo->RedirectChain()[0],
ThreatHit_ThreatSourceType_TAB_RESOURCE); ThreatHit_ThreatSourceType_TAB_RESOURCE);
} }
@ -674,11 +674,7 @@ static nsresult AddTabThreatSources(ThreatHit& aHit, nsIChannel* aChannel) {
Unused << NS_WARN_IF(NS_FAILED(rv)); Unused << NS_WARN_IF(NS_FAILED(rv));
// Set tab_redirect threat sources if there's any // Set tab_redirect threat sources if there's any
nsCOMPtr<nsILoadInfo> topLoadInfo = topChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> topLoadInfo = topChannel->LoadInfo();
if (!topLoadInfo) {
return NS_OK;
}
nsIRedirectHistoryEntry* redirectEntry; nsIRedirectHistoryEntry* redirectEntry;
size_t length = topLoadInfo->RedirectChain().Length(); size_t length = topLoadInfo->RedirectChain().Length();
for (size_t i = 0; i < length; i++) { for (size_t i = 0; i < length; i++) {

24
uriloader/exthandler/nsExternalHelperAppService.cpp
View file

@ -625,7 +625,7 @@ nsresult nsExternalHelperAppService::DoContentContentProcessHelper(
channel->GetContentDisposition(&contentDisposition); channel->GetContentDisposition(&contentDisposition);
channel->GetContentDispositionFilename(fileName); channel->GetContentDispositionFilename(fileName);
channel->GetContentDispositionHeader(disp); channel->GetContentDispositionHeader(disp);
loadInfo = channel->GetLoadInfo(); loadInfo = channel->LoadInfo();
nsCOMPtr<nsIFileChannel> fileChan(do_QueryInterface(aRequest)); nsCOMPtr<nsIFileChannel> fileChan(do_QueryInterface(aRequest));
wasFileChannel = fileChan != nullptr; wasFileChannel = fileChan != nullptr;
@ -1978,19 +1978,17 @@ nsExternalAppHandler::OnSaveComplete(nsIBackgroundFileSaver* aSaver,
// Save the redirect information. // Save the redirect information.
nsCOMPtr<nsIChannel> channel = do_QueryInterface(mRequest); nsCOMPtr<nsIChannel> channel = do_QueryInterface(mRequest);
if (channel) { if (channel) {
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
if (loadInfo) { nsresult rv = NS_OK;
nsresult rv = NS_OK; nsCOMPtr<nsIMutableArray> redirectChain =
nsCOMPtr<nsIMutableArray> redirectChain = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
do_CreateInstance(NS_ARRAY_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_SUCCESS(rv, rv); LOG(("nsExternalAppHandler: Got %zu redirects\n",
LOG(("nsExternalAppHandler: Got %zu redirects\n", loadInfo->RedirectChain().Length()));
loadInfo->RedirectChain().Length())); for (nsIRedirectHistoryEntry* entry : loadInfo->RedirectChain()) {
for (nsIRedirectHistoryEntry* entry : loadInfo->RedirectChain()) { redirectChain->AppendElement(entry);
redirectChain->AppendElement(entry);
}
mRedirects = redirectChain;
} }
mRedirects = redirectChain;
} }
if (NS_FAILED(aStatus)) { if (NS_FAILED(aStatus)) {

12
uriloader/prefetch/nsPrefetchService.cpp
View file

@ -188,13 +188,11 @@ nsPrefetchNode::OnStartRequest(nsIRequest *aRequest, nsISupports *aContext) {
// if the load is cross origin without CORS, or the CORS access is rejected, // if the load is cross origin without CORS, or the CORS access is rejected,
// always fire load event to avoid leaking site information. // always fire load event to avoid leaking site information.
nsCOMPtr<nsILoadInfo> loadInfo = httpChannel->GetLoadInfo(); nsCOMPtr<nsILoadInfo> loadInfo = httpChannel->LoadInfo();
if (loadInfo) { mShouldFireLoadEvent =
mShouldFireLoadEvent = loadInfo->GetTainting() == LoadTainting::Opaque ||
loadInfo->GetTainting() == LoadTainting::Opaque || (loadInfo->GetTainting() == LoadTainting::CORS &&
(loadInfo->GetTainting() == LoadTainting::CORS && (NS_FAILED(httpChannel->GetStatus(&rv)) || NS_FAILED(rv)));
(NS_FAILED(httpChannel->GetStatus(&rv)) || NS_FAILED(rv)));
}
// no need to prefetch http error page // no need to prefetch http error page
bool requestSucceeded; bool requestSucceeded;