diff --git a/gyp/core.gypi b/gyp/core.gypi
index 2239058..01838a3 100644
--- a/gyp/core.gypi
+++ b/gyp/core.gypi
@@ -209,6 +209,7 @@
         '<(skia_src_path)/core/SkUnPreMultiply.cpp',
         '<(skia_src_path)/core/SkUtils.cpp',
         '<(skia_src_path)/core/SkValidatingReadBuffer.cpp',
+        '<(skia_src_path)/core/SkVarAlloc.cpp',
         '<(skia_src_path)/core/SkVertState.cpp',
         '<(skia_src_path)/core/SkWriteBuffer.cpp',
         '<(skia_src_path)/core/SkWriter32.cpp',
diff --git a/src/core/SkRecord.h b/src/core/SkRecord.h
index 5362d91..8302db4 100644
--- a/src/core/SkRecord.h
+++ b/src/core/SkRecord.h
@@ -8,10 +8,10 @@
 #ifndef SkRecord_DEFINED
 #define SkRecord_DEFINED
 
-#include "SkChunkAlloc.h"
 #include "SkRecords.h"
 #include "SkTLogic.h"
 #include "SkTemplates.h"
+#include "SkVarAlloc.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.
@@ -27,11 +27,10 @@
 
 class SkRecord : SkNoncopyable {
     enum {
-        kChunkBytes = 4096,
         kFirstReserveCount = 64 / sizeof(void*),
     };
 public:
-    SkRecord() : fAlloc(kChunkBytes), fCount(0), fReserved(0) {}
+    SkRecord() : fAlloc(1024, 2.0f), fCount(0), fReserved(0) {}
 
     ~SkRecord() {
         Destroyer destroyer;
@@ -69,7 +68,7 @@
     template <typename T>
     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));
+        return (T*)fAlloc.alloc(sizeof(T) * count, SK_MALLOC_THROW);
     }
 
     // Add a new command of type T to the end of this SkRecord.
@@ -226,7 +225,7 @@
     // fRecords and fTypes need to be data structures that can append fixed length data, and need to
     // support efficient random access and forward iteration.  (They don't need to be contiguous.)
 
-    SkChunkAlloc fAlloc;
+    SkVarAlloc fAlloc;
     SkAutoTMalloc<Record> fRecords;
     SkAutoTMalloc<Type8> fTypes;
     // fCount and fReserved measure both fRecords and fTypes, which always grow in lock step.
diff --git a/src/core/SkVarAlloc.cpp b/src/core/SkVarAlloc.cpp
new file mode 100644
index 0000000..5c3a41c
--- /dev/null
+++ b/src/core/SkVarAlloc.cpp
@@ -0,0 +1,56 @@
+#include "SkVarAlloc.h"
+#include "SkScalar.h"
+
+// We use non-standard malloc diagnostic methods to make sure our allocations are sized well.
+#if defined(SK_BUILD_FOR_MAC)
+    #include <malloc/malloc.h>
+#elif defined(SK_BUILD_FOR_LINUX)
+    #include <malloc.h>
+#endif
+
+struct SkVarAlloc::Block {
+    Block* prev;
+    char* data() { return (char*)(this + 1); }
+
+    static Block* Alloc(Block* prev, size_t size, unsigned flags) {
+        SkASSERT(size >= sizeof(Block));
+        Block* b = (Block*)sk_malloc_flags(size, flags);
+        b->prev = prev;
+        return b;
+    }
+};
+
+SkVarAlloc::SkVarAlloc(size_t smallest, float growth)
+    : fByte(NULL)
+    , fLimit(NULL)
+    , fSmallest(SkToUInt(smallest))
+    , fGrowth(growth)
+    , fBlock(NULL) {}
+
+SkVarAlloc::~SkVarAlloc() {
+    Block* b = fBlock;
+    while (b) {
+        Block* prev = b->prev;
+        sk_free(b);
+        b = prev;
+    }
+}
+
+void SkVarAlloc::makeSpace(size_t bytes, unsigned flags) {
+    SkASSERT(SkIsAlignPtr(bytes));
+
+    size_t alloc = fSmallest;
+    while (alloc < bytes + sizeof(Block)) {
+        alloc *= 2;
+    }
+    fBlock = Block::Alloc(fBlock, alloc, flags);
+    fByte = fBlock->data();
+    fLimit = fByte + alloc - sizeof(Block);
+    fSmallest = SkToUInt(SkScalarTruncToInt(fSmallest * fGrowth));
+
+#if defined(SK_BUILD_FOR_MAC)
+    SkASSERT(alloc == malloc_good_size(alloc));
+#elif defined(SK_BUILD_FOR_LINUX)
+    SkASSERT(alloc == malloc_usable_size(fByte - sizeof(Block)));
+#endif
+}
diff --git a/src/core/SkVarAlloc.h b/src/core/SkVarAlloc.h
new file mode 100644
index 0000000..0a7864b
--- /dev/null
+++ b/src/core/SkVarAlloc.h
@@ -0,0 +1,40 @@
+#ifndef SkVarAlloc_DEFINED
+#define SkVarAlloc_DEFINED
+
+#include "SkTypes.h"
+
+class SkVarAlloc : SkNoncopyable {
+public:
+    // SkVarAlloc will never allocate less than smallest bytes at a time.
+    // When it allocates a new block, it will be at least growth times bigger than the last.
+    SkVarAlloc(size_t smallest, float growth);
+    ~SkVarAlloc();
+
+    // Returns contiguous bytes aligned at least for pointers.  You may pass SK_MALLOC_THROW, etc.
+    char* alloc(size_t bytes, unsigned sk_malloc_flags) {
+        bytes = SkAlignPtr(bytes);
+
+        if (fByte + bytes > fLimit) {
+            this->makeSpace(bytes, sk_malloc_flags);
+        }
+        SkASSERT(fByte + bytes <= fLimit);
+
+        char* ptr = fByte;
+        fByte += bytes;
+        return ptr;
+    }
+
+private:
+    void makeSpace(size_t bytes, unsigned flags);
+
+    char* fByte;
+    const char* fLimit;
+
+    unsigned fSmallest;
+    const float fGrowth;
+
+    struct Block;
+    Block* fBlock;
+};
+
+#endif//SkVarAlloc_DEFINED