Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-23 12:51:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1742438 - Part 2: Rename ScriptLoadInfo references from {a,m}LoadInfo to {a,m}Request; r=asuth

Browse Source 
Doing the rename here so it doesn't make it confusing to review.

Differential Revision: https://phabricator.services.mozilla.com/D146174
This commit is contained in:
Yulia Startsev 2022-07-14 17:07:25 +00:00
parent 1ade00f949
commit c7e0fc2f1f
6 changed files with 137 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
dom/workers/ScriptLoader.cpp
View File

@ -86,8 +86,8 @@ ScriptLoadInfo* AsWorkerRequest(JS::loader::ScriptLoadRequest* req) {
return static_cast<ScriptLoadInfo*>(req);
}
JS::loader::ScriptLoadRequest* AsScriptRequest(ScriptLoadInfo* aLoadInfo) {
return static_cast<JS::loader::ScriptLoadRequest*>(aLoadInfo);
JS::loader::ScriptLoadRequest* AsScriptRequest(ScriptLoadInfo* aRequest) {
return static_cast<JS::loader::ScriptLoadRequest*>(aRequest);
}
nsresult ConstructURI(const nsAString& aScriptURL, nsIURI* baseURI,
@ -409,12 +409,12 @@ NS_IMPL_ISUPPORTS(ScriptLoaderRunnable, nsIRunnable, nsINamed)
class ScriptExecutorRunnable final : public MainThreadWorkerSyncRunnable {
WorkerScriptLoader& mScriptLoader;
ScriptLoadInfo* mLoadInfo;
ScriptLoadInfo* mRequest;
public:
ScriptExecutorRunnable(WorkerScriptLoader& aScriptLoader,
nsIEventTarget* aSyncLoopTarget,
ScriptLoadInfo* aLoadInfo);
ScriptLoadInfo* aRequest);
private:
~ScriptExecutorRunnable() = default;
@ -533,38 +533,37 @@ nsIURI* WorkerScriptLoader::GetBaseURI() {
return baseURI;
}
void WorkerScriptLoader::LoadingFinished(ScriptLoadInfo* aLoadInfo,
void WorkerScriptLoader::LoadingFinished(ScriptLoadInfo* aRequest,
nsresult aRv) {
AssertIsOnMainThread();
aLoadInfo->mLoadResult = aRv;
aRequest->mLoadResult = aRv;
MOZ_ASSERT(!aLoadInfo->mLoadingFinished);
aLoadInfo->mLoadingFinished = true;
MOZ_ASSERT(!aRequest->mLoadingFinished);
aRequest->mLoadingFinished = true;
if (IsMainWorkerScript() && NS_SUCCEEDED(aRv)) {
MOZ_DIAGNOSTIC_ASSERT(mWorkerPrivate->PrincipalURIMatchesScriptURL());
}
MaybeExecuteFinishedScripts(aLoadInfo);
MaybeExecuteFinishedScripts(aRequest);
}
void WorkerScriptLoader::MaybeExecuteFinishedScripts(
ScriptLoadInfo* aLoadInfo) {
void WorkerScriptLoader::MaybeExecuteFinishedScripts(ScriptLoadInfo* aRequest) {
AssertIsOnMainThread();
// We execute the last step if we don't have a pending operation with the
// cache and the loading is completed.
if (aLoadInfo->Finished()) {
aLoadInfo->ClearCacheCreator();
DispatchMaybeMoveToLoadedList(aLoadInfo);
if (aRequest->Finished()) {
aRequest->ClearCacheCreator();
DispatchMaybeMoveToLoadedList(aRequest);
}
}
void WorkerScriptLoader::MaybeMoveToLoadedList(ScriptLoadInfo* aLoadInfo) {
void WorkerScriptLoader::MaybeMoveToLoadedList(ScriptLoadInfo* aRequest) {
mWorkerPrivate->AssertIsOnWorkerThread();
MOZ_ASSERT(!aLoadInfo->mExecutionScheduled);
aLoadInfo->mExecutionScheduled = true;
MOZ_ASSERT(!aRequest->mExecutionScheduled);
aRequest->mExecutionScheduled = true;
while (!mLoadingRequests.isEmpty()) {
ScriptLoadRequest* request = mLoadingRequests.getFirst();
@ -633,11 +632,11 @@ bool WorkerScriptLoader::ProcessPendingRequests(JSContext* aCx) {
return true;
}
nsresult WorkerScriptLoader::OnStreamComplete(ScriptLoadInfo* aLoadInfo,
nsresult WorkerScriptLoader::OnStreamComplete(ScriptLoadInfo* aRequest,
nsresult aStatus) {
AssertIsOnMainThread();
LoadingFinished(aLoadInfo, aStatus);
LoadingFinished(aRequest, aStatus);
return NS_OK;
}
@ -707,13 +706,13 @@ nsresult WorkerScriptLoader::LoadScripts() {
return NS_OK;
}
nsresult WorkerScriptLoader::LoadScript(ScriptLoadInfo* aLoadInfo) {
nsresult WorkerScriptLoader::LoadScript(ScriptLoadInfo* aRequest) {
AssertIsOnMainThread();
MOZ_ASSERT_IF(IsMainWorkerScript(), !IsDebuggerScript());
// The URL passed to us for loading was invalid, stop loading at this point.
if (aLoadInfo->mLoadResult != NS_ERROR_NOT_INITIALIZED) {
return aLoadInfo->mLoadResult;
if (aRequest->mLoadResult != NS_ERROR_NOT_INITIALIZED) {
return aRequest->mLoadResult;
}
WorkerPrivate* parentWorker = mWorkerPrivate->GetParent();
@ -747,7 +746,7 @@ nsresult WorkerScriptLoader::LoadScript(ScriptLoadInfo* aLoadInfo) {
nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
NS_ASSERTION(secMan, "This should never be null!");
nsresult& rv = aLoadInfo->mLoadResult;
nsresult& rv = aRequest->mLoadResult;
nsLoadFlags loadFlags = mWorkerPrivate->GetLoadFlags();
@ -782,7 +781,7 @@ nsresult WorkerScriptLoader::LoadScript(ScriptLoadInfo* aLoadInfo) {
->CloneWithNewPolicy(parentWorker->GetReferrerPolicy());
}
ScriptLoadRequest* req = AsScriptRequest(aLoadInfo);
ScriptLoadRequest* req = AsScriptRequest(aRequest);
rv = ChannelFromScriptURL(principal, parentDoc, mWorkerPrivate, loadGroup,
ios, secMan, req->mURI, mClientInfo, mController,
@ -802,7 +801,7 @@ nsresult WorkerScriptLoader::LoadScript(ScriptLoadInfo* aLoadInfo) {
// We need to know which index we're on in OnStreamComplete so we know
// where to put the result.
RefPtr<NetworkLoadHandler> listener = new NetworkLoadHandler(this, aLoadInfo);
RefPtr<NetworkLoadHandler> listener = new NetworkLoadHandler(this, aRequest);
RefPtr<ScriptResponseHeaderProcessor> headerProcessor = nullptr;
@ -850,7 +849,7 @@ nsresult WorkerScriptLoader::LoadScript(ScriptLoadInfo* aLoadInfo) {
channelLoadInfo->SetLoadingEmbedderPolicy(respectedCOEP);
}
if (aLoadInfo->mCacheStatus != ScriptLoadInfo::ToBeCached) {
if (aRequest->mCacheStatus != ScriptLoadInfo::ToBeCached) {
rv = channel->AsyncOpen(loader);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
@ -859,10 +858,10 @@ nsresult WorkerScriptLoader::LoadScript(ScriptLoadInfo* aLoadInfo) {
nsCOMPtr<nsIOutputStream> writer;
// In case we return early.
aLoadInfo->mCacheStatus = ScriptLoadInfo::Cancel;
aRequest->mCacheStatus = ScriptLoadInfo::Cancel;
rv = NS_NewPipe(
getter_AddRefs(aLoadInfo->mCacheReadStream), getter_AddRefs(writer), 0,
getter_AddRefs(aRequest->mCacheReadStream), getter_AddRefs(writer), 0,
UINT32_MAX, // unlimited size to avoid writer WOULD_BLOCK case
true, false); // non-blocking reader, blocking writer
if (NS_WARN_IF(NS_FAILED(rv))) {
@ -886,7 +885,7 @@ nsresult WorkerScriptLoader::LoadScript(ScriptLoadInfo* aLoadInfo) {
}
void WorkerScriptLoader::DispatchMaybeMoveToLoadedList(
ScriptLoadInfo* aLoadInfo) {
ScriptLoadInfo* aRequest) {
AssertIsOnMainThread();
if (IsMainWorkerScript()) {
@ -894,24 +893,24 @@ void WorkerScriptLoader::DispatchMaybeMoveToLoadedList(
}
RefPtr<ScriptExecutorRunnable> runnable =
new ScriptExecutorRunnable(*this, mSyncLoopTarget, aLoadInfo);
new ScriptExecutorRunnable(*this, mSyncLoopTarget, aRequest);
if (!runnable->Dispatch()) {
MOZ_ASSERT(false, "This should never fail!");
}
}
bool WorkerScriptLoader::EvaluateScript(JSContext* aCx,
ScriptLoadInfo* aLoadInfo) {
ScriptLoadInfo* aRequest) {
mWorkerPrivate->AssertIsOnWorkerThread();
NS_ASSERTION(aLoadInfo->mExecutionScheduled, "Should be scheduled!");
NS_ASSERTION(!aLoadInfo->mExecutionResult, "Should not have executed yet!");
NS_ASSERTION(aRequest->mExecutionScheduled, "Should be scheduled!");
NS_ASSERTION(!aRequest->mExecutionResult, "Should not have executed yet!");
MOZ_ASSERT(!mRv.Failed(), "Who failed it and why?");
mRv.MightThrowJSException();
if (NS_FAILED(aLoadInfo->mLoadResult)) {
workerinternals::ReportLoadError(mRv, aLoadInfo->mLoadResult,
aLoadInfo->mURL);
if (NS_FAILED(aRequest->mLoadResult)) {
workerinternals::ReportLoadError(mRv, aRequest->mLoadResult,
aRequest->mURL);
return false;
}
@ -926,16 +925,16 @@ bool WorkerScriptLoader::EvaluateScript(JSContext* aCx,
mWorkerPrivate->ExecutionReady();
}
NS_ConvertUTF16toUTF8 filename(aLoadInfo->mURL);
NS_ConvertUTF16toUTF8 filename(aRequest->mURL);
JS::CompileOptions options(aCx);
options.setFileAndLine(filename.get(), 1).setNoScriptRval(true);
MOZ_ASSERT(aLoadInfo->mMutedErrorFlag.isSome());
options.setMutedErrors(aLoadInfo->mMutedErrorFlag.valueOr(true));
MOZ_ASSERT(aRequest->mMutedErrorFlag.isSome());
options.setMutedErrors(aRequest->mMutedErrorFlag.valueOr(true));
if (aLoadInfo->mSourceMapURL) {
options.setSourceMapURL(aLoadInfo->mSourceMapURL->get());
if (aRequest->mSourceMapURL) {
options.setSourceMapURL(aRequest->mSourceMapURL->get());
}
// Our ErrorResult still shouldn't be a failure.
@ -943,21 +942,21 @@ bool WorkerScriptLoader::EvaluateScript(JSContext* aCx,
// Transfer script length to a local variable, encoding-agnostically.
size_t scriptLength = 0;
std::swap(scriptLength, aLoadInfo->mScriptLength);
std::swap(scriptLength, aRequest->mScriptLength);
// This transfers script data out of the active arm of |aLoadInfo->mScript|.
// This transfers script data out of the active arm of |aRequest->mScript|.
bool successfullyEvaluated =
aLoadInfo->mScriptIsUTF8
? EvaluateSourceBuffer(aCx, options, aLoadInfo->mScript.mUTF8,
aRequest->mScriptIsUTF8
? EvaluateSourceBuffer(aCx, options, aRequest->mScript.mUTF8,
scriptLength)
: EvaluateSourceBuffer(aCx, options, aLoadInfo->mScript.mUTF16,
: EvaluateSourceBuffer(aCx, options, aRequest->mScript.mUTF16,
scriptLength);
MOZ_ASSERT(aLoadInfo->ScriptTextIsNull());
MOZ_ASSERT(aRequest->ScriptTextIsNull());
if (!successfullyEvaluated) {
mRv.StealExceptionFromJSContext(aCx);
return false;
}
aLoadInfo->mExecutionResult = true;
aRequest->mExecutionResult = true;
return true;
}
@ -1033,11 +1032,11 @@ NS_IMPL_ISUPPORTS(WorkerScriptLoader, nsINamed)
ScriptExecutorRunnable::ScriptExecutorRunnable(
WorkerScriptLoader& aScriptLoader, nsIEventTarget* aSyncLoopTarget,
ScriptLoadInfo* aLoadInfo)
ScriptLoadInfo* aRequest)
: MainThreadWorkerSyncRunnable(aScriptLoader.mWorkerPrivate,
aSyncLoopTarget),
mScriptLoader(aScriptLoader),
mLoadInfo(aLoadInfo) {}
mRequest(aRequest) {}
bool ScriptExecutorRunnable::IsDebuggerRunnable() const {
// ScriptExecutorRunnable is used to execute both worker and debugger scripts.
@ -1066,7 +1065,7 @@ bool ScriptExecutorRunnable::WorkerRun(JSContext* aCx,
mScriptLoader.mSyncLoopTarget == mSyncLoopTarget,
"Unexpected SyncLoopTarget. Check if the sync loop was closed early");
mScriptLoader.MaybeMoveToLoadedList(mLoadInfo);
mScriptLoader.MaybeMoveToLoadedList(mRequest);
return mScriptLoader.ProcessPendingRequests(aCx);
}

14
dom/workers/ScriptLoader.h
View File

@ -164,9 +164,9 @@ class WorkerScriptLoader final : public nsINamed {
protected:
nsIURI* GetBaseURI();
void MaybeExecuteFinishedScripts(ScriptLoadInfo* aLoadInfo);
void MaybeExecuteFinishedScripts(ScriptLoadInfo* aRequest);
void MaybeMoveToLoadedList(ScriptLoadInfo* aLoadInfo);
void MaybeMoveToLoadedList(ScriptLoadInfo* aRequest);
bool StoreCSP();
@ -176,7 +176,7 @@ class WorkerScriptLoader final : public nsINamed {
return mLoadingRequests.isEmpty() && mLoadedRequests.isEmpty();
}
nsresult OnStreamComplete(ScriptLoadInfo* aLoadInfo, nsresult aStatus);
nsresult OnStreamComplete(ScriptLoadInfo* aRequest, nsresult aStatus);
// Are we loading the primary script, which is not a Debugger Script?
bool IsMainWorkerScript() const {
@ -200,7 +200,7 @@ class WorkerScriptLoader final : public nsINamed {
nsresult LoadScripts();
nsresult LoadScript(ScriptLoadInfo* aLoadInfo);
nsresult LoadScript(ScriptLoadInfo* aRequest);
void ShutdownScriptLoader(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
bool aResult, bool aMutedError);
@ -214,11 +214,11 @@ class WorkerScriptLoader final : public nsINamed {
return NS_OK;
}
void LoadingFinished(ScriptLoadInfo* aLoadInfo, nsresult aRv);
void LoadingFinished(ScriptLoadInfo* aRequest, nsresult aRv);
void DispatchMaybeMoveToLoadedList(ScriptLoadInfo* aLoadInfo);
void DispatchMaybeMoveToLoadedList(ScriptLoadInfo* aRequest);
bool EvaluateScript(JSContext* aCx, ScriptLoadInfo* aLoadInfo);
bool EvaluateScript(JSContext* aCx, ScriptLoadInfo* aRequest);
void LogExceptionToConsole(JSContext* aCx, WorkerPrivate* aWorkerPrivate);
};

96
dom/workers/loader/CacheLoadHandler.cpp
View File

@ -44,15 +44,15 @@ void CachePromiseHandler::ResolvedCallback(JSContext* aCx,
AssertIsOnMainThread();
// May already have been canceled by CacheLoadHandler::Fail from
// CancelMainThread.
MOZ_ASSERT(mLoadInfo->mCacheStatus == ScriptLoadInfo::WritingToCache ||
mLoadInfo->mCacheStatus == ScriptLoadInfo::Cancel);
MOZ_ASSERT_IF(mLoadInfo->mCacheStatus == ScriptLoadInfo::Cancel,
!mLoadInfo->mCachePromise);
MOZ_ASSERT(mRequest->mCacheStatus == ScriptLoadInfo::WritingToCache ||
mRequest->mCacheStatus == ScriptLoadInfo::Cancel);
MOZ_ASSERT_IF(mRequest->mCacheStatus == ScriptLoadInfo::Cancel,
!mRequest->mCachePromise);
if (mLoadInfo->mCachePromise) {
mLoadInfo->mCacheStatus = ScriptLoadInfo::Cached;
mLoadInfo->mCachePromise = nullptr;
mLoader->MaybeExecuteFinishedScripts(mLoadInfo);
if (mRequest->mCachePromise) {
mRequest->mCacheStatus = ScriptLoadInfo::Cached;
mRequest->mCachePromise = nullptr;
mLoader->MaybeExecuteFinishedScripts(mRequest);
}
}
@ -62,15 +62,15 @@ void CachePromiseHandler::RejectedCallback(JSContext* aCx,
AssertIsOnMainThread();
// May already have been canceled by CacheLoadHandler::Fail from
// CancelMainThread.
MOZ_ASSERT(mLoadInfo->mCacheStatus == ScriptLoadInfo::WritingToCache ||
mLoadInfo->mCacheStatus == ScriptLoadInfo::Cancel);
mLoadInfo->mCacheStatus = ScriptLoadInfo::Cancel;
MOZ_ASSERT(mRequest->mCacheStatus == ScriptLoadInfo::WritingToCache ||
mRequest->mCacheStatus == ScriptLoadInfo::Cancel);
mRequest->mCacheStatus = ScriptLoadInfo::Cancel;
mLoadInfo->mCachePromise = nullptr;
mRequest->mCachePromise = nullptr;
// This will delete the cache object and will call LoadingFinished() with an
// error for each ongoing operation.
mLoadInfo->GetCacheCreator()->DeleteCache(NS_ERROR_FAILURE);
mRequest->GetCacheCreator()->DeleteCache(NS_ERROR_FAILURE);
}
CacheCreator::CacheCreator(WorkerPrivate* aWorkerPrivate)
@ -214,10 +214,10 @@ void CacheCreator::DeleteCache(nsresult aReason) {
}
CacheLoadHandler::CacheLoadHandler(WorkerPrivate* aWorkerPrivate,
ScriptLoadInfo* aLoadInfo,
ScriptLoadInfo* aRequest,
bool aIsWorkerScript,
WorkerScriptLoader* aLoader)
: mLoadInfo(aLoadInfo),
: mRequest(aRequest),
mLoader(aLoader),
mWorkerPrivate(aWorkerPrivate),
mIsWorkerScript(aIsWorkerScript),
@ -242,19 +242,19 @@ void CacheLoadHandler::Fail(nsresult aRv) {
mFailed = true;
if (mPump) {
MOZ_ASSERT(mLoadInfo->mCacheStatus == ScriptLoadInfo::ReadingFromCache);
MOZ_ASSERT(mRequest->mCacheStatus == ScriptLoadInfo::ReadingFromCache);
mPump->Cancel(aRv);
mPump = nullptr;
}
mLoadInfo->mCacheStatus = ScriptLoadInfo::Cancel;
mRequest->mCacheStatus = ScriptLoadInfo::Cancel;
if (mLoadInfo->mCachePromise) {
mLoadInfo->mCachePromise->MaybeReject(aRv);
if (mRequest->mCachePromise) {
mRequest->mCachePromise->MaybeReject(aRv);
}
mLoadInfo->mCachePromise = nullptr;
mRequest->mCachePromise = nullptr;
mLoader->LoadingFinished(mLoadInfo, aRv);
mLoader->LoadingFinished(mRequest, aRv);
}
void CacheLoadHandler::Load(Cache* aCache) {
@ -263,7 +263,7 @@ void CacheLoadHandler::Load(Cache* aCache) {
nsCOMPtr<nsIURI> uri;
nsresult rv =
NS_NewURI(getter_AddRefs(uri), mLoadInfo->mURL, nullptr, mBaseURI);
NS_NewURI(getter_AddRefs(uri), mRequest->mURL, nullptr, mBaseURI);
if (NS_WARN_IF(NS_FAILED(rv))) {
Fail(rv);
return;
@ -276,11 +276,11 @@ void CacheLoadHandler::Load(Cache* aCache) {
return;
}
MOZ_ASSERT(mLoadInfo->mFullURL.IsEmpty());
CopyUTF8toUTF16(spec, mLoadInfo->mFullURL);
MOZ_ASSERT(mRequest->mFullURL.IsEmpty());
CopyUTF8toUTF16(spec, mRequest->mFullURL);
mozilla::dom::RequestOrUSVString request;
request.SetAsUSVString().ShareOrDependUpon(mLoadInfo->mFullURL);
request.SetAsUSVString().ShareOrDependUpon(mRequest->mFullURL);
mozilla::dom::CacheQueryOptions params;
@ -303,7 +303,7 @@ void CacheLoadHandler::RejectedCallback(JSContext* aCx,
JS::Handle<JS::Value> aValue,
ErrorResult& aRv) {
AssertIsOnMainThread();
MOZ_ASSERT(mLoadInfo->mCacheStatus == ScriptLoadInfo::Uncached);
MOZ_ASSERT(mRequest->mCacheStatus == ScriptLoadInfo::Uncached);
Fail(NS_ERROR_FAILURE);
}
@ -316,7 +316,7 @@ void CacheLoadHandler::ResolvedCallback(JSContext* aCx,
return;
}
MOZ_ASSERT(mLoadInfo->mCacheStatus == ScriptLoadInfo::Uncached);
MOZ_ASSERT(mRequest->mCacheStatus == ScriptLoadInfo::Uncached);
nsresult rv;
@ -338,8 +338,8 @@ void CacheLoadHandler::ResolvedCallback(JSContext* aCx,
return;
}
mLoadInfo->mCacheStatus = ScriptLoadInfo::ToBeCached;
rv = mLoader->LoadScript(mLoadInfo);
mRequest->mCacheStatus = ScriptLoadInfo::ToBeCached;
rv = mLoader->LoadScript(mRequest);
if (NS_WARN_IF(NS_FAILED(rv))) {
Fail(rv);
}
@ -387,11 +387,11 @@ void CacheLoadHandler::ResolvedCallback(JSContext* aCx,
}
if (!inputStream) {
mLoadInfo->mCacheStatus = ScriptLoadInfo::Cached;
mRequest->mCacheStatus = ScriptLoadInfo::Cached;
nsresult rv = DataReceivedFromCache(
(uint8_t*)"", 0, mChannelInfo, std::move(mPrincipalInfo),
mCSPHeaderValue, mCSPReportOnlyHeaderValue, mReferrerPolicyHeaderValue);
mLoader->OnStreamComplete(mLoadInfo, rv);
mLoader->OnStreamComplete(mRequest, rv);
return;
}
@ -430,7 +430,7 @@ void CacheLoadHandler::ResolvedCallback(JSContext* aCx,
}
}
mLoadInfo->mCacheStatus = ScriptLoadInfo::ReadingFromCache;
mRequest->mCacheStatus = ScriptLoadInfo::ReadingFromCache;
}
NS_IMETHODIMP
@ -443,20 +443,20 @@ CacheLoadHandler::OnStreamComplete(nsIStreamLoader* aLoader,
mPump = nullptr;
if (NS_FAILED(aStatus)) {
MOZ_ASSERT(mLoadInfo->mCacheStatus == ScriptLoadInfo::ReadingFromCache ||
mLoadInfo->mCacheStatus == ScriptLoadInfo::Cancel);
MOZ_ASSERT(mRequest->mCacheStatus == ScriptLoadInfo::ReadingFromCache ||
mRequest->mCacheStatus == ScriptLoadInfo::Cancel);
Fail(aStatus);
return NS_OK;
}
MOZ_ASSERT(mLoadInfo->mCacheStatus == ScriptLoadInfo::ReadingFromCache);
mLoadInfo->mCacheStatus = ScriptLoadInfo::Cached;
MOZ_ASSERT(mRequest->mCacheStatus == ScriptLoadInfo::ReadingFromCache);
mRequest->mCacheStatus = ScriptLoadInfo::Cached;
MOZ_ASSERT(mPrincipalInfo);
nsresult rv = DataReceivedFromCache(
aString, aStringLen, mChannelInfo, std::move(mPrincipalInfo),
mCSPHeaderValue, mCSPReportOnlyHeaderValue, mReferrerPolicyHeaderValue);
return mLoader->OnStreamComplete(mLoadInfo, rv);
return mLoader->OnStreamComplete(mRequest, rv);
}
nsresult CacheLoadHandler::DataReceivedFromCache(
@ -467,11 +467,11 @@ nsresult CacheLoadHandler::DataReceivedFromCache(
const nsACString& aReferrerPolicyHeaderValue) {
AssertIsOnMainThread();
if (mLoader->IsCancelled()) {
mLoadInfo->GetCacheCreator()->DeleteCache(mLoader->mCancelMainThread.ref());
mRequest->GetCacheCreator()->DeleteCache(mLoader->mCancelMainThread.ref());
return mLoader->mCancelMainThread.ref();
}
MOZ_ASSERT(mLoadInfo->mCacheStatus == ScriptLoadInfo::Cached);
MOZ_ASSERT(mRequest->mCacheStatus == ScriptLoadInfo::Cached);
auto responsePrincipalOrErr = PrincipalInfoToPrincipal(*aPrincipalInfo);
MOZ_DIAGNOSTIC_ASSERT(responsePrincipalOrErr.isOk());
@ -485,28 +485,28 @@ nsresult CacheLoadHandler::DataReceivedFromCache(
nsCOMPtr<nsIPrincipal> responsePrincipal = responsePrincipalOrErr.unwrap();
mLoadInfo->mMutedErrorFlag.emplace(!principal->Subsumes(responsePrincipal));
mRequest->mMutedErrorFlag.emplace(!principal->Subsumes(responsePrincipal));
// May be null.
Document* parentDoc = mWorkerPrivate->GetDocument();
MOZ_ASSERT(mLoadInfo->ScriptTextIsNull());
MOZ_ASSERT(mRequest->ScriptTextIsNull());
nsresult rv;
if (StaticPrefs::dom_worker_script_loader_utf8_parsing_enabled()) {
mLoadInfo->InitUTF8Script();
mRequest->InitUTF8Script();
rv = ScriptLoader::ConvertToUTF8(nullptr, aString, aStringLen, u"UTF-8"_ns,
parentDoc, mLoadInfo->mScript.mUTF8,
mLoadInfo->mScriptLength);
parentDoc, mRequest->mScript.mUTF8,
mRequest->mScriptLength);
} else {
mLoadInfo->InitUTF16Script();
mRequest->InitUTF16Script();
rv = ScriptLoader::ConvertToUTF16(nullptr, aString, aStringLen, u"UTF-8"_ns,
parentDoc, mLoadInfo->mScript.mUTF16,
mLoadInfo->mScriptLength);
parentDoc, mRequest->mScript.mUTF16,
mRequest->mScriptLength);
}
if (NS_SUCCEEDED(rv) && mLoader->IsMainWorkerScript()) {
nsCOMPtr<nsIURI> finalURI;
rv = NS_NewURI(getter_AddRefs(finalURI), mLoadInfo->mFullURL);
rv = NS_NewURI(getter_AddRefs(finalURI), mRequest->mFullURL);
if (NS_SUCCEEDED(rv)) {
mWorkerPrivate->SetBaseURI(finalURI);
}

10
dom/workers/loader/CacheLoadHandler.h
View File

@ -78,7 +78,7 @@ class CacheLoadHandler final : public PromiseNativeHandler,
NS_DECL_ISUPPORTS
NS_DECL_NSISTREAMLOADEROBSERVER
CacheLoadHandler(WorkerPrivate* aWorkerPrivate, ScriptLoadInfo* aLoadInfo,
CacheLoadHandler(WorkerPrivate* aWorkerPrivate, ScriptLoadInfo* aRequest,
bool aIsWorkerScript, WorkerScriptLoader* aLoader);
void Fail(nsresult aRv);
@ -102,7 +102,7 @@ class CacheLoadHandler final : public PromiseNativeHandler,
const nsACString& aReferrerPolicyHeaderValue);
void DataReceived();
ScriptLoadInfo* mLoadInfo;
ScriptLoadInfo* mRequest;
const RefPtr<WorkerScriptLoader> mLoader;
WorkerPrivate* const mWorkerPrivate;
const bool mIsWorkerScript;
@ -193,8 +193,8 @@ class CachePromiseHandler final : public PromiseNativeHandler {
public:
NS_DECL_ISUPPORTS
CachePromiseHandler(WorkerScriptLoader* aLoader, ScriptLoadInfo* aLoadInfo)
: mLoader(aLoader), mLoadInfo(aLoadInfo) {
CachePromiseHandler(WorkerScriptLoader* aLoader, ScriptLoadInfo* aRequest)
: mLoader(aLoader), mRequest(aRequest) {
AssertIsOnMainThread();
MOZ_ASSERT(mLoader);
}
@ -209,7 +209,7 @@ class CachePromiseHandler final : public PromiseNativeHandler {
~CachePromiseHandler() { AssertIsOnMainThread(); }
RefPtr<WorkerScriptLoader> mLoader;
ScriptLoadInfo* mLoadInfo;
ScriptLoadInfo* mRequest;
};
} // namespace workerinternals::loader

50
dom/workers/loader/NetworkLoadHandler.cpp
View File

@ -36,10 +36,10 @@ NS_IMPL_ISUPPORTS(NetworkLoadHandler, nsIStreamLoaderObserver,
nsIRequestObserver)
NetworkLoadHandler::NetworkLoadHandler(WorkerScriptLoader* aLoader,
ScriptLoadInfo* aLoadInfo)
ScriptLoadInfo* aRequest)
: mLoader(aLoader),
mWorkerPrivate(aLoader->mWorkerPrivate),
mLoadInfo(aLoadInfo) {
mRequest(aRequest) {
MOZ_ASSERT(mLoader);
}
@ -49,7 +49,7 @@ NetworkLoadHandler::OnStreamComplete(nsIStreamLoader* aLoader,
uint32_t aStringLen,
const uint8_t* aString) {
nsresult rv = DataReceivedFromNetwork(aLoader, aStatus, aStringLen, aString);
return mLoader->OnStreamComplete(mLoadInfo, rv);
return mLoader->OnStreamComplete(mRequest, rv);
}
nsresult NetworkLoadHandler::DataReceivedFromNetwork(nsIStreamLoader* aLoader,
@ -109,8 +109,8 @@ nsresult NetworkLoadHandler::DataReceivedFromNetwork(nsIStreamLoader* aLoader,
// same-origin checks on them so we should be able to see their errors.
// Note that for data: url, where we allow it through the same-origin check
// but then give it a different origin.
mLoadInfo->mMutedErrorFlag.emplace(!mLoader->IsMainWorkerScript() &&
!principal->Subsumes(channelPrincipal));
mRequest->mMutedErrorFlag.emplace(!mLoader->IsMainWorkerScript() &&
!principal->Subsumes(channelPrincipal));
// Make sure we're not seeing the result of a 404 or something by checking
// the 'requestSucceeded' attribute on the http channel.
@ -137,7 +137,7 @@ nsresult NetworkLoadHandler::DataReceivedFromNetwork(nsIStreamLoader* aLoader,
nsAutoCString sourceMapURL;
if (nsContentUtils::GetSourceMapURL(httpChannel, sourceMapURL)) {
mLoadInfo->mSourceMapURL = Some(NS_ConvertUTF8toUTF16(sourceMapURL));
mRequest->mSourceMapURL = Some(NS_ConvertUTF8toUTF16(sourceMapURL));
}
}
@ -149,22 +149,22 @@ nsresult NetworkLoadHandler::DataReceivedFromNetwork(nsIStreamLoader* aLoader,
// Worker scripts are always decoded as UTF-8 per spec. Passing null for a
// channel and UTF-8 for the hint will always interpret |aString| as UTF-8.
if (StaticPrefs::dom_worker_script_loader_utf8_parsing_enabled()) {
mLoadInfo->InitUTF8Script();
mRequest->InitUTF8Script();
rv = ScriptLoader::ConvertToUTF8(nullptr, aString, aStringLen, u"UTF-8"_ns,
parentDoc, mLoadInfo->mScript.mUTF8,
mLoadInfo->mScriptLength);
parentDoc, mRequest->mScript.mUTF8,
mRequest->mScriptLength);
} else {
mLoadInfo->InitUTF16Script();
mRequest->InitUTF16Script();
rv = ScriptLoader::ConvertToUTF16(nullptr, aString, aStringLen, u"UTF-8"_ns,
parentDoc, mLoadInfo->mScript.mUTF16,
mLoadInfo->mScriptLength);
parentDoc, mRequest->mScript.mUTF16,
mRequest->mScriptLength);
}
if (NS_FAILED(rv)) {
return rv;
}
if (mLoadInfo->ScriptTextIsNull()) {
if (mLoadInfo->mScriptLength != 0) {
if (mRequest->ScriptTextIsNull()) {
if (mRequest->mScriptLength != 0) {
return NS_ERROR_FAILURE;
}
@ -186,7 +186,7 @@ nsresult NetworkLoadHandler::DataReceivedFromNetwork(nsIStreamLoader* aLoader,
if (!filename.IsEmpty()) {
// This will help callers figure out what their script url resolved to
// in case of errors.
mLoadInfo->mURL.Assign(NS_ConvertUTF8toUTF16(filename));
mRequest->mURL.Assign(NS_ConvertUTF8toUTF16(filename));
}
}
@ -295,7 +295,7 @@ nsresult NetworkLoadHandler::PrepareForRequest(nsIRequest* aRequest) {
ServiceWorkerManager::LocalizeAndReportToAllClients(
scope, "ServiceWorkerRegisterMimeTypeError2",
nsTArray<nsString>{NS_ConvertUTF8toUTF16(scope),
NS_ConvertUTF8toUTF16(mimeType), mLoadInfo->mURL});
NS_ConvertUTF8toUTF16(mimeType), mRequest->mURL});
return NS_ERROR_DOM_NETWORK_ERR;
}
@ -304,11 +304,11 @@ nsresult NetworkLoadHandler::PrepareForRequest(nsIRequest* aRequest) {
// We synthesize the result code, but its never exposed to content.
SafeRefPtr<mozilla::dom::InternalResponse> ir =
MakeSafeRefPtr<mozilla::dom::InternalResponse>(200, "OK"_ns);
ir->SetBody(mLoadInfo->mCacheReadStream, InternalResponse::UNKNOWN_BODY_SIZE);
ir->SetBody(mRequest->mCacheReadStream, InternalResponse::UNKNOWN_BODY_SIZE);
// Drop our reference to the stream now that we've passed it along, so it
// doesn't hang around once the cache is done with it and keep data alive.
mLoadInfo->mCacheReadStream = nullptr;
mRequest->mCacheReadStream = nullptr;
// Set the channel info of the channel on the response so that it's
// saved in the cache.
@ -330,12 +330,12 @@ nsresult NetworkLoadHandler::PrepareForRequest(nsIRequest* aRequest) {
ir->Headers()->FillResponseHeaders(channel);
RefPtr<mozilla::dom::Response> response = new mozilla::dom::Response(
mLoadInfo->GetCacheCreator()->Global(), std::move(ir), nullptr);
mRequest->GetCacheCreator()->Global(), std::move(ir), nullptr);
mozilla::dom::RequestOrUSVString request;
MOZ_ASSERT(!mLoadInfo->mFullURL.IsEmpty());
request.SetAsUSVString().ShareOrDependUpon(mLoadInfo->mFullURL);
MOZ_ASSERT(!mRequest->mFullURL.IsEmpty());
request.SetAsUSVString().ShareOrDependUpon(mRequest->mFullURL);
// This JSContext will not end up executing JS code because here there are
// no ReadableStreams involved.
@ -343,7 +343,7 @@ nsresult NetworkLoadHandler::PrepareForRequest(nsIRequest* aRequest) {
jsapi.Init();
ErrorResult error;
RefPtr<Promise> cachePromise = mLoadInfo->GetCacheCreator()->Cache_()->Put(
RefPtr<Promise> cachePromise = mRequest->GetCacheCreator()->Cache_()->Put(
jsapi.cx(), request, *response, error);
error.WouldReportJSException();
if (NS_WARN_IF(error.Failed())) {
@ -351,11 +351,11 @@ nsresult NetworkLoadHandler::PrepareForRequest(nsIRequest* aRequest) {
}
RefPtr<CachePromiseHandler> promiseHandler =
new CachePromiseHandler(mLoader, mLoadInfo);
new CachePromiseHandler(mLoader, mRequest);
cachePromise->AppendNativeHandler(promiseHandler);
mLoadInfo->mCachePromise.swap(cachePromise);
mLoadInfo->mCacheStatus = ScriptLoadInfo::WritingToCache;
mRequest->mCachePromise.swap(cachePromise);
mRequest->mCacheStatus = ScriptLoadInfo::WritingToCache;
return NS_OK;
}

4
dom/workers/loader/NetworkLoadHandler.h
View File

@ -41,7 +41,7 @@ class NetworkLoadHandler final : public nsIStreamLoaderObserver,
public:
NS_DECL_ISUPPORTS
NetworkLoadHandler(WorkerScriptLoader* aLoader, ScriptLoadInfo* aLoadInfo);
NetworkLoadHandler(WorkerScriptLoader* aLoader, ScriptLoadInfo* aRequest);
NS_IMETHOD
OnStreamComplete(nsIStreamLoader* aLoader, nsISupports* aContext,
@ -67,7 +67,7 @@ class NetworkLoadHandler final : public nsIStreamLoaderObserver,
RefPtr<WorkerScriptLoader> mLoader;
WorkerPrivate* const mWorkerPrivate;
ScriptLoadInfo* mLoadInfo;
ScriptLoadInfo* mRequest;
};
} // namespace mozilla::dom::workerinternals::loader