Home | History | Annotate | Download | only in renderer 
      1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/renderer/skia_benchmarking_extension.h"
      6 
      7 #include "base/base64.h"
      8 #include "base/time/time.h"
      9 #include "base/values.h"
     10 #include "cc/base/math_util.h"
     11 #include "cc/resources/picture.h"
     12 #include "content/public/renderer/v8_value_converter.h"
     13 #include "content/renderer/render_thread_impl.h"
     14 #include "gin/arguments.h"
     15 #include "gin/handle.h"
     16 #include "gin/object_template_builder.h"
     17 #include "skia/ext/benchmarking_canvas.h"
     18 #include "third_party/WebKit/public/platform/WebArrayBuffer.h"
     19 #include "third_party/WebKit/public/web/WebArrayBufferConverter.h"
     20 #include "third_party/WebKit/public/web/WebFrame.h"
     21 #include "third_party/WebKit/public/web/WebKit.h"
     22 #include "third_party/skia/include/core/SkCanvas.h"
     23 #include "third_party/skia/include/core/SkColorPriv.h"
     24 #include "third_party/skia/include/core/SkGraphics.h"
     25 #include "third_party/skia/include/core/SkStream.h"
     26 #include "third_party/skia/src/utils/debugger/SkDebugCanvas.h"
     27 #include "third_party/skia/src/utils/debugger/SkDrawCommand.h"
     28 #include "ui/gfx/rect_conversions.h"
     29 #include "ui/gfx/skia_util.h"
     30 #include "v8/include/v8.h"
     31 
     32 
     33 namespace content {
     34 
     35 namespace {
     36 
     37 scoped_ptr<base::Value> ParsePictureArg(v8::Isolate* isolate,
     38                                         v8::Handle<v8::Value> arg) {
     39   scoped_ptr<content::V8ValueConverter> converter(
     40       content::V8ValueConverter::create());
     41   return scoped_ptr<base::Value>(
     42       converter->FromV8Value(arg, isolate->GetCurrentContext()));
     43 }
     44 
     45 scoped_refptr<cc::Picture> ParsePictureStr(v8::Isolate* isolate,
     46                                            v8::Handle<v8::Value> arg) {
     47   scoped_ptr<base::Value> picture_value = ParsePictureArg(isolate, arg);
     48   if (!picture_value)
     49     return NULL;
     50   return cc::Picture::CreateFromSkpValue(picture_value.get());
     51 }
     52 
     53 scoped_refptr<cc::Picture> ParsePictureHash(v8::Isolate* isolate,
     54                                             v8::Handle<v8::Value> arg) {
     55   scoped_ptr<base::Value> picture_value = ParsePictureArg(isolate, arg);
     56   if (!picture_value)
     57     return NULL;
     58   return cc::Picture::CreateFromValue(picture_value.get());
     59 }
     60 
     61 }  // namespace
     62 
     63 gin::WrapperInfo SkiaBenchmarking::kWrapperInfo = {gin::kEmbedderNativeGin};
     64 
     65 // static
     66 void SkiaBenchmarking::Install(blink::WebFrame* frame) {
     67   v8::Isolate* isolate = blink::mainThreadIsolate();
     68   v8::HandleScope handle_scope(isolate);
     69   v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
     70   if (context.IsEmpty())
     71     return;
     72 
     73   v8::Context::Scope context_scope(context);
     74 
     75   gin::Handle<SkiaBenchmarking> controller =
     76       gin::CreateHandle(isolate, new SkiaBenchmarking());
     77   if (controller.IsEmpty())
     78     return;
     79 
     80   v8::Handle<v8::Object> global = context->Global();
     81   v8::Handle<v8::Object> chrome =
     82       global->Get(gin::StringToV8(isolate, "chrome"))->ToObject();
     83   if (chrome.IsEmpty()) {
     84     chrome = v8::Object::New(isolate);
     85     global->Set(gin::StringToV8(isolate, "chrome"), chrome);
     86   }
     87   chrome->Set(gin::StringToV8(isolate, "skiaBenchmarking"), controller.ToV8());
     88 }
     89 
     90 // static
     91 void SkiaBenchmarking::Initialize() {
     92   DCHECK(RenderThreadImpl::current());
     93   // FIXME: remove this after Skia updates SkGraphics::Init() to be
     94   //        thread-safe and idempotent.
     95   static bool skia_initialized = false;
     96   if (!skia_initialized) {
     97     LOG(WARNING) << "Enabling unsafe Skia benchmarking extension.";
     98     SkGraphics::Init();
     99     skia_initialized = true;
    100   }
    101 }
    102 
    103 SkiaBenchmarking::SkiaBenchmarking() {
    104   Initialize();
    105 }
    106 
    107 SkiaBenchmarking::~SkiaBenchmarking() {}
    108 
    109 gin::ObjectTemplateBuilder SkiaBenchmarking::GetObjectTemplateBuilder(
    110     v8::Isolate* isolate) {
    111   return gin::Wrappable<SkiaBenchmarking>::GetObjectTemplateBuilder(isolate)
    112       .SetMethod("rasterize", &SkiaBenchmarking::Rasterize)
    113       .SetMethod("getOps", &SkiaBenchmarking::GetOps)
    114       .SetMethod("getOpTimings", &SkiaBenchmarking::GetOpTimings)
    115       .SetMethod("getInfo", &SkiaBenchmarking::GetInfo);
    116 }
    117 
    118 void SkiaBenchmarking::Rasterize(gin::Arguments* args) {
    119   v8::Isolate* isolate = args->isolate();
    120   if (args->PeekNext().IsEmpty())
    121     return;
    122   v8::Handle<v8::Value> picture_handle;
    123   args->GetNext(&picture_handle);
    124   scoped_refptr<cc::Picture> picture =
    125       ParsePictureHash(isolate, picture_handle);
    126   if (!picture.get())
    127     return;
    128 
    129   double scale = 1.0;
    130   gfx::Rect clip_rect(picture->LayerRect());
    131   int stop_index = -1;
    132   bool overdraw = false;
    133 
    134   v8::Handle<v8::Context> context = isolate->GetCurrentContext();
    135   if (!args->PeekNext().IsEmpty()) {
    136     v8::Handle<v8::Value> params;
    137     args->GetNext(&params);
    138     scoped_ptr<content::V8ValueConverter> converter(
    139         content::V8ValueConverter::create());
    140     scoped_ptr<base::Value> params_value(
    141         converter->FromV8Value(params, context));
    142 
    143     const base::DictionaryValue* params_dict = NULL;
    144     if (params_value.get() && params_value->GetAsDictionary(&params_dict)) {
    145       params_dict->GetDouble("scale", &scale);
    146       params_dict->GetInteger("stop", &stop_index);
    147       params_dict->GetBoolean("overdraw", &overdraw);
    148 
    149       const base::Value* clip_value = NULL;
    150       if (params_dict->Get("clip", &clip_value))
    151         cc::MathUtil::FromValue(clip_value, &clip_rect);
    152     }
    153   }
    154 
    155   gfx::RectF clip(clip_rect);
    156   clip.Intersect(picture->LayerRect());
    157   clip.Scale(scale);
    158   gfx::Rect snapped_clip = gfx::ToEnclosingRect(clip);
    159 
    160   SkBitmap bitmap;
    161   if (!bitmap.setConfig(SkBitmap::kARGB_8888_Config, snapped_clip.width(),
    162                         snapped_clip.height()))
    163     return;
    164   if (!bitmap.allocPixels())
    165     return;
    166   bitmap.eraseARGB(0, 0, 0, 0);
    167 
    168   SkCanvas canvas(bitmap);
    169   canvas.translate(SkFloatToScalar(-clip.x()), SkFloatToScalar(-clip.y()));
    170   canvas.clipRect(gfx::RectToSkRect(snapped_clip));
    171   canvas.scale(scale, scale);
    172   canvas.translate(picture->LayerRect().x(), picture->LayerRect().y());
    173 
    174   // First, build a debug canvas for the given picture.
    175   SkDebugCanvas debug_canvas(picture->LayerRect().width(),
    176                              picture->LayerRect().height());
    177   picture->Replay(&debug_canvas);
    178 
    179   // Raster the requested command subset into the bitmap-backed canvas.
    180   int last_index = debug_canvas.getSize() - 1;
    181   if (last_index >= 0) {
    182     debug_canvas.setOverdrawViz(overdraw);
    183     debug_canvas.drawTo(
    184         &canvas,
    185         stop_index < 0 ? last_index : std::min(last_index, stop_index));
    186   }
    187 
    188   blink::WebArrayBuffer buffer =
    189       blink::WebArrayBuffer::create(bitmap.getSize(), 1);
    190   uint32* packed_pixels = reinterpret_cast<uint32*>(bitmap.getPixels());
    191   uint8* buffer_pixels = reinterpret_cast<uint8*>(buffer.data());
    192   // Swizzle from native Skia format to RGBA as we copy out.
    193   for (size_t i = 0; i < bitmap.getSize(); i += 4) {
    194     uint32 c = packed_pixels[i >> 2];
    195     buffer_pixels[i] = SkGetPackedR32(c);
    196     buffer_pixels[i + 1] = SkGetPackedG32(c);
    197     buffer_pixels[i + 2] = SkGetPackedB32(c);
    198     buffer_pixels[i + 3] = SkGetPackedA32(c);
    199   }
    200 
    201   v8::Handle<v8::Object> result = v8::Object::New(isolate);
    202   result->Set(v8::String::NewFromUtf8(isolate, "width"),
    203               v8::Number::New(isolate, snapped_clip.width()));
    204   result->Set(v8::String::NewFromUtf8(isolate, "height"),
    205               v8::Number::New(isolate, snapped_clip.height()));
    206   result->Set(v8::String::NewFromUtf8(isolate, "data"),
    207               blink::WebArrayBufferConverter::toV8Value(
    208                   &buffer, context->Global(), isolate));
    209 
    210   args->Return(result);
    211 }
    212 
    213 void SkiaBenchmarking::GetOps(gin::Arguments* args) {
    214   v8::Isolate* isolate = args->isolate();
    215   if (args->PeekNext().IsEmpty())
    216     return;
    217   v8::Handle<v8::Value> picture_handle;
    218   args->GetNext(&picture_handle);
    219   scoped_refptr<cc::Picture> picture =
    220       ParsePictureHash(isolate, picture_handle);
    221   if (!picture.get())
    222     return;
    223 
    224   gfx::Rect bounds = picture->LayerRect();
    225   SkDebugCanvas canvas(bounds.width(), bounds.height());
    226   picture->Replay(&canvas);
    227 
    228   v8::Handle<v8::Array> result = v8::Array::New(isolate, canvas.getSize());
    229   for (int i = 0; i < canvas.getSize(); ++i) {
    230     DrawType cmd_type = canvas.getDrawCommandAt(i)->getType();
    231     v8::Handle<v8::Object> cmd = v8::Object::New(isolate);
    232     cmd->Set(v8::String::NewFromUtf8(isolate, "cmd_type"),
    233              v8::Integer::New(isolate, cmd_type));
    234     cmd->Set(v8::String::NewFromUtf8(isolate, "cmd_string"),
    235              v8::String::NewFromUtf8(
    236                  isolate, SkDrawCommand::GetCommandString(cmd_type)));
    237 
    238     SkTDArray<SkString*>* info = canvas.getCommandInfo(i);
    239     DCHECK(info);
    240 
    241     v8::Local<v8::Array> v8_info = v8::Array::New(isolate, info->count());
    242     for (int j = 0; j < info->count(); ++j) {
    243       const SkString* info_str = (*info)[j];
    244       DCHECK(info_str);
    245       v8_info->Set(j, v8::String::NewFromUtf8(isolate, info_str->c_str()));
    246     }
    247 
    248     cmd->Set(v8::String::NewFromUtf8(isolate, "info"), v8_info);
    249 
    250     result->Set(i, cmd);
    251   }
    252 
    253   args->Return(result.As<v8::Object>());
    254 }
    255 
    256 void SkiaBenchmarking::GetOpTimings(gin::Arguments* args) {
    257   v8::Isolate* isolate = args->isolate();
    258   if (args->PeekNext().IsEmpty())
    259     return;
    260   v8::Handle<v8::Value> picture_handle;
    261   args->GetNext(&picture_handle);
    262   scoped_refptr<cc::Picture> picture =
    263       ParsePictureHash(isolate, picture_handle);
    264   if (!picture.get())
    265     return;
    266 
    267   gfx::Rect bounds = picture->LayerRect();
    268 
    269   // Measure the total time by drawing straight into a bitmap-backed canvas.
    270   SkBitmap bitmap;
    271   bitmap.allocN32Pixels(bounds.width(), bounds.height());
    272   SkCanvas bitmap_canvas(bitmap);
    273   bitmap_canvas.clear(SK_ColorTRANSPARENT);
    274   base::TimeTicks t0 = base::TimeTicks::HighResNow();
    275   picture->Replay(&bitmap_canvas);
    276   base::TimeDelta total_time = base::TimeTicks::HighResNow() - t0;
    277 
    278   // Gather per-op timing info by drawing into a BenchmarkingCanvas.
    279   skia::BenchmarkingCanvas benchmarking_canvas(bounds.width(), bounds.height());
    280   picture->Replay(&benchmarking_canvas);
    281 
    282   v8::Local<v8::Array> op_times =
    283       v8::Array::New(isolate, benchmarking_canvas.CommandCount());
    284   for (size_t i = 0; i < benchmarking_canvas.CommandCount(); ++i)
    285     op_times->Set(i, v8::Number::New(isolate, benchmarking_canvas.GetTime(i)));
    286 
    287   v8::Handle<v8::Object> result = v8::Object::New(isolate);
    288   result->Set(v8::String::NewFromUtf8(isolate, "total_time"),
    289               v8::Number::New(isolate, total_time.InMillisecondsF()));
    290   result->Set(v8::String::NewFromUtf8(isolate, "cmd_times"), op_times);
    291 
    292   args->Return(result);
    293 }
    294 
    295 void SkiaBenchmarking::GetInfo(gin::Arguments* args) {
    296   v8::Isolate* isolate = args->isolate();
    297   if (args->PeekNext().IsEmpty())
    298     return;
    299   v8::Handle<v8::Value> picture_handle;
    300   args->GetNext(&picture_handle);
    301   scoped_refptr<cc::Picture> picture =
    302       ParsePictureStr(isolate, picture_handle);
    303   if (!picture.get())
    304     return;
    305 
    306   v8::Handle<v8::Object> result = v8::Object::New(isolate);
    307   result->Set(v8::String::NewFromUtf8(isolate, "width"),
    308               v8::Number::New(isolate, picture->LayerRect().width()));
    309   result->Set(v8::String::NewFromUtf8(isolate, "height"),
    310               v8::Number::New(isolate, picture->LayerRect().height()));
    311 
    312   args->Return(result);
    313 }
    314 
    315 } // namespace content
    316