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
ParsePictureArg(v8::Isolate * isolate,v8::Handle<v8::Value> arg)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
ParsePictureStr(v8::Isolate * isolate,v8::Handle<v8::Value> arg)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
ParsePictureHash(v8::Isolate * isolate,v8::Handle<v8::Value> arg)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
Install(blink::WebFrame * frame)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
Initialize()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
SkiaBenchmarking()103 SkiaBenchmarking::SkiaBenchmarking() {
104 Initialize();
105 }
106
~SkiaBenchmarking()107 SkiaBenchmarking::~SkiaBenchmarking() {}
108
GetObjectTemplateBuilder(v8::Isolate * isolate)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
Rasterize(gin::Arguments * args)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(¶ms);
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(¶ms_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
GetOps(gin::Arguments * args)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
GetOpTimings(gin::Arguments * args)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
GetInfo(gin::Arguments * args)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