SkPDF s/SkAutoTDelete/std::unique_ptr/

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 144 matching lines @@
 }
 
 static 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;
-    SkAutoTDelete<SkMemoryStream> staticStream;
+    std::unique_ptr<SkMemoryStream> staticStream;
     SkData* data = nullptr;
     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;
@@ skipping 406 matching lines @@
     delete[] (unsigned char*)ptr;
 }
 #endif
 
 #if defined(SK_SFNTLY_SUBSETTER)
 static size_t get_subset_font_stream(const char* fontName,
                                      const SkTypeface* typeface,
                                      const SkTDArray<uint32_t>& subset,
                                      SkPDFStream** fontStream) {
     int ttcIndex;
-    SkAutoTDelete<SkStream> fontData(typeface->openStream(&ttcIndex));
+    std::unique_ptr<SkStream> fontData(typeface->openStream(&ttcIndex));
     SkASSERT(fontData.get());
 
     size_t fontSize = fontData->getLength();
 
     // Read font into buffer.
     SkPDFStream* subsetFontStream = nullptr;
     SkTDArray<unsigned char> originalFont;
     originalFont.setCount(SkToInt(fontSize));
     if (fontData->read(originalFont.begin(), fontSize) == fontSize) {
         unsigned char* subsetFont = nullptr;
@@ skipping 446 matching lines @@
                                                   &rawStream);
                 if (rawStream) {
                     fontStream.reset(rawStream);
                     fontStream->insertInt("Length1", fontSize);
                     descriptor->insertObjRef("FontFile2", std::move(fontStream));
                     break;
                 }
             }
 #endif
             sk_sp<SkPDFSharedStream> fontStream;
-            SkAutoTDelete<SkStreamAsset> fontData(
+            std::unique_ptr<SkStreamAsset> fontData(
                     this->typeface()->openStream(nullptr));
             SkASSERT(fontData);
             fontSize = fontData->getLength();
             SkASSERT(fontSize > 0);
             fontStream.reset(new SkPDFSharedStream(fontData.release()));
             fontStream->dict()->insertInt("Length1", fontSize);
             descriptor->insertObjRef("FontFile2", std::move(fontStream));
             break;
         }
         case SkAdvancedTypefaceMetrics::kCFF_Font:
@@ skipping 121 matching lines @@
         return true;
     }
 
     auto descriptor = sk_make_sp<SkPDFDict>("FontDescriptor");
     setFontDescriptor(descriptor.get());
 
     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;
-    SkAutoTDelete<SkStream> rawFontData(typeface()->openStream(&ttcIndex));
+    std::unique_ptr<SkStream> rawFontData(typeface()->openStream(&ttcIndex));
     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>(fontData.get());
     fontStream->insertInt("Length1", header);
     fontStream->insertInt("Length2", data);
     fontStream->insertInt("Length3", trailer);
@@ skipping 138 matching lines @@
 
         SkDynamicMemoryWStream content;
         setGlyphWidthAndBoundingBox(SkFloatToScalar(glyph.fAdvanceX), glyphBBox,
                                     &content);
         const SkPath* path = cache->findPath(glyph);
         if (path) {
             SkPDFUtils::EmitPath(*path, paint.getStyle(), &content);
             SkPDFUtils::PaintPath(paint.getStyle(), path->getFillType(),
                                   &content);
         }
-        SkAutoTDelete<SkMemoryStream> glyphStream(new SkMemoryStream());
+        std::unique_ptr<SkMemoryStream> glyphStream(new SkMemoryStream());
         glyphStream->setData(content.copyToData())->unref();
 
         charProcs->insertObjRef(
                 characterName, sk_make_sp<SkPDFStream>(glyphStream.get()));
     }
 
     encoding->insertObject("Differences", std::move(encDiffs));
 
     this->insertObject("CharProcs", std::move(charProcs));
     this->insertObject("Encoding", std::move(encoding));
@@ skipping 47 matching lines @@
     }
     return *canon->fCanEmbedTypeface.set(id, canEmbed);
 }
 
 void SkPDFFont::drop() {
     fTypeface = nullptr;
     fFontInfo = nullptr;
     fDescriptor = nullptr;
     this->SkPDFDict::drop();
 }