change SkStreams to work with sk_sp<SkData> instead of SkData*

include/core/SkStream.h

 /*
  * Copyright 2006 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 SkStream_DEFINED
 #define SkStream_DEFINED
 
@@ skipping 273 matching lines @@
 class SK_API SkMemoryStream : public SkStreamMemory {
 public:
     SkMemoryStream();
 
     /** We allocate (and free) the memory. Write to it via getMemoryBase() */
     SkMemoryStream(size_t length);
 
     /** If copyData is true, the stream makes a private copy of the data. */
     SkMemoryStream(const void* data, size_t length, bool copyData = false);
 
+#ifdef SK_SUPPORT_LEGACY_STREAM_DATA
     /** Use the specified data as the memory for this stream.
      *  The stream will call ref() on the data (assuming it is not NULL).
      *  DEPRECATED
      */
     SkMemoryStream(SkData*);
+#endif
 
     /** Creates the stream to read from the specified data */
     SkMemoryStream(sk_sp<SkData>);
 
     /** Resets the stream to the specified data and length,
         just like the constructor.
         if copyData is true, the stream makes a private copy of the data
     */
     virtual void setMemory(const void* data, size_t length,
                            bool copyData = false);
     /** Replace any memory buffer with the specified buffer. The caller
         must have allocated data with sk_malloc or sk_realloc, since it
         will be freed with sk_free.
     */
     void setMemoryOwned(const void* data, size_t length);
 
+    sk_sp<SkData> asData() const { return fData; }
+    void setData(sk_sp<SkData>);
+#ifdef SK_SUPPORT_LEGACY_STREAM_DATA
     /** Return the stream's data in a SkData.
      *  The caller must call unref() when it is finished using the data.
      */
-    SkData* copyToData() const;
+    SkData* copyToData() const { return asData().release(); }
 
     /**
      *  Use the specified data as the memory for this stream.
      *  The stream will call ref() on the data (assuming it is not NULL).
      *  The function returns the data parameter as a convenience.
      */
-    SkData* setData(SkData*);
+    SkData* setData(SkData* data) {
+        this->setData(sk_ref_sp(data));
+        return data;
+    }
+#endif
 
     void skipToAlign4();
     const void* getAtPos();
 
     size_t read(void* buffer, size_t size) override;
     bool isAtEnd() const override;
 
     size_t peek(void* buffer, size_t size) const override;
 
     bool rewind() override;
@@ skipping 61 matching lines @@
     // random access write
     // modifies stream and returns true if offset + size is less than or equal to getOffset()
     bool write(const void* buffer, size_t offset, size_t size);
     bool read(void* buffer, size_t offset, size_t size);
     size_t getOffset() const { return fBytesWritten; }
 
     // copy what has been written to the stream into dst
     void copyTo(void* dst) const;
     void writeToStream(SkWStream* dst) const;
 
+    sk_sp<SkData> snapshotAsData() const;
+    // Return the contents as SkData, and then reset the stream.
+    sk_sp<SkData> detachAsData();
+#ifdef SK_SUPPORT_LEGACY_STREAM_DATA
     /**
      *  Return a copy of the data written so far. This call is responsible for
      *  calling unref() when they are finished with the data.
      */
-    SkData* copyToData() const;
+    SkData* copyToData() const {
+        return snapshotAsData().release();
+    }
+#endif
 
     /** Reset, returning a reader stream with the current content. */
     SkStreamAsset* detachAsStream();
 
     /** Reset the stream to its original, empty, state. */
     void reset();
     void padToAlign4();
 private:
     struct Block;
     Block*  fHead;
@@ skipping 22 matching lines @@
 
 private:
     size_t fBytesWritten;
     typedef SkWStream INHERITED;
 };
 
 // for now
 typedef SkFILEStream SkURLStream;
 
 #endif