skia/ext/benchmarking_canvas.cc

   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 "base/logging.h"
   6 #include "base/strings/stringprintf.h"
   7 #include "base/time/time.h"
   8 #include "skia/ext/benchmarking_canvas.h"
   9 #include "third_party/skia/include/core/SkColorFilter.h"
  10 #include "third_party/skia/include/core/SkImageFilter.h"
  11 #include "third_party/skia/include/core/SkPicture.h"
  12 #include "third_party/skia/include/core/SkRegion.h"
  13 #include "third_party/skia/include/core/SkTextBlob.h"
  14 #include "third_party/skia/include/core/SkXfermode.h"
  15
  16 namespace {
  17
  18 class FlagsBuilder {
  19 public:
  20   FlagsBuilder(char separator)
  21       : separator_(separator) {}
  22
  23   void addFlag(bool flag_val, const char flag_name[]) {
  24     if (!flag_val)
  25       return;
  26     if (!oss_.str().empty())
  27       oss_ << separator_;
  28
  29     oss_ << flag_name;
  30   }
  31
  32   std::string str() const {
  33     return oss_.str();
  34   }
  35
  36 private:
  37   char separator_;
  38   std::ostringstream oss_;
  39 };
  40
  41 WARN_UNUSED_RESULT
  42 scoped_ptr<base::Value> AsValue(bool b) {
  43   scoped_ptr<base::FundamentalValue> val(new base::FundamentalValue(b));
  44
  45   return val.Pass();
  46 }
  47
  48 WARN_UNUSED_RESULT
  49 scoped_ptr<base::Value> AsValue(SkScalar scalar) {
  50   scoped_ptr<base::FundamentalValue> val(new base::FundamentalValue(scalar));
  51
  52   return val.Pass();
  53 }
  54
  55 WARN_UNUSED_RESULT
  56 scoped_ptr<base::Value> AsValue(const SkSize& size) {
  57   scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
  58   val->Set("width",  AsValue(size.width()));
  59   val->Set("height", AsValue(size.height()));
  60
  61   return val.Pass();
  62 }
  63
  64 WARN_UNUSED_RESULT
  65 scoped_ptr<base::Value> AsValue(const SkPoint& point) {
  66   scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
  67   val->Set("x", AsValue(point.x()));
  68   val->Set("y", AsValue(point.y()));
  69
  70   return val.Pass();
  71 }
  72
  73 WARN_UNUSED_RESULT
  74 scoped_ptr<base::Value> AsValue(const SkRect& rect) {
  75   scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
  76   val->Set("left", AsValue(rect.fLeft));
  77   val->Set("top", AsValue(rect.fTop));
  78   val->Set("right", AsValue(rect.fRight));
  79   val->Set("bottom", AsValue(rect.fBottom));
  80
  81   return val.Pass();
  82 }
  83
  84 WARN_UNUSED_RESULT
  85 scoped_ptr<base::Value> AsValue(const SkRRect& rrect) {
  86   scoped_ptr<base::DictionaryValue> radii_val(new base::DictionaryValue());
  87   radii_val->Set("upper-left", AsValue(rrect.radii(SkRRect::kUpperLeft_Corner)));
  88   radii_val->Set("upper-right", AsValue(rrect.radii(SkRRect::kUpperRight_Corner)));
  89   radii_val->Set("lower-right", AsValue(rrect.radii(SkRRect::kLowerRight_Corner)));
  90   radii_val->Set("lower-left", AsValue(rrect.radii(SkRRect::kLowerLeft_Corner)));
  91
  92   scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
  93   val->Set("rect", AsValue(rrect.rect()));
  94   val->Set("radii", radii_val.Pass());
  95
  96   return val.Pass();
  97 }
  98
  99 WARN_UNUSED_RESULT
 100 scoped_ptr<base::Value> AsValue(const SkMatrix& matrix) {
 101   scoped_ptr<base::ListValue> val(new base::ListValue());
 102   for (int i = 0; i < 9; ++i)
 103     val->Append(AsValue(matrix[i]).release()); // no scoped_ptr-aware Append() variant
 104
 105   return val.Pass();
 106 }
 107
 108 WARN_UNUSED_RESULT
 109 scoped_ptr<base::Value> AsValue(SkColor color) {
 110   scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
 111   val->SetInteger("a", SkColorGetA(color));
 112   val->SetInteger("r", SkColorGetR(color));
 113   val->SetInteger("g", SkColorGetG(color));
 114   val->SetInteger("b", SkColorGetB(color));
 115
 116   return val.Pass();
 117 }
 118
 119 WARN_UNUSED_RESULT
 120 scoped_ptr<base::Value> AsValue(SkXfermode::Mode mode) {
 121   scoped_ptr<base::StringValue> val(
 122       new base::StringValue(SkXfermode::ModeName(mode)));
 123
 124   return val.Pass();
 125 }
 126
 127 WARN_UNUSED_RESULT
 128 scoped_ptr<base::Value> AsValue(SkCanvas::PointMode mode) {
 129   static const char* gModeStrings[] = { "Points", "Lines", "Polygon" };
 130   DCHECK_LT(static_cast<size_t>(mode), SK_ARRAY_COUNT(gModeStrings));
 131
 132   scoped_ptr<base::StringValue> val(new base::StringValue(gModeStrings[mode]));
 133
 134   return val.Pass();
 135 }
 136
 137 WARN_UNUSED_RESULT
 138 scoped_ptr<base::Value> AsValue(const SkXfermode& xfermode) {
 139   SkXfermode::Mode mode;
 140   if (xfermode.asMode(&mode))
 141     return AsValue(mode);
 142
 143   scoped_ptr<base::StringValue> val(new base::StringValue("unknown"));
 144   return val.Pass();
 145 }
 146
 147 WARN_UNUSED_RESULT
 148 scoped_ptr<base::Value> AsValue(const SkColorFilter& filter) {
 149   scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
 150
 151   if (unsigned flags = filter.getFlags()) {
 152     FlagsBuilder builder('|');
 153     builder.addFlag(flags & SkColorFilter::kAlphaUnchanged_Flag,
 154                     "kAlphaUnchanged_Flag");
 155     builder.addFlag(flags & SkColorFilter::kHasFilter16_Flag,
 156                     "kHasFilter16_Flag");
 157
 158     val->SetString("flags", builder.str());
 159   }
 160
 161   SkScalar color_matrix[20];
 162   if (filter.asColorMatrix(color_matrix)) {
 163     scoped_ptr<base::ListValue> color_matrix_val(new base::ListValue());
 164     for (unsigned i = 0; i < 20; ++i)
 165       color_matrix_val->Append(AsValue(color_matrix[i]).release());
 166
 167     val->Set("color_matrix", color_matrix_val.Pass());
 168   }
 169
 170   SkColor color;
 171   SkXfermode::Mode mode;
 172   if (filter.asColorMode(&color, &mode)) {
 173     scoped_ptr<base::DictionaryValue> color_mode_val(
 174         new base::DictionaryValue());
 175     color_mode_val->Set("color", AsValue(color));
 176     color_mode_val->Set("mode", AsValue(mode));
 177
 178     val->Set("color_mode", color_mode_val.Pass());
 179   }
 180
 181   if (filter.asComponentTable(nullptr)) {
 182     scoped_ptr<base::DictionaryValue> component_table_val(
 183         new base::DictionaryValue());
 184     // use this as a marker for now
 185     val->Set("component_table", component_table_val.Pass());
 186   }
 187
 188   return val.Pass();
 189 }
 190
 191 WARN_UNUSED_RESULT
 192 scoped_ptr<base::Value> AsValue(const SkImageFilter& filter) {
 193   scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
 194   val->SetInteger("inputs", filter.countInputs());
 195
 196   SkColorFilter* color_filter;
 197   if (filter.asColorFilter(&color_filter)) {
 198     val->Set("color_filter", AsValue(*color_filter));
 199     SkSafeUnref(color_filter); // ref'd in asColorFilter
 200   }
 201
 202   return val.Pass();
 203 }
 204
 205 WARN_UNUSED_RESULT
 206 scoped_ptr<base::Value> AsValue(const SkPaint& paint) {
 207   scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
 208   SkPaint default_paint;
 209
 210   if (paint.getColor() != default_paint.getColor())
 211     val->Set("Color", AsValue(paint.getColor()));
 212
 213   if (paint.getStyle() != default_paint.getStyle()) {
 214     static const char* gStyleStrings[] = { "Fill", "Stroke", "StrokeFill" };
 215     DCHECK_LT(static_cast<size_t>(paint.getStyle()),
 216               SK_ARRAY_COUNT(gStyleStrings));
 217     val->SetString("Style", gStyleStrings[paint.getStyle()]);
 218   }
 219
 220   if (paint.getXfermode() != default_paint.getXfermode()) {
 221     DCHECK(paint.getXfermode());
 222     val->Set("Xfermode", AsValue(*paint.getXfermode()));
 223   }
 224
 225   if (paint.getFlags()) {
 226     FlagsBuilder builder('|');
 227     builder.addFlag(paint.isAntiAlias(), "AntiAlias");
 228     builder.addFlag(paint.isDither(), "Dither");
 229     builder.addFlag(paint.isUnderlineText(), "UnderlineText");
 230     builder.addFlag(paint.isStrikeThruText(), "StrikeThruText");
 231     builder.addFlag(paint.isFakeBoldText(), "FakeBoldText");
 232     builder.addFlag(paint.isLinearText(), "LinearText");
 233     builder.addFlag(paint.isSubpixelText(), "SubpixelText");
 234     builder.addFlag(paint.isDevKernText(), "DevKernText");
 235     builder.addFlag(paint.isLCDRenderText(), "LCDRenderText");
 236     builder.addFlag(paint.isEmbeddedBitmapText(), "EmbeddedBitmapText");
 237     builder.addFlag(paint.isAutohinted(), "Autohinted");
 238     builder.addFlag(paint.isVerticalText(), "VerticalText");
 239     builder.addFlag(paint.getFlags() & SkPaint::kGenA8FromLCD_Flag,
 240                     "GenA8FromLCD");
 241
 242     val->SetString("Flags", builder.str());
 243   }
 244
 245   if (paint.getFilterLevel() != default_paint.getFilterLevel()) {
 246     static const char* gFilterLevelStrings[] =
 247         { "None", "Low", "Medium", "High" };
 248     DCHECK_LT(static_cast<size_t>(paint.getFilterLevel()),
 249               SK_ARRAY_COUNT(gFilterLevelStrings));
 250     val->SetString("FilterLevel", gFilterLevelStrings[paint.getFilterLevel()]);
 251   }
 252
 253   if (paint.getTextSize() != default_paint.getTextSize())
 254     val->SetDouble("TextSize", paint.getTextSize());
 255
 256   if (paint.getTextScaleX() != default_paint.getTextScaleX())
 257     val->SetDouble("TextScaleX", paint.getTextScaleX());
 258
 259   if (paint.getTextSkewX() != default_paint.getTextSkewX())
 260     val->SetDouble("TextSkewX", paint.getTextSkewX());
 261
 262   if (paint.getColorFilter())
 263     val->Set("ColorFilter", AsValue(*paint.getColorFilter()));
 264
 265   if (paint.getImageFilter())
 266     val->Set("ImageFilter", AsValue(*paint.getImageFilter()));
 267
 268   return val.Pass();
 269 }
 270
 271 WARN_UNUSED_RESULT
 272 scoped_ptr<base::Value> AsValue(SkCanvas::SaveFlags flags) {
 273   FlagsBuilder builder('|');
 274   builder.addFlag(flags & SkCanvas::kHasAlphaLayer_SaveFlag,
 275                   "kHasAlphaLayer");
 276   builder.addFlag(flags & SkCanvas::kFullColorLayer_SaveFlag,
 277                   "kFullColorLayer");
 278   builder.addFlag(flags & SkCanvas::kClipToLayer_SaveFlag,
 279                   "kClipToLayer");
 280
 281   scoped_ptr<base::StringValue> val(new base::StringValue(builder.str()));
 282
 283   return val.Pass();
 284 }
 285
 286 WARN_UNUSED_RESULT
 287 scoped_ptr<base::Value> AsValue(SkRegion::Op op) {
 288   static const char* gOpStrings[] = { "Difference",
 289                                       "Intersect",
 290                                       "Union",
 291                                       "XOR",
 292                                       "ReverseDifference",
 293                                       "Replace"
 294                                     };
 295   DCHECK_LT(static_cast<size_t>(op), SK_ARRAY_COUNT(gOpStrings));
 296   scoped_ptr<base::StringValue> val(new base::StringValue(gOpStrings[op]));
 297   return val.Pass();
 298 }
 299
 300 WARN_UNUSED_RESULT
 301 scoped_ptr<base::Value> AsValue(const SkRegion& region) {
 302   scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
 303   val->Set("bounds", AsValue(SkRect::Make(region.getBounds())));
 304
 305   return val.Pass();
 306 }
 307
 308 WARN_UNUSED_RESULT
 309 scoped_ptr<base::Value> AsValue(const SkPicture& picture) {
 310   scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
 311   val->Set("cull-rect", AsValue(picture.cullRect()));
 312
 313   return val.Pass();
 314 }
 315
 316 WARN_UNUSED_RESULT
 317 scoped_ptr<base::Value> AsValue(const SkBitmap& bitmap) {
 318   scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
 319   val->Set("size", AsValue(SkSize::Make(bitmap.width(), bitmap.height())));
 320
 321   return val.Pass();
 322 }
 323
 324 WARN_UNUSED_RESULT
 325 scoped_ptr<base::Value> AsValue(const SkImage& image) {
 326   scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
 327   val->Set("size", AsValue(SkSize::Make(image.width(), image.height())));
 328
 329   return val.Pass();
 330 }
 331
 332 WARN_UNUSED_RESULT
 333 scoped_ptr<base::Value> AsValue(const SkTextBlob& blob) {
 334   scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
 335   val->Set("bounds", AsValue(blob.bounds()));
 336
 337   return val.Pass();
 338 }
 339
 340 WARN_UNUSED_RESULT
 341 scoped_ptr<base::Value> AsValue(const SkPath& path) {
 342   scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
 343
 344   static const char* gFillStrings[] =
 345       { "winding", "even-odd", "inverse-winding", "inverse-even-odd" };
 346   DCHECK_LT(static_cast<size_t>(path.getFillType()),
 347       SK_ARRAY_COUNT(gFillStrings));
 348   val->SetString("fill-type", gFillStrings[path.getFillType()]);
 349
 350   static const char* gConvexityStrings[] = { "Unknown", "Convex", "Concave" };
 351   DCHECK_LT(static_cast<size_t>(path.getConvexity()),
 352       SK_ARRAY_COUNT(gConvexityStrings));
 353   val->SetString("convexity", gConvexityStrings[path.getConvexity()]);
 354
 355   val->SetBoolean("is-rect", path.isRect(nullptr));
 356   val->Set("bounds", AsValue(path.getBounds()));
 357
 358   static const char* gVerbStrings[] =
 359       { "move", "line", "quad", "conic", "cubic", "close", "done" };
 360   static const int gPtsPerVerb[] = { 1, 1, 2, 2, 3, 0, 0 };
 361   static const int gPtOffsetPerVerb[] = { 0, 1, 1, 1, 1, 0, 0 };
 362   SK_COMPILE_ASSERT(
 363       SK_ARRAY_COUNT(gVerbStrings) == static_cast<size_t>(SkPath::kDone_Verb + 1),
 364       gVerbStrings_size_mismatch);
 365   SK_COMPILE_ASSERT(
 366       SK_ARRAY_COUNT(gVerbStrings) == SK_ARRAY_COUNT(gPtsPerVerb),
 367       gPtsPerVerb_size_mismatch);
 368   SK_COMPILE_ASSERT(
 369       SK_ARRAY_COUNT(gVerbStrings) == SK_ARRAY_COUNT(gPtOffsetPerVerb),
 370       gPtOffsetPerVerb_size_mismatch);
 371
 372   scoped_ptr<base::ListValue> verbs_val(new base::ListValue());
 373   SkPath::Iter iter(const_cast<SkPath&>(path), false);
 374   SkPoint points[4];
 375
 376   for(SkPath::Verb verb = iter.next(points, false);
 377       verb != SkPath::kDone_Verb; verb = iter.next(points, false)) {
 378       DCHECK_LT(static_cast<size_t>(verb), SK_ARRAY_COUNT(gVerbStrings));
 379
 380       scoped_ptr<base::DictionaryValue> verb_val(new base::DictionaryValue());
 381       scoped_ptr<base::ListValue> pts_val(new base::ListValue());
 382
 383       for (int i = 0; i < gPtsPerVerb[verb]; ++i)
 384         pts_val->Append(AsValue(points[i + gPtOffsetPerVerb[verb]]).release());
 385
 386       verb_val->Set(gVerbStrings[verb], pts_val.Pass());
 387
 388       if (SkPath::kConic_Verb == verb)
 389         verb_val->Set("weight", AsValue(iter.conicWeight()));
 390
 391       verbs_val->Append(verb_val.release());
 392   }
 393   val->Set("verbs", verbs_val.Pass());
 394
 395   return val.Pass();
 396 }
 397
 398 template<typename T>
 399 WARN_UNUSED_RESULT
 400 scoped_ptr<base::Value> AsListValue(const T array[], size_t count) {
 401   scoped_ptr<base::ListValue> val(new base::ListValue());
 402
 403   for (size_t i = 0; i < count; ++i)
 404     val->Append(AsValue(array[i]).release());
 405
 406   return val.Pass();
 407 }
 408
 409 } // namespace
 410
 411 namespace skia {
 412
 413 class BenchmarkingCanvas::AutoOp {
 414 public:
 415   AutoOp(BenchmarkingCanvas* canvas, const char op_name[],
 416          const SkPaint* paint = nullptr)
 417       : canvas_(canvas)
 418       , op_record_(new base::DictionaryValue())
 419       , op_params_(new base::ListValue()) {
 420
 421     DCHECK(canvas);
 422     DCHECK(op_name);
 423
 424     op_record_->SetString("cmd_string", op_name);
 425     op_record_->Set("info", op_params_);
 426
 427     if (paint)
 428       this->addParam("paint", AsValue(*paint));
 429
 430     start_ticks_ = base::TimeTicks::Now();
 431   }
 432
 433   ~AutoOp() {
 434     base::TimeDelta ticks = base::TimeTicks::Now() - start_ticks_;
 435     op_record_->SetDouble("cmd_time", ticks.InMillisecondsF());
 436
 437     canvas_->op_records_.Append(op_record_);
 438   }
 439
 440   void addParam(const char name[], scoped_ptr<base::Value> value) {
 441     scoped_ptr<base::DictionaryValue> param(new base::DictionaryValue());
 442     param->Set(name, value.Pass());
 443
 444     op_params_->Append(param.release());
 445   }
 446
 447 private:
 448   BenchmarkingCanvas* canvas_;
 449   base::DictionaryValue* op_record_;
 450   base::ListValue* op_params_;
 451   base::TimeTicks start_ticks_;
 452 };
 453
 454 BenchmarkingCanvas::BenchmarkingCanvas(SkCanvas* canvas, unsigned flags)
 455     : INHERITED(canvas->imageInfo().width(),
 456                 canvas->imageInfo().height())
 457     , flags_(flags) {
 458   addCanvas(canvas);
 459 }
 460
 461 BenchmarkingCanvas::~BenchmarkingCanvas() {
 462 }
 463
 464 size_t BenchmarkingCanvas::CommandCount() const {
 465   return op_records_.GetSize();
 466 }
 467
 468 const base::ListValue& BenchmarkingCanvas::Commands() const {
 469   return op_records_;
 470 }
 471
 472 double BenchmarkingCanvas::GetTime(size_t index) {
 473   const base::DictionaryValue* op;
 474   if (!op_records_.GetDictionary(index, &op))
 475     return 0;
 476
 477   double t;
 478   if (!op->GetDouble("cmd_time", &t))
 479     return 0;
 480
 481   return t;
 482 }
 483
 484 void BenchmarkingCanvas::willSave() {
 485   AutoOp op(this, "Save");
 486
 487   INHERITED::willSave();
 488 }
 489
 490 SkCanvas::SaveLayerStrategy BenchmarkingCanvas::willSaveLayer(const SkRect* rect,
 491                                                               const SkPaint* paint,
 492                                                               SaveFlags flags) {
 493   AutoOp op(this, "SaveLayer", paint);
 494   if (rect)
 495     op.addParam("bounds", AsValue(*rect));
 496   if (paint)
 497     op.addParam("paint", AsValue(*paint));
 498   if (flags)
 499     op.addParam("flags", AsValue(flags));
 500
 501   return INHERITED::willSaveLayer(rect, paint, flags);
 502 }
 503
 504 void BenchmarkingCanvas::willRestore() {
 505   AutoOp op(this, "Restore");
 506
 507   INHERITED::willRestore();
 508 }
 509
 510 void BenchmarkingCanvas::didConcat(const SkMatrix& m) {
 511   AutoOp op(this, "Concat");
 512   op.addParam("matrix", AsValue(m));
 513
 514   INHERITED::didConcat(m);
 515 }
 516
 517 void BenchmarkingCanvas::didSetMatrix(const SkMatrix& m) {
 518   AutoOp op(this, "SetMatrix");
 519   op.addParam("matrix", AsValue(m));
 520
 521   INHERITED::didSetMatrix(m);
 522 }
 523
 524 void BenchmarkingCanvas::onClipRect(const SkRect& rect,
 525                                     SkRegion::Op region_op,
 526                                     SkCanvas::ClipEdgeStyle style) {
 527   AutoOp op(this, "ClipRect");
 528   op.addParam("rect", AsValue(rect));
 529   op.addParam("op", AsValue(region_op));
 530   op.addParam("anti-alias", AsValue(style == kSoft_ClipEdgeStyle));
 531
 532   INHERITED::onClipRect(rect, region_op, style);
 533 }
 534
 535 void BenchmarkingCanvas::onClipRRect(const SkRRect& rrect,
 536                                      SkRegion::Op region_op,
 537                                      SkCanvas::ClipEdgeStyle style) {
 538   AutoOp op(this, "ClipRRect");
 539   op.addParam("rrect", AsValue(rrect));
 540   op.addParam("op", AsValue(region_op));
 541   op.addParam("anti-alias", AsValue(style == kSoft_ClipEdgeStyle));
 542
 543   INHERITED::onClipRRect(rrect, region_op, style);
 544 }
 545
 546 void BenchmarkingCanvas::onClipPath(const SkPath& path,
 547                                     SkRegion::Op region_op,
 548                                     SkCanvas::ClipEdgeStyle style) {
 549   AutoOp op(this, "ClipPath");
 550   op.addParam("path", AsValue(path));
 551   op.addParam("op", AsValue(region_op));
 552   op.addParam("anti-alias", AsValue(style == kSoft_ClipEdgeStyle));
 553
 554   INHERITED::onClipPath(path, region_op, style);
 555 }
 556
 557 void BenchmarkingCanvas::onClipRegion(const SkRegion& region,
 558                                       SkRegion::Op region_op) {
 559   AutoOp op(this, "ClipRegion");
 560   op.addParam("region", AsValue(region));
 561   op.addParam("op", AsValue(region_op));
 562
 563   INHERITED::onClipRegion(region, region_op);
 564 }
 565
 566 void BenchmarkingCanvas::onDrawPaint(const SkPaint& paint) {
 567   AutoOp op(this, "DrawPaint", &paint);
 568
 569   INHERITED::onDrawPaint(paint);
 570 }
 571
 572 void BenchmarkingCanvas::onDrawPoints(PointMode mode, size_t count,
 573                                       const SkPoint pts[], const SkPaint& paint) {
 574   AutoOp op(this, "DrawPoints", &paint);
 575   op.addParam("mode", AsValue(mode));
 576   op.addParam("points", AsListValue(pts, count));
 577
 578   INHERITED::onDrawPoints(mode, count, pts, paint);
 579 }
 580
 581 void BenchmarkingCanvas::onDrawRect(const SkRect& rect, const SkPaint& paint) {
 582   AutoOp op(this, "DrawRect", &paint);
 583   op.addParam("rect", AsValue(rect));
 584
 585   INHERITED::onDrawRect(rect, paint);
 586 }
 587
 588 void BenchmarkingCanvas::onDrawOval(const SkRect& rect, const SkPaint& paint) {
 589   AutoOp op(this, "DrawOval", &paint);
 590   op.addParam("rect", AsValue(rect));
 591
 592   INHERITED::onDrawOval(rect, paint);
 593 }
 594
 595 void BenchmarkingCanvas::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) {
 596   AutoOp op(this, "DrawRRect", &paint);
 597   op.addParam("rrect", AsValue(rrect));
 598
 599   INHERITED::onDrawRRect(rrect, paint);
 600 }
 601
 602 void BenchmarkingCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
 603                                       const SkPaint& paint) {
 604   AutoOp op(this, "DrawDRRect", &paint);
 605   op.addParam("outer", AsValue(outer));
 606   op.addParam("inner", AsValue(inner));
 607
 608   INHERITED::onDrawDRRect(outer, inner, paint);
 609 }
 610
 611 void BenchmarkingCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) {
 612   AutoOp op(this, "DrawPath", &paint);
 613   op.addParam("path", AsValue(path));
 614
 615   INHERITED::onDrawPath(path, paint);
 616 }
 617
 618 void BenchmarkingCanvas::onDrawPicture(const SkPicture* picture,
 619                                        const SkMatrix* matrix,
 620                                        const SkPaint* paint) {
 621   DCHECK(picture);
 622   AutoOp op(this, "DrawPicture", paint);
 623   op.addParam("picture", AsValue(picture));
 624   if (matrix)
 625     op.addParam("matrix", AsValue(*matrix));
 626
 627   INHERITED::drawPicture(picture, matrix, paint);
 628 }
 629
 630 void BenchmarkingCanvas::onDrawBitmap(const SkBitmap& bitmap,
 631                                       SkScalar left,
 632                                       SkScalar top,
 633                                       const SkPaint* paint) {
 634   AutoOp op(this, "DrawBitmap", paint);
 635   op.addParam("bitmap", AsValue(bitmap));
 636   op.addParam("left", AsValue(left));
 637   op.addParam("top", AsValue(top));
 638
 639   INHERITED::onDrawBitmap(bitmap, left, top, paint);
 640 }
 641
 642 void BenchmarkingCanvas::onDrawBitmapRect(const SkBitmap& bitmap,
 643                                           const SkRect* src,
 644                                           const SkRect& dst,
 645                                           const SkPaint* paint,
 646                                           DrawBitmapRectFlags flags) {
 647   AutoOp op(this, "DrawBitmapRect", paint);
 648   op.addParam("bitmap", AsValue(bitmap));
 649   if (src)
 650     op.addParam("src", AsValue(*src));
 651   op.addParam("dst", AsValue(dst));
 652
 653   INHERITED::onDrawBitmapRect(bitmap, src, dst, paint, flags);
 654 }
 655
 656 void BenchmarkingCanvas::onDrawImage(const SkImage* image,
 657                                      SkScalar left,
 658                                      SkScalar top,
 659                                      const SkPaint* paint) {
 660   DCHECK(image);
 661   AutoOp op(this, "DrawImage", paint);
 662   op.addParam("image", AsValue(*image));
 663   op.addParam("left", AsValue(left));
 664   op.addParam("top", AsValue(top));
 665
 666   INHERITED::onDrawImage(image, left, top, paint);
 667 }
 668
 669 void BenchmarkingCanvas::onDrawImageRect(const SkImage* image, const SkRect* src,
 670                                          const SkRect& dst, const SkPaint* paint) {
 671   DCHECK(image);
 672   AutoOp op(this, "DrawImageRect", paint);
 673   op.addParam("image", AsValue(*image));
 674   if (src)
 675     op.addParam("src", AsValue(*src));
 676   op.addParam("dst", AsValue(dst));
 677
 678   INHERITED::onDrawImageRect(image, src, dst, paint);
 679 }
 680
 681 void BenchmarkingCanvas::onDrawBitmapNine(const SkBitmap& bitmap,
 682                                           const SkIRect& center,
 683                                           const SkRect& dst,
 684                                           const SkPaint* paint) {
 685   AutoOp op(this, "DrawBitmapNine", paint);
 686   op.addParam("bitmap", AsValue(bitmap));
 687   op.addParam("center", AsValue(SkRect::Make(center)));
 688   op.addParam("dst", AsValue(dst));
 689
 690   INHERITED::onDrawBitmapNine(bitmap, center, dst, paint);
 691 }
 692
 693 void BenchmarkingCanvas::onDrawSprite(const SkBitmap& bitmap, int left, int top,
 694                                       const SkPaint* paint)  {
 695   AutoOp op(this, "DrawSprite", paint);
 696   op.addParam("bitmap", AsValue(bitmap));
 697   op.addParam("left", AsValue(SkIntToScalar(left)));
 698   op.addParam("top", AsValue(SkIntToScalar(top)));
 699
 700   INHERITED::onDrawSprite(bitmap, left, top, paint);
 701 }
 702
 703 void BenchmarkingCanvas::onDrawText(const void* text, size_t byteLength,
 704                                     SkScalar x, SkScalar y,
 705                                     const SkPaint& paint) {
 706   AutoOp op(this, "DrawText", &paint);
 707   op.addParam("count", AsValue(SkIntToScalar(paint.countText(text, byteLength))));
 708   op.addParam("x", AsValue(x));
 709   op.addParam("y", AsValue(y));
 710
 711   INHERITED::onDrawText(text, byteLength, x, y, paint);
 712 }
 713
 714 void BenchmarkingCanvas::onDrawPosText(const void* text, size_t byteLength,
 715                                        const SkPoint pos[], const SkPaint& paint) {
 716   AutoOp op(this, "DrawPosText", &paint);
 717
 718   int count = paint.countText(text, byteLength);
 719   op.addParam("count", AsValue(SkIntToScalar(count)));
 720   op.addParam("pos", AsListValue(pos, count));
 721
 722   INHERITED::onDrawPosText(text, byteLength, pos, paint);
 723 }
 724
 725 void BenchmarkingCanvas::onDrawPosTextH(const void* text, size_t byteLength,
 726                                         const SkScalar xpos[], SkScalar constY,
 727                                         const SkPaint& paint)  {
 728   AutoOp op(this, "DrawPosTextH", &paint);
 729   op.addParam("constY", AsValue(constY));
 730
 731   int count = paint.countText(text, byteLength);
 732   op.addParam("count", AsValue(SkIntToScalar(count)));
 733   op.addParam("pos", AsListValue(xpos, count));
 734
 735   INHERITED::onDrawPosTextH(text, byteLength, xpos, constY, paint);
 736 }
 737
 738 void BenchmarkingCanvas::onDrawTextOnPath(const void* text, size_t byteLength,
 739                                           const SkPath& path, const SkMatrix* matrix,
 740                                           const SkPaint& paint) {
 741   AutoOp op(this, "DrawTextOnPath", &paint);
 742   op.addParam("count", AsValue(SkIntToScalar(paint.countText(text, byteLength))));
 743   op.addParam("path", AsValue(path));
 744   if (matrix)
 745     op.addParam("matrix", AsValue(*matrix));
 746
 747   INHERITED::onDrawTextOnPath(text, byteLength, path, matrix, paint);
 748 }
 749
 750 void BenchmarkingCanvas::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
 751                                         const SkPaint& paint) {
 752   DCHECK(blob);
 753   AutoOp op(this, "DrawTextBlob", &paint);
 754   op.addParam("blob", AsValue(*blob));
 755   op.addParam("x", AsValue(x));
 756   op.addParam("y", AsValue(y));
 757
 758   INHERITED::onDrawTextBlob(blob, x, y, paint);
 759 }
 760
 761 } // namespace skia