Add capture snapshot as data to SkWriter32, use it to optimise record->playback.

include/core/SkWriter32.h

Index: include/core/SkWriter32.h
diff --git a/include/core/SkWriter32.h b/include/core/SkWriter32.h
index 2e7c9563d9f748017a6b4e04adc1ccff1cbab63b..b8c555d6ca82c1872a715f8f1814bcd0581439db 100644
--- a/include/core/SkWriter32.h
+++ b/include/core/SkWriter32.h
@@ -10,6 +10,7 @@
 #ifndef SkWriter32_DEFINED
 #define SkWriter32_DEFINED
 
+#include "SkData.h"
 #include "SkMatrix.h"
 #include "SkPath.h"
 #include "SkPoint.h"
@@ -44,6 +45,7 @@ public:
         SkASSERT(SkIsAlign4((uintptr_t)external));
         SkASSERT(SkIsAlign4(externalBytes));
 
+        fSnapshot.reset(NULL);
         fData = (uint8_t*)external;
         fCapacity = externalBytes;
         fUsed = 0;
@@ -230,6 +232,15 @@ public:
         return stream->read(this->reservePad(length), length);
     }
 
+    /**
+     *  Captures a snapshot of the data as it is right now, and return it.
+     *  Multiple calls without intervening writes may return the same SkData,
+     *  but this is not guaranteed.
+     *  Future appends will not affect the returned buffer, but future writes
+     *  without an intervening append may.

[reed1, 2014/03/06 19:20:31]

"may" -- does this mean future writes *will* appear in the returned buffer, or
*will not*, or undefined?

[iancottrell, 2014/03/06 21:31:52]

Undefined but predictable.
For instance, if the current backing store was an external buffer, then the
returned snapshot will be a copy of that, but the array will keep writing to the
external store, so they won't appear. If it was the internal buffer, then we
will not copy it, just return it, so changes would appear. This is all an
implementation detail though. I did not want to use the word undefined, because
that carries scary connotations to me.

+     *  Callers must unref the returned SkData.
+     */
+    SkData* snapshotAsData() const;
 private:
     void growToAtLeast(size_t size);
 
@@ -238,6 +249,7 @@ private:
     size_t fUsed;                      // Number of bytes written.
     void* fExternal;                   // Unmanaged memory block.
     SkAutoTMalloc<uint8_t> fInternal;  // Managed memory block.
+    SkAutoTUnref<SkData> fSnapshot;    // Holds the result of last asData.
 };
 
 /**