Add back overdraw visualization for Skia BenchmarkingCanvas

skia/ext/benchmarking_canvas.cc

Index: skia/ext/benchmarking_canvas.cc
diff --git a/skia/ext/benchmarking_canvas.cc b/skia/ext/benchmarking_canvas.cc
index 2af0d1a956ae58292ffe33461c97c39cdde30afd..57bd70d027d0824ce8caaaa657bccc7c91cb5440 100644
--- a/skia/ext/benchmarking_canvas.cc
+++ b/skia/ext/benchmarking_canvas.cc
@@ -8,8 +8,10 @@
 #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"
 
@@ -406,6 +408,35 @@ scoped_ptr<base::Value> AsListValue(const T array[], size_t count) {
   return val.Pass();
 }
 

[robertphillips, 2015/03/11 14:07:47]

// Comment maybe ?
// This filter works by ...

[f(malita), 2015/03/11 14:45:48]

Switched back to the color-table approach.

+class OverdrawXfermode : public SkXfermode {
+public:
+  SkPMColor xferColor(SkPMColor, SkPMColor dst) const override {
+    // Interpolate between kStartColor & kEndColor,
+    // adding kRate weight for each overdraw.
+    const SkPMColor kStartColor = SkPackARGB32(0xFF, 0x80, 0x80, 0xFF);
+    const SkPMColor kEndColor = SkPackARGB32(0xFF, 0xFF, 0, 0);
+    const float kRate = 0.1f;
+
+    float weight = 0.f;
+    if (SkGetPackedR32(dst) >= SkGetPackedR16(kStartColor)) {
+      weight = (float)(SkGetPackedR32(dst) - SkGetPackedR32(kStartColor)) /
+               (SkGetPackedR32(kEndColor) - SkGetPackedR32(kStartColor));
+      weight = std::min(weight + kRate, 1.f);
+    }
+
+    return SkFourByteInterp(kEndColor, kStartColor,
+                            SkScalarRoundToInt(weight * 255));
+  }
+
+  Factory getFactory() const override { return NULL; }
+#ifndef SK_IGNORE_TO_STRING
+  void toString(SkString* str) const override { str->set("OverdrawXfermode"); }
+#endif
+
+private:
+  typedef SkXfermode INHERITED;
+};
+
 } // namespace
 
 namespace skia {
@@ -416,7 +447,8 @@ public:
          const SkPaint* paint = nullptr)
       : canvas_(canvas)
       , op_record_(new base::DictionaryValue())
-      , op_params_(new base::ListValue()) {
+      , op_params_(new base::ListValue())

[robertphillips, 2015/03/11 14:07:47]

What guarantees is the caller providing regarding the lifetime of the passed in
paints?

[f(malita), 2015/03/11 14:45:48]

AutoOp objects are always scoped within a given draw method, so the paint ptr is
guaranteed to be valid for their lifetime.

Added a comment.

+      , paint_(paint) {
 
     DCHECK(canvas);
     DCHECK(op_name);
@@ -424,9 +456,16 @@ public:
     op_record_->SetString("cmd_string", op_name);
     op_record_->Set("info", op_params_);
 
-    if (paint)
+    if (paint) {
       this->addParam("paint", AsValue(*paint));
 

[robertphillips, 2015/03/11 14:07:47]

I think even if the op has no paint you need to create a default munged paint
when in overdraw viz mode.

[f(malita), 2015/03/11 14:45:48]

Good catch, done.

+      if (canvas->flags_ & kOverdrawVisualization_Flag) {
+        DCHECK(canvas->overdraw_xfermode_);
+        paint_ = filtered_paint_.set(*paint);
+        filtered_paint_.get()->setXfermode(canvas->overdraw_xfermode_.get());

[robertphillips, 2015/03/11 14:07:47]

Should disable AA in here too.

[f(malita), 2015/03/11 14:45:49]

Done.

+      }
+    }
+
     start_ticks_ = base::TimeTicks::Now();
   }
 
@@ -444,11 +483,16 @@ public:
     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)
@@ -456,6 +500,9 @@ BenchmarkingCanvas::BenchmarkingCanvas(SkCanvas* canvas, unsigned flags)
                 canvas->imageInfo().height())
     , flags_(flags) {
   addCanvas(canvas);
+
+  if (flags & kOverdrawVisualization_Flag)
+    overdraw_xfermode_ = AdoptRef(new OverdrawXfermode);
 }
 
 BenchmarkingCanvas::~BenchmarkingCanvas() {
@@ -493,12 +540,10 @@ SkCanvas::SaveLayerStrategy BenchmarkingCanvas::willSaveLayer(const SkRect* rect
   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() {
@@ -566,7 +611,7 @@ void BenchmarkingCanvas::onClipRegion(const SkRegion& region,
 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,
@@ -575,28 +620,28 @@ void BenchmarkingCanvas::onDrawPoints(PointMode mode, size_t count,
   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,
@@ -605,14 +650,14 @@ void BenchmarkingCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner
   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,
@@ -624,7 +669,7 @@ void BenchmarkingCanvas::onDrawPicture(const SkPicture* picture,
   if (matrix)
     op.addParam("matrix", AsValue(*matrix));
 
-  INHERITED::onDrawPicture(picture, matrix, paint);
+  INHERITED::onDrawPicture(picture, matrix, op.paint());
 }
 
 void BenchmarkingCanvas::onDrawBitmap(const SkBitmap& bitmap,
@@ -636,7 +681,7 @@ void BenchmarkingCanvas::onDrawBitmap(const SkBitmap& 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,
@@ -650,7 +695,7 @@ void BenchmarkingCanvas::onDrawBitmapRect(const SkBitmap& bitmap,
     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,
@@ -663,7 +708,7 @@ void BenchmarkingCanvas::onDrawImage(const SkImage* 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,
@@ -675,7 +720,7 @@ void BenchmarkingCanvas::onDrawImageRect(const SkImage* image, const SkRect* 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,
@@ -687,7 +732,7 @@ void BenchmarkingCanvas::onDrawBitmapNine(const SkBitmap& 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,
@@ -697,7 +742,7 @@ void BenchmarkingCanvas::onDrawSprite(const SkBitmap& bitmap, int left, int top,
   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,
@@ -708,7 +753,7 @@ void BenchmarkingCanvas::onDrawText(const void* text, size_t 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,
@@ -719,7 +764,7 @@ void BenchmarkingCanvas::onDrawPosText(const void* text, size_t 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,
@@ -732,7 +777,7 @@ void BenchmarkingCanvas::onDrawPosTextH(const void* text, size_t 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,
@@ -744,7 +789,7 @@ void BenchmarkingCanvas::onDrawTextOnPath(const void* text, size_t byteLength,
   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,
@@ -755,7 +800,7 @@ void BenchmarkingCanvas::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkSc
   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