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

tests/CodecTest.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Resources.h"
 #include "SkAndroidCodec.h"
 #include "SkBitmap.h"
@@ skipping 192 matching lines @@
     if (!stream) {
         SkDebugf("Missing resource '%s'\n", path);
         return;
     }
 
     SkAutoTDelete<SkCodec> codec(nullptr);
     bool isIncomplete = supportsIncomplete;
     if (isIncomplete) {
         size_t size = stream->getLength();
         sk_sp<SkData> data((SkData::MakeFromStream(stream, 2 * size / 3)));
-        codec.reset(SkCodec::NewFromData(data.get()));
+        codec.reset(SkCodec::NewFromData(data));
     } else {
         codec.reset(SkCodec::NewFromStream(stream.release()));
     }
     if (!codec) {
         ERRORF(r, "Unable to decode '%s'", path);
         return;
     }
 
     // Test full image decodes with SkCodec
     SkMD5::Digest codecDigest;
@@ skipping 108 matching lines @@
         SkAutoTDelete<SkStream> stream(resource(path));
         if (!stream) {
             SkDebugf("Missing resource '%s'\n", path);
             return;
         }
 
         SkAutoTDelete<SkAndroidCodec> androidCodec(nullptr);
         if (isIncomplete) {
             size_t size = stream->getLength();
             sk_sp<SkData> data((SkData::MakeFromStream(stream, 2 * size / 3)));
-            androidCodec.reset(SkAndroidCodec::NewFromData(data.get()));
+            androidCodec.reset(SkAndroidCodec::NewFromData(data));
         } else {
             androidCodec.reset(SkAndroidCodec::NewFromStream(stream.release()));
         }
         if (!androidCodec) {
             ERRORF(r, "Unable to decode '%s'", path);
             return;
         }
 
         SkBitmap bm;
         SkMD5::Digest androidCodecDigest;
@@ skipping 464 matching lines @@
         }
 
     private:
         skiatest::Reporter* fReporter;  // Unowned
         bool fSeen[3];
     };
 
     ChunkReader chunkReader(r);
 
     // Now read the file with SkCodec.
-    sk_sp<SkData> data(wStream.copyToData());
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data.get(), &chunkReader));
+    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(wStream.detachAsData(), &chunkReader));
     REPORTER_ASSERT(r, codec);
     if (!codec) {
         return;
     }
 
     // Now compare to the original.
     SkBitmap decodedBm;
     decodedBm.setInfo(codec->getInfo());
     decodedBm.allocPixels();
     SkCodec::Result result = codec->getPixels(codec->getInfo(), decodedBm.getPixels(),
@@ skipping 19 matching lines @@
     REPORTER_ASSERT(r, !chunkReader.allHaveBeenSeen());
     result = codec->getPixels(codec->getInfo(), decodedBm.getPixels(), decodedBm.rowBytes());
     REPORTER_ASSERT(r, SkCodec::kSuccess == result);
     REPORTER_ASSERT(r, chunkReader.allHaveBeenSeen());
 }
 #endif // PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
 
 // Stream that can only peek up to a limit
 class LimitedPeekingMemStream : public SkStream {
 public:
-    LimitedPeekingMemStream(SkData* data, size_t limit)
-        : fStream(data)
+    LimitedPeekingMemStream(sk_sp<SkData> data, size_t limit)
+        : fStream(std::move(data))
         , fLimit(limit) {}
 
     size_t peek(void* buf, size_t bytes) const override {
         return fStream.peek(buf, SkTMin(bytes, fLimit));
     }
     size_t read(void* buf, size_t bytes) override {
         return fStream.read(buf, bytes);
     }
     bool rewind() override {
         return fStream.rewind();
@@ skipping 61 matching lines @@
     const char* path = "baby_tux.webp";
     SkString fullPath(GetResourcePath(path));
     auto data = SkData::MakeFromFileName(fullPath.c_str());
     if (!data) {
         SkDebugf("Missing resource '%s'\n", path);
         return;
     }
 
     // The limit is less than webp needs to peek or read.
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(
-                                 new LimitedPeekingMemStream(data.get(), 25)));
+                                 new LimitedPeekingMemStream(data, 25)));
     REPORTER_ASSERT(r, codec);
 
     test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
 
     // Similarly, a stream which does not peek should still succeed.
-    codec.reset(SkCodec::NewFromStream(new LimitedPeekingMemStream(data.get(), 0)));
+    codec.reset(SkCodec::NewFromStream(new LimitedPeekingMemStream(data, 0)));
     REPORTER_ASSERT(r, codec);
 
     test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
 }
 
 // SkCodec's wbmp decoder was initially unnecessarily restrictive.
 // It required the second byte to be zero. The wbmp specification allows
 // a couple of bits to be 1 (so long as they do not overlap with 0x9F).
 // Test that SkCodec now supports an image with these bits set.
 DEF_TEST(Codec_wbmp, r) {
     const char* path = "mandrill.wbmp";
     SkAutoTDelete<SkStream> stream(resource(path));
     if (!stream) {
         SkDebugf("Missing resource '%s'\n", path);
         return;
     }
 
     // Modify the stream to contain a second byte with some bits set.
     auto data = SkCopyStreamToData(stream);
     uint8_t* writeableData = static_cast<uint8_t*>(data->writable_data());
     writeableData[1] = static_cast<uint8_t>(~0x9F);
 
     // SkCodec should support this.
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data.get()));
+    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data));
     REPORTER_ASSERT(r, codec);
     if (!codec) {
         return;
     }
     test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
 }
 
 // wbmp images have a header that can be arbitrarily large, depending on the
 // size of the image. We cap the size at 65535, meaning we only need to look at
 // 8 bytes to determine whether we can read the image. This is important
@@ skipping 84 matching lines @@
 
 static void check_round_trip(skiatest::Reporter* r, const SkBitmap& bm1) {
     SkColorType origColorType = bm1.colorType();
     SkAlphaType origAlphaType = bm1.alphaType();
 
     // Encode the image to png.
     sk_sp<SkData> data =
             sk_sp<SkData>(SkImageEncoder::EncodeData(bm1, SkImageEncoder::kPNG_Type, 100));
 
     // Prepare to decode.  The codec should recognize that the PNG is 565.
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data.get()));
+    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data));
     REPORTER_ASSERT(r, origColorType == codec->getInfo().colorType());
     REPORTER_ASSERT(r, origAlphaType == codec->getInfo().alphaType());
 
     SkBitmap bm2;
     bm2.allocPixels(codec->getInfo());
     SkCodec::Result result = codec->getPixels(codec->getInfo(), bm2.getPixels(), bm2.rowBytes());
     REPORTER_ASSERT(r, SkCodec::kSuccess == result);
 
     SkMD5::Digest d1, d2;
     md5(bm1, &d1);
@@ skipping 46 matching lines @@
         result = codec->startScanlineDecode(infoF16);
         REPORTER_ASSERT(r, SkCodec::kSuccess == result);
     }
 }
 
 DEF_TEST(Codec_F16ConversionPossible, r) {
     test_conversion_possible(r, "color_wheel.webp", false);
     test_conversion_possible(r, "mandrill_512_q075.jpg", true);
     test_conversion_possible(r, "yellow_rose.png", true);
 }