Move off SK_SUPPORT_LEGACY_DATA_FACTORIES.

src/codec/SkRawCodec.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCodec.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 239 matching lines @@
 
         size_t sum;
         if (!safe_add_to_size_t(offset, length, &sum)) {
             return false;
         }
 
         return this->bufferMoreData(sum) && fStreamBuffer.read(data, offset, length);
     }
 
     SkMemoryStream* transferBuffer(size_t offset, size_t size) override {
-        SkAutoTUnref<SkData> data(SkData::NewUninitialized(size));
+        sk_sp<SkData> data(SkData::MakeUninitialized(size));
         if (offset > fStreamBuffer.bytesWritten()) {
             // If the offset is not buffered, read from fStream directly and skip the buffering.
             const size_t skipLength = offset - fStreamBuffer.bytesWritten();
             if (fStream->skip(skipLength) != skipLength) {
                 return nullptr;
             }
             const size_t bytesRead = fStream->read(data->writable_data(), size);
             if (bytesRead < size) {
-                data.reset(SkData::NewSubset(data.get(), 0, bytesRead));
+                data = SkData::MakeSubset(data.get(), 0, bytesRead);
             }
         } else {
             const size_t alreadyBuffered = SkTMin(fStreamBuffer.bytesWritten() - offset, size);
             if (alreadyBuffered > 0 &&
                 !fStreamBuffer.read(data->writable_data(), offset, alreadyBuffered)) {
                 return nullptr;
             }
 
             const size_t remaining = size - alreadyBuffered;
             if (remaining) {
                 auto* dst = static_cast<uint8_t*>(data->writable_data()) + alreadyBuffered;
                 const size_t bytesRead = fStream->read(dst, remaining);
                 size_t newSize;
                 if (bytesRead < remaining) {
                     if (!safe_add_to_size_t(alreadyBuffered, bytesRead, &newSize)) {
                         return nullptr;
                     }
-                    data.reset(SkData::NewSubset(data.get(), 0, newSize));
+                    data = SkData::MakeSubset(data.get(), 0, newSize);
                 }
             }
         }
         return new SkMemoryStream(data);
     }
 
 private:
     // Note: if the newSize == kReadToEnd (0), this function will read to the end of stream.
     bool bufferMoreData(size_t newSize) {
         if (newSize == kReadToEnd) {
@@ skipping 74 matching lines @@
         }
 
         // This will allow read less than the requested "size", because the JPEG codec wants to
         // handle also a partial JPEG file.
         const size_t bytesToRead = SkTMin(sum, fStream->getLength()) - offset;
         if (bytesToRead == 0) {
             return nullptr;
         }
 
         if (fStream->getMemoryBase()) {  // directly copy if getMemoryBase() is available.
-            SkAutoTUnref<SkData> data(SkData::NewWithCopy(
+            sk_sp<SkData> data(SkData::MakeWithCopy(
                 static_cast<const uint8_t*>(fStream->getMemoryBase()) + offset, bytesToRead));
             fStream.reset();
             return new SkMemoryStream(data);
         } else {
-            SkAutoTUnref<SkData> data(SkData::NewUninitialized(bytesToRead));
+            sk_sp<SkData> data(SkData::MakeUninitialized(bytesToRead));
             if (!fStream->seek(offset)) {
                 return nullptr;
             }
             const size_t bytesRead = fStream->read(data->writable_data(), bytesToRead);
             if (bytesRead < bytesToRead) {
-                data.reset(SkData::NewSubset(data.get(), 0, bytesRead));
+                data = SkData::MakeSubset(data.get(), 0, bytesRead);
             }
             return new SkMemoryStream(data);
         }
     }
 private:
     SkAutoTDelete<SkStream> fStream;
 };
 
 class SkPiexStream : public ::piex::StreamInterface {
 public:
@@ skipping 369 matching lines @@
     SkISize sizeFloor = this->onGetScaledDimensions(1.f / std::floor(fullShortEdge / shortEdge));
     SkISize sizeCeil = this->onGetScaledDimensions(1.f / std::ceil(fullShortEdge / shortEdge));
     return sizeFloor == dim || sizeCeil == dim;
 }
 
 SkRawCodec::~SkRawCodec() {}
 
 SkRawCodec::SkRawCodec(SkDngImage* dngImage)
     : INHERITED(dngImage->width(), dngImage->height(), dngImage->getEncodedInfo(), nullptr)
     , fDngImage(dngImage) {}