corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Bug 1967417 - Create a fallible LoadInfo factory. r=smaug,necko-reviewers,places-reviewers,kershaw" for causing multiple failures.

Browse Source 
This reverts commit b9a9491a35.
This commit is contained in:
Serban Stanca
2025-05-21 16:28:52 +03:00
committed by sstanca@mozilla.com
parent 6d6c598acb
commit 071240c3d9
20 changed files with 75 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
docshell/base/nsDocShell.cpp
View File

@@ -10555,17 +10555,15 @@ nsresult nsDocShell::DoURILoad(nsDocShellLoadState* aLoadState,
mBrowsingContext->SetTriggeringAndInheritPrincipals(
aLoadState->TriggeringPrincipal(), aLoadState->PrincipalToInherit(),
aLoadState->GetLoadIdentifier());
RefPtr<LoadInfo> loadInfo;
if (contentPolicyType == nsIContentPolicy::TYPE_DOCUMENT) {
loadInfo =
new LoadInfo(loadingWindow, uri, aLoadState->TriggeringPrincipal(),
topLevelLoadingContext, securityFlags, sandboxFlags);
} else {
loadInfo = MOZ_TRY(LoadInfo::Create(
loadingPrincipal, aLoadState->TriggeringPrincipal(), loadingNode,
securityFlags, contentPolicyType, Maybe<mozilla::dom::ClientInfo>(),
Maybe<mozilla::dom::ServiceWorkerDescriptor>(), sandboxFlags));
}
RefPtr<LoadInfo> loadInfo =
(contentPolicyType == nsIContentPolicy::TYPE_DOCUMENT)
? new LoadInfo(loadingWindow, uri, aLoadState->TriggeringPrincipal(),
topLevelLoadingContext, securityFlags, sandboxFlags)
: new LoadInfo(loadingPrincipal, aLoadState->TriggeringPrincipal(),
loadingNode, securityFlags, contentPolicyType,
Maybe<mozilla::dom::ClientInfo>(),
Maybe<mozilla::dom::ServiceWorkerDescriptor>(),
sandboxFlags);
RefPtr<WindowContext> context = mBrowsingContext->GetCurrentWindowContext();
if (isAboutBlankLoadOntoInitialAboutBlank) {

18
dom/base/nsObjectLoadingContent.cpp
View File

@@ -613,15 +613,11 @@ bool nsObjectLoadingContent::CheckLoadPolicy(int16_t* aContentPolicy) {
nsContentPolicyType contentPolicyType = GetContentPolicyType();
Result<RefPtr<LoadInfo>, nsresult> maybeLoadInfo =
LoadInfo::Create(doc->NodePrincipal(), // loading principal
nsCOMPtr<nsILoadInfo> secCheckLoadInfo =
new LoadInfo(doc->NodePrincipal(), // loading principal
doc->NodePrincipal(), // triggering principal
el, nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
contentPolicyType);
if (NS_WARN_IF(maybeLoadInfo.isErr())) {
return false;
}
RefPtr<LoadInfo> secCheckLoadInfo = maybeLoadInfo.unwrap();
*aContentPolicy = nsIContentPolicy::ACCEPT;
nsresult rv =
@@ -657,14 +653,10 @@ bool nsObjectLoadingContent::CheckProcessPolicy(int16_t* aContentPolicy) {
return false;
}
Result<RefPtr<LoadInfo>, nsresult> maybeLoadInfo = LoadInfo::Create(
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new LoadInfo(
doc->NodePrincipal(), // loading principal
doc->NodePrincipal(), // triggering principal
el, nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK, objectType);
if (NS_WARN_IF(maybeLoadInfo.isErr())) {
return false;
}
RefPtr<LoadInfo> secCheckLoadInfo = maybeLoadInfo.unwrap();
*aContentPolicy = nsIContentPolicy::ACCEPT;
nsresult rv = NS_CheckContentProcessPolicy(
@@ -1441,7 +1433,7 @@ nsresult nsObjectLoadingContent::OpenChannel() {
}
// --- Create LoadInfo
RefPtr<LoadInfo> loadInfo = MOZ_TRY(LoadInfo::Create(
RefPtr<LoadInfo> loadInfo = new LoadInfo(
/*aLoadingPrincipal = aLoadingContext->NodePrincipal() */ nullptr,
/*aTriggeringPrincipal = aLoadingPrincipal */ nullptr,
/*aLoadingContext = */ el,
@@ -1449,7 +1441,7 @@ nsresult nsObjectLoadingContent::OpenChannel() {
/*aContentPolicyType = */ contentPolicyType,
/*aLoadingClientInfo = */ Nothing(),
/*aController = */ Nothing(),
/*aSandboxFlags = */ sandboxFlags));
/*aSandboxFlags = */ sandboxFlags);
if (inheritAttrs) {
loadInfo->SetPrincipalToInherit(el->NodePrincipal());

8
dom/media/webrtc/jsapi/PeerConnectionImpl.cpp
View File

@@ -4874,14 +4874,10 @@ std::unique_ptr<NrSocketProxyConfig> PeerConnectionImpl::GetProxyConfig()
}
TabId id = browserChild->GetTabId();
Result<RefPtr<net::LoadInfo>, nsresult> maybeLoadInfo = net::LoadInfo::Create(
doc->NodePrincipal(), doc->NodePrincipal(), doc,
nsCOMPtr<nsILoadInfo> loadInfo =
new net::LoadInfo(doc->NodePrincipal(), doc->NodePrincipal(), doc,
nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
nsIContentPolicy::TYPE_PROXIED_WEBRTC_MEDIA);
if (NS_WARN_IF(maybeLoadInfo.isErr())) {
return nullptr;
}
RefPtr<net::LoadInfo> loadInfo = maybeLoadInfo.unwrap();
net::LoadInfoArgs loadInfoArgs;
MOZ_ALWAYS_SUCCEEDS(

4
dom/script/ScriptLoader.cpp
View File

@@ -477,11 +477,11 @@ nsresult ScriptLoader::CheckContentPolicy(nsIScriptElement* aElement,
if (aElement) {
requestingNode = do_QueryInterface(aElement);
}
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = MOZ_TRY(net::LoadInfo::Create(
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new net::LoadInfo(
mDocument->NodePrincipal(), // loading principal
mDocument->NodePrincipal(), // triggering principal
requestingNode, nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
contentPolicyType));
contentPolicyType);
secCheckLoadInfo->SetParserCreatedScript(aElement &&
aElement->GetParserCreated() !=
mozilla::dom::NOT_FROM_PARSER);

6
dom/security/nsContentSecurityUtils.cpp
View File

@@ -2220,14 +2220,10 @@ long nsContentSecurityUtils::ClassifyDownload(
loadingPrincipal = loadInfo->TriggeringPrincipal();
}
// Creating a fake Loadinfo that is just used for the MCB check.
Result<RefPtr<net::LoadInfo>, nsresult> maybeLoadInfo = net::LoadInfo::Create(
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new mozilla::net::LoadInfo(
loadingPrincipal, loadInfo->TriggeringPrincipal(), nullptr,
nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
nsIContentPolicy::TYPE_FETCH);
if (maybeLoadInfo.isErr()) {
return nsITransfer::DOWNLOAD_FORBIDDEN;
}
RefPtr<net::LoadInfo> secCheckLoadInfo = maybeLoadInfo.unwrap();
// Disable HTTPS-Only checks for that loadinfo. This is required because
// otherwise nsMixedContentBlocker::ShouldLoad would assume that the request
// is safe, because HTTPS-Only is handling it.

8
dom/serviceworkers/ServiceWorkerUtils.cpp
View File

@@ -354,18 +354,12 @@ void ServiceWorkerScopeAndScriptAreValid(const ClientInfo& aClientInfo,
// logic here (and the CheckMayLoad calls above) corresponds to the steps of
// the register (https://w3c.github.io/ServiceWorker/#register-algorithm)
// which explicitly throws a SecurityError.
Result<RefPtr<net::LoadInfo>, nsresult> maybeLoadInfo =
net::LoadInfo::Create(
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new mozilla::net::LoadInfo(
principal, // loading principal
principal, // triggering principal
maybeDoc, // loading node
nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
nsIContentPolicy::TYPE_INTERNAL_SERVICE_WORKER, Some(aClientInfo));
if (NS_WARN_IF(maybeLoadInfo.isErr())) {
aResult.ThrowSecurityError("Script URL is not allowed by policy.");
return;
}
RefPtr<net::LoadInfo> secCheckLoadInfo = maybeLoadInfo.unwrap();
if (cspListener) {
rv = secCheckLoadInfo->SetCspEventListener(cspListener);

4
dom/websocket/WebSocket.cpp
View File

@@ -1711,11 +1711,11 @@ nsresult WebSocketImpl::Init(nsIGlobalObject* aWindowGlobal, JSContext* aCx,
// AsyncOpen().
// Please note that websockets can't follow redirects, hence there is no
// need to perform a CSP check after redirects.
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = MOZ_TRY(net::LoadInfo::Create(
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new net::LoadInfo(
aPrincipal, // loading principal
aPrincipal, // triggering principal
originDoc, nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
nsIContentPolicy::TYPE_WEBSOCKET, aClientInfo));
nsIContentPolicy::TYPE_WEBSOCKET, aClientInfo);
if (aCSPEventListener) {
secCheckLoadInfo->SetCspEventListener(aCSPEventListener);

6
dom/xml/nsXMLContentSink.cpp
View File

@@ -763,12 +763,12 @@ nsresult nsXMLContentSink::MaybeProcessXSLTLink(
mDocument->InnerWindowID());
NS_ENSURE_SUCCESS(rv, NS_OK);
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = MOZ_TRY(
net::LoadInfo::Create(mDocument->NodePrincipal(), // loading principal
nsCOMPtr<nsILoadInfo> secCheckLoadInfo =
new net::LoadInfo(mDocument->NodePrincipal(), // loading principal
mDocument->NodePrincipal(), // triggering principal
aProcessingInstruction,
nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
nsIContentPolicy::TYPE_XSLT));
nsIContentPolicy::TYPE_XSLT);
// Do content policy check
int16_t decision = nsIContentPolicy::ACCEPT;

7
image/imgLoader.cpp
View File

@@ -727,13 +727,10 @@ static bool ShouldLoadCachedImage(imgRequest* aImgRequest,
loadingPrincipal = NullPrincipal::CreateWithoutOriginAttributes();
}
Result<RefPtr<LoadInfo>, nsresult> maybeLoadInfo = LoadInfo::Create(
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new LoadInfo(
loadingPrincipal, aTriggeringPrincipal, aLoadingDocument,
nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK, aPolicyType);
if (NS_WARN_IF(maybeLoadInfo.isErr())) {
return false;
}
RefPtr<LoadInfo> secCheckLoadInfo = maybeLoadInfo.unwrap();
secCheckLoadInfo->SetSendCSPViolationEvents(aSendCSPViolationReports);
int16_t decision = nsIContentPolicy::REJECT_REQUEST;

6
layout/style/FontFaceSetDocumentImpl.cpp
View File

@@ -356,15 +356,11 @@ bool FontFaceSetDocumentImpl::IsFontLoadAllowed(const gfxFontFaceSrc& aSrc) {
nsIPrincipal* principal =
gfxPrincipal ? gfxPrincipal->NodePrincipal() : nullptr;
Result<RefPtr<net::LoadInfo>, nsresult> maybeLoadInfo = net::LoadInfo::Create(
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new net::LoadInfo(
mDocument->NodePrincipal(), // loading principal
principal, // triggering principal
mDocument, nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
nsIContentPolicy::TYPE_FONT);
if (NS_WARN_IF(maybeLoadInfo.isErr())) {
return false;
}
RefPtr<net::LoadInfo> secCheckLoadInfo = maybeLoadInfo.unwrap();
int16_t shouldLoad = nsIContentPolicy::ACCEPT;
nsresult rv =

6
layout/style/FontFaceSetWorkerImpl.cpp
View File

@@ -316,15 +316,11 @@ bool FontFaceSetWorkerImpl::IsFontLoadAllowed(const gfxFontFaceSrc& aSrc) {
nsIPrincipal* principal =
gfxPrincipal ? gfxPrincipal->NodePrincipal() : nullptr;
Result<RefPtr<net::LoadInfo>, nsresult> maybeLoadInfo = net::LoadInfo::Create(
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new net::LoadInfo(
mWorkerRef->Private()->GetLoadingPrincipal(), // loading principal
principal, // triggering principal
nullptr, nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
nsIContentPolicy::TYPE_FONT);
if (NS_WARN_IF(maybeLoadInfo.isErr())) {
return false;
}
RefPtr<net::LoadInfo> secCheckLoadInfo = maybeLoadInfo.unwrap();
int16_t shouldLoad = nsIContentPolicy::ACCEPT;
nsresult rv =

4
layout/style/Loader.cpp
View File

@@ -828,9 +828,9 @@ nsresult Loader::CheckContentPolicy(nsIPrincipal* aLoadingPrincipal,
nsContentPolicyType contentPolicyType =
ComputeContentPolicyType(aPreloadKind);
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = MOZ_TRY(net::LoadInfo::Create(
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new net::LoadInfo(
aLoadingPrincipal, aTriggeringPrincipal, aRequestingNode,
nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK, contentPolicyType));
nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK, contentPolicyType);
secCheckLoadInfo->SetCspNonce(aNonce);
int16_t shouldLoad = nsIContentPolicy::ACCEPT;

12
netwerk/base/LoadInfo.cpp
View File

@@ -75,18 +75,6 @@ static nsContentPolicyType InternalContentPolicyTypeForFrame(
: nsIContentPolicy::TYPE_INTERNAL_FRAME;
}
/* static */ Result<already_AddRefed<LoadInfo>, nsresult> LoadInfo::Create(
nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal,
nsINode* aLoadingContext, nsSecurityFlags aSecurityFlags,
nsContentPolicyType aContentPolicyType,
const Maybe<mozilla::dom::ClientInfo>& aLoadingClientInfo,
const Maybe<mozilla::dom::ServiceWorkerDescriptor>& aController,
uint32_t aSandboxFlags) {
return MakeAndAddRef<LoadInfo>(
aLoadingPrincipal, aTriggeringPrincipal, aLoadingContext, aSecurityFlags,
aContentPolicyType, aLoadingClientInfo, aController);
}
/* static */ already_AddRefed<LoadInfo> LoadInfo::CreateForDocument(
dom::CanonicalBrowsingContext* aBrowsingContext, nsIURI* aURI,
nsIPrincipal* aTriggeringPrincipal, const nsACString& aTriggeringRemoteType,

32
netwerk/base/LoadInfo.h
View File

@@ -19,7 +19,6 @@
#include "nsTArray.h"
#include "mozilla/BasePrincipal.h"
#include "mozilla/Result.h"
#include "mozilla/dom/ClientInfo.h"
#include "mozilla/dom/ServiceWorkerDescriptor.h"
@@ -67,18 +66,6 @@ class LoadInfo final : public nsILoadInfo {
NS_DECL_ISUPPORTS
NS_DECL_NSILOADINFO
// Currently used for most load types, but prefer the specialized factories
// below when possible. aLoadingPrincipal MUST NOT BE NULL.
static mozilla::Result<already_AddRefed<LoadInfo>, nsresult> Create(
nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal,
nsINode* aLoadingContext, nsSecurityFlags aSecurityFlags,
nsContentPolicyType aContentPolicyType,
const Maybe<mozilla::dom::ClientInfo>& aLoadingClientInfo =
Maybe<mozilla::dom::ClientInfo>(),
const Maybe<mozilla::dom::ServiceWorkerDescriptor>& aController =
Maybe<mozilla::dom::ServiceWorkerDescriptor>(),
uint32_t aSandboxFlags = 0);
// Used for TYPE_DOCUMENT load.
static already_AddRefed<LoadInfo> CreateForDocument(
dom::CanonicalBrowsingContext* aBrowsingContext, nsIURI* aURI,
@@ -100,16 +87,6 @@ class LoadInfo final : public nsILoadInfo {
nsContentPolicyType aContentPolicyType, nsSecurityFlags aSecurityFlags,
uint32_t aSandboxFlags);
// Constructor used for TYPE_DOCUMENT loads which have a different
// loadingContext than other loads. This ContextForTopLevelLoad is
// only used for content policy checks.
LoadInfo(nsPIDOMWindowOuter* aOuterWindow, nsIURI* aURI,
nsIPrincipal* aTriggeringPrincipal,
nsISupports* aContextForTopLevelLoad, nsSecurityFlags aSecurityFlags,
uint32_t aSandboxFlags);
private:
// Use factory function Create.
// aLoadingPrincipal MUST NOT BE NULL.
LoadInfo(nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal,
nsINode* aLoadingContext, nsSecurityFlags aSecurityFlags,
@@ -120,6 +97,15 @@ class LoadInfo final : public nsILoadInfo {
Maybe<mozilla::dom::ServiceWorkerDescriptor>(),
uint32_t aSandboxFlags = 0);
// Constructor used for TYPE_DOCUMENT loads which have a different
// loadingContext than other loads. This ContextForTopLevelLoad is
// only used for content policy checks.
LoadInfo(nsPIDOMWindowOuter* aOuterWindow, nsIURI* aURI,
nsIPrincipal* aTriggeringPrincipal,
nsISupports* aContextForTopLevelLoad, nsSecurityFlags aSecurityFlags,
uint32_t aSandboxFlags);
private:
// Use factory function CreateForDocument
// Used for TYPE_DOCUMENT load.
LoadInfo(dom::CanonicalBrowsingContext* aBrowsingContext, nsIURI* aURI,

10
netwerk/base/nsIOService.cpp
View File

@@ -1183,9 +1183,9 @@ nsresult nsIOService::NewChannelFromURIWithProxyFlagsInternal(
const Maybe<ServiceWorkerDescriptor>& aController, uint32_t aSecurityFlags,
nsContentPolicyType aContentPolicyType, uint32_t aSandboxFlags,
nsIChannel** result) {
nsCOMPtr<nsILoadInfo> loadInfo = MOZ_TRY(LoadInfo::Create(
nsCOMPtr<nsILoadInfo> loadInfo = new LoadInfo(
aLoadingPrincipal, aTriggeringPrincipal, aLoadingNode, aSecurityFlags,
aContentPolicyType, aLoadingClientInfo, aController, aSandboxFlags));
aContentPolicyType, aLoadingClientInfo, aController, aSandboxFlags);
return NewChannelFromURIWithProxyFlagsInternal(aURI, aProxyURI, aProxyFlags,
loadInfo, result);
}
@@ -2158,10 +2158,10 @@ nsresult nsIOService::SpeculativeConnectInternal(
// connection from http to https.
nsCOMPtr<nsIURI> httpsURI;
if (aURI->SchemeIs("http")) {
nsCOMPtr<nsILoadInfo> httpsOnlyCheckLoadInfo = MOZ_TRY(
LoadInfo::Create(loadingPrincipal, loadingPrincipal, nullptr,
nsCOMPtr<nsILoadInfo> httpsOnlyCheckLoadInfo =
new LoadInfo(loadingPrincipal, loadingPrincipal, nullptr,
nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
nsIContentPolicy::TYPE_SPECULATIVE));
nsIContentPolicy::TYPE_SPECULATIVE);
// Check if https-only, or https-first would upgrade the request
if (nsHTTPSOnlyUtils::ShouldUpgradeRequest(aURI, httpsOnlyCheckLoadInfo) ||

12
netwerk/base/nsNetUtil.cpp
View File

@@ -782,9 +782,9 @@ nsresult NS_NewInputStreamChannelInternal(
const nsACString& aContentCharset, nsINode* aLoadingNode,
nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal,
nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType) {
nsCOMPtr<nsILoadInfo> loadInfo = MOZ_TRY(
LoadInfo::Create(aLoadingPrincipal, aTriggeringPrincipal, aLoadingNode,
aSecurityFlags, aContentPolicyType));
nsCOMPtr<nsILoadInfo> loadInfo = new mozilla::net::LoadInfo(
aLoadingPrincipal, aTriggeringPrincipal, aLoadingNode, aSecurityFlags,
aContentPolicyType);
if (!loadInfo) {
return NS_ERROR_UNEXPECTED;
}
@@ -847,9 +847,9 @@ nsresult NS_NewInputStreamChannelInternal(
nsIPrincipal* aLoadingPrincipal, nsIPrincipal* aTriggeringPrincipal,
nsSecurityFlags aSecurityFlags, nsContentPolicyType aContentPolicyType,
bool aIsSrcdocChannel /* = false */) {
nsCOMPtr<nsILoadInfo> loadInfo = MOZ_TRY(
net::LoadInfo::Create(aLoadingPrincipal, aTriggeringPrincipal,
aLoadingNode, aSecurityFlags, aContentPolicyType));
nsCOMPtr<nsILoadInfo> loadInfo = new mozilla::net::LoadInfo(
aLoadingPrincipal, aTriggeringPrincipal, aLoadingNode, aSecurityFlags,
aContentPolicyType);
return NS_NewInputStreamChannelInternal(outChannel, aUri, aData, aContentType,
loadInfo, aIsSrcdocChannel);
}

6
netwerk/protocol/http/AlternateServices.cpp
View File

@@ -696,10 +696,10 @@ class WellKnownChecker {
nsresult Start() {
LOG(("WellKnownChecker::Start %p\n", this));
nsCOMPtr<nsILoadInfo> loadInfo = MOZ_TRY(LoadInfo::Create(
nsContentUtils::GetSystemPrincipal(), nullptr, nullptr,
nsCOMPtr<nsILoadInfo> loadInfo =
new LoadInfo(nsContentUtils::GetSystemPrincipal(), nullptr, nullptr,
nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
nsIContentPolicy::TYPE_OTHER));
nsIContentPolicy::TYPE_OTHER);
loadInfo->SetOriginAttributes(mCI->GetOriginAttributes());
// allow deprecated HTTP request from SystemPrincipal
loadInfo->SetAllowDeprecatedSystemRequests(true);

4
netwerk/protocol/websocket/BaseWebSocketChannel.cpp
View File

@@ -219,10 +219,10 @@ BaseWebSocketChannel::InitLoadInfoNative(
nsIPrincipal* aTriggeringPrincipal,
nsICookieJarSettings* aCookieJarSettings, uint32_t aSecurityFlags,
nsContentPolicyType aContentPolicyType, uint32_t aSandboxFlags) {
mLoadInfo = MOZ_TRY(LoadInfo::Create(
mLoadInfo = new LoadInfo(
aLoadingPrincipal, aTriggeringPrincipal, aLoadingNode, aSecurityFlags,
aContentPolicyType, Maybe<mozilla::dom::ClientInfo>(),
Maybe<mozilla::dom::ServiceWorkerDescriptor>(), aSandboxFlags));
Maybe<mozilla::dom::ServiceWorkerDescriptor>(), aSandboxFlags);
if (aCookieJarSettings) {
mLoadInfo->SetCookieJarSettings(aCookieJarSettings);
}

4
toolkit/components/places/nsFaviconService.cpp
View File

@@ -277,13 +277,13 @@ nsFaviconService::SetFaviconForPage(nsIURI* aPageURI, nsIURI* aFaviconURI,
return NS_ERROR_NULL_POINTER;
}
nsCOMPtr<nsILoadInfo> loadInfo = MOZ_TRY(net::LoadInfo::Create(
nsCOMPtr<nsILoadInfo> loadInfo = new mozilla::net::LoadInfo(
loadingPrincipal,
nullptr, // aTriggeringPrincipal
nullptr, // aLoadingNode
nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT |
nsILoadInfo::SEC_ALLOW_CHROME | nsILoadInfo::SEC_DISALLOW_SCRIPT,
nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON));
nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON);
nsCOMPtr<nsIChannel> channel;
rv = protocolHandler->NewChannel(aDataURL, loadInfo, getter_AddRefs(channel));

4
uriloader/preload/FetchPreloader.cpp
View File

@@ -154,9 +154,9 @@ nsresult FetchPreloader::CheckContentPolicy(nsIURI* aURI,
return NS_OK;
}
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = MOZ_TRY(net::LoadInfo::Create(
nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new net::LoadInfo(
aDocument->NodePrincipal(), aDocument->NodePrincipal(), aDocument,
nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK, mContentPolicyType));
nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK, mContentPolicyType);
int16_t shouldLoad = nsIContentPolicy::ACCEPT;
nsresult rv = NS_CheckContentLoadPolicy(aURI, secCheckLoadInfo, &shouldLoad,