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;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (!loadInfo || loadInfo->GetExternalContentPolicyType() !=
nsIContentPolicy::TYPE_SUBDOCUMENT) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo->GetExternalContentPolicyType() !=
nsIContentPolicy::TYPE_SUBDOCUMENT) {
return;
}
@ -302,8 +302,8 @@ nsresult nsScriptSecurityManager::GetChannelResultPrincipal(
MOZ_ASSERT(aChannel, "Must have channel!");
// Check whether we have an nsILoadInfo that says what we should do.
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (loadInfo && loadInfo->GetForceInheritPrincipalOverruleOwner()) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo->GetForceInheritPrincipalOverruleOwner()) {
nsCOMPtr<nsIPrincipal> principalToInherit =
loadInfo->FindPrincipalToInherit(aChannel);
principalToInherit.forget(aPrincipal);
@ -319,53 +319,51 @@ nsresult nsScriptSecurityManager::GetChannelResultPrincipal(
}
}
if (loadInfo) {
if (!aIgnoreSandboxing && loadInfo->GetLoadingSandboxed()) {
nsCOMPtr<nsIPrincipal> sandboxedLoadingPrincipal =
loadInfo->GetSandboxedLoadingPrincipal();
MOZ_ASSERT(sandboxedLoadingPrincipal);
InheritAndSetCSPOnPrincipalIfNeeded(aChannel, sandboxedLoadingPrincipal);
sandboxedLoadingPrincipal.forget(aPrincipal);
return NS_OK;
}
if (!aIgnoreSandboxing && loadInfo->GetLoadingSandboxed()) {
nsCOMPtr<nsIPrincipal> sandboxedLoadingPrincipal =
loadInfo->GetSandboxedLoadingPrincipal();
MOZ_ASSERT(sandboxedLoadingPrincipal);
InheritAndSetCSPOnPrincipalIfNeeded(aChannel, sandboxedLoadingPrincipal);
sandboxedLoadingPrincipal.forget(aPrincipal);
return NS_OK;
}
bool forceInherit = loadInfo->GetForceInheritPrincipal();
if (aIgnoreSandboxing && !forceInherit) {
// Check if SEC_FORCE_INHERIT_PRINCIPAL was dropped because of
// sandboxing:
if (loadInfo->GetLoadingSandboxed() &&
loadInfo->GetForceInheritPrincipalDropped()) {
forceInherit = true;
}
bool forceInherit = loadInfo->GetForceInheritPrincipal();
if (aIgnoreSandboxing && !forceInherit) {
// Check if SEC_FORCE_INHERIT_PRINCIPAL was dropped because of
// sandboxing:
if (loadInfo->GetLoadingSandboxed() &&
loadInfo->GetForceInheritPrincipalDropped()) {
forceInherit = true;
}
if (forceInherit) {
nsCOMPtr<nsIPrincipal> principalToInherit =
loadInfo->FindPrincipalToInherit(aChannel);
}
if (forceInherit) {
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);
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);
NS_ENSURE_SUCCESS(rv, rv);
@ -395,20 +393,14 @@ nsScriptSecurityManager::GetChannelURIPrincipal(nsIChannel* aChannel,
nsresult rv = NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo;
aChannel->GetLoadInfo(getter_AddRefs(loadInfo));
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
// Inherit the origin attributes from loadInfo.
// If this is a top-level document load, the origin attributes of the
// loadInfo will be set from nsDocShell::DoURILoad.
// For subresource loading, the origin attributes of the loadInfo is from
// its loadingPrincipal.
OriginAttributes attrs;
// For addons loadInfo might be null.
if (loadInfo) {
attrs = loadInfo->GetOriginAttributes();
}
OriginAttributes attrs = loadInfo->GetOriginAttributes();
nsCOMPtr<nsIPrincipal> prin =
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));
}
nsCOMPtr<nsILoadInfo> loadInfo = chan->GetLoadInfo();
if (loadInfo) {
loadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI));
}
nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
loadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI));
}
MOZ_ASSERT(triggeringPrincipal, "Need a valid triggeringPrincipal");
@ -6850,7 +6848,7 @@ nsresult nsDocShell::EndPageLoad(nsIWebProgress* aProgress,
// can increment counts from the search engine
MaybeNotifyKeywordSearchLoading(keywordProviderName, keywordAsSent);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
MOZ_ASSERT(loadInfo, "loadInfo is required on all channels");
nsCOMPtr<nsIPrincipal> triggeringPrincipal =
loadInfo->TriggeringPrincipal();
@ -6902,10 +6900,8 @@ nsresult nsDocShell::EndPageLoad(nsIWebProgress* aProgress,
}
} else if (url && NS_SUCCEEDED(aStatus)) {
// If we have a host
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (loadInfo) {
PredictorLearnRedirect(url, aChannel, loadInfo->GetOriginAttributes());
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
PredictorLearnRedirect(url, aChannel, loadInfo->GetOriginAttributes());
}
return NS_OK;
@ -9829,8 +9825,7 @@ nsresult nsDocShell::DoURILoad(nsDocShellLoadState* aLoadState,
GetIsMozBrowser());
if (isTopLevelDoc && GetDocument() && GetDocument()->GetChannel()) {
nsCOMPtr<nsILoadInfo> oldLoadInfo =
GetDocument()->GetChannel()->GetLoadInfo();
nsCOMPtr<nsILoadInfo> oldLoadInfo = GetDocument()->GetChannel()->LoadInfo();
loadInfo->SetOpenerPolicy(oldLoadInfo->GetOpenerPolicy());
}
@ -11293,29 +11288,27 @@ nsresult nsDocShell::AddToSessionHistory(nsIURI* aURI, nsIChannel* aChannel,
discardLayoutState = ShouldDiscardLayoutState(httpChannel);
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (loadInfo) {
if (!triggeringPrincipal) {
triggeringPrincipal = loadInfo->TriggeringPrincipal();
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (!triggeringPrincipal) {
triggeringPrincipal = loadInfo->TriggeringPrincipal();
}
loadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI));
loadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI));
// For now keep storing just the principal in the SHEntry.
if (!principalToInherit) {
if (loadInfo->GetLoadingSandboxed()) {
if (loadInfo->LoadingPrincipal()) {
principalToInherit = NullPrincipal::CreateWithInheritedAttributes(
loadInfo->LoadingPrincipal());
} else {
// get the OriginAttributes
OriginAttributes attrs;
loadInfo->GetOriginAttributes(&attrs);
principalToInherit = NullPrincipal::Create(attrs);
}
// For now keep storing just the principal in the SHEntry.
if (!principalToInherit) {
if (loadInfo->GetLoadingSandboxed()) {
if (loadInfo->LoadingPrincipal()) {
principalToInherit = NullPrincipal::CreateWithInheritedAttributes(
loadInfo->LoadingPrincipal());
} 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);
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
if (NS_WARN_IF(!loadInfo)) {
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
loadState->SetTriggeringPrincipal(loadInfo->TriggeringPrincipal());
// Return the newly created loadState.

25
dom/base/Document.cpp
View file

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

10
dom/base/nsContentUtils.cpp
View file

@ -8122,10 +8122,7 @@ bool nsContentUtils::IsNonSubresourceRequest(nsIChannel* aChannel) {
return true;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (!loadInfo) {
return false;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
nsContentPolicyType type = loadInfo->InternalContentPolicyType();
return IsNonSubresourceInternalPolicyType(type);
}
@ -9810,10 +9807,7 @@ nsContentUtils::LookupCustomElementDefinition(Document* aDoc, nsAtom* aNameAtom,
rv = aChannel->GetReferrer(getter_AddRefs(referrer));
NS_ENSURE_SUCCESS(rv, false);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (!loadInfo) {
return false;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
nsCOMPtr<nsIPrincipal> triggeringPrincipal = loadInfo->TriggeringPrincipal();
// 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) {
loadInfo = channel->GetLoadInfo();
loadInfo = channel->LoadInfo();
}
}

5
dom/base/nsGlobalWindowOuter.cpp
View file

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

2
dom/base/nsNodeInfoManager.cpp
View file

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

3
dom/base/nsObjectLoadingContent.cpp
View file

@ -2412,8 +2412,7 @@ nsresult nsObjectLoadingContent::OpenChannel() {
nsIRequest::LOAD_HTML_OBJECT_DATA);
NS_ENSURE_SUCCESS(rv, rv);
if (inherit) {
nsCOMPtr<nsILoadInfo> loadinfo = chan->GetLoadInfo();
NS_ENSURE_STATE(loadinfo);
nsCOMPtr<nsILoadInfo> loadinfo = chan->LoadInfo();
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"),
false);
MOZ_ASSERT(NS_SUCCEEDED(rv));
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (loadInfo) {
nsCOMPtr<nsIURI> loaderUri;
loadInfo->TriggeringPrincipal()->GetURI(getter_AddRefs(loaderUri));
if (loaderUri) {
rv = http->SetReferrerWithPolicy(loaderUri, aReferrerPolicy);
MOZ_ASSERT(NS_SUCCEEDED(rv));
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
nsCOMPtr<nsIURI> loaderUri;
loadInfo->TriggeringPrincipal()->GetURI(getter_AddRefs(loaderUri));
if (loaderUri) {
rv = http->SetReferrerWithPolicy(loaderUri, aReferrerPolicy);
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 {
MOZ_ASSERT(NS_IsMainThread());
nsCOMPtr<nsILoadInfo> oldLoadInfo;
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);
nsresult rv = nsContentUtils::CheckSameOrigin(aOldChannel, aNewChannel);
if (NS_WARN_IF(NS_FAILED(rv) && rv != NS_ERROR_DOM_BAD_URI)) {
return rv;
}
nsCOMPtr<nsILoadInfo> oldLoadInfo = aOldChannel->LoadInfo();
nsCOMPtr<nsILoadInfo> newLoadInfo = aNewChannel->LoadInfo();
UniquePtr<ClientSource> reservedClient =
oldLoadInfo->TakeReservedClientSource();
@ -181,8 +176,7 @@ nsresult AddClientChannelHelper(nsIChannel* aChannel,
MOZ_DIAGNOSTIC_ASSERT(reservedClientInfo.isNothing() ||
initialClientInfo.isNothing());
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
NS_ENSURE_TRUE(loadInfo, NS_ERROR_FAILURE);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
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);
if (mCSPEventListener) {
nsCOMPtr<nsILoadInfo> loadInfo = chan->GetLoadInfo();
if (NS_WARN_IF(!loadInfo)) {
return NS_ERROR_UNEXPECTED;
}
nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
rv = loadInfo->SetCspEventListener(mCSPEventListener);
NS_ENSURE_SUCCESS(rv, rv);
}
@ -588,7 +584,7 @@ nsresult FetchDriver::HttpFetch(
// If request’s referrer policy is the empty string,
// then set request’s referrer policy to the user-set default policy.
if (mRequest->ReferrerPolicy_() == ReferrerPolicy::_empty) {
nsCOMPtr<nsILoadInfo> loadInfo = httpChan->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = httpChan->LoadInfo();
bool isPrivate = loadInfo->GetOriginAttributes().mPrivateBrowsingId > 0;
net::ReferrerPolicy referrerPolicy = static_cast<net::ReferrerPolicy>(
NS_GetDefaultReferrerPolicy(isPrivate));
@ -673,10 +669,8 @@ nsresult FetchDriver::HttpFetch(
if (mRequest->Mode() == RequestMode::Cors) {
AutoTArray<nsCString, 5> unsafeHeaders;
mRequest->Headers()->GetUnsafeHeaders(unsafeHeaders);
nsCOMPtr<nsILoadInfo> loadInfo = chan->GetLoadInfo();
if (loadInfo) {
loadInfo->SetCorsPreflightInfo(unsafeHeaders, false);
}
nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
loadInfo->SetCorsPreflightInfo(unsafeHeaders, false);
}
if (mIsTrackingFetch && nsContentUtils::IsTailingEnabled() && cos) {
@ -981,13 +975,7 @@ FetchDriver::OnStartRequest(nsIRequest* aRequest, nsISupports* aContext) {
return rv;
}
nsCOMPtr<nsILoadInfo> loadInfo;
rv = channel->GetLoadInfo(getter_AddRefs(loadInfo));
if (NS_WARN_IF(NS_FAILED(rv))) {
FailWithNetworkError(rv);
return rv;
}
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
// 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
// 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) {
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
if (loadInfo) {
// The function simply returns NS_OK, so we ignore the return value.
Unused << loadInfo->SetOriginAttributes(
triggeringPrincipal->OriginAttributesRef());
}
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
// The function simply returns NS_OK, so we ignore the return value.
Unused << loadInfo->SetOriginAttributes(
triggeringPrincipal->OriginAttributesRef());
}
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;
channel->GetContentType(mimeType);
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
// query the corresponding arguments for the channel loadinfo and pass
// it on to the temporary loadinfo used for content policy checks.
nsCOMPtr<nsINode> requestingNode = domWindow->GetFrameElementInternal();
@ -100,8 +100,8 @@ ImageListener::OnStartRequest(nsIRequest* request, nsISupports* ctxt) {
}
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new net::LoadInfo(
loadingPrincipal, loadInfo ? loadInfo->TriggeringPrincipal() : nullptr,
requestingNode, nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
loadingPrincipal, loadInfo->TriggeringPrincipal(), requestingNode,
nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
nsIContentPolicy::TYPE_INTERNAL_IMAGE);
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,
nsIContentPolicy::TYPE_OTHER);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
NS_ENSURE_STATE(loadInfo);
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
loadInfo->SetPrincipalToInherit(NodePrincipal());
mWyciwygChannel = do_QueryInterface(channel);

7
dom/jsurl/nsJSProtocolHandler.cpp
View file

@ -144,9 +144,8 @@ nsresult nsJSThunk::EvaluateScript(
aChannel->GetOwner(getter_AddRefs(owner));
nsCOMPtr<nsIPrincipal> principal = do_QueryInterface(owner);
if (!principal) {
nsCOMPtr<nsILoadInfo> loadInfo;
aChannel->GetLoadInfo(getter_AddRefs(loadInfo));
if (loadInfo && loadInfo->GetForceInheritPrincipal()) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo->GetForceInheritPrincipal()) {
principal = loadInfo->FindPrincipalToInherit(aChannel);
} else {
// No execution without a principal!
@ -509,7 +508,7 @@ nsJSChannel::AsyncOpen(nsIStreamListener* aListener) {
#ifdef DEBUG
{
nsCOMPtr<nsILoadInfo> loadInfo = nsIChannel::GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = nsIChannel::LoadInfo();
MOZ_ASSERT(!loadInfo || loadInfo->GetSecurityMode() == 0 ||
loadInfo->GetInitialSecurityCheckDone(),
"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);
if (setAttrs) {
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
if (loadInfo) {
// The function simply returns NS_OK, so we ignore the return value.
Unused << loadInfo->SetOriginAttributes(
triggeringPrincipal->OriginAttributesRef());
}
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
// The function simply returns NS_OK, so we ignore the return value.
Unused << loadInfo->SetOriginAttributes(
triggeringPrincipal->OriginAttributesRef());
}
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.
nsCOMPtr<nsILoadInfo> loadInfo;
aResourceChannel->GetLoadInfo(getter_AddRefs(loadInfo));
if (!loadInfo) {
return false;
}
nsCOMPtr<nsILoadInfo> loadInfo = aResourceChannel->LoadInfo();
// TYPE_DOCUMENT loads have no loadingPrincipal.
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;
// Check ShouldProcess with content policy
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
int16_t shouldLoad = nsIContentPolicy::ACCEPT;
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()) {
nsAutoString cspNonce;
element->GetAttribute(NS_LITERAL_STRING("nonce"), cspNonce);
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
loadInfo->SetCspNonce(cspNonce);
}
}
@ -3208,9 +3208,9 @@ nsresult ScriptLoader::VerifySRI(ScriptLoadRequest* aRequest,
rv = NS_ERROR_SRI_CORRUPT;
}
} 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,
("ScriptLoader::OnStreamComplete, required SRI not found"));
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
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
uint64_t innerWindowID = loadInfo ? loadInfo->GetInnerWindowID() : 0;
bool privateWindow =
loadInfo ? !!loadInfo->GetOriginAttributes().mPrivateBrowsingId : false;
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
uint64_t innerWindowID = loadInfo->GetInnerWindowID();
bool privateWindow = !!loadInfo->GetOriginAttributes().mPrivateBrowsingId;
const char16_t* params[] = {u"x-frame-options", u"frame-ancestors"};
CSP_LogLocalizedStr("IgnoringSrcBecauseOfDirective", params,
ArrayLength(params),
@ -252,9 +251,7 @@ static bool ShouldIgnoreFrameOptions(nsIChannel* aChannel,
if (aDocShell) {
nsCOMPtr<nsIWebNavigation> webNav(do_QueryObject(aDocShell));
if (webNav) {
nsCOMPtr<nsILoadInfo> loadInfo = httpChannel->GetLoadInfo();
MOZ_ASSERT(loadInfo);
nsCOMPtr<nsILoadInfo> loadInfo = httpChannel->LoadInfo();
RefPtr<NullPrincipal> principal =
NullPrincipal::CreateWithInheritedAttributes(
loadInfo->TriggeringPrincipal());

3
dom/security/SRICheck.cpp
View file

@ -327,8 +327,7 @@ nsresult SRICheckDataVerifier::Verify(const SRIMetadata& aMetadata,
nsresult rv = Finish();
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
NS_ENSURE_TRUE(loadInfo, NS_ERROR_FAILURE);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
LoadTainting tainting = loadInfo->GetTainting();
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));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = oldChannel->GetLoadInfo();
// if no loadInfo on the channel, nothing for us to do
if (!loadInfo) {
return NS_OK;
}
nsCOMPtr<nsILoadInfo> loadInfo = oldChannel->LoadInfo();
nsCOMPtr<nsICSPEventListener> cspEventListener;
rv = loadInfo->GetCspEventListener(getter_AddRefs(cspEventListener));
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()) {
return true;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (!loadInfo) {
return true;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo->GetExternalContentPolicyType() !=
nsIContentPolicy::TYPE_DOCUMENT) {
return true;
@ -115,10 +112,7 @@ static mozilla::LazyLogModule sCSMLog("CSMLog");
/* static */ bool nsContentSecurityManager::AllowInsecureRedirectToDataURI(
nsIChannel* aNewChannel) {
nsCOMPtr<nsILoadInfo> loadInfo = aNewChannel->GetLoadInfo();
if (!loadInfo) {
return true;
}
nsCOMPtr<nsILoadInfo> loadInfo = aNewChannel->LoadInfo();
if (loadInfo->GetExternalContentPolicyType() !=
nsIContentPolicy::TYPE_SCRIPT) {
return true;
@ -170,11 +164,7 @@ static mozilla::LazyLogModule sCSMLog("CSMLog");
return NS_OK;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (!loadInfo) {
return NS_OK;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
nsContentPolicyType type = loadInfo->GetExternalContentPolicyType();
// 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(
nsIChannel* aChannel, nsCOMPtr<nsIStreamListener>& aInAndOutListener) {
NS_ENSURE_ARG(aChannel);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (!loadInfo) {
MOZ_ASSERT(false,
"channel needs to have loadInfo to perform security checks");
return NS_ERROR_UNEXPECTED;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (MOZ_UNLIKELY(MOZ_LOG_TEST(sCSMLog, LogLevel::Debug))) {
DebugDoContentSecurityCheck(aChannel, loadInfo);
}
@ -844,16 +827,14 @@ NS_IMETHODIMP
nsContentSecurityManager::AsyncOnChannelRedirect(
nsIChannel* aOldChannel, nsIChannel* aNewChannel, uint32_t aRedirFlags,
nsIAsyncVerifyRedirectCallback* aCb) {
nsCOMPtr<nsILoadInfo> loadInfo = aOldChannel->GetLoadInfo();
if (loadInfo) {
nsresult rv = CheckChannel(aNewChannel);
if (NS_SUCCEEDED(rv)) {
rv = CheckFTPSubresourceLoad(aNewChannel);
}
if (NS_FAILED(rv)) {
aOldChannel->Cancel(rv);
return rv;
}
nsCOMPtr<nsILoadInfo> loadInfo = aOldChannel->LoadInfo();
nsresult rv = CheckChannel(aNewChannel);
if (NS_SUCCEEDED(rv)) {
rv = CheckFTPSubresourceLoad(aNewChannel);
}
if (NS_FAILED(rv)) {
aOldChannel->Cancel(rv);
return rv;
}
// Also verify that the redirecting server is allowed to redirect to the
@ -876,7 +857,7 @@ nsContentSecurityManager::AsyncOnChannelRedirect(
const uint32_t flags =
nsIScriptSecurityManager::LOAD_IS_AUTOMATIC_DOCUMENT_REPLACEMENT |
nsIScriptSecurityManager::DISALLOW_SCRIPT;
nsresult rv = nsContentUtils::GetSecurityManager()->CheckLoadURIWithPrincipal(
rv = nsContentUtils::GetSecurityManager()->CheckLoadURIWithPrincipal(
oldPrincipal, newURI, flags);
NS_ENSURE_SUCCESS(rv, rv);
@ -896,9 +877,7 @@ static void AddLoadFlags(nsIRequest* aRequest, nsLoadFlags aNewFlags) {
* if this requesst should not be permitted.
*/
nsresult nsContentSecurityManager::CheckChannel(nsIChannel* aChannel) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
MOZ_ASSERT(loadInfo);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
nsCOMPtr<nsIURI> uri;
nsresult rv = NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri));
NS_ENSURE_SUCCESS(rv, rv);

2
dom/security/nsMixedContentBlocker.cpp
View file

@ -301,7 +301,7 @@ nsMixedContentBlocker::AsyncOnChannelRedirect(
NS_ENSURE_SUCCESS(rv, rv);
// Get the loading Info from the old channel
nsCOMPtr<nsILoadInfo> loadInfo = aOldChannel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = aOldChannel->LoadInfo();
nsCOMPtr<nsIPrincipal> requestingPrincipal = loadInfo->LoadingPrincipal();
// 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));
NS_ENSURE_SUCCESS(rv, rv);
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);
return NS_OK;
}

5
dom/serviceworkers/ServiceWorkerInterceptController.cpp
View file

@ -22,10 +22,7 @@ ServiceWorkerInterceptController::ShouldPrepareForIntercept(
nsIURI* aURI, nsIChannel* aChannel, bool* aShouldIntercept) {
*aShouldIntercept = false;
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (!loadInfo) {
return NS_OK;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
// For subresource requests we base our decision solely on the client's
// 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 resultingClientId;
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
if (loadInfo) {
char buf[NSID_LENGTH];
Maybe<ClientInfo> clientInfo = loadInfo->GetClientInfo();
if (clientInfo.isSome()) {
clientInfo.ref().Id().ToProvidedString(buf);
NS_ConvertASCIItoUTF16 uuid(buf);
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
char buf[NSID_LENGTH];
Maybe<ClientInfo> clientInfo = loadInfo->GetClientInfo();
if (clientInfo.isSome()) {
clientInfo.ref().Id().ToProvidedString(buf);
NS_ConvertASCIItoUTF16 uuid(buf);
// Remove {} and the null terminator
clientId.Assign(Substring(uuid, 1, NSID_LENGTH - 3));
}
// Remove {} and the null terminator
clientId.Assign(Substring(uuid, 1, NSID_LENGTH - 3));
}
// Having an initial or reserved client are mutually exclusive events:
// either an initial client is used upon navigating an about:blank
// iframe, or a new, reserved environment/client is created (e.g.
// upon a top-level navigation). See step 4 of
// https://html.spec.whatwg.org/#process-a-navigate-fetch as well as
// https://github.com/w3c/ServiceWorker/issues/1228#issuecomment-345132444
Maybe<ClientInfo> resulting = loadInfo->GetInitialClientInfo();
// Having an initial or reserved client are mutually exclusive events:
// either an initial client is used upon navigating an about:blank
// iframe, or a new, reserved environment/client is created (e.g.
// upon a top-level navigation). See step 4 of
// https://html.spec.whatwg.org/#process-a-navigate-fetch as well as
// https://github.com/w3c/ServiceWorker/issues/1228#issuecomment-345132444
Maybe<ClientInfo> resulting = loadInfo->GetInitialClientInfo();
if (resulting.isNothing()) {
resulting = loadInfo->GetReservedClientInfo();
} else {
MOZ_ASSERT(loadInfo->GetReservedClientInfo().isNothing());
}
if (resulting.isNothing()) {
resulting = loadInfo->GetReservedClientInfo();
} else {
MOZ_ASSERT(loadInfo->GetReservedClientInfo().isNothing());
}
if (resulting.isSome()) {
resulting.ref().Id().ToProvidedString(buf);
NS_ConvertASCIItoUTF16 uuid(buf);
if (resulting.isSome()) {
resulting.ref().Id().ToProvidedString(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,
@ -1936,12 +1934,7 @@ void ServiceWorkerManager::DispatchFetchEvent(nsIInterceptedChannel* aChannel,
return;
}
nsCOMPtr<nsILoadInfo> loadInfo = internalChannel->GetLoadInfo();
if (NS_WARN_IF(!loadInfo)) {
aRv.Throw(NS_ERROR_UNEXPECTED);
return;
}
nsCOMPtr<nsILoadInfo> loadInfo = internalChannel->LoadInfo();
RefPtr<ServiceWorkerInfo> serviceWorker;
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);
if (cspEventListener) {
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
if (NS_WARN_IF(!loadInfo)) {
return NS_ERROR_UNEXPECTED;
}
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
rv = loadInfo->SetCspEventListener(cspEventListener);
NS_ENSURE_SUCCESS(rv, rv);
}
@ -1156,8 +1152,8 @@ class ScriptLoaderRunnable final : public nsIRunnable, public nsINamed {
aLoadInfo.mURL.Assign(NS_ConvertUTF8toUTF16(filename));
}
nsCOMPtr<nsILoadInfo> chanLoadInfo = channel->GetLoadInfo();
if (chanLoadInfo && chanLoadInfo->GetEnforceSRI()) {
nsCOMPtr<nsILoadInfo> chanLoadInfo = channel->LoadInfo();
if (chanLoadInfo->GetEnforceSRI()) {
// importScripts() and the Worker constructor do not support integrity
// metadata
// (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;
}
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
MOZ_ASSERT(loadInfo);
if (!loadInfo) {
return false;
}
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
return loadInfo->GetTainting() == LoadTainting::CORS;
}
@ -1478,11 +1472,8 @@ void XMLHttpRequestMainThread::SetOriginAttributes(
OriginAttributes attrs(aAttrs);
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
MOZ_ASSERT(loadInfo);
if (loadInfo) {
loadInfo->SetOriginAttributes(attrs);
}
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
loadInfo->SetOriginAttributes(attrs);
}
/*
@ -1989,12 +1980,9 @@ XMLHttpRequestMainThread::OnStartRequest(nsIRequest* request,
mResponseXML->ForceEnableXULXBL();
}
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
MOZ_ASSERT(loadInfo);
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
bool isCrossSite = false;
if (loadInfo) {
isCrossSite = loadInfo->GetTainting() != LoadTainting::Basic;
}
isCrossSite = loadInfo->GetTainting() != LoadTainting::Basic;
if (isCrossSite) {
nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(mResponseXML);
@ -2365,11 +2353,7 @@ nsresult XMLHttpRequestMainThread::CreateChannel() {
NS_ENSURE_SUCCESS(rv, rv);
if (mCSPEventListener) {
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
if (NS_WARN_IF(!loadInfo)) {
return NS_ERROR_UNEXPECTED;
}
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
rv = loadInfo->SetCspEventListener(mCSPEventListener);
NS_ENSURE_SUCCESS(rv, rv);
}
@ -2525,10 +2509,8 @@ nsresult XMLHttpRequestMainThread::InitiateFetch(
// .withCredentials can be called after open() is called.
// Not doing this for privileged system XHRs since those don't use CORS.
if (!IsSystemXHR() && !mIsAnon && mFlagACwithCredentials) {
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
if (loadInfo) {
static_cast<net::LoadInfo*>(loadInfo.get())->SetIncludeCookiesSecFlag();
}
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
static_cast<net::LoadInfo*>(loadInfo.get())->SetIncludeCookiesSecFlag();
}
// We never let XHR be blocked by head CSS/JS loads to avoid potential
@ -2591,11 +2573,9 @@ nsresult XMLHttpRequestMainThread::InitiateFetch(
if (!IsSystemXHR()) {
nsTArray<nsCString> CORSUnsafeHeaders;
mAuthorRequestHeaders.GetCORSUnsafeHeaders(CORSUnsafeHeaders);
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
if (loadInfo) {
loadInfo->SetCorsPreflightInfo(CORSUnsafeHeaders,
mFlagHadUploadListenersOnSend);
}
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
loadInfo->SetCorsPreflightInfo(CORSUnsafeHeaders,
mFlagHadUploadListenersOnSend);
}
// 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
// favicon loading from XUL will use the correct originAttributes.
nsCOMPtr<nsILoadInfo> loadInfo = (*aResult)->GetLoadInfo();
if (loadInfo) {
rv = loadInfo->SetOriginAttributes(
aTriggeringPrincipal->OriginAttributesRef());
}
nsCOMPtr<nsILoadInfo> loadInfo = (*aResult)->LoadInfo();
rv = loadInfo->SetOriginAttributes(
aTriggeringPrincipal->OriginAttributesRef());
}
} else {
// either we are loading something inside a document, in which case
@ -858,10 +856,8 @@ static nsresult NewImageChannel(
}
attrs.mPrivateBrowsingId = aRespectPrivacy ? 1 : 0;
nsCOMPtr<nsILoadInfo> loadInfo = (*aResult)->GetLoadInfo();
if (loadInfo) {
rv = loadInfo->SetOriginAttributes(attrs);
}
nsCOMPtr<nsILoadInfo> loadInfo = (*aResult)->LoadInfo();
rv = loadInfo->SetOriginAttributes(attrs);
}
if (NS_FAILED(rv)) {
@ -2374,12 +2370,9 @@ nsresult imgLoader::LoadImageWithChannel(nsIChannel* channel,
nsCOMPtr<Document> doc = do_QueryInterface(aCX);
NS_ENSURE_TRUE(channel, NS_ERROR_FAILURE);
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
OriginAttributes attrs;
if (loadInfo) {
attrs = loadInfo->GetOriginAttributes();
}
OriginAttributes attrs = loadInfo->GetOriginAttributes();
nsresult 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
// type/principal/etc
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
// if there is a loadInfo, use the right contentType, otherwise
// default to the internal image type
nsContentPolicyType policyType =
loadInfo ? loadInfo->InternalContentPolicyType()
: nsIContentPolicy::TYPE_INTERNAL_IMAGE;
nsContentPolicyType policyType = loadInfo->InternalContentPolicyType();
if (ValidateEntry(entry, uri, nullptr, nullptr, RP_Unset, nullptr,
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
// from the network. Do not pollute mHadInsecureRedirect in case of such an
// internal redirect.
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
bool upgradeInsecureRequests =
loadInfo ? loadInfo->GetUpgradeInsecureRequests() ||
loadInfo->GetBrowserUpgradeInsecureRequests()

8
layout/style/Loader.cpp
View file

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

6
netwerk/base/Predictor.cpp
View file

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

4
netwerk/base/nsAsyncRedirectVerifyHelper.cpp
View file

@ -74,8 +74,8 @@ nsresult nsAsyncRedirectVerifyHelper::Init(
if (!(flags & (nsIChannelEventSink::REDIRECT_INTERNAL |
nsIChannelEventSink::REDIRECT_STS_UPGRADE))) {
nsCOMPtr<nsILoadInfo> loadInfo = oldChan->GetLoadInfo();
if (loadInfo && loadInfo->GetDontFollowRedirects()) {
nsCOMPtr<nsILoadInfo> loadInfo = oldChan->LoadInfo();
if (loadInfo->GetDontFollowRedirects()) {
ExplicitCallback(NS_BINDING_ABORTED);
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
// and set it on the new channel
if (mLoadInfo) {
nsSecurityFlags secFlags = mLoadInfo->GetSecurityFlags() &
~nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL;
nsCOMPtr<nsILoadInfo> newLoadInfo =
static_cast<mozilla::net::LoadInfo *>(mLoadInfo.get())
->CloneWithNewSecFlags(secFlags);
nsSecurityFlags secFlags =
mLoadInfo->GetSecurityFlags() & ~nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL;
nsCOMPtr<nsILoadInfo> newLoadInfo =
static_cast<mozilla::net::LoadInfo *>(mLoadInfo.get())
->CloneWithNewSecFlags(secFlags);
nsCOMPtr<nsIPrincipal> uriPrincipal;
nsIScriptSecurityManager *sm = nsContentUtils::GetSecurityManager();
sm->GetChannelURIPrincipal(this, getter_AddRefs(uriPrincipal));
bool isInternalRedirect =
(redirectFlags & (nsIChannelEventSink::REDIRECT_INTERNAL |
nsIChannelEventSink::REDIRECT_STS_UPGRADE));
nsCOMPtr<nsIPrincipal> uriPrincipal;
nsIScriptSecurityManager *sm = nsContentUtils::GetSecurityManager();
sm->GetChannelURIPrincipal(this, getter_AddRefs(uriPrincipal));
bool isInternalRedirect =
(redirectFlags & (nsIChannelEventSink::REDIRECT_INTERNAL |
nsIChannelEventSink::REDIRECT_STS_UPGRADE));
// nsBaseChannel hst no thing to do with HttpBaseChannel, we would not care
// about referrer and remote address in this case
nsCOMPtr<nsIRedirectHistoryEntry> entry =
new nsRedirectHistoryEntry(uriPrincipal, nullptr, EmptyCString());
// nsBaseChannel hst no thing to do with HttpBaseChannel, we would not care
// about referrer and remote address in this case
nsCOMPtr<nsIRedirectHistoryEntry> entry =
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
// either non-null or updated to the redirect target 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
// overwrite it with the whole redirect chain first URI before opening
// the target channel, hence the information would be lost.
// If the protocol handler that created the channel wants to use
// the originalURI of the channel as the principal URI, it has left
// the result principal URI on the load info null.
nsCOMPtr<nsIURI> resultPrincipalURI;
// Ensure the channel's loadInfo's result principal URI so that it's
// either non-null or updated to the redirect target 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
// overwrite it with the whole redirect chain first URI before opening
// the target channel, hence the information would be lost.
// If the protocol handler that created the channel wants to use
// the originalURI of the channel as the principal URI, it has left
// the result principal URI on the load info null.
nsCOMPtr<nsIURI> resultPrincipalURI;
nsCOMPtr<nsILoadInfo> existingLoadInfo = newChannel->GetLoadInfo();
if (existingLoadInfo) {
existingLoadInfo->GetResultPrincipalURI(
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);
nsCOMPtr<nsILoadInfo> existingLoadInfo = newChannel->LoadInfo();
if (existingLoadInfo) {
existingLoadInfo->GetResultPrincipalURI(getter_AddRefs(resultPrincipalURI));
}
if (!resultPrincipalURI) {
newChannel->GetOriginalURI(getter_AddRefs(resultPrincipalURI));
}
newLoadInfo->SetResultPrincipalURI(resultPrincipalURI);
newChannel->SetLoadInfo(newLoadInfo);
// Preserve the privacy bit if it has been overridden
if (mPrivateBrowsingOverriden) {

4
netwerk/base/nsIChannel.idl
View file

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

56
netwerk/base/nsINetworkInterceptController.idl
View file

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

11
netwerk/base/nsIOService.cpp
View file

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

64
netwerk/base/nsNetUtil.cpp
View file

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

19
netwerk/cookie/CookieServiceChild.cpp
View file

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

7
netwerk/cookie/CookieServiceParent.cpp
View file

@ -132,11 +132,8 @@ void CookieServiceParent::TrackCookieLoad(nsIChannel *aChannel) {
nsCOMPtr<nsIURI> uri;
aChannel->GetURI(getter_AddRefs(uri));
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
mozilla::OriginAttributes attrs;
if (loadInfo) {
attrs = loadInfo->GetOriginAttributes();
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
mozilla::OriginAttributes attrs = loadInfo->GetOriginAttributes();
bool isSafeTopLevelNav = NS_IsSafeTopLevelNav(aChannel);
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) {
nsCOMPtr<nsIURI> channelURI;
NS_GetFinalChannelURI(aChannel, getter_AddRefs(channelURI));
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
addonAllowsLoad =
loadInfo && BasePrincipal::Cast(loadInfo->TriggeringPrincipal())
->AddonAllowsLoad(channelURI);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
addonAllowsLoad = BasePrincipal::Cast(loadInfo->TriggeringPrincipal())
->AddonAllowsLoad(channelURI);
}
if (!addonAllowsLoad) {

6
netwerk/ipc/ChannelEventQueue.cpp
View file

@ -186,11 +186,7 @@ bool ChannelEventQueue::MaybeSuspendIfEventsAreSuppressed() {
return false;
}
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
if (!loadInfo) {
return false;
}
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
// Figure out if this is for an XHR, if we haven't done so already.
if (!mHasCheckedForXMLHttpRequest) {
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
// an interim solution we set the LoadInfo here if not
// available on the channel. Bug 1087720
nsCOMPtr<nsILoadInfo> loadInfo = (*result)->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = (*result)->LoadInfo();
if (aLoadInfo != loadInfo) {
if (loadInfo) {
NS_ASSERTION(false,
"nsIAboutModule->newChannel(aURI, aLoadInfo) needs to "
"set LoadInfo");
const char16_t *params[] = {
u"nsIAboutModule->newChannel(aURI)",
u"nsIAboutModule->newChannel(aURI, aLoadInfo)"};
nsContentUtils::ReportToConsole(
nsIScriptError::warningFlag,
NS_LITERAL_CSTRING("Security by Default"),
nullptr, // aDocument
nsContentUtils::eNECKO_PROPERTIES, "APIDeprecationWarning",
params, mozilla::ArrayLength(params));
}
NS_ASSERTION(false,
"nsIAboutModule->newChannel(aURI, aLoadInfo) needs to "
"set LoadInfo");
const char16_t *params[] = {
u"nsIAboutModule->newChannel(aURI)",
u"nsIAboutModule->newChannel(aURI, aLoadInfo)"};
nsContentUtils::ReportToConsole(
nsIScriptError::warningFlag,
NS_LITERAL_CSTRING("Security by Default"),
nullptr, // aDocument
nsContentUtils::eNECKO_PROPERTIES, "APIDeprecationWarning", params,
mozilla::ArrayLength(params));
(*result)->SetLoadInfo(aLoadInfo);
}

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

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

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

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

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

@ -32,11 +32,7 @@ namespace net {
nsresult topWindowURIResult =
httpChannelInternal->GetTopWindowURI(getter_AddRefs(topWindowURI));
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (!loadInfo) {
return false;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
OptionalLoadInfoArgs 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;
}
nsCOMPtr<nsILoadInfo> loadInfo = http->GetLoadInfo();
if (loadInfo && loadInfo->GetServiceWorkerTaintingSynthesized()) {
nsCOMPtr<nsILoadInfo> loadInfo = http->LoadInfo();
if (loadInfo->GetServiceWorkerTaintingSynthesized()) {
// For synthesized responses, we don't need to perform any checks.
// Note: This would be unsafe if we ever changed our behavior to allow
// service workers to intercept CORS preflights.
@ -842,14 +842,7 @@ bool CheckUpgradeInsecureRequestsPreventsCORS(
return false;
}
nsCOMPtr<nsILoadInfo> loadInfo;
rv = aChannel->GetLoadInfo(getter_AddRefs(loadInfo));
NS_ENSURE_SUCCESS(rv, false);
if (!loadInfo) {
return false;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
// lets see if the loadInfo indicates that the request will
// be upgraded before fetching any data from the netwerk.
return loadInfo->GetUpgradeInsecureRequests() ||
@ -865,7 +858,7 @@ nsresult nsCORSListenerProxy::UpdateChannel(nsIChannel* aChannel,
rv = aChannel->GetOriginalURI(getter_AddRefs(originalURI));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
// exempt data URIs from the same origin check.
if (aAllowDataURI == DataURIHandling::Allow && originalURI == uri) {
@ -875,7 +868,7 @@ nsresult nsCORSListenerProxy::UpdateChannel(nsIChannel* aChannel,
if (dataScheme) {
return NS_OK;
}
if (loadInfo && loadInfo->GetAboutBlankInherits() && NS_IsAboutBlank(uri)) {
if (loadInfo->GetAboutBlankInherits() && NS_IsAboutBlank(uri)) {
return NS_OK;
}
}
@ -1001,9 +994,8 @@ nsresult nsCORSListenerProxy::CheckPreflightNeeded(nsIChannel* aChannel,
UpdateType aUpdateType) {
// If this caller isn't using AsyncOpen, or if this *is* a preflight channel,
// then we shouldn't initiate preflight for this channel.
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (!loadInfo ||
loadInfo->GetSecurityMode() !=
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo->GetSecurityMode() !=
nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS ||
loadInfo->GetIsPreflight()) {
return NS_OK;
@ -1223,7 +1215,7 @@ nsCORSPreflightListener::OnStartRequest(nsIRequest* aRequest,
#ifdef DEBUG
{
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());
}
#endif
@ -1398,13 +1390,7 @@ nsresult nsCORSListenerProxy::StartCORSPreflight(
nsresult rv = NS_GetFinalChannelURI(aRequestChannel, getter_AddRefs(uri));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> originalLoadInfo = aRequestChannel->GetLoadInfo();
MOZ_ASSERT(originalLoadInfo,
"can not perform CORS preflight without a loadInfo");
if (!originalLoadInfo) {
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsILoadInfo> originalLoadInfo = aRequestChannel->LoadInfo();
MOZ_ASSERT(originalLoadInfo->GetSecurityMode() ==
nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS,
"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<nsILoadInfo> loadInfo;
chan->GetLoadInfo(getter_AddRefs(loadInfo));
nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
// We will treat loads w/o loadInfo as a top level document.
bool topDoc = true;
bool xhr = false;
bool nonWebContent = false;
if (loadInfo) {
if (loadInfo->GetExternalContentPolicyType() !=
nsIContentPolicy::TYPE_DOCUMENT) {
topDoc = false;
}
if (loadInfo->GetExternalContentPolicyType() !=
nsIContentPolicy::TYPE_DOCUMENT) {
topDoc = false;
}
if (!topDoc) {
nsCOMPtr<nsIPrincipal> triggeringPrinc = loadInfo->TriggeringPrincipal();
if (nsContentUtils::IsSystemPrincipal(triggeringPrinc)) {
nonWebContent = true;
if (!topDoc) {
nsCOMPtr<nsIPrincipal> triggeringPrinc = loadInfo->TriggeringPrincipal();
if (nsContentUtils::IsSystemPrincipal(triggeringPrinc)) {
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() ==
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 (!NS_SecurityCompareURIs(topURI, mURI, true)) {
mCrossOrigin = true;
}
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);
nsCOMPtr<nsILoadInfo> channelLoadInfo = mChannel->GetLoadInfo();
if (!channelLoadInfo) {
return NS_OK;
}
nsCOMPtr<nsILoadInfo> channelLoadInfo = mChannel->LoadInfo();
nsCOMPtr<nsIURI> channelResultPrincipalURI;
rv = channelLoadInfo->GetResultPrincipalURI(
getter_AddRefs(channelResultPrincipalURI));
@ -290,21 +286,11 @@ nsViewSourceChannel::GetURI(nsIURI **aURI) {
NS_IMETHODIMP
nsViewSourceChannel::Open(nsIInputStream **aStream) {
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);
}
NS_IMETHODIMP
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
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();
}
nsCOMPtr<nsILoadInfo> loadInfo = chan->GetLoadInfo();
if (loadInfo) {
rv = loadInfo->SetPrincipalToInherit(principalToInherit);
}
nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
rv = loadInfo->SetPrincipalToInherit(principalToInherit);
if (NS_FAILED(rv)) {
if (!SendCancelEarly(rv)) {
return IPC_FAIL_NO_REASON(this);
@ -212,7 +210,7 @@ mozilla::ipc::IPCResult WyciwygChannelParent::RecvAsyncOpen(
return IPC_OK();
}
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
rv = mChannel->AsyncOpen(this);
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,
nsIURI* aURI) {
nsCOMPtr<nsILoadInfo> channelLoadInfo = aChannel->GetLoadInfo();
if (!channelLoadInfo) {
return false;
}
nsCOMPtr<nsILoadInfo> channelLoadInfo = aChannel->LoadInfo();
// loadingPrincipal is used here to ensure we are loading into an
// addon principal. This allows an addon, with explicit permission, to
// 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.
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
nsContentPolicyType contentPolicyType =
loadInfo ? loadInfo->GetExternalContentPolicyType()
: nsIContentPolicy::TYPE_INVALID;
loadInfo->GetExternalContentPolicyType();
if (contentPolicyType != nsIContentPolicy::TYPE_DOCUMENT &&
contentPolicyType != nsIContentPolicy::TYPE_SUBDOCUMENT) {

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

@ -271,10 +271,7 @@ OCSPRequest::Run() {
attrs.mFirstPartyDomain = mOriginAttributes.mFirstPartyDomain;
attrs.mPrivateBrowsingId = mOriginAttributes.mPrivateBrowsingId;
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
if (!loadInfo) {
return NotifyDone(NS_ERROR_FAILURE, lock);
}
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
rv = loadInfo->SetOriginAttributes(attrs);
if (NS_FAILED(rv)) {
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),
channelURI);
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (!loadInfo) {
LOG(("No loadInfo, bail out early"));
return true;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
// 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
// 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
// if necessary.
void ExtensionPolicyService::CheckRequest(nsIChannel* aChannel) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (!loadInfo) {
return;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
auto loadType = loadInfo->GetExternalContentPolicyType();
if (loadType != nsIContentPolicy::TYPE_DOCUMENT &&
loadType != nsIContentPolicy::TYPE_SUBDOCUMENT) {

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

@ -745,12 +745,7 @@ bool WindowShouldMatchActiveTab(nsPIDOMWindowOuter* aWin) {
return false;
}
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
if (!loadInfo) {
return false;
}
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
if (!loadInfo->GetOriginalFrameSrcLoad()) {
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 {
nsCOMPtr<nsIChannel> chan = MaybeChannel();
if (chan) {
return chan->GetLoadInfo();
return chan->LoadInfo();
}
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),
NS_LITERAL_CSTRING(FAVICON_DEFAULT_URL));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = aOriginalChannel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = aOriginalChannel->LoadInfo();
rv = NS_NewChannelInternal(aChannel, defaultIconURI, loadInfo);
NS_ENSURE_SUCCESS(rv, rv);
Unused << (*aChannel)->SetContentType(
@ -132,7 +132,7 @@ class faviconAsyncLoader : public AsyncStatementCallback {
// Ensure we'll break possible cycles with the listener.
auto cleanup = MakeScopeExit([&]() { mListener = nullptr; });
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
nsCOMPtr<nsIEventTarget> target =
nsContentUtils::GetEventTargetByLoadInfo(loadInfo, TaskCategory::Other);
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));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
if (loadInfo) {
mozilla::OriginAttributes attrs;
attrs.mFirstPartyDomain.AssignLiteral(
NECKO_SAFEBROWSING_FIRST_PARTY_DOMAIN);
loadInfo->SetOriginAttributes(attrs);
}
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
mozilla::OriginAttributes attrs;
attrs.mFirstPartyDomain.AssignLiteral(NECKO_SAFEBROWSING_FIRST_PARTY_DOMAIN);
loadInfo->SetOriginAttributes(attrs);
nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(mChannel, &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);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsILoadInfo> loadInfo = reportChannel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = reportChannel->LoadInfo();
mozilla::OriginAttributes attrs;
attrs.mFirstPartyDomain.AssignLiteral(NECKO_SAFEBROWSING_FIRST_PARTY_DOMAIN);
if (loadInfo) {
loadInfo->SetOriginAttributes(attrs);
}
loadInfo->SetOriginAttributes(attrs);
nsCOMPtr<nsIUploadChannel> uploadChannel(do_QueryInterface(reportChannel));
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);
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->GetLoadInfo();
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
mozilla::OriginAttributes attrs;
attrs.mFirstPartyDomain.AssignLiteral(NECKO_SAFEBROWSING_FIRST_PARTY_DOMAIN);
if (loadInfo) {
loadInfo->SetOriginAttributes(attrs);
}
loadInfo->SetOriginAttributes(attrs);
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;
rv = topUri->Equals(uri, &isTopUri);
if (NS_SUCCEEDED(rv) && !isTopUri) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
if (loadInfo && loadInfo->RedirectChain().Length()) {
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
if (loadInfo->RedirectChain().Length()) {
AddThreatSourceFromRedirectEntry(aHit, loadInfo->RedirectChain()[0],
ThreatHit_ThreatSourceType_TAB_RESOURCE);
}
@ -674,11 +674,7 @@ static nsresult AddTabThreatSources(ThreatHit& aHit, nsIChannel* aChannel) {
Unused << NS_WARN_IF(NS_FAILED(rv));
// Set tab_redirect threat sources if there's any
nsCOMPtr<nsILoadInfo> topLoadInfo = topChannel->GetLoadInfo();
if (!topLoadInfo) {
return NS_OK;
}
nsCOMPtr<nsILoadInfo> topLoadInfo = topChannel->LoadInfo();
nsIRedirectHistoryEntry* redirectEntry;
size_t length = topLoadInfo->RedirectChain().Length();
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->GetContentDispositionFilename(fileName);
channel->GetContentDispositionHeader(disp);
loadInfo = channel->GetLoadInfo();
loadInfo = channel->LoadInfo();
nsCOMPtr<nsIFileChannel> fileChan(do_QueryInterface(aRequest));
wasFileChannel = fileChan != nullptr;
@ -1978,19 +1978,17 @@ nsExternalAppHandler::OnSaveComplete(nsIBackgroundFileSaver* aSaver,
// Save the redirect information.
nsCOMPtr<nsIChannel> channel = do_QueryInterface(mRequest);
if (channel) {
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
if (loadInfo) {
nsresult rv = NS_OK;
nsCOMPtr<nsIMutableArray> redirectChain =
do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
LOG(("nsExternalAppHandler: Got %zu redirects\n",
loadInfo->RedirectChain().Length()));
for (nsIRedirectHistoryEntry* entry : loadInfo->RedirectChain()) {
redirectChain->AppendElement(entry);
}
mRedirects = redirectChain;
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
nsresult rv = NS_OK;
nsCOMPtr<nsIMutableArray> redirectChain =
do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
LOG(("nsExternalAppHandler: Got %zu redirects\n",
loadInfo->RedirectChain().Length()));
for (nsIRedirectHistoryEntry* entry : loadInfo->RedirectChain()) {
redirectChain->AppendElement(entry);
}
mRedirects = redirectChain;
}
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,
// always fire load event to avoid leaking site information.
nsCOMPtr<nsILoadInfo> loadInfo = httpChannel->GetLoadInfo();
if (loadInfo) {
mShouldFireLoadEvent =
loadInfo->GetTainting() == LoadTainting::Opaque ||
(loadInfo->GetTainting() == LoadTainting::CORS &&
(NS_FAILED(httpChannel->GetStatus(&rv)) || NS_FAILED(rv)));
}
nsCOMPtr<nsILoadInfo> loadInfo = httpChannel->LoadInfo();
mShouldFireLoadEvent =
loadInfo->GetTainting() == LoadTainting::Opaque ||
(loadInfo->GetTainting() == LoadTainting::CORS &&
(NS_FAILED(httpChannel->GetStatus(&rv)) || NS_FAILED(rv)));
// no need to prefetch http error page
bool requestSucceeded;