Reland of Split PendingScript into PendingScript and ClassicPendingScript

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"
@@ skipping 284 matching lines @@
   if (parserBlockingScript() != pendingScript)
     return;
 
   ScriptElementBase* element = parserBlockingScript()->element();
 
   ScriptLoader* scriptLoader = element->loader();
   if (!scriptLoader || !scriptLoader->disallowedFetchForDocWrittenScript())
     return;
 
   if (!pendingScript->errorOccurred()) {
-    emitWarningForDocWriteScripts(pendingScript->resource()->url().getString(),
+    emitWarningForDocWriteScripts(pendingScript->url().getString(),
                                   *m_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(pendingScript->resource()->url().getString(),
-                              *m_document);
+  emitErrorForDocWriteScripts(pendingScript->url().getString(), *m_document);
   TextPosition startingPosition = parserBlockingScript()->startingPosition();
   bool isParserInserted = scriptLoader->isParserInserted();
   // Remove this resource entry from memory cache as the new request
   // should not join onto this existing entry.
-  memoryCache()->remove(pendingScript->resource());
+  // memoryCache()->remove(pendingScript->resource());
   fetchBlockedDocWriteScript(element, isParserInserted, startingPosition);
 }
 
 void HTMLParserScriptRunner::pendingScriptFinished(
     PendingScript* pendingScript) {
   // 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() && pendingScript->resource()->wasCanceled()) {
+  if (isExecutingScript() && pendingScript->wasCanceled()) {
     pendingScript->dispose();
 
     if (pendingScript == parserBlockingScript()) {
       m_parserBlockingScript = nullptr;
     } else {
       CHECK_EQ(pendingScript, m_scriptsToExecuteAfterParsing.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 (!m_scriptsToExecuteAfterParsing.isEmpty()) {
     DCHECK(!isExecutingScript());
     DCHECK(!hasParserBlockingScript());
-    DCHECK(m_scriptsToExecuteAfterParsing.front()->resource());
+    DCHECK(m_scriptsToExecuteAfterParsing.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 (!m_scriptsToExecuteAfterParsing.front()->isReady()) {
       m_scriptsToExecuteAfterParsing.front()->watchForLoad(this);
       traceParserBlockingScript(m_scriptsToExecuteAfterParsing.front().get(),
                                 !m_document->isScriptExecutionReady());
@@ skipping 24 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());
   m_parserBlockingScript = requestPendingScript(element);
   if (!parserBlockingScript())
     return;
 
-  DCHECK(parserBlockingScript()->resource());
-
   // 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()) {
     m_parserBlockingScript->startStreamingIfPossible(
         m_document, ScriptStreamer::ParsingBlocking);
     m_parserBlockingScript->watchForLoad(this);
   }
 }
 
 // 1st Clause, Step 23 of https://html.spec.whatwg.org/#prepare-a-script
 void HTMLParserScriptRunner::requestDeferredScript(Element* element) {
   PendingScript* pendingScript = requestPendingScript(element);
   if (!pendingScript)
     return;
 
   if (!pendingScript->isReady()) {
     pendingScript->startStreamingIfPossible(m_document,
                                             ScriptStreamer::Deferred);
   }
 
-  DCHECK(pendingScript->resource());
-
   // "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."
   m_scriptsToExecuteAfterParsing.push_back(pendingScript);
 }
 
 PendingScript* HTMLParserScriptRunner::requestPendingScript(
     Element* element) const {
   ScriptElementBase* scriptElement =
       ScriptElementBase::fromElementIfPossible(element);
   ScriptResource* resource = scriptElement->loader()->resource();
   // Here |resource| should be non-null. If it were nullptr,
   // ScriptLoader::fetchScript() should have returned false and
   // thus the control shouldn't have reached here.
   CHECK(resource);
-  return PendingScript::create(scriptElement, resource);
+  ClassicPendingScript* pendingScript =
+      ClassicPendingScript::create(scriptElement, resource);
+  DCHECK(pendingScript->resource());
+  return pendingScript;
 }
 
 // The initial steps for 'An end tag whose tag name is "script"'
 // https://html.spec.whatwg.org/#scriptEndTag
 void HTMLParserScriptRunner::processScriptElementInternal(
     Element* script,
     const TextPosition& scriptStartPosition) {
   DCHECK(m_document);
   DCHECK(!hasParserBlockingScript());
   {
@@ skipping 37 matching lines @@
     } else if (scriptLoader->readyToBeParserExecuted()) {
       // 5th Clause of Step 23.
       // "If ... it's an HTML parser
       //  whose script nesting level is not greater than one"
       if (m_reentryPermit->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(!m_parserBlockingScript);
         m_parserBlockingScript =
-            PendingScript::create(element, scriptStartPosition);
+            ClassicPendingScript::create(element, scriptStartPosition);
       } 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(m_reentryPermit->scriptNestingLevel(), 1u);
         if (m_parserBlockingScript)
           m_parserBlockingScript->dispose();
         m_parserBlockingScript = nullptr;
         ScriptSourceCode sourceCode(script->textContent(),
@@ skipping 19 matching lines @@
 
 DEFINE_TRACE(HTMLParserScriptRunner) {
   visitor->trace(m_document);
   visitor->trace(m_host);
   visitor->trace(m_parserBlockingScript);
   visitor->trace(m_scriptsToExecuteAfterParsing);
   PendingScriptClient::trace(visitor);
 }
 
 }  // namespace blink