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

third_party/WebKit/Source/core/dom/ScriptLoader.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2008 Nikolas Zimmermann <zimmermann@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 93 matching lines @@
 
 ScriptLoader::~ScriptLoader() {}
 
 DEFINE_TRACE(ScriptLoader) {
   visitor->trace(m_element);
   visitor->trace(m_resource);
   visitor->trace(m_pendingScript);
   PendingScriptClient::trace(visitor);
 }
 
+// static
+AccessControlStatus ScriptLoader::accessControlStatusForScript(
+    bool isExternalScript,
+    const ScriptResource* resource,
+    const SecurityOrigin* scriptElementOrigin) {
+  if (!isExternalScript)
+    return SharableCrossOrigin;
+
+  // TODO(jbroman): DCHECK(resource)?
+  if (!resource)
+    return NotSharableCrossOrigin;
+
+  const auto& response = resource->response();
+  if (response.wasFetchedViaServiceWorker()) {
+    return response.serviceWorkerResponseType() ==
+                   WebServiceWorkerResponseTypeOpaque
+               ? OpaqueResource
+               : SharableCrossOrigin;
+  }
+
+  return resource->passesAccessControlCheck(scriptElementOrigin)
+             ? SharableCrossOrigin
+             : NotSharableCrossOrigin;
+}
+
 void ScriptLoader::setFetchDocWrittenScriptDeferIdle() {
   DCHECK(!m_createdDuringDocumentWrite);
   m_documentWriteIntervention =
       DocumentWriteIntervention::FetchDocWrittenScriptDeferIdle;
 }
 
 void ScriptLoader::didNotifySubtreeInsertionsToDocument() {
   if (!m_parserInserted)
     prepareScript();  // FIXME: Provide a real starting line number here.
 }
@@ skipping 529 matching lines @@
           ? (isText ? UseCounter::SameOriginTextScript
                     : isApplication ? UseCounter::SameOriginApplicationScript
                                     : UseCounter::SameOriginOtherScript)
           : (isText ? UseCounter::CrossOriginTextScript
                     : isApplication ? UseCounter::CrossOriginApplicationScript
                                     : UseCounter::CrossOriginOtherScript);
 
   UseCounter::count(frame, feature);
 }
 
-bool ScriptLoader::executeScript(const ScriptSourceCode& sourceCode) {
+bool ScriptLoader::executeScript(const ScriptSourceCode& sourceCode,
+                                 CompiledScript* compiledScript) {
   double scriptExecStartTime = monotonicallyIncreasingTime();
-  bool result = doExecuteScript(sourceCode);
+  bool result = doExecuteScript(sourceCode, compiledScript);
 
   // NOTE: we do not check m_willBeParserExecuted here, since
   // m_willBeParserExecuted is false for inline scripts, and we want to
   // include inline script execution time as part of parser blocked script
   // execution time.
   if (m_asyncExecType == ScriptRunner::None)
     DocumentParserTiming::from(m_element->document())
         .recordParserBlockedOnScriptExecutionDuration(
             monotonicallyIncreasingTime() - scriptExecStartTime,
             wasCreatedDuringDocumentWrite());
   return result;
 }
 
 // https://html.spec.whatwg.org/#execute-the-script-block
 // with additional support for HTML imports.
 // Note that Steps 2 and 8 must be handled by the caller of doExecuteScript(),
 // i.e. load/error events are dispatched by the caller.
 // Steps 3--7 are implemented here in doExecuteScript().
 // TODO(hiroshige): Move event dispatching code to doExecuteScript().
-bool ScriptLoader::doExecuteScript(const ScriptSourceCode& sourceCode) {
+bool ScriptLoader::doExecuteScript(const ScriptSourceCode& sourceCode,
+                                   CompiledScript* compiledScript) {
   DCHECK(m_alreadyStarted);
 
   if (sourceCode.isEmpty())
     return true;
 
   Document* elementDocument = &(m_element->document());
   Document* contextDocument = elementDocument->contextDocument();
   if (!contextDocument)
     return true;
 
@@ skipping 49 matching lines @@
           UseCounter::count(frame, UseCounter::BlockedSniffingVideoToScript);
         else if (mimeType == "text/csv")
           UseCounter::count(frame, UseCounter::BlockedSniffingCSVToScript);
         return false;
       }
 
       logScriptMIMEType(frame, resource, mimeType);
     }
   }
 
-  AccessControlStatus accessControlStatus = NotSharableCrossOrigin;
-  if (!m_isExternalScript) {
-    accessControlStatus = SharableCrossOrigin;
-  } else if (sourceCode.resource()) {
-    if (sourceCode.resource()->response().wasFetchedViaServiceWorker()) {
-      if (sourceCode.resource()->response().serviceWorkerResponseType() ==
-          WebServiceWorkerResponseTypeOpaque)
-        accessControlStatus = OpaqueResource;
-      else
-        accessControlStatus = SharableCrossOrigin;
-    } else if (sourceCode.resource()->passesAccessControlCheck(
-                   m_element->document().getSecurityOrigin())) {
-      accessControlStatus = SharableCrossOrigin;
-    }
-  }
+  AccessControlStatus accessControlStatus =
+      accessControlStatusForScript(m_isExternalScript, sourceCode.resource(),
+                                   elementDocument->getSecurityOrigin());
 
   const bool isImportedScript = contextDocument != elementDocument;
 
   // 3. "If the script is from an external file,
   //     or the script's type is module",
   //     then increment the ignore-destructive-writes counter of the
   //     script element's node document. Let neutralized doc be that Document."
   // TODO(hiroshige): Implement "module" case.
   IgnoreDestructiveWriteCountIncrementer ignoreDestructiveWriteCountIncrementer(
       m_isExternalScript || isImportedScript ? contextDocument : 0);
 
   // 4. "Let old script element be the value to which the script element's
   //     node document's currentScript object was most recently set."
   // This is implemented as push/popCurrentScript().
 
   // 5. "Switch on the script's type:"
   //    - "classic":
   //    1. "If the script element's root is not a shadow root,
   //        then set the script element's node document's currentScript
   //        attribute to the script element. Otherwise, set it to null."
   if (isHTMLScriptLoader(m_element) || isSVGScriptLoader(m_element))
     contextDocument->pushCurrentScript(m_element);
 
   //    2. "Run the classic script given by the script's script."
   // Note: This is where the script is compiled and actually executed.
-  frame->script().executeScriptInMainWorld(sourceCode, accessControlStatus);
+  if (compiledScript) {
+    frame->script().executeScriptInMainWorld(*compiledScript);
+  } else {
+    frame->script().executeScriptInMainWorld(sourceCode, accessControlStatus);
+  }
 
   //    - "module":
   // TODO(hiroshige): Implement this.
 
   // 6. "Set the script element's node document's currentScript attribute
   //     to old script element."
   if (isHTMLScriptLoader(m_element) || isSVGScriptLoader(m_element)) {
     DCHECK(contextDocument->currentScript() == m_element);
     contextDocument->popCurrentScript();
   }
 
   return true;
 
   // 7. "Decrement the ignore-destructive-writes counter of neutralized doc,
   //     if it was incremented in the earlier step."
   // Implemented as the scope out of IgnoreDestructiveWriteCountIncrementer.
 }
 
 void ScriptLoader::execute() {
   DCHECK(!m_willBeParserExecuted);
   DCHECK(m_asyncExecType != ScriptRunner::None);
   DCHECK(m_pendingScript->resource());
   bool errorOccurred = false;
   ScriptSourceCode source = m_pendingScript->getSource(KURL(), errorOccurred);
+  CompiledScript* compiledScript = m_pendingScript->getCompiledScript();
   detachPendingScript();
   if (errorOccurred) {
     dispatchErrorEvent();
   } else if (!m_resource->wasCanceled()) {
-    if (executeScript(source))
+    if (executeScript(source, compiledScript))
       dispatchLoadEvent();
     else
       dispatchErrorEvent();
   }
   m_resource = nullptr;
 }
 
 void ScriptLoader::pendingScriptFinished(PendingScript* pendingScript) {
+  LOG(ERROR) << "Finished loading pending script of size "
+             << pendingScript->resource()->size();
   DCHECK(!m_willBeParserExecuted);
   DCHECK_EQ(m_pendingScript, pendingScript);
   DCHECK_EQ(pendingScript->resource(), m_resource);
 
   // We do not need this script in the memory cache. The primary goals of
   // sending this fetch request are to let the third party server know
   // about the document.write scripts intervention and populate the http
   // cache for subsequent uses.
   if (m_documentWriteIntervention ==
       DocumentWriteIntervention::FetchDocWrittenScriptDeferIdle) {
@@ skipping 73 matching lines @@
   if (isHTMLScriptLoader(element))
     return toHTMLScriptElement(element)->loader();
 
   if (isSVGScriptLoader(element))
     return toSVGScriptElement(element)->loader();
 
   return 0;
 }
 
 }  // namespace blink