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 buffer,

[reed1, 2014/02/14 17:31:08]

I like noting this possible optimization, but perhaps we should be very clear
not to rely on it...

"... may return the same buffer (SkData?), but this is not guaranteed."

[iancottrell, 2014/02/14 18:28:36]

Sure, I deliberately used the word may, but I agree that's probably too subtle.

+     *  and future appends will not affect the returned buffer.
+     *  Callers must unref the returned SkData.
+     */
+    SkData* snapshotAsData();
+    SkData* snapshotAsData() const {

[mtklein, 2014/02/14 17:42:18]

Why have both const and non-const versions?  Why not const_cast inside the const
method?

Can you add a note that snapshotAsData isn't threadsafe?

[iancottrell, 2014/02/14 18:28:36]

Would we rather make it threadsafe?

+        return const_cast<SkWriter32*>(this)->snapshotAsData();

[reed1, 2014/02/14 17:31:08]

Do we want a mutex guard around this, since we are mutating a const-object ?

[iancottrell, 2014/02/14 18:28:36]

Maybe? This is an area where I just don't have enough Skia experience to make
the call between documenting non threadsafe vs making threadsafe, if you could
make a call with Mike and tell me that would be great.

[iancottrell, 2014/02/27 20:16:19]

Added a mutex guard in the implementation.

+    }
 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