ScriptController: Expose methods to compile a script and execute a compiled script.

third_party/WebKit/Source/bindings/core/v8/ScriptController.cpp

 /*
  * Copyright (C) 2008, 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Opera Software ASA. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
@@ skipping 14 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "bindings/core/v8/ScriptController.h"
 
+#include "bindings/core/v8/CompiledScript.h"
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8Event.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "bindings/core/v8/V8HTMLElement.h"
 #include "bindings/core/v8/V8PerContextData.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "bindings/core/v8/V8Window.h"
 #include "bindings/core/v8/WindowProxy.h"
@@ skipping 41 matching lines @@
 
 void ScriptController::clearForClose() {
   m_windowProxyManager->clearForClose();
   MainThreadDebugger::instance()->didClearContextsForFrame(frame());
 }
 
 void ScriptController::updateSecurityOrigin(SecurityOrigin* securityOrigin) {
   m_windowProxyManager->updateSecurityOrigin(securityOrigin);
 }
 
+namespace {
+
+V8CacheOptions cacheOptions(const ScriptResource* resource,
+                            const Settings* settings) {
+  V8CacheOptions v8CacheOptions(V8CacheOptionsDefault);
+  if (settings)
+    v8CacheOptions = settings->v8CacheOptions();
+  if (resource && !resource->response().cacheStorageCacheName().isNull()) {
+    switch (settings->v8CacheStrategiesForCacheStorage()) {
+      case V8CacheStrategiesForCacheStorage::None:
+        v8CacheOptions = V8CacheOptionsNone;
+        break;
+      case V8CacheStrategiesForCacheStorage::Normal:
+        v8CacheOptions = V8CacheOptionsCode;
+        break;
+      case V8CacheStrategiesForCacheStorage::Default:
+      case V8CacheStrategiesForCacheStorage::Aggressive:
+        v8CacheOptions = V8CacheOptionsAlways;
+        break;
+    }
+  }
+  return v8CacheOptions;
+}
+
+}  // namespace
+
 v8::Local<v8::Value> ScriptController::executeScriptAndReturnValue(
     v8::Local<v8::Context> context,
     const ScriptSourceCode& source,
     AccessControlStatus accessControlStatus) {
   TRACE_EVENT1("devtools.timeline", "EvaluateScript", "data",
                InspectorEvaluateScriptEvent::data(
                    frame(), source.url().getString(), source.startPosition()));
   InspectorInstrumentation::NativeBreakpoint nativeBreakpoint(
       frame()->document(), "scriptFirstStatement", false);
 
   v8::Local<v8::Value> result;
   {
-    V8CacheOptions v8CacheOptions(V8CacheOptionsDefault);
-    if (frame()->settings())
-      v8CacheOptions = frame()->settings()->v8CacheOptions();
-    if (source.resource() &&
-        !source.resource()->response().cacheStorageCacheName().isNull()) {
-      switch (frame()->settings()->v8CacheStrategiesForCacheStorage()) {
-        case V8CacheStrategiesForCacheStorage::None:
-          v8CacheOptions = V8CacheOptionsNone;
-          break;
-        case V8CacheStrategiesForCacheStorage::Normal:
-          v8CacheOptions = V8CacheOptionsCode;
-          break;
-        case V8CacheStrategiesForCacheStorage::Default:
-        case V8CacheStrategiesForCacheStorage::Aggressive:
-          v8CacheOptions = V8CacheOptionsAlways;
-          break;
-      }
-    }
+    V8CacheOptions v8CacheOptions =
+        cacheOptions(source.resource(), frame()->settings());
 
     // Isolate exceptions that occur when compiling and executing
     // the code. These exceptions should not interfere with
     // javascript code we might evaluate from C++ when returning
     // from here.
     v8::TryCatch tryCatch(isolate());
     tryCatch.SetVerbose(true);
 
     v8::Local<v8::Script> script;
     if (!v8Call(V8ScriptRunner::compileScript(
                     source, isolate(), accessControlStatus, v8CacheOptions),
                 script, tryCatch))
       return result;
 
     if (!v8Call(V8ScriptRunner::runCompiledScript(isolate(), script,
                                                   frame()->document()),
                 result, tryCatch))
       return result;
   }
 
   TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"),
                        "UpdateCounters", TRACE_EVENT_SCOPE_THREAD, "data",
                        InspectorUpdateCountersEvent::data());
 
   return result;
 }
 
+CompiledScript* ScriptController::compileScriptInMainWorld(
+    const ScriptSourceCode& source,
+    AccessControlStatus accessControlStatus) {
+  V8CacheOptions v8CacheOptions =
+      cacheOptions(source.resource(), frame()->settings());
+
+  v8::HandleScope handleScope(isolate());
+  v8::TryCatch tryCatch(isolate());
+  tryCatch.SetVerbose(true);
+
+  v8::Local<v8::Script> script;
+  if (!v8Call(V8ScriptRunner::compileScript(
+                  source, isolate(), accessControlStatus, v8CacheOptions),
+              script, tryCatch)) {
+    return nullptr;
+  }
+
+  TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"),
+                       "UpdateCounters", TRACE_EVENT_SCOPE_THREAD, "data",
+                       InspectorUpdateCountersEvent::data());
+  return new CompiledScript(isolate(), script, source);
+}
+
+void ScriptController::executeScriptInMainWorld(
+    const CompiledScript& compiledScript) {
+  TRACE_EVENT1("devtools.timeline", "EvaluateScript", "data",
+               InspectorEvaluateScriptEvent::data(
+                   frame(), compiledScript.url().getString(),
+                   compiledScript.startPosition()));

[haraken, 2016/12/12 00:53:57]

Shall we introduce two trace events: "CompileScript" and "RunScript"?

- compileScript uses "CompileScript"
- executeScript uses "RunScript"
- executeScriptAndReturnValue uses "CompileScript" and "RunScript"

[jbroman, 2016/12/13 15:53:21]

I'm not opposed in principle, but these string constants are written into the
devtools timeline model code. It does already have a compile event, triggering
off "v8.compile" (which, along with "v8.run", already exists in V8ScriptRunner).
I admit to not being entirely sure why we have this separate event given that
v8.compile and v8.run both exist in the devtools.timeline category.

+  InspectorInstrumentation::NativeBreakpoint nativeBreakpoint(
+      frame()->document(), "scriptFirstStatement", false);
+
+  v8::HandleScope handleScope(isolate());
+  v8::TryCatch tryCatch(isolate());
+  tryCatch.SetVerbose(true);
+
+  v8::Local<v8::Value> result;
+  if (!v8Call(
+          V8ScriptRunner::runCompiledScript(
+              isolate(), compiledScript.script(isolate()), frame()->document()),
+          result, tryCatch))
+    return;
+
+  TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"),
+                       "UpdateCounters", TRACE_EVENT_SCOPE_THREAD, "data",
+                       InspectorUpdateCountersEvent::data());

[haraken, 2016/12/12 00:53:57]

I don't fully understand this trace event. Is it expected to be called on both
compileScript and executeScript? Before this CL, it was called only once for
each compile & execution step.

[jbroman, 2016/12/13 15:53:21]

From what I can tell, it makes a note of the heap size, JS listener count,
document and node count. Since the script compile may increase the heap size
(and execution certainly can), it seems reasonable to update these in the
devtools timeline at both times.

+}
+
 bool ScriptController::initializeMainWorld() {
   if (m_windowProxyManager->mainWorldProxy()->isContextInitialized())
     return false;
   return windowProxy(DOMWrapperWorld::mainWorld())->isContextInitialized();
 }
 
 WindowProxy* ScriptController::existingWindowProxy(DOMWrapperWorld& world) {
   return m_windowProxyManager->existingWindowProxy(world);
 }
 
@@ skipping 283 matching lines @@
     for (size_t i = 0; i < resultArray->Length(); ++i) {
       v8::Local<v8::Value> value;
       if (!resultArray->Get(scriptState->context(), i).ToLocal(&value))
         return;
       results->push_back(value);
     }
   }
 }
 
 }  // namespace blink