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;
+        if (this->adjustForSaveLayerPaints(&clip)) {
+            fCurrentClipBounds = clip.intersect(fCullRect) ? clip : Bounds::MakeEmpty();
+        } else {
+            fCurrentClipBounds = fCullRect;
+        }
     }
 
     // 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;
+        if (this->adjustForSaveLayerPaints(&clip, kSavesToIgnore)) {
+            fCurrentClipBounds = clip.intersect(fCullRect) ? clip : Bounds::MakeEmpty();
+        } else {
+            fCurrentClipBounds = fCullRect;
+        }
     }
 
     // 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);
         }
     }
 
     // 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();

[mtklein, 2015/03/06 20:54:25]

Might want to put this guy back on one line?

+    }
 
     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(); }
 
@@ skipping 91 matching lines @@
             fSaveStack.top().bounds.join(bounds);
         }
     }
 
     // FIXME: this method could use better bounds
     Bounds bounds(const DrawText&) const { return fCurrentClipBounds; }
 
     Bounds bounds(const DrawPaint&) const { return fCurrentClipBounds; }
     Bounds bounds(const NoOp&)  const { return Bounds::MakeEmpty(); }    // NoOps don't draw.
 
-    Bounds bounds(const DrawSprite& op) const {  // Ignores the matrix.
-        return Bounds::MakeXYWH(op.left, op.top, op.bitmap.width(), op.bitmap.height());
+    Bounds bounds(const DrawSprite& op) const {  // Ignores the matrix, but respects the clip.
+        SkRect rect = Bounds::MakeXYWH(op.left, op.top, op.bitmap.width(), op.bitmap.height());
+        if (!rect.intersect(fCurrentClipBounds)) {
+            return Bounds::MakeEmpty();
+        }
+        return rect;
     }
 
     Bounds bounds(const DrawRect& op) const { return this->adjustAndMap(op.rect, &op.paint); }
     Bounds bounds(const DrawOval& op) const { return this->adjustAndMap(op.oval, &op.paint); }
     Bounds bounds(const DrawRRect& op) const {
         return this->adjustAndMap(op.rrect.rect(), &op.paint);
     }
     Bounds bounds(const DrawDRRect& op) const {
         return this->adjustAndMap(op.outer.rect(), &op.paint);
     }
@@ skipping 385 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);
 }