Make sp variants for 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
 
-#include "SkRefCnt.h"

[bungeman-skia, 2016/03/11 14:53:13]

Please don't remove this. You are directly using sk_sp here.

+#include "SkData.h"

[bungeman-skia, 2016/03/11 14:53:13]

Was there a compiler that required this? It shouldn't be necessary to include
this here, the forward declaration should be enough. If it isn't we need to know
why, since that should work.

[reed1, 2016/03/11 19:23:34]

Needed for destructor

 #include "SkScalar.h"
 
-class SkData;
-
 class SkStream;
 class SkStreamRewindable;
 class SkStreamSeekable;
 class SkStreamAsset;
 class SkStreamMemory;
 
 /**
  *  SkStream -- abstraction for a source of bytes. Subclasses can be backed by
  *  memory, or a file, or something else.
  *
@@ skipping 237 matching lines @@
     size_t getPosition() const override;
     bool seek(size_t position) override;
     bool move(long offset) override;
     SkStreamAsset* fork() const override;
 
     size_t getLength() const override;
 
     const void* getMemoryBase() override;
 
 private:
-    FILE*     fFILE;
+    FILE*       fFILE;
     SkString    fName;
     Ownership   fOwnership;
     // fData is lazilly initialized when needed.
-    mutable SkAutoTUnref<SkData> fData;
+    mutable sk_sp<SkData> fData;
 
     typedef SkStreamAsset INHERITED;
 };
 
 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);
 
     /** Use the specified data as the memory for this stream.
      *  The stream will call ref() on the data (assuming it is not NULL).

[scroggo, 2016/03/11 15:28:35]

IIUC, this is not necessarily true for the sk_sp version. Maybe put a blank line
between the two versions, and/or add a comment for the second one?

[reed1, 2016/03/11 19:23:34]

Done.

      */
     SkMemoryStream(SkData*);
-
-    virtual ~SkMemoryStream();
+    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.
@@ skipping 26 matching lines @@
     size_t getPosition() const override;
     bool seek(size_t position) override;
     bool move(long offset) override;
     SkMemoryStream* fork() const override;
 
     size_t getLength() const override;
 
     const void* getMemoryBase() override;
 
 private:
-    SkData* fData;
-    size_t  fOffset;
+    sk_sp<SkData>   fData;
+    size_t          fOffset;
 
     typedef SkStreamMemory INHERITED;
 };
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 
 class SK_API SkFILEWStream : public SkWStream {
 public:
     SkFILEWStream(const char path[]);
     virtual ~SkFILEWStream();
@@ skipping 54 matching lines @@
     SkStreamAsset* detachAsStream();
 
     /** Reset the stream to its original, empty, state. */
     void reset();
     void padToAlign4();
 private:
     struct Block;
     Block*  fHead;
     Block*  fTail;
     size_t  fBytesWritten;
-    mutable SkData* fCopy;  // is invalidated if we write after it is created
+    mutable sk_sp<SkData> fCopy;  // is invalidated if we write after it is created
 
     void invalidateCopy();
 
     // For access to the Block type.
     friend class SkBlockMemoryStream;
     friend class SkBlockMemoryRefCnt;
 
     typedef SkWStream INHERITED;
 };
 
 
 class SK_API SkDebugWStream : public SkWStream {
 public:
     SkDebugWStream() : fBytesWritten(0) {}
 
     // overrides
     bool write(const void* buffer, size_t size) override;
     void newline() override;
     size_t bytesWritten() const override { return fBytesWritten; }
 
 private:
     size_t fBytesWritten;
     typedef SkWStream INHERITED;
 };
 
 // for now
 typedef SkFILEStream SkURLStream;
 
 #endif