SkRecord: make culling work if SkRecordAnnotateCullingPairs is called.

src/record/SkRecord.h

 #ifndef SkRecord_DEFINED
 #define SkRecord_DEFINED
 
 #include "SkChunkAlloc.h"
 #include "SkRecords.h"
 #include "SkTemplates.h"
 
 // SkRecord (REC-ord) represents a sequence of SkCanvas calls, saved for future use.
 // These future uses may include: replay, optimization, serialization, or combinations of those.
 //
 // Though an enterprising user may find calling alloc(), append(), visit(), and mutate() enough to
 // work with SkRecord, you probably want to look at SkRecorder which presents an SkCanvas interface
 // for creating an SkRecord, and SkRecordDraw which plays an SkRecord back into another SkCanvas.
 //
 // SkRecord often looks like it's compatible with any type T, but really it's compatible with any
 // type T which has a static const SkRecords::Type kType.  That is to say, SkRecord is compatible
 // only with SkRecords::* structs defined in SkRecords.h.  Your compiler will helpfully yell if you
 // get this wrong.
 
 class SkRecord : SkNoncopyable {
 public:
     SkRecord(size_t chunkBytes = 4096, unsigned firstReserveCount = 64 / sizeof(void*))
         : fAlloc(chunkBytes), fCount(0), fReserved(0), kFirstReserveCount(firstReserveCount) {}
-    ~SkRecord() { this->mutate(Destroyer()); }
+
+    ~SkRecord() {
+        Destroyer destroyer;
+        this->mutate(destroyer);
+    }
+
+    unsigned count() const { return fCount; }
 
     // Accepts a visitor functor with this interface:
     //   template <typename T>
-    //   void operator()()(const T& record) { ... }
+    //   void operator()(const T& record) { ... }
     // This operator() must be defined for at least all SkRecords::*; your compiler will help you
     // get this right.
-    //
-    // f will be called on each recorded canvas call in the order they were append()ed.
     template <typename F>
-    void visit(F f) const {
+    void visit(unsigned i, F& f) const {
+        SkASSERT(i < this->count());
+        fRecords[i].visit(fTypes[i], f);
+    }
+
+    // As above.  f will be called on each recorded canvas call in the order they were append()ed.
+    template <typename F>
+    void visit(F& f) const {
         for (unsigned i = 0; i < fCount; i++) {
-            fRecords[i].visit(fTypes[i], f);
+            this->visit(i, f);
         }
     }
 
     // Accepts a visitor functor with this interface:
     //   template <typename T>
-    //   void operator()()(T* record) { ... }
+    //   void operator()(T* record) { ... }
     // This operator() must be defined for at least all SkRecords::*; again, your compiler will help
     // you get this right.
-    //
-    // f will be called on each recorded canvas call in the order they were append()ed.
     template <typename F>
-    void mutate(F f) {
+    void mutate(unsigned i, F& f) {
+        SkASSERT(i < this->count());
+        fRecords[i].mutate(fTypes[i], f);
+    }
+
+    // As above.  f will be called on each recorded canvas call in the order they were append()ed.
+    template <typename F>
+    void mutate(F& f) {
         for (unsigned i = 0; i < fCount; i++) {
-            fRecords[i].mutate(fTypes[i], f);
+            this->mutate(i, f);
         }
     }
 
     // Allocate contiguous space for count Ts, to be destroyed (not just freed) when the SkRecord is
     // destroyed.  For classes with constructors, placement new into this array.  Throws on failure.
     // Here T can really be any class, not just those from SkRecords.
     template <typename T>
     T* alloc(unsigned count = 1) {
         return (T*)fAlloc.allocThrow(sizeof(T) * count);
     }
@@ skipping 86 matching lines @@
         T* alloc(SkRecord* record) {
             if (IsLarge<T>()) {
                 fRecord = (uintptr_t)record->alloc<T>();
             }
             return this->ptr<T>();
         }
 
         // Visit this record with functor F (see public API above) assuming the record we're
         // pointing to has this type.
         template <typename F>
-        void visit(Type8 type, F f) const {
+        void visit(Type8 type, F& f) const {
         #define CASE(T) case SkRecords::T##_Type: return f(*this->ptr<SkRecords::T>());
             switch(type) { SK_RECORD_TYPES(CASE) }
         #undef CASE
         }
 
         // Mutate this record with functor F (see public API above) assuming the record we're
         // pointing to has this type.
         template <typename F>
-        void mutate(Type8 type, F f) {
+        void mutate(Type8 type, F& f) {
         #define CASE(T) case SkRecords::T##_Type: return f(this->ptr<SkRecords::T>());
             switch(type) { SK_RECORD_TYPES(CASE) }
         #undef CASE
         }
 
     private:
         template <typename T>
         T* ptr() const { return (T*)(IsLarge<T>() ? (void*)fRecord : &fRecord); }
 
         // Is T too big to fit directly into a uintptr_t, neededing external allocation?
@@ skipping 12 matching lines @@
     SkChunkAlloc fAlloc;
     SkAutoTMalloc<Record> fRecords;
     SkAutoTMalloc<Type8> fTypes;
     // fCount and fReserved measure both fRecords and fTypes, which always grow in lock step.
     unsigned fCount;
     unsigned fReserved;
     const unsigned kFirstReserveCount;
 };
 
 #endif//SkRecord_DEFINED