Revert of 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 380 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 643 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) {
-    if (m_lastChunkBeforeScript) {
-      validateSpeculations(std::move(m_lastChunkBeforeScript));
-      DCHECK(!m_lastChunkBeforeScript);
-      pumpPendingSpeculations();
-    }
+    validateSpeculations(std::move(m_lastChunkBeforeScript));
+    ASSERT(!m_lastChunkBeforeScript);
+    pumpPendingSpeculations();
     return;
   }
 
   m_insertionPreloadScanner.reset();
   pumpTokenizerIfPossible();
   endIfDelayed();
 }
 
 void HTMLDocumentParser::appendCurrentInputStreamToPreloadScannerAndScan() {
   ASSERT(m_preloadScanner);
@@ skipping 14 matching lines @@
     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.
-  DCHECK(m_scriptRunner);
+  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;
   m_scriptRunner->executeScriptsWaitingForResources();
   if (!isWaitingForScripts())
     resumeParsingAfterScriptExecution();
 }
 
 void HTMLDocumentParser::parseDocumentFragment(
     const String& source,
     DocumentFragment* fragment,
     Element* contextElement,
     ParserContentPolicy parserContentPolicy) {
@@ skipping 181 matching lines @@
     case Asynchronous:
       m_loadingTaskRunner->postTask(
           BLINK_FROM_HERE,
           WTF::bind(function, std::forward<Ps>(parameters)...));
       return;
   }
   NOTREACHED();
 }
 
 }  // namespace blink