Expose synthetic delays through the GPU benchmarking extension

content/renderer/gpu/gpu_benchmarking_extension.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/gpu/gpu_benchmarking_extension.h"
 
 #include <string>
 
 #include "base/base64.h"
+#include "base/debug/trace_event_synthetic_delay.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string_number_conversions.h"
 #include "cc/layers/layer.h"
 #include "content/common/browser_rendering_stats.h"
 #include "content/common/gpu/gpu_rendering_stats.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/v8_value_converter.h"
 #include "content/renderer/gpu/render_widget_compositor.h"
@@ skipping 285 matching lines @@
           "};"
           "chrome.gpuBenchmarking.runMicroBenchmark ="
           "    function(name, callback, opt_arguments) {"
           "  arguments = opt_arguments || {};"
           "  native function RunMicroBenchmark();"
           "  return RunMicroBenchmark(name, callback, arguments);"
           "};"
           "chrome.gpuBenchmarking.hasGpuProcess = function() {"
           "  native function HasGpuProcess();"
           "  return HasGpuProcess();"
+          "};"
+          "chrome.gpuBenchmarking.configureSyntheticDelay = "
+          "    function(name, target_duration, opt_mode, opt_callback) {"
+          "  callback = opt_callback || function() { };"
+          "  mode = opt_mode || 'static';"
+          "  native function ConfigureSyntheticDelay();"
+          "  return ConfigureSyntheticDelay(name, target_duration, mode,"
+          "                                 callback);"
           "};") {}
 
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<v8::String> name) OVERRIDE {
     if (name->Equals(v8::String::New("SetNeedsDisplayOnAllLayers")))
       return v8::FunctionTemplate::New(SetNeedsDisplayOnAllLayers);
     if (name->Equals(v8::String::New("SetRasterizeOnlyVisibleContent")))
       return v8::FunctionTemplate::New(SetRasterizeOnlyVisibleContent);
     if (name->Equals(v8::String::New("GetRenderingStats")))
       return v8::FunctionTemplate::New(GetRenderingStats);
     if (name->Equals(v8::String::New("GetGpuRenderingStats")))
       return v8::FunctionTemplate::New(GetGpuRenderingStats);
     if (name->Equals(v8::String::New("PrintToSkPicture")))
       return v8::FunctionTemplate::New(PrintToSkPicture);
     if (name->Equals(v8::String::New("BeginSmoothScroll")))
       return v8::FunctionTemplate::New(BeginSmoothScroll);
     if (name->Equals(v8::String::New("SmoothScrollSendsTouch")))
       return v8::FunctionTemplate::New(SmoothScrollSendsTouch);
     if (name->Equals(v8::String::New("BeginPinch")))
       return v8::FunctionTemplate::New(BeginPinch);
     if (name->Equals(v8::String::New("BeginWindowSnapshotPNG")))
       return v8::FunctionTemplate::New(BeginWindowSnapshotPNG);
     if (name->Equals(v8::String::New("ClearImageCache")))
       return v8::FunctionTemplate::New(ClearImageCache);
     if (name->Equals(v8::String::New("RunMicroBenchmark")))
       return v8::FunctionTemplate::New(RunMicroBenchmark);
     if (name->Equals(v8::String::New("HasGpuProcess")))
       return v8::FunctionTemplate::New(HasGpuProcess);
+    if (name->Equals(v8::String::New("ConfigureSyntheticDelay")))
+      return v8::FunctionTemplate::New(ConfigureSyntheticDelay);
 
     return v8::Handle<v8::FunctionTemplate>();
   }
 
   static void SetNeedsDisplayOnAllLayers(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     GpuBenchmarkingContext context;
     if (!context.Init(true))
       return;
 
@@ skipping 87 matching lines @@
     v8::HandleScope scope(callback_and_context->isolate());
     v8::Handle<v8::Context> context = callback_and_context->GetContext();
     v8::Context::Scope context_scope(context);
     WebFrame* frame = WebFrame::frameForContext(context);
     if (frame) {
       frame->callFunctionEvenIfScriptDisabled(
           callback_and_context->GetCallback(), v8::Object::New(), 0, NULL);
     }
   }
 
+  static void OnConfigureSyntheticDelayCompleted(
+      CallbackAndContext* callback_and_context) {
+    v8::HandleScope scope(callback_and_context->isolate());
+    v8::Handle<v8::Context> context = callback_and_context->GetContext();
+    v8::Context::Scope context_scope(context);
+    WebFrame* frame = WebFrame::frameForContext(context);
+    if (frame) {
+      frame->callFunctionEvenIfScriptDisabled(
+          callback_and_context->GetCallback(), v8::Object::New(), 0, NULL);
+    }
+  }
+
   static void SmoothScrollSendsTouch(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     // TODO(epenner): Should other platforms emulate touch events?
 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
     args.GetReturnValue().Set(true);
 #else
     args.GetReturnValue().Set(false);
 #endif
   }
 
@@ skipping 227 matching lines @@
     args.GetReturnValue().Set(context.compositor()->ScheduleMicroBenchmark(
         std::string(*benchmark),
         value.Pass(),
         base::Bind(&OnMicroBenchmarkCompleted, callback_and_context)));
   }
 
   static void HasGpuProcess(const v8::FunctionCallbackInfo<v8::Value>& args) {
     GpuChannelHost* gpu_channel = RenderThreadImpl::current()->GetGpuChannel();
     args.GetReturnValue().Set(!!gpu_channel);
   }
+
+  static void ConfigureSyntheticDelay(
+      const v8::FunctionCallbackInfo<v8::Value>& args) {
+    GpuBenchmarkingContext context;
+    if (!context.Init(false)) {
+      args.GetReturnValue().Set(false);
+      return;
+    }
+
+    if (args.Length() != 4 ||
+        !args[0]->IsString() ||
+        !args[1]->IsNumber() ||
+        !args[2]->IsString() ||
+        !args[3]->IsObject()) {
+      args.GetReturnValue().Set(false);
+      return;
+    }
+
+    v8::String::Utf8Value name(args[0]);
+    base::TimeDelta target_duration =
+        base::TimeDelta::FromMicroseconds(args[1]->NumberValue() * 1e6);
+    v8::String::Utf8Value mode_value(args[2]);
+    v8::Local<v8::Function> callback_local =
+        v8::Local<v8::Function>::Cast(args[3]);
+    DCHECK(*name);
+    DCHECK(*mode_value);
+
+    std::string mode(*mode_value);
+    base::debug::TraceEventSyntheticDelay::Mode delay_mode;
+    if (mode == "static") {
+      delay_mode = base::debug::TraceEventSyntheticDelay::STATIC;
+    } else if (mode == "oneshot") {
+      delay_mode = base::debug::TraceEventSyntheticDelay::ONE_SHOT;
+    } else if (mode == "alternating") {
+      delay_mode = base::debug::TraceEventSyntheticDelay::ALTERNATING;
+    } else {
+      args.GetReturnValue().Set(false);
+      return;
+    }
+
+    scoped_refptr<CallbackAndContext> callback_and_context =
+        new CallbackAndContext(args.GetIsolate(),
+                               callback_local,
+                               context.web_frame()->mainWorldScriptContext());
+    context.render_view_impl()->ConfigureSyntheticDelay(
+        *name,
+        target_duration,
+        delay_mode,
+        base::Bind(&OnConfigureSyntheticDelayCompleted,
+                   callback_and_context));
+    args.GetReturnValue().Set(true);
+  }
 };
 
 v8::Extension* GpuBenchmarkingExtension::Get() {
   return new GpuBenchmarkingWrapper();
 }
 
 }  // namespace content