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

Backed out 13 changesets (bug 1771867) for causing CanonicalBrowsingContext crashes. CLOSED TREE

Browse Source 
Backed out changeset 120838b58449 (bug 1771867)
Backed out changeset aea7ca0bbd17 (bug 1771867)
Backed out changeset 2fe2afdee09d (bug 1771867)
Backed out changeset 8bdb1f682d22 (bug 1771867)
Backed out changeset a9f3158ed688 (bug 1771867)
Backed out changeset 1177913e1edf (bug 1771867)
Backed out changeset d33ccbbf407d (bug 1771867)
Backed out changeset 110ac12e16f5 (bug 1771867)
Backed out changeset 7f20525f5e94 (bug 1771867)
Backed out changeset b3d65b1aa872 (bug 1771867)
Backed out changeset 7cdf3cef2773 (bug 1771867)
Backed out changeset 5090eae24a5c (bug 1771867)
Backed out changeset f8a03d226c73 (bug 1771867)
This commit is contained in:
Csoregi Natalia
2022-12-02 13:44:55 +02:00
parent 145d35e54d
commit 51f523d872
66 changed files with 492 additions and 1258 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
docshell/base/CanonicalBrowsingContext.cpp
View File

@@ -1297,6 +1297,10 @@ void CanonicalBrowsingContext::AddFinalDiscardListener(
mFullyDiscardedListeners.AppendElement(std::move(aListener));
}
net::EarlyHintsService* CanonicalBrowsingContext::GetEarlyHintsService() {
return &mEarlyHintsService;
}
void CanonicalBrowsingContext::AdjustPrivateBrowsingCount(
bool aPrivateBrowsing) {
if (IsDiscarded() || !EverAttached() || IsChrome()) {

5
docshell/base/CanonicalBrowsingContext.h
View File

@@ -7,6 +7,7 @@
#ifndef mozilla_dom_CanonicalBrowsingContext_h
#define mozilla_dom_CanonicalBrowsingContext_h
#include "mozilla/net/EarlyHintsService.h"
#include "mozilla/dom/BrowsingContext.h"
#include "mozilla/dom/MediaControlKeySource.h"
#include "mozilla/dom/BrowsingContextWebProgress.h"
@@ -362,6 +363,8 @@ class CanonicalBrowsingContext final : public BrowsingContext {
void AddFinalDiscardListener(std::function<void(uint64_t)>&& aListener);
net::EarlyHintsService* GetEarlyHintsService();
protected:
// Called when the browsing context is being discarded.
void CanonicalDiscard();
@@ -565,6 +568,8 @@ class CanonicalBrowsingContext final : public BrowsingContext {
bool mFullyDiscarded = false;
nsTArray<std::function<void(uint64_t)>> mFullyDiscardedListeners;
net::EarlyHintsService mEarlyHintsService;
};
} // namespace dom

27
dom/base/Document.cpp
View File

@@ -6747,11 +6747,6 @@ void Document::SetHeaderData(nsAtom* aHeaderField, const nsAString& aData) {
}
}
void Document::SetEarlyHints(
nsTArray<net::EarlyHintConnectArgs>&& aEarlyHints) {
mEarlyHints = std::move(aEarlyHints);
}
void Document::TryChannelCharset(nsIChannel* aChannel, int32_t& aCharsetSource,
NotNull<const Encoding*>& aEncoding,
nsHtml5TreeOpExecutor* aExecutor) {
@@ -12212,7 +12207,7 @@ already_AddRefed<nsIURI> Document::ResolvePreloadImage(
void Document::PreLoadImage(nsIURI* aUri, const nsAString& aCrossOriginAttr,
ReferrerPolicyEnum aReferrerPolicy, bool aIsImgSet,
bool aLinkPreload, uint64_t aEarlyHintPreloaderId) {
bool aLinkPreload) {
nsLoadFlags loadFlags = nsIRequest::LOAD_NORMAL |
nsIRequest::LOAD_RECORD_START_REQUEST_DELAY |
nsContentUtils::CORSModeToLoadImageFlags(
@@ -12226,15 +12221,11 @@ void Document::PreLoadImage(nsIURI* aUri, const nsAString& aCrossOriginAttr,
ReferrerInfo::CreateFromDocumentAndPolicyOverride(this, aReferrerPolicy);
RefPtr<imgRequestProxy> request;
nsLiteralString initiator = aEarlyHintPreloaderId
? u"early-hints"_ns
: (aLinkPreload ? u"link"_ns : u"img"_ns);
nsresult rv = nsContentUtils::LoadImage(
aUri, static_cast<nsINode*>(this), this, NodePrincipal(), 0, referrerInfo,
nullptr /* no observer */, loadFlags, initiator, getter_AddRefs(request),
policyType, false /* urgent */, aLinkPreload, aEarlyHintPreloaderId);
nullptr /* no observer */, loadFlags,
aLinkPreload ? u"link"_ns : u"img"_ns, getter_AddRefs(request),
policyType, false /* urgent */, aLinkPreload);
// Pin image-reference to avoid evicting it from the img-cache before
// the "real" load occurs. Unpinned in DispatchContentLoadedEvents and
@@ -12257,7 +12248,7 @@ void Document::MaybePreLoadImage(nsIURI* aUri,
dom::Element::StringToCORSMode(aCrossOriginAttr));
if (!mPreloadService.PreloadExists(key)) {
PreLoadImage(aUri, aCrossOriginAttr, aReferrerPolicy, aIsImgSet,
aLinkPreload, 0);
aLinkPreload);
}
return;
}
@@ -12277,8 +12268,8 @@ void Document::MaybePreLoadImage(nsIURI* aUri,
#endif
// Image not in cache - trigger preload
PreLoadImage(aUri, aCrossOriginAttr, aReferrerPolicy, aIsImgSet, aLinkPreload,
0);
PreLoadImage(aUri, aCrossOriginAttr, aReferrerPolicy, aIsImgSet,
aLinkPreload);
}
void Document::MaybePreconnect(nsIURI* aOrigURI, mozilla::CORSMode aCORSMode) {
@@ -12402,7 +12393,7 @@ NS_IMPL_ISUPPORTS(StubCSSLoaderObserver, nsICSSLoaderObserver)
SheetPreloadStatus Document::PreloadStyle(
nsIURI* uri, const Encoding* aEncoding, const nsAString& aCrossOriginAttr,
const enum ReferrerPolicy aReferrerPolicy, const nsAString& aIntegrity,
css::StylePreloadKind aKind, uint64_t aEarlyHintPreloaderId) {
css::StylePreloadKind aKind) {
MOZ_ASSERT(aKind != css::StylePreloadKind::None);
// The CSSLoader will retain this object after we return.
@@ -12413,7 +12404,7 @@ SheetPreloadStatus Document::PreloadStyle(
// Charset names are always ASCII.
auto result = CSSLoader()->LoadSheet(
uri, aKind, aEncoding, referrerInfo, obs, aEarlyHintPreloaderId,
uri, aKind, aEncoding, referrerInfo, obs,
Element::StringToCORSMode(aCrossOriginAttr), aIntegrity);
if (result.isErr()) {
return SheetPreloadStatus::Errored;

17
dom/base/Document.h
View File

@@ -322,7 +322,6 @@ enum BFCacheStatus {
namespace mozilla::net {
class ChannelEventQueue;
class EarlyHintConnectArgs;
} // namespace mozilla::net
// Must be kept in sync with xpcom/rust/xpcom/src/interfaces/nonidl.rs
@@ -1169,15 +1168,6 @@ class Document : public nsINode,
void GetHeaderData(nsAtom* aHeaderField, nsAString& aData) const;
void SetHeaderData(nsAtom* aheaderField, const nsAString& aData);
/**
* Set Early Hint data, moves the arrays into the function, leaving the
* passed variables empty
*/
void SetEarlyHints(nsTArray<net::EarlyHintConnectArgs>&& aEarlyHints);
const nsTArray<net::EarlyHintConnectArgs>& GetEarlyHints() const {
return mEarlyHints;
}
/**
* Create a new presentation shell that will use aContext for its
* presentation context (presentation contexts <b>must not</b> be
@@ -3014,7 +3004,7 @@ class Document : public nsINode,
bool aLinkPreload, const TimeStamp& aInitTimestamp);
void PreLoadImage(nsIURI* uri, const nsAString& aCrossOriginAttr,
ReferrerPolicyEnum aReferrerPolicy, bool aIsImgSet,
bool aLinkPreload, uint64_t aEarlyHintPreloaderId);
bool aLinkPreload);
/**
* Called by images to forget an image preload when they start doing
@@ -3030,8 +3020,7 @@ class Document : public nsINode,
const nsAString& aCrossOriginAttr,
ReferrerPolicyEnum aReferrerPolicy,
const nsAString& aIntegrity,
css::StylePreloadKind,
uint64_t aEarlyHintPreloaderId);
css::StylePreloadKind);
/**
* Called by the chrome registry to load style sheets.
@@ -5128,8 +5117,6 @@ class Document : public nsINode,
class HeaderData;
UniquePtr<HeaderData> mHeaderData;
nsTArray<net::EarlyHintConnectArgs> mEarlyHints;
nsRevocableEventPtr<nsRunnableMethod<Document, void, false>>
mPendingTitleChangeEvent;

1
dom/base/moz.build
View File

@@ -569,7 +569,6 @@ LOCAL_INCLUDES += [
"/layout/style",
"/layout/xul",
"/netwerk/base",
"/netwerk/protocol/http",
"/netwerk/url-classifier",
"/parser/htmlparser",
"/security/manager/ssl",

82
dom/base/nsContentSink.cpp
View File

@@ -20,8 +20,6 @@
#include "mozilla/dom/MutationObservers.h"
#include "mozilla/dom/SRILogHelper.h"
#include "mozilla/StoragePrincipalHelper.h"
#include "mozilla/net/HttpBaseChannel.h"
#include "mozilla/net/NeckoChannelParams.h"
#include "nsIDocShell.h"
#include "nsILoadContext.h"
#include "nsIPrefetchService.h"
@@ -224,27 +222,16 @@ nsresult nsContentSink::ProcessHTTPHeaders(nsIChannel* aChannel) {
return NS_OK;
}
bool gotEarlyHints = false;
if (nsCOMPtr<mozilla::net::HttpBaseChannel> baseChannel =
do_QueryInterface(aChannel)) {
nsTArray<mozilla::net::EarlyHintConnectArgs> earlyHints =
baseChannel->TakeEarlyHints();
gotEarlyHints = !earlyHints.IsEmpty();
mDocument->SetEarlyHints(std::move(earlyHints));
}
// Note that the only header we care about is the "link" header, since we
// have all the infrastructure for kicking off stylesheet loads.
nsAutoCString linkHeader;
nsresult rv = httpchannel->GetResponseHeader("link"_ns, linkHeader);
bool gotLinkHeader = NS_SUCCEEDED(rv) && !linkHeader.IsEmpty();
if (gotLinkHeader) {
if (NS_SUCCEEDED(rv) && !linkHeader.IsEmpty()) {
mDocument->SetHeaderData(nsGkAtoms::link,
NS_ConvertASCIItoUTF16(linkHeader));
}
if (gotLinkHeader || gotEarlyHints) {
NS_ASSERTION(!mProcessLinkHeaderEvent.get(),
"Already dispatched an event?");
@@ -261,28 +248,63 @@ nsresult nsContentSink::ProcessHTTPHeaders(nsIChannel* aChannel) {
}
void nsContentSink::DoProcessLinkHeader() {
for (const auto& earlyHint : mDocument->GetEarlyHints()) {
ProcessLinkFromHeader(earlyHint.link(), earlyHint.earlyHintPreloaderId());
}
nsAutoString value;
mDocument->GetHeaderData(nsGkAtoms::link, value);
auto linkHeaders = net::ParseLinkHeader(value);
for (const auto& linkHeader : linkHeaders) {
ProcessLinkFromHeader(linkHeader, 0);
ProcessLinkFromHeader(linkHeader);
}
}
nsresult nsContentSink::ProcessLinkFromHeader(const net::LinkHeader& aHeader,
uint64_t aEarlyHintPreloaderId) {
// check whether the Link header field applies to the context resource
// see <http://tools.ietf.org/html/rfc5988#section-5.2>
bool nsContentSink::LinkContextIsOurDocument(const nsAString& aAnchor) {
if (aAnchor.IsEmpty()) {
// anchor parameter not present or empty -> same document reference
return true;
}
nsIURI* docUri = mDocument->GetDocumentURI();
// the document URI might contain a fragment identifier ("#...')
// we want to ignore that because it's invisible to the server
// and just affects the local interpretation in the recipient
nsCOMPtr<nsIURI> contextUri;
nsresult rv = NS_GetURIWithoutRef(docUri, getter_AddRefs(contextUri));
if (NS_FAILED(rv)) {
// copying failed
return false;
}
// resolve anchor against context
nsCOMPtr<nsIURI> resolvedUri;
rv = NS_NewURI(getter_AddRefs(resolvedUri), aAnchor, nullptr, contextUri);
if (NS_FAILED(rv)) {
// resolving failed
return false;
}
bool same;
rv = contextUri->Equals(resolvedUri, &same);
if (NS_FAILED(rv)) {
// comparison failed
return false;
}
return same;
}
nsresult nsContentSink::ProcessLinkFromHeader(const net::LinkHeader& aHeader) {
uint32_t linkTypes = LinkStyle::ParseLinkTypes(aHeader.mRel);
// The link relation may apply to a different resource, specified
// in the anchor parameter. For the link relations supported so far,
// we simply abort if the link applies to a resource different to the
// one we've loaded
if (!nsContentUtils::LinkContextIsURI(aHeader.mAnchor,
mDocument->GetDocumentURI())) {
if (!LinkContextIsOurDocument(aHeader.mAnchor)) {
return NS_OK;
}
@@ -303,8 +325,7 @@ nsresult nsContentSink::ProcessLinkFromHeader(const net::LinkHeader& aHeader,
if (linkTypes & LinkStyle::ePRELOAD) {
PreloadHref(aHeader.mHref, aHeader.mAs, aHeader.mType, aHeader.mMedia,
aHeader.mIntegrity, aHeader.mSrcset, aHeader.mSizes,
aHeader.mCrossOrigin, aHeader.mReferrerPolicy,
aEarlyHintPreloaderId);
aHeader.mCrossOrigin, aHeader.mReferrerPolicy);
}
if ((linkTypes & LinkStyle::eMODULE_PRELOAD) &&
@@ -414,8 +435,7 @@ void nsContentSink::PreloadHref(const nsAString& aHref, const nsAString& aAs,
const nsAString& aIntegrity,
const nsAString& aSrcset,
const nsAString& aSizes, const nsAString& aCORS,
const nsAString& aReferrerPolicy,
uint64_t aEarlyHintPreloaderId) {
const nsAString& aReferrerPolicy) {
auto encoding = mDocument->GetDocumentCharacterSet();
nsCOMPtr<nsIURI> uri;
NS_NewURI(getter_AddRefs(uri), aHref, encoding, mDocument->GetDocBaseURI());
@@ -439,9 +459,9 @@ void nsContentSink::PreloadHref(const nsAString& aHref, const nsAString& aAs,
return;
}
mDocument->Preloads().PreloadLinkHeader(
uri, aHref, policyType, aAs, aType, aIntegrity, aSrcset, aSizes, aCORS,
aReferrerPolicy, aEarlyHintPreloaderId);
mDocument->Preloads().PreloadLinkHeader(uri, aHref, policyType, aAs, aType,
aIntegrity, aSrcset, aSizes, aCORS,
aReferrerPolicy);
}
void nsContentSink::PrefetchDNS(const nsAString& aHref) {

8
dom/base/nsContentSink.h
View File

@@ -115,6 +115,7 @@ class nsContentSink : public nsICSSLoaderObserver,
virtual void UpdateChildCounts() = 0;
bool IsTimeToNotify();
bool LinkContextIsOurDocument(const nsAString& aAnchor);
protected:
nsContentSink();
@@ -124,9 +125,7 @@ class nsContentSink : public nsICSSLoaderObserver,
nsIChannel* aChannel);
nsresult ProcessHTTPHeaders(nsIChannel* aChannel);
// aEarlyHintPreloaderId zero means no early hint channel to connect back
nsresult ProcessLinkFromHeader(const mozilla::net::LinkHeader& aHeader,
uint64_t aEarlyHintPreloaderId);
nsresult ProcessLinkFromHeader(const mozilla::net::LinkHeader& aHeader);
virtual nsresult ProcessStyleLinkFromHeader(
const nsAString& aHref, bool aAlternate, const nsAString& aTitle,
@@ -139,8 +138,7 @@ class nsContentSink : public nsICSSLoaderObserver,
const nsAString& aType, const nsAString& aMedia,
const nsAString& aIntegrity, const nsAString& aSrcset,
const nsAString& aSizes, const nsAString& aCORS,
const nsAString& aReferrerPolicy,
uint64_t aEarlyHintPreloaderId);
const nsAString& aReferrerPolicy);
// For PrefetchDNS() aHref can either be the usual
// URI format or of the form "//www.hostname.com" without a scheme.

43
dom/base/nsContentUtils.cpp
View File

@@ -3815,8 +3815,7 @@ nsresult nsContentUtils::LoadImage(
nsIReferrerInfo* aReferrerInfo, imgINotificationObserver* aObserver,
int32_t aLoadFlags, const nsAString& initiatorType,
imgRequestProxy** aRequest, nsContentPolicyType aContentPolicyType,
bool aUseUrgentStartForChannel, bool aLinkPreload,
uint64_t aEarlyHintPreloaderId) {
bool aUseUrgentStartForChannel, bool aLinkPreload) {
MOZ_ASSERT(aURI, "Must have a URI");
MOZ_ASSERT(aContext, "Must have a context");
MOZ_ASSERT(aLoadingDocument, "Must have a document");
@@ -3853,7 +3852,7 @@ nsresult nsContentUtils::LoadImage(
initiatorType, /* the load initiator */
aUseUrgentStartForChannel, /* urgent-start flag */
aLinkPreload, /* <link preload> initiator */
aEarlyHintPreloaderId, aRequest);
aRequest);
}
// static
@@ -8528,44 +8527,6 @@ already_AddRefed<nsPIWindowRoot> nsContentUtils::GetWindowRoot(Document* aDoc) {
return nullptr;
}
/* static */
bool nsContentUtils::LinkContextIsURI(const nsAString& aAnchor,
nsIURI* aDocURI) {
if (aAnchor.IsEmpty()) {
// anchor parameter not present or empty -> same document reference
return true;
}
// the document URI might contain a fragment identifier ("#...')
// we want to ignore that because it's invisible to the server
// and just affects the local interpretation in the recipient
nsCOMPtr<nsIURI> contextUri;
nsresult rv = NS_GetURIWithoutRef(aDocURI, getter_AddRefs(contextUri));
if (NS_FAILED(rv)) {
// copying failed
return false;
}
// resolve anchor against context
nsCOMPtr<nsIURI> resolvedUri;
rv = NS_NewURI(getter_AddRefs(resolvedUri), aAnchor, nullptr, contextUri);
if (NS_FAILED(rv)) {
// resolving failed
return false;
}
bool same;
rv = contextUri->Equals(resolvedUri, &same);
if (NS_FAILED(rv)) {
// comparison failed
return false;
}
return same;
}
/* static */
bool nsContentUtils::IsPreloadType(nsContentPolicyType aType) {
return (aType == nsIContentPolicy::TYPE_INTERNAL_SCRIPT_PRELOAD ||

9
dom/base/nsContentUtils.h
View File

@@ -1016,8 +1016,7 @@ class nsContentUtils {
imgRequestProxy** aRequest,
nsContentPolicyType aContentPolicyType =
nsIContentPolicy::TYPE_INTERNAL_IMAGE,
bool aUseUrgentStartForChannel = false, bool aLinkPreload = false,
uint64_t aEarlyHintPreloaderId = 0);
bool aUseUrgentStartForChannel = false, bool aLinkPreload = false);
/**
* Obtain an image loader that respects the given document/channel's privacy
@@ -1408,12 +1407,6 @@ class nsContentUtils {
static inline ExtContentPolicyType InternalContentPolicyTypeToExternal(
nsContentPolicyType aType);
/**
* check whether the Link header field applies to the context resource
* see <http://tools.ietf.org/html/rfc5988#section-5.2>
*/
static bool LinkContextIsURI(const nsAString& aAnchor, nsIURI* aDocURI);
/**
* Returns true if the content policy type is any of:
* * TYPE_INTERNAL_SCRIPT_PRELOAD

4
dom/ipc/ContentChild.cpp
View File

@@ -3550,10 +3550,6 @@ mozilla::ipc::IPCResult ContentChild::RecvCrossProcessRedirect(
getter_AddRefs(newChannel), aArgs.uri(), loadInfo, nullptr,
aArgs.newLoadFlags(), aArgs.srcdocData(), aArgs.baseUri());
if (RefPtr<HttpBaseChannel> httpChannel = do_QueryObject(newChannel)) {
httpChannel->SetEarlyHints(std::move(aArgs.earlyHints()));
}
// This is used to report any errors back to the parent by calling
// CrossProcessRedirectFinished.
RefPtr<HttpChannelChild> httpChild = do_QueryObject(newChannel);

3
dom/script/ModuleLoader.cpp
View File

@@ -107,8 +107,7 @@ nsresult ModuleLoader::StartFetch(ModuleLoadRequest* aRequest) {
securityFlags |= nsILoadInfo::SEC_ALLOW_CHROME;
// Delegate Shared Behavior to base ScriptLoader
nsresult rv =
GetScriptLoader()->StartLoadInternal(aRequest, securityFlags, 0);
nsresult rv = GetScriptLoader()->StartLoadInternal(aRequest, securityFlags);
NS_ENSURE_SUCCESS(rv, rv);
// https://html.spec.whatwg.org/multipage/webappapis.html#fetch-an-import()-module-script-graph

45
dom/script/ScriptLoader.cpp
View File

@@ -9,7 +9,6 @@
#include "ScriptTrace.h"
#include "ModuleLoader.h"
#include "nsIChildChannel.h"
#include "zlib.h"
#include "prsystem.h"
@@ -520,7 +519,7 @@ nsresult ScriptLoader::RestartLoad(ScriptLoadRequest* aRequest) {
if (aRequest->IsModuleRequest()) {
rv = aRequest->AsModuleRequest()->RestartModuleLoad();
} else {
rv = StartLoad(aRequest, 0);
rv = StartLoad(aRequest);
}
if (NS_FAILED(rv)) {
return rv;
@@ -531,17 +530,15 @@ nsresult ScriptLoader::RestartLoad(ScriptLoadRequest* aRequest) {
return NS_BINDING_RETARGETED;
}
nsresult ScriptLoader::StartLoad(ScriptLoadRequest* aRequest,
uint64_t aEarlyHintPreloaderId) {
nsresult ScriptLoader::StartLoad(ScriptLoadRequest* aRequest) {
if (aRequest->IsModuleRequest()) {
return aRequest->AsModuleRequest()->StartModuleLoad();
}
return StartClassicLoad(aRequest, aEarlyHintPreloaderId);
return StartClassicLoad(aRequest);
}
nsresult ScriptLoader::StartClassicLoad(ScriptLoadRequest* aRequest,
uint64_t aEarlyHintPreloaderId) {
nsresult ScriptLoader::StartClassicLoad(ScriptLoadRequest* aRequest) {
MOZ_ASSERT(aRequest->IsFetching());
NS_ENSURE_TRUE(mDocument, NS_ERROR_NULL_POINTER);
aRequest->SetUnknownDataType();
@@ -565,8 +562,7 @@ nsresult ScriptLoader::StartClassicLoad(ScriptLoadRequest* aRequest,
securityFlags |= nsILoadInfo::SEC_ALLOW_CHROME;
nsresult rv =
StartLoadInternal(aRequest, securityFlags, aEarlyHintPreloaderId);
nsresult rv = StartLoadInternal(aRequest, securityFlags);
NS_ENSURE_SUCCESS(rv, rv);
@@ -584,8 +580,7 @@ static bool IsWebExtensionRequest(ScriptLoadRequest* aRequest) {
}
nsresult ScriptLoader::StartLoadInternal(ScriptLoadRequest* aRequest,
nsSecurityFlags securityFlags,
uint64_t aEarlyHintPreloaderId) {
nsSecurityFlags securityFlags) {
nsContentPolicyType contentPolicyType =
ScriptLoadRequestToContentPolicyType(aRequest);
nsCOMPtr<nsINode> context;
@@ -611,15 +606,6 @@ nsresult ScriptLoader::StartLoadInternal(ScriptLoadRequest* aRequest,
NS_ENSURE_SUCCESS(rv, rv);
if (aEarlyHintPreloaderId) {
nsCOMPtr<nsIHttpChannelInternal> channelInternal =
do_QueryInterface(channel);
NS_ENSURE_TRUE(channelInternal != nullptr, NS_ERROR_FAILURE);
rv = channelInternal->SetEarlyHintPreloaderId(aEarlyHintPreloaderId);
NS_ENSURE_SUCCESS(rv, rv);
}
// snapshot the nonce at load start time for performing CSP checks
if (contentPolicyType == nsIContentPolicy::TYPE_INTERNAL_SCRIPT ||
contentPolicyType == nsIContentPolicy::TYPE_INTERNAL_MODULE) {
@@ -741,9 +727,7 @@ nsresult ScriptLoader::StartLoadInternal(ScriptLoadRequest* aRequest,
// Set the initiator type
nsCOMPtr<nsITimedChannel> timedChannel(do_QueryInterface(httpChannel));
if (timedChannel) {
if (aEarlyHintPreloaderId) {
timedChannel->SetInitiatorType(u"early-hints"_ns);
} else if (aRequest->GetScriptLoadContext()->IsLinkPreloadScript()) {
if (aRequest->GetScriptLoadContext()->IsLinkPreloadScript()) {
timedChannel->SetInitiatorType(u"link"_ns);
} else {
timedChannel->SetInitiatorType(u"script"_ns);
@@ -773,14 +757,6 @@ nsresult ScriptLoader::StartLoadInternal(ScriptLoadRequest* aRequest,
key, channel, mDocument,
aRequest->GetScriptLoadContext()->IsLinkPreloadScript());
if (aEarlyHintPreloaderId) {
nsCOMPtr<nsIHttpChannelInternal> channelInternal =
do_QueryInterface(channel);
NS_ENSURE_TRUE(channelInternal != nullptr, NS_ERROR_FAILURE);
rv = channelInternal->SetEarlyHintPreloaderId(aEarlyHintPreloaderId);
NS_ENSURE_SUCCESS(rv, rv);
}
rv = channel->AsyncOpen(loader);
if (NS_FAILED(rv)) {
@@ -1026,7 +1002,7 @@ bool ScriptLoader::ProcessExternalScript(nsIScriptElement* aElement,
LOG(("ScriptLoadRequest (%p): Created request for external script",
request.get()));
nsresult rv = StartLoad(request, 0);
nsresult rv = StartLoad(request);
if (NS_FAILED(rv)) {
ReportErrorToConsole(request, rv);
@@ -3560,8 +3536,7 @@ void ScriptLoader::PreloadURI(nsIURI* aURI, const nsAString& aCharset,
const nsAString& aIntegrity, bool aScriptFromHead,
bool aAsync, bool aDefer, bool aNoModule,
bool aLinkPreload,
const ReferrerPolicy aReferrerPolicy,
uint64_t aEarlyHintPreloaderId) {
const ReferrerPolicy aReferrerPolicy) {
NS_ENSURE_TRUE_VOID(mDocument);
// Check to see if scripts has been turned off.
if (!mEnabled || !mDocument->IsScriptEnabled()) {
@@ -3609,7 +3584,7 @@ void ScriptLoader::PreloadURI(nsIURI* aURI, const nsAString& aCharset,
request.get(), url.get()));
}
nsresult rv = StartLoad(request, aEarlyHintPreloaderId);
nsresult rv = StartLoad(request);
if (NS_FAILED(rv)) {
return;
}

12
dom/script/ScriptLoader.h
View File

@@ -392,8 +392,7 @@ class ScriptLoader final : public JS::loader::ScriptLoaderInterface {
const nsAString& aIntegrity, bool aScriptFromHead,
bool aAsync, bool aDefer, bool aNoModule,
bool aLinkPreload,
const ReferrerPolicy aReferrerPolicy,
uint64_t aEarlyHintPreloaderId);
const ReferrerPolicy aReferrerPolicy);
/**
* Process a request that was deferred so that the script could be compiled
@@ -491,21 +490,18 @@ class ScriptLoader final : public JS::loader::ScriptLoaderInterface {
/**
* Start a load for aRequest's URI.
*/
nsresult StartLoad(ScriptLoadRequest* aRequest,
uint64_t aEarlyHintPreloaderId);
nsresult StartLoad(ScriptLoadRequest* aRequest);
/**
* Start a load for a classic script URI.
* Sets up the necessary security flags before calling StartLoadInternal.
*/
nsresult StartClassicLoad(ScriptLoadRequest* aRequest,
uint64_t aEarlyHintPreloaderId);
nsresult StartClassicLoad(ScriptLoadRequest* aRequest);
/**
* Start a load for a module script URI.
*/
nsresult StartLoadInternal(ScriptLoadRequest* aRequest,
nsSecurityFlags securityFlags,
uint64_t aEarlyHintPreloaderId);
nsSecurityFlags securityFlags);
/**
* Abort the current stream, and re-start with a new load request from scratch

26
image/imgLoader.cpp
View File

@@ -6,7 +6,6 @@
// Undefine windows version of LoadImage because our code uses that name.
#include "mozilla/ScopeExit.h"
#include "nsIChildChannel.h"
#undef LoadImage
#include "imgLoader.h"
@@ -2236,12 +2235,11 @@ imgLoader::LoadImageXPCOM(
aContentPolicyType = nsIContentPolicy::TYPE_INTERNAL_IMAGE;
}
imgRequestProxy* proxy;
nsresult rv =
LoadImage(aURI, aInitialDocumentURI, aReferrerInfo, aTriggeringPrincipal,
0, aLoadGroup, aObserver, aLoadingDocument, aLoadingDocument,
aLoadFlags, aCacheKey, aContentPolicyType, u""_ns,
/* aUseUrgentStartForChannel */ false, /* aListPreload */ false,
0, &proxy);
nsresult rv = LoadImage(
aURI, aInitialDocumentURI, aReferrerInfo, aTriggeringPrincipal, 0,
aLoadGroup, aObserver, aLoadingDocument, aLoadingDocument, aLoadFlags,
aCacheKey, aContentPolicyType, u""_ns,
/* aUseUrgentStartForChannel */ false, /* aListPreload */ false, &proxy);
*_retval = proxy;
return rv;
}
@@ -2292,8 +2290,7 @@ nsresult imgLoader::LoadImage(
nsINode* aContext, Document* aLoadingDocument, nsLoadFlags aLoadFlags,
nsISupports* aCacheKey, nsContentPolicyType aContentPolicyType,
const nsAString& initiatorType, bool aUseUrgentStartForChannel,
bool aLinkPreload, uint64_t aEarlyHintPreloaderId,
imgRequestProxy** _retval) {
bool aLinkPreload, imgRequestProxy** _retval) {
VerifyCacheSizes();
NS_ASSERTION(aURI, "imgLoader::LoadImage -- NULL URI pointer");
@@ -2554,16 +2551,7 @@ nsresult imgLoader::LoadImage(
nsINetworkPredictor::LEARN_LOAD_SUBRESOURCE,
aLoadGroup);
nsresult openRes;
if (aEarlyHintPreloaderId) {
nsCOMPtr<nsIHttpChannelInternal> channelInternal =
do_QueryInterface(newChannel);
NS_ENSURE_TRUE(channelInternal != nullptr, NS_ERROR_FAILURE);
rv = channelInternal->SetEarlyHintPreloaderId(aEarlyHintPreloaderId);
NS_ENSURE_SUCCESS(rv, rv);
}
openRes = newChannel->AsyncOpen(listener);
nsresult openRes = newChannel->AsyncOpen(listener);
if (NS_FAILED(openRes)) {
MOZ_LOG(

2
image/imgLoader.h
View File

@@ -259,7 +259,7 @@ class imgLoader final : public imgILoader,
nsLoadFlags aLoadFlags, nsISupports* aCacheKey,
nsContentPolicyType aContentPolicyType, const nsAString& initiatorType,
bool aUseUrgentStartForChannel, bool aLinkPreload,
uint64_t aEarlyHintPreloaderId, imgRequestProxy** _retval);
imgRequestProxy** _retval);
[[nodiscard]] nsresult LoadImageWithChannel(
nsIChannel* channel, imgINotificationObserver* aObserver,

52
ipc/glue/IPCMessageUtilsSpecializations.h
View File

@@ -41,7 +41,6 @@
#include "nsILoadInfo.h"
#include "nsIThread.h"
#include "nsLiteralString.h"
#include "nsNetUtil.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashSet.h"
@@ -705,57 +704,6 @@ struct ParamTraits<mozilla::Tuple<Ts...>> {
}
};
template <>
struct ParamTraits<mozilla::net::LinkHeader> {
typedef mozilla::net::LinkHeader paramType;
static void Write(MessageWriter* aWriter, const paramType& aParam) {
WriteParam(aWriter, aParam.mHref);
WriteParam(aWriter, aParam.mRel);
WriteParam(aWriter, aParam.mTitle);
WriteParam(aWriter, aParam.mIntegrity);
WriteParam(aWriter, aParam.mSrcset);
WriteParam(aWriter, aParam.mSizes);
WriteParam(aWriter, aParam.mType);
WriteParam(aWriter, aParam.mMedia);
WriteParam(aWriter, aParam.mCrossOrigin);
WriteParam(aWriter, aParam.mReferrerPolicy);
WriteParam(aWriter, aParam.mAs);
}
static bool Read(MessageReader* aReader, paramType* aResult) {
if (!ReadParam(aReader, &aResult->mHref)) {
return false;
}
if (!ReadParam(aReader, &aResult->mRel)) {
return false;
}
if (!ReadParam(aReader, &aResult->mTitle)) {
return false;
}
if (!ReadParam(aReader, &aResult->mIntegrity)) {
return false;
}
if (!ReadParam(aReader, &aResult->mSrcset)) {
return false;
}
if (!ReadParam(aReader, &aResult->mSizes)) {
return false;
}
if (!ReadParam(aReader, &aResult->mType)) {
return false;
}
if (!ReadParam(aReader, &aResult->mMedia)) {
return false;
}
if (!ReadParam(aReader, &aResult->mCrossOrigin)) {
return false;
}
if (!ReadParam(aReader, &aResult->mReferrerPolicy)) {
return false;
}
return ReadParam(aReader, &aResult->mAs);
};
};
} /* namespace IPC */
#endif /* __IPC_GLUE_IPCMESSAGEUTILSSPECIALIZATIONS_H__ */

2
layout/generic/nsImageFrame.cpp
View File

@@ -2692,7 +2692,7 @@ nsresult nsImageFrame::LoadIcon(const nsAString& aSpec,
loadFlags, nullptr, contentPolicyType, u""_ns,
false, /* aUseUrgentStartForChannel */
false, /* aLinkPreload */
0, aRequest);
aRequest);
}
void nsImageFrame::GetDocumentCharacterSet(nsACString& aCharset) const {

3
layout/style/FontPreloader.cpp
View File

@@ -25,8 +25,7 @@ void FontPreloader::PrioritizeAsPreload() { PrioritizeAsPreload(Channel()); }
nsresult FontPreloader::CreateChannel(
nsIChannel** aChannel, nsIURI* aURI, const CORSMode aCORSMode,
const dom::ReferrerPolicy& aReferrerPolicy, dom::Document* aDocument,
nsILoadGroup* aLoadGroup, nsIInterfaceRequestor* aCallbacks,
uint64_t aEarlyHintPreloaderId) {
nsILoadGroup* aLoadGroup, nsIInterfaceRequestor* aCallbacks) {
return BuildChannel(aChannel, aURI, aCORSMode, aReferrerPolicy, nullptr,
nullptr, aDocument, aLoadGroup, aCallbacks, true);
}

3
layout/style/FontPreloader.h
View File

@@ -49,8 +49,7 @@ class FontPreloader final : public FetchPreloader {
const CORSMode aCORSMode,
const dom::ReferrerPolicy& aReferrerPolicy,
dom::Document* aDocument, nsILoadGroup* aLoadGroup,
nsIInterfaceRequestor* aCallbacks,
uint64_t aEarlyHintPreloaderId) override;
nsIInterfaceRequestor* aCallbacks) override;
static void BuildChannelFlags(
nsIURI* aURI, bool aIsPreload,

38
layout/style/Loader.cpp
View File

@@ -20,7 +20,6 @@
#include "mozilla/ResultExtensions.h"
#include "mozilla/SchedulerGroup.h"
#include "mozilla/URLPreloader.h"
#include "nsIChildChannel.h"
#include "nsIRunnable.h"
#include "nsISupportsPriority.h"
#include "nsITimedChannel.h"
@@ -466,7 +465,7 @@ void SheetLoadData::FireLoadEvent(nsIThreadInternal* aThread) {
}
void SheetLoadData::StartPendingLoad() {
mLoader->LoadSheet(*this, Loader::SheetState::NeedsParser, 0,
mLoader->LoadSheet(*this, Loader::SheetState::NeedsParser,
Loader::PendingLoad::Yes);
}
@@ -1185,7 +1184,6 @@ void Loader::InsertChildSheet(StyleSheet& aSheet, StyleSheet& aParentSheet) {
* a new load is kicked off asynchronously.
*/
nsresult Loader::LoadSheet(SheetLoadData& aLoadData, SheetState aSheetState,
uint64_t aEarlyHintPreloaderId,
PendingLoad aPendingLoad) {
LOG(("css::Loader::LoadSheet"));
MOZ_ASSERT(aLoadData.mURI, "Need a URI to load");
@@ -1503,8 +1501,6 @@ nsresult Loader::LoadSheet(SheetLoadData& aLoadData, SheetState aSheetState,
timedChannel->SetReportResourceTiming(false);
}
} else if (aEarlyHintPreloaderId) {
timedChannel->SetInitiatorType(u"early-hints"_ns);
} else {
timedChannel->SetInitiatorType(u"link"_ns);
}
@@ -1524,14 +1520,6 @@ nsresult Loader::LoadSheet(SheetLoadData& aLoadData, SheetState aSheetState,
nsINetworkPredictor::LEARN_LOAD_SUBRESOURCE, mDocument);
}
if (aEarlyHintPreloaderId) {
nsCOMPtr<nsIHttpChannelInternal> channelInternal =
do_QueryInterface(channel);
NS_ENSURE_TRUE(channelInternal != nullptr, NS_ERROR_FAILURE);
rv = channelInternal->SetEarlyHintPreloaderId(aEarlyHintPreloaderId);
NS_ENSURE_SUCCESS(rv, rv);
}
rv = channel->AsyncOpen(streamLoader);
if (NS_FAILED(rv)) {
LOG_ERROR((" Failed to create stream loader"));
@@ -1922,7 +1910,7 @@ Result<Loader::LoadSheetResult, nsresult> Loader::LoadStyleLink(
"These should better match!");
// Load completion will free the data
rv = LoadSheet(*data, state, 0);
rv = LoadSheet(*data, state);
if (NS_FAILED(rv)) {
return Err(rv);
}
@@ -2057,7 +2045,7 @@ nsresult Loader::LoadChildSheet(StyleSheet& aParentSheet,
bool syncLoad = data->mSyncLoad;
// Load completion will release the data
rv = LoadSheet(*data, state, 0);
rv = LoadSheet(*data, state);
NS_ENSURE_SUCCESS(rv, rv);
if (!syncLoad) {
@@ -2073,7 +2061,7 @@ Result<RefPtr<StyleSheet>, nsresult> Loader::LoadSheetSync(
nsCOMPtr<nsIReferrerInfo> referrerInfo = new ReferrerInfo(nullptr);
return InternalLoadNonDocumentSheet(
aURL, StylePreloadKind::None, aParsingMode, aUseSystemPrincipal, nullptr,
referrerInfo, nullptr, CORS_NONE, u""_ns, 0);
referrerInfo, nullptr, CORS_NONE, u""_ns);
}
Result<RefPtr<StyleSheet>, nsresult> Loader::LoadSheet(
@@ -2082,27 +2070,25 @@ Result<RefPtr<StyleSheet>, nsresult> Loader::LoadSheet(
nsCOMPtr<nsIReferrerInfo> referrerInfo = new ReferrerInfo(nullptr);
return InternalLoadNonDocumentSheet(
aURI, StylePreloadKind::None, aParsingMode, aUseSystemPrincipal, nullptr,
referrerInfo, aObserver, CORS_NONE, u""_ns, 0);
referrerInfo, aObserver, CORS_NONE, u""_ns);
}
Result<RefPtr<StyleSheet>, nsresult> Loader::LoadSheet(
nsIURI* aURL, StylePreloadKind aPreloadKind,
const Encoding* aPreloadEncoding, nsIReferrerInfo* aReferrerInfo,
nsICSSLoaderObserver* aObserver, uint64_t aEarlyHintPreloaderId,
CORSMode aCORSMode, const nsAString& aIntegrity) {
nsICSSLoaderObserver* aObserver, CORSMode aCORSMode,
const nsAString& aIntegrity) {
LOG(("css::Loader::LoadSheet(aURL, aObserver) api call"));
return InternalLoadNonDocumentSheet(aURL, aPreloadKind, eAuthorSheetFeatures,
UseSystemPrincipal::No, aPreloadEncoding,
aReferrerInfo, aObserver, aCORSMode,
aIntegrity, aEarlyHintPreloaderId);
return InternalLoadNonDocumentSheet(
aURL, aPreloadKind, eAuthorSheetFeatures, UseSystemPrincipal::No,
aPreloadEncoding, aReferrerInfo, aObserver, aCORSMode, aIntegrity);
}
Result<RefPtr<StyleSheet>, nsresult> Loader::InternalLoadNonDocumentSheet(
nsIURI* aURL, StylePreloadKind aPreloadKind, SheetParsingMode aParsingMode,
UseSystemPrincipal aUseSystemPrincipal, const Encoding* aPreloadEncoding,
nsIReferrerInfo* aReferrerInfo, nsICSSLoaderObserver* aObserver,
CORSMode aCORSMode, const nsAString& aIntegrity,
uint64_t aEarlyHintPreloaderId) {
CORSMode aCORSMode, const nsAString& aIntegrity) {
MOZ_ASSERT(aURL, "Must have a URI to load");
MOZ_ASSERT(aUseSystemPrincipal == UseSystemPrincipal::No || !aObserver,
"Shouldn't load system-principal sheets async");
@@ -2152,7 +2138,7 @@ Result<RefPtr<StyleSheet>, nsresult> Loader::InternalLoadNonDocumentSheet(
return sheet;
}
rv = LoadSheet(*data, state, aEarlyHintPreloaderId);
rv = LoadSheet(*data, state);
if (NS_FAILED(rv)) {
return Err(rv);
}

11
layout/style/Loader.h
View File

@@ -361,8 +361,6 @@ class Loader final {
* @param aReferrerInfo referrer information of the sheet.
* @param aObserver the observer to notify when the load completes.
* Must not be null.
* @param aEarlyHintPreloaderId to connect back to the early hint preload
* channel. Null means no connect back should happen
* @return the sheet to load. Note that the sheet may well not be loaded by
* the time this method returns.
*
@@ -373,8 +371,7 @@ class Loader final {
Result<RefPtr<StyleSheet>, nsresult> LoadSheet(
nsIURI* aURI, StylePreloadKind, const Encoding* aPreloadEncoding,
nsIReferrerInfo* aReferrerInfo, nsICSSLoaderObserver* aObserver,
uint64_t aEarlyHintPreloaderId, CORSMode = CORS_NONE,
const nsAString& aIntegrity = u""_ns);
CORSMode = CORS_NONE, const nsAString& aIntegrity = u""_ns);
/**
* As above, but without caring for a couple things.
@@ -541,8 +538,7 @@ class Loader final {
nsIURI* aURL, StylePreloadKind, SheetParsingMode aParsingMode,
UseSystemPrincipal, const Encoding* aPreloadEncoding,
nsIReferrerInfo* aReferrerInfo, nsICSSLoaderObserver* aObserver,
CORSMode aCORSMode, const nsAString& aIntegrity,
uint64_t aEarlyHintPreloaderId);
CORSMode aCORSMode, const nsAString& aIntegrity);
RefPtr<StyleSheet> LookupInlineSheetInCache(const nsAString&);
@@ -560,8 +556,7 @@ class Loader final {
// Note: LoadSheet is responsible for setting the sheet to complete on
// failure.
enum class PendingLoad { No, Yes };
nsresult LoadSheet(SheetLoadData&, SheetState, uint64_t aEarlyHintPreloaderId,
PendingLoad = PendingLoad::No);
nsresult LoadSheet(SheetLoadData&, SheetState, PendingLoad = PendingLoad::No);
enum class AllowAsyncParse {
Yes,

4
netwerk/ipc/DocumentChannelChild.cpp
View File

@@ -267,10 +267,6 @@ IPCResult DocumentChannelChild::RecvRedirectToRealChannel(
newChannel->SetLoadGroup(mLoadGroup);
}
if (RefPtr<HttpBaseChannel> httpChannel = do_QueryObject(newChannel)) {
httpChannel->SetEarlyHints(std::move(aArgs.earlyHints()));
}
// This is used to report any errors back to the parent by calling
// CrossProcessRedirectFinished.
auto scopeExit = MakeScopeExit([&]() {

10
netwerk/ipc/DocumentChannelParent.cpp
View File

@@ -11,7 +11,6 @@
#include "mozilla/dom/CanonicalBrowsingContext.h"
#include "mozilla/dom/ClientInfo.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/net/NeckoChannelParams.h"
#include "nsDocShellLoadState.h"
extern mozilla::LazyLogModule gDocumentChannelLog;
@@ -97,8 +96,7 @@ bool DocumentChannelParent::Init(dom::CanonicalBrowsingContext* aContext,
// PDocumentChannel::RedirectToRealChannelPromise given as parameter.
auto promise = self->RedirectToRealChannel(
std::move(aResolveValue.mStreamFilterEndpoints),
aResolveValue.mRedirectFlags, aResolveValue.mLoadFlags,
std::move(aResolveValue.mEarlyHints));
aResolveValue.mRedirectFlags, aResolveValue.mLoadFlags);
// We chain the promise the DLL is waiting on to the one returned by
// RedirectToRealChannel. As soon as the promise returned is resolved
// or rejected, so will the DLL's promise.
@@ -137,8 +135,7 @@ RefPtr<PDocumentChannelParent::RedirectToRealChannelPromise>
DocumentChannelParent::RedirectToRealChannel(
nsTArray<ipc::Endpoint<extensions::PStreamFilterParent>>&&
aStreamFilterEndpoints,
uint32_t aRedirectFlags, uint32_t aLoadFlags,
nsTArray<EarlyHintConnectArgs>&& aEarlyHints) {
uint32_t aRedirectFlags, uint32_t aLoadFlags) {
if (!CanSend()) {
return PDocumentChannelParent::RedirectToRealChannelPromise::
CreateAndReject(ResponseRejectReason::ChannelClosed, __func__);
@@ -146,8 +143,7 @@ DocumentChannelParent::RedirectToRealChannel(
RedirectToRealChannelArgs args;
mDocumentLoadListener->SerializeRedirectData(
args, false, aRedirectFlags, aLoadFlags,
static_cast<ContentParent*>(Manager()->Manager()),
std::move(aEarlyHints));
static_cast<ContentParent*>(Manager()->Manager()));
return SendRedirectToRealChannel(args, std::move(aStreamFilterEndpoints));
}

5
netwerk/ipc/DocumentChannelParent.h
View File

@@ -16,8 +16,6 @@ class CanonicalBrowsingContext;
}
namespace net {
class EarlyHintConnectArgs;
/**
* An actor that forwards all changes across to DocumentChannelChild, the
* nsIChannel implementation owned by a content process docshell.
@@ -54,8 +52,7 @@ class DocumentChannelParent final
RedirectToRealChannel(
nsTArray<ipc::Endpoint<extensions::PStreamFilterParent>>&&
aStreamFilterEndpoints,
uint32_t aRedirectFlags, uint32_t aLoadFlags,
nsTArray<EarlyHintConnectArgs>&& aEarlyHints);
uint32_t aRedirectFlags, uint32_t aLoadFlags);
virtual ~DocumentChannelParent();

126
netwerk/ipc/DocumentLoadListener.cpp
View File

@@ -7,7 +7,6 @@
#include "DocumentLoadListener.h"
#include "NeckoCommon.h"
#include "mozilla/AntiTrackingUtils.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/LoadInfo.h"
@@ -1204,8 +1203,8 @@ void DocumentLoadListener::Disconnect(bool aContinueNavigating) {
// Don't cancel ongoing early hints when continuing to load the web page.
// Early hints are loaded earlier in the code and shouldn't get cancelled
// here. See also: Bug 1765652
if (!aContinueNavigating) {
mEarlyHintsService.Cancel();
if (GetLoadingBrowsingContext() && !aContinueNavigating) {
GetLoadingBrowsingContext()->mEarlyHintsService.Cancel();
}
if (auto* ctx = GetDocumentBrowsingContext()) {
@@ -1424,9 +1423,54 @@ bool DocumentLoadListener::ResumeSuspendedChannel(
if (!aListener) {
streamListenerFunctions.Clear();
}
ForwardStreamListenerFunctions(streamListenerFunctions, aListener);
nsresult rv = NS_OK;
for (auto& variant : streamListenerFunctions) {
variant.match(
[&](const OnStartRequestParams& aParams) {
rv = aListener->OnStartRequest(aParams.request);
if (NS_FAILED(rv)) {
aParams.request->Cancel(rv);
}
},
[&](const OnDataAvailableParams& aParams) {
// Don't deliver OnDataAvailable if we've
// already failed.
if (NS_FAILED(rv)) {
return;
}
nsCOMPtr<nsIInputStream> stringStream;
rv = NS_NewByteInputStream(
getter_AddRefs(stringStream),
Span<const char>(aParams.data.get(), aParams.count),
NS_ASSIGNMENT_DEPEND);
if (NS_SUCCEEDED(rv)) {
rv = aListener->OnDataAvailable(aParams.request, stringStream,
aParams.offset, aParams.count);
}
if (NS_FAILED(rv)) {
aParams.request->Cancel(rv);
}
},
[&](const OnStopRequestParams& aParams) {
if (NS_SUCCEEDED(rv)) {
aListener->OnStopRequest(aParams.request, aParams.status);
} else {
aListener->OnStopRequest(aParams.request, rv);
}
rv = NS_OK;
},
[&](const OnAfterLastPartParams& aParams) {
nsCOMPtr<nsIMultiPartChannelListener> multiListener =
do_QueryInterface(aListener);
if (multiListener) {
if (NS_SUCCEEDED(rv)) {
multiListener->OnAfterLastPart(aParams.status);
} else {
multiListener->OnAfterLastPart(rv);
}
}
});
}
// We don't expect to get new stream listener functions added
// via re-entrancy. If this ever happens, we should understand
// exactly why before allowing it.
@@ -1442,11 +1486,10 @@ bool DocumentLoadListener::ResumeSuspendedChannel(
void DocumentLoadListener::SerializeRedirectData(
RedirectToRealChannelArgs& aArgs, bool aIsCrossProcess,
uint32_t aRedirectFlags, uint32_t aLoadFlags, ContentParent* aParent,
nsTArray<EarlyHintConnectArgs>&& aEarlyHints) const {
uint32_t aRedirectFlags, uint32_t aLoadFlags,
ContentParent* aParent) const {
aArgs.uri() = GetChannelCreationURI();
aArgs.loadIdentifier() = mLoadIdentifier;
aArgs.earlyHints() = std::move(aEarlyHints);
// I previously used HttpBaseChannel::CloneLoadInfoForRedirect, but that
// clears the principal to inherit, which fails tests (probably because this
@@ -2077,12 +2120,9 @@ DocumentLoadListener::RedirectToRealChannel(
CreateAndReject(ipc::ResponseRejectReason::SendError, __func__);
}
nsTArray<EarlyHintConnectArgs> ehArgs;
mEarlyHintsService.RegisterLinksAndGetConnectArgs(ehArgs);
RedirectToRealChannelArgs args;
SerializeRedirectData(args, /* aIsCrossProcess */ true, aRedirectFlags,
aLoadFlags, cp, std::move(ehArgs));
aLoadFlags, cp);
if (mTiming) {
mTiming->Anonymize(args.uri());
args.timing() = Some(std::move(mTiming));
@@ -2118,14 +2158,10 @@ DocumentLoadListener::RedirectToRealChannel(
auto promise =
MakeRefPtr<PDocumentChannelParent::RedirectToRealChannelPromise::Private>(
__func__);
nsTArray<EarlyHintConnectArgs> ehArgs;
mEarlyHintsService.RegisterLinksAndGetConnectArgs(ehArgs);
mOpenPromise->Resolve(OpenPromiseSucceededType(
{std::move(aStreamFilterEndpoints), aRedirectFlags,
aLoadFlags, std::move(ehArgs), promise}),
__func__);
mOpenPromise->Resolve(
OpenPromiseSucceededType({std::move(aStreamFilterEndpoints),
aRedirectFlags, aLoadFlags, promise}),
__func__);
// There is no way we could come back here if the promise had been resolved
// previously. But for clarity and to avoid all doubt, we set this boolean to
@@ -2540,12 +2576,15 @@ DocumentLoadListener::OnStartRequest(nsIRequest* aRequest) {
}
}
if (httpChannel) {
uint32_t responseStatus = 0;
Unused << httpChannel->GetResponseStatus(&responseStatus);
mEarlyHintsService.FinalResponse(responseStatus);
} else {
mEarlyHintsService.Cancel();
if (GetLoadingBrowsingContext()) {
if (httpChannel) {
uint32_t responseStatus;
Unused << httpChannel->GetResponseStatus(&responseStatus);
GetLoadingBrowsingContext()->mEarlyHintsService.FinalResponse(
responseStatus);
} else {
GetLoadingBrowsingContext()->mEarlyHintsService.Cancel();
}
}
// If we're going to be delivering this channel to a remote content
@@ -2765,22 +2804,20 @@ DocumentLoadListener::AsyncOnChannelRedirect(
return NS_OK;
}
// Cancel cross origin redirects as described by whatwg:
// > Note: [The early hint reponse] is discarded if it is succeeded by a
// > cross-origin redirect.
// https://html.spec.whatwg.org/multipage/semantics.html#early-hints
nsCOMPtr<nsIURI> oldURI;
aOldChannel->GetURI(getter_AddRefs(oldURI));
if (!net::ChannelIsPost(aOldChannel)) {
AddURIVisit(aOldChannel, 0);
nsDocShell::SaveLastVisit(aNewChannel, oldURI, aFlags);
}
nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
nsresult rv = ssm->CheckSameOriginURI(oldURI, uri, false, false);
if (NS_FAILED(rv)) {
mEarlyHintsService.Cancel();
}
if (GetDocumentBrowsingContext()) {
nsCOMPtr<nsIURI> oldURI;
aOldChannel->GetURI(getter_AddRefs(oldURI));
if (!net::ChannelIsPost(aOldChannel)) {
AddURIVisit(aOldChannel, 0);
nsDocShell::SaveLastVisit(aNewChannel, oldURI, aFlags);
}
nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
nsresult rv = ssm->CheckSameOriginURI(oldURI, uri, false, false);
if (NS_FAILED(rv)) {
GetLoadingBrowsingContext()->mEarlyHintsService.Cancel();
}
}
mHaveVisibleRedirect |= true;
LOG(
@@ -2912,7 +2949,10 @@ NS_IMETHODIMP DocumentLoadListener::OnStatus(nsIRequest* aRequest,
NS_IMETHODIMP DocumentLoadListener::EarlyHint(const nsACString& linkHeader) {
LOG(("DocumentLoadListener::EarlyHint.\n"));
mEarlyHintsService.EarlyHint(linkHeader, GetChannelCreationURI(), mChannel);
if (GetLoadingBrowsingContext()) {
GetLoadingBrowsingContext()->mEarlyHintsService.EarlyHint(
linkHeader, GetChannelCreationURI(), mChannel);
}
return NS_OK;
}

11
netwerk/ipc/DocumentLoadListener.h
View File

@@ -110,7 +110,6 @@ class DocumentLoadListener : public nsIInterfaceRequestor,
mStreamFilterEndpoints;
uint32_t mRedirectFlags;
uint32_t mLoadFlags;
nsTArray<EarlyHintConnectArgs> mEarlyHints;
RefPtr<PDocumentChannelParent::RedirectToRealChannelPromise::Private>
mPromise;
};
@@ -279,10 +278,10 @@ class DocumentLoadListener : public nsIInterfaceRequestor,
// Serializes all data needed to setup the new replacement channel
// in the content process into the RedirectToRealChannelArgs struct.
void SerializeRedirectData(
RedirectToRealChannelArgs& aArgs, bool aIsCrossProcess,
uint32_t aRedirectFlags, uint32_t aLoadFlags, dom::ContentParent* aParent,
nsTArray<EarlyHintConnectArgs>&& aEarlyHints) const;
void SerializeRedirectData(RedirectToRealChannelArgs& aArgs,
bool aIsCrossProcess, uint32_t aRedirectFlags,
uint32_t aLoadFlags,
dom::ContentParent* aParent) const;
uint64_t GetLoadIdentifier() const { return mLoadIdentifier; }
uint32_t GetLoadType() const { return mLoadStateLoadType; }
@@ -514,8 +513,6 @@ class DocumentLoadListener : public nsIInterfaceRequestor,
// switch occurs.
RefPtr<nsDOMNavigationTiming> mTiming;
net::EarlyHintsService mEarlyHintsService;
// An optional ObjectUpgradeHandler which can be used to upgrade an <object>
// or <embed> element to contain a nsFrameLoader, allowing us to switch them
// into a different process.

8
netwerk/ipc/NeckoChannelParams.ipdlh
View File

@@ -36,7 +36,6 @@ using nsILoadInfo::CrossOriginEmbedderPolicy from "nsILoadInfo.h";
using nsILoadInfo::StoragePermissionState from "nsILoadInfo.h";
using struct mozilla::dom::LoadingSessionHistoryInfo from "mozilla/dom/SessionHistoryEntry.h";
using mozilla::dom::RequestMode from "mozilla/dom/RequestBinding.h";
using mozilla::net::LinkHeader from "nsNetUtil.h";
namespace mozilla {
namespace net {
@@ -344,7 +343,6 @@ struct HttpChannelOpenArgs
TimeStamp handleFetchEventEnd;
bool forceMainDocumentChannel;
TimeStamp navigationStartTimeStamp;
uint64_t earlyHintPreloaderId;
};
struct HttpChannelConnectArgs
@@ -460,11 +458,6 @@ struct DocumentChannelCreationArgs {
uint64_t parentInitiatedNavigationEpoch;
};
struct EarlyHintConnectArgs {
LinkHeader link;
uint64_t earlyHintPreloaderId;
};
struct RedirectToRealChannelArgs {
uint32_t registrarId;
nsIURI uri;
@@ -487,7 +480,6 @@ struct RedirectToRealChannelArgs {
LoadingSessionHistoryInfo? loadingSessionHistoryInfo;
uint64_t loadIdentifier;
nsCString? originalUriString;
EarlyHintConnectArgs[] earlyHints;
};
struct TimingStructArgs {

70
netwerk/ipc/NeckoCommon.cpp
View File

@@ -1,70 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 ts=8 et tw=80 : */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "NeckoCommon.h"
#include "nsIInputStream.h"
#include "nsIMultiPartChannel.h"
#include "nsIParentChannel.h"
#include "nsStringStream.h"
namespace mozilla::net {
nsresult ForwardStreamListenerFunctions(
nsTArray<StreamListenerFunction>& aCalls, nsIStreamListener* aParent) {
nsresult rv = NS_OK;
for (auto& variant : aCalls) {
variant.match(
[&](const OnStartRequestParams& aParams) {
rv = aParent->OnStartRequest(aParams.request);
if (NS_FAILED(rv)) {
aParams.request->Cancel(rv);
}
},
[&](const OnDataAvailableParams& aParams) {
// Don't deliver OnDataAvailable if we've
// already failed.
if (NS_FAILED(rv)) {
return;
}
nsCOMPtr<nsIInputStream> stringStream;
rv = NS_NewByteInputStream(
getter_AddRefs(stringStream),
Span<const char>(aParams.data.get(), aParams.count),
NS_ASSIGNMENT_DEPEND);
if (NS_SUCCEEDED(rv)) {
rv = aParent->OnDataAvailable(aParams.request, stringStream,
aParams.offset, aParams.count);
}
if (NS_FAILED(rv)) {
aParams.request->Cancel(rv);
}
},
[&](const OnStopRequestParams& aParams) {
if (NS_SUCCEEDED(rv)) {
aParent->OnStopRequest(aParams.request, aParams.status);
} else {
aParent->OnStopRequest(aParams.request, rv);
}
rv = NS_OK;
},
[&](const OnAfterLastPartParams& aParams) {
nsCOMPtr<nsIMultiPartChannelListener> multiListener =
do_QueryInterface(aParent);
if (multiListener) {
if (NS_SUCCEEDED(rv)) {
multiListener->OnAfterLastPart(aParams.status);
} else {
multiListener->OnAfterLastPart(rv);
}
}
});
}
return rv;
}
} // namespace mozilla::net

5
netwerk/ipc/NeckoCommon.h
View File

@@ -15,8 +15,6 @@
#include "nsXULAppAPI.h"
#include "prenv.h"
class nsIStreamListener;
namespace mozilla {
namespace dom {
class BrowserChild;
@@ -134,9 +132,6 @@ using StreamListenerFunction =
mozilla::Variant<OnStartRequestParams, OnDataAvailableParams,
OnStopRequestParams, OnAfterLastPartParams>;
nsresult ForwardStreamListenerFunctions(
nsTArray<StreamListenerFunction>& aCalls, nsIStreamListener* aParent);
} // namespace net
} // namespace mozilla

6
netwerk/ipc/ParentProcessDocumentChannel.cpp
View File

@@ -48,8 +48,7 @@ RefPtr<RedirectToRealChannelPromise>
ParentProcessDocumentChannel::RedirectToRealChannel(
nsTArray<ipc::Endpoint<extensions::PStreamFilterParent>>&&
aStreamFilterEndpoints,
uint32_t aRedirectFlags, uint32_t aLoadFlags,
const nsTArray<EarlyHintConnectArgs>& aEarlyHints) {
uint32_t aRedirectFlags, uint32_t aLoadFlags) {
LOG(("ParentProcessDocumentChannel RedirectToRealChannel [this=%p]", this));
nsCOMPtr<nsIChannel> channel = mDocumentLoadListener->GetChannel();
channel->SetLoadFlags(aLoadFlags);
@@ -208,8 +207,7 @@ NS_IMETHODIMP ParentProcessDocumentChannel::AsyncOpen(
RefPtr<RedirectToRealChannelPromise> p =
self->RedirectToRealChannel(
std::move(aResolveValue.mStreamFilterEndpoints),
aResolveValue.mRedirectFlags, aResolveValue.mLoadFlags,
aResolveValue.mEarlyHints)
aResolveValue.mRedirectFlags, aResolveValue.mLoadFlags)
->Then(
GetCurrentSerialEventTarget(), __func__,
[self](RedirectToRealChannelPromise::ResolveOrRejectValue&&

5
netwerk/ipc/ParentProcessDocumentChannel.h
View File

@@ -16,8 +16,6 @@
namespace mozilla {
namespace net {
class EarlyHintConnectArgs;
class ParentProcessDocumentChannel : public DocumentChannel,
public nsIAsyncVerifyRedirectCallback,
public nsIObserver {
@@ -40,8 +38,7 @@ class ParentProcessDocumentChannel : public DocumentChannel,
RedirectToRealChannel(
nsTArray<ipc::Endpoint<extensions::PStreamFilterParent>>&&
aStreamFilterEndpoints,
uint32_t aRedirectFlags, uint32_t aLoadFlags,
const nsTArray<EarlyHintConnectArgs>& aEarlyHints);
uint32_t aRedirectFlags, uint32_t aLoadFlags);
private:
virtual ~ParentProcessDocumentChannel();

1
netwerk/ipc/moz.build
View File

@@ -41,7 +41,6 @@ UNIFIED_SOURCES += [
"InputChannelThrottleQueueChild.cpp",
"InputChannelThrottleQueueParent.cpp",
"NeckoChild.cpp",
"NeckoCommon.cpp",
"NeckoParent.cpp",
"NeckoTargetHolder.cpp",
"ParentChannelWrapper.cpp",

12
netwerk/protocol/http/ClassifierDummyChannel.cpp
View File

@@ -812,18 +812,6 @@ ClassifierDummyChannel::SetEarlyHintObserver(nsIEarlyHintObserver* aObserver) {
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
ClassifierDummyChannel::SetEarlyHintPreloaderId(
uint64_t aEarlyHintPreloaderId) {
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
ClassifierDummyChannel::GetEarlyHintPreloaderId(
uint64_t* aEarlyHintPreloaderId) {
return NS_ERROR_NOT_IMPLEMENTED;
}
void ClassifierDummyChannel::SetConnectionInfo(
mozilla::net::nsHttpConnectionInfo* aInfo) {}

264
netwerk/protocol/http/EarlyHintPreloader.cpp
View File

@@ -4,42 +4,28 @@
#include "EarlyHintPreloader.h"
#include "EarlyHintRegistrar.h"
#include "EarlyHintsService.h"
#include "ErrorList.h"
#include "HttpChannelParent.h"
#include "MainThreadUtils.h"
#include "NeckoCommon.h"
#include "mozilla/CORSMode.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/ReferrerInfo.h"
#include "mozilla/StaticPrefs_network.h"
#include "mozilla/glean/GleanMetrics.h"
#include "mozilla/Logging.h"
#include "mozilla/net/EarlyHintRegistrar.h"
#include "mozilla/net/NeckoChannelParams.h"
#include "mozilla/StaticPrefs_network.h"
#include "nsAttrValue.h"
#include "nsAttrValueInlines.h"
#include "nsCOMPtr.h"
#include "nsContentSecurityManager.h"
#include "nsContentUtils.h"
#include "nsDebug.h"
#include "nsHttpChannel.h"
#include "nsIAsyncVerifyRedirectCallback.h"
#include "nsICacheInfoChannel.h"
#include "nsIChannel.h"
#include "nsIHttpChannel.h"
#include "nsIInputStream.h"
#include "nsILoadInfo.h"
#include "nsIParentChannel.h"
#include "nsIReferrerInfo.h"
#include "nsIURI.h"
#include "nsNetUtil.h"
#include "nsQueryObject.h"
#include "nsStreamUtils.h"
#include "nsStringStream.h"
#include "ParentChannelListener.h"
#include "nsIChannel.h"
//
// To enable logging (see mozilla/Logging.h for full details):
@@ -60,53 +46,30 @@ static mozilla::LazyLogModule gEarlyHintLog("EarlyHint");
namespace mozilla::net {
namespace {
// This id uniquely identifies each early hint preloader in the
// EarlyHintRegistrar. Must only be accessed from main thread.
static uint64_t gEarlyHintPreloaderId{0};
} // namespace
//=============================================================================
// OngoingEarlyHints
//=============================================================================
void OngoingEarlyHints::CancelAllOngoingPreloads() {
for (auto& preloader : mPreloaders) {
preloader->CancelChannel(nsresult::NS_ERROR_ABORT);
for (auto& el : mOngoingPreloads) {
el.GetData()->CancelChannel(nsresult::NS_ERROR_ABORT);
}
mStartedPreloads.Clear();
}
bool OngoingEarlyHints::Contains(const PreloadHashKey& aKey) {
return mStartedPreloads.Contains(aKey);
return mOngoingPreloads.Contains(aKey);
}
bool OngoingEarlyHints::Add(const PreloadHashKey& aKey,
RefPtr<EarlyHintPreloader> aPreloader) {
if (!mStartedPreloads.Contains(aKey)) {
mStartedPreloads.Insert(aKey);
mPreloaders.AppendElement(aPreloader);
return true;
}
return false;
}
void OngoingEarlyHints::RegisterLinksAndGetConnectArgs(
nsTArray<EarlyHintConnectArgs>& aOutLinks) {
// register all channels before returning
for (auto& preload : mPreloaders) {
aOutLinks.AppendElement(preload->Register());
}
return mOngoingPreloads.InsertOrUpdate(aKey, aPreloader);
}
//=============================================================================
// EarlyHintPreloader
//=============================================================================
EarlyHintPreloader::EarlyHintPreloader() {
AssertIsOnMainThread();
mConnectArgs.earlyHintPreloaderId() = ++gEarlyHintPreloaderId;
};
EarlyHintPreloader::EarlyHintPreloader(nsIURI* aURI) : mURI(aURI) {}
/* static */
Maybe<PreloadHashKey> EarlyHintPreloader::GenerateHashKey(
@@ -208,15 +171,8 @@ void EarlyHintPreloader::MaybeCreateAndInsertPreload(
}
nsCOMPtr<nsIURI> uri;
NS_ENSURE_SUCCESS_VOID(
NS_NewURI(getter_AddRefs(uri), aHeader.mHref, nullptr, aBaseURI));
// The link relation may apply to a different resource, specified
// in the anchor parameter. For the link relations supported so far,
// we simply abort if the link applies to a resource different to the
// one we've loaded
if (!nsContentUtils::LinkContextIsURI(aHeader.mAnchor, uri)) {
return;
}
// use the base uri
NS_ENSURE_SUCCESS_VOID(aHeader.NewResolveHref(getter_AddRefs(uri), aBaseURI));
// only preload secure context urls
if (!uri->SchemeIs("https")) {
@@ -248,25 +204,24 @@ void EarlyHintPreloader::MaybeCreateAndInsertPreload(
nsCOMPtr<nsIReferrerInfo> referrerInfo =
new dom::ReferrerInfo(aBaseURI, referrerPolicy);
RefPtr<EarlyHintPreloader> earlyHintPreloader = new EarlyHintPreloader();
RefPtr<EarlyHintPreloader> earlyHintPreloader =
RefPtr(new EarlyHintPreloader(uri));
nsSecurityFlags securityFlags = EarlyHintPreloader::ComputeSecurityFlags(
corsMode, static_cast<ASDestination>(as.GetEnumValue()),
aHeader.mType.LowerCaseEqualsASCII("module"));
NS_ENSURE_SUCCESS_VOID(earlyHintPreloader->OpenChannel(
uri, aPrincipal, securityFlags, contentPolicyType, referrerInfo,
aPrincipal, securityFlags, contentPolicyType, referrerInfo,
aCookieJarSettings));
earlyHintPreloader->SetLinkHeader(aHeader);
DebugOnly<bool> result =
aOngoingEarlyHints->Add(*hashKey, earlyHintPreloader);
MOZ_ASSERT(result);
}
nsresult EarlyHintPreloader::OpenChannel(
nsIURI* aURI, nsIPrincipal* aPrincipal, nsSecurityFlags aSecurityFlags,
nsIPrincipal* aPrincipal, nsSecurityFlags aSecurityFlags,
nsContentPolicyType aContentPolicyType, nsIReferrerInfo* aReferrerInfo,
nsICookieJarSettings* aCookieJarSettings) {
MOZ_ASSERT(aContentPolicyType == nsContentPolicyType::TYPE_IMAGE ||
@@ -276,7 +231,7 @@ nsresult EarlyHintPreloader::OpenChannel(
aContentPolicyType == nsContentPolicyType::TYPE_STYLESHEET ||
aContentPolicyType == nsContentPolicyType::TYPE_FONT);
nsresult rv =
NS_NewChannel(getter_AddRefs(mChannel), aURI, aPrincipal, aSecurityFlags,
NS_NewChannel(getter_AddRefs(mChannel), mURI, aPrincipal, aSecurityFlags,
aContentPolicyType, aCookieJarSettings,
/* aPerformanceStorage */ nullptr,
/* aLoadGroup */ nullptr,
@@ -284,12 +239,6 @@ nsresult EarlyHintPreloader::OpenChannel(
NS_ENSURE_SUCCESS(rv, rv);
RefPtr<nsHttpChannel> httpChannelObject = do_QueryObject(mChannel);
if (!httpChannelObject) {
mChannel = nullptr;
return NS_ERROR_ABORT;
}
// configure HTTP specific stuff
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(mChannel);
if (!httpChannel) {
@@ -301,24 +250,7 @@ nsresult EarlyHintPreloader::OpenChannel(
success = httpChannel->SetRequestHeader("X-Moz"_ns, "early hint"_ns, false);
MOZ_ASSERT(NS_SUCCEEDED(success));
mParentListener = new ParentChannelListener(this, nullptr, false);
rv = mChannel->AsyncOpen(mParentListener);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
void EarlyHintPreloader::SetLinkHeader(const LinkHeader& aLinkHeader) {
mConnectArgs.link() = aLinkHeader;
}
EarlyHintConnectArgs EarlyHintPreloader::Register() {
// Create an entry in the redirect channel registrar to
// allocate an identifier for this load.
RefPtr<EarlyHintRegistrar> registrar = EarlyHintRegistrar::GetOrCreate();
registrar->RegisterEarlyHint(mConnectArgs.earlyHintPreloaderId(), this);
return mConnectArgs;
return mChannel->AsyncOpen(this);
}
nsresult EarlyHintPreloader::CancelChannel(nsresult aStatus) {
@@ -333,176 +265,51 @@ nsresult EarlyHintPreloader::CancelChannel(nsresult aStatus) {
return NS_OK;
}
void EarlyHintPreloader::OnParentReady(nsIParentChannel* aParent,
uint64_t aChannelId) {
AssertIsOnMainThread();
MOZ_ASSERT(aParent);
LOG(("EarlyHintPreloader::OnParentReady [this=%p]\n", this));
mParent = aParent;
mChannelId = aChannelId;
RefPtr<EarlyHintRegistrar> registrar = EarlyHintRegistrar::GetOrCreate();
registrar->DeleteEntry(mConnectArgs.earlyHintPreloaderId());
if (mSuspended) {
SetParentChannel();
InvokeStreamListenerFunctions();
}
}
void EarlyHintPreloader::SetParentChannel() {
RefPtr<HttpBaseChannel> channel = do_QueryObject(mChannel);
RefPtr<HttpChannelParent> parent = do_QueryObject(mParent);
parent->SetHttpChannelFromEarlyHintPreloader(channel);
}
// Adapted from
// https://searchfox.org/mozilla-central/rev/b4150d1c6fae0c51c522df2d2c939cf5ad331d4c/netwerk/ipc/DocumentLoadListener.cpp#1311
bool EarlyHintPreloader::InvokeStreamListenerFunctions() {
AssertIsOnMainThread();
LOG(("EarlyHintPreloader::RedirectToParent [this=%p parent=%p]\n", this,
mParent.get()));
if (nsCOMPtr<nsIIdentChannel> channel = do_QueryInterface(mChannel)) {
MOZ_ASSERT(mChannelId);
DebugOnly<nsresult> rv = channel->SetChannelId(mChannelId);
MOZ_ASSERT(NS_SUCCEEDED(rv));
}
// If we failed to suspend the channel, then we might have received
// some messages while the redirected was being handled.
// Manually send them on now.
if (!mIsFinished) {
// This is safe to do, because OnStartRequest/OnStopRequest/OnDataAvailable
// are all called on the main thread. They can't be called until we worked
// through all functions in the streamListnerFunctions array.
mParentListener->SetListenerAfterRedirect(mParent);
}
nsTArray<StreamListenerFunction> streamListenerFunctions =
std::move(mStreamListenerFunctions);
ForwardStreamListenerFunctions(streamListenerFunctions, mParent);
// We don't expect to get new stream listener functions added
// via re-entrancy. If this ever happens, we should understand
// exactly why before allowing it.
NS_ASSERTION(mStreamListenerFunctions.IsEmpty(),
"Should not have added new stream listener function!");
if (mChannel && mSuspended) {
mChannel->Resume();
}
mChannel = nullptr;
mParent = nullptr;
mParentListener = nullptr;
return true;
}
//-----------------------------------------------------------------------------
// EarlyHintPreloader::nsISupports
//-----------------------------------------------------------------------------
NS_IMPL_ISUPPORTS(EarlyHintPreloader, nsIRequestObserver, nsIStreamListener,
nsIChannelEventSink, nsIInterfaceRequestor,
nsIRedirectResultListener, nsIMultiPartChannelListener);
nsIRedirectResultListener)
//-----------------------------------------------------------------------------
// EarlyHintPreloader::nsIStreamListener
//-----------------------------------------------------------------------------
// Implementation copied and adapted from DocumentLoadListener::OnStartRequest
// https://searchfox.org/mozilla-central/rev/380fc5571b039fd453b45bbb64ed13146fe9b066/netwerk/ipc/DocumentLoadListener.cpp#2317-2508
NS_IMETHODIMP
EarlyHintPreloader::OnStartRequest(nsIRequest* aRequest) {
LOG(("EarlyHintPreloader::OnStartRequest [this=%p]\n", this));
AssertIsOnMainThread();
nsCOMPtr<nsIMultiPartChannel> multiPartChannel = do_QueryInterface(aRequest);
if (multiPartChannel) {
multiPartChannel->GetBaseChannel(getter_AddRefs(mChannel));
} else {
mChannel = do_QueryInterface(aRequest);
}
MOZ_DIAGNOSTIC_ASSERT(mChannel);
LOG(("EarlyHintPreloader::OnStartRequest\n"));
nsCOMPtr<nsICacheInfoChannel> cacheInfoChannel = do_QueryInterface(aRequest);
if (!cacheInfoChannel) {
return NS_ERROR_ABORT;
}
if (mParent) {
SetParentChannel();
mParent->OnStartRequest(aRequest);
InvokeStreamListenerFunctions();
} else {
mStreamListenerFunctions.AppendElement(
AsVariant(OnStartRequestParams{aRequest}));
mChannel->Suspend();
mSuspended = true;
// no need to prefetch an asset that is already in the cache
bool fromCache;
if (NS_SUCCEEDED(cacheInfoChannel->IsFromCache(&fromCache)) && fromCache) {
LOG(("document is already in the cache; canceling prefetch\n"));
return NS_BINDING_ABORTED;
}
return NS_OK;
}
// Implementation copied from DocumentLoadListener::OnStopRequest
// https://searchfox.org/mozilla-central/rev/380fc5571b039fd453b45bbb64ed13146fe9b066/netwerk/ipc/DocumentLoadListener.cpp#2510-2528
NS_IMETHODIMP
EarlyHintPreloader::OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) {
AssertIsOnMainThread();
LOG(("EarlyHintPreloader::OnStopRequest [this=%p]\n", this));
mStreamListenerFunctions.AppendElement(
AsVariant(OnStopRequestParams{aRequest, aStatusCode}));
// If we're not a multi-part channel, then we're finished and we don't
// expect any further events. If we are, then this might be called again,
// so wait for OnAfterLastPart instead.
nsCOMPtr<nsIMultiPartChannel> multiPartChannel = do_QueryInterface(aRequest);
if (!multiPartChannel) {
mIsFinished = true;
}
return NS_OK;
}
//-----------------------------------------------------------------------------
// EarlyHintPreloader::nsIStreamListener
//-----------------------------------------------------------------------------
// Implementation copied from DocumentLoadListener::OnDataAvailable
// https://searchfox.org/mozilla-central/rev/380fc5571b039fd453b45bbb64ed13146fe9b066/netwerk/ipc/DocumentLoadListener.cpp#2530-2549
NS_IMETHODIMP
EarlyHintPreloader::OnDataAvailable(nsIRequest* aRequest,
nsIInputStream* aInputStream,
uint64_t aOffset, uint32_t aCount) {
AssertIsOnMainThread();
LOG(("EarlyHintPreloader::OnDataAvailable [this=%p]\n", this));
// This isn't supposed to happen, since we suspended the channel, but
// sometimes Suspend just doesn't work. This can happen when we're routing
// through nsUnknownDecoder to sniff the content type, and it doesn't handle
// being suspended. Let's just store the data and manually forward it to our
// redirected channel when it's ready.
nsCString data;
nsresult rv = NS_ReadInputStreamToString(aInputStream, data, aCount);
NS_ENSURE_SUCCESS(rv, rv);
mStreamListenerFunctions.AppendElement(
AsVariant(OnDataAvailableParams{aRequest, data, aOffset, aCount}));
return NS_OK;
nsIInputStream* aStream, uint64_t aOffset,
uint32_t aCount) {
uint32_t bytesRead = 0;
nsresult rv =
aStream->ReadSegments(NS_DiscardSegment, nullptr, aCount, &bytesRead);
LOG(("prefetched %u bytes [offset=%" PRIu64 "]\n", bytesRead, aOffset));
return rv;
}
//-----------------------------------------------------------------------------
// EarlyHintPreloader::nsIMultiPartChannelListener
//-----------------------------------------------------------------------------
NS_IMETHODIMP
EarlyHintPreloader::OnAfterLastPart(nsresult aStatus) {
LOG(("EarlyHintPreloader::OnAfterLastPart [this=%p]", this));
mStreamListenerFunctions.AppendElement(
AsVariant(OnAfterLastPartParams{aStatus}));
mIsFinished = true;
EarlyHintPreloader::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
LOG(("EarlyHintPreloader::OnStopRequest\n"));
mChannel = nullptr;
return NS_OK;
}
@@ -514,7 +321,6 @@ NS_IMETHODIMP
EarlyHintPreloader::AsyncOnChannelRedirect(
nsIChannel* aOldChannel, nsIChannel* aNewChannel, uint32_t aFlags,
nsIAsyncVerifyRedirectCallback* callback) {
LOG(("EarlyHintPreloader::AsyncOnChannelRedirect [this=%p]", this));
nsCOMPtr<nsIURI> newURI;
nsresult rv = NS_GetFinalChannelURI(aNewChannel, getter_AddRefs(newURI));
NS_ENSURE_SUCCESS(rv, rv);
@@ -525,6 +331,12 @@ EarlyHintPreloader::AsyncOnChannelRedirect(
return NS_OK;
}
// abort the request if redirecting to insecure context
if (!newURI->SchemeIs("https")) {
callback->OnRedirectVerifyCallback(NS_ERROR_ABORT);
return NS_OK;
}
// HTTP request headers are not automatically forwarded to the new channel.
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aNewChannel);
NS_ENSURE_STATE(httpChannel);
@@ -546,8 +358,6 @@ EarlyHintPreloader::AsyncOnChannelRedirect(
NS_IMETHODIMP
EarlyHintPreloader::OnRedirectResult(nsresult aStatus) {
LOG(("EarlyHintPreloader::OnRedirectResult [this=%p] aProceeding=0x%" PRIx32,
this, static_cast<uint32_t>(aStatus)));
if (NS_SUCCEEDED(aStatus) && mRedirectChannel) {
mChannel = mRedirectChannel;
}

70
netwerk/protocol/http/EarlyHintPreloader.h
View File

@@ -7,15 +7,12 @@
#include "mozilla/Maybe.h"
#include "mozilla/PreloadHashKey.h"
#include "NeckoCommon.h"
#include "mozilla/net/NeckoChannelParams.h"
#include "nsHashtablesFwd.h"
#include "nsIChannelEventSink.h"
#include "nsIInterfaceRequestor.h"
#include "nsIMultiPartChannel.h"
#include "nsIRedirectResultListener.h"
#include "nsIStreamListener.h"
#include "nsNetUtil.h"
#include "nsRefPtrHashtable.h"
class nsAttrValue;
class nsICookieJarSettings;
@@ -25,14 +22,13 @@ class nsIReferrerInfo;
namespace mozilla::net {
class EarlyHintPreloader;
class EarlyHintConnectArgs;
class ParentChannelListener;
struct LinkHeader;
// class keeping track of all ongoing early hints
class OngoingEarlyHints final {
public:
NS_INLINE_DECL_REFCOUNTING(OngoingEarlyHints)
MOZ_DECLARE_REFCOUNTED_TYPENAME(OngoingEarlyHints)
OngoingEarlyHints() = default;
@@ -42,29 +38,15 @@ class OngoingEarlyHints final {
void CancelAllOngoingPreloads();
// registers all channels and returns the ids
void RegisterLinksAndGetConnectArgs(
nsTArray<EarlyHintConnectArgs>& aOutLinks);
private:
~OngoingEarlyHints() = default;
// We need to do two things requiring two separate variables to keep track of
// preloads:
// - deduplicate Link headers when starting preloads, therefore we store them
// hashset with PreloadHashKey to look up whether we started the preload
// already
// - pass link headers in order they were received when passing all started
// preloads to the content process, therefore we store them in a nsTArray
nsTHashSet<PreloadHashKey> mStartedPreloads;
nsTArray<RefPtr<EarlyHintPreloader>> mPreloaders;
nsRefPtrHashtable<PreloadHashKey, EarlyHintPreloader> mOngoingPreloads;
};
class EarlyHintPreloader final : public nsIStreamListener,
public nsIChannelEventSink,
public nsIRedirectResultListener,
public nsIInterfaceRequestor,
public nsIMultiPartChannelListener {
public nsIInterfaceRequestor {
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIREQUESTOBSERVER
@@ -72,7 +54,6 @@ class EarlyHintPreloader final : public nsIStreamListener,
NS_DECL_NSICHANNELEVENTSINK
NS_DECL_NSIREDIRECTRESULTLISTENER
NS_DECL_NSIINTERFACEREQUESTOR
NS_DECL_NSIMULTIPARTCHANNELLISTENER
public:
// Create and insert a preload into OngoingEarlyHints if the same preload
@@ -82,21 +63,12 @@ class EarlyHintPreloader final : public nsIStreamListener,
nsIURI* aBaseURI, nsIPrincipal* aPrincipal,
nsICookieJarSettings* aCookieJarSettings);
// register Channel to EarlyHintRegistrar returns connect arguments
EarlyHintConnectArgs Register();
// Should be called by the preloader service when the preload is not
// needed after all, because the final response returns a non-2xx status
// code.
// Should be called by the preloader service when the preload is not needed
// after all, because the final response returns a non-2xx status code.
nsresult CancelChannel(nsresult aStatus);
void OnParentReady(nsIParentChannel* aParent, uint64_t aChannelId);
private:
void SetParentChannel();
bool InvokeStreamListenerFunctions();
EarlyHintPreloader();
explicit EarlyHintPreloader(nsIURI* aURI);
~EarlyHintPreloader() = default;
static Maybe<PreloadHashKey> GenerateHashKey(ASDestination aAs, nsIURI* aURI,
@@ -109,38 +81,16 @@ class EarlyHintPreloader final : public nsIStreamListener,
bool aIsModule);
// call to start the preload
nsresult OpenChannel(nsIURI* aURI, nsIPrincipal* aPrincipal,
nsSecurityFlags aSecurityFlags,
nsresult OpenChannel(nsIPrincipal* aPrincipal, nsSecurityFlags aSecurityFlags,
nsContentPolicyType aContentPolicyType,
nsIReferrerInfo* aReferrerInfo,
nsICookieJarSettings* aCookieJarSettings);
void SetLinkHeader(const LinkHeader& aLinkHeader);
static void CollectResourcesTypeTelemetry(ASDestination aASDestination);
// keep opening uri to not preload cross origins on redirects for now
nsCOMPtr<nsIURI> mURI;
nsCOMPtr<nsIChannel> mChannel;
nsCOMPtr<nsIChannel> mRedirectChannel;
uint64_t mChannelId = 0;
EarlyHintConnectArgs mConnectArgs;
// Copy behavior from DocumentLoadListener.h:
// https://searchfox.org/mozilla-central/rev/c0bed29d643393af6ebe77aa31455f283f169202/netwerk/ipc/DocumentLoadListener.h#487-512
// The set of nsIStreamListener functions that got called on this
// listener, so that we can replay them onto the replacement channel's
// listener. This should generally only be OnStartRequest, since we
// Suspend() the channel at that point, but it can fail sometimes
// so we have to support holding a list.
nsTArray<StreamListenerFunction> mStreamListenerFunctions;
// Set to true once OnStartRequest is called and we suspend our mChannel
bool mSuspended = false;
nsCOMPtr<nsIParentChannel> mParent;
// Set to true after we've received the last OnStopRequest, and shouldn't
// setup a reference from the ParentChannelListener to the replacement
// channel.
bool mIsFinished = false;
RefPtr<ParentChannelListener> mParentListener;
};
inline nsISupports* ToSupports(EarlyHintPreloader* aObj) {

68
netwerk/protocol/http/EarlyHintRegistrar.cpp
View File

@@ -1,68 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "EarlyHintRegistrar.h"
#include "EarlyHintPreloader.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/StaticPtr.h"
#include "nsXULAppAPI.h"
namespace {
mozilla::StaticRefPtr<mozilla::net::EarlyHintRegistrar> gSingleton;
} // namespace
namespace mozilla::net {
EarlyHintRegistrar::EarlyHintRegistrar() {
// EarlyHintRegistrar is a main-thread-only object.
// All the operations should be run on main thread.
// It should be used on chrome process only.
MOZ_ASSERT(XRE_IsParentProcess());
MOZ_ASSERT(NS_IsMainThread());
}
EarlyHintRegistrar::~EarlyHintRegistrar() { MOZ_ASSERT(NS_IsMainThread()); }
// static
already_AddRefed<EarlyHintRegistrar> EarlyHintRegistrar::GetOrCreate() {
if (!gSingleton) {
gSingleton = new EarlyHintRegistrar();
mozilla::ClearOnShutdown(&gSingleton);
}
return do_AddRef(gSingleton);
}
void EarlyHintRegistrar::DeleteEntry(uint64_t aEarlyHintPreloaderId) {
MOZ_ASSERT(NS_IsMainThread());
mEarlyHint.Remove(aEarlyHintPreloaderId);
}
void EarlyHintRegistrar::RegisterEarlyHint(uint64_t aEarlyHintPreloaderId,
EarlyHintPreloader* aEhp) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aEhp);
mEarlyHint.InsertOrUpdate(aEarlyHintPreloaderId, RefPtr{aEhp});
}
bool EarlyHintRegistrar::LinkParentChannel(uint64_t aEarlyHintPreloaderId,
nsIParentChannel* aParent,
uint64_t aChannelId) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aParent);
RefPtr<EarlyHintPreloader> ehp;
bool found = mEarlyHint.Get(aEarlyHintPreloaderId, getter_AddRefs(ehp));
if (ehp) {
ehp->OnParentReady(aParent, aChannelId);
}
MOZ_ASSERT(ehp || !found);
return found;
}
} // namespace mozilla::net

72
netwerk/protocol/http/EarlyHintRegistrar.h
View File

@@ -1,72 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_net_EarlyHintRegistrar_h__
#define mozilla_net_EarlyHintRegistrar_h__
#include "mozilla/RefCounted.h"
#include "nsRefPtrHashtable.h"
#include "mozilla/AlreadyAddRefed.h"
class nsIParentChannel;
namespace mozilla::net {
class EarlyHintPreloader;
/*
* Registrar for pairing EarlyHintPreloader and HttpChannelParent via
* earlyHintPreloaderId. EarlyHintPreloader has to be registered first.
* EarlyHintPreloader::OnParentReady will be invoked to notify the
* EarlyHintpreloader about the existence of the associated HttpChannelParent.
*/
class EarlyHintRegistrar final : public RefCounted<EarlyHintRegistrar> {
using EarlyHintHashtable =
nsRefPtrHashtable<nsUint64HashKey, EarlyHintPreloader>;
public:
MOZ_DECLARE_REFCOUNTED_TYPENAME(EarlyHintRegistrar)
EarlyHintRegistrar();
~EarlyHintRegistrar();
/*
* Store EarlyHintPreloader for the HttpChannelParent to connect back to.
*
* @param aEarlyHintPreloaderId identifying the EarlyHintPreloader
* @param aEhp the EarlyHintPreloader to store
*/
void RegisterEarlyHint(uint64_t aEarlyHintPreloaderId,
EarlyHintPreloader* aEhp);
/*
* Link the provided nsIParentChannel with the associated EarlyHintPreloader.
*
* @param aEarlyHintPreloaderId identifying the EarlyHintPreloader
* @param aParent the nsIParentChannel to be paired
* @param aChannelId the id of the nsIChannel connecting to the
* EarlyHintPreloader.
*/
bool LinkParentChannel(uint64_t aEarlyHintPreloaderId,
nsIParentChannel* aParent, uint64_t aChannelId);
/*
* Delete previous stored EarlyHintPreloader
*
* @param aEarlyHintPreloaderId identifying the EarlyHintPreloader
*/
void DeleteEntry(uint64_t aEarlyHintPreloaderId);
// Singleton accessor
static already_AddRefed<EarlyHintRegistrar> GetOrCreate();
// Store unlinked EarlyHintPreloader objects.
EarlyHintHashtable mEarlyHint;
};
} // namespace mozilla::net
#endif // mozilla_net_EarlyHintRegistrar_h__

25
netwerk/protocol/http/EarlyHintsService.cpp
View File

@@ -31,15 +31,8 @@ EarlyHintsService::~EarlyHintsService() = default;
void EarlyHintsService::EarlyHint(const nsACString& aLinkHeader,
nsIURI* aBaseURI, nsIChannel* aChannel) {
mEarlyHintsCount++;
if (mFirstEarlyHint.isNothing()) {
if (!mFirstEarlyHint) {
mFirstEarlyHint.emplace(TimeStamp::NowLoRes());
} else {
// Only allow one early hint response with link headers. See
// https://html.spec.whatwg.org/multipage/semantics.html#early-hints
// > Note: Only the first early hint response served during the navigation
// > is handled, and it is discarded if it is succeeded by a cross-origin
// > redirect.
return;
}
nsCOMPtr<nsILoadInfo> loadInfo = aChannel->LoadInfo();
@@ -93,16 +86,18 @@ void EarlyHintsService::FinalResponse(uint32_t aResponseStatus) {
// We will collect telemetry mosly once for a document.
// In case of a reddirect this will be called multiple times.
CollectTelemetry(Some(aResponseStatus));
if (aResponseStatus >= 300 && aResponseStatus < 400) {
mOngoingEarlyHints->CancelAllOngoingPreloads();
mCanceled = true;
}
}
void EarlyHintsService::Cancel() {
CollectTelemetry(Nothing());
mOngoingEarlyHints->CancelAllOngoingPreloads();
}
void EarlyHintsService::RegisterLinksAndGetConnectArgs(
nsTArray<EarlyHintConnectArgs>& aOutLinks) {
mOngoingEarlyHints->RegisterLinksAndGetConnectArgs(aOutLinks);
if (!mCanceled) {
CollectTelemetry(Nothing());
mOngoingEarlyHints->CancelAllOngoingPreloads();
mCanceled = true;
}
}
void EarlyHintsService::CollectTelemetry(Maybe<uint32_t> aResponseStatus) {

8
netwerk/protocol/http/EarlyHintsService.h
View File

@@ -9,17 +9,15 @@
#define mozilla_net_EarlyHintsService_h
#include "mozilla/Maybe.h"
#include "mozilla/RefPtr.h"
#include "mozilla/TimeStamp.h"
#include "nsStringFwd.h"
#include "nsTArray.h"
#include "mozilla/RefPtr.h"
class nsIChannel;
class nsIURI;
namespace mozilla::net {
class EarlyHintConnectArgs;
class OngoingEarlyHints;
class EarlyHintsService {
@@ -31,15 +29,13 @@ class EarlyHintsService {
void FinalResponse(uint32_t aResponseStatus);
void Cancel();
void RegisterLinksAndGetConnectArgs(
nsTArray<EarlyHintConnectArgs>& aOutLinks);
private:
void CollectTelemetry(Maybe<uint32_t> aResponseStatus);
void CollectLinkTypeTelemetry(const nsAString& aRel);
Maybe<TimeStamp> mFirstEarlyHint;
uint32_t mEarlyHintsCount{0};
bool mCanceled{false};
RefPtr<OngoingEarlyHints> mOngoingEarlyHints;
};

22
netwerk/protocol/http/HttpBaseChannel.cpp
View File

@@ -5945,28 +5945,6 @@ void HttpBaseChannel::SetDummyChannelForImageCache() {
mResponseHead = MakeUnique<nsHttpResponseHead>();
}
void HttpBaseChannel::SetEarlyHints(
nsTArray<EarlyHintConnectArgs>&& aEarlyHints) {
mEarlyHints = std::move(aEarlyHints);
}
nsTArray<EarlyHintConnectArgs>&& HttpBaseChannel::TakeEarlyHints() {
return std::move(mEarlyHints);
}
NS_IMETHODIMP
HttpBaseChannel::SetEarlyHintPreloaderId(uint64_t aEarlyHintPreloaderId) {
mEarlyHintPreloaderId = aEarlyHintPreloaderId;
return NS_OK;
}
NS_IMETHODIMP
HttpBaseChannel::GetEarlyHintPreloaderId(uint64_t* aEarlyHintPreloaderId) {
NS_ENSURE_ARG_POINTER(aEarlyHintPreloaderId);
*aEarlyHintPreloaderId = mEarlyHintPreloaderId;
return NS_OK;
}
void HttpBaseChannel::SetConnectionInfo(nsHttpConnectionInfo* aCI) {
mConnectionInfo = aCI ? aCI->Clone() : nullptr;
}

19
netwerk/protocol/http/HttpBaseChannel.h
View File

@@ -14,7 +14,6 @@
#include "mozilla/Atomics.h"
#include "mozilla/dom/DOMTypes.h"
#include "mozilla/net/DNS.h"
#include "mozilla/net/NeckoChannelParams.h"
#include "mozilla/net/NeckoCommon.h"
#include "mozilla/net/PrivateBrowsingChannel.h"
#include "nsCOMPtr.h"
@@ -345,9 +344,6 @@ class HttpBaseChannel : public nsHashPropertyBag,
NS_IMETHOD SetWaitForHTTPSSVCRecord() override;
NS_IMETHOD SetEarlyHintPreloaderId(uint64_t aEarlyHintPreloaderId) override;
NS_IMETHOD GetEarlyHintPreloaderId(uint64_t* aEarlyHintPreloaderId) override;
virtual void SetConnectionInfo(
mozilla::net::nsHttpConnectionInfo* aCI) override;
@@ -789,21 +785,6 @@ class HttpBaseChannel : public nsHashPropertyBag,
ClassOfService mClassOfService;
public:
void SetEarlyHints(
nsTArray<mozilla::net::EarlyHintConnectArgs>&& aEarlyHints);
nsTArray<mozilla::net::EarlyHintConnectArgs>&& TakeEarlyHints();
protected:
// Storing Http 103 Early Hint preloads. The parent process is responsible to
// start the early hint preloads, but the http child needs to be able to look
// them up. They are sent via IPC and stored in this variable. This is set on
// main document channel
nsTArray<EarlyHintConnectArgs> mEarlyHints;
// EarlyHintRegistrar id to connect back to the preload. Set on preload
// channels started from the above list
uint64_t mEarlyHintPreloaderId = 0;
// clang-format off
MOZ_ATOMIC_BITFIELDS(mAtomicBitfields1, 32, (
(uint32_t, UpgradeToSecure, 1),

1
netwerk/protocol/http/HttpChannelChild.cpp
View File

@@ -2256,7 +2256,6 @@ nsresult HttpChannelChild::ContinueAsyncOpen() {
openArgs.forceMainDocumentChannel() = LoadForceMainDocumentChannel();
openArgs.navigationStartTimeStamp() = navigationStartTimeStamp;
openArgs.earlyHintPreloaderId() = mEarlyHintPreloaderId;
// This must happen before the constructor message is sent. Otherwise messages
// from the parent could arrive quickly and be delivered to the wrong event

86
netwerk/protocol/http/HttpChannelParent.cpp
View File

@@ -5,12 +5,10 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// HttpLog.h should generally be included first
#include "ErrorList.h"
#include "HttpLog.h"
#include "mozilla/ConsoleReportCollector.h"
#include "mozilla/ipc/IPCStreamUtils.h"
#include "mozilla/net/EarlyHintRegistrar.h"
#include "mozilla/net/HttpChannelParent.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/ContentProcessManager.h"
@@ -26,7 +24,6 @@
#include "mozilla/Unused.h"
#include "HttpBackgroundChannelParent.h"
#include "ParentChannelListener.h"
#include "nsDebug.h"
#include "nsICacheInfoChannel.h"
#include "nsHttpHandler.h"
#include "nsNetCID.h"
@@ -141,7 +138,7 @@ bool HttpChannelParent::Init(const HttpChannelCreationArgs& aArgs) {
a.launchServiceWorkerEnd(), a.dispatchFetchEventStart(),
a.dispatchFetchEventEnd(), a.handleFetchEventStart(),
a.handleFetchEventEnd(), a.forceMainDocumentChannel(),
a.navigationStartTimeStamp(), a.earlyHintPreloaderId());
a.navigationStartTimeStamp());
}
case HttpChannelCreationArgs::THttpChannelConnectArgs: {
const HttpChannelConnectArgs& cArgs = aArgs.get_HttpChannelConnectArgs();
@@ -354,26 +351,6 @@ void HttpChannelParent::InvokeAsyncOpen(nsresult rv) {
}
}
void HttpChannelParent::InvokeEarlyHintPreloader(nsresult rv,
uint64_t aEarlyHintPreloaderId,
uint64_t aChannelId) {
LOG(("HttpChannelParent::InvokeEarlyHintPreloader [this=%p rv=%" PRIx32 "]\n",
this, static_cast<uint32_t>(rv)));
MOZ_ASSERT(NS_IsMainThread());
RefPtr<EarlyHintRegistrar> ehr = EarlyHintRegistrar::GetOrCreate();
if (NS_SUCCEEDED(rv)) {
rv = ehr->LinkParentChannel(aEarlyHintPreloaderId, this, aChannelId)
? NS_OK
: NS_ERROR_FAILURE;
}
if (NS_FAILED(rv)) {
ehr->DeleteEntry(aEarlyHintPreloaderId);
AsyncOpenFailed(NS_ERROR_FAILURE);
}
}
bool HttpChannelParent::DoAsyncOpen(
nsIURI* aURI, nsIURI* aOriginalURI, nsIURI* aDocURI,
nsIReferrerInfo* aReferrerInfo, nsIURI* aAPIRedirectToURI,
@@ -404,31 +381,9 @@ bool HttpChannelParent::DoAsyncOpen(
const TimeStamp& aHandleFetchEventStart,
const TimeStamp& aHandleFetchEventEnd,
const bool& aForceMainDocumentChannel,
const TimeStamp& aNavigationStartTimeStamp,
const uint64_t& aEarlyHintPreloaderId) {
const TimeStamp& aNavigationStartTimeStamp) {
MOZ_ASSERT(aURI, "aURI should not be NULL");
if (aEarlyHintPreloaderId) {
// Wait for HttpBackgrounChannel to continue the async open procedure.
mEarlyHintPreloaderId = aEarlyHintPreloaderId;
RefPtr<HttpChannelParent> self = this;
WaitForBgParent(aChannelId)
->Then(
GetMainThreadSerialEventTarget(), __func__,
[self, aEarlyHintPreloaderId, aChannelId]() {
self->mRequest.Complete();
self->InvokeEarlyHintPreloader(NS_OK, aEarlyHintPreloaderId,
aChannelId);
},
[self, aEarlyHintPreloaderId, aChannelId](nsresult aStatus) {
self->mRequest.Complete();
self->InvokeEarlyHintPreloader(aStatus, aEarlyHintPreloaderId,
aChannelId);
})
->Track(mRequest);
return true;
}
if (!aURI) {
// this check is neccessary to prevent null deref
// in opt builds
@@ -615,7 +570,7 @@ bool HttpChannelParent::DoAsyncOpen(
// Wait for HttpBackgrounChannel to continue the async open procedure.
++mAsyncOpenBarrier;
RefPtr<HttpChannelParent> self = this;
WaitForBgParent(mChannel->ChannelId())
WaitForBgParent()
->Then(
GetMainThreadSerialEventTarget(), __func__,
[self]() {
@@ -630,12 +585,11 @@ bool HttpChannelParent::DoAsyncOpen(
return true;
}
RefPtr<GenericNonExclusivePromise> HttpChannelParent::WaitForBgParent(
uint64_t aChannelId) {
RefPtr<GenericNonExclusivePromise> HttpChannelParent::WaitForBgParent() {
LOG(("HttpChannelParent::WaitForBgParent [this=%p]\n", this));
MOZ_ASSERT(!mBgParent);
if (!mChannel && !mEarlyHintPreloaderId) {
if (!mChannel) {
return GenericNonExclusivePromise::CreateAndReject(NS_ERROR_FAILURE,
__func__);
}
@@ -643,7 +597,7 @@ RefPtr<GenericNonExclusivePromise> HttpChannelParent::WaitForBgParent(
nsCOMPtr<nsIBackgroundChannelRegistrar> registrar =
BackgroundChannelRegistrar::GetOrCreate();
MOZ_ASSERT(registrar);
registrar->LinkHttpChannel(aChannelId, this);
registrar->LinkHttpChannel(mChannel->ChannelId(), this);
if (mBgParent) {
return GenericNonExclusivePromise::CreateAndResolve(true, __func__);
@@ -698,7 +652,7 @@ bool HttpChannelParent::ConnectChannel(const uint32_t& registrarId) {
MOZ_ASSERT(mPromise.IsEmpty());
// Waiting for background channel
RefPtr<HttpChannelParent> self = this;
WaitForBgParent(mChannel->ChannelId())
WaitForBgParent()
->Then(
GetMainThreadSerialEventTarget(), __func__,
[self]() { self->mRequest.Complete(); },
@@ -943,14 +897,13 @@ HttpChannelParent::ContinueVerification(
// Otherwise, wait for the background channel.
nsCOMPtr<nsIAsyncVerifyRedirectReadyCallback> callback = aCallback;
WaitForBgParent(mChannel->ChannelId())
->Then(
GetMainThreadSerialEventTarget(), __func__,
[callback]() { callback->ReadyToVerify(NS_OK); },
[callback](const nsresult& aResult) {
NS_ERROR("failed to establish the background channel");
callback->ReadyToVerify(aResult);
});
WaitForBgParent()->Then(
GetMainThreadSerialEventTarget(), __func__,
[callback]() { callback->ReadyToVerify(NS_OK); },
[callback](const nsresult& aResult) {
NS_ERROR("failed to establish the background channel");
callback->ReadyToVerify(aResult);
});
return NS_OK;
}
@@ -2078,17 +2031,6 @@ auto HttpChannelParent::DetachStreamFilters() -> RefPtr<GenericPromise> {
&HttpBackgroundChannelParent::DetachStreamFilters);
}
void HttpChannelParent::SetHttpChannelFromEarlyHintPreloader(
HttpBaseChannel* aChannel) {
MOZ_ASSERT(aChannel);
if (mChannel) {
MOZ_ASSERT(false, "SetHttpChannel called with mChannel aready set");
return;
}
mChannel = aChannel;
}
void HttpChannelParent::SetCookie(nsCString&& aCookie) {
LOG(("HttpChannelParent::SetCookie [this=%p]", this));
MOZ_ASSERT(!mAfterOnStartRequestBegun);

18
netwerk/protocol/http/HttpChannelParent.h
View File

@@ -8,7 +8,6 @@
#ifndef mozilla_net_HttpChannelParent_h
#define mozilla_net_HttpChannelParent_h
#include "HttpBaseChannel.h"
#include "nsHttp.h"
#include "mozilla/net/PHttpChannelParent.h"
#include "mozilla/net/NeckoCommon.h"
@@ -95,9 +94,6 @@ class HttpChannelParent final : public nsIInterfaceRequestor,
void InvokeAsyncOpen(nsresult rv);
void InvokeEarlyHintPreloader(nsresult rv, uint64_t aEarlyHintPreloaderId,
uint64_t aChannelId);
// Calls SendSetPriority if mIPCClosed is false.
void DoSendSetPriority(int16_t aValue);
@@ -128,12 +124,6 @@ class HttpChannelParent final : public nsIInterfaceRequestor,
Endpoint<extensions::PStreamFilterChild>&& aChildEndpoint);
[[nodiscard]] RefPtr<GenericPromise> DetachStreamFilters();
// Should only be called from EarlyHintPreloader. mChannel should be null at
// the point of calling. Sets mChannel to aChannel. Used by the
// EarlyHintPreloader to redirect the channel to this parent as soon as the
// final channel becomes available after all http redirects.
void SetHttpChannelFromEarlyHintPreloader(HttpBaseChannel* aChannel);
protected:
// used to connect redirected-to channel in parent with just created
// ChildChannel. Used during redirects.
@@ -170,8 +160,7 @@ class HttpChannelParent final : public nsIInterfaceRequestor,
const TimeStamp& aHandleFetchEventStart,
const TimeStamp& aHandleFetchEventEnd,
const bool& aForceMainDocumentChannel,
const TimeStamp& aNavigationStartTimeStamp,
const uint64_t& aEarlyHintPreloaderId);
const TimeStamp& aNavigationStartTimeStamp);
virtual mozilla::ipc::IPCResult RecvSetPriority(
const int16_t& priority) override;
@@ -231,8 +220,7 @@ class HttpChannelParent final : public nsIInterfaceRequestor,
// id, a promise will be returned so the caller can append callbacks on it.
// If called multiple times before mBgParent is available, the same promise
// will be returned and the callbacks will be invoked in order.
[[nodiscard]] RefPtr<GenericNonExclusivePromise> WaitForBgParent(
uint64_t aChannelId);
[[nodiscard]] RefPtr<GenericNonExclusivePromise> WaitForBgParent();
// Remove the association with background channel after main-thread IPC
// is about to be destroyed or no further event is going to be sent, i.e.,
@@ -247,8 +235,6 @@ class HttpChannelParent final : public nsIInterfaceRequestor,
friend class HttpBackgroundChannelParent;
uint64_t mEarlyHintPreloaderId;
RefPtr<HttpBaseChannel> mChannel;
nsCOMPtr<nsICacheEntry> mCacheEntry;

2
netwerk/protocol/http/moz.build
View File

@@ -51,7 +51,6 @@ EXPORTS.mozilla.net += [
"ClassifierDummyChannelParent.h",
"ClassOfService.h",
"EarlyHintPreloader.h",
"EarlyHintRegistrar.h",
"EarlyHintsService.h",
"HttpAuthUtils.h",
"HttpBackgroundChannelChild.h",
@@ -104,7 +103,6 @@ UNIFIED_SOURCES += [
"ConnectionHandle.cpp",
"DnsAndConnectSocket.cpp",
"EarlyHintPreloader.cpp",
"EarlyHintRegistrar.cpp",
"EarlyHintsService.cpp",
"Http2Compression.cpp",
"Http2Push.cpp",

7
netwerk/protocol/http/nsIHttpChannelInternal.idl
View File

@@ -15,7 +15,6 @@ class TimeStamp;
namespace net {
class nsHttpConnectionInfo;
class WebSocketConnectionBase;
class EarlyHintConnectArgs;
}
namespace dom {
enum class RequestMode : uint8_t;
@@ -469,12 +468,6 @@ interface nsIHttpChannelInternal : nsISupports
*/
[must_use] void setEarlyHintObserver(in nsIEarlyHintObserver aObserver);
/*
* id of the EarlyHintPreloader to connect back from PreloadService to
* EarlyHintPreloader.
*/
[must_use] attribute unsigned long long earlyHintPreloaderId;
[notxpcom, nostdcall] void setConnectionInfo(in nsHttpConnectionInfo aInfo);
};

3
netwerk/test/browser/browser.ini
View File

@@ -95,7 +95,8 @@ skip-if = socketprocess_networking # Bug 1772209
[browser_103_csp.js]
support-files =
early_hint_preload_test_helper.jsm
skip-if = true # Bug 1765289 superseds this test
skip-if =
os == 'linux' && bits == 64 && !debug # Bug 1744028 and Bug 1746324
[browser_backgroundtask_purgeHTTPCache.js]
skip-if =
os == "android" # MultiInstanceLock doesn't work on Android

42
netwerk/test/browser/browser_103_assets.js
View File

@@ -4,7 +4,7 @@
Services.prefs.setBoolPref("network.early-hints.enabled", true);
const { request_count_checking } = ChromeUtils.import(
const { lax_request_count_checking } = ChromeUtils.import(
"resource://testing-common/early_hint_preload_test_helper.jsm"
);
@@ -38,43 +38,43 @@ async function test_hint_asset(testName, asset, hinted) {
"http://example.com/browser/netwerk/test/browser/early_hint_pixel_count.sjs"
).then(response => response.json());
await request_count_checking(
// TODO: Switch to stricter counting method after fixing https://bugzilla.mozilla.org/show_bug.cgi?id=1753730#c11
await lax_request_count_checking(
`${testName} (${asset})`,
gotRequestCount,
hinted ? { hinted: 1, normal: 0 } : { hinted: 0, normal: 1 }
);
/*
await Assert.deepEqual(
gotRequestCount,
hinted ? { hinted: 1, normal: 0 } : { hinted: 0, normal: 1 },
`${testName} (${asset}): Unexpected amount of requests made`
);
*/
}
// preload image
add_task(async function test_103_asset_image() {
await test_hint_asset("test_103_asset_normal", "image", false);
add_task(async function test_103_asset_style() {
await test_hint_asset("test_103_asset_hinted", "image", true);
await test_hint_asset("test_103_asset_normal", "image", false);
});
// preload css
add_task(async function test_103_asset_style() {
await test_hint_asset("test_103_asset_normal", "style", false);
await test_hint_asset("test_103_asset_hinted", "style", true);
await test_hint_asset("test_103_asset_normal", "style", false);
});
// preload javascript
add_task(async function test_103_asset_javascript() {
await test_hint_asset("test_103_asset_normal", "script", false);
await test_hint_asset("test_103_asset_hinted", "script", true);
await test_hint_asset("test_103_asset_normal", "script", false);
});
// preload javascript module
/* TODO(Bug 1798319): enable this test case
add_task(async function test_103_asset_module() {
await test_hint_asset("test_103_asset_normal", "module", false);
await test_hint_asset("test_103_asset_hinted", "module", true);
});
*/
// preload font
add_task(async function test_103_asset_font() {
await test_hint_asset("test_103_asset_normal", "font", false);
await test_hint_asset("test_103_asset_hinted", "font", true);
await test_hint_asset("test_103_asset_normal", "font", false);
});
// - testName is just there to be printed during Asserts when failing
@@ -117,15 +117,23 @@ async function test_hint_fetch(testName, hinted) {
"http://example.com/browser/netwerk/test/browser/early_hint_pixel_count.sjs"
).then(response => response.json());
await request_count_checking(
// TODO: Switch to stricter counting method after fixing https://bugzilla.mozilla.org/show_bug.cgi?id=1753730#c11
await lax_request_count_checking(
`${testName} (fetch)`,
gotRequestCount,
hinted ? { hinted: 1, normal: 0 } : { hinted: 0, normal: 1 }
);
/*
await Assert.deepEqual(
gotRequestCount,
hinted ? { hinted: 1, normal: 0 } : { hinted: 0, normal: 1 },
`${testName} (fetch): Unexpected amount of requests made`
);
*/
}
// preload fetch
add_task(async function test_103_asset_fetch() {
await test_hint_fetch("test_103_asset_normal", false);
await test_hint_fetch("test_103_asset_hinted", true);
await test_hint_fetch("test_103_asset_normal", false);
});

12
netwerk/test/browser/browser_103_csp.js
View File

@@ -4,7 +4,7 @@
"use strict";
const { request_count_checking } = ChromeUtils.import(
const { lax_request_count_checking } = ChromeUtils.import(
"resource://testing-common/early_hint_preload_test_helper.jsm"
);
@@ -46,11 +46,19 @@ add_task(async function test_preload_csp_imgsrc_none() {
).then(response => response.json());
let expectedRequestCount = { hinted: 1, normal: 0 };
await request_count_checking(
// TODO: Switch to stricter counting method after fixing https://bugzilla.mozilla.org/show_bug.cgi?id=1753730#c11
await lax_request_count_checking(
"test_preload_csp_imgsrc_none",
gotRequestCount,
expectedRequestCount
);
/* stricter counting method:
await Assert.deepEqual(
gotRequestCount,
{ hinted: 1, normal: 0 },
"test_preload_csp_imgsrc_none: Unexpected amount of requests made"
);
*/
Services.cache2.clear();
});

26
netwerk/test/browser/browser_103_error.js
View File

@@ -6,7 +6,11 @@
Services.prefs.setBoolPref("network.early-hints.enabled", true);
const { test_hint_preload } = ChromeUtils.import(
const {
lax_request_count_checking,
test_hint_preload_internal,
test_hint_preload,
} = ChromeUtils.import(
"resource://testing-common/early_hint_preload_test_helper.jsm"
);
@@ -16,7 +20,7 @@ add_task(async function test_103_error_400() {
"test_103_error_400",
"https://example.com",
"https://example.com/browser/netwerk/test/browser/early_hint_error.sjs?400",
{ hinted: 1, normal: 0 }
{ hinted: 1, normal: 1 }
);
});
@@ -26,7 +30,7 @@ add_task(async function test_103_error_401() {
"test_103_error_401",
"https://example.com",
"https://example.com/browser/netwerk/test/browser/early_hint_error.sjs?401",
{ hinted: 1, normal: 0 }
{ hinted: 1, normal: 1 }
);
});
@@ -36,7 +40,7 @@ add_task(async function test_103_error_403() {
"test_103_error_403",
"https://example.com",
"https://example.com/browser/netwerk/test/browser/early_hint_error.sjs?403",
{ hinted: 1, normal: 0 }
{ hinted: 1, normal: 1 }
);
});
@@ -46,7 +50,7 @@ add_task(async function test_103_error_404() {
"test_103_error_404",
"https://example.com",
"https://example.com/browser/netwerk/test/browser/early_hint_error.sjs?404",
{ hinted: 1, normal: 0 }
{ hinted: 1, normal: 1 }
);
});
@@ -56,7 +60,7 @@ add_task(async function test_103_error_408() {
"test_103_error_408",
"https://example.com",
"https://example.com/browser/netwerk/test/browser/early_hint_error.sjs?408",
{ hinted: 1, normal: 0 }
{ hinted: 1, normal: 1 }
);
});
@@ -76,7 +80,7 @@ add_task(async function test_103_error_429() {
"test_103_error_429",
"https://example.com",
"https://example.com/browser/netwerk/test/browser/early_hint_error.sjs?429",
{ hinted: 1, normal: 0 }
{ hinted: 1, normal: 1 }
);
});
@@ -86,7 +90,7 @@ add_task(async function test_103_error_500() {
"test_103_error_500",
"https://example.com",
"https://example.com/browser/netwerk/test/browser/early_hint_error.sjs?500",
{ hinted: 1, normal: 0 }
{ hinted: 1, normal: 1 }
);
});
@@ -96,7 +100,7 @@ add_task(async function test_103_error_502() {
"test_103_error_502",
"https://example.com",
"https://example.com/browser/netwerk/test/browser/early_hint_error.sjs?502",
{ hinted: 1, normal: 0 }
{ hinted: 1, normal: 1 }
);
});
@@ -106,7 +110,7 @@ add_task(async function test_103_error_503() {
"test_103_error_503",
"https://example.com",
"https://example.com/browser/netwerk/test/browser/early_hint_error.sjs?503",
{ hinted: 1, normal: 0 }
{ hinted: 1, normal: 1 }
);
});
@@ -116,6 +120,6 @@ add_task(async function test_103_error_504() {
"test_103_error_504",
"https://example.com",
"https://example.com/browser/netwerk/test/browser/early_hint_error.sjs?504",
{ hinted: 1, normal: 0 }
{ hinted: 1, normal: 1 }
);
});

22
netwerk/test/browser/browser_103_no_cancel_on_error.js
View File

@@ -8,7 +8,7 @@
Services.prefs.setBoolPref("network.early-hints.enabled", true);
const { request_count_checking } = ChromeUtils.import(
const { lax_request_count_checking } = ChromeUtils.import(
"resource://testing-common/early_hint_preload_test_helper.jsm"
);
@@ -37,10 +37,22 @@ async function test_hint_completion_on_error(httpCode) {
"https://example.com/browser/netwerk/test/browser/early_hint_pixel_count.sjs"
).then(response => response.json());
await request_count_checking(`test_103_error_${httpCode}`, gotRequestCount, {
hinted: 1,
normal: 0,
});
// TODO: Switch to stricter counting method after fixing https://bugzilla.mozilla.org/show_bug.cgi?id=1753730#c11
await lax_request_count_checking(
`test_103_error_${httpCode}`,
gotRequestCount,
{
hinted: 1,
normal: 0,
}
);
/*
await Assert.deepEqual(
gotRequestCount,
hinted ? { hinted: 1, normal: 0 } : { hinted: 0, normal: 1 },
`${testName} (${asset}): Unexpected amount of requests made`
);
*/
}
// 400 Bad Request

49
netwerk/test/browser/browser_103_preload.js
View File

@@ -7,7 +7,7 @@
Services.prefs.setBoolPref("network.early-hints.enabled", true);
const {
request_count_checking,
lax_request_count_checking,
test_hint_preload_internal,
test_hint_preload,
} = ChromeUtils.import(
@@ -27,13 +27,13 @@ add_task(async function test_103_two_preload_responses() {
"https://example.com/browser/netwerk/test/browser/early_hint_pixel.sjs",
Services.uuid.generateUUID().toString(),
],
["", "new_response"], // indicate new early hint response
["", "new_response"], // empty string to indicate new early hint response
[
"https://example.com/browser/netwerk/test/browser/early_hint_pixel.sjs",
Services.uuid.generateUUID().toString(),
],
],
{ hinted: 1, normal: 1 }
{ hinted: 2, normal: 0 }
);
});
@@ -47,7 +47,7 @@ add_task(async function test_103_two_link_header() {
"https://example.com/browser/netwerk/test/browser/early_hint_pixel.sjs",
Services.uuid.generateUUID().toString(),
],
["", ""], // indicate new link header in same reponse
["", ""], // empty string to indicate new early hint response
[
"https://example.com/browser/netwerk/test/browser/early_hint_pixel.sjs",
Services.uuid.generateUUID().toString(),
@@ -76,23 +76,6 @@ add_task(async function test_103_two_links() {
);
});
// two early hint responses, only second one has a link header
add_task(async function test_103_two_links() {
await test_hint_preload_internal(
"103_two_links",
"https://example.com",
[
["", "non_link_header"], // indicate non-link related header
["", "new_response"], // indicate new early hint response
[
"https://example.com/browser/netwerk/test/browser/early_hint_pixel.sjs",
Services.uuid.generateUUID().toString(),
],
],
{ hinted: 1, normal: 0 }
);
});
// Preload twice same origin in secure context
add_task(async function test_103_preload_twice() {
// pass two times the same uuid so that on the second request, the response is
@@ -233,11 +216,19 @@ add_task(async function test_103_iframe() {
).then(response => response.json());
let expectedRequestCount = { hinted: 0, normal: 1 };
await request_count_checking(
// TODO: Switch to stricter counting method after fixing https://bugzilla.mozilla.org/show_bug.cgi?id=1753730#c11
await lax_request_count_checking(
"test_103_iframe",
gotRequestCount,
expectedRequestCount
);
/* stricter counting method:
await Assert.deepEqual(
gotRequestCount,
{ hinted: 0, normal: 1 },
"test_103_iframe: Unexpected amount of requests made"
);
*/
Services.cache2.clear();
});
@@ -268,8 +259,16 @@ add_task(async function test_103_anchor() {
"https://example.com/browser/netwerk/test/browser/early_hint_pixel_count.sjs"
).then(response => response.json());
await request_count_checking("test_103_anchor", gotRequestCount, {
hinted: 0,
normal: 1,
// TODO: Switch to stricter counting method after fixing Bug 1771867
await lax_request_count_checking("test_103_anchor", gotRequestCount, {
hinted: 1,
normal: 0,
});
/* stricter counting method:
await Assert.deepEqual(
gotRequestCount,
{ hinted: 1, normal: 0 },
"test_103_anchor: Unexpected amount of requests made"
);
*/
});

8
netwerk/test/browser/browser_103_redirect.js
View File

@@ -6,7 +6,7 @@
Services.prefs.setBoolPref("network.early-hints.enabled", true);
const { test_hint_preload, request_count_checking } = ChromeUtils.import(
const { test_hint_preload } = ChromeUtils.import(
"resource://testing-common/early_hint_preload_test_helper.jsm"
);
@@ -26,7 +26,7 @@ add_task(async function test_103_redirect_cross_origin() {
"test_103_redirect_cross_origin",
"https://example.com",
"https://example.com/browser/netwerk/test/browser/early_hint_redirect.sjs?https://example.net/browser/netwerk/test/browser/early_hint_pixel.sjs",
{ hinted: 2, normal: 0 }
{ hinted: 2, normal: 0 } // successful load of redirect in preload, but image loaded via normal load
);
});
@@ -36,7 +36,7 @@ add_task(async function test_103_redirect_insecure_cross_origin() {
"test_103_redirect_insecure_cross_origin",
"https://example.com",
"https://example.com/browser/netwerk/test/browser/early_hint_redirect.sjs?http://mochi.test:8888/browser/netwerk/test/browser/early_hint_pixel.sjs",
{ hinted: 2, normal: 0 }
{ hinted: 1, normal: 1 }
);
});
@@ -46,6 +46,6 @@ add_task(async function test_103_preload_redirect_mixed_content() {
"test_103_preload_redirect_mixed_content",
"https://example.org",
"https://example.org/browser/netwerk/test/browser/early_hint_redirect.sjs?http://example.org/browser/netwerk/test/browser/early_hint_pixel.sjs",
{ hinted: 2, normal: 0 }
{ hinted: 1, normal: 1 }
);
});

6
netwerk/test/browser/browser_103_redirect_from_server.js
View File

@@ -1,6 +1,6 @@
Services.prefs.setBoolPref("network.early-hints.enabled", true);
const { request_count_checking } = ChromeUtils.import(
const { lax_request_count_checking } = ChromeUtils.import(
"resource://testing-common/early_hint_preload_test_helper.jsm"
);
@@ -36,8 +36,8 @@ async function test_hint_completion_on_redirect(
"https://example.com/browser/netwerk/test/browser/early_hint_pixel_count.sjs"
).then(response => response.json());
await request_count_checking(testName, gotRequestCount, expectedCount);
Services.cache2.clear();
// TODO: Switch to stricter counting method after fixing https://bugzilla.mozilla.org/show_bug.cgi?id=1753730#c11
await lax_request_count_checking(testName, gotRequestCount, expectedCount);
}
/**

12
netwerk/test/browser/browser_103_user_load.js
View File

@@ -8,7 +8,7 @@
// https://searchfox.org/mozilla-central/rev/5644fae86d5122519a0e34ee03117c88c6ed9b47/browser/components/urlbar/tests/browser/browser_enter.js
const {
request_count_checking,
lax_request_count_checking,
test_hint_preload_internal,
test_hint_preload,
} = ChromeUtils.import(
@@ -70,11 +70,19 @@ add_task(async function user_initiated_load() {
).then(response => response.json());
let expectedRequestCount = { hinted: 1, normal: 0 };
await request_count_checking(
// TODO: Switch to stricter counting method after fixing Bug 1771867
await lax_request_count_checking(
"test_preload_user_initiated",
gotRequestCount,
expectedRequestCount
);
/* stricter counting method:
await Assert.deepEqual(
gotRequestCount,
expectedRequestCount,
"test_preload_user_initiated: Unexpected amount of requests made"
);
*/
// Cleanup.
BrowserTestUtils.removeTab(gBrowser.selectedTab);

2
netwerk/test/browser/early_hint_asset.sjs
View File

@@ -10,7 +10,7 @@ function handleRequest(request, response) {
count.normal += 1;
}
setSharedState("earlyHintCount", JSON.stringify(count));
response.setHeader("Cache-Control", "no-cache", false);
response.setHeader("Cache-Control", "max-age=604800", false);
let content = "";
Cu.importGlobalProperties(["URLSearchParams"]);

69
netwerk/test/browser/early_hint_asset_html.sjs
View File

@@ -18,22 +18,10 @@ function handleRequest(request, response) {
// write to raw socket
response.seizePower();
let link = "";
if (hinted) {
response.write("HTTP/1.1 103 Early Hint\r\n");
if (asset === "fetch" || asset === "font") {
// fetch and font has to specify the crossorigin attribute
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-as
link = `Link: <${url}>; rel=preload; as=${asset}; crossorigin=anonymous\r\n`;
response.write(link);
} else if (asset === "module") {
// module preloads are handled differently
link = `Link: <${url}>; rel=modulepreload\r\n`;
response.write(link);
} else {
link = `Link: <${url}>; rel=preload; as=${asset}\r\n`;
response.write(link);
}
response.write(`Link: <${url}>; rel=preload; as=${asset}\r\n`);
response.write("\r\n");
}
@@ -69,24 +57,6 @@ function handleRequest(request, response) {
</body>
</html>
`;
} else if (asset === "module") {
// this code assumes that the .sjs for the module is in the same directory
var file_name = url.split("/");
file_name = file_name[file_name.length - 1];
body = `<!DOCTYPE html>
<html>
<head>
</head>
<body>
<h1>Test preload module<h1>
<div id="square" style="width:100px;height:100px;">
<script type="module">
import { draw } from "./${file_name}";
draw();
</script>
</body>
</html>
`;
} else if (asset === "fetch") {
body = `<!DOCTYPE html>
<html>
@@ -105,23 +75,23 @@ function handleRequest(request, response) {
`;
} else if (asset === "font") {
body = `<!DOCTYPE html>
<html>
<head>
<style>
@font-face {
font-family: "preloadFont";
src: url("${url}");
}
body {
font-family: "preloadFont";
}
</style>
</head>
<body>
<h1>Test preload font<h1>
</body>
</html>
`;
<html>
<head>
<style>
@font-face {
font-family: "preloadFont";
src: url("${url}") format("woff");
}
body {
font-family: "preloadFont";
}
</style>
</head>
<body>
<h1>Test preload font<h1>
</body>
</html>
`;
}
if (redirect) {
@@ -138,7 +108,6 @@ function handleRequest(request, response) {
} else {
response.write(`HTTP/1.1 ${httpCode} Error\r\n`);
}
response.write(link);
response.write("Content-Type: text/html;charset=utf-8\r\n");
response.write("Cache-Control: no-cache\r\n");
response.write(`Content-Length: ${body.length}\r\n`);

2
netwerk/test/browser/early_hint_main_html.sjs
View File

@@ -22,8 +22,6 @@ function handleRequest(request, response) {
if (uuid === "new_response") {
new_hint = true;
response.write("\r\n");
} else if (uuid === "non_link_header") {
response.write("Content-Length: 25\r\n");
}
response.write("\r\n");
} else {

33
netwerk/test/browser/early_hint_preload_test_helper.jsm
View File

@@ -5,7 +5,7 @@
"use strict";
const EXPORTED_SYMBOLS = [
"request_count_checking",
"lax_request_count_checking",
"test_hint_preload",
"test_hint_preload_internal",
];
@@ -18,22 +18,23 @@ const { BrowserTestUtils } = ChromeUtils.importESModule(
);
const { gBrowser } = Services.wm.getMostRecentWindow("navigator:browser");
async function request_count_checking(testName, got, expected) {
// TODO: remove this and do strict request count
async function lax_request_count_checking(testName, got, expected) {
// stringify to pretty print assert output
let g = JSON.stringify(got);
let e = JSON.stringify(expected);
// each early hint request can starts one hinted request, but doesn't yet
// complete the early hint request during the test case
Assert.ok(
got.hinted == expected.hinted,
`${testName}: unexpected amount of hinted request made expected ${expected.hinted} (${e}), got ${got.hinted} (${g})`
await Assert.ok(
got.hinted <= expected.hinted,
`${testName}: unexpected amount of hinted request made expected at most ${expected.hinted} (${e}), got ${got.hinted} (${g})`
);
// when the early hint request doesn't complete fast enough, another request
// is currently sent from the main document
let expected_normal = expected.normal;
Assert.ok(
got.normal == expected_normal,
`${testName}: unexpected amount of normal request made expected ${expected_normal} (${e}), got ${got.normal} (${g})`
let expected_normal = expected.normal + expected.hinted;
await Assert.ok(
got.normal <= expected_normal,
`${testName}: unexpected amount of normal request made expected at most ${expected_normal} (${e}), got ${got.normal} (${g})`
);
}
@@ -94,5 +95,17 @@ async function test_hint_preload_internal(
"http://example.com/browser/netwerk/test/browser/early_hint_pixel_count.sjs"
).then(response => response.json());
await request_count_checking(testName, gotRequestCount, expectedRequestCount);
// TODO: Switch to stricter counting method after fixing https://bugzilla.mozilla.org/show_bug.cgi?id=1753730#c11
await lax_request_count_checking(
testName,
gotRequestCount,
expectedRequestCount
);
/* stricter counting method:
await Assert.deepEqual(
gotRequestCount,
expectedRequestCount,
testName + ": Unexpected amount of requests made"
);
*/
}

9
parser/html/nsHtml5TreeOpExecutor.cpp
View File

@@ -1218,7 +1218,7 @@ void nsHtml5TreeOpExecutor::PreloadScript(
mDocument->ScriptLoader()->PreloadURI(
uri, aCharset, aType, aCrossOrigin, aIntegrity, aScriptFromHead, aAsync,
aDefer, aNoModule, aLinkPreload,
GetPreloadReferrerPolicy(aReferrerPolicy), 0);
GetPreloadReferrerPolicy(aReferrerPolicy));
}
void nsHtml5TreeOpExecutor::PreloadStyle(const nsAString& aURL,
@@ -1247,8 +1247,7 @@ void nsHtml5TreeOpExecutor::PreloadStyle(const nsAString& aURL,
GetPreloadReferrerPolicy(aReferrerPolicy), aIntegrity,
aLinkPreload
? css::StylePreloadKind::FromLinkRelPreloadElement
: css::StylePreloadKind::FromParser,
0);
: css::StylePreloadKind::FromParser);
}
void nsHtml5TreeOpExecutor::PreloadImage(
@@ -1286,7 +1285,7 @@ void nsHtml5TreeOpExecutor::PreloadFont(const nsAString& aURL,
return;
}
mDocument->Preloads().PreloadFont(uri, aCrossOrigin, aReferrerPolicy, 0);
mDocument->Preloads().PreloadFont(uri, aCrossOrigin, aReferrerPolicy);
}
void nsHtml5TreeOpExecutor::PreloadFetch(const nsAString& aURL,
@@ -1298,7 +1297,7 @@ void nsHtml5TreeOpExecutor::PreloadFetch(const nsAString& aURL,
return;
}
mDocument->Preloads().PreloadFetch(uri, aCrossOrigin, aReferrerPolicy, 0);
mDocument->Preloads().PreloadFetch(uri, aCrossOrigin, aReferrerPolicy);
}
void nsHtml5TreeOpExecutor::PreloadOpenPicture() {

24
uriloader/preload/FetchPreloader.cpp
View File

@@ -17,10 +17,8 @@
#include "nsContentSecurityManager.h"
#include "nsContentUtils.h"
#include "nsIChannel.h"
#include "nsIChildChannel.h"
#include "nsIClassOfService.h"
#include "nsIHttpChannel.h"
#include "nsIHttpChannelInternal.h"
#include "nsITimedChannel.h"
#include "nsNetUtil.h"
#include "nsStringStream.h"
@@ -39,8 +37,7 @@ FetchPreloader::FetchPreloader(nsContentPolicyType aContentPolicyType)
nsresult FetchPreloader::OpenChannel(const PreloadHashKey& aKey, nsIURI* aURI,
const CORSMode aCORSMode,
const dom::ReferrerPolicy& aReferrerPolicy,
dom::Document* aDocument,
uint64_t aEarlyHintPreloaderId) {
dom::Document* aDocument) {
nsresult rv;
nsCOMPtr<nsIChannel> channel;
@@ -65,7 +62,7 @@ nsresult FetchPreloader::OpenChannel(const PreloadHashKey& aKey, nsIURI* aURI,
}
rv = CreateChannel(getter_AddRefs(channel), aURI, aCORSMode, aReferrerPolicy,
aDocument, loadGroup, prompter, aEarlyHintPreloaderId);
aDocument, loadGroup, prompter);
NS_ENSURE_SUCCESS(rv, rv);
// Doing this now so that we have the channel and tainting set on it properly
@@ -81,22 +78,13 @@ nsresult FetchPreloader::OpenChannel(const PreloadHashKey& aKey, nsIURI* aURI,
NotifyOpen(aKey, channel, aDocument, true);
if (aEarlyHintPreloaderId) {
nsCOMPtr<nsIHttpChannelInternal> channelInternal =
do_QueryInterface(channel);
NS_ENSURE_TRUE(channelInternal != nullptr, NS_ERROR_FAILURE);
rv = channelInternal->SetEarlyHintPreloaderId(aEarlyHintPreloaderId);
NS_ENSURE_SUCCESS(rv, rv);
}
return mAsyncConsumeResult = rv = channel->AsyncOpen(this);
}
nsresult FetchPreloader::CreateChannel(
nsIChannel** aChannel, nsIURI* aURI, const CORSMode aCORSMode,
const dom::ReferrerPolicy& aReferrerPolicy, dom::Document* aDocument,
nsILoadGroup* aLoadGroup, nsIInterfaceRequestor* aCallbacks,
uint64_t aEarlyHintPreloaderId) {
nsILoadGroup* aLoadGroup, nsIInterfaceRequestor* aCallbacks) {
nsresult rv;
nsSecurityFlags securityFlags =
@@ -121,11 +109,7 @@ nsresult FetchPreloader::CreateChannel(
}
if (nsCOMPtr<nsITimedChannel> timedChannel = do_QueryInterface(channel)) {
if (aEarlyHintPreloaderId) {
timedChannel->SetInitiatorType(u"early-hints"_ns);
} else {
timedChannel->SetInitiatorType(u"link"_ns);
}
timedChannel->SetInitiatorType(u"link"_ns);
}
channel.forget(aChannel);

6
uriloader/preload/FetchPreloader.h
View File

@@ -33,8 +33,7 @@ class FetchPreloader : public PreloaderBase, public nsIStreamListener {
nsresult OpenChannel(const PreloadHashKey& aKey, nsIURI* aURI,
const CORSMode aCORSMode,
const dom::ReferrerPolicy& aReferrerPolicy,
dom::Document* aDocument,
uint64_t aEarlyHintPreloaderId);
dom::Document* aDocument);
// PreloaderBase
nsresult AsyncConsume(nsIStreamListener* aListener) override;
@@ -52,8 +51,7 @@ class FetchPreloader : public PreloaderBase, public nsIStreamListener {
const dom::ReferrerPolicy& aReferrerPolicy,
dom::Document* aDocument,
nsILoadGroup* aLoadGroup,
nsIInterfaceRequestor* aCallbacks,
uint64_t aEarlyHintPreloaderId);
nsIInterfaceRequestor* aCallbacks);
private:
nsresult CheckContentPolicy(nsIURI* aURI, dom::Document* aDocument);

43
uriloader/preload/PreloadService.cpp
View File

@@ -87,7 +87,7 @@ already_AddRefed<PreloaderBase> PreloadService::PreloadLinkElement(
auto result = PreloadOrCoalesce(uri, url, aPolicyType, as, type, charset,
srcset, sizes, integrity, crossOrigin,
referrerPolicy, /* aFromHeader = */ false, 0);
referrerPolicy, /* aFromHeader = */ false);
if (!result.mPreloader) {
NotifyNodeEvent(aLinkElement, result.mAlreadyComplete);
@@ -102,7 +102,7 @@ void PreloadService::PreloadLinkHeader(
nsIURI* aURI, const nsAString& aURL, nsContentPolicyType aPolicyType,
const nsAString& aAs, const nsAString& aType, const nsAString& aIntegrity,
const nsAString& aSrcset, const nsAString& aSizes, const nsAString& aCORS,
const nsAString& aReferrerPolicy, uint64_t aEarlyHintPreloaderId) {
const nsAString& aReferrerPolicy) {
if (aPolicyType == nsIContentPolicy::TYPE_INVALID) {
MOZ_ASSERT_UNREACHABLE("Caller should check");
return;
@@ -114,7 +114,7 @@ void PreloadService::PreloadLinkHeader(
PreloadOrCoalesce(aURI, aURL, aPolicyType, aAs, aType, u""_ns, aSrcset,
aSizes, aIntegrity, aCORS, aReferrerPolicy,
/* aFromHeader = */ true, aEarlyHintPreloaderId);
/* aFromHeader = */ true);
}
PreloadService::PreloadOrCoalesceResult PreloadService::PreloadOrCoalesce(
@@ -122,8 +122,7 @@ PreloadService::PreloadOrCoalesceResult PreloadService::PreloadOrCoalesce(
const nsAString& aAs, const nsAString& aType, const nsAString& aCharset,
const nsAString& aSrcset, const nsAString& aSizes,
const nsAString& aIntegrity, const nsAString& aCORS,
const nsAString& aReferrerPolicy, bool aFromHeader,
uint64_t aEarlyHintPreloaderId) {
const nsAString& aReferrerPolicy, bool aFromHeader) {
if (!aURI) {
MOZ_ASSERT_UNREACHABLE("Should not pass null nsIURI");
return {nullptr, false};
@@ -164,14 +163,13 @@ PreloadService::PreloadOrCoalesceResult PreloadService::PreloadOrCoalesce(
if (aAs.LowerCaseEqualsASCII("script")) {
PreloadScript(uri, aType, aCharset, aCORS, aReferrerPolicy, aIntegrity,
true /* isInHead - TODO */, aEarlyHintPreloaderId);
true /* isInHead - TODO */);
} else if (aAs.LowerCaseEqualsASCII("style")) {
auto status = mDocument->PreloadStyle(
aURI, Encoding::ForLabel(aCharset), aCORS,
PreloadReferrerPolicy(aReferrerPolicy), aIntegrity,
aFromHeader ? css::StylePreloadKind::FromLinkRelPreloadHeader
: css::StylePreloadKind::FromLinkRelPreloadElement,
aEarlyHintPreloaderId);
: css::StylePreloadKind::FromLinkRelPreloadElement);
switch (status) {
case dom::SheetPreloadStatus::AlreadyComplete:
return {nullptr, /* already_complete = */ true};
@@ -180,11 +178,11 @@ PreloadService::PreloadOrCoalesceResult PreloadService::PreloadOrCoalesce(
break;
}
} else if (aAs.LowerCaseEqualsASCII("image")) {
PreloadImage(uri, aCORS, aReferrerPolicy, isImgSet, aEarlyHintPreloaderId);
PreloadImage(uri, aCORS, aReferrerPolicy, isImgSet);
} else if (aAs.LowerCaseEqualsASCII("font")) {
PreloadFont(uri, aCORS, aReferrerPolicy, aEarlyHintPreloaderId);
PreloadFont(uri, aCORS, aReferrerPolicy);
} else if (aAs.LowerCaseEqualsASCII("fetch")) {
PreloadFetch(uri, aCORS, aReferrerPolicy, aEarlyHintPreloaderId);
PreloadFetch(uri, aCORS, aReferrerPolicy);
}
return {LookupPreload(preloadKey), false};
@@ -195,26 +193,22 @@ void PreloadService::PreloadScript(nsIURI* aURI, const nsAString& aType,
const nsAString& aCrossOrigin,
const nsAString& aReferrerPolicy,
const nsAString& aIntegrity,
bool aScriptFromHead,
uint64_t aEarlyHintPreloaderId) {
bool aScriptFromHead) {
mDocument->ScriptLoader()->PreloadURI(
aURI, aCharset, aType, aCrossOrigin, aIntegrity, aScriptFromHead, false,
false, false, true, PreloadReferrerPolicy(aReferrerPolicy),
aEarlyHintPreloaderId);
false, false, true, PreloadReferrerPolicy(aReferrerPolicy));
}
void PreloadService::PreloadImage(nsIURI* aURI, const nsAString& aCrossOrigin,
const nsAString& aImageReferrerPolicy,
bool aIsImgSet,
uint64_t aEarlyHintPreloaderId) {
bool aIsImgSet) {
mDocument->PreLoadImage(aURI, aCrossOrigin,
PreloadReferrerPolicy(aImageReferrerPolicy),
aIsImgSet, true, aEarlyHintPreloaderId);
aIsImgSet, true);
}
void PreloadService::PreloadFont(nsIURI* aURI, const nsAString& aCrossOrigin,
const nsAString& aReferrerPolicy,
uint64_t aEarlyHintPreloaderId) {
const nsAString& aReferrerPolicy) {
CORSMode cors = dom::Element::StringToCORSMode(aCrossOrigin);
auto key = PreloadHashKey::CreateAsFont(aURI, cors);
@@ -223,13 +217,11 @@ void PreloadService::PreloadFont(nsIURI* aURI, const nsAString& aCrossOrigin,
RefPtr<FontPreloader> preloader = new FontPreloader();
dom::ReferrerPolicy referrerPolicy = PreloadReferrerPolicy(aReferrerPolicy);
preloader->OpenChannel(key, aURI, cors, referrerPolicy, mDocument,
aEarlyHintPreloaderId);
preloader->OpenChannel(key, aURI, cors, referrerPolicy, mDocument);
}
void PreloadService::PreloadFetch(nsIURI* aURI, const nsAString& aCrossOrigin,
const nsAString& aReferrerPolicy,
uint64_t aEarlyHintPreloaderId) {
const nsAString& aReferrerPolicy) {
CORSMode cors = dom::Element::StringToCORSMode(aCrossOrigin);
auto key = PreloadHashKey::CreateAsFetch(aURI, cors);
@@ -238,8 +230,7 @@ void PreloadService::PreloadFetch(nsIURI* aURI, const nsAString& aCrossOrigin,
RefPtr<FetchPreloader> preloader = new FetchPreloader();
dom::ReferrerPolicy referrerPolicy = PreloadReferrerPolicy(aReferrerPolicy);
preloader->OpenChannel(key, aURI, cors, referrerPolicy, mDocument,
aEarlyHintPreloaderId);
preloader->OpenChannel(key, aURI, cors, referrerPolicy, mDocument);
}
// static

22
uriloader/preload/PreloadService.h
View File

@@ -66,35 +66,26 @@ class PreloadService {
already_AddRefed<PreloaderBase> PreloadLinkElement(
dom::HTMLLinkElement* aLink, nsContentPolicyType aPolicyType);
// a non-zero aEarlyHintPreloaderId tells this service that a preload for this
// link was started by the EarlyHintPreloader and the preloaders should
// connect back by setting earlyHintPreloaderId in nsIChannelInternal before
// AsyncOpen.
void PreloadLinkHeader(nsIURI* aURI, const nsAString& aURL,
nsContentPolicyType aPolicyType, const nsAString& aAs,
const nsAString& aType, const nsAString& aIntegrity,
const nsAString& aSrcset, const nsAString& aSizes,
const nsAString& aCORS,
const nsAString& aReferrerPolicy,
uint64_t aEarlyHintPreloaderId);
const nsAString& aReferrerPolicy);
void PreloadScript(nsIURI* aURI, const nsAString& aType,
const nsAString& aCharset, const nsAString& aCrossOrigin,
const nsAString& aReferrerPolicy,
const nsAString& aIntegrity, bool aScriptFromHead,
uint64_t aEarlyHintPreloaderId);
const nsAString& aIntegrity, bool aScriptFromHead);
void PreloadImage(nsIURI* aURI, const nsAString& aCrossOrigin,
const nsAString& aImageReferrerPolicy, bool aIsImgSet,
uint64_t aEarlyHintPreloaderId);
const nsAString& aImageReferrerPolicy, bool aIsImgSet);
void PreloadFont(nsIURI* aURI, const nsAString& aCrossOrigin,
const nsAString& aReferrerPolicy,
uint64_t aEarlyHintPreloaderId);
const nsAString& aReferrerPolicy);
void PreloadFetch(nsIURI* aURI, const nsAString& aCrossOrigin,
const nsAString& aReferrerPolicy,
uint64_t aEarlyHintPreloaderId);
const nsAString& aReferrerPolicy);
static void NotifyNodeEvent(nsINode* aNode, bool aSuccess);
@@ -112,8 +103,7 @@ class PreloadService {
const nsAString& aAs, const nsAString& aType, const nsAString& aCharset,
const nsAString& aSrcset, const nsAString& aSizes,
const nsAString& aIntegrity, const nsAString& aCORS,
const nsAString& aReferrerPolicy, bool aFromHeader,
uint64_t aEarlyHintPreloaderId);
const nsAString& aReferrerPolicy, bool aFromHeader);
private:
nsRefPtrHashtable<PreloadHashKey, PreloaderBase> mPreloads;

34
uriloader/preload/gtest/TestFetchPreloader.cpp
View File

@@ -189,7 +189,7 @@ class FakePreloader : public mozilla::FetchPreloader {
nsIChannel** aChannel, nsIURI* aURI, const mozilla::CORSMode aCORSMode,
const mozilla::dom::ReferrerPolicy& aReferrerPolicy,
mozilla::dom::Document* aDocument, nsILoadGroup* aLoadGroup,
nsIInterfaceRequestor* aCallbacks, uint64_t aHttpChannelId) override {
nsIInterfaceRequestor* aCallbacks) override {
mDrivingChannel.forget(aChannel);
return NS_OK;
}
@@ -287,7 +287,7 @@ TEST(TestFetchPreloader, CacheNoneBeforeConsume)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
RefPtr<FakeListener> listener = new FakeListener();
EXPECT_NS_SUCCEEDED(preloader->AsyncConsume(listener));
@@ -325,7 +325,7 @@ TEST(TestFetchPreloader, CacheStartBeforeConsume)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
@@ -365,7 +365,7 @@ TEST(TestFetchPreloader, CachePartOfDataBeforeConsume)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
@@ -405,7 +405,7 @@ TEST(TestFetchPreloader, CacheAllDataBeforeConsume)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
@@ -445,7 +445,7 @@ TEST(TestFetchPreloader, CacheAllBeforeConsume)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
@@ -484,7 +484,7 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeWithChannelError)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
@@ -523,7 +523,7 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeWithChannelCancel)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
@@ -566,7 +566,7 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeThrowFromOnStartRequest)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
@@ -606,7 +606,7 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeThrowFromOnDataAvailable)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
@@ -646,7 +646,7 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeThrowFromOnStopRequest)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
@@ -688,7 +688,7 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeCancelInOnStartRequest)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
@@ -731,7 +731,7 @@ TEST(TestFetchPreloader, CacheAllBeforeConsumeCancelInOnDataAvailable)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
@@ -775,7 +775,7 @@ TEST(TestFetchPreloader, CachePartlyBeforeConsumeCancelInOnDataAvailable)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
@@ -816,7 +816,7 @@ TEST(TestFetchPreloader, CachePartlyBeforeConsumeCancelInOnStartRequestAndRace)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
@@ -865,7 +865,7 @@ TEST(TestFetchPreloader, CachePartlyBeforeConsumeCancelInOnDataAvailableAndRace)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));
@@ -914,7 +914,7 @@ TEST(TestFetchPreloader, CachePartlyBeforeConsumeThrowFromOnStartRequestAndRace)
EXPECT_TRUE(NS_SUCCEEDED(
preloader->OpenChannel(key, uri, mozilla::CORS_NONE,
mozilla::dom::ReferrerPolicy::_empty, doc, 0)));
mozilla::dom::ReferrerPolicy::_empty, doc)));
EXPECT_NS_SUCCEEDED(channel->Start());
EXPECT_NS_SUCCEEDED(channel->Data("one"_ns));

4
widget/IconLoader.cpp
View File

@@ -62,7 +62,7 @@ nsresult IconLoader::LoadIcon(nsIURI* aIconURI, nsINode* aNode,
aIconURI, nullptr, nullptr, nullptr, 0, loadGroup, this, nullptr,
nullptr, nsIRequest::LOAD_NORMAL, nullptr,
nsIContentPolicy::TYPE_INTERNAL_IMAGE, u""_ns,
/* aUseUrgentStartForChannel */ false, /* aLinkPreload */ false, 0,
/* aUseUrgentStartForChannel */ false, /* aLinkPreload */ false,
getter_AddRefs(mIconRequest));
} else {
// TODO: nsIContentPolicy::TYPE_INTERNAL_IMAGE may not be the correct
@@ -72,7 +72,7 @@ nsresult IconLoader::LoadIcon(nsIURI* aIconURI, nsINode* aNode,
aNode, document, nsIRequest::LOAD_NORMAL, nullptr,
nsIContentPolicy::TYPE_INTERNAL_IMAGE, u""_ns,
/* aUseUrgentStartForChannel */ false,
/* aLinkPreload */ false, 0, getter_AddRefs(mIconRequest));
/* aLinkPreload */ false, getter_AddRefs(mIconRequest));
}
if (NS_FAILED(rv)) {
return rv;