// 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 "skia/ext/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/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 {
const char kSkiaBenchmarkingExtensionName[] = "v8/SkiaBenchmarking";
static 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_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_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(¶ms_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));
}
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();
result->Set(v8::String::NewFromUtf8(isolate, "width"),
v8::Number::New(snapped_clip.width()));
result->Set(v8::String::NewFromUtf8(isolate, "height"),
v8::Number::New(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();
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(benchmarking_canvas.GetTime(i)));
v8::Handle<v8::Object> result = v8::Object::New(isolate);
result->Set(v8::String::NewFromUtf8(isolate, "total_time"),
v8::Number::New(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(picture->LayerRect().width()));
result->Set(v8::String::NewFromUtf8(isolate, "height"),
v8::Number::New(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;
}
}
} // namespace content