Adding release method to SkWriter32 and using it to not copy the ops data from SkPictureRecord to S…

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 "SkMatrix.h"
 #include "SkPath.h"
 #include "SkPoint.h"
 #include "SkRRect.h"
 #include "SkRect.h"
 #include "SkRegion.h"
 #include "SkScalar.h"
 #include "SkStream.h"
 #include "SkTDArray.h"
 #include "SkTypes.h"
 
+class SkData;
+
 class SkWriter32 : SkNoncopyable {
 public:
     /**
      *  The caller can specify an initial block of storage, which the caller manages.
      *
      *  SkWriter32 will try to back reserve and write calls with this external storage until the
      *  first time an allocation doesn't fit.  From then it will use dynamically allocated storage.
      *  This used to be optional behavior, but pipe now relies on it.
      */
     SkWriter32(void* external = NULL, size_t externalBytes = 0)
@@ skipping 188 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);
     }
 
+    /**
+     *  Release the internal buffer to the caller in an SkData.
+     *  The caller must call unref() when it is finished using the data.
+     */
+    SkData* release();

[reed1, 2014/02/07 16:06:49]

Modest vote for a more explicit name :

e.g.

releaseAsData() ?
detachAsData() ?  // seems like we use detach for this idea in other classes,
but maybe we use both

Also we should well-document that this also resets the state of the writer.  

[iancottrell, 2014/02/07 17:01:47]

Done.

+
 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.
     SkTDArray<uint8_t> fInternal;  // Managed memory block.
 };
 
 /**
  *  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() : SkWriter32(fData.fStorage, SIZE) {}
 
 private:
     union {
         void*   fPtrAlignment;
         double  fDoubleAlignment;
         char    fStorage[SIZE];
     } fData;
 };
 
 #endif