Add skiaBenchmarking.getOps()

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/values.h"
 #include "cc/resources/picture.h"
 #include "content/public/renderer/v8_value_converter.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebArrayBuffer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.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/src/utils/debugger/SkDebugCanvas.h"
+#include "third_party/skia/src/utils/debugger/SkDrawCommand.h"
 #include "ui/gfx/rect_conversions.h"
 #include "v8/include/v8.h"
 
 using WebKit::WebFrame;
 
 namespace {
 
 const char kSkiaBenchmarkingExtensionName[] = "v8/SkiaBenchmarking";
 
+static scoped_refptr<cc::Picture> ParsePictureArg(v8::Handle<v8::Value> arg) {
+  scoped_ptr<content::V8ValueConverter> converter(
+      content::V8ValueConverter::create());
+
+  v8::String::Value v8_picture(arg);
+  scoped_ptr<base::Value> picture_value(
+      converter->FromV8Value(arg, v8::Context::GetCurrent()));
+  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, scale, rect) {"
         "  /* "
         "     Rasterizes a Picture JSON-encoded by cc::Picture::AsValue()."
         "     @param {Object} picture A json-encoded cc::Picture."
         "     @param {Number} scale (optional) Rendering scale."
         "     @param [Number, Number, Number, Number] clip_rect (optional)."
         "     @returns { 'width': {Number}, 'height': {Number},"
         "                'data': {ArrayBuffer} }"
         "   */"
         "  native function Rasterize();"
         "  return Rasterize(picture, scale, rect);"
         "};"
+        "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, ...] }, ...]"

[nduca, 2013/06/11 23:52:13]

define in the docs that undefined is returned when the picture is an old version
and wont load... 

[f(malita), 2013/06/12 13:32:37]

Ok.

+        "   */"
+        "  native function GetOps();"
+        "  return GetOps(picture);"
+        "};"
         ) {
       content::SkiaBenchmarkingExtension::InitSkGraphics();
   }
 
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<v8::String> name) OVERRIDE {
     if (name->Equals(v8::String::New("Rasterize")))
       return v8::FunctionTemplate::New(Rasterize);
+    if (name->Equals(v8::String::New("GetOps")))
+      return v8::FunctionTemplate::New(GetOps);
 
     return v8::Handle<v8::FunctionTemplate>();
   }
 
   static v8::Handle<v8::Value> Rasterize(const v8::Arguments& args) {
     if (args.Length() < 1)
       return v8::Undefined();
 
-    WebFrame* web_frame = WebFrame::frameForCurrentContext();
-    if (!web_frame)
-      return v8::Undefined();
-
-    scoped_ptr<content::V8ValueConverter> converter(
-        content::V8ValueConverter::create());
-
-    v8::String::Value v8_picture(args[0]);
-    scoped_ptr<base::Value> picture_value(
-        converter->FromV8Value(
-            args[0], v8::Context::GetCurrent()));
-    if (!picture_value)
-      return v8::Undefined();
-
-    scoped_refptr<cc::Picture> picture =
-        cc::Picture::CreateFromValue(picture_value.get());
+    scoped_refptr<cc::Picture> picture = ParsePictureArg(args[0]);
     if (!picture.get())
       return v8::Undefined();
 
     float scale = 1.0f;
     if (args.Length() > 1 && args[1]->IsNumber())
       scale = std::max(0.01, std::min(100.0, args[1]->NumberValue()));
 
     gfx::RectF clip(picture->LayerRect());
     if (args.Length() > 2 && args[2]->IsArray()) {
       v8::Array* a = v8::Array::Cast(*args[2]);
@@ skipping 45 matching lines @@
 
     v8::Handle<v8::Object> result = v8::Object::New();
     result->Set(v8::String::New("width"),
                 v8::Number::New(snapped_clip.width()));
     result->Set(v8::String::New("height"),
                 v8::Number::New(snapped_clip.height()));
     result->Set(v8::String::New("data"), buffer.toV8Value());
 
     return result;
   }
+
+  static v8::Handle<v8::Value> GetOps(const v8::Arguments& args) {
+    if (args.Length() != 1)
+      return v8::Undefined();
+
+    scoped_refptr<cc::Picture> picture = ParsePictureArg(args[0]);
+    if (!picture.get())
+      return v8::Undefined();
+
+    gfx::Rect bounds = picture->LayerRect();
+    SkDebugCanvas canvas(bounds.width(), bounds.height());
+    canvas.setBounds(bounds.width(), bounds.height());
+    picture->Raster(&canvas, NULL, bounds, 1.0f);
+
+    v8::Local<v8::Array> result = v8::Array::New(canvas.getSize());
+    for (int i = 0; i < canvas.getSize(); ++i) {
+      v8::Handle<v8::Object> cmd = v8::Object::New();
+      cmd->Set(v8::String::New("cmd"), v8::String::New(
+          SkDrawCommand::GetCommandString(
+              canvas.getDrawCommandAt(i)->getType())));
+
+      SkTDArray<SkString*>* info = canvas.getCommandInfo(i);

[nduca, 2013/06/11 23:52:13]

what is in the info? what is mandatory and what is optional? We dont want a roll
of skia to randomly break the frame viewer.

Lets make a _unittest.cc for this file, and add some tests that record a
picture, then get cmd info on it and asser tthat the things we expect to require
are in this array. That way a skia deps roll will explode at the right time.

[f(malita), 2013/06/12 13:32:37]

This is based on the current Skia debugger backend, where the format is loosely
defined and we probably shouldn't use info for anything beyond displaying the
strings (same as the Skia debugger does).

The plan is to revisit the debugger backend classes, and clean-up all this
(https://code.google.com/p/skia/issues/detail?id=1341). Ideally we'll end up
with some form of serialization for draw command parameters, and proper v8
wrapper types. At that point we can start relying on info fields and capture the
behavior in unit tests.

It would make sense to wait for the Skia cleanup before adding this, but pdr
suggested that you guys are blocked on getOps and even a simple command list
would help.

+      if (info) {

[nduca, 2013/06/11 23:52:13]

why would info not be returned? It seems odd that some will have info and some
not.... we should clarify that too

[f(malita), 2013/06/12 13:32:37]

Was following Skia use here, but you're right - it cannot be null. The list can
be empty thought for commands with no args (restore, etc), but that is guarded
below.

+        v8::Local<v8::Array> v8_info = v8::Array::New(info->count());
+        for (int j = 0; j < info->count(); ++j)
+          v8_info->Set(j, v8::String::New(info->getAt(j)->c_str()));
+
+        cmd->Set(v8::String::New("info"), v8_info);
+      }
+
+      result->Set(i, cmd);
+    }
+
+    return 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;
     }
 }
 
 } // namespace content