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"
+#include "ui/gfx/skia_util.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, gfx::Rect 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() {}
 
 bool AnalysisDevice::GetColorIfSolid(SkColor* color) const {
   if (is_transparent_) {
@@ skipping 29 matching lines @@
 
   if (!is_forced_not_solid_ && SkColorGetA(color) == 255) {
     is_solid_color_ = true;
     color_ = color;
   } else {
     is_solid_color_ = false;
   }
 }
 
 void AnalysisDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
+  INHERITED::drawPaint(draw, paint);

[vangelis, 2013/11/07 01:35:03]

Do we see this method getting called for common web content?  If so, it may be
worth including it in the analysis as it could clear out a large chunk of
pixels.

[enne (OOO), 2013/11/07 22:13:50]

No.  This is not called from Blink.

   is_solid_color_ = false;
   is_transparent_ = false;
 }
 
 void AnalysisDevice::drawPoints(const SkDraw& draw,
                                 SkCanvas::PointMode mode,
                                 size_t count,
                                 const SkPoint points[],
                                 const SkPaint& paint) {
+  INHERITED::drawPoints(draw, mode, count, points, paint);
   is_solid_color_ = false;
   is_transparent_ = false;
 }
 
 void AnalysisDevice::drawRect(const SkDraw& draw,
                               const SkRect& rect,
                               const SkPaint& paint) {
-  bool does_cover_canvas =
-      IsFullQuad(draw, SkRect::MakeWH(width(), height()), 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;
-  }
+  INHERITED::drawRect(draw, rect, paint);
+  AnalyzeDrawRect(draw, rect, paint);
 }
 
 void AnalysisDevice::drawOval(const SkDraw& draw,
                               const SkRect& oval,
                               const SkPaint& paint) {
+  INHERITED::drawOval(draw, oval, paint);
   is_solid_color_ = false;
   is_transparent_ = false;
 }
 
 void AnalysisDevice::drawPath(const SkDraw& draw,
                               const SkPath& path,
                               const SkPaint& paint,
                               const SkMatrix* pre_path_matrix,
                               bool path_is_mutable) {
+  INHERITED::drawPath(draw, path, paint, pre_path_matrix, path_is_mutable);
   is_solid_color_ = false;
   is_transparent_ = false;
 }
 
 void AnalysisDevice::drawBitmap(const SkDraw& draw,
                                 const SkBitmap& bitmap,
                                 const SkMatrix& matrix,
                                 const SkPaint& paint) {
+  INHERITED::drawBitmap(draw, bitmap, matrix, paint);
   is_solid_color_ = false;
   is_transparent_ = false;
 }
 
 void AnalysisDevice::drawSprite(const SkDraw& draw,
                                 const SkBitmap& bitmap,
                                 int x,
                                 int y,
                                 const SkPaint& paint) {
+  INHERITED::drawSprite(draw, bitmap, x, y, paint);
   is_solid_color_ = false;
   is_transparent_ = false;
 }
 
 void AnalysisDevice::drawBitmapRect(const SkDraw& draw,
                                     const SkBitmap& bitmap,
                                     const SkRect* src_or_null,
-                                    const SkRect& dst,
+                                    const SkRect& rect,
                                     const SkPaint& paint,
                                     SkCanvas::DrawBitmapRectFlags flags) {
-  // Call drawRect to determine transparency,
+  INHERITED::drawBitmapRect(draw, bitmap, src_or_null, rect, paint, flags);
+
+  // Call AnalyzeDrawRect to determine transparency,
   // but reset solid color to false.
-  drawRect(draw, dst, paint);
+  AnalyzeDrawRect(draw, rect, paint);
   is_solid_color_ = false;
 }
 
 void AnalysisDevice::drawText(const SkDraw& draw,
                               const void* text,
                               size_t len,
                               SkScalar x,
                               SkScalar y,
                               const SkPaint& paint) {
+  INHERITED::drawText(draw, text, len, x, y, paint);
   is_solid_color_ = false;
   is_transparent_ = false;
   has_text_ = true;
 }
 
 void AnalysisDevice::drawPosText(const SkDraw& draw,
                                  const void* text,
                                  size_t len,
                                  const SkScalar pos[],
                                  SkScalar const_y,
                                  int scalars_per_pos,
                                  const SkPaint& paint) {
+  INHERITED::drawPosText(draw, text, len, pos, const_y, scalars_per_pos, paint);
   is_solid_color_ = false;
   is_transparent_ = false;
   has_text_ = true;
 }
 
 void AnalysisDevice::drawTextOnPath(const SkDraw& draw,
                                     const void* text,
                                     size_t len,
                                     const SkPath& path,
                                     const SkMatrix* matrix,
                                     const SkPaint& paint) {
+  INHERITED::drawTextOnPath(draw, text, len, path, matrix, paint);
   is_solid_color_ = false;
   is_transparent_ = false;
   has_text_ = true;
 }
 
 #ifdef SK_BUILD_FOR_ANDROID
 void AnalysisDevice::drawPosTextOnPath(const SkDraw& draw,
                                        const void* text,
                                        size_t len,
                                        const SkPoint pos[],
                                        const SkPaint& paint,
                                        const SkPath& path,
                                        const SkMatrix* matrix) {
+  INHERITED::drawPosTextOnPath(draw, text, len, pos, paint, path, 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) {
+  INHERITED::drawVertices(draw,
+                          mode,
+                          vertex_count,
+                          verts,
+                          texs,
+                          colors,
+                          xmode,
+                          indices,
+                          index_count,
+                          paint);
   is_solid_color_ = false;
   is_transparent_ = false;
 }
 
 void AnalysisDevice::drawDevice(const SkDraw& draw,
                                 SkBaseDevice* device,
                                 int x,
                                 int y,
                                 const SkPaint& paint) {
+  INHERITED::drawDevice(draw, device, x, y, paint);
   is_solid_color_ = false;
   is_transparent_ = false;
 }
 
 AnalysisCanvas::AnalysisCanvas(AnalysisDevice* device)
     : INHERITED(device),
       saved_stack_size_(0),
       force_not_solid_stack_level_(kNoLayer),
       force_not_transparent_stack_level_(kNoLayer) {}
 
 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_;
     (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotSolid(true);
   }
   if (force_not_transparent_stack_level_ == kNoLayer) {
     force_not_transparent_stack_level_ = saved_stack_size_;
     (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotTransparent(true);
   }
 
-  return INHERITED::clipRect(path.getBounds(), op, do_aa);
+  return INHERITED::clipPath(path, op, do_aa);
 }
 
 bool AnalysisCanvas::clipRRect(const SkRRect& rrect,
                                SkRegion::Op op,
                                bool do_aa) {
   // clipRRect 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_;
     (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotSolid(true);
   }
   if (force_not_transparent_stack_level_ == kNoLayer) {
     force_not_transparent_stack_level_ = saved_stack_size_;
     (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotTransparent(true);
   }
 
-  return INHERITED::clipRect(rrect.getBounds(), op, do_aa);
+  return INHERITED::clipRRect(rrect, op, do_aa);
 }
 
 int AnalysisCanvas::save(SkCanvas::SaveFlags flags) {
   ++saved_stack_size_;
   return INHERITED::save(flags);
 }
 
 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.
+  gfx::Rect analysis_rect =
+      static_cast<AnalysisDevice*>(getDevice())->AnalysisRect();
   if ((paint && !IsSolidColorPaint(*paint)) ||
-      (bounds && !bounds->contains(SkRect::MakeWH(getDevice()->width(),
-                                                  getDevice()->height())))) {
+      (bounds && !bounds->contains(RectToSkRect(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;
   if (paint)
     SkXfermode::AsMode(paint->getXfermode(), &xfermode);
   if (xfermode != SkXfermode::kSrc_Mode) {
     if (force_not_transparent_stack_level_ == kNoLayer) {
       force_not_transparent_stack_level_ = saved_stack_size_;
       (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotTransparent(true);
     }
   }
 
-  // Actually saving a layer here could cause a new bitmap to be created
-  // and real rendering to occur.
-  int count = INHERITED::save(flags);
-  if (bounds) {
-    INHERITED::clipRectBounds(bounds, flags, NULL);
-  }
-  return count;
+  return INHERITED::saveLayer(bounds, paint, flags);
 }
 
 void AnalysisCanvas::restore() {
   INHERITED::restore();
 
   DCHECK(saved_stack_size_);
   if (saved_stack_size_) {
     --saved_stack_size_;
     if (saved_stack_size_ < force_not_solid_stack_level_) {
       (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotSolid(false);
       force_not_solid_stack_level_ = kNoLayer;
     }
     if (saved_stack_size_ < force_not_transparent_stack_level_) {
       (static_cast<AnalysisDevice*>(getDevice()))->SetForceNotTransparent(
           false);
       force_not_transparent_stack_level_ = kNoLayer;
     }
   }
 }
 
+void AnalysisDevice::AnalyzeDrawRect(const SkDraw& draw,
+                                     const SkRect& rect,
+                                     const SkPaint& paint) {
+  bool does_cover_canvas =
+      IsFullQuad(draw, RectToSkRect(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)

[Stephen White, 2013/11/07 18:14:22]

Nit: also not new to this patch, but is it possible that an SkShader in the
paint could override the transfer mode and end up painting non-transparent here?
Don't know, but perhaps reed@ does. If so, I wonder if we should have some
helper function on SkPaint to query when a paint will definitely paint
transparent black (if that's what this test is trying to do).

[enne (OOO), 2013/11/07 22:36:10]

Such a helper function from the Skia side would be really helpful.

+  //
+  // 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;
+  }
+}
+
 }  // namespace skia
-
-