SkRecord: clean up comments and 4 bytes per SkRecord.

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
 
 #include "SkChunkAlloc.h"
 #include "SkRecords.h"
 #include "SkTLogic.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 {
+    enum {
+        kChunkBytes = 4096,
+        kFirstReserveCount = 64 / sizeof(void*),
+    };
 public:
-    SkRecord(size_t chunkBytes = 4096, unsigned firstReserveCount = 64 / sizeof(void*))
-        : fAlloc(chunkBytes), fCount(0), fReserved(0), kFirstReserveCount(firstReserveCount) {}
+    SkRecord() : fAlloc(kChunkBytes), fCount(0), fReserved(0) {}
 
     ~SkRecord() {
         Destroyer destroyer;
         for (unsigned i = 0; i < this->count(); i++) {
             this->mutate<void>(i, destroyer);
         }
     }
 
     // Returns the number of canvas commands in this SkRecord.
     unsigned count() const { return fCount; }
@@ skipping 25 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.allocThrow(SkAlignPtr(sizeof(T) * count));
     }
 
     // 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(kFirstReserveCount, fReserved*2);
+            fReserved = SkTMax<unsigned>(kFirstReserveCount, fReserved*2);
             fRecords.realloc(fReserved);
             fTypes.realloc(fReserved);
         }
 
         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.
@@ skipping 126 matching lines @@
         }
 
     private:
         void* fPtr;
     };
 
     // fAlloc needs to be a data structure which can append variable length data in contiguous
     // chunks, returning a stable handle to that data for later retrieval.
     //
     // fRecords and fTypes need to be data structures that can append fixed length data, and need to
-    // support efficient forward iteration.  (They don't need to be contiguous or indexable.)
+    // support efficient random access and forward iteration.  (They don't need to be contiguous.)
 
     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