Reland Script blocking resources tracking should be only done by Document::isScriptExecutionReady"

third_party/WebKit/Source/core/html/parser/HTMLDocumentParser.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 379 matching lines @@
 }
 
 void HTMLDocumentParser::didReceiveEncodingDataFromBackgroundParser(
     const DocumentEncodingData& data) {
   document()->setEncodingData(data);
 }
 
 void HTMLDocumentParser::validateSpeculations(
     std::unique_ptr<TokenizedChunk> chunk) {
   ASSERT(chunk);
+  // TODO(kouhei): We should simplify codepath here by disallowing
+  // validateSpeculations
+  // while isWaitingForScripts, and m_lastChunkBeforeScript can simply be
+  // pushed to m_speculations.
   if (isWaitingForScripts()) {
     // We're waiting on a network script, just save the chunk, we'll get a
     // second validateSpeculations call after the script completes. This call
     // should have been made immediately after runScriptsForPausedTreeBuilder
     // which may have started a network load and left us waiting.
     ASSERT(!m_lastChunkBeforeScript);
     m_lastChunkBeforeScript = std::move(chunk);
     return;
   }
 
@@ skipping 639 matching lines @@
   // If either object has a blocking script, the parser should be paused.
   return treeBuilderHasBlockingScript || scriptRunnerHasBlockingScript ||
          m_reentryPermit->parserPauseFlag();
 }
 
 void HTMLDocumentParser::resumeParsingAfterScriptExecution() {
   ASSERT(!isExecutingScript());
   ASSERT(!isWaitingForScripts());
 
   if (m_haveBackgroundParser) {
-    validateSpeculations(std::move(m_lastChunkBeforeScript));
-    ASSERT(!m_lastChunkBeforeScript);
-    pumpPendingSpeculations();
+    if (m_lastChunkBeforeScript) {
+      validateSpeculations(std::move(m_lastChunkBeforeScript));
+      DCHECK(!m_lastChunkBeforeScript);
+      pumpPendingSpeculations();
+    }
     return;
   }
 
   m_insertionPreloadScanner.reset();
-  pumpTokenizerIfPossible();
+  if (m_tokenizer) {
+    pumpTokenizerIfPossible();
+  }
   endIfDelayed();
 }
 
 void HTMLDocumentParser::appendCurrentInputStreamToPreloadScannerAndScan() {
   ASSERT(m_preloadScanner);
   m_preloadScanner->appendToEnd(m_input.current());
   scanAndPreload(m_preloadScanner.get());
 }
 
 void HTMLDocumentParser::notifyScriptLoaded(Resource* cachedResource) {
   ASSERT(m_scriptRunner);
   ASSERT(!isExecutingScript());
 
   if (isStopped()) {
     return;
   }
 
   if (isStopping()) {
     attemptToRunDeferredScriptsAndEnd();
     return;
   }
 
   m_scriptRunner->executeScriptsWaitingForLoad(cachedResource);
   if (!isWaitingForScripts())
     resumeParsingAfterScriptExecution();
 }
 
 void HTMLDocumentParser::executeScriptsWaitingForResources() {
+  DCHECK(document()->isScriptExecutionReady());
+
   // Document only calls this when the Document owns the DocumentParser so this
   // will not be called in the DocumentFragment case.
-  ASSERT(m_scriptRunner);
-  // Ignore calls unless we have a script blocking the parser waiting on a
-  // stylesheet load.  Otherwise we are currently parsing and this is a
-  // re-entrant call from encountering a </ style> tag.
-  if (!m_scriptRunner->hasScriptsWaitingForResources())
-    return;
+  DCHECK(m_scriptRunner);
   m_scriptRunner->executeScriptsWaitingForResources();
   if (!isWaitingForScripts())
     resumeParsingAfterScriptExecution();
 }
 
 void HTMLDocumentParser::parseDocumentFragment(
     const String& source,
     DocumentFragment* fragment,
     Element* contextElement,
     ParserContentPolicy parserContentPolicy) {
@@ skipping 188 matching lines @@
     case Asynchronous:
       m_loadingTaskRunner->postTask(
           BLINK_FROM_HERE,
           WTF::bind(function, std::forward<Ps>(parameters)...));
       return;
   }
   NOTREACHED();
 }
 
 }  // namespace blink