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

tests/StreamTest.cpp

 /*
  * Copyright 2011 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 "SkData.h"
 #include "SkFrontBufferedStream.h"
@@ skipping 99 matching lines @@
         stream3->rewind();
         test_loop_stream(reporter, stream3.get(), s, 26, 100);
     }
 
     for (i = 0; i < 100; i++) {
         REPORTER_ASSERT(reporter, ds.write(s, 26));
     }
     REPORTER_ASSERT(reporter, ds.getOffset() == 100 * 26);
 
     {
-        sk_sp<SkData> data(ds.copyToData());
+        sk_sp<SkData> data = ds.snapshotAsData();
         REPORTER_ASSERT(reporter, 100 * 26 == data->size());
         REPORTER_ASSERT(reporter, memcmp(dst, data->data(), data->size()) == 0);
     }
 
     {
-        // Test that this works after a copyToData.
+        // Test that this works after a snapshot.
         SkAutoTDelete<SkStreamAsset> stream(ds.detachAsStream());
         REPORTER_ASSERT(reporter, ds.getOffset() == 0);
         test_loop_stream(reporter, stream.get(), s, 26, 100);
 
         SkAutoTDelete<SkStreamAsset> stream2(stream->duplicate());
         test_loop_stream(reporter, stream2.get(), s, 26, 100);
     }
     delete[] dst;
 
     SkString tmpDir = skiatest::GetTmpDir();
@@ skipping 30 matching lines @@
             ERRORF(reporter, "sizes:%x != n:%x\n", i, sizes[i], n);
         }
     }
 }
 
 // Test that setting an SkMemoryStream to a nullptr data does not result in a crash when calling
 // methods that access fData.
 static void TestDereferencingData(SkMemoryStream* memStream) {
     memStream->read(nullptr, 0);
     memStream->getMemoryBase();
-    sk_sp<SkData> data(memStream->copyToData());
+    (void)memStream->asData();
 }
 
 static void TestNullData() {
-    SkData* nullData = nullptr;
-    SkMemoryStream memStream(nullData);
+    SkMemoryStream memStream(nullptr);
     TestDereferencingData(&memStream);
 
-    memStream.setData(nullData);
+    memStream.setData(nullptr);
     TestDereferencingData(&memStream);
 
 }
 
 DEF_TEST(Stream, reporter) {
     TestWStream(reporter);
     TestPackedUInt(reporter);
     TestNullData();
 }
 
@@ skipping 201 matching lines @@
 
 static void stream_copy_test(skiatest::Reporter* reporter,
                              const void* srcData,
                              size_t N,
                              SkStream* stream) {
     SkDynamicMemoryWStream tgt;
     if (!SkStreamCopy(&tgt, stream)) {
         ERRORF(reporter, "SkStreamCopy failed");
         return;
     }
-    sk_sp<SkData> data(tgt.copyToData());
-    tgt.reset();
+    sk_sp<SkData> data(tgt.detachAsData());
     if (data->size() != N) {
         ERRORF(reporter, "SkStreamCopy incorrect size");
         return;
     }
     if (0 != memcmp(data->data(), srcData, N)) {
         ERRORF(reporter, "SkStreamCopy bad copy");
     }
 }
 
 DEF_TEST(StreamCopy, reporter) {
     SkRandom random(123456);
     static const int N = 10000;
     SkAutoTMalloc<uint8_t> src((size_t)N);
     for (int j = 0; j < N; ++j) {
         src[j] = random.nextU() & 0xff;
     }
     // SkStreamCopy had two code paths; this test both.
     DumbStream dumbStream(src.get(), (size_t)N);
     stream_copy_test(reporter, src, N, &dumbStream);
     SkMemoryStream smartStream(src.get(), (size_t)N);
     stream_copy_test(reporter, src, N, &smartStream);
 }
 
 DEF_TEST(StreamEmptyStreamMemoryBase, r) {
     SkDynamicMemoryWStream tmp;
     SkAutoTDelete<SkStreamAsset> asset(tmp.detachAsStream());
     REPORTER_ASSERT(r, nullptr == asset->getMemoryBase());
 }