SkPDF: Hold page objects, not SkPDFDevices.

src/pdf/SkPDFDocument.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 "SkPDFCanon.h"
 #include "SkPDFCanvas.h"
 #include "SkPDFDevice.h"
@@ skipping 75 matching lines @@
     wStream->writeBigDecAsText(xRefFileOffset);
     wStream->writeText("\n%%EOF");
 }
 
 int32_t SkPDFObjectSerializer::offset(SkWStream* wStream) {
     size_t offset = wStream->bytesWritten();
     SkASSERT(offset > fBaseOffset);
     return SkToS32(offset - fBaseOffset);
 }
 
-static void perform_font_subsetting(
-        const SkTArray<sk_sp<const SkPDFDevice>>& pageDevices,
-        SkPDFSubstituteMap* substituteMap) {
-    SkASSERT(substituteMap);
-
-    SkPDFGlyphSetMap usage;
-    for (const sk_sp<const SkPDFDevice>& pageDevice : pageDevices) {
-        usage.merge(pageDevice->getFontGlyphUsage());
-    }
-    SkPDFGlyphSetMap::F2BIter iterator(usage);
-    const SkPDFGlyphSetMap::FontGlyphSetPair* entry = iterator.next();
-    while (entry) {
-        sk_sp<SkPDFFont> subsetFont(
-                entry->fFont->getFontSubset(entry->fGlyphSet));
-        if (subsetFont) {
-            substituteMap->setSubstitute(entry->fFont, subsetFont.get());
-        }
-        entry = iterator.next();
-    }
-}
-
-static sk_sp<SkPDFDict> create_pdf_page(const SkPDFDevice* pageDevice) {
-    auto page = sk_make_sp<SkPDFDict>("Page");
-    page->insertObject("Resources", pageDevice->makeResourceDict());
-    page->insertObject("MediaBox", pageDevice->copyMediaBox());
-    auto annotations = sk_make_sp<SkPDFArray>();
-    pageDevice->appendAnnotations(annotations.get());
-    if (annotations->size() > 0) {
-        page->insertObject("Annots", std::move(annotations));
-    }
-    auto content = pageDevice->content();
-    page->insertObjRef("Contents", sk_make_sp<SkPDFStream>(content.get()));
-    return page;
-}
 
 // return root node.
-static sk_sp<SkPDFDict> generate_page_tree(
-        SkTDArray<SkPDFDict*>& pages,
-        SkTDArray<SkPDFDict*>* pageTree) {
+static sk_sp<SkPDFDict> generate_page_tree(SkTArray<sk_sp<SkPDFDict>>* pages) {
     // 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
     // builds the tree bottom up, skipping internal nodes that would have only
     // one child.
     static const int kNodeSize = 8;
 
     // curNodes takes a reference to its items, which it passes to pageTree.
-    SkTDArray<SkPDFDict*> curNodes;
-    curNodes.setReserve(pages.count());
-    for (int i = 0; i < pages.count(); i++) {
-        SkSafeRef(pages[i]);
-        curNodes.push(pages[i]);
-    }
+    int totalPageCount = pages->count();
+    SkTArray<sk_sp<SkPDFDict>> curNodes;
+    curNodes.swap(pages);
 
     // nextRoundNodes passes its references to nodes on to curNodes.
-    SkTDArray<SkPDFDict*> nextRoundNodes;
-    nextRoundNodes.setReserve((pages.count() + kNodeSize - 1)/kNodeSize);
-
     int treeCapacity = kNodeSize;
     do {
+        SkTArray<sk_sp<SkPDFDict>> nextRoundNodes;
         for (int i = 0; i < curNodes.count(); ) {
             if (i > 0 && i + 1 == curNodes.count()) {
-                nextRoundNodes.push(curNodes[i]);
+                SkASSERT(curNodes[i]);
+                nextRoundNodes.emplace_back(std::move(curNodes[i]));
                 break;
             }
 
             auto newNode = sk_make_sp<SkPDFDict>("Pages");
             auto kids = sk_make_sp<SkPDFArray>();
             kids->reserve(kNodeSize);
 
             int count = 0;
             for (; i < curNodes.count() && count < kNodeSize; i++, count++) {
+                SkASSERT(curNodes[i]);
                 curNodes[i]->insertObjRef("Parent", newNode);
-                kids->appendObjRef(sk_ref_sp(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]);
-                }
+                kids->appendObjRef(std::move(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;
+                pageCount = ((totalPageCount - 1) % treeCapacity) + 1;
             }
             newNode->insertInt("Count", pageCount);
             newNode->insertObject("Kids", std::move(kids));
-            nextRoundNodes.push(newNode.release());  // Transfer reference.
+            nextRoundNodes.emplace_back(std::move(newNode));
         }
+        SkDEBUGCODE( for (const auto& n : curNodes) { SkASSERT(!n); } );
 
-        curNodes = nextRoundNodes;
-        nextRoundNodes.rewind();
+        curNodes.swap(&nextRoundNodes);
+        nextRoundNodes.reset();
         treeCapacity *= kNodeSize;
     } while (curNodes.count() > 1);
-
-    pageTree->push(curNodes[0]);  // Transfer reference.
-    return sk_ref_sp(curNodes[0]);
+    return std::move(curNodes[0]);
 }
 
 #if 0
 // TODO(halcanary): expose notEmbeddableCount in SkDocument
 void GetCountOfFontTypes(
         const SkTDArray<SkPDFDevice*>& pageDevices,
         int counts[SkAdvancedTypefaceMetrics::kOther_Font + 1],
         int* notSubsettableCount,
         int* notEmbeddableCount) {
     sk_bzero(counts, sizeof(int) *
@@ skipping 47 matching lines @@
 }
 
 void SkPDFDocument::serialize(const sk_sp<SkPDFObject>& object) {
     fObjectSerializer.addObjectRecursively(object);
     fObjectSerializer.serializeObjects(this->getStream());
 }
 
 SkCanvas* SkPDFDocument::onBeginPage(SkScalar width, SkScalar height,
                                      const SkRect& trimBox) {
     SkASSERT(!fCanvas.get());  // endPage() was called before this.
-    if (fPageDevices.empty()) {
+    if (fPages.empty()) {
         // if this is the first page if the document.
         fObjectSerializer.serializeHeader(this->getStream(), fMetadata);
+        fDests = sk_make_sp<SkPDFDict>();
     }
     SkISize pageSize = SkISize::Make(
             SkScalarRoundToInt(width), SkScalarRoundToInt(height));
-    sk_sp<SkPDFDevice> device(
+    fPageDevice.reset(
             SkPDFDevice::Create(pageSize, fRasterDpi, this));
-    fCanvas = sk_make_sp<SkPDFCanvas>(device);
-    fPageDevices.push_back(std::move(device));
+    fCanvas = sk_make_sp<SkPDFCanvas>(fPageDevice);
     fCanvas->clipRect(trimBox);
     fCanvas->translate(trimBox.x(), trimBox.y());
     return fCanvas.get();
 }
 
 void SkPDFDocument::onEndPage() {
     SkASSERT(fCanvas.get());
     fCanvas->flush();
     fCanvas.reset(nullptr);
+    SkASSERT(fPageDevice);
+    fGlyphUsage.merge(fPageDevice->getFontGlyphUsage());
+    auto page = sk_make_sp<SkPDFDict>("Page");
+    page->insertObject("Resources", fPageDevice->makeResourceDict());
+    page->insertObject("MediaBox", fPageDevice->copyMediaBox());
+    auto annotations = sk_make_sp<SkPDFArray>();
+    fPageDevice->appendAnnotations(annotations.get());
+    if (annotations->size() > 0) {
+        page->insertObject("Annots", std::move(annotations));
+    }
+    auto contentData = fPageDevice->content();
+    auto contentObject = sk_make_sp<SkPDFStream>(contentData.get());
+    this->serialize(contentObject);
+    page->insertObjRef("Contents", std::move(contentObject));
+    fPageDevice->appendDestinations(fDests.get(), page.get());
+    fPages.emplace_back(std::move(page));
+    fPageDevice.reset(nullptr);
 }
 
 void SkPDFDocument::onAbort() {
     fCanvas.reset(nullptr);
-    fPageDevices.reset();
+    fPages.reset();
     fCanon.reset();
     renew(&fObjectSerializer);
 }
 
 void SkPDFDocument::setMetadata(const SkDocument::Attribute info[],
                                 int infoCount,
                                 const SkTime::DateTime* creationDate,
                                 const SkTime::DateTime* modifiedDate) {
     fMetadata.fInfo.reset(info, infoCount);
     fMetadata.fCreation.reset(clone(creationDate));
     fMetadata.fModified.reset(clone(modifiedDate));
 }
 
 bool SkPDFDocument::onClose(SkWStream* stream) {
     SkASSERT(!fCanvas.get());
-    if (fPageDevices.empty()) {
-        fPageDevices.reset();
+    if (fPages.empty()) {
+        fPages.reset();
         fCanon.reset();
         renew(&fObjectSerializer);
         return false;
     }
-    SkTDArray<SkPDFDict*> pages;  // TODO: SkTArray<sk_sp<SkPDFDict>>
-    auto dests = sk_make_sp<SkPDFDict>();
-
-    for (const sk_sp<const SkPDFDevice>& pageDevice : fPageDevices) {
-        SkASSERT(pageDevice);
-        SkASSERT(fPageDevices[0]->getCanon() == pageDevice->getCanon());
-        sk_sp<SkPDFDict> page(create_pdf_page(pageDevice.get()));
-        pageDevice->appendDestinations(dests.get(), page.get());
-        pages.push(page.release());
-    }
-
     auto docCatalog = sk_make_sp<SkPDFDict>("Catalog");
-
     sk_sp<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", std::move(xmp));
 
         // sRGB is specified by HTML, CSS, and SVG.
         auto outputIntent = sk_make_sp<SkPDFDict>("OutputIntent");
         outputIntent->insertName("S", "GTS_PDFA1");
         outputIntent->insertString("RegistryName", "http://www.color.org");
         outputIntent->insertString("OutputConditionIdentifier",
                                    "sRGB IEC61966-2.1");
         auto intentArray = sk_make_sp<SkPDFArray>();
         intentArray->appendObject(std::move(outputIntent));
         // Don't specify OutputIntents if we are not in PDF/A mode since
         // no one has ever asked for this feature.
         docCatalog->insertObject("OutputIntents", std::move(intentArray));
     #endif
 
-    SkTDArray<SkPDFDict*> pageTree;
-    docCatalog->insertObjRef("Pages", generate_page_tree(pages, &pageTree));
+    docCatalog->insertObjRef("Pages", generate_page_tree(&fPages));
 
-    if (dests->size() > 0) {
-        docCatalog->insertObjRef("Dests", std::move(dests));
+    if (fDests->size() > 0) {
+        docCatalog->insertObjRef("Dests", std::move(fDests));
     }
 
     // Build font subsetting info before calling addObjectRecursively().
-    perform_font_subsetting(fPageDevices, &fObjectSerializer.fSubstituteMap);
+    for (const auto& entry : fGlyphUsage) {
+        sk_sp<SkPDFFont> subsetFont(
+                entry.fFont->getFontSubset(entry.fGlyphSet));
+        if (subsetFont) {
+            fObjectSerializer.fSubstituteMap.setSubstitute(
+                    entry.fFont, subsetFont.get());
+        }
+    }
 
     fObjectSerializer.addObjectRecursively(docCatalog);
     fObjectSerializer.serializeObjects(this->getStream());
     fObjectSerializer.serializeFooter(
             this->getStream(), docCatalog, std::move(id));
-    pageTree.unrefAll();  // TODO(halcanary): make this unnecesary by
-                          // refactoring generate_page_tree().
-    pages.unrefAll();
-    fPageDevices.reset();
+
+    SkASSERT(fPages.count() == 0);
     fCanon.reset();
     renew(&fObjectSerializer);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 sk_sp<SkDocument> SkPDFMakeDocument(SkWStream* stream,
                                     void (*proc)(SkWStream*, bool),
                                     SkScalar dpi,
@@ skipping 11 matching lines @@
     return SkPDFMakeDocument(stream, nullptr, dpi, jpegEncoder).release();
 }
 
 SkDocument* SkDocument::CreatePDF(const char path[], SkScalar dpi) {
     auto delete_wstream = [](SkWStream* stream, bool) { delete stream; };
     SkAutoTDelete<SkFILEWStream> stream(new SkFILEWStream(path));
     return stream->isValid()
         ? SkPDFMakeDocument(stream.release(), delete_wstream, dpi, nullptr).release()
         : nullptr;
 }