[SkiaBenchmarkingExtension] Add draw command timing info.

content/renderer/skia_benchmarking/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 "content/renderer/skia_benchmarking/skia_benchmarking_extension.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/skia_benchmarking/skia_benchmarking_canvas.h"
 #include "third_party/WebKit/public/platform/WebArrayBuffer.h"
 #include "third_party/WebKit/public/web/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 "ui/gfx/skia_util.h"
 #include "v8/include/v8.h"
 
 using WebKit::WebFrame;
+using content::SkiaBenchmarkingCanvas;
 
 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);
@@ skipping 149 matching lines @@
   }
 
   static void GetOps(const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() != 1)
       return;
 
     scoped_refptr<cc::Picture> picture = ParsePictureArg(args[0]);
     if (!picture.get())
       return;
 
-    gfx::Rect bounds = picture->LayerRect();
-    SkDebugCanvas canvas(bounds.width(), bounds.height());
+    SkiaBenchmarkingCanvas canvas(picture->LayerRect());
     picture->Replay(&canvas);
 
-    v8::Local<v8::Array> result = v8::Array::New(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();
-      cmd->Set(v8::String::New("cmd_type"), v8::Integer::New(cmd_type));
-      cmd->Set(v8::String::New("cmd_string"), v8::String::New(
-          SkDrawCommand::GetCommandString(cmd_type)));
+    v8::Local<v8::Array> result = v8::Array::New(canvas.CommandCount());
+    for (size_t i = 0; i < canvas.CommandCount(); ++i) {
+      v8::Handle<v8::Object> v8_cmd = v8::Object::New();
+      SkDrawCommand* cmd = canvas.GetCommand(i);
+      DCHECK(cmd);
 
-      SkTDArray<SkString*>* info = canvas.getCommandInfo(i);
+      DrawType cmd_type = cmd->getType();
+      v8_cmd->Set(v8::String::New("cmd_type"), v8::Integer::New(cmd_type));
+      v8_cmd->Set(v8::String::New("cmd_string"),
+                  v8::String::New(SkDrawCommand::GetCommandString(cmd_type)));
+      v8_cmd->Set(v8::String::New("cmd_time"),
+                  v8::Number::New(canvas.GetTime(i)));
+
+      SkTDArray<SkString*>* info = cmd->Info();
       DCHECK(info);
 
       v8::Local<v8::Array> v8_info = v8::Array::New(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::New(info_str->c_str()));
       }
+      v8_cmd->Set(v8::String::New("info"), v8_info);
 
-      cmd->Set(v8::String::New("info"), v8_info);
-
-      result->Set(i, cmd);
+      result->Set(i, v8_cmd);
     }
 
     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;
     }
 }
 
 } // namespace content