Introduce blink::Script

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 13 matching lines @@
  */
 
 #include "core/html/parser/HTMLParserScriptRunner.h"
 
 #include <inttypes.h>
 #include <memory>
 #include "bindings/core/v8/Microtask.h"
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8PerIsolateData.h"
+#include "core/dom/ClassicScript.h"
 #include "core/dom/DocumentParserTiming.h"
 #include "core/dom/Element.h"
 #include "core/dom/IgnoreDestructiveWriteCountIncrementer.h"
 #include "core/dom/ScriptLoader.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/events/Event.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/parser/HTMLInputStream.h"
 #include "core/html/parser/HTMLParserScriptRunnerHost.h"
 #include "core/html/parser/NestingLevelIncrementer.h"
@@ skipping 28 matching lines @@
   }
   if (textPosition.m_line.zeroBasedInt() > 0 ||
       textPosition.m_column.zeroBasedInt() > 0) {
     value->setInteger("lineNumber", textPosition.m_line.oneBasedInt());
     value->setInteger("columnNumber", textPosition.m_column.oneBasedInt());
   }
   return value;
 }
 
 bool doExecuteScript(ScriptElementBase* element,
-                     const ScriptSourceCode& sourceCode,
+                     const Script* script,
                      const TextPosition& textPosition) {
   ScriptLoader* scriptLoader = element->loader();
   DCHECK(scriptLoader);
   TRACE_EVENT_WITH_FLOW1("blink", "HTMLParserScriptRunner ExecuteScript",
                          element, TRACE_EVENT_FLAG_FLOW_IN, "data",
                          getTraceArgsForScriptElement(element, textPosition));
-  return scriptLoader->executeScript(sourceCode);
+  return scriptLoader->executeScript(script);
 }
 
 void traceParserBlockingScript(const PendingScript* pendingScript,
                                bool waitingForResources) {
   // The HTML parser must yield before executing script in the following
   // cases:
   // * the script's execution is blocked on the completed load of the script
   //   resource
   //   (https://html.spec.whatwg.org/multipage/scripting.html#pending-parsing-blocking-script)
   // * the script's execution is blocked on the load of a style sheet or other
@@ skipping 96 matching lines @@
 //   steps of the "Otherwise" Clause of 'An end tag whose tag name is "script"'
 //   https://html.spec.whatwg.org/#scriptEndTag
 // - When called from executeScriptsWaitingForParsing(), this corresponds
 //   https://html.spec.whatwg.org/#execute-the-script-block
 //   and thus currently this function does more than specced.
 // TODO(hiroshige): Make the spec and implementation consistent.
 void HTMLParserScriptRunner::executePendingScriptAndDispatchEvent(
     PendingScript* pendingScript,
     ScriptStreamer::Type pendingScriptType) {
   bool errorOccurred = false;
-  ScriptSourceCode sourceCode = pendingScript->getSource(
+  Script* script = 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());
@@ skipping 38 matching lines @@
           getTraceArgsForScriptElement(element, scriptStartPosition));
       scriptLoader->dispatchErrorEvent();
     } else {
       DCHECK(isExecutingScript());
       if (scriptParserBlockingTime > 0.0) {
         DocumentParserTiming::from(*m_document)
             .recordParserBlockedOnScriptLoadDuration(
                 monotonicallyIncreasingTime() - scriptParserBlockingTime,
                 scriptLoader->wasCreatedDuringDocumentWrite());
       }
-      if (!doExecuteScript(element, sourceCode, scriptStartPosition)) {
+      if (!doExecuteScript(element, script, scriptStartPosition)) {
         scriptLoader->dispatchErrorEvent();
       } else {
         element->dispatchLoadEvent();
       }
     }
 
     // 9. "Decrement the parser's script nesting level by one.
     //     If the parser's script nesting level is zero
     //     (which it always should be at this point),
     //     then set the parser pause flag to false."
@@ skipping 389 matching lines @@
         // "Immediately execute the script block,
         //  even if other scripts are already executing."
         // TODO(hiroshige): Merge the block into ScriptLoader::prepareScript().
         DCHECK_GT(m_reentryPermit->scriptNestingLevel(), 1u);
         if (m_parserBlockingScript)
           m_parserBlockingScript->dispose();
         m_parserBlockingScript = nullptr;
         ScriptSourceCode sourceCode(script->textContent(),
                                     documentURLForScriptExecution(m_document),
                                     scriptStartPosition);
-        doExecuteScript(element, sourceCode, scriptStartPosition);
+        doExecuteScript(element, ClassicScript::create(sourceCode),
+                        scriptStartPosition);
       }
     } else {
       // 2nd Clause of Step 23.
       requestParsingBlockingScript(script);
     }
 
     // "Decrement the parser's script nesting level by one.
     //  If the parser's script nesting level is zero, then set the parser
     //  pause flag to false."
     // Implemented by ~ScriptNestingLevelIncrementer().
 
     // "Let the insertion point have the value of the old insertion point."
     // Implemented by ~InsertionPointRecord().
   }
 }
 
 DEFINE_TRACE(HTMLParserScriptRunner) {
   visitor->trace(m_document);
   visitor->trace(m_host);
   visitor->trace(m_parserBlockingScript);
   visitor->trace(m_scriptsToExecuteAfterParsing);
   PendingScriptClient::trace(visitor);
 }
 
 }  // namespace blink