SkRecord: outline methods that are not called O(N) times.

src/core/SkRecord.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkRecord_DEFINED
 #define SkRecord_DEFINED
 
@@ skipping 13 matching lines @@
 // 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 {
     enum {
         kFirstReserveCount = 64 / sizeof(void*),
     };
 public:
     SkRecord() : fCount(0), fReserved(0) {}
-
-    ~SkRecord() {
-        Destroyer destroyer;
-        for (unsigned i = 0; i < this->count(); i++) {
-            this->mutate<void>(i, destroyer);
-        }
-    }
+    ~SkRecord();
 
     // Returns the number of canvas commands in this SkRecord.
     unsigned count() const { return fCount; }
 
     // Visit the i-th canvas command with a functor matching this interface:
     //   template <typename T>
     //   R operator()(const T& record) { ... }
     // This operator() must be defined for at least all SkRecords::*.
     template <typename R, typename F>
     R visit(unsigned i, F& f) const {
@@ skipping 18 matching lines @@
     T* alloc(size_t count = 1) {
         // Bump up to the next pointer width if needed, so all allocations start pointer-aligned.
         return (T*)fAlloc.alloc(sizeof(T) * count, SK_MALLOC_THROW);
     }
 
     // Add a new command of type T to the end of this SkRecord.
     // You are expected to placement new an object of type T onto this pointer.
     template <typename T>
     T* append() {
         if (fCount == fReserved) {
-            fReserved = SkTMax<unsigned>(kFirstReserveCount, fReserved*2);
-            fRecords.realloc(fReserved);
-            fTypes.realloc(fReserved);
+            this->grow();
         }
-
         fTypes[fCount] = T::kType;
         return fRecords[fCount++].set(this->allocCommand<T>());
     }
 
     // Replace the i-th command with a new command of type T.
     // You are expected to placement new an object of type T onto this pointer.
     // References to the original command are invalidated.
     template <typename T>
     T* replace(unsigned i) {
         SkASSERT(i < this->count());
@@ skipping 14 matching lines @@
 
         SkASSERT(Existing::kType == fTypes[i]);
         SkASSERT(proofOfAdoption == fRecords[i].ptr<Existing>());
 
         fTypes[i] = T::kType;
         return fRecords[i].set(this->allocCommand<T>());
     }
 
     // Does not return the bytes in any pointers embedded in the Records; callers
     // need to iterate with a visitor to measure those they care for.
-    size_t bytesUsed() const { return fAlloc.approxBytesAllocated() +
-                                      fReserved * (sizeof(Record) + sizeof(Type8)) +
-                                      sizeof(SkRecord); }
+    size_t bytesUsed() const;
 
 private:
     // Implementation notes!
     //
     // Logically an SkRecord is structured as an array of pointers into a big chunk of memory where
     // records representing each canvas draw call are stored:
     //
     // fRecords:  [*][*][*]...
     //             |  |  |
     //             |  |  |
@@ skipping 46 matching lines @@
     // We could just return NULL but it's sort of confusing to return NULL on success.
     template <typename T>
     SK_WHEN(SkTIsEmpty<T>, T*) allocCommand() {
         static T singleton = {};
         return &singleton;
     }
 
     template <typename T>
     SK_WHEN(!SkTIsEmpty<T>, T*) allocCommand() { return this->alloc<T>(); }
 
+    // Called when we've run out of room to record new commands.
+    void grow();
+
     // An untyped pointer to some bytes in fAlloc.  This is the interface for polymorphic dispatch:
     // visit() and mutate() work with the parallel fTypes array to do the work of a vtable.
     struct Record {
     public:
         // Point this record to its data in fAlloc.  Returns ptr for convenience.
         template <typename T>
         T* set(T* ptr) {
             fPtr = ptr;
             return ptr;
         }
@@ skipping 39 matching lines @@
     unsigned fReserved;
     SkAutoTMalloc<Record> fRecords;
     SkAutoTMalloc<Type8> fTypes;
     SkVarAlloc fAlloc;
     // Strangely the order of these fields matters.  If the unsigneds don't go first we're 56 bytes.
     // tomhudson and mtklein have no idea why.
 };
 SK_COMPILE_ASSERT(sizeof(SkRecord) <= 48, SkRecordSize);
 
 #endif//SkRecord_DEFINED