Move off SK_SUPPORT_LEGACY_DATA_FACTORIES.

bench/nanobench.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <ctype.h>
 
 #include "nanobench.h"
@@ skipping 736 matching lines @@
             }
         }
 
         for (; fCurrentCodec < fImages.count(); fCurrentCodec++) {
             fSourceType = "image";
             fBenchType = "skcodec";
             const SkString& path = fImages[fCurrentCodec];
             if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path.c_str())) {
                 continue;
             }
-            SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
-            SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
+            sk_sp<SkData> encoded(SkData::MakeFromFileName(path.c_str()));
+            SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded.get()));
             if (!codec) {
                 // Nothing to time.
                 SkDebugf("Cannot find codec for %s\n", path.c_str());
                 continue;
             }
 
             while (fCurrentColorType < fColorTypes.count()) {
                 const SkColorType colorType = fColorTypes[fCurrentColorType];
 
                 SkAlphaType alphaType = codec->getInfo().alphaType();
@@ skipping 39 matching lines @@
                 int colorCount = 256;
                 SkPMColor colors[256];
 
                 const SkCodec::Result result = codec->getPixels(
                         info, storage.get(), rowBytes, nullptr, colors,
                         &colorCount);
                 switch (result) {
                     case SkCodec::kSuccess:
                     case SkCodec::kIncompleteInput:
                         return new CodecBench(SkOSPath::Basename(path.c_str()),
-                                encoded, colorType, alphaType);
+                                              encoded.get(), colorType, alphaType);
                     case SkCodec::kInvalidConversion:
                         // This is okay. Not all conversions are valid.
                         break;
                     default:
                         // This represents some sort of failure.
                         SkASSERT(false);
                         break;
                 }
             }
             fCurrentColorType = 0;
         }
 
         // Run AndroidCodecBenches
         const int sampleSizes[] = { 2, 4, 8 };
         for (; fCurrentAndroidCodec < fImages.count(); fCurrentAndroidCodec++) {
             fSourceType = "image";
             fBenchType = "skandroidcodec";
 
             const SkString& path = fImages[fCurrentAndroidCodec];
             if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path.c_str())) {
                 continue;
             }
-            SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
-            SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded));
+            sk_sp<SkData> encoded(SkData::MakeFromFileName(path.c_str()));
+            SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded.get()));
             if (!codec) {
                 // Nothing to time.
                 SkDebugf("Cannot find codec for %s\n", path.c_str());
                 continue;
             }
 
             while (fCurrentSampleSize < (int) SK_ARRAY_COUNT(sampleSizes)) {
                 int sampleSize = sampleSizes[fCurrentSampleSize];
                 fCurrentSampleSize++;
                 if (10 * sampleSize > SkTMin(codec->getInfo().width(), codec->getInfo().height())) {
                     // Avoid benchmarking scaled decodes of already small images.
                     break;
                 }
 
-                return new AndroidCodecBench(SkOSPath::Basename(path.c_str()), encoded, sampleSize);
+                return new AndroidCodecBench(SkOSPath::Basename(path.c_str()),
+                                             encoded.get(), sampleSize);
             }
             fCurrentSampleSize = 0;
         }
 
         // Run the BRDBenches
         // We intend to create benchmarks that model the use cases in
         // android/libraries/social/tiledimage.  In this library, an image is decoded in 512x512
         // tiles.  The image can be translated freely, so the location of a tile may be anywhere in
         // the image.  For that reason, we will benchmark decodes in five representative locations
         // in the image.  Additionally, this use case utilizes power of two scaling, so we will
@@ skipping 12 matching lines @@
 
             const SkString& path = fImages[fCurrentBRDImage];
             if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path.c_str())) {
                 continue;
             }
 
             while (fCurrentColorType < fColorTypes.count()) {
                 while (fCurrentSampleSize < (int) SK_ARRAY_COUNT(brdSampleSizes)) {
                     while (fCurrentSubsetType <= kLastSingle_SubsetType) {
 
-                        SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
+                        sk_sp<SkData> encoded(SkData::MakeFromFileName(path.c_str()));
                         const SkColorType colorType = fColorTypes[fCurrentColorType];
                         uint32_t sampleSize = brdSampleSizes[fCurrentSampleSize];
                         int currentSubsetType = fCurrentSubsetType++;
 
                         int width = 0;
                         int height = 0;
                         if (!valid_brd_bench(encoded.get(), colorType, sampleSize, minOutputSize,
                                 &width, &height)) {
                             break;
                         }
@@ skipping 400 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif