Make SkWriter32::snapshotAsData() a dumb copy.

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
@@ skipping 27 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 23 matching lines @@
     }
 
     /**
      *  Overwrite a T record at offset, which must be a multiple of 4. Only legal if the record
      *  was written atomically using the write methods below.
      */
     template<typename T>
     void overwriteTAt(size_t offset, const T& value) {
         SkASSERT(SkAlign4(offset) == offset);
         SkASSERT(offset < fUsed);
-        SkASSERT(fSnapshot.get() == NULL);
         *(T*)(fData + offset) = value;
     }
 
     bool writeBool(bool value) {
         this->write32(value);
         return value;
     }
 
     void writeInt(int32_t value) {
         this->write32(value);
@@ skipping 125 matching lines @@
     }
 
     // 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.
-     *  It is illegal to call overwriteTAt after this without an intervening
-     *  append. It may cause the snapshot buffer to be corrupted.
-     *  Callers must unref the returned SkData.
-     *  This is not thread safe, it should only be called on the writing thread,
-     *  the result however can be shared across threads.
      */
     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