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

include/core/SkWriter32.h

 
 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkWriter32_DEFINED
 #define SkWriter32_DEFINED
 
+#include "SkData.h"
 #include "SkMatrix.h"
 #include "SkPath.h"
 #include "SkPoint.h"
 #include "SkRRect.h"
 #include "SkRect.h"
 #include "SkRegion.h"
 #include "SkScalar.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkTypes.h"
@@ skipping 14 matching lines @@
     // return the current offset (will always be a multiple of 4)
     size_t bytesWritten() const { return fUsed; }
 
     SK_ATTR_DEPRECATED("use bytesWritten")
     size_t size() const { return this->bytesWritten(); }
 
     void reset(void* external = NULL, size_t externalBytes = 0) {
         SkASSERT(SkIsAlign4((uintptr_t)external));
         SkASSERT(SkIsAlign4(externalBytes));
 
+        fSnapshot.reset(NULL);
         fData = (uint8_t*)external;
         fCapacity = externalBytes;
         fUsed = 0;
         fExternal = external;
     }
 
     // Returns the current buffer.
     // The pointer may be invalidated by any future write calls.
     const uint32_t* contiguousArray() const {
         return (uint32_t*)fData;
@@ skipping 166 matching lines @@
     bool writeToStream(SkWStream* stream) const {
         return stream->write(fData, fUsed);
     }
 
     // read from the stream, and write up to length bytes. Return the actual
     // number of bytes written.
     size_t readFromStream(SkStream* stream, size_t length) {
         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);
 
     uint8_t* fData;                    // Points to either fInternal or fExternal.
     size_t fCapacity;                  // Number of bytes we can write to fData.
     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.
 };
 
 /**
  *  Helper class to allocated SIZE bytes as part of the writer, and to provide
  *  that storage to the constructor as its initial storage buffer.
  *
  *  This wrapper ensures proper alignment rules are met for the storage.
  */
 template <size_t SIZE> class SkSWriter32 : public SkWriter32 {
 public:
     SkSWriter32() { this->reset(); }
 
     void reset() {this->INHERITED::reset(fData.fStorage, SIZE); }
 
 private:
     union {
         void*   fPtrAlignment;
         double  fDoubleAlignment;
         char    fStorage[SIZE];
     } fData;
 
     typedef SkWriter32 INHERITED;
 };
 
 #endif