Bug 1916277 - Part 6: Implement AddToResolvedModuleSet to complete the 'resolve a module specifier' per spec. r=jonco

The addition is performed after resolution so that resolved specifiers
can be processed more easily, particularly for preload requests. This
change also refactors the return value of ResolvedModuleSpecifier to use
a SpecifierResolutionRecord instead.

Differential Revision: https://phabricator.services.mozilla.com/D272779

Author: allstarschh

dom/script/ScriptLoader.h

@@ -652,6 +652,8 @@ class ScriptLoader final : public JS::loader::ScriptLoaderInterface {
       ScriptLoadRequest* aRequest, const char* aMessageName,
       const nsTArray<nsString>& aParams = nsTArray<nsString>()) const override;
 
+  bool IsImportMapSupported() const override { return true; }
+
   void ReportPreloadErrorsToConsole(ScriptLoadRequest* aRequest);
 
   nsIConsoleReportCollector* GetConsoleReportCollector() const override {

js/loader/ImportMap.cpp

@@ -10,6 +10,7 @@
 #include "js/friend/ErrorMessages.h"  // js::GetErrorMessage, JSMSG_*
 #include "js/JSON.h"                  // JS_ParseJSON
 #include "js/PropertyDescriptor.h"    // JS::PropertyDescriptor
+#include "mozilla/StaticPrefs_dom.h"
 #include "LoadedScript.h"
 #include "ModuleLoaderBase.h"  // ScriptLoaderInterface
 #include "nsContentUtils.h"
@@ -42,9 +43,12 @@ void ReportWarningHelper::Report(const char* aMessageName,
   mLoader->ReportWarningToConsole(mRequest, aMessageName, aParams);
 }
 
+using ResolveURLLikeResult =
+    mozilla::Result<mozilla::NotNull<nsCOMPtr<nsIURI>>, ResolveError>;
+
 // https://html.spec.whatwg.org/multipage/webappapis.html#resolving-a-url-like-module-specifier
-static ResolveResult ResolveURLLikeModuleSpecifier(const nsAString& aSpecifier,
-                                                   nsIURI* aBaseURL) {
+static ResolveURLLikeResult ResolveURLLikeModuleSpecifier(
+    const nsAString& aSpecifier, nsIURI* aBaseURL) {
   nsCOMPtr<nsIURI> uri;
   nsresult rv;
 
@@ -719,6 +723,16 @@ static mozilla::Result<nsCOMPtr<nsIURI>, ResolveError> ResolveImportsMatch(
   return nsCOMPtr<nsIURI>(nullptr);
 }
 
+static UniquePtr<SpecifierResolutionRecord> CreateResolutionRecord(
+    ScriptLoaderInterface* aLoader, nsCString& aSerializedBaseURL,
+    nsString& aNormalizedSpecifier, nsIURI* aAsURL, nsIURI* aResult) {
+  bool isURLLike = !!aAsURL;
+  bool isSpecial = aAsURL ? IsSpecialScheme(aAsURL) : false;
+
+  return mozilla::MakeUnique<SpecifierResolutionRecord>(
+      aSerializedBaseURL, aNormalizedSpecifier, aResult, isURLLike, isSpecial);
+}
+
 // https://html.spec.whatwg.org/multipage/webappapis.html#resolve-a-module-specifier
 // static
 ResolveResult ImportMap::ResolveModuleSpecifier(ImportMap* aImportMap,
@@ -802,10 +816,17 @@ ResolveResult ImportMap::ResolveModuleSpecifier(ImportMap* aImportMap,
 
   // 13. If result is not null, then:
   if (result) {
-    // 2. Return result.
     LOG(("ResolveModuleSpecifier returns result: %s",
          result->GetSpecOrDefault().get()));
-    return WrapNotNull(result);
+    // 1. Add module to resolved module set given settingsObject,
+    //    serializedBaseURL, normalizedSpecifier, and asURL.
+    //
+    // Impl note: Implemented in the caller(ModuleLoaderBase), as we need to
+    // store the result if this resolution is for preload.
+
+    // 2. Return result.
+    return CreateResolutionRecord(aLoader, serializedBaseURL,
+                                  normalizedSpecifier, asURL, result);
   }
 
   LOG(("ResolveModuleSpecifier failed to resolve specifier: %s",

js/loader/ModuleLoaderBase.cpp

@@ -36,10 +36,10 @@
 using mozilla::AutoSlowOperation;
 using mozilla::CycleCollectedJSContext;
 using mozilla::Err;
+using mozilla::MakeUnique;
 using mozilla::MicroTaskRunnable;
 using mozilla::Preferences;
 using mozilla::UniquePtr;
-using mozilla::WrapNotNull;
 using mozilla::dom::AutoJSAPI;
 using mozilla::dom::ReferrerPolicy;
 
@@ -210,9 +210,20 @@ bool ModuleLoaderBase::HostLoadImportedModule(
     }
 
     MOZ_ASSERT(result.isOk());
-    nsCOMPtr<nsIURI> uri = result.unwrap();
+    auto record = result.unwrap();
+    nsCOMPtr<nsIURI> uri = record->Result();
     MOZ_ASSERT(uri, "Failed to resolve module specifier");
 
+    if (ImportMap::IsMultipleImportMapsSupported()) {
+      // This implements the 'Add module to resolved module set' part defined in
+      // 'resolve a module specifier'. This is done here because we need to
+      // process the resolved specifiers differently for preloading module
+      // scripts.
+      //
+      // See https://html.spec.whatwg.org/#resolve-a-module-specifier
+      loader->AddToResolvedModuleSet(std::move(record), script, aHostDefined);
+    }
+
     ModuleType moduleType = GetModuleRequestType(aCx, aModuleRequest);
     if (!loader->IsModuleTypeAllowed(moduleType)) {
       LOG(("ModuleLoaderBase::HostLoadImportedModule uri %s, bad module type",
@@ -398,7 +409,16 @@ JSString* ModuleLoaderBase::ImportMetaResolveImpl(
       return nullptr;
     }
 
-    nsCOMPtr<nsIURI> uri = result.unwrap();
+    MOZ_ASSERT(result.isOk());
+    auto record = result.unwrap();
+
+    nsCOMPtr<nsIURI> uri = record->Result();
+    if (ImportMap::IsMultipleImportMapsSupported()) {
+      // This implements the 'Add module to resolved module set' part defined in
+      // 'resolve a module specifier'.
+      loader->AddToResolvedModuleSet(std::move(record));
+    }
+
     nsAutoCString url;
     MOZ_ALWAYS_SUCCEEDS(uri->GetAsciiSpec(url));
 
@@ -1101,6 +1121,44 @@ ResolveResult ModuleLoaderBase::ResolveModuleSpecifier(
                                            aSpecifier);
 }
 
+ResolvedModuleSet* ModuleLoaderBase::GetResolvedModuleSet() {
+  MOZ_ASSERT(ImportMap::IsMultipleImportMapsSupported());
+  if (!mResolvedModuleSet) {
+    mResolvedModuleSet = MakeUnique<ResolvedModuleSet>();
+  }
+
+  return mResolvedModuleSet.get();
+}
+
+static void AddToResolvedSet(ResolvedModuleSet* aSet,
+                             UniquePtr<SpecifierResolutionRecord> aRecord) {
+  MOZ_ASSERT(ImportMap::IsMultipleImportMapsSupported());
+  auto ptr = aSet->lookupForAdd(aRecord);
+  if (ptr) {
+    return;
+  }
+
+  MOZ_ALWAYS_TRUE(aSet->add(ptr, std::move(aRecord)));
+}
+
+void ModuleLoaderBase::AddToGlobalResolvedSet(
+    UniquePtr<SpecifierResolutionRecord> aRecord) {
+  AddToResolvedSet(GetResolvedModuleSet(), std::move(aRecord));
+}
+
+void ModuleLoaderBase::AddToResolvedModuleSet(
+    UniquePtr<SpecifierResolutionRecord> aRecord, LoadedScript* aScript,
+    Handle<Value> aHostDefined) {
+  // 2. If global does not implement Window, then return.
+  if (!mLoader->IsImportMapSupported()) {
+    return;
+  }
+
+  // release the mResult from the record as it is not needed.
+  nsCOMPtr<nsIURI> _ = aRecord->TakeResult();
+  AddToGlobalResolvedSet(std::move(aRecord));
+}
+
 void ModuleLoaderBase::StartFetchingModuleDependencies(
     ModuleLoadRequest* aRequest) {
   if (aRequest->IsCanceled()) {

js/loader/ModuleLoaderBase.h

@@ -26,6 +26,7 @@
 #include "mozilla/UniquePtr.h"
 #include "mozilla/dom/ReferrerPolicyBinding.h"
 #include "mozilla/StaticPrefs_layout.h"
+#include "ResolvedModuleSet.h"
 #include "ResolveResult.h"
 
 class nsIConsoleReportCollector;
@@ -116,6 +117,10 @@ class ScriptLoaderInterface : public nsISupports {
   }
 
   virtual void MaybeUpdateDiskCache() {}
+
+  // Import map is supported if the global implements 'Windows'.
+  // See https://html.spec.whatwg.org/#concept-global-import-map
+  virtual bool IsImportMapSupported() const { return false; }
 };
 
 class ModuleMapKey : public PLDHashEntryHdr {
@@ -280,6 +285,8 @@ class ModuleLoaderBase : public nsISupports {
 
   mozilla::UniquePtr<ImportMap> mImportMap;
 
+  mozilla::UniquePtr<ResolvedModuleSet> mResolvedModuleSet;
+
   virtual ~ModuleLoaderBase();
 
 #ifdef DEBUG
@@ -441,6 +448,8 @@ class ModuleLoaderBase : public nsISupports {
                        nsIConsoleReportCollector* aReporter,
                        mozilla::dom::SRIMetadata* aMetadataOut);
 
+  ResolvedModuleSet* GetResolvedModuleSet();
+
   // Returns true if the module for given module key is already fetched.
   bool IsModuleFetched(const ModuleMapKey& key) const;
 
@@ -522,6 +531,17 @@ class ModuleLoaderBase : public nsISupports {
   bool IsModuleFetching(const ModuleMapKey& key) const;
   void WaitForModuleFetch(ModuleLoadRequest* aRequest);
 
+  void AddToGlobalResolvedSet(
+      mozilla::UniquePtr<SpecifierResolutionRecord> aRecord);
+
+  // https://html.spec.whatwg.org/#add-module-to-resolved-module-set
+  // The aScript and aHostDefined arguments are for determining if this is
+  // resolved during preloading.
+  void AddToResolvedModuleSet(
+      mozilla::UniquePtr<SpecifierResolutionRecord> aRecord,
+      LoadedScript* aScript = nullptr,
+      Handle<Value> aHostDefined = UndefinedHandleValue);
+
  protected:
   void SetModuleFetchStarted(ModuleLoadRequest* aRequest);
 

js/loader/ResolveResult.h

@@ -8,8 +8,9 @@
 #define js_loader_ResolveResult_h
 
 #include "mozilla/ResultVariant.h"
-#include "mozilla/NotNull.h"
+#include "mozilla/UniquePtr.h"
 #include "nsIURI.h"
+#include "ResolvedModuleSet.h"
 
 namespace JS::loader {
 
@@ -46,10 +47,11 @@ struct ResolveErrorInfo {
 
 /**
  * ResolveResult is used to store the result of 'resolving a module specifier',
- * which could be an URI on success or a ResolveError on failure.
+ * which could be a resolution record on success or a ResolveError on failure.
  */
 using ResolveResult =
-    mozilla::Result<mozilla::NotNull<nsCOMPtr<nsIURI>>, ResolveError>;
+    mozilla::Result<mozilla::UniquePtr<SpecifierResolutionRecord>,
+                    ResolveError>;
 
 }  // namespace JS::loader