[WIP Prototype] ES6 https://html.spec.whatwg.org/#fetch-a-single-module-script implementation

third_party/WebKit/Source/core/html/parser/HTMLParserScriptRunner.cpp

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 13 matching lines @@
  */
 
 #include "core/html/parser/HTMLParserScriptRunner.h"
 
 #include <inttypes.h>
 #include <memory>
 #include "bindings/core/v8/Microtask.h"
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8PerIsolateData.h"
+#include "core/dom/ClassicPendingScript.h"
 #include "core/dom/ClassicScript.h"
 #include "core/dom/DocumentParserTiming.h"
 #include "core/dom/Element.h"
 #include "core/dom/IgnoreDestructiveWriteCountIncrementer.h"
 #include "core/dom/ScriptLoader.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/events/Event.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/parser/HTMLInputStream.h"
 #include "core/html/parser/HTMLParserScriptRunnerHost.h"
 #include "core/html/parser/NestingLevelIncrementer.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/loader/resource/ScriptResource.h"
 #include "platform/Histogram.h"
 #include "platform/WebFrameScheduler.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/instrumentation/tracing/TracedValue.h"
-#include "platform/loader/fetch/MemoryCache.h"
 #include "public/platform/Platform.h"
 
 namespace blink {
 
 namespace {
 
 // TODO(bmcquade): move this to a shared location if we find ourselves wanting
 // to trace similar data elsewhere in the codebase.
 std::unique_ptr<TracedValue> GetTraceArgsForScriptElement(
     ScriptElementBase* element,
@@ skipping 222 matching lines @@
 void FetchBlockedDocWriteScript(ScriptElementBase* element,
                                 bool is_parser_inserted,
                                 const TextPosition& script_start_position) {
   DCHECK(element);
 
   ScriptLoader* script_loader =
       ScriptLoader::Create(element, is_parser_inserted, false, false);
   DCHECK(script_loader);
   script_loader->SetFetchDocWrittenScriptDeferIdle();
   script_loader->PrepareScript(script_start_position);
+  CHECK_EQ(script_loader->GetScriptType(), ScriptType::kClassic);
 }
 
 void EmitWarningForDocWriteScripts(const String& url, Document& document) {
   String message =
       "The Parser-blocking, cross site (i.e. different eTLD+1) "
       "script, " +
       url +
       ", invoked via document.write was NOT BLOCKED on this page load, but MAY "
       "be blocked by the browser in future page loads with poor network "
       "connectivity.";
@@ skipping 24 matching lines @@
 
   if (ParserBlockingScript() != pending_script)
     return;
 
   ScriptElementBase* element = ParserBlockingScript()->GetElement();
 
   ScriptLoader* script_loader = element->Loader();
   if (!script_loader || !script_loader->DisallowedFetchForDocWrittenScript())
     return;
 
+  // We don't allow document.write() and its intervention with module scripts.
+  CHECK_EQ(pending_script->GetScriptType(), ScriptType::kClassic);
+
   if (!pending_script->ErrorOccurred()) {
     EmitWarningForDocWriteScripts(
-        pending_script->GetResource()->Url().GetString(), *document_);
+        pending_script->UrlForClassicScript().GetString(), *document_);
     return;
   }
 
   // Due to dependency violation, not able to check the exact error to be
   // ERR_CACHE_MISS but other errors are rare with
   // WebCachePolicy::ReturnCacheDataDontLoad.
 
-  EmitErrorForDocWriteScripts(pending_script->GetResource()->Url().GetString(),
+  EmitErrorForDocWriteScripts(pending_script->UrlForClassicScript().GetString(),
                               *document_);
   TextPosition starting_position = ParserBlockingScript()->StartingPosition();
   bool is_parser_inserted = script_loader->IsParserInserted();
   // Remove this resource entry from memory cache as the new request
   // should not join onto this existing entry.
-  GetMemoryCache()->Remove(pending_script->GetResource());
+  pending_script->RemoveFromMemoryCache();
   FetchBlockedDocWriteScript(element, is_parser_inserted, starting_position);
 }
 
 void HTMLParserScriptRunner::PendingScriptFinished(
     PendingScript* pending_script) {
   // Handle cancellations of parser-blocking script loads without
   // notifying the host (i.e., parser) if these were initiated by nested
   // document.write()s. The cancellation may have been triggered by
   // script execution to signal an abrupt stop (e.g., window.close().)
   //
   // The parser is unprepared to be told, and doesn't need to be.
-  if (IsExecutingScript() && pending_script->GetResource()->WasCanceled()) {
+  if (IsExecutingScript() && pending_script->WasCanceled()) {
     pending_script->Dispose();
 
     if (pending_script == ParserBlockingScript()) {
       parser_blocking_script_ = nullptr;
     } else {
       CHECK_EQ(pending_script, scripts_to_execute_after_parsing_.front());
 
       // TODO(hiroshige): Remove this CHECK() before going to beta.
       // This is only to make clusterfuzz to find a test case that executes
       // this code path.
@@ skipping 121 matching lines @@
 // Step 3 of https://html.spec.whatwg.org/#the-end:
 // "If the list of scripts that will execute when the document has
 //  finished parsing is not empty, run these substeps:"
 bool HTMLParserScriptRunner::ExecuteScriptsWaitingForParsing() {
   TRACE_EVENT0("blink",
                "HTMLParserScriptRunner::executeScriptsWaitingForParsing");
 
   while (!scripts_to_execute_after_parsing_.IsEmpty()) {
     DCHECK(!IsExecutingScript());
     DCHECK(!HasParserBlockingScript());
-    DCHECK(scripts_to_execute_after_parsing_.front()->GetResource());
+    DCHECK(scripts_to_execute_after_parsing_.front()->IsExternal());
 
     // 1. "Spin the event loop until the first script in the list of scripts
     //     that will execute when the document has finished parsing
     //     has its "ready to be parser-executed" flag set and
     //     the parser's Document has no style sheet that is blocking scripts."
     // TODO(hiroshige): Is the latter part checked anywhere?
     if (!scripts_to_execute_after_parsing_.front()->IsReady()) {
       scripts_to_execute_after_parsing_.front()->WatchForLoad(this);
       TraceParserBlockingScript(scripts_to_execute_after_parsing_.front().Get(),
                                 !document_->IsScriptExecutionReady());
@@ skipping 25 matching lines @@
 // 2nd Clause, Step 23 of https://html.spec.whatwg.org/#prepare-a-script
 void HTMLParserScriptRunner::RequestParsingBlockingScript(Element* element) {
   // "The element is the pending parsing-blocking script of the Document of
   //  the parser that created the element.
   //  (There can only be one such script per Document at a time.)"
   CHECK(!ParserBlockingScript());
   parser_blocking_script_ = RequestPendingScript(element);
   if (!ParserBlockingScript())
     return;
 
-  DCHECK(ParserBlockingScript()->GetResource());
+  DCHECK(ParserBlockingScript()->IsExternal());
 
   // We only care about a load callback if resource is not already in the cache.
   // Callers will attempt to run the m_parserBlockingScript if possible before
   // returning control to the parser.
   if (!ParserBlockingScript()->IsReady()) {
     parser_blocking_script_->StartStreamingIfPossible(
         document_, ScriptStreamer::kParsingBlocking);
     parser_blocking_script_->WatchForLoad(this);
   }
 }
 
 // 1st Clause, Step 23 of https://html.spec.whatwg.org/#prepare-a-script
 void HTMLParserScriptRunner::RequestDeferredScript(Element* element) {
   PendingScript* pending_script = RequestPendingScript(element);
   if (!pending_script)
     return;
 
   if (!pending_script->IsReady()) {
     pending_script->StartStreamingIfPossible(document_,
                                              ScriptStreamer::kDeferred);
   }
 
-  DCHECK(pending_script->GetResource());
+  DCHECK(pending_script->IsExternal());
 
   // "Add the element to the end of the list of scripts that will execute
   //  when the document has finished parsing associated with the Document
   //  of the parser that created the element."
   scripts_to_execute_after_parsing_.push_back(pending_script);
 }
 
 PendingScript* HTMLParserScriptRunner::RequestPendingScript(
     Element* element) const {
   ScriptElementBase* script_element =
@@ skipping 49 matching lines @@
     } else if (script_loader->ReadyToBeParserExecuted()) {
       // 5th Clause of Step 23.
       // "If ... it's an HTML parser
       //  whose script nesting level is not greater than one"
       if (reentry_permit_->ScriptNestingLevel() == 1u) {
         // "The element is the pending parsing-blocking script of the
         //  Document of the parser that created the element.
         //  (There can only be one such script per Document at a time.)"
         CHECK(!parser_blocking_script_);
         parser_blocking_script_ =
-            PendingScript::Create(element, script_start_position);
+            ClassicPendingScript::Create(element, script_start_position);
       } else {
         // 6th Clause of Step 23.
         // "Immediately execute the script block,
         //  even if other scripts are already executing."
         // TODO(hiroshige): Merge the block into ScriptLoader::prepareScript().
         DCHECK_GT(reentry_permit_->ScriptNestingLevel(), 1u);
         if (parser_blocking_script_)
           parser_blocking_script_->Dispose();
         parser_blocking_script_ = nullptr;
         ScriptSourceCode source_code(script->textContent(),
@@ skipping 19 matching lines @@
 
 DEFINE_TRACE(HTMLParserScriptRunner) {
   visitor->Trace(document_);
   visitor->Trace(host_);
   visitor->Trace(parser_blocking_script_);
   visitor->Trace(scripts_to_execute_after_parsing_);
   PendingScriptClient::Trace(visitor);
 }
 
 }  // namespace blink