[ES6 modules] Return previous error when an instantiation is reattempt.

third_party/WebKit/Source/core/loader/modulescript/ModuleTreeLinkerTest.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 "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8BindingForCore.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
@@ skipping 31 matching lines @@
   }
 
   bool WasNotifyFinished() const { return was_notify_finished_; }
   ModuleScript* GetModuleScript() { return module_script_; }
 
  private:
   bool was_notify_finished_ = false;
   Member<ModuleScript> module_script_;
 };
 
+}  // namespace
+
 class ModuleTreeLinkerTestModulator final : public DummyModulator {
  public:
   ModuleTreeLinkerTestModulator(RefPtr<ScriptState> script_state)
       : script_state_(std::move(script_state)) {}
   ~ModuleTreeLinkerTestModulator() override {}
 
   DECLARE_TRACE();
 
   enum class ResolveResult { kFailure, kSuccess };
 
   // Resolve last |Modulator::FetchSingle()| call.
   ModuleScript* ResolveSingleModuleScriptFetch(
       const KURL& url,
-      const Vector<String>& dependency_module_requests) {
+      const Vector<String>& dependency_module_requests,
+      ModuleInstantiationState state) {
     ScriptState::Scope scope(script_state_.Get());
 
     StringBuilder source_text;
     for (const auto& request : dependency_module_requests) {
       source_text.Append("import '");
       source_text.Append(request);
       source_text.Append("';\n");
     }
     source_text.Append("export default 'grapes';");
 
     ScriptModule script_module = ScriptModule::Compile(
         script_state_->GetIsolate(), source_text.ToString(), url.GetString(),
         kSharableCrossOrigin);
     ModuleScript* module_script =
         ModuleScript::Create(this, script_module, url, "", kParserInserted,
                              WebURLRequest::kFetchCredentialsModeOmit);
     auto result_request = dependency_module_requests_map_.insert(
         script_module, dependency_module_requests);
     EXPECT_TRUE(result_request.is_new_entry);
     auto result_map = module_map_.insert(url, module_script);
     EXPECT_TRUE(result_map.is_new_entry);
 
+    if (state == ModuleInstantiationState::kErrored) {
+      v8::Local<v8::Value> error = V8ThrowException::CreateError(
+          script_state_->GetIsolate(), "Instantiation failure.");
+      module_script->SetInstantiationErrorAndClearRecord(
+          ScriptValue(script_state_.Get(), error));
+    }
+
     EXPECT_EQ(url, pending_request_url_);
+    EXPECT_EQ(state, module_script->InstantiationState());
     EXPECT_TRUE(pending_client_);
     pending_client_->NotifyModuleLoadFinished(module_script);
     pending_client_.Clear();
 
     return module_script;
   }
 
   // Get AncestorList specified in |Modulator::FetchTreeInternal()| call for
   // request matching |url|.
   AncestorList GetAncestorListForTreeFetch(const KURL& url) const {
@@ skipping 70 matching lines @@
   ScriptValue InstantiateModule(ScriptModule) override {
     if (instantiate_should_fail_) {
       ScriptState::Scope scope(script_state_.Get());
       v8::Local<v8::Value> error = V8ThrowException::CreateError(
           script_state_->GetIsolate(), "Instantiation failure.");
       return ScriptValue(script_state_.Get(), error);
     }
     return ScriptValue();
   }
 
+  ScriptValue GetInstantiationError(
+      const ModuleScript* module_script) override {
+    ScriptState::Scope scope(script_state_.Get());
+    return ScriptValue(script_state_.Get(),
+                       module_script->CreateInstantiationErrorInternal(
+                           script_state_->GetIsolate()));
+  }
+
   Vector<String> ModuleRequestsFromScriptModule(
       ScriptModule script_module) override {
+    if (script_module.IsNull())
+      return Vector<String>();
+
     const auto& it = dependency_module_requests_map_.find(script_module);
     if (it == dependency_module_requests_map_.end())
       return Vector<String>();
 
     return it->value;
   }
 
   RefPtr<ScriptState> script_state_;
   KURL pending_request_url_;
   Member<SingleModuleClient> pending_client_;
   HashMap<ScriptModule, Vector<String>> dependency_module_requests_map_;
   HeapHashMap<KURL, Member<ModuleScript>> module_map_;
   HeapHashMap<KURL, Member<ModuleTreeClient>> pending_tree_client_map_;
   HashMap<KURL, AncestorList> pending_tree_ancestor_list_;
   bool instantiate_should_fail_ = false;
 };
 
 DEFINE_TRACE(ModuleTreeLinkerTestModulator) {
   visitor->Trace(pending_client_);
   visitor->Trace(module_map_);
   visitor->Trace(pending_tree_client_map_);
   DummyModulator::Trace(visitor);
 }
 
-}  // namespace
-
 class ModuleTreeLinkerTest : public ::testing::Test {
   DISALLOW_COPY_AND_ASSIGN(ModuleTreeLinkerTest);
 
  public:
   ModuleTreeLinkerTest() = default;
   void SetUp() override;
 
   ModuleTreeLinkerTestModulator* GetModulator() { return modulator_.Get(); }
 
  protected:
@@ skipping 16 matching lines @@
       url, String(), kParserInserted, WebURLRequest::kFetchCredentialsModeOmit);
   TestModuleTreeClient* client = new TestModuleTreeClient;
   registry->Fetch(module_request, AncestorList(),
                   ModuleGraphLevel::kTopLevelModuleFetch, GetModulator(),
                   client);
 
   EXPECT_FALSE(client->WasNotifyFinished())
       << "ModuleTreeLinker should always finish asynchronously.";
   EXPECT_FALSE(client->GetModuleScript());
 
-  GetModulator()->ResolveSingleModuleScriptFetch(url, {});
+  GetModulator()->ResolveSingleModuleScriptFetch(
+      url, {}, ModuleInstantiationState::kUninstantiated);
   EXPECT_TRUE(client->WasNotifyFinished());
   ASSERT_TRUE(client->GetModuleScript());
   EXPECT_EQ(client->GetModuleScript()->InstantiationState(),
             ModuleInstantiationState::kInstantiated);
 }
 
 TEST_F(ModuleTreeLinkerTest, FetchTreeInstantiationFailure) {
   GetModulator()->SetInstantiateShouldFail(true);
 
   ModuleTreeLinkerRegistry* registry = ModuleTreeLinkerRegistry::Create();
 
   KURL url(kParsedURLString, "http://example.com/root.js");
   ModuleScriptFetchRequest module_request(
       url, String(), kParserInserted, WebURLRequest::kFetchCredentialsModeOmit);
   TestModuleTreeClient* client = new TestModuleTreeClient;
   registry->Fetch(module_request, AncestorList(),
                   ModuleGraphLevel::kTopLevelModuleFetch, GetModulator(),
                   client);
 
   EXPECT_FALSE(client->WasNotifyFinished())
       << "ModuleTreeLinker should always finish asynchronously.";
   EXPECT_FALSE(client->GetModuleScript());
 
-  GetModulator()->ResolveSingleModuleScriptFetch(url, {});
+  GetModulator()->ResolveSingleModuleScriptFetch(
+      url, {}, ModuleInstantiationState::kUninstantiated);
+
+  // Modulator::InstantiateModule() fails here, as
+  // we SetInstantiateShouldFail(true) earlier.
+
   EXPECT_TRUE(client->WasNotifyFinished());
   ASSERT_TRUE(client->GetModuleScript());
   EXPECT_EQ(client->GetModuleScript()->InstantiationState(),
             ModuleInstantiationState::kErrored);
 }
 
+TEST_F(ModuleTreeLinkerTest, FetchTreePreviousInstantiationFailure) {
+  ModuleTreeLinkerRegistry* registry = ModuleTreeLinkerRegistry::Create();
+
+  KURL url(kParsedURLString, "http://example.com/root.js");
+  ModuleScriptFetchRequest module_request(
+      url, String(), kParserInserted, WebURLRequest::kFetchCredentialsModeOmit);
+  TestModuleTreeClient* client = new TestModuleTreeClient;
+  registry->Fetch(module_request, AncestorList(),
+                  ModuleGraphLevel::kTopLevelModuleFetch, GetModulator(),
+                  client);
+
+  EXPECT_FALSE(client->WasNotifyFinished())
+      << "ModuleTreeLinker should always finish asynchronously.";
+  EXPECT_FALSE(client->GetModuleScript());
+
+  // This emulates "previous instantiation failure", where
+  // Modulator::FetchSingle resolves w/ "errored" module script.
+  GetModulator()->ResolveSingleModuleScriptFetch(
+      url, {}, ModuleInstantiationState::kErrored);
+  EXPECT_TRUE(client->WasNotifyFinished());
+  ASSERT_TRUE(client->GetModuleScript());
+  EXPECT_EQ(ModuleInstantiationState::kErrored,
+            client->GetModuleScript()->InstantiationState());
+}
+
 TEST_F(ModuleTreeLinkerTest, FetchTreeWithSingleDependency) {
   ModuleTreeLinkerRegistry* registry = ModuleTreeLinkerRegistry::Create();
 
   KURL url(kParsedURLString, "http://example.com/root.js");
   ModuleScriptFetchRequest module_request(
       url, String(), kParserInserted, WebURLRequest::kFetchCredentialsModeOmit);
   TestModuleTreeClient* client = new TestModuleTreeClient;
   registry->Fetch(module_request, AncestorList(),
                   ModuleGraphLevel::kTopLevelModuleFetch, GetModulator(),
                   client);
 
   EXPECT_FALSE(client->WasNotifyFinished())
       << "ModuleTreeLinker should always finish asynchronously.";
   EXPECT_FALSE(client->GetModuleScript());
 
-  GetModulator()->ResolveSingleModuleScriptFetch(url, {"./dep1.js"});
+  GetModulator()->ResolveSingleModuleScriptFetch(
+      url, {"./dep1.js"}, ModuleInstantiationState::kUninstantiated);
   EXPECT_FALSE(client->WasNotifyFinished());
 
   KURL url_dep1(kParsedURLString, "http://example.com/dep1.js");
   auto ancestor_list = GetModulator()->GetAncestorListForTreeFetch(url_dep1);
   EXPECT_EQ(1u, ancestor_list.size());
   EXPECT_TRUE(ancestor_list.Contains(
       KURL(kParsedURLString, "http://example.com/root.js")));
 
   GetModulator()->ResolveDependentTreeFetch(
       url_dep1, ModuleTreeLinkerTestModulator::ResolveResult::kSuccess);
@@ skipping 13 matching lines @@
   TestModuleTreeClient* client = new TestModuleTreeClient;
   registry->Fetch(module_request, AncestorList(),
                   ModuleGraphLevel::kTopLevelModuleFetch, GetModulator(),
                   client);
 
   EXPECT_FALSE(client->WasNotifyFinished())
       << "ModuleTreeLinker should always finish asynchronously.";
   EXPECT_FALSE(client->GetModuleScript());
 
   GetModulator()->ResolveSingleModuleScriptFetch(
-      url, {"./dep1.js", "./dep2.js", "./dep3.js"});
+      url, {"./dep1.js", "./dep2.js", "./dep3.js"},
+      ModuleInstantiationState::kUninstantiated);
   EXPECT_FALSE(client->WasNotifyFinished());
 
   Vector<KURL> url_deps;
   for (int i = 1; i <= 3; ++i) {
     StringBuilder url_dep_str;
     url_dep_str.Append("http://example.com/dep");
     url_dep_str.AppendNumber(i);
     url_dep_str.Append(".js");
 
     KURL url_dep(kParsedURLString, url_dep_str.ToString());
@@ skipping 29 matching lines @@
   TestModuleTreeClient* client = new TestModuleTreeClient;
   registry->Fetch(module_request, AncestorList(),
                   ModuleGraphLevel::kTopLevelModuleFetch, GetModulator(),
                   client);
 
   EXPECT_FALSE(client->WasNotifyFinished())
       << "ModuleTreeLinker should always finish asynchronously.";
   EXPECT_FALSE(client->GetModuleScript());
 
   GetModulator()->ResolveSingleModuleScriptFetch(
-      url, {"./dep1.js", "./dep2.js", "./dep3.js"});
+      url, {"./dep1.js", "./dep2.js", "./dep3.js"},
+      ModuleInstantiationState::kUninstantiated);
   EXPECT_FALSE(client->WasNotifyFinished());
 
   Vector<KURL> url_deps;
   for (int i = 1; i <= 3; ++i) {
     StringBuilder url_dep_str;
     url_dep_str.Append("http://example.com/dep");
     url_dep_str.AppendNumber(i);
     url_dep_str.Append(".js");
 
     KURL url_dep(kParsedURLString, url_dep_str.ToString());
@@ skipping 38 matching lines @@
   TestModuleTreeClient* client = new TestModuleTreeClient;
   registry->Fetch(
       module_request,
       AncestorList{KURL(kParsedURLString, "http://example.com/root.js")},
       ModuleGraphLevel::kDependentModuleFetch, GetModulator(), client);
 
   EXPECT_FALSE(client->WasNotifyFinished())
       << "ModuleTreeLinker should always finish asynchronously.";
   EXPECT_FALSE(client->GetModuleScript());
 
-  GetModulator()->ResolveSingleModuleScriptFetch(url, {"./depth2.js"});
+  GetModulator()->ResolveSingleModuleScriptFetch(
+      url, {"./depth2.js"}, ModuleInstantiationState::kUninstantiated);
 
   KURL url_dep2(kParsedURLString, "http://example.com/depth2.js");
   auto ancestor_list = GetModulator()->GetAncestorListForTreeFetch(url_dep2);
   EXPECT_EQ(2u, ancestor_list.size());
   EXPECT_TRUE(ancestor_list.Contains(
       KURL(kParsedURLString, "http://example.com/root.js")));
   EXPECT_TRUE(ancestor_list.Contains(
       KURL(kParsedURLString, "http://example.com/depth1.js")));
 
   GetModulator()->ResolveDependentTreeFetch(
       url_dep2, ModuleTreeLinkerTestModulator::ResolveResult::kSuccess);
 
   EXPECT_TRUE(client->WasNotifyFinished());
   ASSERT_TRUE(client->GetModuleScript());
   EXPECT_EQ(client->GetModuleScript()->InstantiationState(),
             ModuleInstantiationState::kInstantiated);
 }
 
 }  // namespace blink