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

skia/ext/analysis_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/debug/trace_event.h"
 #include "base/logging.h"
 #include "skia/ext/analysis_canvas.h"
 #include "third_party/skia/include/core/SkDraw.h"
 #include "third_party/skia/include/core/SkRRect.h"
 #include "third_party/skia/include/core/SkShader.h"
@@ skipping 62 matching lines @@
 }
 
 void AnalysisCanvas::SetForceNotTransparent(bool flag) {
   is_forced_not_transparent_ = flag;
   if (is_forced_not_transparent_)
     is_transparent_ = false;
 }
 
 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;
     color_ = color;
   } else {
     is_solid_color_ = false;
   }
 }
 
 void AnalysisCanvas::drawPaint(const SkPaint& paint) {
   // This check is in SkCanvas::drawPaint(), and some of our unittests rely on
   // on this, so we reproduce it here.
   if (isClipEmpty())
     return;
 
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawPoints(SkCanvas::PointMode mode,
                                 size_t count,
                                 const SkPoint points[],
                                 const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
   // This recreates the early-exit logic in SkCanvas.cpp, which aborts early
   // if the paint will "draw nothing".
   if (paint.nothingToDraw())
     return;
 
   bool does_cover_canvas = IsFullQuad(this, rect);
 
   SkXfermode::Mode xfermode;
   SkXfermode::AsMode(paint.getXfermode(), &xfermode);
 
   // This canvas will become transparent if the following holds:
   // - The quad is a full tile quad
   // - We're not in "forced not transparent" mode
   // - Transfer mode is clear (0 color, 0 alpha)
   //
   // If the paint alpha is not 0, or if the transfrer mode is
   // not src, then this canvas will not be transparent.
   //
   // In all other cases, we keep the current transparent value
   if (does_cover_canvas &&
       !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;
   }
 
   // This bitmap is solid if and only if the following holds.
   // Note that this might be overly conservative:
   // - We're not in "forced not solid" mode
   // - Paint is solid color
   // - The quad is a full tile quad
   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) {
   // This should add the SkRRect to an SkPath, and call
   // drawPath, but since drawPath ignores the SkPath, just
   // 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,
                                 SkScalar left,
                                 SkScalar top,
                                 const SkPaint*) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawBitmapRectToRect(const SkBitmap&,
                                           const SkRect* src,
                                           const SkRect& dst,
                                           const SkPaint* paint,
                                           DrawBitmapRectFlags flags) {
   // Call drawRect to determine transparency,
   // but reset solid color to false.
   SkPaint tmpPaint;
   if (!paint)
     paint = &tmpPaint;
   drawRect(dst, *paint);
   is_solid_color_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawBitmapMatrix(const SkBitmap& bitmap,
                                       const SkMatrix& matrix,
                                       const SkPaint* paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawBitmapNine(const SkBitmap& bitmap,
                                     const SkIRect& center,
                                     const SkRect& dst,
                                     const SkPaint* paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawSprite(const SkBitmap& bitmap,
                                 int left,
                                 int top,
                                 const SkPaint* paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::onDrawText(const void* text,
                                 size_t len,
                                 SkScalar x,
                                 SkScalar y,
                                 const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
-  has_text_ = true;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::onDrawPosText(const void* text,
                                    size_t byteLength,
                                    const SkPoint pos[],
                                    const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
-  has_text_ = true;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::onDrawPosTextH(const void* text,
                                     size_t byteLength,
                                     const SkScalar xpos[],
                                     SkScalar constY,
                                     const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
-  has_text_ = true;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::onDrawTextOnPath(const void* text,
                                       size_t len,
                                       const SkPath& path,
                                       const SkMatrix* matrix,
                                       const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
-  has_text_ = true;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::onDrawDRRect(const SkRRect& outer,
                                   const SkRRect& inner,
                                   const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
+  ++draw_op_count_;
 }
 
 void AnalysisCanvas::drawVertices(SkCanvas::VertexMode,
                                   int vertex_count,
                                   const SkPoint verts[],
                                   const SkPoint texs[],
                                   const SkColor colors[],
                                   SkXfermode* xmode,
                                   const uint16_t indices[],
                                   int index_count,
                                   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
 // by any pixels
 static SkBitmap MakeEmptyBitmap(int width, int height) {
   SkBitmap bitmap;
   bitmap.setInfo(SkImageInfo::MakeUnknown(width, height));
   return bitmap;
 }
 
 AnalysisCanvas::AnalysisCanvas(int width, int height)
     : INHERITED(MakeEmptyBitmap(width, height)),
       saved_stack_size_(0),
       force_not_solid_stack_level_(kNoLayer),
       force_not_transparent_stack_level_(kNoLayer),
       is_forced_not_solid_(false),
       is_forced_not_transparent_(false),
       is_solid_color_(true),
       is_transparent_(true),
-      has_text_(false) {}
+      draw_op_count_(0) {}
 
 AnalysisCanvas::~AnalysisCanvas() {}
 
 bool AnalysisCanvas::GetColorIfSolid(SkColor* color) const {
   if (is_transparent_) {
     *color = SK_ColorTRANSPARENT;
     return true;
   }
   if (is_solid_color_) {
     *color = color_;
     return true;
   }
   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, 
                                 ClipEdgeStyle edge_style) {
 
   INHERITED::onClipRect(rect, op, edge_style);
 }
 
 void AnalysisCanvas::onClipPath(const SkPath& path, SkRegion::Op op,
                                 ClipEdgeStyle edge_style) {
@@ skipping 89 matching lines @@
       force_not_transparent_stack_level_ = kNoLayer;
     }
   }
 
   INHERITED::willRestore();
 }
 
 }  // namespace skia