Update SkPicture cull rects with RTree information

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 "SkLayerInfo.h"
 #include "SkRecordDraw.h"
 #include "SkPatchUtils.h"
@@ skipping 230 matching lines @@
     void updateClipBounds(const ClipPath&   op) { this->updateClipBoundsForClipOp(op.devBounds); }
     void updateClipBounds(const ClipRRect&  op) { this->updateClipBoundsForClipOp(op.devBounds); }
     void updateClipBounds(const ClipRect&   op) { this->updateClipBoundsForClipOp(op.devBounds); }
     void updateClipBounds(const ClipRegion& op) { this->updateClipBoundsForClipOp(op.devBounds); }
 
     // The bounds of clip ops need to be adjusted for the paints of saveLayers they're inside.
     void updateClipBoundsForClipOp(const SkIRect& devBounds) {
         Bounds clip = SkRect::Make(devBounds);
         // We don't call adjustAndMap() because as its last step it would intersect the adjusted
         // clip bounds with the previous clip, exactly what we can't do when the clip grows.
-        fCurrentClipBounds = this->adjustForSaveLayerPaints(&clip) ? clip : fCullRect;
+        bool isBoundedClip = this->adjustForSaveLayerPaints(&clip);
+        if (isBoundedClip) {

[mtklein, 2015/03/06 18:18:50]

Let's definitely create a little method for the assert on 261+262. 
SkASSERT(this->currentClipInsideCullRect()) or something like that.

I'm okay repeating this logic here if we tighten it up a bit, and I also am ok
with extracting it as its own little method.  Here's what I'd suggest if we
leave this in place:

if (this->adjustForSaveLayerPaints(&clip, ...)) {
  fCurrentClipBounds = clip.intersect(fCullRect) ? clip : Bounds::MakeEmpty();
} else {
  fCurrentClipBounds = fCullRect;
}

+            bool intersects = clip.intersect(fCullRect);
+            if (intersects)
+                fCurrentClipBounds = clip;
+            else
+                fCurrentClipBounds = Bounds::MakeEmpty();
+        } else {
+            fCurrentClipBounds = fCullRect;
+        }
+        SkASSERT((fCurrentClipBounds.isEmpty() || fCullRect.contains(fCurrentClipBounds))
+            || (fCurrentClipBounds.isEmpty() && fCullRect.isEmpty()));
     }
 
     // Restore holds the devBounds for the clip after the {save,saveLayer}/restore block completes.
     void updateClipBounds(const Restore& op) {
         // This is just like the clip ops above, but we need to skip the effects (if any) of our
         // paired saveLayer (if it is one); it has not yet been popped off the save stack.  Our
         // devBounds reflect the state of the world after the saveLayer/restore block is done,
         // so they are not affected by the saveLayer's paint.
         const int kSavesToIgnore = 1;
         Bounds clip = SkRect::Make(op.devBounds);
-        fCurrentClipBounds =
-            this->adjustForSaveLayerPaints(&clip, kSavesToIgnore) ? clip : fCullRect;
+        bool isBoundedClip = this->adjustForSaveLayerPaints(&clip, kSavesToIgnore);
+        if (isBoundedClip) {
+            bool intersects = clip.intersect(fCullRect);
+            if (intersects)
+                fCurrentClipBounds = clip;
+            else
+                fCurrentClipBounds = Bounds::MakeEmpty();
+        } else {
+            fCurrentClipBounds = fCullRect;
+        }
+        SkASSERT((fCurrentClipBounds.isEmpty() || fCullRect.contains(fCurrentClipBounds))
+            || (fCurrentClipBounds.isEmpty() && fCullRect.isEmpty()));
     }
 
     // We also take advantage of SaveLayer bounds when present to further cut the clip down.
     void updateClipBounds(const SaveLayer& op)  {
         if (op.bounds) {
             // adjustAndMap() intersects these layer bounds with the previous clip for us.
             fCurrentClipBounds = this->adjustAndMap(*op.bounds, op.paint);
+            SkASSERT((fCurrentClipBounds.isEmpty() || fCullRect.contains(fCurrentClipBounds))
+                || (fCurrentClipBounds.isEmpty() && fCullRect.isEmpty()));
         }
     }
 
     // The bounds of these ops must be calculated when we hit the Restore
     // from the bounds of the ops in the same Save block.
     void trackBounds(const Save&)          { this->pushSaveBlock(NULL); }
     void trackBounds(const SaveLayer& op)  { this->pushSaveBlock(op.paint); }
-    void trackBounds(const Restore&) { fBounds[fCurrentOp] = this->popSaveBlock(); }
+    void trackBounds(const Restore&) {
+        fBounds[fCurrentOp] = this->popSaveBlock();
+        SkASSERT((fBounds[fCurrentOp].isEmpty() || fCullRect.contains(fBounds[fCurrentOp]))
+            || (fBounds[fCurrentOp].isEmpty() && fCullRect.isEmpty()));
+    }
 
     void trackBounds(const SetMatrix&)         { this->pushControl(); }
     void trackBounds(const ClipRect&)          { this->pushControl(); }
     void trackBounds(const ClipRRect&)         { this->pushControl(); }
     void trackBounds(const ClipPath&)          { this->pushControl(); }
     void trackBounds(const ClipRegion&)        { this->pushControl(); }
     void trackBounds(const BeginCommentGroup&) { this->pushControl(); }
     void trackBounds(const AddComment&)        { this->pushControl(); }
     void trackBounds(const EndCommentGroup&)   { this->pushControl(); }
 
     // For all other ops, we can calculate and store the bounds directly now.
     template <typename T> void trackBounds(const T& op) {
         fBounds[fCurrentOp] = this->bounds(op);
+        SkASSERT((fBounds[fCurrentOp].isEmpty() || fCullRect.contains(fBounds[fCurrentOp]))
+            || (fBounds[fCurrentOp].isEmpty() && fCullRect.isEmpty()));
         this->updateSaveBounds(fBounds[fCurrentOp]);
     }
 
     void pushSaveBlock(const SkPaint* paint) {
         // Starting a new Save block.  Push a new entry to represent that.
         SaveBounds sb;
         sb.controlOps = 0;
         // If the paint affects transparent black, the bound shouldn't be smaller
         // than the current clip bounds.
         sb.bounds =
@@ skipping 61 matching lines @@
     }
 
     void pushControl() {
         fControlIndices.push(fCurrentOp);
         if (!fSaveStack.isEmpty()) {
             fSaveStack.top().controlOps++;
         }
     }
 
     void popControl(const Bounds& bounds) {
+        SkASSERT((bounds.isEmpty() || fCullRect.contains(bounds))
+            || (bounds.isEmpty() && fCullRect.isEmpty()));
         fBounds[fControlIndices.top()] = bounds;
         fControlIndices.pop();
     }
 
     void updateSaveBounds(const Bounds& bounds) {
         // If we're in a Save block, expand its bounds to cover these bounds too.
         if (!fSaveStack.isEmpty()) {
             fSaveStack.top().bounds.join(bounds);
         }
     }
@@ skipping 408 matching lines @@
     SkRecords::CollectLayers visitor(cullRect, record, pictList, data);
 
     for (unsigned curOp = 0; curOp < record.count(); curOp++) {
         visitor.setCurrentOp(curOp);
         record.visit<void>(curOp, visitor);
     }
 
     visitor.cleanUp(bbh);
 }