Move off SK_SUPPORT_LEGACY_DATA_FACTORIES.

src/pdf/SkPDFFont.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 <ctype.h>
 
 #include "SkData.h"
@@ skipping 134 matching lines @@
     } else if (c <= '9') {
         return c - '0';
     } else if (c <= 'F') {
         return c - 'A' + 10;
     } else if (c <= 'f') {
         return c - 'a' + 10;
     }
     return -1;
 }
 
-static SkData* handle_type1_stream(SkStream* srcStream, size_t* headerLen,
-                                   size_t* dataLen, size_t* trailerLen) {
+static sk_sp<SkData> handle_type1_stream(SkStream* srcStream, size_t* headerLen,
+                                         size_t* dataLen, size_t* trailerLen) {
     // srcStream may be backed by a file or a unseekable fd, so we may not be
     // able to use skip(), rewind(), or getMemoryBase().  read()ing through
     // the input only once is doable, but very ugly. Furthermore, it'd be nice
     // if the data was NUL terminated so that we can use strstr() to search it.
     // Make as few copies as possible given these constraints.
     SkDynamicMemoryWStream dynamicStream;
     std::unique_ptr<SkMemoryStream> staticStream;
-    SkData* data = nullptr;
+    sk_sp<SkData> data;
     const uint8_t* src;
     size_t srcLen;
     if ((srcLen = srcStream->getLength()) > 0) {
         staticStream.reset(new SkMemoryStream(srcLen + 1));
         src = (const uint8_t*)staticStream->getMemoryBase();
         if (srcStream->getMemoryBase() != nullptr) {
             memcpy((void *)src, srcStream->getMemoryBase(), srcLen);
         } else {
             size_t read = 0;
             while (read < srcLen) {
                 size_t got = srcStream->read((void *)staticStream->getAtPos(),
                                              srcLen - read);
                 if (got == 0) {
                     return nullptr;
                 }
                 read += got;
                 staticStream->seek(read);
             }
         }
         ((uint8_t *)src)[srcLen] = 0;
     } else {
         static const size_t kBufSize = 4096;
         uint8_t buf[kBufSize];
         size_t amount;
         while ((amount = srcStream->read(buf, kBufSize)) > 0) {
             dynamicStream.write(buf, amount);
         }
         amount = 0;
         dynamicStream.write(&amount, 1);  // nullptr terminator.
-        data = dynamicStream.copyToData();
+        data.reset(dynamicStream.copyToData());
         src = data->bytes();
         srcLen = data->size() - 1;
     }
 
-    // this handles releasing the data we may have gotten from dynamicStream.
-    // if data is null, it is a no-op
-    SkAutoDataUnref aud(data);
-
     if (parsePFB(src, srcLen, headerLen, dataLen, trailerLen)) {
         static const int kPFBSectionHeaderLength = 6;
         const size_t length = *headerLen + *dataLen + *trailerLen;
         SkASSERT(length > 0);
         SkASSERT(length + (2 * kPFBSectionHeaderLength) <= srcLen);
 
-        SkData* data = SkData::NewUninitialized(length);
+        sk_sp<SkData> data(SkData::MakeUninitialized(length));
 
         const uint8_t* const srcHeader = src + kPFBSectionHeaderLength;
         // There is a six-byte section header before header and data
         // (but not trailer) that we're not going to copy.
         const uint8_t* const srcData = srcHeader + *headerLen + kPFBSectionHeaderLength;
         const uint8_t* const srcTrailer = srcData + *headerLen;
 
         uint8_t* const resultHeader = (uint8_t*)data->writable_data();
         uint8_t* const resultData = resultHeader + *headerLen;
         uint8_t* const resultTrailer = resultData + *dataLen;
@@ skipping 38 matching lines @@
             }
         }
         if (!highNibble) {
             resultData[outputOffset++] = dataByte;
         }
         SkASSERT(outputOffset == *dataLen);
 
         uint8_t* const resultTrailer = &(buffer[SkToInt(*headerLen + outputOffset)]);
         memcpy(resultTrailer, src + *headerLen + hexDataLen, *trailerLen);
 
-        return SkData::NewFromMalloc(buffer.release(), length);
+        return SkData::MakeFromMalloc(buffer.release(), length);
     }
     return nullptr;
 }
 
 // scale from em-units to base-1000, returning as a SkScalar
 SkScalar scaleFromFontUnits(int16_t val, uint16_t emSize) {
     SkScalar scaled = SkIntToScalar(val);
     if (emSize == 1000) {
         return scaled;
     } else {
@@ skipping 905 matching lines @@
     int ttcIndex;
     size_t header SK_INIT_TO_AVOID_WARNING;
     size_t data SK_INIT_TO_AVOID_WARNING;
     size_t trailer SK_INIT_TO_AVOID_WARNING;
     std::unique_ptr<SkStreamAsset> rawFontData(typeface()->openStream(&ttcIndex));
     SkASSERT(rawFontData);
     SkASSERT(rawFontData->getLength() > 0);
     if (!rawFontData || 0 == rawFontData->getLength()) {
         return false;
     }
-    sk_sp<SkData> fontData(handle_type1_stream(rawFontData.get(), &header,
-                                                      &data, &trailer));
+    sk_sp<SkData> fontData(handle_type1_stream(rawFontData.get(), &header, &data, &trailer));
     if (fontData.get() == nullptr) {
         return false;
     }
     SkASSERT(this->canEmbed());
     auto fontStream = sk_make_sp<SkPDFStream>(std::move(fontData));
     fontStream->dict()->insertInt("Length1", header);
     fontStream->dict()->insertInt("Length2", data);
     fontStream->dict()->insertInt("Length3", trailer);
     descriptor->insertObjRef("FontFile", std::move(fontStream));
 
@@ skipping 199 matching lines @@
     }
     return *canon->fCanEmbedTypeface.set(id, canEmbed);
 }
 
 void SkPDFFont::drop() {
     fTypeface = nullptr;
     fFontInfo = nullptr;
     fDescriptor = nullptr;
     this->SkPDFDict::drop();
 }