Update from https://crrev.com/320343

skia/ext/benchmarking_canvas.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 "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "skia/ext/benchmarking_canvas.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
+#include "third_party/skia/include/core/SkTLazy.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkRegion.h"
+#include "third_party/skia/include/core/SkString.h"
 #include "third_party/skia/include/core/SkTextBlob.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 
 namespace {
 
 class FlagsBuilder {
 public:
   FlagsBuilder(char separator)
       : separator_(separator) {}
 
@@ skipping 376 matching lines @@
 WARN_UNUSED_RESULT
 scoped_ptr<base::Value> AsListValue(const T array[], size_t count) {
   scoped_ptr<base::ListValue> val(new base::ListValue());
 
   for (size_t i = 0; i < count; ++i)
     val->Append(AsValue(array[i]).release());
 
   return val.Pass();
 }
 
+class OverdrawXfermode : public SkXfermode {
+public:
+  SkPMColor xferColor(SkPMColor src, SkPMColor dst) const override {
+    // This table encodes the color progression of the overdraw visualization
+    static const SkPMColor gTable[] = {
+      SkPackARGB32(0x00, 0x00, 0x00, 0x00),
+      SkPackARGB32(0xFF, 128, 158, 255),
+      SkPackARGB32(0xFF, 170, 185, 212),
+      SkPackARGB32(0xFF, 213, 195, 170),
+      SkPackARGB32(0xFF, 255, 192, 127),
+      SkPackARGB32(0xFF, 255, 185, 85),
+      SkPackARGB32(0xFF, 255, 165, 42),
+      SkPackARGB32(0xFF, 255, 135, 0),
+      SkPackARGB32(0xFF, 255,  95, 0),
+      SkPackARGB32(0xFF, 255,  50, 0),
+      SkPackARGB32(0xFF, 255,  0, 0)
+    };
+
+    size_t idx;
+    if (SkColorGetR(dst) < 64) { // 0
+      idx = 0;
+    } else if (SkColorGetG(dst) < 25) { // 10
+      idx = 9;  // cap at 9 for upcoming increment
+    } else if ((SkColorGetB(dst) + 21) / 42 > 0) { // 1-6
+      idx = 7 - (SkColorGetB(dst) + 21) / 42;
+    } else { // 7-9
+      idx = 10 - (SkColorGetG(dst) + 22) / 45;
+    }
+
+    ++idx;
+    SkASSERT(idx < SK_ARRAY_COUNT(gTable));
+
+    return gTable[idx];
+  }
+
+  Factory getFactory() const override { return NULL; }
+#ifndef SK_IGNORE_TO_STRING
+  void toString(SkString* str) const override { str->set("OverdrawXfermode"); }
+#endif
+};
+
 } // namespace
 
 namespace skia {
 
 class BenchmarkingCanvas::AutoOp {
 public:
   AutoOp(BenchmarkingCanvas* canvas, const char op_name[],
          const SkPaint* paint = nullptr)
       : canvas_(canvas)
       , op_record_(new base::DictionaryValue())
-      , op_params_(new base::ListValue()) {
+      , op_params_(new base::ListValue())
+      // AutoOp objects are always scoped within draw call frames,
+      // so the paint is guaranteed to be valid for their lifetime.
+      , paint_(paint) {
 
     DCHECK(canvas);
     DCHECK(op_name);
 
     op_record_->SetString("cmd_string", op_name);
     op_record_->Set("info", op_params_);
 
     if (paint)
       this->addParam("paint", AsValue(*paint));
 
+    if (canvas->flags_ & kOverdrawVisualization_Flag) {
+      DCHECK(canvas->overdraw_xfermode_);
+
+      paint_ = paint ? filtered_paint_.set(*paint) : filtered_paint_.init();
+      filtered_paint_.get()->setXfermode(canvas->overdraw_xfermode_.get());
+      filtered_paint_.get()->setAntiAlias(false);
+    }
+
     start_ticks_ = base::TimeTicks::Now();
   }
 
   ~AutoOp() {
     base::TimeDelta ticks = base::TimeTicks::Now() - start_ticks_;
     op_record_->SetDouble("cmd_time", ticks.InMillisecondsF());
 
     canvas_->op_records_.Append(op_record_);
   }
 
   void addParam(const char name[], scoped_ptr<base::Value> value) {
     scoped_ptr<base::DictionaryValue> param(new base::DictionaryValue());
     param->Set(name, value.Pass());
 
     op_params_->Append(param.release());
   }
 
+  const SkPaint* paint() const { return paint_; }
+
 private:
   BenchmarkingCanvas* canvas_;
   base::DictionaryValue* op_record_;
   base::ListValue* op_params_;
   base::TimeTicks start_ticks_;
+
+  const SkPaint* paint_;
+  SkTLazy<SkPaint> filtered_paint_;
 };
 
 BenchmarkingCanvas::BenchmarkingCanvas(SkCanvas* canvas, unsigned flags)
     : INHERITED(canvas->imageInfo().width(),
                 canvas->imageInfo().height())
     , flags_(flags) {
   addCanvas(canvas);
+
+  if (flags & kOverdrawVisualization_Flag)
+    overdraw_xfermode_ = AdoptRef(new OverdrawXfermode);
 }
 
 BenchmarkingCanvas::~BenchmarkingCanvas() {
 }
 
 size_t BenchmarkingCanvas::CommandCount() const {
   return op_records_.GetSize();
 }
 
 const base::ListValue& BenchmarkingCanvas::Commands() const {
@@ skipping 17 matching lines @@
 
   INHERITED::willSave();
 }
 
 SkCanvas::SaveLayerStrategy BenchmarkingCanvas::willSaveLayer(const SkRect* rect,
                                                               const SkPaint* paint,
                                                               SaveFlags flags) {
   AutoOp op(this, "SaveLayer", paint);
   if (rect)
     op.addParam("bounds", AsValue(*rect));
-  if (paint)
-    op.addParam("paint", AsValue(*paint));
   if (flags)
     op.addParam("flags", AsValue(flags));
 
-  return INHERITED::willSaveLayer(rect, paint, flags);
+  return INHERITED::willSaveLayer(rect, op.paint(), flags);
 }
 
 void BenchmarkingCanvas::willRestore() {
   AutoOp op(this, "Restore");
 
   INHERITED::willRestore();
 }
 
 void BenchmarkingCanvas::didConcat(const SkMatrix& m) {
   AutoOp op(this, "Concat");
@@ skipping 47 matching lines @@
   AutoOp op(this, "ClipRegion");
   op.addParam("region", AsValue(region));
   op.addParam("op", AsValue(region_op));
 
   INHERITED::onClipRegion(region, region_op);
 }
 
 void BenchmarkingCanvas::onDrawPaint(const SkPaint& paint) {
   AutoOp op(this, "DrawPaint", &paint);
 
-  INHERITED::onDrawPaint(paint);
+  INHERITED::onDrawPaint(*op.paint());
 }
 
 void BenchmarkingCanvas::onDrawPoints(PointMode mode, size_t count,
                                       const SkPoint pts[], const SkPaint& paint) {
   AutoOp op(this, "DrawPoints", &paint);
   op.addParam("mode", AsValue(mode));
   op.addParam("points", AsListValue(pts, count));
 
-  INHERITED::onDrawPoints(mode, count, pts, paint);
+  INHERITED::onDrawPoints(mode, count, pts, *op.paint());
 }
 
 void BenchmarkingCanvas::onDrawRect(const SkRect& rect, const SkPaint& paint) {
   AutoOp op(this, "DrawRect", &paint);
   op.addParam("rect", AsValue(rect));
 
-  INHERITED::onDrawRect(rect, paint);
+  INHERITED::onDrawRect(rect, *op.paint());
 }
 
 void BenchmarkingCanvas::onDrawOval(const SkRect& rect, const SkPaint& paint) {
   AutoOp op(this, "DrawOval", &paint);
   op.addParam("rect", AsValue(rect));
 
-  INHERITED::onDrawOval(rect, paint);
+  INHERITED::onDrawOval(rect, *op.paint());
 }
 
 void BenchmarkingCanvas::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) {
   AutoOp op(this, "DrawRRect", &paint);
   op.addParam("rrect", AsValue(rrect));
 
-  INHERITED::onDrawRRect(rrect, paint);
+  INHERITED::onDrawRRect(rrect, *op.paint());
 }
 
 void BenchmarkingCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
                                       const SkPaint& paint) {
   AutoOp op(this, "DrawDRRect", &paint);
   op.addParam("outer", AsValue(outer));
   op.addParam("inner", AsValue(inner));
 
-  INHERITED::onDrawDRRect(outer, inner, paint);
+  INHERITED::onDrawDRRect(outer, inner, *op.paint());
 }
 
 void BenchmarkingCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) {
   AutoOp op(this, "DrawPath", &paint);
   op.addParam("path", AsValue(path));
 
-  INHERITED::onDrawPath(path, paint);
+  INHERITED::onDrawPath(path, *op.paint());
 }
 
 void BenchmarkingCanvas::onDrawPicture(const SkPicture* picture,
                                        const SkMatrix* matrix,
                                        const SkPaint* paint) {
   DCHECK(picture);
   AutoOp op(this, "DrawPicture", paint);
   op.addParam("picture", AsValue(picture));
   if (matrix)
     op.addParam("matrix", AsValue(*matrix));
 
-  INHERITED::drawPicture(picture, matrix, paint);
+  INHERITED::onDrawPicture(picture, matrix, op.paint());
 }
 
 void BenchmarkingCanvas::onDrawBitmap(const SkBitmap& bitmap,
                                       SkScalar left,
                                       SkScalar top,
                                       const SkPaint* paint) {
   AutoOp op(this, "DrawBitmap", paint);
   op.addParam("bitmap", AsValue(bitmap));
   op.addParam("left", AsValue(left));
   op.addParam("top", AsValue(top));
 
-  INHERITED::onDrawBitmap(bitmap, left, top, paint);
+  INHERITED::onDrawBitmap(bitmap, left, top, op.paint());
 }
 
 void BenchmarkingCanvas::onDrawBitmapRect(const SkBitmap& bitmap,
                                           const SkRect* src,
                                           const SkRect& dst,
                                           const SkPaint* paint,
                                           DrawBitmapRectFlags flags) {
   AutoOp op(this, "DrawBitmapRect", paint);
   op.addParam("bitmap", AsValue(bitmap));
   if (src)
     op.addParam("src", AsValue(*src));
   op.addParam("dst", AsValue(dst));
 
-  INHERITED::onDrawBitmapRect(bitmap, src, dst, paint, flags);
+  INHERITED::onDrawBitmapRect(bitmap, src, dst, op.paint(), flags);
 }
 
 void BenchmarkingCanvas::onDrawImage(const SkImage* image,
                                      SkScalar left,
                                      SkScalar top,
                                      const SkPaint* paint) {
   DCHECK(image);
   AutoOp op(this, "DrawImage", paint);
   op.addParam("image", AsValue(*image));
   op.addParam("left", AsValue(left));
   op.addParam("top", AsValue(top));
 
-  INHERITED::onDrawImage(image, left, top, paint);
+  INHERITED::onDrawImage(image, left, top, op.paint());
 }
 
 void BenchmarkingCanvas::onDrawImageRect(const SkImage* image, const SkRect* src,
                                          const SkRect& dst, const SkPaint* paint) {
   DCHECK(image);
   AutoOp op(this, "DrawImageRect", paint);
   op.addParam("image", AsValue(*image));
   if (src)
     op.addParam("src", AsValue(*src));
   op.addParam("dst", AsValue(dst));
 
-  INHERITED::onDrawImageRect(image, src, dst, paint);
+  INHERITED::onDrawImageRect(image, src, dst, op.paint());
 }
 
 void BenchmarkingCanvas::onDrawBitmapNine(const SkBitmap& bitmap,
                                           const SkIRect& center,
                                           const SkRect& dst,
                                           const SkPaint* paint) {
   AutoOp op(this, "DrawBitmapNine", paint);
   op.addParam("bitmap", AsValue(bitmap));
   op.addParam("center", AsValue(SkRect::Make(center)));
   op.addParam("dst", AsValue(dst));
 
-  INHERITED::onDrawBitmapNine(bitmap, center, dst, paint);
+  INHERITED::onDrawBitmapNine(bitmap, center, dst, op.paint());
 }
 
 void BenchmarkingCanvas::onDrawSprite(const SkBitmap& bitmap, int left, int top,
                                       const SkPaint* paint)  {
   AutoOp op(this, "DrawSprite", paint);
   op.addParam("bitmap", AsValue(bitmap));
   op.addParam("left", AsValue(SkIntToScalar(left)));
   op.addParam("top", AsValue(SkIntToScalar(top)));
 
-  INHERITED::onDrawSprite(bitmap, left, top, paint);
+  INHERITED::onDrawSprite(bitmap, left, top, op.paint());
 }
 
 void BenchmarkingCanvas::onDrawText(const void* text, size_t byteLength,
                                     SkScalar x, SkScalar y,
                                     const SkPaint& paint) {
   AutoOp op(this, "DrawText", &paint);
   op.addParam("count", AsValue(SkIntToScalar(paint.countText(text, byteLength))));
   op.addParam("x", AsValue(x));
   op.addParam("y", AsValue(y));
 
-  INHERITED::onDrawText(text, byteLength, x, y, paint);
+  INHERITED::onDrawText(text, byteLength, x, y, *op.paint());
 }
 
 void BenchmarkingCanvas::onDrawPosText(const void* text, size_t byteLength,
                                        const SkPoint pos[], const SkPaint& paint) {
   AutoOp op(this, "DrawPosText", &paint);
 
   int count = paint.countText(text, byteLength);
   op.addParam("count", AsValue(SkIntToScalar(count)));
   op.addParam("pos", AsListValue(pos, count));
 
-  INHERITED::onDrawPosText(text, byteLength, pos, paint);
+  INHERITED::onDrawPosText(text, byteLength, pos, *op.paint());
 }
 
 void BenchmarkingCanvas::onDrawPosTextH(const void* text, size_t byteLength,
                                         const SkScalar xpos[], SkScalar constY,
                                         const SkPaint& paint)  {
   AutoOp op(this, "DrawPosTextH", &paint);
   op.addParam("constY", AsValue(constY));
 
   int count = paint.countText(text, byteLength);
   op.addParam("count", AsValue(SkIntToScalar(count)));
   op.addParam("pos", AsListValue(xpos, count));
 
-  INHERITED::onDrawPosTextH(text, byteLength, xpos, constY, paint);
+  INHERITED::onDrawPosTextH(text, byteLength, xpos, constY, *op.paint());
 }
 
 void BenchmarkingCanvas::onDrawTextOnPath(const void* text, size_t byteLength,
                                           const SkPath& path, const SkMatrix* matrix,
                                           const SkPaint& paint) {
   AutoOp op(this, "DrawTextOnPath", &paint);
   op.addParam("count", AsValue(SkIntToScalar(paint.countText(text, byteLength))));
   op.addParam("path", AsValue(path));
   if (matrix)
     op.addParam("matrix", AsValue(*matrix));
 
-  INHERITED::onDrawTextOnPath(text, byteLength, path, matrix, paint);
+  INHERITED::onDrawTextOnPath(text, byteLength, path, matrix, *op.paint());
 }
 
 void BenchmarkingCanvas::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                                         const SkPaint& paint) {
   DCHECK(blob);
   AutoOp op(this, "DrawTextBlob", &paint);
   op.addParam("blob", AsValue(*blob));
   op.addParam("x", AsValue(x));
   op.addParam("y", AsValue(y));
 
-  INHERITED::onDrawTextBlob(blob, x, y, paint);
+  INHERITED::onDrawTextBlob(blob, x, y, *op.paint());
 }
 
 } // namespace skia