SKPDF: refactor pdfcatalog and pdfdocument

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 "SkPDFCatalog.h"
 #include "SkPDFDevice.h"
 #include "SkPDFDocument.h"
 #include "SkPDFFont.h"
 #include "SkPDFPage.h"
 #include "SkPDFTypes.h"
 #include "SkStream.h"
 
 
 static void perform_font_subsetting(SkPDFCatalog* catalog,
-                                    const SkTDArray<SkPDFPage*>& pages,
-                                    SkTDArray<SkPDFObject*>* substitutes) {
+                                    const SkTDArray<SkPDFPage*>& pages) {
     SkASSERT(catalog);
-    SkASSERT(substitutes);
 
     SkPDFGlyphSetMap usage;
     for (int i = 0; i < pages.count(); ++i) {
         usage.merge(pages[i]->getFontGlyphUsage());
     }
     SkPDFGlyphSetMap::F2BIter iterator(usage);
     const SkPDFGlyphSetMap::FontGlyphSetPair* entry = iterator.next();
     while (entry) {
-        SkPDFFont* subsetFont =
-            entry->fFont->getFontSubset(entry->fGlyphSet);
+        SkAutoTUnref<SkPDFFont> subsetFont(
+                entry->fFont->getFontSubset(entry->fGlyphSet));
         if (subsetFont) {
-            catalog->setSubstitute(entry->fFont, subsetFont);
-            substitutes->push(subsetFont);  // Transfer ownership to substitutes
+            catalog->setSubstitute(entry->fFont, subsetFont.get());
         }
         entry = iterator.next();
     }
 }
 
 static void emit_pdf_header(SkWStream* stream) {
     stream->writeText("%PDF-1.4\n%");
     // The PDF spec recommends including a comment with four bytes, all
     // with their high bits set.  This is "Skia" with the high bits set.
     stream->write32(0xD3EBE9E1);
@@ skipping 18 matching lines @@
     stream->writeText("\n%%EOF");
 }
 
 bool SkPDFDocument::EmitPDF(const SkTDArray<const SkPDFDevice*>& pageDevices,
                             SkWStream* stream) {
     if (pageDevices.isEmpty()) {
         return false;
     }
 
     SkTDArray<SkPDFPage*> pages;
+    SkAutoTUnref<SkPDFDict> dests(SkNEW(SkPDFDict));
+
     for (int i = 0; i < pageDevices.count(); i++) {
         SkASSERT(pageDevices[i]);
         SkASSERT(i == 0 ||
                  pageDevices[i - 1]->getCanon() == pageDevices[i]->getCanon());
         // Reference from new passed to pages.
-        pages.push(SkNEW_ARGS(SkPDFPage, (pageDevices[i])));
+        SkAutoTUnref<SkPDFPage> page(SkNEW_ARGS(SkPDFPage, (pageDevices[i])));
+        page->finalizePage();
+        page->appendDestinations(dests);
+        pages.push(page.detach());
     }
     SkPDFCatalog catalog;
 
     SkTDArray<SkPDFDict*> pageTree;
     SkAutoTUnref<SkPDFDict> docCatalog(SkNEW_ARGS(SkPDFDict, ("Catalog")));
-    SkTSet<SkPDFObject*> firstPageResources;
-    SkTSet<SkPDFObject*> otherPageResources;
-    SkTDArray<SkPDFObject*> substitutes;
-    catalog.addObject(docCatalog.get(), true);
 
     SkPDFDict* pageTreeRoot;
-    SkPDFPage::GeneratePageTree(pages, &catalog, &pageTree, &pageTreeRoot);
+    SkPDFPage::GeneratePageTree(pages, &pageTree, &pageTreeRoot);
+
     docCatalog->insert("Pages", new SkPDFObjRef(pageTreeRoot))->unref();
 
     /* 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());
     */
 
-    SkAutoTUnref<SkPDFDict> dests(SkNEW(SkPDFDict));
-
-    bool firstPage = true;
-    /* The references returned in newResources are transfered to
-     * firstPageResources or otherPageResources depending on firstPage and
-     * knownResources doesn't have a reference but just relies on the other
-     * two sets to maintain a reference.
-     */
-    SkTSet<SkPDFObject*> knownResources;
-
-    // mergeInto returns the number of duplicates.
-    // If there are duplicates, there is a bug and we mess ref counting.
-    SkDEBUGCODE(int duplicates = ) knownResources.mergeInto(firstPageResources);
-    SkASSERT(duplicates == 0);
-
-    for (int i = 0; i < pages.count(); i++) {
-        if (i == 1) {
-            firstPage = false;
-            SkDEBUGCODE(duplicates = )
-                    knownResources.mergeInto(otherPageResources);
-        }
-        SkTSet<SkPDFObject*> newResources;
-        pages[i]->finalizePage(&catalog, firstPage, knownResources,
-                               &newResources);
-        for (int j = 0; j < newResources.count(); j++) {
-            catalog.addObject(newResources[i], firstPage);
-        }
-        if (firstPage) {
-            SkDEBUGCODE(duplicates = )
-                    firstPageResources.mergeInto(newResources);
-        } else {
-            SkDEBUGCODE(duplicates = )
-                    otherPageResources.mergeInto(newResources);
-        }
-        SkASSERT(duplicates == 0);
-
-        SkDEBUGCODE(duplicates = ) knownResources.mergeInto(newResources);
-        SkASSERT(duplicates == 0);
-
-        pages[i]->appendDestinations(dests);
-    }
-
     if (dests->size() > 0) {
-        SkPDFDict* raw_dests = dests.get();
-        firstPageResources.add(dests.detach());  // Transfer ownership.
-        catalog.addObject(raw_dests, true /* onFirstPage */);
-        docCatalog->insert("Dests", SkNEW_ARGS(SkPDFObjRef, (raw_dests)))
+        docCatalog->insert("Dests", SkNEW_ARGS(SkPDFObjRef, (dests.get())))
                 ->unref();
     }
 
     // Build font subsetting info before proceeding.
-    perform_font_subsetting(&catalog, pages, &substitutes);
+    perform_font_subsetting(&catalog, pages);
 
     SkTSet<SkPDFObject*> resourceSet;
     if (resourceSet.add(docCatalog.get())) {
         docCatalog->addResources(&resourceSet, &catalog);
     }
+    for (int i = 0; i < resourceSet.count(); ++i) {
+        SkAssertResult(catalog.addObject(resourceSet[i]));
+    }
+
     size_t baseOffset = SkToOffT(stream->bytesWritten());
     emit_pdf_header(stream);
+    SkTDArray<int32_t> offsets;
     for (int i = 0; i < resourceSet.count(); ++i) {
         SkPDFObject* object = resourceSet[i];
-        catalog.setFileOffset(object,
-                              SkToOffT(stream->bytesWritten() - baseOffset));
+        offsets.push(SkToS32(stream->bytesWritten() - baseOffset));
         SkASSERT(object == catalog.getSubstituteObject(object));
-        stream->writeDecAsText(catalog.getObjectNumber(object));
+        SkASSERT(catalog.getObjectNumber(object) == i + 1);
+        stream->writeDecAsText(i + 1);
         stream->writeText(" 0 obj\n");  // Generation number is always 0.
         object->emitObject(stream, &catalog);
         stream->writeText("\nendobj\n");
     }
     int32_t xRefFileOffset = SkToS32(stream->bytesWritten() - baseOffset);
-    int64_t objCount = catalog.emitXrefTable(stream, pages.count() > 1);
 
+    int32_t objCount = SkToS32(offsets.count() + 1);
+
+    stream->writeText("xref\n0 ");
+    stream->writeDecAsText(objCount + 1);
+    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, &catalog, docCatalog.get(), objCount,
                     xRefFileOffset);
 
     // 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();
-
-    firstPageResources.safeUnrefAll();
-    otherPageResources.safeUnrefAll();
-
-    substitutes.unrefAll();
-    docCatalog.reset(NULL);
     return true;
 }
 
 // TODO(halcanary): expose notEmbeddableCount in SkDocument
 void SkPDFDocument::GetCountOfFontTypes(
         const SkTDArray<SkPDFDevice*>& pageDevices,
         int counts[SkAdvancedTypefaceMetrics::kOther_Font + 1],
         int* notSubsettableCount,
         int* notEmbeddableCount) {
     sk_bzero(counts, sizeof(int) *
@@ skipping 20 matching lines @@
         }
     }
     if (notSubsettableCount) {
         *notSubsettableCount = notSubsettable;
 
     }
     if (notEmbeddableCount) {
         *notEmbeddableCount = notEmbeddable;
     }
 }