diff --git a/dom/workers/ScriptLoader.cpp b/dom/workers/ScriptLoader.cpp
index 2d091ed034cc..fe4f05b85ac4 100644
--- a/dom/workers/ScriptLoader.cpp
+++ b/dom/workers/ScriptLoader.cpp
@@ -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);
 }
 
diff --git a/dom/workers/ScriptLoader.h b/dom/workers/ScriptLoader.h
index 8487ca7158be..dc4057191ed9 100644
--- a/dom/workers/ScriptLoader.h
+++ b/dom/workers/ScriptLoader.h
@@ -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);
 };
diff --git a/dom/workers/loader/CacheLoadHandler.cpp b/dom/workers/loader/CacheLoadHandler.cpp
index 8c41cf03a820..3b5ec79e24f0 100644
--- a/dom/workers/loader/CacheLoadHandler.cpp
+++ b/dom/workers/loader/CacheLoadHandler.cpp
@@ -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);
     }
diff --git a/dom/workers/loader/CacheLoadHandler.h b/dom/workers/loader/CacheLoadHandler.h
index 4f301e48b873..a7310caf0651 100644
--- a/dom/workers/loader/CacheLoadHandler.h
+++ b/dom/workers/loader/CacheLoadHandler.h
@@ -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
diff --git a/dom/workers/loader/NetworkLoadHandler.cpp b/dom/workers/loader/NetworkLoadHandler.cpp
index ddcb0ba098e8..cb2657c03ee9 100644
--- a/dom/workers/loader/NetworkLoadHandler.cpp
+++ b/dom/workers/loader/NetworkLoadHandler.cpp
@@ -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;
 }
diff --git a/dom/workers/loader/NetworkLoadHandler.h b/dom/workers/loader/NetworkLoadHandler.h
index 3386a323195c..a4a10e4fa0da 100644
--- a/dom/workers/loader/NetworkLoadHandler.h
+++ b/dom/workers/loader/NetworkLoadHandler.h
@@ -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