Move off SK_SUPPORT_LEGACY_DATA_FACTORIES.

tests/TextureCompressionTest.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 "SkAutoPixmapStorage.h"
 #include "SkBitmap.h"
 #include "SkData.h"
@@ skipping 46 matching lines @@
 
     SkAutoPixmapStorage pixmap;
     pixmap.alloc(SkImageInfo::MakeA8(kWidth, kHeight));
     // leaving the pixels uninitialized, as they don't affect the test...
 
     for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) {
         const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i);
         if (!compresses_a8(fmt)) {
             continue;
         }
-        SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
+        sk_sp<SkData> data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
         REPORTER_ASSERT(reporter, nullptr == data);
     }
 }
 
 /**
  * Make sure that we properly fail when we don't have the correct bitmap type.
  * compressed textures can (currently) only be created from A8 bitmaps.
  */
 DEF_TEST(CompressAlphaFailColorType, reporter) {
     static const int kWidth = 12;
     static const int kHeight = 12;
 
     // ASTC is at most 12x12, and any dimension divisible by 12 is also divisible
     // by 4, which is the dimensions of R11_EAC and LATC. In the future, we might
     // support additional variants of ASTC, such as 5x6 and 8x8, in which case this would
     // need to be updated.
     REPORTER_ASSERT(reporter, kWidth % 12 == 0);
     REPORTER_ASSERT(reporter, kHeight % 12 == 0);
 
     SkAutoPixmapStorage pixmap;
     pixmap.alloc(SkImageInfo::MakeN32Premul(kWidth, kHeight));
     // leaving the pixels uninitialized, as they don't affect the test...
 
     for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) {
         const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i);
         if (!compresses_a8(fmt)) {
             continue;
         }
-        SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
+        sk_sp<SkData> data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
         REPORTER_ASSERT(reporter, nullptr == data);
     }
 }
 
 /**
  * Make sure that if you compress a texture with alternating black/white pixels, and
  * then decompress it, you get what you started with.
  */
 DEF_TEST(CompressCheckerboard, reporter) {
     static const int kWidth = 48;  // We need the number to be divisible by both
@@ skipping 40 matching lines @@
 
     for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) {
         const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i);
 
         // Ignore formats for RGBA data, since the decompressed buffer
         // won't match the size and contents of the original.
         if (!decompresses_a8(fmt) || !compresses_a8(fmt)) {
             continue;
         }
 
-        SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
+        sk_sp<SkData> data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
         REPORTER_ASSERT(reporter, data);
         if (nullptr == data) {
             continue;
         }
 
         bool decompResult =
             SkTextureCompressor::DecompressBufferFromFormat(
                 decompBuffer, kWidth,
                 data->bytes(),
                 kWidth, kHeight, fmt);
@@ skipping 37 matching lines @@
         SkTextureCompressor::GetCompressedDataSize(kLATCFormat, kWidth, kHeight);
     REPORTER_ASSERT(reporter, kSizeToBe == ((kWidth*kHeight*kLATCEncodedBlockSize)/16));
     REPORTER_ASSERT(reporter, (kSizeToBe % kLATCEncodedBlockSize) == 0);
 
     for (int lum = 0; lum < 256; ++lum) {
         uint8_t* pixels = reinterpret_cast<uint8_t*>(pixmap.writable_addr());
         for (int i = 0; i < kWidth*kHeight; ++i) {
             pixels[i] = lum;
         }
 
-        SkAutoDataUnref latcData(
+        sk_sp<SkData> latcData(
             SkTextureCompressor::CompressBitmapToFormat(pixmap, kLATCFormat));
         REPORTER_ASSERT(reporter, latcData);
         if (nullptr == latcData) {
             continue;
         }
 
         REPORTER_ASSERT(reporter, kSizeToBe == latcData->size());
 
         // Make sure that it all matches a given block encoding. Since we have
         // COMPRESS_LATC_FAST defined in SkTextureCompressor_LATC.cpp, we are using
@@ skipping 42 matching lines @@
                 (kIndex << 28) | (kIndex << 31) | (kIndex << 34) | (kIndex << 37) |
                 (kIndex << 40) | (kIndex << 43) | (kIndex << 46) | (kIndex << 49) |
                 (kIndex << 52) | (kIndex << 55) | (kIndex << 58) | (kIndex << 61));
 
         const uint64_t* blockPtr = reinterpret_cast<const uint64_t*>(latcData->data());
         for (size_t i = 0; i < (kSizeToBe/8); ++i) {
             REPORTER_ASSERT(reporter, blockPtr[i] == kConstColorEncoding);
         }
     }
 }