skia/ext: Early out from analysis when we have more than 1 draw op.

skia/ext/analysis_canvas.cc

Index: skia/ext/analysis_canvas.cc
diff --git a/skia/ext/analysis_canvas.cc b/skia/ext/analysis_canvas.cc
index 16a7ffa45675a6b5753cc457785aaef0d2baa00f..ffb29107720cc2f3804bef6c52d5aee9eae3853c 100644
--- a/skia/ext/analysis_canvas.cc
+++ b/skia/ext/analysis_canvas.cc
@@ -80,7 +80,6 @@ void AnalysisCanvas::SetForceNotTransparent(bool flag) {
 
 void AnalysisCanvas::clear(SkColor color) {
   is_transparent_ = (!is_forced_not_transparent_ && SkColorGetA(color) == 0);
-  has_text_ = false;
 
   if (!is_forced_not_solid_ && SkColorGetA(color) == 255) {
     is_solid_color_ = true;
@@ -98,6 +97,7 @@ void AnalysisCanvas::drawPaint(const SkPaint& paint) {
 
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawPoints(SkCanvas::PointMode mode,
@@ -106,6 +106,7 @@ void AnalysisCanvas::drawPoints(SkCanvas::PointMode mode,
                                 const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
@@ -132,7 +133,6 @@ void AnalysisCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
       !is_forced_not_transparent_ &&
       xfermode == SkXfermode::kClear_Mode) {
     is_transparent_ = true;
-    has_text_ = false;
   } else if (paint.getAlpha() != 0 || xfermode != SkXfermode::kSrc_Mode) {
     is_transparent_ = false;
   }
@@ -145,15 +145,16 @@ void AnalysisCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
   if (!is_forced_not_solid_ && IsSolidColorPaint(paint) && does_cover_canvas) {
     is_solid_color_ = true;
     color_ = paint.getColor();
-    has_text_ = false;
   } else {
     is_solid_color_ = false;
   }
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawOval(const SkRect& oval, const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawRRect(const SkRRect& rr, const SkPaint& paint) {
@@ -162,11 +163,13 @@ void AnalysisCanvas::drawRRect(const SkRRect& rr, const SkPaint& paint) {
   // do the same work here.
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawBitmap(const SkBitmap& bitmap,
@@ -175,6 +178,7 @@ void AnalysisCanvas::drawBitmap(const SkBitmap& bitmap,
                                 const SkPaint*) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawBitmapRectToRect(const SkBitmap&,
@@ -189,6 +193,7 @@ void AnalysisCanvas::drawBitmapRectToRect(const SkBitmap&,
     paint = &tmpPaint;
   drawRect(dst, *paint);
   is_solid_color_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawBitmapMatrix(const SkBitmap& bitmap,
@@ -196,6 +201,7 @@ void AnalysisCanvas::drawBitmapMatrix(const SkBitmap& bitmap,
                                       const SkPaint* paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawBitmapNine(const SkBitmap& bitmap,
@@ -204,6 +210,7 @@ void AnalysisCanvas::drawBitmapNine(const SkBitmap& bitmap,
                                     const SkPaint* paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawSprite(const SkBitmap& bitmap,
@@ -212,6 +219,7 @@ void AnalysisCanvas::drawSprite(const SkBitmap& bitmap,
                                 const SkPaint* paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::onDrawText(const void* text,
@@ -221,7 +229,7 @@ void AnalysisCanvas::onDrawText(const void* text,
                                 const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
-  has_text_ = true;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::onDrawPosText(const void* text,
@@ -230,7 +238,7 @@ void AnalysisCanvas::onDrawPosText(const void* text,
                                    const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
-  has_text_ = true;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::onDrawPosTextH(const void* text,
@@ -240,7 +248,7 @@ void AnalysisCanvas::onDrawPosTextH(const void* text,
                                     const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
-  has_text_ = true;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::onDrawTextOnPath(const void* text,
@@ -250,7 +258,7 @@ void AnalysisCanvas::onDrawTextOnPath(const void* text,
                                       const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
-  has_text_ = true;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::onDrawDRRect(const SkRRect& outer,
@@ -258,6 +266,7 @@ void AnalysisCanvas::onDrawDRRect(const SkRRect& outer,
                                   const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawVertices(SkCanvas::VertexMode,
@@ -271,6 +280,7 @@ void AnalysisCanvas::drawVertices(SkCanvas::VertexMode,
                                   const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 // Needed for now, since SkCanvas requires a bitmap, even if it is not backed
@@ -290,7 +300,7 @@ AnalysisCanvas::AnalysisCanvas(int width, int height)
       is_forced_not_transparent_(false),
       is_solid_color_(true),
       is_transparent_(true),
-      has_text_(false) {}
+      draw_op_count_(0) {}
 
 AnalysisCanvas::~AnalysisCanvas() {}
 
@@ -306,11 +316,12 @@ bool AnalysisCanvas::GetColorIfSolid(SkColor* color) const {
   return false;
 }
 
-bool AnalysisCanvas::HasText() const { return has_text_; }
-
 bool AnalysisCanvas::abortDrawing() {
-  // Early out as soon as we have detected that the tile has text.
-  return HasText();
+  // Early out as soon as we have more than one draw op.
+  // TODO(vmpstr): Investigate if 1 is the correct metric here. We need to
+  // balance the amount of time we spend analyzing vs how many tiles would be
+  // solid if the number was higher.
+  return draw_op_count_ > 1;

[Justin Novosad, 2014/07/24 20:16:15]

Since this is an heuristic, it feels like the '1' should be a settable member
variable rather than a hard coded constant. Just a thought. I don't feel very
strongly about this, so lgtm anyways

[vmpstr, 2014/07/24 21:03:03]

Sounds good... For now I'd rather keep this hard coded, since I don't want to
burden the system using this with figuring out what to set this value to.
However, it might make sense that we might even have different values for
different analysis types in the future. I'll keep this in mind.

 }
 
 void AnalysisCanvas::onClipRect(const SkRect& rect, SkRegion::Op op,