Move off SK_SUPPORT_LEGACY_DATA_FACTORIES.

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 190 matching lines @@
     SkAutoTDelete<SkStream> stream(resource(path));
     if (!stream) {
         SkDebugf("Missing resource '%s'\n", path);
         return;
     }
 
     SkAutoTDelete<SkCodec> codec(nullptr);
     bool isIncomplete = supportsIncomplete;
     if (isIncomplete) {
         size_t size = stream->getLength();
-        SkAutoTUnref<SkData> data((SkData::NewFromStream(stream, 2 * size / 3)));
-        codec.reset(SkCodec::NewFromData(data));
+        sk_sp<SkData> data((SkData::MakeFromStream(stream, 2 * size / 3)));
+        codec.reset(SkCodec::NewFromData(data.get()));
     } 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 107 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();
-            SkAutoTUnref<SkData> data((SkData::NewFromStream(stream, 2 * size / 3)));
-            androidCodec.reset(SkAndroidCodec::NewFromData(data));
+            sk_sp<SkData> data((SkData::MakeFromStream(stream, 2 * size / 3)));
+            androidCodec.reset(SkAndroidCodec::NewFromData(data.get()));
         } else {
             androidCodec.reset(SkAndroidCodec::NewFromStream(stream.release()));
         }
         if (!androidCodec) {
             ERRORF(r, "Unable to decode '%s'", path);
             return;
         }
 
         SkBitmap bm;
         SkMD5::Digest androidCodecDigest;
         test_codec(r, androidCodec.get(), bm, info, size, expectedResult, &androidCodecDigest,
                    &codecDigest);
     }
 
     if (!isIncomplete) {
         // Test SkCodecImageGenerator
         SkAutoTDelete<SkStream> stream(resource(path));
-        SkAutoTUnref<SkData> fullData(SkData::NewFromStream(stream, stream->getLength()));
-        SkAutoTDelete<SkImageGenerator> gen(SkCodecImageGenerator::NewFromEncodedCodec(fullData));
+        sk_sp<SkData> fullData(SkData::MakeFromStream(stream, stream->getLength()));
+        SkAutoTDelete<SkImageGenerator> gen(
+                SkCodecImageGenerator::NewFromEncodedCodec(fullData.get()));
         SkBitmap bm;
         bm.allocPixels(info);
         SkAutoLockPixels autoLockPixels(bm);
         REPORTER_ASSERT(r, gen->getPixels(info, bm.getPixels(), bm.rowBytes()));
         compare_to_good_digest(r, codecDigest, bm);
 
         // Test using SkFrontBufferedStream, as Android does
-        SkStream* bufferedStream = SkFrontBufferedStream::Create(new SkMemoryStream(fullData),
-                SkCodec::MinBufferedBytesNeeded());
+        SkStream* bufferedStream = SkFrontBufferedStream::Create(
+                new SkMemoryStream(std::move(fullData)), SkCodec::MinBufferedBytesNeeded());
         REPORTER_ASSERT(r, bufferedStream);
         codec.reset(SkCodec::NewFromStream(bufferedStream));
         REPORTER_ASSERT(r, codec);
         if (codec) {
             test_info(r, codec.get(), info, SkCodec::kSuccess, &codecDigest);
         }
     }
 
     // If we've just tested incomplete decodes, let's run the same test again on full decodes.
     if (isIncomplete) {
@@ skipping 500 matching lines @@
         return false;
     }
 private:
     SkMemoryStream fStream;
     const size_t   fLimit;
 };
 
 // Stream that is not an asset stream (!hasPosition() or !hasLength())
 class NotAssetMemStream : public SkStream {
 public:
-    NotAssetMemStream(SkData* data) : fStream(data) {}
+    NotAssetMemStream(sk_sp<SkData> data) : fStream(std::move(data)) {}
 
     bool hasPosition() const override {
         return false;
     }
 
     bool hasLength() const override {
         return false;
     }
 
     size_t peek(void* buf, size_t bytes) const override {
@@ skipping 12 matching lines @@
     SkMemoryStream fStream;
 };
 
 // Disable RAW tests for Win32.
 #if defined(SK_CODEC_DECODES_RAW) && (!defined(_WIN32))
 // Test that the RawCodec works also for not asset stream. This will test the code path using
 // SkRawBufferedStream instead of SkRawAssetStream.
 DEF_TEST(Codec_raw_notseekable, r) {
     const char* path = "dng_with_preview.dng";
     SkString fullPath(GetResourcePath(path));
-    SkAutoTUnref<SkData> data(SkData::NewFromFileName(fullPath.c_str()));
+    sk_sp<SkData> data(SkData::MakeFromFileName(fullPath.c_str()));
     if (!data) {
         SkDebugf("Missing resource '%s'\n", path);
         return;
     }
 
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(new NotAssetMemStream(data)));
+    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(new NotAssetMemStream(std::move(data))));
     REPORTER_ASSERT(r, codec);
 
     test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
 }
 #endif
 
 // Test that even if webp_parse_header fails to peek enough, it will fall back to read()
 // + rewind() and succeed.
 DEF_TEST(Codec_webp_peek, r) {
     const char* path = "baby_tux.webp";
@@ skipping 94 matching lines @@
     // Perform a sampled decode.
     SkAndroidCodec::AndroidOptions opts;
     opts.fSampleSize = 12;
     codec->getAndroidPixels(codec->getInfo().makeWH(width / 12, height / 12), pixelStorage.get(),
                             rowBytes, &opts);
 
     // Rewind the codec and perform a full image decode.
     SkCodec::Result result = codec->getPixels(codec->getInfo(), pixelStorage.get(), rowBytes);
     REPORTER_ASSERT(r, SkCodec::kSuccess == result);
 }