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 (text_position.line_.ZeroBasedInt() > 0 ||
       text_position.column_.ZeroBasedInt() > 0) {
     value->SetInteger("lineNumber", text_position.line_.OneBasedInt());
     value->SetInteger("columnNumber", text_position.column_.OneBasedInt());
   }
   return value;
 }
 
 bool DoExecuteScript(ScriptElementBase* element,
-                     const ScriptSourceCode& source_code,
+                     const Script* script,
                      const TextPosition& text_position) {
   ScriptLoader* script_loader = element->Loader();
   DCHECK(script_loader);
   TRACE_EVENT_WITH_FLOW1("blink", "HTMLParserScriptRunner ExecuteScript",
                          element, TRACE_EVENT_FLAG_FLOW_IN, "data",
                          GetTraceArgsForScriptElement(element, text_position));
-  return script_loader->ExecuteScript(source_code);
+  return script_loader->ExecuteScript(script);
 }
 
 void TraceParserBlockingScript(const PendingScript* pending_script,
                                bool waiting_for_resources) {
   // 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 97 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* pending_script,
     ScriptStreamer::Type pending_script_type) {
   bool error_occurred = false;
-  ScriptSourceCode source_code = pending_script->GetSource(
+  Script* script = pending_script->GetSource(
       DocumentURLForScriptExecution(document_), error_occurred);
 
   // 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.
   pending_script->StopWatchingForLoad();
 
   if (!IsExecutingScript()) {
     Microtask::PerformCheckpoint(V8PerIsolateData::MainThreadIsolate());
@@ skipping 38 matching lines @@
           GetTraceArgsForScriptElement(element, script_start_position));
       script_loader->DispatchErrorEvent();
     } else {
       DCHECK(IsExecutingScript());
       if (script_parser_blocking_time > 0.0) {
         DocumentParserTiming::From(*document_)
             .RecordParserBlockedOnScriptLoadDuration(
                 MonotonicallyIncreasingTime() - script_parser_blocking_time,
                 script_loader->WasCreatedDuringDocumentWrite());
       }
-      if (!DoExecuteScript(element, source_code, script_start_position)) {
+      if (!DoExecuteScript(element, script, script_start_position)) {
         script_loader->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 372 matching lines @@
         // "Immediately execute the script block,
         //  even if other scripts are already executing."
         // TODO(hiroshige): Merge the block into ScriptLoader::prepareScript().
         DCHECK_GT(reentry_permit_->ScriptNestingLevel(), 1u);
         if (parser_blocking_script_)
           parser_blocking_script_->Dispose();
         parser_blocking_script_ = nullptr;
         ScriptSourceCode source_code(script->textContent(),
                                      DocumentURLForScriptExecution(document_),
                                      script_start_position);
-        DoExecuteScript(element, source_code, script_start_position);
+        DoExecuteScript(element, ClassicScript::Create(source_code),
+                        script_start_position);
       }
     } 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(document_);
   visitor->Trace(host_);
   visitor->Trace(parser_blocking_script_);
   visitor->Trace(scripts_to_execute_after_parsing_);
   PendingScriptClient::Trace(visitor);
 }
 
 }  // namespace blink