SkPDF: clean up uses of deprecated calls in SkDocument_PDF

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 13 matching lines @@
 static void emit_pdf_footer(SkWStream* stream,
                             const SkPDFObjNumMap& objNumMap,
                             const SkPDFSubstituteMap& substitutes,
                             SkPDFObject* docCatalog,
                             int64_t objCount,
                             int32_t xRefFileOffset) {
     SkPDFDict trailerDict;
     // TODO(vandebo): Linearized format will take a Prev entry too.
     // TODO(vandebo): PDF/A requires an ID entry.
     trailerDict.insertInt("Size", int(objCount));
-    trailerDict.insert("Root", new SkPDFObjRef(docCatalog))->unref();
+    trailerDict.insertObjRef("Root", SkRef(docCatalog));
 
     stream->writeText("trailer\n");
     trailerDict.emitObject(stream, objNumMap, substitutes);
     stream->writeText("\nstartxref\n");
     stream->writeBigDecAsText(xRefFileOffset);
     stream->writeText("\n%%EOF");
 }
 
 static void perform_font_subsetting(
         const SkTDArray<const SkPDFDevice*>& pageDevices,
         SkPDFSubstituteMap* substituteMap) {
     SkASSERT(substituteMap);
 
     SkPDFGlyphSetMap usage;
     for (int i = 0; i < pageDevices.count(); ++i) {
         usage.merge(pageDevices[i]->getFontGlyphUsage());
     }
     SkPDFGlyphSetMap::F2BIter iterator(usage);
     const SkPDFGlyphSetMap::FontGlyphSetPair* entry = iterator.next();
     while (entry) {
         SkAutoTUnref<SkPDFFont> subsetFont(
                 entry->fFont->getFontSubset(entry->fGlyphSet));
         if (subsetFont) {
             substituteMap->setSubstitute(entry->fFont, subsetFont.get());
         }
         entry = iterator.next();
     }
 }
 
+static SkPDFObject* create_pdf_page_content(const SkPDFDevice* pageDevice) {
+    SkAutoTDelete<SkStreamAsset> content(pageDevice->content());
+    return SkNEW_ARGS(SkPDFStream, (content.get()));

[tomhudson, 2015/05/04 18:15:04]

Ugh, I really need to internalize your memory management approach.

We create content.
We store the pointer in the SkPDFStream
We then autodelete content?

... because two or three layers down in the calling chain,
SkStreamRewindableFromSkStream is going to try to duplicate the stream passed
in? Is there not a reasonable way to do this that isn't going to dup a stream?
(Or is that so lightweight it doesn't matter?)

[hal.canary, 2015/05/05 14:37:50]

Yes.  SkStreamRewindableFromSkStream should be almost free.

Also, SkPDFStream will be re-written from scratch at a later date.

+}
+
 static SkPDFDict* create_pdf_page(const SkPDFDevice* pageDevice) {
     SkAutoTUnref<SkPDFDict> page(SkNEW_ARGS(SkPDFDict, ("Page")));
-    SkAutoTUnref<SkPDFDict> deviceResourceDict(
-            pageDevice->createResourceDict());
-    page->insert("Resources", deviceResourceDict.get());
-
-    SkAutoTUnref<SkPDFArray> mediaBox(pageDevice->copyMediaBox());
-    page->insert("MediaBox", mediaBox.get());
-
-    SkPDFArray* annots = pageDevice->getAnnotations();
-    if (annots && annots->size() > 0) {
-        page->insert("Annots", annots);
+    page->insertObject("Resources", pageDevice->createResourceDict());
+    page->insertObject("MediaBox", pageDevice->copyMediaBox());
+    if (SkPDFArray* annots = pageDevice->getAnnotations()) {
+        SkASSERT(annots->size() > 0);
+        page->insertObject("Annots", SkRef(annots));
     }
-
-    SkAutoTDelete<SkStreamAsset> content(pageDevice->content());
-    SkAutoTUnref<SkPDFStream> contentStream(
-            SkNEW_ARGS(SkPDFStream, (content.get())));
-    page->insert("Contents", new SkPDFObjRef(contentStream.get()))->unref();
+    page->insertObjRef("Contents", create_pdf_page_content(pageDevice));
     return page.detach();
 }
 
 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
@@ skipping 15 matching lines @@
     nextRoundNodes.setReserve((pages.count() + kNodeSize - 1)/kNodeSize);
 
     int treeCapacity = kNodeSize;
     do {
         for (int i = 0; i < curNodes.count(); ) {
             if (i > 0 && i + 1 == curNodes.count()) {
                 nextRoundNodes.push(curNodes[i]);
                 break;
             }
 
-            SkPDFDict* newNode = new SkPDFDict("Pages");
-            SkAutoTUnref<SkPDFObjRef> newNodeRef(new SkPDFObjRef(newNode));
-
+            SkAutoTUnref<SkPDFDict> newNode(new SkPDFDict("Pages"));
             SkAutoTUnref<SkPDFArray> kids(new SkPDFArray);
             kids->reserve(kNodeSize);
 
             int count = 0;
             for (; i < curNodes.count() && count < kNodeSize; i++, count++) {
-                curNodes[i]->insert("Parent", newNodeRef.get());
-                kids->append(new SkPDFObjRef(curNodes[i]))->unref();
+                curNodes[i]->insertObjRef("Parent", SkRef(newNode.get()));
+                kids->appendObjRef(SkRef(curNodes[i]));
 
                 // TODO(vandebo): put the objects in strict access order.
                 // Probably doesn't matter because they are so small.
                 if (curNodes[i] != pages[0]) {
                     pageTree->push(curNodes[i]);  // Transfer reference.
                 } else {
                     SkSafeUnref(curNodes[i]);
                 }
             }
 
             // treeCapacity is the number of leaf nodes possible for the
             // current set of subtrees being generated. (i.e. 8, 64, 512, ...).
             // 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->insert("Count", new SkPDFInt(pageCount))->unref();
-            newNode->insert("Kids", kids.get());
-            nextRoundNodes.push(newNode);  // Transfer reference.
+            newNode->insertInt("Count", pageCount);
+            newNode->insertObject("Kids", kids.detach());
+            nextRoundNodes.push(newNode.detach());  // Transfer reference.
         }
 
         curNodes = nextRoundNodes;
         nextRoundNodes.rewind();
         treeCapacity *= kNodeSize;
     } while (curNodes.count() > 1);
 
     pageTree->push(curNodes[0]);  // Transfer reference.
     if (rootNode) {
         *rootNode = curNodes[0];
@@ skipping 16 matching lines @@
         SkAutoTUnref<SkPDFDict> page(create_pdf_page(pageDevices[i]));
         pageDevices[i]->appendDestinations(dests, page.get());
         pages.push(page.detach());
     }
 
     SkTDArray<SkPDFDict*> pageTree;
     SkAutoTUnref<SkPDFDict> docCatalog(SkNEW_ARGS(SkPDFDict, ("Catalog")));
 
     SkPDFDict* pageTreeRoot;
     generate_page_tree(pages, &pageTree, &pageTreeRoot);
+    docCatalog->insertObjRef("Pages", SkRef(pageTreeRoot));
 
-    docCatalog->insert("Pages", new SkPDFObjRef(pageTreeRoot))->unref();
+    if (dests->size() > 0) {
+        docCatalog->insertObjRef("Dests", dests.detach());
+    }
 
     /* TODO(vandebo): output intent
     SkAutoTUnref<SkPDFDict> outputIntent = new SkPDFDict("OutputIntent");
-    outputIntent->insert("S", new SkPDFName("GTS_PDFA1"))->unref();
-    outputIntent->insert("OutputConditionIdentifier",
-                         new SkPDFString("sRGB"))->unref();
-    SkAutoTUnref<SkPDFArray> intentArray = new SkPDFArray;
-    intentArray->append(outputIntent.get());
-    docCatalog->insert("OutputIntent", intentArray.get());
+    outputIntent->insertName("S", "GTS_PDFA1");
+    outputIntent->insertString("OutputConditionIdentifier", "sRGB");
+    SkAutoTUnref<SkPDFArray> intentArray(new SkPDFArray);
+    intentArray->appendObject(SkRef(outputIntent.get()));
+    docCatalog->insertObject("OutputIntent", intentArray.detach());
     */
 
-    if (dests->size() > 0) {
-        docCatalog->insert("Dests", SkNEW_ARGS(SkPDFObjRef, (dests.get())))
-                ->unref();
-    }
-
     // Build font subsetting info before proceeding.
     SkPDFSubstituteMap substitutes;
     perform_font_subsetting(pageDevices, &substitutes);
 
     SkPDFObjNumMap objNumMap;
     if (objNumMap.addObject(docCatalog.get())) {
         docCatalog->addResources(&objNumMap, substitutes);
     }
     size_t baseOffset = SkToOffT(stream->bytesWritten());
     emit_pdf_header(stream);
@@ skipping 140 matching lines @@
 
 SkDocument* SkDocument::CreatePDF(const char path[], SkScalar dpi) {
     SkFILEWStream* stream = SkNEW_ARGS(SkFILEWStream, (path));
     if (!stream->isValid()) {
         SkDELETE(stream);
         return NULL;
     }
     auto delete_wstream = [](SkWStream* stream, bool) { SkDELETE(stream); };
     return SkNEW_ARGS(SkDocument_PDF, (stream, delete_wstream, dpi));
 }