cc: Combine analysis and raster

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/SkDevice.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"
 #include "third_party/skia/src/core/SkRasterClip.h"
-#include "ui/gfx/rect_conversions.h"
 
 namespace {
 
 const int kNoLayer = -1;
 
 bool IsSolidColorPaint(const SkPaint& paint) {
   SkXfermode::Mode xfermode;
 
   // getXfermode can return a NULL, but that is handled
   // gracefully by AsMode (NULL turns into kSrcOver mode).
@@ skipping 39 matching lines @@
   return draw.fRC->isRect() &&
          device_rect.contains(clip_rect) &&
          clip_rect.contains(canvas_rect) &&
          draw_bitmap_rect.contains(canvas_rect);
 }
 
 } // namespace
 
 namespace skia {
 
-AnalysisDevice::AnalysisDevice(const SkBitmap& bitmap)
+AnalysisDevice::AnalysisDevice(const SkBitmap& bitmap, SkRect analysis_rect)
     : INHERITED(bitmap),
+      analysis_rect_(analysis_rect),
       is_forced_not_solid_(false),
       is_forced_not_transparent_(false),
       is_solid_color_(true),
+      is_transparent_(true),
+      has_text_(false) {}
+
+AnalysisDevice::AnalysisDevice(const SkBitmap& bitmap)
+    : INHERITED(bitmap),
+      analysis_rect_(SkRect::MakeWH(bitmap.width(), bitmap.height())),
+      is_forced_not_solid_(false),
+      is_forced_not_transparent_(false),
+      is_solid_color_(true),
       is_transparent_(true),
       has_text_(false) {}
 
 AnalysisDevice::~AnalysisDevice() {}
 
 bool AnalysisDevice::GetColorIfSolid(SkColor* color) const {
   if (is_transparent_) {
     *color = SK_ColorTRANSPARENT;
     return true;
   }
@@ skipping 42 matching lines @@
                                 size_t count,
                                 const SkPoint points[],
                                 const SkPaint& paint) {
   is_solid_color_ = false;
   is_transparent_ = false;
 }
 
 void AnalysisDevice::drawRect(const SkDraw& draw,
                               const SkRect& rect,
                               const SkPaint& paint) {
+  // Early out of work where possible.  It could be the case that a picture
+  // draws text and then clears, but this is unlikely.
+  if (has_text_ && !is_solid_color_)
+    return;
+
   bool does_cover_canvas =
-      IsFullQuad(draw, SkRect::MakeWH(width(), height()), rect);
+      IsFullQuad(draw, analysis_rect_, 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
@@ skipping 120 matching lines @@
                                        const SkPaint& paint,
                                        const SkPath& path,
                                        const SkMatrix* matrix) {
   is_solid_color_ = false;
   is_transparent_ = false;
   has_text_ = true;
 }
 #endif
 
 void AnalysisDevice::drawVertices(const SkDraw& draw,
-                                  SkCanvas::VertexMode,
+                                  SkCanvas::VertexMode mode,
                                   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;
@@ skipping 17 matching lines @@
 AnalysisCanvas::~AnalysisCanvas() {}
 
 bool AnalysisCanvas::GetColorIfSolid(SkColor* color) const {
   return (static_cast<AnalysisDevice*>(getDevice()))->GetColorIfSolid(color);
 }
 
 bool AnalysisCanvas::HasText() const {
   return (static_cast<AnalysisDevice*>(getDevice()))->HasText();
 }
 
-bool AnalysisCanvas::abortDrawing() {
-  // Early out as soon as we have detected that the tile has text.
-  return HasText();
-}
-
 bool AnalysisCanvas::clipRect(const SkRect& rect, SkRegion::Op op, bool do_aa) {
   return INHERITED::clipRect(rect, op, do_aa);
 }
 
 bool AnalysisCanvas::clipPath(const SkPath& path, SkRegion::Op op, bool do_aa) {
   // clipPaths can make our calls to IsFullQuad invalid (ie have false
   // positives). As a precaution, force the setting to be non-solid
   // and non-transparent until we pop this
   if (force_not_solid_stack_level_ == kNoLayer) {
     force_not_solid_stack_level_ = saved_stack_size_;
@@ skipping 31 matching lines @@
 }
 
 int AnalysisCanvas::saveLayer(const SkRect* bounds,
                               const SkPaint* paint,
                               SkCanvas::SaveFlags flags) {
   ++saved_stack_size_;
 
   // If after we draw to the saved layer, we have to blend with the current
   // layer, then we can conservatively say that the canvas will not be of
   // solid color.
+  SkRect analysis_rect =
+      static_cast<AnalysisDevice*>(getDevice())->AnalysisRect();
   if ((paint && !IsSolidColorPaint(*paint)) ||
-      (bounds && !bounds->contains(SkRect::MakeWH(getDevice()->width(),
-                                                  getDevice()->height())))) {
+      (bounds && !bounds->contains(analysis_rect))) {
     if (force_not_solid_stack_level_ == kNoLayer) {
       force_not_solid_stack_level_ = saved_stack_size_;
       (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotSolid(true);
     }
   }
 
   // If after we draw to the save layer, we have to blend with the current
   // layer using any part of the current layer's alpha, then we can
   // conservatively say that the canvas will not be transparent.
   SkXfermode::Mode xfermode = SkXfermode::kSrc_Mode;
@@ skipping 29 matching lines @@
       (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotTransparent(
           false);
       force_not_transparent_stack_level_ = kNoLayer;
     }
   }
 }
 
 }  // namespace skia