[ES6 modules] ModuleTreeLinker::FetchDescendants should not assume urls isn't empty.

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 215 matching lines @@
   CHECK(module_script_);
   AdvanceState(State::kFetchingDependencies);
 
   // 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;
-  }
+  // Note: We defer this bail-out until Step 5. Step 4 will be no-op anyway if
+  //       record.[[RequestedModules]] is empty.
 
   // Step 3. Let urls be a new empty list.
   Vector<KURL> urls;
 
   // Step 4. For each string requested of record.[[RequestedModules]],
+  Vector<String> module_requests =
+      modulator_->ModuleRequestsFromScriptModule(record);
   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.
@@ skipping 21 matching lines @@
   }
 
   // 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()) {
+    // Step 2. If record.[[RequestedModules]] is empty, asynchronously
+    // complete this algorithm with module script. [spec text]
+    // Also, if record.[[RequestedModules]] is not empty but |urls| is
+    // empty here, we can immediately complete this algorithm, as
+    // we don't have to process or wait for anything in Step 5. [non-spec text]
+
+    // Proceed to Instantiate() to continue
+    // "internal module script graph fetching procedure".
+    descendants_module_script_ = module_script_;
+    Instantiate();
+    return;
+  }
+
+  // Step 5, when "urls" is non-empty.
   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 200 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