[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/V8Binding.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
@@ skipping 44 matching lines @@
       : 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_);

[hiroshige, 2017/04/27 22:56:40]

EXPECT_EQ(state, module_script->InstantiationState()) around here?

[kouhei (in TOK), 2017/04/28 00:55:09]

Done.

     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*) override {
+    ScriptState::Scope scope(script_state_.Get());

[hiroshige, 2017/04/27 22:56:40]

Can we make this just the same as ModulatorImpl's one?

[kouhei (in TOK), 2017/04/28 00:55:09]

Done.

+    v8::Local<v8::Value> error = V8ThrowException::CreateError(
+        script_state_->GetIsolate(), "Previous instantiation failure.");
+    return ScriptValue(script_state_.Get(), error);
+  }
+
   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_;
@@ skipping 42 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);
   EXPECT_TRUE(client->WasNotifyFinished());
   ASSERT_TRUE(client->GetModuleScript());
   EXPECT_EQ(client->GetModuleScript()->InstantiationState(),
             ModuleInstantiationState::kErrored);
 }
 
+TEST_F(ModuleTreeLinkerTest, FetchTreePreviousInstantiationFailure) {

[hiroshige, 2017/04/27 22:56:40]

This looks almost the same as FetchTreeInstantiationFailure.
Probably we should do an additional Fetch() call at the end of this test.

[kouhei (in TOK), 2017/04/28 00:55:09]

It is similar, but I'd like to keep them separate.
- ModuleTreeLinkerModulator doesn't have a "real" module map to dedupe
previously resolved module fetch.
- This test is expected to fail without Modulator::InstantiateModule().

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

Oh, understood.
So
Emulates "previous instantiation failure", and
this tests the case where Fetch() results in kErrored when *previous*
instantiation is failed.

And FetchTreeInstantiationFailure tests the case where
Fetch() results in kErrored when *current* instantiation is failed
emulated by SetInstantiateShouldFail(true);

Probably adding some comments might be helpful.

+  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, {}, 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