DO NOT SUBMIT: Sketching out ScriptLoader::executeScriptAsync.

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
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "core/dom/ScriptLoader.h"
 
+#include "bindings/core/v8/CompiledScript.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "core/HTMLNames.h"
 #include "core/SVGNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentParserTiming.h"
 #include "core/dom/IgnoreDestructiveWriteCountIncrementer.h"
 #include "core/dom/ScriptLoaderClient.h"
 #include "core/dom/ScriptRunner.h"
 #include "core/dom/ScriptableDocumentParser.h"
+#include "core/dom/TaskRunnerHelper.h"
 #include "core/dom/Text.h"
 #include "core/events/Event.h"
 #include "core/fetch/AccessControlStatus.h"
 #include "core/fetch/FetchRequest.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/SubresourceIntegrity.h"
 #include "core/frame/UseCounter.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/CrossOriginAttribute.h"
 #include "core/html/HTMLScriptElement.h"
 #include "core/html/imports/HTMLImport.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/svg/SVGScriptElement.h"
 #include "platform/WebFrameScheduler.h"
 #include "platform/network/mime/MIMETypeRegistry.h"
 #include "platform/weborigin/SecurityOrigin.h"
+#include "public/platform/Platform.h"
 #include "public/platform/WebCachePolicy.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/StringHash.h"
 
 namespace blink {
 
 ScriptLoader::ScriptLoader(Element* element,
                            bool parserInserted,
                            bool alreadyStarted,
@@ skipping 357 matching lines @@
                                     : UseCounter::SameOriginOtherScript)
           : (isText ? UseCounter::CrossOriginTextScript
                     : isApplication ? UseCounter::CrossOriginApplicationScript
                                     : UseCounter::CrossOriginOtherScript);
 
   UseCounter::count(frame, feature);
 }
 
 bool ScriptLoader::executeScript(const ScriptSourceCode& sourceCode) {
   double scriptExecStartTime = monotonicallyIncreasingTime();
-  bool result = doExecuteScript(sourceCode);
 
-  // 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;
+  CheckScriptResult result = checkScript(sourceCode);
+  if (result == CheckScriptResult::Proceed) {
+    AccessControlStatus accessControlStatus =
+        computeAccessControlStatus(sourceCode);
+    asCurrentScript(
+        [&sourceCode, accessControlStatus](ScriptController& scriptController) {
+          scriptController.executeScriptInMainWorld(sourceCode,
+                                                    accessControlStatus);
+        });
+  }
+
+  recordParserBlockedOnScriptExecutionSince(scriptExecStartTime);
+  return result != CheckScriptResult::Abort;
 }
 
-bool ScriptLoader::doExecuteScript(const ScriptSourceCode& sourceCode) {
+void ScriptLoader::executeScriptAsync(
+    const ScriptSourceCode& sourceCode,
+    std::unique_ptr<ExecuteScriptAsyncCallback> completionCallback) {
+  DCHECK(completionCallback);
+  double scriptCompileStartTime = monotonicallyIncreasingTime();
+
+  AccessControlStatus accessControlStatus =
+      computeAccessControlStatus(sourceCode);
+  Document* elementDocument = &(m_element->document());
+  Document* contextDocument = elementDocument->contextDocument();
+  LocalFrame* frame = contextDocument->frame();
+
+  // TODO(jbroman): Could call checkScript here first.
+  // This would arguably be redundant, especially if we call it synchronously.
+  // On the other hand, it could also avoid compiling something that cannot
+  // execute.
+
+  CompiledScript* compiled =
+      frame->script().compileScriptInMainWorld(sourceCode, accessControlStatus);
+  recordParserBlockedOnScriptExecutionSince(scriptCompileStartTime);
+
+  if (!compiled) {
+    (*completionCallback)(true);
+    return;
+  }
+
+  static const unsigned kSmallScriptSize = 30 * 1024;
+  const bool shouldYield = sourceCode.source().length() >= kSmallScriptSize &&
+                           Platform::current()
+                               ->mainThread()
+                               ->scheduler()
+                               ->shouldYieldForHighPriorityWork();
+  if (shouldYield) {
+    std::unique_ptr<WTF::Closure> continuation = WTF::bind(
+        &ScriptLoader::continueExecuteScriptAsync, wrapPersistent(this),
+        wrapPersistent(compiled), wrapPersistent(elementDocument),
+        WTF::passed(std::move(completionCallback)));
+    TaskRunnerHelper::get(TaskType::Networking, frame)
+        ->postTask(BLINK_FROM_HERE, std::move(continuation));
+  } else {
+    continueExecuteScriptAsync(compiled, elementDocument,
+                               std::move(completionCallback));
+  }
+}
+
+void ScriptLoader::continueExecuteScriptAsync(
+    CompiledScript* compiled,
+    Document* elementDocumentWhenCompiled,
+    std::unique_ptr<ExecuteScriptAsyncCallback> completionCallback) {
+  double scriptExecStartTime = monotonicallyIncreasingTime();
+
+  CheckScriptResult result = checkScript(compiled->sourceCode());
+  if (result == CheckScriptResult::Proceed) {
+    asCurrentScript([this, compiled, elementDocumentWhenCompiled](
+        ScriptController& scriptController) {
+      if (m_element->document() == elementDocumentWhenCompiled) {
+        scriptController.executeScriptInMainWorld(*compiled);
+      } else {
+        // This will recompile the source code. But it only happens when the
+        // element moves to a new document at an inopportune time, which
+        // should be rare.
+        scriptController.executeScriptInMainWorld(compiled->sourceCode());
+      }
+    });
+  }
+
+  recordParserBlockedOnScriptExecutionSince(scriptExecStartTime);
+  (*completionCallback)(result != CheckScriptResult::Abort);
+}
+
+ScriptLoader::CheckScriptResult ScriptLoader::checkScript(
+    const ScriptSourceCode& sourceCode) {
   DCHECK(m_alreadyStarted);
 
   if (sourceCode.isEmpty())
-    return true;
+    return CheckScriptResult::NothingToDo;
 
   Document* elementDocument = &(m_element->document());
   Document* contextDocument = elementDocument->contextDocument();
   if (!contextDocument)
-    return true;
+    return CheckScriptResult::NothingToDo;
 
   LocalFrame* frame = contextDocument->frame();
+  if (!frame)
+    return CheckScriptResult::NothingToDo;
 
   const ContentSecurityPolicy* csp = elementDocument->contentSecurityPolicy();
   bool shouldBypassMainWorldCSP =
       (frame && frame->script().shouldBypassMainWorldCSP()) ||
       csp->allowScriptWithHash(sourceCode.source(),
                                ContentSecurityPolicy::InlineType::Block);
 
   AtomicString nonce =
       ContentSecurityPolicy::isNonceableElement(m_element.get())
           ? m_element->fastGetAttribute(HTMLNames::nonceAttr)
           : AtomicString();
   if (!m_isExternalScript &&
       (!shouldBypassMainWorldCSP &&
        !csp->allowInlineScript(m_element, elementDocument->url(), nonce,
                                m_startLineNumber, sourceCode.source()))) {
-    return false;
+    return CheckScriptResult::Abort;
   }
 
   if (m_isExternalScript) {
     ScriptResource* resource =
         m_resource ? m_resource.get() : sourceCode.resource();
     if (resource) {
       if (!resource->mimeTypeAllowedByNosniff()) {
         contextDocument->addConsoleMessage(ConsoleMessage::create(
             SecurityMessageSource, ErrorMessageLevel,
             "Refused to execute script from '" +
                 resource->url().elidedString() + "' because its MIME type ('" +
                 resource->httpContentType() + "') is not executable, and "
                                               "strict MIME type checking is "
                                               "enabled."));
-        return false;
+        return CheckScriptResult::Abort;
       }
 
       String mimeType = resource->httpContentType();
       if (mimeType.startsWith("image/") || mimeType == "text/csv" ||
           mimeType.startsWith("audio/") || mimeType.startsWith("video/")) {
         contextDocument->addConsoleMessage(ConsoleMessage::create(
             SecurityMessageSource, ErrorMessageLevel,
             "Refused to execute script from '" +
                 resource->url().elidedString() + "' because its MIME type ('" +
                 mimeType + "') is not executable."));
         if (mimeType.startsWith("image/"))
           UseCounter::count(frame, UseCounter::BlockedSniffingImageToScript);
         else if (mimeType.startsWith("audio/"))
           UseCounter::count(frame, UseCounter::BlockedSniffingAudioToScript);
         else if (mimeType.startsWith("video/"))
           UseCounter::count(frame, UseCounter::BlockedSniffingVideoToScript);
         else if (mimeType == "text/csv")
           UseCounter::count(frame, UseCounter::BlockedSniffingCSVToScript);
-        return false;
+        return CheckScriptResult::Abort;
       }
 
       logScriptMIMEType(frame, resource, mimeType);
     }
   }
 
-  // FIXME: Can this be moved earlier in the function?
-  // Why are we ever attempting to execute scripts without a frame?
-  if (!frame)
-    return true;
+  return CheckScriptResult::Proceed;
+}
 
+AccessControlStatus ScriptLoader::computeAccessControlStatus(
+    const ScriptSourceCode& sourceCode) {
   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;
     }
   }
+  return accessControlStatus;
+}
 
-  const bool isImportedScript = contextDocument != elementDocument;
+template <typename Functor>
+void ScriptLoader::asCurrentScript(const Functor& functor) {
+  Document* elementDocument = &m_element->document();
+  Document* contextDocument = elementDocument->contextDocument();
+  LocalFrame* frame = contextDocument->frame();
+  if (!frame)
+    return;
+
   // http://www.whatwg.org/specs/web-apps/current-work/#execute-the-script-block
   // step 2.3 with additional support for HTML imports.
+  const bool isImportedScript = contextDocument != elementDocument;
   IgnoreDestructiveWriteCountIncrementer ignoreDestructiveWriteCountIncrementer(
       m_isExternalScript || isImportedScript ? contextDocument : 0);
 
   if (isHTMLScriptLoader(m_element) || isSVGScriptLoader(m_element))
     contextDocument->pushCurrentScript(m_element);
 
-  // Create a script from the script element node, using the script
-  // block's source and the script block's type.
-  // Note: This is where the script is compiled and actually executed.
-  frame->script().executeScriptInMainWorld(sourceCode, accessControlStatus);
+  functor(frame->script());
 
   if (isHTMLScriptLoader(m_element) || isSVGScriptLoader(m_element)) {
     DCHECK(contextDocument->currentScript() == m_element);
     contextDocument->popCurrentScript();
   }
+}
 
-  return true;
+void ScriptLoader::recordParserBlockedOnScriptExecutionSince(double startTime) {
+  // 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() - startTime,
+            wasCreatedDuringDocumentWrite());
+  }
 }
 
 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);
   m_pendingScript->dispose();
   if (errorOccurred) {
@@ skipping 80 matching lines @@
   if (isHTMLScriptLoader(element))
     return toHTMLScriptElement(element)->loader();
 
   if (isSVGScriptLoader(element))
     return toSVGScriptElement(element)->loader();
 
   return 0;
 }
 
 }  // namespace blink