cc: Merge GatherPixelRefs and AnalyzeInRect

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 "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 {
 
 // FIXME: Arbitrary number. Requires tuning & experimentation.
 // Probably requires per-platform tuning; N10 average draw call takes
 // 25x as long as Z620.
 const int gPictureCostThreshold = 1000;
 
+// URI label for a lazily decoded SkPixelRef.
+const char labelLazyDecoded[] = "lazy";

[Sami, 2013/03/18 12:14:33]

const char kLabelLazyDecoded[] = ...

+
 static 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).
   SkXfermode::AsMode(paint.getXfermode(), &xferMode);
 
   // Paint is solid color if the following holds:
   // - Alpha is 1.0, style is fill, and there are no special effects
   // - Xfer mode is either kSrc or kSrcOver (kSrcOver is equivalent
@@ skipping 74 matching lines @@
   if (isForcedNotSolid_)
     isSolidColor_ = false;
 }
 
 void AnalysisDevice::setForceNotTransparent(bool flag) {
   isForcedNotTransparent_ = flag;
   if (isForcedNotTransparent_)
     isTransparent_ = false;
 }
 
+void AnalysisDevice::addPixelRefIfLazy(SkPixelRef* pixelRef) {
+  if (!pixelRef)
+    return;
+
+  uint32_t genID = pixelRef->getGenerationID();
+
+  // If this ID exists (whether it is lazy pixel ref or not),
+  // we can return early.
+  std::pair<base::hash_set<uint32_t>::iterator, bool> insertionResult =
+      existingPixelRefIDs_.insert(genID);
+  if (!insertionResult.second)
+    return;
+
+  if (pixelRef->getURI() &&
+      !strncmp(pixelRef->getURI(), labelLazyDecoded, 4)) {

[Sami, 2013/03/18 12:14:33]

Use a named constant instead of 4.

+    lazyPixelRefs_.push_back(static_cast<skia::LazyPixelRef*>(pixelRef));
+  }
+}
+
+void AnalysisDevice::addBitmap(const SkBitmap& bitmap) {
+  addPixelRefIfLazy(bitmap.pixelRef());
+}
+
+void AnalysisDevice::addBitmapFromPaint(const SkPaint& paint) {
+  SkShader* shader = paint.getShader();
+  if (shader) {
+    SkBitmap bitmap;
+    // Check whether the shader is a gradient in order to short-circuit
+    // call to asABitmap to prevent generation of bitmaps from
+    // gradient shaders, which implement asABitmap.
+    if (SkShader::kNone_GradientType == shader->asAGradient(NULL) &&
+        SkShader::kNone_BitmapType != shader->asABitmap(&bitmap, NULL, NULL)) {
+        addPixelRefIfLazy(bitmap.pixelRef());
+    }
+  }
+}
+
+void AnalysisDevice::consumeLazyPixelRefs(std::list<LazyPixelRef*>& pixelRefs) {
+  DCHECK(pixelRefs.empty());
+  lazyPixelRefs_.swap(pixelRefs);
+  existingPixelRefIDs_.clear();
+}
+
 void AnalysisDevice::clear(SkColor color) {
   ++estimatedCost_;
 
   isTransparent_ = (!isForcedNotTransparent_ && SkColorGetA(color) == 0);
 
   if (!isForcedNotSolid_ && SkColorGetA(color) == 255) {
     isSolidColor_ = true;
     color_ = color;
   }
   else {
     isSolidColor_ = false;
   }
 }
 
 void AnalysisDevice::drawPaint(const SkDraw&, const SkPaint& paint) {
   ++estimatedCost_;
   isSolidColor_ = false;
   isTransparent_ = false;
+  addBitmapFromPaint(paint);

[Tom Hudson, 2013/03/18 11:52:39]

Hmm, idiomatically this isn't how I expected drawPaint to be used, but it looks
like RenderWidget::PaintRect() will hit this.

 }
 
 void AnalysisDevice::drawPoints(const SkDraw&, SkCanvas::PointMode mode,
                           size_t count, const SkPoint[],
                           const SkPaint& paint) {
   ++estimatedCost_;
   isSolidColor_ = false;
   isTransparent_ = false;
+  addBitmapFromPaint(paint);
 }
 
 void AnalysisDevice::drawRect(const SkDraw& draw, const SkRect& rect,
                         const SkPaint& paint) {
 
   // FIXME: if there's a pending image decode & resize, more expensive
   if (paint.getMaskFilter()) {
     estimatedCost_ += 300;
   }
   ++estimatedCost_;
-
+  addBitmapFromPaint(paint);
   bool doesCoverCanvas = 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
@@ skipping 27 matching lines @@
   else {
     isSolidColor_ = false;
   }
 }
 
 void AnalysisDevice::drawOval(const SkDraw&, const SkRect& oval,
                         const SkPaint& paint) {
   ++estimatedCost_;
   isSolidColor_ = false;
   isTransparent_ = false;
+  addBitmapFromPaint(paint);
 }
 
 void AnalysisDevice::drawPath(const SkDraw&, const SkPath& path,
                         const SkPaint& paint,
                         const SkMatrix* prePathMatrix ,
                         bool pathIsMutable ) {
   // On Z620, every antialiased path costs us about 300us.
   // We've only seen this in practice on filled paths, but
   // we expect it to apply to all path stroking modes.
   if (paint.getMaskFilter()) {
     estimatedCost_ += 300;
   }
   ++estimatedCost_;
   isSolidColor_ = false;
   isTransparent_ = false;
+  addBitmapFromPaint(paint);
 }
 
 void AnalysisDevice::drawBitmap(const SkDraw&, const SkBitmap& bitmap,
                           const SkIRect* srcRectOrNull,
                           const SkMatrix& matrix, const SkPaint& paint) {
   ++estimatedCost_;
   isSolidColor_ = false;
   isTransparent_ = false;
+  addBitmap(bitmap);
 }
 
 void AnalysisDevice::drawSprite(const SkDraw&, const SkBitmap& bitmap,
                           int x, int y, const SkPaint& paint) {
   ++estimatedCost_;
   isSolidColor_ = false;
   isTransparent_ = false;
+  addBitmap(bitmap);
 }
 
-void AnalysisDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap&,
+void AnalysisDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
                               const SkRect* srcOrNull, const SkRect& dst,
                               const SkPaint& paint) {
   ++estimatedCost_;
 
   // Call drawRect to determine transparency,
   // but reset solid color to false.
   drawRect(draw, dst, paint);
   isSolidColor_ = false;
+  addBitmap(bitmap);
 }
 
 
 void AnalysisDevice::drawText(const SkDraw&, const void* text, size_t len,
                         SkScalar x, SkScalar y, const SkPaint& paint) {
   ++estimatedCost_;
   isSolidColor_ = false;
   isTransparent_ = false;
+  addBitmapFromPaint(paint);
 }
 
 void AnalysisDevice::drawPosText(const SkDraw& draw, const void* text, size_t len,
                            const SkScalar pos[], SkScalar constY,
                            int scalarsPerPos, const SkPaint& paint) {
   // FIXME: On Z620, every glyph cache miss costs us about 10us.
   // We don't have a good mechanism for predicting glyph cache misses.
   ++estimatedCost_;
   isSolidColor_ = false;
   isTransparent_ = false;
+  addBitmapFromPaint(paint);
 }
 
 void AnalysisDevice::drawTextOnPath(const SkDraw&, const void* text, size_t len,
                               const SkPath& path, const SkMatrix* matrix,
                               const SkPaint& paint) {
   ++estimatedCost_;
   isSolidColor_ = false;
   isTransparent_ = false;
+  addBitmapFromPaint(paint);
 }
 
 #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) {
   ++estimatedCost_;
   isSolidColor_ = false;
   isTransparent_ = false;
+  addBitmapFromPaint(paint);
 }
 #endif
 
 void AnalysisDevice::drawVertices(const SkDraw&, SkCanvas::VertexMode,
                             int vertexCount,
                             const SkPoint verts[], const SkPoint texs[],
                             const SkColor colors[], SkXfermode* xmode,
                             const uint16_t indices[], int indexCount,
                             const SkPaint& paint) {
   ++estimatedCost_;
   isSolidColor_ = false;
   isTransparent_ = false;
+  addBitmapFromPaint(paint);
 }
 
 void AnalysisDevice::drawDevice(const SkDraw&, SkDevice*, int x, int y,
                           const SkPaint&) {
   ++estimatedCost_;
   isSolidColor_ = false;
   isTransparent_ = false;
 }
 
 
@@ skipping 19 matching lines @@
 }
 
 bool AnalysisCanvas::isTransparent() const {
   return (static_cast<AnalysisDevice*>(getDevice()))->isTransparent();
 }
 
 int AnalysisCanvas::getEstimatedCost() const {
   return (static_cast<AnalysisDevice*>(getDevice()))->getEstimatedCost();
 }
 
+void AnalysisCanvas::consumeLazyPixelRefs(std::list<LazyPixelRef*>& pixelRefs) {
+  static_cast<AnalysisDevice*>(getDevice())->consumeLazyPixelRefs(pixelRefs);
+}
+
 bool AnalysisCanvas::clipRect(const SkRect& rect, SkRegion::Op op,
                         bool doAA) {
   return INHERITED::clipRect(rect, op, doAA);
 }
 
 bool AnalysisCanvas::clipPath(const SkPath& path, SkRegion::Op op,
                         bool doAA) {
   // 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 
@@ skipping 82 matching lines @@
     if (savedStackSize_ < forceNotTransparentStackLevel_) {
       (static_cast<AnalysisDevice*>(getDevice()))->setForceNotTransparent(false);
       forceNotTransparentStackLevel_ = kNoLayer;
     }
   }
 }
 
 }  // namespace skia