[not-for-commit] kitsune changes + pending kouhei changes

third_party/WebKit/Source/core/loader/modulescript/ModuleTreeLinker.cpp

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/loader/modulescript/ModuleTreeLinker.h"
 
 #include "bindings/core/v8/ScriptModule.h"
 #include "core/dom/AncestorList.h"
 #include "core/dom/ModuleScript.h"
 #include "core/loader/modulescript/ModuleScriptFetchRequest.h"
@@ skipping 94 matching lines @@
       NOTREACHED();
       break;
   }
 
   state_ = new_state;
 
   if (state_ == State::kFinished) {
     registry_->ReleaseFinishedFetcher(this);
 
     // https://html.spec.whatwg.org/multipage/webappapis.html#internal-module-script-graph-fetching-procedure
-    // Step 8. Asynchronously complete this algorithm with descendants result.
+    // Step 9. Asynchronously complete this algorithm with descendants result.
     client_->NotifyModuleTreeLoadFinished(descendants_module_script_);
   }
 }
 
 void ModuleTreeLinker::FetchSelf(const ModuleScriptFetchRequest& request,
                                  ModuleGraphLevel level) {
   // https://html.spec.whatwg.org/multipage/webappapis.html#internal-module-script-graph-fetching-procedure
 
   // Step 1. Fetch a single module script given url, fetch client settings
   // object, destination, cryptographic nonce, parser state, credentials mode,
@@ skipping 71 matching lines @@
 
   // https://html.spec.whatwg.org/multipage/webappapis.html#fetch-the-descendants-of-a-module-script
 
   // Step 1. Let record be module script's module record.
   ScriptModule record = module_script_->Record();
 
   // Step 2. If record.[[RequestedModules]] is empty, asynchronously complete
   // this algorithm with module script.
   Vector<String> module_requests =
       modulator_->ModuleRequestsFromScriptModule(record);
-  if (module_requests.IsEmpty()) {
-    // Continue to Instantiate() to process "internal module script graph
-    // fetching procedure" Step 5-.
-    descendants_module_script_ = module_script_;
-    Instantiate();
-    return;
-  }
 
   // Step 3. Let urls be a new empty list.
   Vector<KURL> urls;
 
   // Step 4. For each string requested of record.[[RequestedModules]],
   for (const auto& module_request : module_requests) {
     // Step 4.1. Let url be the result of resolving a module specifier given
     // module script and requested.
     KURL url = Modulator::ResolveModuleSpecifier(module_request,
                                                  module_script_->BaseURL());
 
     // Step 4.2. If the result is error: ...
     if (url.IsNull()) {
       // Let error be a new TypeError exception.
       // Report the exception error for module script.
       // TODO(kouhei): Implement the exception.
 
       // Abort this algorithm, and asynchronously complete it with null.
       // Note: The return variable for "internal module script graph fetching
-      // procedure" is descendants_module_script_ per Step 8.
+      // procedure" is descendants_module_script_ per Step 9.
       DCHECK(!descendants_module_script_);
       // Note: while we complete "fetch the descendants of a module script"
       //       algorithm here, we still need to continue to the rest of the
       //       steps in "internal module script graph fetching procedure"
       Instantiate();
       return;
     }
 
     // Step 4.3. Otherwise, if ancestor list does not contain url, append url to
     // urls.
 
     // Modulator::resolveModuleSpecifier() impl must return either a valid url
     // or null.
     CHECK(url.IsValid());
     if (!ancestor_list_with_url_.Contains(url))
       urls.push_back(url);
   }
 
   // Step 5. For each url in urls, perform the internal module script graph
   // fetching procedure given url, module script's credentials mode, module
   // script's cryptographic nonce, module script's parser state, destination,
   // module script's settings object, module script's settings object, ancestor
   // list, module script's base URL, and with the top-level module fetch flag
   // unset. If the caller of this algorithm specified custom perform the fetch
   // steps, pass those along while performing the internal module script graph
   // fetching procedure.
   // TODO(kouhei): handle "destination".
-  DCHECK(!urls.IsEmpty());
+  if (urls.IsEmpty()) {

[kouhei (in TOK), 2017/04/26 13:03:44]

DCHECK doesn't always hold. The requests may be all in ancestor_list

[hiroshige, 2017/04/28 01:15:35]

Memo: This causes crash in imports.html wpt test.

+    // Continue to Instantiate() to process "internal module script graph
+    // fetching procedure" Step 5-.
+    descendants_module_script_ = module_script_;
+    Instantiate();
+
+    RESOURCE_LOADING_DVLOG(1) << "maybe cycles? " << module_script_->BaseURL().GetString();
+    return;
+  }
   CHECK_EQ(num_incomplete_descendants_, 0u);
   num_incomplete_descendants_ = urls.size();
   for (const KURL& url : urls) {
     DependencyModuleClient* dependency_client =
         DependencyModuleClient::Create(this);
     dependency_clients_.insert(dependency_client);
 
     ModuleScriptFetchRequest request(url, module_script_->Nonce(),
                                      module_script_->ParserState(),
                                      module_script_->CredentialsMode(),
@@ skipping 57 matching lines @@
     Instantiate();
   }
 }
 
 void ModuleTreeLinker::Instantiate() {
   CHECK(module_script_);
   AdvanceState(State::kInstantiating);
 
   // https://html.spec.whatwg.org/multipage/webappapis.html#internal-module-script-graph-fetching-procedure
 
-  // Step 5. Let record be result's module record.
-  ScriptModule record = module_script_->Record();
-
-  // Step 6. Let instantiationStatus be record.ModuleDeclarationInstantiation().
+  // Step 5. Let instantiationStatus be null.
   // Note: The |error| variable corresponds to spec variable
   // "instantiationStatus". If |error| is empty, it indicates successful
   // completion.
-  ScriptValue error = modulator_->InstantiateModule(record);
+  ScriptValue error;
 
-  // Step 7. For each module script script in result's uninstantiated inclusive
+  // Step 6. If result's instantiation state is "errored",...
+  if (module_script_->InstantiationState() ==
+      ModuleInstantiationState::kErrored) {
+    // ... Set instantiationStatus to record.ModuleDeclarationInstantiation().
+    error = modulator_->GetInstantiationError(module_script_);
+  } else {
+    // Step 7. Otherwise:
+    // Step 7.1. Let record be result's module record.
+    ScriptModule record = module_script_->Record();
+    // Step 7.2. Set instantiationStatus to
+    // record.ModuleDeclarationInstantiation().
+    error = modulator_->InstantiateModule(record);
+  }
+
+  // Step 8. For each module script script in result's uninstantiated inclusive
   // descendant module scripts, perform the following steps:
   HeapHashSet<Member<ModuleScript>> uninstantiated_set =
       UninstantiatedInclusiveDescendants();
   for (const auto& descendant : uninstantiated_set) {
     if (!error.IsEmpty()) {
-      // Step 7.1. If instantiationStatus is an abrupt completion, then set
-      // script's instantiation state to "errored", its instantiation error to
-      // instantiationStatus.[[Value]], and its module record to null.
+      // Step 8.1. If instantiationStatus is an abrupt completion, then
+      // Step 8.1.1. Set script module record's [[HostDefined]] field to
+      // undefined.
+      // TODO(kouhei): Implement this.
+
+      // Step 8.1.2. Set script's module record to null.
+      // Step 8.1.3. Set script's instantiation state to "errored".
+      // Step 8.1.4. Set script's instantiation error to
+      // instantiationStatus.[[Value]].
       descendant->SetInstantiationErrorAndClearRecord(error);
     } else {
-      // Step 7.2. Otherwise, set script's instantiation state to
+      // Step 8.2. Otherwise, set script's instantiation state to
       // "instantiated".
       descendant->SetInstantiationSuccess();
     }
   }
 
-  // Step 8. Asynchronously complete this algorithm with descendants result.
+  // Step 9. Asynchronously complete this algorithm with descendants result.
   AdvanceState(State::kFinished);
 }
 
 HeapHashSet<Member<ModuleScript>>
 ModuleTreeLinker::UninstantiatedInclusiveDescendants() {
   // https://html.spec.whatwg.org/multipage/webappapis.html#uninstantiated-inclusive-descendant-module-scripts
   // Step 1. Let moduleMap be script's settings object's module map.
   // Note: Modulator is our "settings object".
   // Note: We won't reference the ModuleMap directly here to aid testing.
 
@@ skipping 78 matching lines @@
   HeapHashSet<Member<ModuleScript>> uninstantiated_set;
   for (const auto& script : inclusive_descendants) {
     if (script->InstantiationState() ==
         ModuleInstantiationState::kUninstantiated)
       uninstantiated_set.insert(script);
   }
   return uninstantiated_set;
 }
 
 }  // namespace blink