Enable module scripts in ScriptLoader

third_party/WebKit/Source/core/dom/ScriptLoader.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2008 Nikolas Zimmermann <zimmermann@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "core/dom/ScriptLoader.h"
 
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptSourceCode.h"
+#include "bindings/core/v8/V8Binding.h"
 #include "core/HTMLNames.h"
 #include "core/SVGNames.h"
 #include "core/dom/ClassicPendingScript.h"
 #include "core/dom/ClassicScript.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentParserTiming.h"
 #include "core/dom/IgnoreDestructiveWriteCountIncrementer.h"
+#include "core/dom/Modulator.h"
+#include "core/dom/ModulePendingScript.h"
 #include "core/dom/Script.h"
 #include "core/dom/ScriptElementBase.h"
 #include "core/dom/ScriptRunner.h"
 #include "core/dom/ScriptableDocumentParser.h"
 #include "core/dom/Text.h"
 #include "core/events/Event.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/SubresourceIntegrity.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/CrossOriginAttribute.h"
 #include "core/html/imports/HTMLImport.h"
 #include "core/html/parser/HTMLParserIdioms.h"
+#include "core/loader/modulescript/ModuleScriptFetchRequest.h"
+#include "core/loader/resource/ScriptResource.h"
 #include "platform/WebFrameScheduler.h"
 #include "platform/loader/fetch/AccessControlStatus.h"
 #include "platform/loader/fetch/FetchParameters.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
 #include "platform/network/mime/MIMETypeRegistry.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/wtf/StdLibExtras.h"
 #include "platform/wtf/text/StringBuilder.h"
 #include "platform/wtf/text/StringHash.h"
 #include "public/platform/WebCachePolicy.h"
@@ skipping 41 matching lines @@
         element_->GetDocument().GetScriptableDocumentParser()->LineNumber();
   }
 }
 
 ScriptLoader::~ScriptLoader() {}
 
 DEFINE_TRACE(ScriptLoader) {
   visitor->Trace(element_);
   visitor->Trace(resource_);
   visitor->Trace(pending_script_);
+  visitor->Trace(module_tree_client_);
   PendingScriptClient::Trace(visitor);
 }
 
 void ScriptLoader::SetFetchDocWrittenScriptDeferIdle() {
   DCHECK(!created_during_document_write_);
   document_write_intervention_ =
       DocumentWriteIntervention::kFetchDocWrittenScriptDeferIdle;
 }
 
 void ScriptLoader::DidNotifySubtreeInsertionsToDocument() {
@@ skipping 109 matching lines @@
   // 5. "If the element is not connected, then abort these steps.
   //     The script is not executed."
   if (!element_->IsConnected())
     return false;
 
   // 6.
   // TODO(hiroshige): Annotate and/or cleanup this step.
   if (!IsScriptTypeSupported(support_legacy_types))
     return false;
 
+  // TODO(hiroshige): Make the determination of script type spec-comformant.
+  if (RuntimeEnabledFeatures::moduleScriptsEnabled() &&
+      element_->TypeAttributeValue() == "module") {
+    script_type_ = ScriptType::kModule;
+  } else {
+    script_type_ = ScriptType::kClassic;
+  }
+
   // 7. "If was-parser-inserted is true,
   //     then flag the element as "parser-inserted" again,
   //     and set the element's "non-blocking" flag to false."
   if (was_parser_inserted) {
     parser_inserted_ = true;
     non_blocking_ = false;
   }
 
   // 8. "Set the element's "already started" flag."
   already_started_ = true;
@@ skipping 40 matching lines @@
     if (!parser_inserted_ || element_->AsyncAttributeValue() ||
         element_->DeferAttributeValue())
       defer = FetchParameters::kLazyLoad;
     if (document_write_intervention_ ==
         DocumentWriteIntervention::kFetchDocWrittenScriptDeferIdle)
       defer = FetchParameters::kIdleLoad;
     if (!FetchScript(element_->SourceAttributeValue(), encoding, defer))
       return false;
   }
 
+  // Inline module script is not yet supported.
+  if (GetScriptType() == ScriptType::kModule && !module_tree_client_) {
+    fprintf(stderr,
+            "Inline module script is not yet supported (Document URL: %s)\n",
+            element_document.Url().GetString().Utf8().Data());
+    CHECK(false);
+  }
+
   // 22. "If the element does not have a src content attribute,
   //      run these substeps:"
 
   // 22.1. "Let source text be the value of the text IDL attribute."
   // This step is done later:
   // - in ScriptLoader::pendingScript() (Step 23, 6th Clause),
   //   as Element::textFromChildren() in ScriptLoader::scriptContent(),
   // - in HTMLParserScriptRunner::processScriptElementInternal()
   //   (Duplicated code of Step 23, 6th Clause),
   //   as Element::textContent(),
   // - in XMLDocumentParser::endElementNs() (Step 23, 5th Clause),
   //   as Element::textFromChildren() in ScriptLoader::scriptContent(),
   // - PendingScript::getSource() (Indirectly used via
   //   HTMLParserScriptRunner::processScriptElementInternal(),
   //   Step 23, 5th Clause),
   //   as Element::textContent().
   // TODO(hiroshige): Make them merged or consistent.
 
   // 22.2. "Switch on the script's type:"
   // TODO(hiroshige): Clarify how Step 22.2 is implemented for "classic".
   // TODO(hiroshige): Implement Step 22.2 for "module".
 
   // [Intervention]
   // Since the asynchronous, low priority fetch for doc.written blocked
   // script is not for execution, return early from here. Watch for its
   // completion to be able to remove it from the memory cache.
-  if (document_write_intervention_ ==
-      DocumentWriteIntervention::kFetchDocWrittenScriptDeferIdle) {
+  if (GetScriptType() == ScriptType::kClassic &&
+      document_write_intervention_ ==
+          DocumentWriteIntervention::kFetchDocWrittenScriptDeferIdle) {
     pending_script_ = CreatePendingScript();
     pending_script_->WatchForLoad(this);
     return true;
   }
 
   // 23. "Then, follow the first of the following options that describes the
   //      situation:"
 
   // Three flags are used to instruct the caller of prepareScript() to execute
   // a part of Step 23, when |m_willBeParserExecuted| is true:
   // - |m_willBeParserExecuted|
   // - |m_willExecuteWhenDocumentFinishedParsing|
   // - |m_readyToBeParserExecuted|
   // TODO(hiroshige): Clean up the dependency.
 
   // 1st Clause:
   // - "If the script's type is "classic", and
   //    the element has a src attribute, and the element has a defer attribute,
   //    and the element has been flagged as "parser-inserted",
   //    and the element does not have an async attribute"
-  // TODO(hiroshige): Check the script's type and implement "module" case.
-  if (element_->HasSourceAttribute() && element_->DeferAttributeValue() &&
-      parser_inserted_ && !element_->AsyncAttributeValue()) {
+  // - "If the script's type is "module",
+  //    and the element has been flagged as "parser-inserted",
+  //    and the element does not have an async attribute"
+  if ((GetScriptType() == ScriptType::kClassic &&
+       element_->HasSourceAttribute() && element_->DeferAttributeValue() &&
+       parser_inserted_ && !element_->AsyncAttributeValue()) ||
+      (GetScriptType() == ScriptType::kModule && parser_inserted_ &&
+       !element_->AsyncAttributeValue())) {
     // This clause is implemented by the caller-side of prepareScript():
     // - HTMLParserScriptRunner::requestDeferredScript(), and
     // - TODO(hiroshige): Investigate XMLDocumentParser::endElementNs()
     will_execute_when_document_finished_parsing_ = true;
     will_be_parser_executed_ = true;
 
     return true;
   }
 
   // 2nd Clause:
   // - "If the script's type is "classic",
   //    and the element has a src attribute,
   //    and the element has been flagged as "parser-inserted",
   //    and the element does not have an async attribute"
   // TODO(hiroshige): Check the script's type.
-  if (element_->HasSourceAttribute() && parser_inserted_ &&
+  if (GetScriptType() == ScriptType::kClassic &&
+      element_->HasSourceAttribute() && parser_inserted_ &&
       !element_->AsyncAttributeValue()) {
     // This clause is implemented by the caller-side of prepareScript():
     // - HTMLParserScriptRunner::requestParsingBlockingScript()
     // - TODO(hiroshige): Investigate XMLDocumentParser::endElementNs()
     will_be_parser_executed_ = true;
 
     return true;
   }
 
   // 5th Clause:
   // TODO(hiroshige): Reorder the clauses to match the spec.
   // - "If the element does not have a src attribute,
   //    and the element has been flagged as "parser-inserted",
   //    and either the parser that created the script is an XML parser
   //      or it's an HTML parser whose script nesting level is not greater than
   //      one,
   //    and the Document of the HTML parser or XML parser that created
   //      the script element has a style sheet that is blocking scripts"
   // The last part "... has a style sheet that is blocking scripts"
   // is implemented in Document::isScriptExecutionReady().
   // Part of the condition check is done in
   // HTMLParserScriptRunner::processScriptElementInternal().
   // TODO(hiroshige): Clean up the split condition check.
-  if (!element_->HasSourceAttribute() && parser_inserted_ &&
+  // We check that the type is "classic" here, because according to the spec
+  // a "module" script doesn't reach the 5th Clause because the 4th Clause
+  // catches all "module" scripts.
+  if (GetScriptType() == ScriptType::kClassic &&
+      !element_->HasSourceAttribute() && parser_inserted_ &&
       !element_document.IsScriptExecutionReady()) {
     // The former part of this clause is
     // implemented by the caller-side of prepareScript():
     // - HTMLParserScriptRunner::requestParsingBlockingScript()
     // - TODO(hiroshige): Investigate XMLDocumentParser::endElementNs()
     will_be_parser_executed_ = true;
     // "Set the element's "ready to be parser-executed" flag."
     ready_to_be_parser_executed_ = true;
 
     return true;
   }
 
   // 3rd Clause:
   // - "If the script's type is "classic",
   //    and the element has a src attribute,
   //    and the element does not have an async attribute,
   //    and the element does not have the "non-blocking" flag set"
+  // - "If the script's type is "module",
+  //    and the element does not have an async attribute,
+  //    and the element does not have the "non-blocking" flag set"
   // TODO(hiroshige): Check the script's type and implement "module" case.
-  if (element_->HasSourceAttribute() && !element_->AsyncAttributeValue() &&
-      !non_blocking_) {
+  if ((GetScriptType() == ScriptType::kClassic &&
+       element_->HasSourceAttribute() && !element_->AsyncAttributeValue() &&
+       !non_blocking_) ||
+      (GetScriptType() == ScriptType::kModule &&
+       !element_->AsyncAttributeValue() && !non_blocking_)) {
     // "Add the element to the end of the list of scripts that will execute
     // in order as soon as possible associated with the node document of the
     // script element at the time the prepare a script algorithm started."
     pending_script_ = CreatePendingScript();
     async_exec_type_ = ScriptRunner::kInOrder;
     // TODO(hiroshige): Here |contextDocument| is used as "node document"
-    // while Step 14 uses |elementDocument| as "node document". Fix this.
+    // while Step 14 uses |element_document| as "node document". Fix this.
     context_document->GetScriptRunner()->QueueScriptForExecution(
         this, async_exec_type_);
     // Note that watchForLoad can immediately call pendingScriptFinished.
     pending_script_->WatchForLoad(this);
     // The part "When the script is ready..." is implemented in
     // ScriptRunner::notifyScriptReady().
     // TODO(hiroshige): Annotate it.
 
     return true;
   }
 
   // 4th Clause:
   // - "If the script's type is "classic", and the element has a src attribute"
-  // TODO(hiroshige): Check the script's type and implement "module" case.
-  if (element_->HasSourceAttribute()) {
+  // - "If the script's type is "module""
+  if ((GetScriptType() == ScriptType::kClassic &&
+       element_->HasSourceAttribute()) ||
+      GetScriptType() == ScriptType::kModule) {
     // "The element must be added to the set of scripts that will execute
     //  as soon as possible of the node document of the script element at the
     //  time the prepare a script algorithm started."
     pending_script_ = CreatePendingScript();
     async_exec_type_ = ScriptRunner::kAsync;
     pending_script_->StartStreamingIfPossible(&element_->GetDocument(),
                                               ScriptStreamer::kAsync);
+
     // TODO(hiroshige): Here |contextDocument| is used as "node document"
-    // while Step 14 uses |elementDocument| as "node document". Fix this.
+    // while Step 14 uses |element_document| as "node document". Fix this.
     context_document->GetScriptRunner()->QueueScriptForExecution(
         this, async_exec_type_);
     // Note that watchForLoad can immediately call pendingScriptFinished.
     pending_script_->WatchForLoad(this);
     // The part "When the script is ready..." is implemented in
     // ScriptRunner::notifyScriptReady().
     // TODO(hiroshige): Annotate it.
 
     return true;
   }
 
   // 6th Clause:
   // - "Otherwise"
   // "Immediately execute the script block,
   //  even if other scripts are already executing."
   // Note: this block is also duplicated in
   // HTMLParserScriptRunner::processScriptElementInternal().
   // TODO(hiroshige): Merge the duplicated code.
 
   // This clause is executed only if the script's type is "classic"
   // and the element doesn't have a src attribute.
+  DCHECK_EQ(GetScriptType(), ScriptType::kClassic);
+  DCHECK(!is_external_script_);
 
   // Reset line numbering for nested writes.
   TextPosition position = element_document.IsInDocumentWrite()
                               ? TextPosition()
                               : script_start_position;
   KURL script_url = (!element_document.IsInDocumentWrite() && parser_inserted_)
                         ? element_document.Url()
                         : KURL();
 
   if (!ExecuteScript(ClassicScript::Create(
           ScriptSourceCode(ScriptContent(), script_url, position)))) {
     DispatchErrorEvent();
     return false;
   }
 
   return true;
 }
 
 // Steps 15--21 of https://html.spec.whatwg.org/#prepare-a-script
 bool ScriptLoader::FetchScript(const String& source_url,
                                const String& encoding,
                                FetchParameters::DeferOption defer) {
   Document* element_document = &(element_->GetDocument());
   if (!element_->IsConnected() || element_->GetDocument() != element_document)
     return false;
 
   DCHECK(!resource_);
+  DCHECK(!module_tree_client_);
+
   // 21. "If the element has a src content attribute, run these substeps:"
   if (!StripLeadingAndTrailingHTMLSpaces(source_url).IsEmpty()) {
     // 21.4. "Parse src relative to the element's node document."
-    ResourceRequest resource_request(element_document->CompleteURL(source_url));
-
-    // [Intervention]
-    if (document_write_intervention_ ==
-        DocumentWriteIntervention::kFetchDocWrittenScriptDeferIdle) {
-      resource_request.SetHTTPHeaderField(
-          "Intervention",
-          "<https://www.chromestatus.com/feature/5718547946799104>");
-    }
-
-    FetchParameters params(resource_request, element_->InitiatorName());
+    KURL url = element_document->CompleteURL(source_url);
 
     // 15. "Let CORS setting be the current state of the element's
     //      crossorigin content attribute."
     CrossOriginAttributeValue cross_origin =
         GetCrossOriginAttributeValue(element_->CrossOriginAttributeValue());
 
-    // 16. "Let module script credentials mode be determined by switching
-    //      on CORS setting:"
-    // TODO(hiroshige): Implement this step for "module".
-
-    // 21.6, "classic": "Fetch a classic script given ... CORS setting
-    //                   ... and encoding."
-    if (cross_origin != kCrossOriginAttributeNotSet) {
-      params.SetCrossOriginAccessControl(element_document->GetSecurityOrigin(),
-                                         cross_origin);
-    }
-
-    params.SetCharset(encoding);
-
     // 17. "If the script element has a nonce attribute,
     //      then let cryptographic nonce be that attribute's value.
     //      Otherwise, let cryptographic nonce be the empty string."
+    String nonce;
     if (element_->IsNonceableElement())
-      params.SetContentSecurityPolicyNonce(element_->nonce());
+      nonce = element_->nonce();
 
     // 19. "Let parser state be "parser-inserted"
     //      if the script element has been flagged as "parser-inserted",
     //      and "not parser-inserted" otherwise."
-    params.SetParserDisposition(IsParserInserted() ? kParserInserted
-                                                   : kNotParserInserted);
-
-    params.SetDefer(defer);
-
-    // 18. "If the script element has an integrity attribute,
-    //      then let integrity metadata be that attribute's value.
-    //      Otherwise, let integrity metadata be the empty string."
-    String integrity_attr = element_->IntegrityAttributeValue();
-    if (!integrity_attr.IsEmpty()) {
-      IntegrityMetadataSet metadata_set;
-      SubresourceIntegrity::ParseIntegrityAttribute(
-          integrity_attr, metadata_set, element_document);
-      params.SetIntegrityMetadata(metadata_set);
-    }
+    ParserDisposition parser_state =
+        IsParserInserted() ? kParserInserted : kNotParserInserted;
 
     // 21.6. "Switch on the script's type:"
+    if (RuntimeEnabledFeatures::moduleScriptsEnabled() &&
+        GetScriptType() == ScriptType::kModule) {
+      // - "module":
 
-    // - "classic":
-    //   "Fetch a classic script given url, settings, cryptographic nonce,
-    //    integrity metadata, parser state, CORS setting, and encoding."
-    resource_ = ScriptResource::Fetch(params, element_document->Fetcher());
+      // 16. "Let module script credentials mode be determined by switching
+      //      on CORS setting:"
+      // FOXME
+      WebURLRequest::FetchCredentialsMode credentials_mode =
+          WebURLRequest::kFetchCredentialsModeOmit;
+      switch (cross_origin) {
+        case kCrossOriginAttributeNotSet:
+          credentials_mode = WebURLRequest::kFetchCredentialsModeOmit;
+          break;
+        case kCrossOriginAttributeAnonymous:
+          credentials_mode = WebURLRequest::kFetchCredentialsModeSameOrigin;
+          break;
+        case kCrossOriginAttributeUseCredentials:
+          credentials_mode = WebURLRequest::kFetchCredentialsModeInclude;
+          break;
+      }
 
-    // - "module":
-    //   "Fetch a module script graph given url, settings, "script",
-    //    cryptographic nonce, parser state, and
-    //    module script credentials mode."
-    // TODO(kouhei, hiroshige): Implement this.
+      // Step 18 is skipped because "integrity metadata" is not used
+      // for module scripts.
+
+      // TODO(hiroshige): (How) should we reflect |defer|?
+
+      //   "Fetch a module script graph given url, settings, "script",
+      //    cryptographic nonce, parser state, and
+      //    module script credentials mode."
+      ModuleScriptFetchRequest module_request(url, nonce, parser_state,
+                                              credentials_mode);
+      module_tree_client_ = ModulePendingScriptTreeClient::Create();
+      Modulator::From(ToScriptStateForMainWorld(element_document->GetFrame()))
+          ->FetchTree(module_request, module_tree_client_);
+    } else {
+      // - "classic":
+
+      // Step 16 is skipped because "module script credentials" is not used
+      // for classic scripts.
+
+      // 18. "If the script element has an integrity attribute,
+      //      then let integrity metadata be that attribute's value.
+      //      Otherwise, let integrity metadata be the empty string."
+      String integrity_attr = element_->IntegrityAttributeValue();
+
+      //   "Fetch a classic script given url, settings, ..."
+      ResourceRequest resource_request(url);
+
+      // [Intervention]
+      if (document_write_intervention_ ==
+          DocumentWriteIntervention::kFetchDocWrittenScriptDeferIdle) {
+        resource_request.SetHTTPHeaderField(
+            "Intervention",
+            "<https://www.chromestatus.com/feature/5718547946799104>");
+      }
+
+      FetchParameters params(resource_request, element_->InitiatorName());
+
+      //   "... cryptographic nonce, ..."
+      params.SetContentSecurityPolicyNonce(nonce);
+
+      //   "... integrity metadata, ..."
+      if (!integrity_attr.IsEmpty()) {
+        IntegrityMetadataSet metadata_set;
+        SubresourceIntegrity::ParseIntegrityAttribute(
+            integrity_attr, metadata_set, element_document);
+        params.SetIntegrityMetadata(metadata_set);
+      }
+
+      //   "... parser state, ..."
+      params.SetParserDisposition(parser_state);
+
+      //   "... CORS setting, ..."
+      if (cross_origin != kCrossOriginAttributeNotSet) {
+        params.SetCrossOriginAccessControl(
+            element_document->GetSecurityOrigin(), cross_origin);
+      }
+
+      //   "... and encoding."
+      params.SetCharset(encoding);
+
+      params.SetDefer(defer);
+
+      resource_ = ScriptResource::Fetch(params, element_document->Fetcher());
+    }
 
     // "When the chosen algorithm asynchronously completes, set
     //  the script's script to the result. At that time, the script is ready."
     // When the script is ready, PendingScriptClient::pendingScriptFinished()
     // is used as the notification, and the action to take when
     // the script is ready is specified later, in
     // - ScriptLoader::prepareScript(), or
     // - HTMLParserScriptRunner,
     // depending on the conditions in Step 23 of "prepare a script".
 
     // 21.3. "Set the element's from an external file flag."
     is_external_script_ = true;
   }
 
-  if (!resource_) {
+  if (GetScriptType() == ScriptType::kClassic && !resource_) {
     // 21.2. "If src is the empty string, queue a task to
     //        fire an event named error at the element, and abort these steps."
     // 21.5. "If the previous step failed, queue a task to
     //        fire an event named error at the element, and abort these steps."
     // TODO(hiroshige): Make this asynchronous.
     DispatchErrorEvent();
     return false;
   }
 
   // [Intervention]
-  if (created_during_document_write_ &&
+  if (GetScriptType() == ScriptType::kClassic &&
+      created_during_document_write_ &&
       resource_->GetResourceRequest().GetCachePolicy() ==
           WebCachePolicy::kReturnCacheDataDontLoad) {
     document_write_intervention_ =
         DocumentWriteIntervention::kDoNotFetchDocWrittenScript;
   }
 
   return true;
 }
 
 PendingScript* ScriptLoader::CreatePendingScript() {
-  CHECK(resource_);
-  return ClassicPendingScript::Create(element_, resource_);
+  switch (GetScriptType()) {
+    case ScriptType::kClassic:
+      CHECK(resource_);
+      return ClassicPendingScript::Create(element_, resource_);
+    case ScriptType::kModule:
+      CHECK(module_tree_client_);
+      return ModulePendingScript::Create(element_, module_tree_client_);
+  }
+  NOTREACHED();
+  return nullptr;
 }
 
 bool ScriptLoader::ExecuteScript(const Script* script) {
   double script_exec_start_time = MonotonicallyIncreasingTime();
   bool result = DoExecuteScript(script);
 
   // NOTE: we do not check m_willBeParserExecuted here, since
   // m_willBeParserExecuted is false for inline scripts, and we want to
   // include inline script execution time as part of parser blocked script
   // execution time.
   if (async_exec_type_ == ScriptRunner::kNone)
     DocumentParserTiming::From(element_->GetDocument())
         .RecordParserBlockedOnScriptExecutionDuration(
             MonotonicallyIncreasingTime() - script_exec_start_time,
             WasCreatedDuringDocumentWrite());
   return result;
 }
 
 // https://html.spec.whatwg.org/#execute-the-script-block
 // with additional support for HTML imports.
 // Note that Steps 2 and 8 must be handled by the caller of doExecuteScript(),
 // i.e. load/error events are dispatched by the caller.
 // Steps 3--7 are implemented here in doExecuteScript().
 // TODO(hiroshige): Move event dispatching code to doExecuteScript().
 bool ScriptLoader::DoExecuteScript(const Script* script) {
   DCHECK(already_started_);
+  CHECK_EQ(script->GetScriptType(), GetScriptType());
 
   if (script->IsEmpty())
     return true;
 
   Document* element_document = &(element_->GetDocument());
   Document* context_document = element_document->ContextDocument();
   if (!context_document)
     return true;
 
   LocalFrame* frame = context_document->GetFrame();
@@ skipping 15 matching lines @@
                                            script->InlineSourceTextForCSP())) {
       return false;
     }
   }
 
   if (is_external_script_) {
     if (!script->CheckMIMETypeBeforeRunScript(
             context_document, element_->GetDocument().GetSecurityOrigin()))
       return false;
   }
+  // FOXME: In module cases, AccessControlStatus is not set or used here.
+  // Instead, it is used when module script is fetched (and compiled).
 
   const bool is_imported_script = context_document != element_document;
 
   // 3. "If the script is from an external file,
   //     or the script's type is module",
   //     then increment the ignore-destructive-writes counter of the
   //     script element's node document. Let neutralized doc be that Document."
   // TODO(hiroshige): Implement "module" case.
   IgnoreDestructiveWriteCountIncrementer
       ignore_destructive_write_count_incrementer(
-          is_external_script_ || is_imported_script ? context_document : 0);
+          is_external_script_ ||
+                  script->GetScriptType() == ScriptType::kModule ||
+                  is_imported_script
+              ? context_document
+              : 0);
 
   // 4. "Let old script element be the value to which the script element's
   //     node document's currentScript object was most recently set."
   // This is implemented as push/popCurrentScript().
 
   // 5. "Switch on the script's type:"
   //    - "classic":
   //    1. "If the script element's root is not a shadow root,
   //        then set the script element's node document's currentScript
   //        attribute to the script element. Otherwise, set it to null."
-  context_document->PushCurrentScript(element_.Get());
+  //    - "module":
+  //    1. "Set the script element's node document's currentScript attribute
+  //        to null."
+  ScriptElementBase* current_script = nullptr;
+  if (script->GetScriptType() == ScriptType::kClassic)
+    current_script = element_;
+  context_document->PushCurrentScript(current_script);
 
+  //    - "classic":
   //    2. "Run the classic script given by the script's script."
   // Note: This is where the script is compiled and actually executed.
+  //    - "module":
+  //    2. "Run the module script given by the script's script."
   script->RunScript(frame, element_->GetDocument().GetSecurityOrigin());
 
-  //    - "module":
-  // TODO(hiroshige): Implement this.
-
   // 6. "Set the script element's node document's currentScript attribute
   //     to old script element."
-  context_document->PopCurrentScript(element_.Get());
+  context_document->PopCurrentScript(current_script);
 
   return true;
 
   // 7. "Decrement the ignore-destructive-writes counter of neutralized doc,
   //     if it was incremented in the earlier step."
   // Implemented as the scope out of IgnoreDestructiveWriteCountIncrementer.
 }
 
 void ScriptLoader::Execute() {
   DCHECK(!will_be_parser_executed_);
   DCHECK(async_exec_type_ != ScriptRunner::kNone);
   DCHECK(pending_script_->IsExternal());
   bool error_occurred = false;
   Script* script = pending_script_->GetSource(KURL(), error_occurred);
-  const bool wasCanceled = pending_script_->WasCanceled();
+  const bool was_canceled = pending_script_->WasCanceled();
   DetachPendingScript();
   if (error_occurred) {
     DispatchErrorEvent();
-  } else if (!wasCanceled) {
+  } else if (!was_canceled) {
     if (ExecuteScript(script))
       DispatchLoadEvent();
     else
       DispatchErrorEvent();
   }
   resource_ = nullptr;
+  module_tree_client_ = nullptr;
 }
 
 void ScriptLoader::PendingScriptFinished(PendingScript* pending_script) {
   DCHECK(!will_be_parser_executed_);
   DCHECK_EQ(pending_script_, pending_script);
+  DCHECK_EQ(pending_script_->GetScriptType(), GetScriptType());
 
   // We do not need this script in the memory cache. The primary goals of
   // sending this fetch request are to let the third party server know
   // about the document.write scripts intervention and populate the http
   // cache for subsequent uses.
   if (document_write_intervention_ ==
       DocumentWriteIntervention::kFetchDocWrittenScriptDeferIdle) {
     DCHECK_EQ(pending_script_->GetScriptType(), ScriptType::kClassic);
     pending_script_->RemoveFromMemoryCache();
     pending_script_->StopWatchingForLoad();
@@ skipping 51 matching lines @@
   //     then abort these steps at this point. The script is not executed.
   return DeprecatedEqualIgnoringCase(event_attribute, "onload") ||
          DeprecatedEqualIgnoringCase(event_attribute, "onload()");
 }
 
 String ScriptLoader::ScriptContent() const {
   return element_->TextFromChildren();
 }
 
 }  // namespace blink