Small tweaks and a bug fix.

src/core/SkRecordDraw.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkRecordDraw.h"
 #include "SkTSort.h"
 
@@ skipping 221 matching lines @@
     }
 
     void updateSaveBounds(const SkIRect& bounds) {
         // If we're in a Save block, expand its bounds to cover these bounds too.
         if (!fSaveStack.isEmpty()) {
             fSaveStack.top().bounds.join(bounds);
         }
     }
 
     // TODO: Remove this default when done bounding all ops.
-    template <typename T> SkIRect bounds(const T&) { return fCurrentClipBounds; }
-    SkIRect bounds(const Clear&) { return SkIRect::MakeLargest(); }  // Ignores the clip
-    SkIRect bounds(const NoOp&)  { return SkIRect::MakeEmpty(); }    // NoOps don't draw anywhere.
+    template <typename T> SkIRect bounds(const T&) const { return fCurrentClipBounds; }
+    SkIRect bounds(const Clear&) const { return SkIRect::MakeLargest(); }  // Ignores the clip
+    SkIRect bounds(const NoOp&)  const { return SkIRect::MakeEmpty(); }    // NoOps don't draw.
+
+    // Returns true if rect was meaningfully adjusted for the effects of paint,
+    // false if the paint could affect the rect in unknown ways.
+    static bool AdjustForPaint(const SkPaint* paint, SkRect* rect) {
+        if (paint) {
+            if (paint->canComputeFastBounds()) {
+                *rect = paint->computeFastBounds(*rect, rect);
+                return true;
+            }
+            return false;
+        }
+        return true;
+    }
 
     // Adjust rect for all paints that may affect its geometry, then map it to device space.
-    SkIRect adjustAndMap(SkRect rect, const SkPaint* paint) {
-        // Adjust rect for its own paint.
-        if (paint) {
-            if (paint->canComputeFastBounds()) {
-                rect = paint->computeFastBounds(rect, &rect);
-            } else {
-                // The paint could do anything.  The only safe answer is the current clip.
+    SkIRect adjustAndMap(SkRect rect, const SkPaint* paint) const {
+        // Inverted rectangles really confuse our BBHs.
+        rect.sort();
+
+        // Adjust the rect for its own paint.
+        if (!AdjustForPaint(paint, &rect)) {
+            // The paint could do anything to our bounds.  The only safe answer is the current clip.
+            return fCurrentClipBounds;
+        }
+
+        // Adjust rect for all the paints from the SaveLayers we're inside.
+        for (int i = fSaveStack.count() - 1; i >= 0; i--) {
+            if (!AdjustForPaint(fSaveStack[i].paint, &rect)) {
+                // Same deal as above.
                 return fCurrentClipBounds;
             }
         }
 
-        // Adjust rect for all the paints from the SaveLayers we're inside.
-        // For SaveLayers, only image filters will affect the bounds.
-        for (int i = fSaveStack.count() - 1; i >= 0; i--) {
-            if (fSaveStack[i].paint && fSaveStack[i].paint->getImageFilter()) {
-                if (paint->canComputeFastBounds()) {
-                    rect = fSaveStack[i].paint->computeFastBounds(rect, &rect);
-                } else {
-                    // Same deal as above.
-                    return fCurrentClipBounds;
-                }
-            }
-        }
-
         // Map the rect back to device space.
         fCTM.mapRect(&rect);
         SkIRect devRect;
         rect.roundOut(&devRect);
+
+        // Nothing can draw outside the current clip.
+        // (Only bounded ops call into this method, so oddballs like Clear don't matter here.)
+        devRect.intersect(fCurrentClipBounds);
         return devRect;
     }
 
     // Conservative device bounds for each op in the SkRecord.
     SkAutoTMalloc<SkIRect> fBounds;
 
     // We walk fCurrentOp through the SkRecord, as we go using updateCTM()
     // and updateClipBounds() to maintain the exact CTM (fCTM) and conservative
     // device bounds of the current clip (fCurrentClipBounds).
     unsigned fCurrentOp;
     SkMatrix fCTM;
     SkIRect fCurrentClipBounds;
 
     // Used to track the bounds of Save/Restore blocks and the control ops inside them.
     SkTDArray<SaveBounds> fSaveStack;
     SkTDArray<unsigned>   fControlIndices;
 };
 
 }  // namespace SkRecords
 
 void SkRecordFillBounds(const SkRecord& record, SkBBoxHierarchy* bbh) {
     SkRecords::FillBounds(record, bbh);
 }