Create PendingScriptClient as a separate client interface for PendingScript.

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 231 matching lines @@
         scriptLoader->dispatchErrorEvent();
       } else {
         element->dispatchEvent(Event::create(EventTypeNames::load));
       }
     }
   }
 
   DCHECK(!isExecutingScript());
 }
 
-void HTMLParserScriptRunner::stopWatchingResourceForLoad(Resource* resource) {
-  if (m_parserBlockingScript->resource() == resource) {
-    m_parserBlockingScript->dispose();
-    return;
-  }
-  for (auto& script : m_scriptsToExecuteAfterParsing) {
-    if (script->resource() == resource) {
-      script->dispose();
-      return;
-    }
-  }
-}
-
 void fetchBlockedDocWriteScript(Element* script,
                                 bool isParserInserted,
                                 const TextPosition& scriptStartPosition) {
   DCHECK(script);
 
   ScriptLoader* scriptLoader =
       ScriptLoader::create(script, isParserInserted, false, false);
   DCHECK(scriptLoader);
   scriptLoader->setFetchDocWrittenScriptDeferIdle();
   scriptLoader->prepareScript(scriptStartPosition);
 }
 
 void HTMLParserScriptRunner::possiblyFetchBlockedDocWriteScript(
-    Resource* resource) {
+    PendingScript* pendingScript) {
   // If the script was blocked as part of document.write intervention,
   // then send an asynchronous GET request with an interventions header.
   Element* element = nullptr;
   TextPosition startingPosition;
   bool isParserInserted = false;
 
-  if (!resource->errorOccurred() || !m_parserBlockingScript ||
-      !(m_parserBlockingScript->resource() == resource))
+  if (!pendingScript->errorOccurred() ||
+      m_parserBlockingScript != pendingScript)
     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.
   element = m_parserBlockingScript->element();
 
   ScriptLoader* scriptLoader = nullptr;
   if (element && (scriptLoader = toScriptLoaderIfPossible(element)) &&
       scriptLoader->disallowedFetchForDocWrittenScript()) {
     startingPosition = m_parserBlockingScript->startingPosition();
     isParserInserted = scriptLoader->isParserInserted();
     // remove this resource entry from memory cache as the new request
     // should not join onto this existing entry.
-    memoryCache()->remove(resource);
+    memoryCache()->remove(pendingScript->resource());
     fetchBlockedDocWriteScript(element, isParserInserted, startingPosition);
   }
 }
 
-void HTMLParserScriptRunner::notifyFinished(Resource* cachedResource) {
+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() && cachedResource->wasCanceled()) {
-    stopWatchingResourceForLoad(cachedResource);
+  if (isExecutingScript() && pendingScript->resource()->wasCanceled()) {
+    pendingScript->dispose();
     return;
   }
 
   // If the script was blocked as part of document.write intervention,
   // then send an asynchronous GET request with an interventions header.
-  possiblyFetchBlockedDocWriteScript(cachedResource);
+  possiblyFetchBlockedDocWriteScript(pendingScript);
 
-  m_host->notifyScriptLoaded(cachedResource);
+  m_host->notifyScriptLoaded(pendingScript);
 }
 
 // Implements the steps for 'An end tag whose tag name is "script"'
 // http://whatwg.org/html#scriptEndTag
 // Script handling lives outside the tree builder to keep each class simple.
 void HTMLParserScriptRunner::processScriptElement(
     Element* scriptElement,
     const TextPosition& scriptStartPosition) {
   DCHECK(scriptElement);
   TRACE_EVENT1(
@@ skipping 34 matching lines @@
     DCHECK(m_document);
     DCHECK(!isExecutingScript());
     DCHECK(m_document->isScriptExecutionReady());
 
     InsertionPointRecord insertionPointRecord(m_host->inputStream());
     executePendingScriptAndDispatchEvent(m_parserBlockingScript.get(),
                                          ScriptStreamer::ParsingBlocking);
   }
 }
 
-void HTMLParserScriptRunner::executeScriptsWaitingForLoad(Resource* resource) {
+void HTMLParserScriptRunner::executeScriptsWaitingForLoad(
+    PendingScript* pendingScript) {
   TRACE_EVENT0("blink", "HTMLParserScriptRunner::executeScriptsWaitingForLoad");
   DCHECK(!isExecutingScript());
   DCHECK(hasParserBlockingScript());
-  DCHECK_EQ(resource, m_parserBlockingScript->resource());
+  DCHECK_EQ(pendingScript, m_parserBlockingScript);
   DCHECK(m_parserBlockingScript->isReady());
   executeParsingBlockingScripts();
 }
 
 void HTMLParserScriptRunner::executeScriptsWaitingForResources() {
   TRACE_EVENT0("blink",
                "HTMLParserScriptRunner::executeScriptsWaitingForResources");
   DCHECK(m_document);
   DCHECK(!isExecutingScript());
   DCHECK(m_document->isScriptExecutionReady());
@@ skipping 131 matching lines @@
       requestParsingBlockingScript(script);
     }
   }
 }
 
 DEFINE_TRACE(HTMLParserScriptRunner) {
   visitor->trace(m_document);
   visitor->trace(m_host);
   visitor->trace(m_parserBlockingScript);
   visitor->trace(m_scriptsToExecuteAfterParsing);
-  ScriptResourceClient::trace(visitor);
+  PendingScriptClient::trace(visitor);
 }
 
 }  // namespace blink