Simplify: remove PendingScript::releaseElementAndClear

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 151 matching lines @@
 
 HTMLScriptRunner::~HTMLScriptRunner() {
   // Verify that detach() has been called.
   ASSERT(!m_document);
 }
 
 void HTMLScriptRunner::detach() {
   if (!m_document)
     return;
 
-  m_parserBlockingScript->stopWatchingForLoad();
-  m_parserBlockingScript->releaseElementAndClear();
+  m_parserBlockingScript->dispose();
 
   while (!m_scriptsToExecuteAfterParsing.isEmpty()) {
     PendingScript* pendingScript = m_scriptsToExecuteAfterParsing.takeFirst();
-    pendingScript->stopWatchingForLoad();
-    pendingScript->releaseElementAndClear();
+    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)
@@ skipping 14 matching lines @@
 
 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)
         return;
     }
   }
 
   TextPosition scriptStartPosition = pendingScript->startingPosition();
   double scriptParserBlockingTime =
       pendingScript->parserBlockingLoadStartTime();
   // Clear the pending script before possible re-entrancy from executeScript()
-  Element* element = pendingScript->releaseElementAndClear();
+  Element* element = pendingScript->element();
+  pendingScript->dispose();
+
   if (ScriptLoader* scriptLoader = toScriptLoaderIfPossible(element)) {
     HTMLParserReentryPermit::ScriptNestingLevelIncrementer
         nestingLevelIncrementer =
             m_reentryPermit->incrementScriptNestingLevel();
     IgnoreDestructiveWriteCountIncrementer
         ignoreDestructiveWriteCountIncrementer(m_document);
     if (errorOccurred) {
       TRACE_EVENT_WITH_FLOW1(
           "blink", "HTMLScriptRunner ExecuteScriptFailed", element,
           TRACE_EVENT_FLAG_FLOW_IN, "data",
@@ skipping 13 matching lines @@
         element->dispatchEvent(Event::create(EventTypeNames::load));
       }
     }
   }
 
   ASSERT(!isExecutingScript());
 }
 
 void HTMLScriptRunner::stopWatchingResourceForLoad(Resource* resource) {
   if (m_parserBlockingScript->resource() == resource) {
-    m_parserBlockingScript->stopWatchingForLoad();
-    m_parserBlockingScript->releaseElementAndClear();
+    m_parserBlockingScript->dispose();
     return;
   }
   for (auto& script : m_scriptsToExecuteAfterParsing) {
     if (script->resource() == resource) {
-      script->stopWatchingForLoad();
-      script->releaseElementAndClear();
+      script->dispose();
       return;
     }
   }
 }
 
 void fetchBlockedDocWriteScript(Element* script,
                                 bool isParserInserted,
                                 const TextPosition& scriptStartPosition) {
   DCHECK(script);
 
@@ skipping 226 matching lines @@
       return;
 
     if (scriptLoader->willExecuteWhenDocumentFinishedParsing()) {
       requestDeferredScript(script);
     } else if (scriptLoader->readyToBeParserExecuted()) {
       if (m_reentryPermit->scriptNestingLevel() == 1u) {
         m_parserBlockingScript->setElement(script);
         m_parserBlockingScript->setStartingPosition(scriptStartPosition);
       } else {
         DCHECK_GT(m_reentryPermit->scriptNestingLevel(), 1u);
-        m_parserBlockingScript->releaseElementAndClear();
+        m_parserBlockingScript->dispose();

[yhirano, 2016/11/29 01:29:00]

Can you tell me why we can call stopWatchingLoad here?

[kouhei (in TOK), 2016/11/29 01:52:57]

This is when we execute inline scripts.
We shouldn't have a network-fetched Resource attached to the script, thus
stopWatchingLoad equiv should be just a no-op.

         ScriptSourceCode sourceCode(script->textContent(),
                                     documentURLForScriptExecution(m_document),
                                     scriptStartPosition);
         doExecuteScript(script, sourceCode, scriptStartPosition);
       }
     } else {
       requestParsingBlockingScript(script);
     }
   }
 }
 
 DEFINE_TRACE(HTMLScriptRunner) {
   visitor->trace(m_document);
   visitor->trace(m_host);
   visitor->trace(m_parserBlockingScript);
   visitor->trace(m_scriptsToExecuteAfterParsing);
   ScriptResourceClient::trace(visitor);
 }
 
 }  // namespace blink