SkPDF: AutoTUnref<T> changes in use

src/doc/SkDocument_PDF.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 "SkDocument.h"
 #include "SkPDFCanon.h"
 #include "SkPDFDevice.h"
@@ skipping 63 matching lines @@
 static SkPDFObject* create_pdf_page_content(const SkPDFDevice* pageDevice) {
     SkAutoTDelete<SkStreamAsset> content(pageDevice->content());
     return new SkPDFStream(content.get());
 }
 
 static SkPDFDict* create_pdf_page(const SkPDFDevice* pageDevice) {
     SkAutoTUnref<SkPDFDict> page(new SkPDFDict("Page"));
     page->insertObject("Resources", pageDevice->createResourceDict());
     page->insertObject("MediaBox", pageDevice->copyMediaBox());
     SkAutoTUnref<SkPDFArray> annotations(new SkPDFArray);
-    pageDevice->appendAnnotations(annotations);
+    pageDevice->appendAnnotations(annotations.get());
     if (annotations->size() > 0) {
-        page->insertObject("Annots", annotations.detach());
+        page->insertObject("Annots", annotations.release());
     }
     page->insertObjRef("Contents", create_pdf_page_content(pageDevice));
-    return page.detach();
+    return page.release();
 }
 
 static void generate_page_tree(const SkTDArray<SkPDFDict*>& pages,
                                SkTDArray<SkPDFDict*>* pageTree,
                                SkPDFDict** rootNode) {
     // PDF wants a tree describing all the pages in the document.  We arbitrary
     // choose 8 (kNodeSize) as the number of allowed children.  The internal
     // nodes have type "Pages" with an array of children, a parent pointer, and
     // the number of leaves below the node as "Count."  The leaves are passed
     // into the method, have type "Page" and need a parent pointer. This method
@@ skipping 44 matching lines @@
             // It is hard to count the number of leaf nodes in the current
             // subtree. However, by construction, we know that unless it's the
             // last subtree for the current depth, the leaf count will be
             // treeCapacity, otherwise it's what ever is left over after
             // consuming treeCapacity chunks.
             int pageCount = treeCapacity;
             if (i == curNodes.count()) {
                 pageCount = ((pages.count() - 1) % treeCapacity) + 1;
             }
             newNode->insertInt("Count", pageCount);
-            newNode->insertObject("Kids", kids.detach());
-            nextRoundNodes.push(newNode.detach());  // Transfer reference.
+            newNode->insertObject("Kids", kids.release());
+            nextRoundNodes.push(newNode.release());  // Transfer reference.
         }
 
         curNodes = nextRoundNodes;
         nextRoundNodes.rewind();
         treeCapacity *= kNodeSize;
     } while (curNodes.count() > 1);
 
     pageTree->push(curNodes[0]);  // Transfer reference.
     if (rootNode) {
         *rootNode = curNodes[0];
     }
 }
 
 static bool emit_pdf_document(const SkTDArray<const SkPDFDevice*>& pageDevices,
                               const SkPDFMetadata& metadata,
                               SkWStream* stream) {
     if (pageDevices.isEmpty()) {
         return false;
     }
 
     SkTDArray<SkPDFDict*> pages;
     SkAutoTUnref<SkPDFDict> dests(new SkPDFDict);
 
     for (int i = 0; i < pageDevices.count(); i++) {
         SkASSERT(pageDevices[i]);
         SkASSERT(i == 0 ||
                  pageDevices[i - 1]->getCanon() == pageDevices[i]->getCanon());
         SkAutoTUnref<SkPDFDict> page(create_pdf_page(pageDevices[i]));
-        pageDevices[i]->appendDestinations(dests, page.get());
-        pages.push(page.detach());
+        pageDevices[i]->appendDestinations(dests.get(), page.get());
+        pages.push(page.release());
     }
 
     SkAutoTUnref<SkPDFDict> docCatalog(new SkPDFDict("Catalog"));
 
     SkAutoTUnref<SkPDFObject> infoDict(
             metadata.createDocumentInformationDict());
 
     SkAutoTUnref<SkPDFObject> id, xmp;
 #ifdef SK_PDF_GENERATE_PDFA
     SkPDFMetadata::UUID uuid = metadata.uuid();
     // We use the same UUID for Document ID and Instance ID since this
     // is the first revision of this document (and Skia does not
     // support revising existing PDF documents).
     // If we are not in PDF/A mode, don't use a UUID since testing
     // works best with reproducible outputs.
     id.reset(SkPDFMetadata::CreatePdfId(uuid, uuid));
     xmp.reset(metadata.createXMPObject(uuid, uuid));
-    docCatalog->insertObjRef("Metadata", xmp.detach());
+    docCatalog->insertObjRef("Metadata", xmp.release());
 
     // sRGB is specified by HTML, CSS, and SVG.
     SkAutoTUnref<SkPDFDict> outputIntent(new SkPDFDict("OutputIntent"));
     outputIntent->insertName("S", "GTS_PDFA1");
     outputIntent->insertString("RegistryName", "http://www.color.org");
     outputIntent->insertString("OutputConditionIdentifier",
                                "sRGB IEC61966-2.1");
     SkAutoTUnref<SkPDFArray> intentArray(new SkPDFArray);
-    intentArray->appendObject(outputIntent.detach());
+    intentArray->appendObject(outputIntent.release());
     // Don't specify OutputIntents if we are not in PDF/A mode since
     // no one has ever asked for this feature.
-    docCatalog->insertObject("OutputIntents", intentArray.detach());
+    docCatalog->insertObject("OutputIntents", intentArray.release());
 #endif
 
     SkTDArray<SkPDFDict*> pageTree;
     SkPDFDict* pageTreeRoot;
     generate_page_tree(pages, &pageTree, &pageTreeRoot);
     docCatalog->insertObjRef("Pages", SkRef(pageTreeRoot));
 
     if (dests->size() > 0) {
-        docCatalog->insertObjRef("Dests", dests.detach());
+        docCatalog->insertObjRef("Dests", dests.release());
     }
 
     // Build font subsetting info before proceeding.
     SkPDFSubstituteMap substitutes;
     perform_font_subsetting(pageDevices, &substitutes);
 
     SkPDFObjNumMap objNumMap;
-    objNumMap.addObjectRecursively(infoDict, substitutes);
+    objNumMap.addObjectRecursively(infoDict.get(), substitutes);
     objNumMap.addObjectRecursively(docCatalog.get(), substitutes);
     size_t baseOffset = stream->bytesWritten();
     emit_pdf_header(stream);
     SkTDArray<int32_t> offsets;
     for (int i = 0; i < objNumMap.objects().count(); ++i) {
         SkPDFObject* object = objNumMap.objects()[i];
         size_t offset = stream->bytesWritten();
         // This assert checks that size(pdf_header) > 0 and that
         // the output stream correctly reports bytesWritten().
         SkASSERT(offset > baseOffset);
@@ skipping 12 matching lines @@
 
     stream->writeText("xref\n0 ");
     stream->writeDecAsText(objCount);
     stream->writeText("\n0000000000 65535 f \n");
     for (int i = 0; i < offsets.count(); i++) {
         SkASSERT(offsets[i] > 0);
         stream->writeBigDecAsText(offsets[i], 10);
         stream->writeText(" 00000 n \n");
     }
     emit_pdf_footer(stream, objNumMap, substitutes, docCatalog.get(), objCount,
-                    xRefFileOffset, infoDict.detach(), id.detach());
+                    xRefFileOffset, infoDict.release(), id.release());
 
     // The page tree has both child and parent pointers, so it creates a
     // reference cycle.  We must clear that cycle to properly reclaim memory.
     for (int i = 0; i < pageTree.count(); i++) {
         pageTree[i]->clear();
     }
     pageTree.safeUnrefAll();
     pages.unrefAll();
     return true;
 }
@@ skipping 43 matching lines @@
 
 namespace {
 class SkDocument_PDF : public SkDocument {
 public:
     SkDocument_PDF(SkWStream* stream,
                    void (*doneProc)(SkWStream*, bool),
                    SkScalar rasterDpi,
                    SkPixelSerializer* jpegEncoder)
         : SkDocument(stream, doneProc)
         , fRasterDpi(rasterDpi) {
-        fCanon.fPixelSerializer.reset(SkSafeRef(jpegEncoder));
+        fCanon.setPixelSerializer(SkSafeRef(jpegEncoder));
     }
 
     virtual ~SkDocument_PDF() {
         // subclasses must call close() in their destructors
         this->close();
     }
 
 protected:
     SkCanvas* onBeginPage(SkScalar width, SkScalar height,
                           const SkRect& trimBox) override {
         SkASSERT(!fCanvas.get());
 
         SkISize pageSize = SkISize::Make(
                 SkScalarRoundToInt(width), SkScalarRoundToInt(height));
         SkAutoTUnref<SkPDFDevice> device(
                 SkPDFDevice::Create(pageSize, fRasterDpi, &fCanon));
         fCanvas.reset(new SkCanvas(device.get()));
-        fPageDevices.push(device.detach());
+        fPageDevices.push(device.release());
         fCanvas->clipRect(trimBox);
         fCanvas->translate(trimBox.x(), trimBox.y());
         return fCanvas.get();
     }
 
     void onEndPage() override {
         SkASSERT(fCanvas.get());
         fCanvas->flush();
         fCanvas.reset(nullptr);
     }
@@ skipping 45 matching lines @@
 
 SkDocument* SkDocument::CreatePDF(const char path[], SkScalar dpi) {
     SkFILEWStream* stream = new SkFILEWStream(path);
     if (!stream->isValid()) {
         delete stream;
         return nullptr;
     }
     auto delete_wstream = [](SkWStream* stream, bool) { delete stream; };
     return new SkDocument_PDF(stream, delete_wstream, dpi, nullptr);
 }