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

third_party/WebKit/Source/core/html/parser/HTMLScriptRunner.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 136 matching lines @@
 }  // namespace
 
 using namespace HTMLNames;
 
 HTMLScriptRunner::HTMLScriptRunner(HTMLParserReentryPermit* reentryPermit,
                                    Document* document,
                                    HTMLScriptRunnerHost* host)
     : m_reentryPermit(reentryPermit),
       m_document(document),
       m_host(host),
-      m_parserBlockingScript(PendingScript::create(nullptr, nullptr)),
-      m_hasScriptsWaitingForResources(false) {
+      m_parserBlockingScript(PendingScript::create(nullptr, nullptr)) {
   ASSERT(m_host);
   ThreadState::current()->registerPreFinalizer(this);
 }
 
 HTMLScriptRunner::~HTMLScriptRunner() {
   // Verify that detach() has been called.
   ASSERT(!m_document);
 }
 
 void HTMLScriptRunner::detach() {
   if (!m_document)
     return;
 
   m_parserBlockingScript->dispose();
 
   while (!m_scriptsToExecuteAfterParsing.isEmpty()) {
     PendingScript* pendingScript = m_scriptsToExecuteAfterParsing.takeFirst();
     pendingScript->dispose();
   }
   m_document = nullptr;
   // m_reentryPermit is not cleared here, because the script runner
   // may continue to run pending scripts after the parser has
   // detached.
 }
 
-bool HTMLScriptRunner::isPendingScriptReady(const PendingScript* script) {
-  m_hasScriptsWaitingForResources = !m_document->isScriptExecutionReady();
-  if (m_hasScriptsWaitingForResources)
+bool HTMLScriptRunner::isPendingScriptReady() {
+  if (!m_document->isScriptExecutionReady())
     return false;
-  return script->isReady();
+  return m_parserBlockingScript->isReady();
 }
 
 void HTMLScriptRunner::executeParsingBlockingScript() {
-  ASSERT(m_document);
-  ASSERT(!isExecutingScript());
-  ASSERT(m_document->isScriptExecutionReady());
-  ASSERT(isPendingScriptReady(m_parserBlockingScript.get()));
+  DCHECK(m_document);
+  DCHECK(!isExecutingScript());
+  DCHECK(m_document->isScriptExecutionReady());
+  DCHECK(isPendingScriptReady());
 
   InsertionPointRecord insertionPointRecord(m_host->inputStream());
   executePendingScriptAndDispatchEvent(m_parserBlockingScript.get(),
                                        ScriptStreamer::ParsingBlocking);
 }
 
 void HTMLScriptRunner::executePendingScriptAndDispatchEvent(
     PendingScript* pendingScript,
     ScriptStreamer::Type pendingScriptType) {
   bool errorOccurred = false;
   ScriptSourceCode sourceCode = pendingScript->getSource(
       documentURLForScriptExecution(m_document), errorOccurred);
 
   // Stop watching loads before executeScript to prevent recursion if the script
   // reloads itself.
   // TODO(kouhei): Consider merging this w/ pendingScript->dispose() after the
   // if block.
   pendingScript->stopWatchingForLoad();
 
   if (!isExecutingScript()) {
     Microtask::performCheckpoint(V8PerIsolateData::mainThreadIsolate());
     if (pendingScriptType == ScriptStreamer::ParsingBlocking) {
-      m_hasScriptsWaitingForResources = !m_document->isScriptExecutionReady();
       // The parser cannot be unblocked as a microtask requested another
       // resource
-      if (m_hasScriptsWaitingForResources)
+      if (!m_document->isScriptExecutionReady())
         return;
     }
   }
 
   TextPosition scriptStartPosition = pendingScript->startingPosition();
   double scriptParserBlockingTime =
       pendingScript->parserBlockingLoadStartTime();
   // Clear the pending script before possible re-entrancy from executeScript()
   Element* element = pendingScript->element();
   pendingScript->dispose();
@@ skipping 134 matching lines @@
       m_host->appendCurrentInputStreamToPreloadScannerAndScan();
     executeParsingBlockingScripts();
   }
 }
 
 bool HTMLScriptRunner::hasParserBlockingScript() const {
   return !!m_parserBlockingScript->element();
 }
 
 void HTMLScriptRunner::executeParsingBlockingScripts() {
-  while (hasParserBlockingScript() &&
-         isPendingScriptReady(m_parserBlockingScript.get()))
+  while (hasParserBlockingScript() && isPendingScriptReady())
     executeParsingBlockingScript();
 }
 
 void HTMLScriptRunner::executeScriptsWaitingForLoad(Resource* resource) {
   TRACE_EVENT0("blink", "HTMLScriptRunner::executeScriptsWaitingForLoad");
   ASSERT(!isExecutingScript());
   ASSERT(hasParserBlockingScript());
   DCHECK_EQ(resource, m_parserBlockingScript->resource());
   ASSERT(m_parserBlockingScript->isReady());
   executeParsingBlockingScripts();
 }
 
 void HTMLScriptRunner::executeScriptsWaitingForResources() {
   TRACE_EVENT0("blink", "HTMLScriptRunner::executeScriptsWaitingForResources");
   ASSERT(m_document);
-  // Callers should check hasScriptsWaitingForResources() before calling
-  // to prevent parser or script re-entry during </style> parsing.
-  ASSERT(hasScriptsWaitingForResources());
   ASSERT(!isExecutingScript());
   ASSERT(m_document->isScriptExecutionReady());
   executeParsingBlockingScripts();
 }
 
 bool HTMLScriptRunner::executeScriptsWaitingForParsing() {
   TRACE_EVENT0("blink", "HTMLScriptRunner::executeScriptsWaitingForParsing");
   while (!m_scriptsToExecuteAfterParsing.isEmpty()) {
     ASSERT(!isExecutingScript());
     ASSERT(!hasParserBlockingScript());
@@ skipping 123 matching lines @@
 
 DEFINE_TRACE(HTMLScriptRunner) {
   visitor->trace(m_document);
   visitor->trace(m_host);
   visitor->trace(m_parserBlockingScript);
   visitor->trace(m_scriptsToExecuteAfterParsing);
   ScriptResourceClient::trace(visitor);
 }
 
 }  // namespace blink