Refactor BenchmarkingCanvas to avoid internal Skia dependencies

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/child/v8_value_converter.h"
 #include "content/renderer/chrome_object_extensions_utils.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/web/WebArrayBuffer.h"
 #include "third_party/WebKit/public/web/WebArrayBufferConverter.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebKit.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/SkPicture.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/geometry/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "v8/include/v8.h"
 
 namespace content {
 
 namespace {
 
 scoped_ptr<base::Value> ParsePictureArg(v8::Isolate* isolate,
                                         v8::Handle<v8::Value> arg) {
@@ skipping 12 matching lines @@
 }
 
 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 PicturePlaybackController : public SkPicture::AbortCallback {
+public:
+  PicturePlaybackController(const skia::BenchmarkingCanvas& canvas,
+                            size_t count)
+      : canvas_(canvas)
+      , playback_count_(count) {
+  }
+
+  bool abort() override {
+      return canvas_.CommandCount() > playback_count_;
+  }
+
+private:
+  const skia::BenchmarkingCanvas& canvas_;
+  size_t playback_count_;
+};
+
 }  // 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())
@@ skipping 85 matching lines @@
   if (!bitmap.tryAllocN32Pixels(snapped_clip.width(), snapped_clip.height()))
     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));
-  }
+  // FIXME: no overdraw support ATM.

[pdr., 2015/02/20 04:48:00]

Maybe we should just take this out? Overdraw seems useful but I've never
actually seen someone use it.

[f(malita), 2015/02/20 13:57:00]

Sounds reasonable. The only reason I'm hesitating is that I expect it to be
fairly easy to implement (just a custom color filter or xfermode to be slapped
onto each panint).

+  skia::BenchmarkingCanvas benchmarking_canvas(&canvas);
+  size_t playback_count = (stop_index < 0) ?
+      std::numeric_limits<size_t>::max() : stop_index;
+  PicturePlaybackController controller(benchmarking_canvas, playback_count);
+  picture->Replay(&benchmarking_canvas, &controller);
 
   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);
@@ skipping 17 matching lines @@
   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);
+  SkCanvas canvas(picture->LayerRect().width(),
+                  picture->LayerRect().height());
+  skia::BenchmarkingCanvas benchmarking_canvas(&canvas);
+  picture->Replay(&benchmarking_canvas);
 
-  v8::Handle<v8::Array> result = v8::Array::New(isolate, canvas.getSize());
-  for (int i = 0; i < canvas.getSize(); ++i) {
-    SkDrawCommand::OpType 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)));
+  v8::Handle<v8::Context> context = isolate->GetCurrentContext();
+  scoped_ptr<content::V8ValueConverter> converter(
+      content::V8ValueConverter::create());
 
-    const 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->Return(result.As<v8::Object>());
+  args->Return(converter->ToV8Value(&benchmarking_canvas.Commands(), context));
 }
 
 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.
   SkBitmap bitmap;
   bitmap.allocN32Pixels(bounds.width(), bounds.height());
   SkCanvas bitmap_canvas(bitmap);
   bitmap_canvas.clear(SK_ColorTRANSPARENT);
   base::TimeTicks t0 = base::TimeTicks::Now();
   picture->Replay(&bitmap_canvas);
   base::TimeDelta total_time = base::TimeTicks::Now() - t0;
 
   // Gather per-op timing info by drawing into a BenchmarkingCanvas.
-  skia::BenchmarkingCanvas benchmarking_canvas(bounds.width(), bounds.height());
+  SkCanvas canvas(bitmap);
+  canvas.clear(SK_ColorTRANSPARENT);
+  skia::BenchmarkingCanvas benchmarking_canvas(&canvas);
   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)
+  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) {
@@ skipping 10 matching lines @@
   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