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.
+  return draw_op_count_ > 1;

[enne (OOO), 2014/07/24 19:15:03]

I think you could be less conservative than 1, but I'm not going to argue too
hard.

[vmpstr, 2014/07/24 19:23:13]

I think we should leave it at 1 for now, and then check things like "if we move
this to 2, how many more tiles do we get detected as solid vs how much more time
do we spend in analysis".

At least then we can pinpoint a number that we're comfortable with. I've added a
todo here for myself.

 }
 
 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