WIP: Reland CompiledScript, prototype compiling in a separate task.

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 61 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(Element* scriptElement,
                      const ScriptSourceCode& sourceCode,
-                     const TextPosition& textPosition) {
+                     const TextPosition& textPosition,
+                     CompiledScript* compiledScript = nullptr) {
   ScriptLoader* scriptLoader = toScriptLoaderIfPossible(scriptElement);
   DCHECK(scriptLoader);
-  TRACE_EVENT_WITH_FLOW1(
+  TRACE_EVENT_WITH_FLOW2(
       "blink", "HTMLParserScriptRunner ExecuteScript", scriptElement,
       TRACE_EVENT_FLAG_FLOW_IN, "data",
-      getTraceArgsForScriptElement(scriptElement, textPosition));
-  return scriptLoader->executeScript(sourceCode);
+      getTraceArgsForScriptElement(scriptElement, textPosition),
+      "compiledScript", compiledScript);
+  return scriptLoader->executeScript(sourceCode, compiledScript);
 }
 
 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 119 matching lines @@
       // resource
       if (!m_document->isScriptExecutionReady())
         return;
     }
   }
 
   TextPosition scriptStartPosition = pendingScript->startingPosition();
   double scriptParserBlockingTime =
       pendingScript->parserBlockingLoadStartTime();
   Element* element = pendingScript->element();
+  CompiledScript* compiledScript = pendingScript->getCompiledScript();
 
   // 1. "Let the script be the pending parsing-blocking script.
   //     There is no longer a pending parsing-blocking script."
   // Clear the pending script before possible re-entrancy from executeScript()
   pendingScript->dispose();
   pendingScript = nullptr;
 
   if (pendingScriptType == ScriptStreamer::ParsingBlocking) {
     m_parserBlockingScript = nullptr;
   }
@@ skipping 16 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, sourceCode, scriptStartPosition,
+                           compiledScript)) {
         scriptLoader->dispatchErrorEvent();
       } else {
         element->dispatchEvent(Event::create(EventTypeNames::load));
       }
     }
 
     // 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 72 matching lines @@
   TextPosition startingPosition = parserBlockingScript()->startingPosition();
   bool isParserInserted = scriptLoader->isParserInserted();
   // Remove this resource entry from memory cache as the new request
   // should not join onto this existing entry.
   memoryCache()->remove(pendingScript->resource());
   fetchBlockedDocWriteScript(element, isParserInserted, startingPosition);
 }
 
 void HTMLParserScriptRunner::pendingScriptFinished(
     PendingScript* pendingScript) {
+  LOG(ERROR) << "Finished loading pending script of size "
+             << pendingScript->resource()->size();
+
   // 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() && pendingScript->resource()->wasCanceled()) {
     pendingScript->dispose();
 
     if (pendingScript == parserBlockingScript()) {
@@ skipping 291 matching lines @@
         //  Document of the parser that created the element.
         //  (There can only be one such script per Document at a time.)"
         CHECK(!m_parserBlockingScript);
         m_parserBlockingScript =
             PendingScript::create(script, scriptStartPosition);
       } else {
         // 6th Clause of Step 23.
         // "Immediately execute the script block,
         //  even if other scripts are already executing."
         // TODO(hiroshige): Merge the block into ScriptLoader::prepareScript().
+        TRACE_EVENT0("blink", "HTMLParserScriptRunner immediate-execute");
         DCHECK_GT(m_reentryPermit->scriptNestingLevel(), 1u);
         if (m_parserBlockingScript)
           m_parserBlockingScript->dispose();
         m_parserBlockingScript = nullptr;
         ScriptSourceCode sourceCode(script->textContent(),
                                     documentURLForScriptExecution(m_document),
                                     scriptStartPosition);
         doExecuteScript(script, sourceCode, scriptStartPosition);
       }
     } else {
@@ skipping 13 matching lines @@
 
 DEFINE_TRACE(HTMLParserScriptRunner) {
   visitor->trace(m_document);
   visitor->trace(m_host);
   visitor->trace(m_parserBlockingScript);
   visitor->trace(m_scriptsToExecuteAfterParsing);
   PendingScriptClient::trace(visitor);
 }
 
 }  // namespace blink