Unfurl catch-all bounds(). This makes it a little easier to track progress.

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 167 matching lines @@
     void updateClipBounds(const ClipRegion& op) { fCurrentClipBounds = op.devBounds; }
     void updateClipBounds(const SaveLayer& op)  {
         if (op.bounds) {
             fCurrentClipBounds.intersect(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); }
-    // TODO: bounds of SaveLayer may be more complicated?
     void trackBounds(const SaveLayer& op)  { this->pushSaveBlock(op.paint); }
     void trackBounds(const Restore&) { fBounds[fCurrentOp] = this->popSaveBlock(); }
 
-    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 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(); }

[robertphillips, 2014/08/25 20:28:19]

Seems like we should do more with the culling information.

[mtklein, 2014/08/25 20:36:12]

Yes.  It's a little moot right now because we're not getting these at the
moment.  But we could do the same sort of thing we do with save layer bounds,
clipping the bounds down further as we receive pushCulls (and newly, undoing
that when we hit a popCull()).

+    void trackBounds(const PushCull&)          { this->pushControl(); }
+    void trackBounds(const PopCull&)           { this->pushControl(); }

[robertphillips, 2014/08/25 20:28:19]

Could these guys be treated like Noop (since they don't draw) ?

[mtklein, 2014/08/25 20:36:13]

Could be, but then we'd be in the odd spot of playing back something different
than was recorded.  NoOps aren't ever recorded, so we can do whatever we like
with them, but it'd really be a bad idea for us to swallow culls if the target
canvas was looking for them.

+    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);
         this->updateSaveBounds(fBounds[fCurrentOp]);
     }
 
     void pushSaveBlock(const SkPaint* paint) {
         // Starting a new Save block.  Push a new entry to represent that.
         SaveBounds sb = { 0, SkIRect::MakeEmpty(), paint };
@@ skipping 38 matching lines @@
         fControlIndices.pop();
     }
 
     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(mtklein): Remove this default when done bounding all ops.
-    template <typename T> SkIRect bounds(const T&) const { return fCurrentClipBounds; }
+    // FIXME: these methods could use better bounds
+    SkIRect bounds(const DrawPatch&)      const { return fCurrentClipBounds; }
+    SkIRect bounds(const DrawPicture&)    const { return fCurrentClipBounds; }
+    SkIRect bounds(const DrawTextOnPath&) const { return fCurrentClipBounds; }
+    SkIRect bounds(const DrawSprite&)     const { return fCurrentClipBounds; }
+    SkIRect bounds(const DrawTextBlob&)   const { return fCurrentClipBounds; }
+    SkIRect bounds(const DrawText&)       const { return fCurrentClipBounds; }
+    SkIRect bounds(const DrawVertices&)   const { return fCurrentClipBounds; }
+    //  end of methods that could use better bounds
+
     SkIRect bounds(const Clear&) const { return SkIRect::MakeLargest(); }  // Ignores the clip
+    SkIRect bounds(const DrawPaint&) const { return fCurrentClipBounds; }
     SkIRect bounds(const NoOp&)  const { return SkIRect::MakeEmpty(); }    // NoOps don't draw.
 
     SkIRect bounds(const DrawRect& op) const { return this->adjustAndMap(op.rect, &op.paint); }
     SkIRect bounds(const DrawOval& op) const { return this->adjustAndMap(op.oval, &op.paint); }
     SkIRect bounds(const DrawRRect& op) const {
         return this->adjustAndMap(op.rrect.rect(), &op.paint);
     }
     SkIRect bounds(const DrawDRRect& op) const {
         return this->adjustAndMap(op.outer.rect(), &op.paint);
     }
@@ skipping 136 matching lines @@
     // 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);
 }