Convert the SkiaBenchmarkingExtension to a gin::Wrappable class

content/renderer/skia_benchmarking_extension.cc

 // Copyright (c) 2013 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/skia_benchmarking_extension.h"
 
 #include "base/base64.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/resources/picture.h"
 #include "content/public/renderer/v8_value_converter.h"
+#include "content/renderer/render_thread_impl.h"
+#include "gin/arguments.h"
+#include "gin/handle.h"
+#include "gin/object_template_builder.h"
 #include "skia/ext/benchmarking_canvas.h"
 #include "third_party/WebKit/public/platform/WebArrayBuffer.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
+#include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/skia/include/core/SkBitmapDevice.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "third_party/skia/src/utils/debugger/SkDebugCanvas.h"
 #include "third_party/skia/src/utils/debugger/SkDrawCommand.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "v8/include/v8.h"
 
-using blink::WebFrame;
+
+namespace content {
 
 namespace {
 
-const char kSkiaBenchmarkingExtensionName[] = "v8/SkiaBenchmarking";
-
-static scoped_ptr<base::Value> ParsePictureArg(v8::Isolate* isolate,
-                                               v8::Handle<v8::Value> arg) {
+scoped_ptr<base::Value> ParsePictureArg(v8::Isolate* isolate,
+                                        v8::Handle<v8::Value> arg) {
   scoped_ptr<content::V8ValueConverter> converter(
       content::V8ValueConverter::create());
   return scoped_ptr<base::Value>(
       converter->FromV8Value(arg, isolate->GetCurrentContext()));
 }
 
-static scoped_refptr<cc::Picture> ParsePictureStr(v8::Isolate* isolate,
-                                                  v8::Handle<v8::Value> arg) {
+scoped_refptr<cc::Picture> ParsePictureStr(v8::Isolate* isolate,
+                                           v8::Handle<v8::Value> arg) {
   scoped_ptr<base::Value> picture_value = ParsePictureArg(isolate, arg);
   if (!picture_value)
     return NULL;
   return cc::Picture::CreateFromSkpValue(picture_value.get());
 }
 
-static scoped_refptr<cc::Picture> ParsePictureHash(v8::Isolate* isolate,
-                                                   v8::Handle<v8::Value> arg) {
+scoped_refptr<cc::Picture> ParsePictureHash(v8::Isolate* isolate,
+                                            v8::Handle<v8::Value> arg) {
   scoped_ptr<base::Value> picture_value = ParsePictureArg(isolate, arg);
   if (!picture_value)
     return NULL;
   return cc::Picture::CreateFromValue(picture_value.get());
 }
 
-class SkiaBenchmarkingWrapper : public v8::Extension {
- public:
-  SkiaBenchmarkingWrapper() :
-      v8::Extension(kSkiaBenchmarkingExtensionName,
-        "if (typeof(chrome) == 'undefined') {"
-        "  chrome = {};"
-        "};"
-        "if (typeof(chrome.skiaBenchmarking) == 'undefined') {"
-        "  chrome.skiaBenchmarking = {};"
-        "};"
-        "chrome.skiaBenchmarking.rasterize = function(picture, params) {"
-        "  /* "
-        "     Rasterizes a Picture JSON-encoded by cc::Picture::AsValue()."
-        "     @param {Object} picture A json-encoded cc::Picture."
-        "     @param {"
-        "                 'scale':    {Number},"
-        "                 'stop':     {Number},"
-        "                 'overdraw': {Boolean},"
-        "                 'clip':     [Number, Number, Number, Number]"
-        "     } (optional) Rasterization parameters."
-        "     @returns {"
-        "                 'width':    {Number},"
-        "                 'height':   {Number},"
-        "                 'data':     {ArrayBuffer}"
-        "     }"
-        "     @returns undefined if the arguments are invalid or the picture"
-        "                        version is not supported."
-        "   */"
-        "  native function Rasterize();"
-        "  return Rasterize(picture, params);"
-        "};"
-        "chrome.skiaBenchmarking.getOps = function(picture) {"
-        "  /* "
-        "     Extracts the Skia draw commands from a JSON-encoded cc::Picture"
-        "     @param {Object} picture A json-encoded cc::Picture."
-        "     @returns [{ 'cmd': {String}, 'info': [String, ...] }, ...]"
-        "     @returns undefined if the arguments are invalid or the picture"
-        "                        version is not supported."
-        "   */"
-        "  native function GetOps();"
-        "  return GetOps(picture);"
-        "};"
-        "chrome.skiaBenchmarking.getOpTimings = function(picture) {"
-        "  /* "
-        "     Returns timing information for the given picture."
-        "     @param {Object} picture A json-encoded cc::Picture."
-        "     @returns { 'total_time': {Number}, 'cmd_times': [Number, ...] }"
-        "     @returns undefined if the arguments are invalid or the picture"
-        "                        version is not supported."
-        "   */"
-        "  native function GetOpTimings();"
-        "  return GetOpTimings(picture);"
-        "};"
-        "chrome.skiaBenchmarking.getInfo = function(picture) {"
-        "  /* "
-        "     Returns meta information for the given picture."
-        "     @param {Object} picture A base64 encoded SKP."
-        "     @returns { 'width': {Number}, 'height': {Number} }"
-        "     @returns undefined if the picture version is not supported."
-        "   */"
-        "  native function GetInfo();"
-        "  return GetInfo(picture);"
-        "};"
-        ) {
-      content::SkiaBenchmarkingExtension::InitSkGraphics();
-  }
-
-  virtual v8::Handle<v8::FunctionTemplate> GetNativeFunctionTemplate(
-      v8::Isolate* isolate,
-      v8::Handle<v8::String> name) OVERRIDE {
-    if (name->Equals(v8::String::NewFromUtf8(isolate, "Rasterize")))
-      return v8::FunctionTemplate::New(isolate, Rasterize);
-    if (name->Equals(v8::String::NewFromUtf8(isolate, "GetOps")))
-      return v8::FunctionTemplate::New(isolate, GetOps);
-    if (name->Equals(v8::String::NewFromUtf8(isolate, "GetOpTimings")))
-      return v8::FunctionTemplate::New(isolate, GetOpTimings);
-    if (name->Equals(v8::String::NewFromUtf8(isolate, "GetInfo")))
-      return v8::FunctionTemplate::New(isolate, GetInfo);
-
-    return v8::Handle<v8::FunctionTemplate>();
-  }
-
-  static void Rasterize(const v8::FunctionCallbackInfo<v8::Value>& args) {
-    if (args.Length() < 1)
-      return;
-
-    v8::Isolate* isolate = args.GetIsolate();
-    scoped_refptr<cc::Picture> picture = ParsePictureHash(isolate, args[0]);
-    if (!picture.get())
-      return;
-
-    double scale = 1.0;
-    gfx::Rect clip_rect(picture->LayerRect());
-    int stop_index = -1;
-    bool overdraw = false;
-
-    if (args.Length() > 1) {
-      scoped_ptr<content::V8ValueConverter> converter(
-          content::V8ValueConverter::create());
-      scoped_ptr<base::Value> params_value(
-          converter->FromV8Value(args[1], isolate->GetCurrentContext()));
-
-      const base::DictionaryValue* params_dict = NULL;
-      if (params_value.get() && params_value->GetAsDictionary(&params_dict)) {
-        params_dict->GetDouble("scale", &scale);
-        params_dict->GetInteger("stop", &stop_index);
-        params_dict->GetBoolean("overdraw", &overdraw);
-
-        const base::Value* clip_value = NULL;
-        if (params_dict->Get("clip", &clip_value))
-          cc::MathUtil::FromValue(clip_value, &clip_rect);
-      }
+}  // namespace
+
+gin::WrapperInfo SkiaBenchmarking::kWrapperInfo = {gin::kEmbedderNativeGin};
+
+// static
+void SkiaBenchmarking::Install(blink::WebFrame* frame) {
+  v8::Isolate* isolate = blink::mainThreadIsolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
+  if (context.IsEmpty())
+    return;
+
+  v8::Context::Scope context_scope(context);
+
+  gin::Handle<SkiaBenchmarking> controller =
+      gin::CreateHandle(isolate, new SkiaBenchmarking());
+  v8::Handle<v8::Object> global = context->Global();
+  v8::Handle<v8::Object> chrome =
+      global->Get(gin::StringToV8(isolate, "chrome"))->ToObject();
+  if (chrome.IsEmpty()) {
+    chrome = v8::Object::New(isolate);
+    global->Set(gin::StringToV8(isolate, "chrome"), chrome);
+  }
+  chrome->Set(gin::StringToV8(isolate, "skiaBenchmarking"), controller.ToV8());
+}
+
+// static
+void SkiaBenchmarking::Initialize() {
+  DCHECK(RenderThreadImpl::current());
+  // FIXME: remove this after Skia updates SkGraphics::Init() to be
+  //        thread-safe and idempotent.
+  static bool skia_initialized = false;
+  if (!skia_initialized) {
+    LOG(WARNING) << "Enabling unsafe Skia benchmarking extension.";
+    SkGraphics::Init();
+    skia_initialized = true;
+  }
+}
+
+SkiaBenchmarking::SkiaBenchmarking() {
+  Initialize();
+}
+
+SkiaBenchmarking::~SkiaBenchmarking() {}
+
+gin::ObjectTemplateBuilder SkiaBenchmarking::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return gin::Wrappable<SkiaBenchmarking>::GetObjectTemplateBuilder(isolate)
+      .SetMethod("rasterize", &SkiaBenchmarking::Rasterize)
+      .SetMethod("getOps", &SkiaBenchmarking::GetOps)
+      .SetMethod("getOpTimings", &SkiaBenchmarking::GetOpTimings)
+      .SetMethod("getInfo", &SkiaBenchmarking::GetInfo);
+}
+
+void SkiaBenchmarking::Rasterize(gin::Arguments* args) {
+  v8::Isolate* isolate = args->isolate();
+  if (args->PeekNext().IsEmpty())
+    return;
+  v8::Handle<v8::Value> picture_handle;
+  args->GetNext(&picture_handle);
+  scoped_refptr<cc::Picture> picture =
+      ParsePictureHash(isolate, picture_handle);
+  if (!picture.get())
+    return;
+
+  double scale = 1.0;
+  gfx::Rect clip_rect(picture->LayerRect());
+  int stop_index = -1;
+  bool overdraw = false;
+
+  if (!args->PeekNext().IsEmpty()) {
+    v8::Handle<v8::Value> params;
+    args->GetNext(&params);
+    scoped_ptr<content::V8ValueConverter> converter(
+        content::V8ValueConverter::create());
+    scoped_ptr<base::Value> params_value(
+        converter->FromV8Value(params, isolate->GetCurrentContext()));
+
+    const base::DictionaryValue* params_dict = NULL;
+    if (params_value.get() && params_value->GetAsDictionary(&params_dict)) {
+      params_dict->GetDouble("scale", &scale);
+      params_dict->GetInteger("stop", &stop_index);
+      params_dict->GetBoolean("overdraw", &overdraw);
+
+      const base::Value* clip_value = NULL;
+      if (params_dict->Get("clip", &clip_value))
+        cc::MathUtil::FromValue(clip_value, &clip_rect);
     }
-
-    gfx::RectF clip(clip_rect);
-    clip.Intersect(picture->LayerRect());
-    clip.Scale(scale);
-    gfx::Rect snapped_clip = gfx::ToEnclosingRect(clip);
-
-    const int kMaxBitmapSize = 4096;
-    if (snapped_clip.width() > kMaxBitmapSize
-        || snapped_clip.height() > kMaxBitmapSize)
-      return;
-
-    SkBitmap bitmap;
-    bitmap.setConfig(SkBitmap::kARGB_8888_Config, snapped_clip.width(),
-                     snapped_clip.height());
-    if (!bitmap.allocPixels())
-      return;
-    bitmap.eraseARGB(0, 0, 0, 0);
-
-    SkCanvas canvas(bitmap);
-    canvas.translate(SkFloatToScalar(-clip.x()),
-                     SkFloatToScalar(-clip.y()));
-    canvas.clipRect(gfx::RectToSkRect(snapped_clip));
-    canvas.scale(scale, scale);
-    canvas.translate(picture->LayerRect().x(),
-                     picture->LayerRect().y());
-
-    // First, build a debug canvas for the given picture.
-    SkDebugCanvas debug_canvas(picture->LayerRect().width(),
-                               picture->LayerRect().height());
-    picture->Replay(&debug_canvas);
-
-    // Raster the requested command subset into the bitmap-backed canvas.
-    int last_index = debug_canvas.getSize() - 1;
-    if (last_index >= 0) {
-        debug_canvas.setOverdrawViz(overdraw);
-        debug_canvas.drawTo(&canvas, stop_index < 0
-                            ? last_index
-                            : std::min(last_index, stop_index));
+  }
+
+  gfx::RectF clip(clip_rect);
+  clip.Intersect(picture->LayerRect());
+  clip.Scale(scale);
+  gfx::Rect snapped_clip = gfx::ToEnclosingRect(clip);
+
+  const int kMaxBitmapSize = 4096;
+  if (snapped_clip.width() > kMaxBitmapSize ||
+      snapped_clip.height() > kMaxBitmapSize)
+    return;
+
+  SkBitmap bitmap;
+  bitmap.setConfig(
+      SkBitmap::kARGB_8888_Config, snapped_clip.width(), snapped_clip.height());
+  if (!bitmap.allocPixels())
+    return;
+  bitmap.eraseARGB(0, 0, 0, 0);
+
+  SkCanvas canvas(bitmap);
+  canvas.translate(SkFloatToScalar(-clip.x()), SkFloatToScalar(-clip.y()));
+  canvas.clipRect(gfx::RectToSkRect(snapped_clip));
+  canvas.scale(scale, scale);
+  canvas.translate(picture->LayerRect().x(), picture->LayerRect().y());
+
+  // First, build a debug canvas for the given picture.
+  SkDebugCanvas debug_canvas(picture->LayerRect().width(),
+                             picture->LayerRect().height());
+  picture->Replay(&debug_canvas);
+
+  // Raster the requested command subset into the bitmap-backed canvas.
+  int last_index = debug_canvas.getSize() - 1;
+  if (last_index >= 0) {
+    debug_canvas.setOverdrawViz(overdraw);
+    debug_canvas.drawTo(
+        &canvas,
+        stop_index < 0 ? last_index : std::min(last_index, stop_index));
+  }
+
+  blink::WebArrayBuffer buffer =
+      blink::WebArrayBuffer::create(bitmap.getSize(), 1);
+  uint32* packed_pixels = reinterpret_cast<uint32*>(bitmap.getPixels());
+  uint8* buffer_pixels = reinterpret_cast<uint8*>(buffer.data());
+  // Swizzle from native Skia format to RGBA as we copy out.
+  for (size_t i = 0; i < bitmap.getSize(); i += 4) {
+    uint32 c = packed_pixels[i >> 2];
+    buffer_pixels[i] = SkGetPackedR32(c);
+    buffer_pixels[i + 1] = SkGetPackedG32(c);
+    buffer_pixels[i + 2] = SkGetPackedB32(c);
+    buffer_pixels[i + 3] = SkGetPackedA32(c);
+  }
+
+  v8::Handle<v8::Object> result = v8::Object::New(isolate);
+  result->Set(v8::String::NewFromUtf8(isolate, "width"),
+              v8::Number::New(isolate, snapped_clip.width()));
+  result->Set(v8::String::NewFromUtf8(isolate, "height"),
+              v8::Number::New(isolate, snapped_clip.height()));
+  result->Set(v8::String::NewFromUtf8(isolate, "data"), buffer.toV8Value());
+
+  args->Return(result);
+}
+
+void SkiaBenchmarking::GetOps(gin::Arguments* args) {
+  v8::Isolate* isolate = args->isolate();
+  if (args->PeekNext().IsEmpty())
+    return;
+  v8::Handle<v8::Value> picture_handle;
+  args->GetNext(&picture_handle);
+  scoped_refptr<cc::Picture> picture =
+      ParsePictureHash(isolate, picture_handle);
+  if (!picture.get())
+    return;
+
+  gfx::Rect bounds = picture->LayerRect();
+  SkDebugCanvas canvas(bounds.width(), bounds.height());
+  picture->Replay(&canvas);
+
+  v8::Handle<v8::Array> result = v8::Array::New(isolate, canvas.getSize());
+  for (int i = 0; i < canvas.getSize(); ++i) {
+    DrawType cmd_type = canvas.getDrawCommandAt(i)->getType();
+    v8::Handle<v8::Object> cmd = v8::Object::New(isolate);
+    cmd->Set(v8::String::NewFromUtf8(isolate, "cmd_type"),
+             v8::Integer::New(isolate, cmd_type));
+    cmd->Set(v8::String::NewFromUtf8(isolate, "cmd_string"),
+             v8::String::NewFromUtf8(
+                 isolate, SkDrawCommand::GetCommandString(cmd_type)));
+
+    SkTDArray<SkString*>* info = canvas.getCommandInfo(i);
+    DCHECK(info);
+
+    v8::Local<v8::Array> v8_info = v8::Array::New(isolate, info->count());
+    for (int j = 0; j < info->count(); ++j) {
+      const SkString* info_str = (*info)[j];
+      DCHECK(info_str);
+      v8_info->Set(j, v8::String::NewFromUtf8(isolate, info_str->c_str()));
     }
 
-    blink::WebArrayBuffer buffer =
-        blink::WebArrayBuffer::create(bitmap.getSize(), 1);
-    uint32* packed_pixels = reinterpret_cast<uint32*>(bitmap.getPixels());
-    uint8* buffer_pixels = reinterpret_cast<uint8*>(buffer.data());
-    // Swizzle from native Skia format to RGBA as we copy out.
-    for (size_t i = 0; i < bitmap.getSize(); i += 4) {
-        uint32 c = packed_pixels[i >> 2];
-        buffer_pixels[i]     = SkGetPackedR32(c);
-        buffer_pixels[i + 1] = SkGetPackedG32(c);
-        buffer_pixels[i + 2] = SkGetPackedB32(c);
-        buffer_pixels[i + 3] = SkGetPackedA32(c);
-    }
-
-    v8::Handle<v8::Object> result = v8::Object::New(isolate);
-    result->Set(v8::String::NewFromUtf8(isolate, "width"),
-                v8::Number::New(isolate, snapped_clip.width()));
-    result->Set(v8::String::NewFromUtf8(isolate, "height"),
-                v8::Number::New(isolate, snapped_clip.height()));
-    result->Set(v8::String::NewFromUtf8(isolate, "data"), buffer.toV8Value());
-
-    args.GetReturnValue().Set(result);
-  }
-
-  static void GetOps(const v8::FunctionCallbackInfo<v8::Value>& args) {
-    if (args.Length() != 1)
-      return;
-
-    v8::Isolate* isolate = args.GetIsolate();
-    scoped_refptr<cc::Picture> picture = ParsePictureHash(isolate, args[0]);
-    if (!picture.get())
-      return;
-
-    gfx::Rect bounds = picture->LayerRect();
-    SkDebugCanvas canvas(bounds.width(), bounds.height());
-    picture->Replay(&canvas);
-
-    v8::Local<v8::Array> result = v8::Array::New(isolate, canvas.getSize());
-    for (int i = 0; i < canvas.getSize(); ++i) {
-      DrawType cmd_type = canvas.getDrawCommandAt(i)->getType();
-      v8::Handle<v8::Object> cmd = v8::Object::New(isolate);
-      cmd->Set(v8::String::NewFromUtf8(isolate, "cmd_type"),
-               v8::Integer::New(isolate, cmd_type));
-      cmd->Set(v8::String::NewFromUtf8(isolate, "cmd_string"),
-               v8::String::NewFromUtf8(
-                   isolate, SkDrawCommand::GetCommandString(cmd_type)));
-
-      SkTDArray<SkString*>* info = canvas.getCommandInfo(i);
-      DCHECK(info);
-
-      v8::Local<v8::Array> v8_info = v8::Array::New(isolate, info->count());
-      for (int j = 0; j < info->count(); ++j) {
-        const SkString* info_str = (*info)[j];
-        DCHECK(info_str);
-        v8_info->Set(j, v8::String::NewFromUtf8(isolate, info_str->c_str()));
-      }
-
-      cmd->Set(v8::String::NewFromUtf8(isolate, "info"), v8_info);
-
-      result->Set(i, cmd);
-    }
-
-    args.GetReturnValue().Set(result);
-  }
-
-  static void GetOpTimings(const v8::FunctionCallbackInfo<v8::Value>& args) {
-    if (args.Length() != 1)
-      return;
-
-    v8::Isolate* isolate = args.GetIsolate();
-    scoped_refptr<cc::Picture> picture = ParsePictureHash(isolate, args[0]);
-    if (!picture.get())
-      return;
-
-    gfx::Rect bounds = picture->LayerRect();
-
-    // Measure the total time by drawing straight into a bitmap-backed canvas.
-    skia::RefPtr<SkBaseDevice> device = skia::AdoptRef(
-        SkNEW_ARGS(SkBitmapDevice,
-             (SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height())));
-    SkCanvas bitmap_canvas(device.get());
-    bitmap_canvas.clear(SK_ColorTRANSPARENT);
-    base::TimeTicks t0 = base::TimeTicks::HighResNow();
-    picture->Replay(&bitmap_canvas);
-    base::TimeDelta total_time = base::TimeTicks::HighResNow() - t0;
-
-    // Gather per-op timing info by drawing into a BenchmarkingCanvas.
-    skia::BenchmarkingCanvas benchmarking_canvas(bounds.width(),
-                                                 bounds.height());
-    picture->Replay(&benchmarking_canvas);
-
-    v8::Local<v8::Array> op_times =
-        v8::Array::New(isolate, benchmarking_canvas.CommandCount());
-    for (size_t i = 0; i < benchmarking_canvas.CommandCount(); ++i)
-        op_times->Set(i, v8::Number::New(isolate,
-                                         benchmarking_canvas.GetTime(i)));
-
-    v8::Handle<v8::Object> result = v8::Object::New(isolate);
-    result->Set(v8::String::NewFromUtf8(isolate, "total_time"),
-                v8::Number::New(isolate, total_time.InMillisecondsF()));
-    result->Set(v8::String::NewFromUtf8(isolate, "cmd_times"), op_times);
-
-    args.GetReturnValue().Set(result);
-  }
-
-  static void GetInfo(const v8::FunctionCallbackInfo<v8::Value>& args) {
-    if (args.Length() != 1)
-      return;
-
-    v8::Isolate* isolate = args.GetIsolate();
-    scoped_refptr<cc::Picture> picture = ParsePictureStr(isolate, args[0]);
-    if (!picture.get())
-      return;
-
-    v8::Handle<v8::Object> result = v8::Object::New(isolate);
-    result->Set(v8::String::NewFromUtf8(isolate, "width"),
-                v8::Number::New(isolate, picture->LayerRect().width()));
-    result->Set(v8::String::NewFromUtf8(isolate, "height"),
-                v8::Number::New(isolate, picture->LayerRect().height()));
-
-    args.GetReturnValue().Set(result);
-  }
-};
-
-} // namespace
-
-namespace content {
-
-v8::Extension* SkiaBenchmarkingExtension::Get() {
-  return new SkiaBenchmarkingWrapper();
-}
-
-void SkiaBenchmarkingExtension::InitSkGraphics() {
-    // Always call on the main render thread.
-    // Does not need to be thread-safe, as long as the above holds.
-    // FIXME: remove this after Skia updates SkGraphics::Init() to be
-    //        thread-safe and idempotent.
-    static bool skia_initialized = false;
-    if (!skia_initialized) {
-      SkGraphics::Init();
-      skia_initialized = true;
-    }
+    cmd->Set(v8::String::NewFromUtf8(isolate, "info"), v8_info);
+
+    result->Set(i, cmd);
+  }
+
+  args->Return(result.As<v8::Object>());
+}
+
+void SkiaBenchmarking::GetOpTimings(gin::Arguments* args) {
+  v8::Isolate* isolate = args->isolate();
+  if (args->PeekNext().IsEmpty())
+    return;
+  v8::Handle<v8::Value> picture_handle;
+  args->GetNext(&picture_handle);
+  scoped_refptr<cc::Picture> picture =
+      ParsePictureHash(isolate, picture_handle);
+  if (!picture.get())
+    return;
+
+  gfx::Rect bounds = picture->LayerRect();
+
+  // Measure the total time by drawing straight into a bitmap-backed canvas.
+  skia::RefPtr<SkBaseDevice> device = skia::AdoptRef(SkNEW_ARGS(
+      SkBitmapDevice,
+      (SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height())));
+  SkCanvas bitmap_canvas(device.get());
+  bitmap_canvas.clear(SK_ColorTRANSPARENT);
+  base::TimeTicks t0 = base::TimeTicks::HighResNow();
+  picture->Replay(&bitmap_canvas);
+  base::TimeDelta total_time = base::TimeTicks::HighResNow() - t0;
+
+  // Gather per-op timing info by drawing into a BenchmarkingCanvas.
+  skia::BenchmarkingCanvas benchmarking_canvas(bounds.width(), bounds.height());
+  picture->Replay(&benchmarking_canvas);
+
+  v8::Local<v8::Array> op_times =
+      v8::Array::New(isolate, benchmarking_canvas.CommandCount());
+  for (size_t i = 0; i < benchmarking_canvas.CommandCount(); ++i)
+    op_times->Set(i, v8::Number::New(isolate, benchmarking_canvas.GetTime(i)));
+
+  v8::Handle<v8::Object> result = v8::Object::New(isolate);
+  result->Set(v8::String::NewFromUtf8(isolate, "total_time"),
+              v8::Number::New(isolate, total_time.InMillisecondsF()));
+  result->Set(v8::String::NewFromUtf8(isolate, "cmd_times"), op_times);
+
+  args->Return(result);
+}
+
+void SkiaBenchmarking::GetInfo(gin::Arguments* args) {
+  v8::Isolate* isolate = args->isolate();
+  if (args->PeekNext().IsEmpty())
+    return;
+  v8::Handle<v8::Value> picture_handle;
+  args->GetNext(&picture_handle);
+  scoped_refptr<cc::Picture> picture =
+      ParsePictureStr(isolate, picture_handle);
+  if (!picture.get())
+    return;
+
+  v8::Handle<v8::Object> result = v8::Object::New(isolate);
+  result->Set(v8::String::NewFromUtf8(isolate, "width"),
+              v8::Number::New(isolate, picture->LayerRect().width()));
+  result->Set(v8::String::NewFromUtf8(isolate, "height"),
+              v8::Number::New(isolate, picture->LayerRect().height()));
+
+  args->Return(result);
 }
 
 } // namespace content