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/common/input/synthetic_gesture_params.h"
 #include "content/common/input/synthetic_pinch_gesture_params.h"
 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
+#include "content/common/synthetic_delay_configuration.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/v8_value_converter.h"
 #include "content/renderer/gpu/render_widget_compositor.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/skia_benchmarking_extension.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebImageCache.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/skia/include/core/SkData.h"
@@ skipping 294 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.configureSyntheticDelays = "
+          "    function(delays, opt_callback) {"
+          "  callback = opt_callback || function() { };"
+          "  native function ConfigureSyntheticDelays();"
+          "  return ConfigureSyntheticDelays(delays, callback);"
           "};") {}
 
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunctionTemplate(
       v8::Isolate* isolate,
       v8::Handle<v8::String> name) OVERRIDE {
     if (name->Equals(
             v8::String::NewFromUtf8(isolate, "SetNeedsDisplayOnAllLayers")))
       return v8::FunctionTemplate::New(isolate, SetNeedsDisplayOnAllLayers);
     if (name->Equals(
             v8::String::NewFromUtf8(isolate, "SetRasterizeOnlyVisibleContent")))
@@ skipping 13 matching lines @@
       return v8::FunctionTemplate::New(isolate, BeginPinch);
     if (name->Equals(
             v8::String::NewFromUtf8(isolate, "BeginWindowSnapshotPNG")))
       return v8::FunctionTemplate::New(isolate, BeginWindowSnapshotPNG);
     if (name->Equals(v8::String::NewFromUtf8(isolate, "ClearImageCache")))
       return v8::FunctionTemplate::New(isolate, ClearImageCache);
     if (name->Equals(v8::String::NewFromUtf8(isolate, "RunMicroBenchmark")))
       return v8::FunctionTemplate::New(isolate, RunMicroBenchmark);
     if (name->Equals(v8::String::NewFromUtf8(isolate, "HasGpuProcess")))
       return v8::FunctionTemplate::New(isolate, HasGpuProcess);
+    if (name->Equals(v8::String::New("ConfigureSyntheticDelays")))
+      return v8::FunctionTemplate::New(ConfigureSyntheticDelays);
 
     return v8::Handle<v8::FunctionTemplate>();
   }
 
   static void SetNeedsDisplayOnAllLayers(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     GpuBenchmarkingContext context;
     if (!context.Init(true))
       return;
 
@@ skipping 89 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 244 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 ConfigureSyntheticDelays(
+      const v8::FunctionCallbackInfo<v8::Value>& args) {
+    GpuBenchmarkingContext context;
+    if (!context.Init(false)) {
+      args.GetReturnValue().Set(false);
+      return;
+    }
+
+    if (args.Length() != 2 ||
+        !args[0]->IsObject() ||
+        !args[1]->IsObject()) {
+      args.GetReturnValue().Set(false);
+      return;
+    }
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Function> callback_local =
+        v8::Local<v8::Function>::Cast(args[1]);
+    v8::Handle<v8::String> duration_key(
+        v8::String::NewFromUtf8(isolate, "target_duration"));
+    v8::Handle<v8::String> mode_key(v8::String::NewFromUtf8(isolate, "mode"));
+
+    std::vector<SyntheticDelayConfiguration> delay_configs;
+    v8::Handle<v8::Object> delay_settings(args[0]->ToObject());
+    v8::Handle<v8::Array> delay_names(delay_settings->GetOwnPropertyNames());
+    for (size_t i = 0; i < delay_names->Length(); ++i) {
+      v8::Handle<v8::Value> key(delay_names->Get(i));
+      if (!key->IsString()) {
+        args.GetReturnValue().Set(false);
+        return;
+      }
+      v8::String::Utf8Value name_utf8(key->ToString());
+      v8::Handle<v8::Value> settings_value = delay_settings->Get(key);
+      if (!settings_value ->IsObject()) {
+        args.GetReturnValue().Set(false);
+        return;
+      }
+
+      v8::Handle<v8::Object> settings(settings_value->ToObject());
+      SyntheticDelayConfiguration delay_config;
+      delay_config.name = std::string(*name_utf8);
+
+      if (settings->HasOwnProperty(duration_key)) {
+        v8::Handle<v8::Value> value = settings->Get(duration_key);
+        if (!value->IsNumber()) {
+          args.GetReturnValue().Set(false);
+          return;
+        }
+        delay_config.target_duration =
+            base::TimeDelta::FromMicroseconds(value->NumberValue() * 1e6);
+      }
+      if (settings->HasOwnProperty(mode_key)) {
+        v8::Handle<v8::Value> value = settings->Get(mode_key);
+        if (!value->IsString()) {
+          args.GetReturnValue().Set(false);
+          return;
+        }
+        v8::String::Utf8Value mode_utf8(value->ToString());
+        std::string mode(*mode_utf8);
+        if (mode == "static") {
+          delay_config.mode =
+              static_cast<SyntheticDelayConfiguration::Mode>(
+                  content::SyntheticDelayConfiguration::STATIC);
+        } else if (mode == "oneshot") {
+          delay_config.mode =
+              static_cast<SyntheticDelayConfiguration::Mode>(
+                  content::SyntheticDelayConfiguration::ONE_SHOT);
+        } else if (mode == "alternating") {
+          delay_config.mode =
+              static_cast<SyntheticDelayConfiguration::Mode>(
+                  content::SyntheticDelayConfiguration::ALTERNATING);
+        } else {
+          args.GetReturnValue().Set(false);
+          return;
+        }
+      }
+      delay_configs.push_back(delay_config);
+    }
+
+    scoped_refptr<CallbackAndContext> callback_and_context =
+        new CallbackAndContext(args.GetIsolate(),
+                               callback_local,
+                               context.web_frame()->mainWorldScriptContext());
+    context.render_view_impl()->ConfigureSyntheticDelays(
+        delay_configs,
+        base::Bind(&OnConfigureSyntheticDelayCompleted,
+                   callback_and_context));
+    args.GetReturnValue().Set(true);
+  }
 };
 
 v8::Extension* GpuBenchmarkingExtension::Get() {
   return new GpuBenchmarkingWrapper();
 }
 
 }  // namespace content