SkPDF: clean up skpdfdocument, add static functions

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"
@@ skipping 21 matching lines @@
         SkPDFFont* subsetFont =
             entry->fFont->getFontSubset(entry->fGlyphSet);
         if (subsetFont) {
             catalog->setSubstitute(entry->fFont, subsetFont);
             substitutes->push(subsetFont);  // Transfer ownership to substitutes
         }
         entry = iterator.next();
     }
 }
 
-SkPDFDocument::SkPDFDocument() {}
-
-SkPDFDocument::~SkPDFDocument() { fPageDevices.unrefAll(); }
-
 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);
     stream->writeText("\n");
 }
 
 static void emit_pdf_footer(SkWStream* stream,
                             SkPDFCatalog* catalog,
                             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();
 
     stream->writeText("trailer\n");
     trailerDict.emitObject(stream, catalog);
     stream->writeText("\nstartxref\n");
     stream->writeBigDecAsText(xRefFileOffset);
     stream->writeText("\n%%EOF");
 }
 
-bool SkPDFDocument::emitPDF(SkWStream* stream) {
-    // SkTDArray<SkPDFDevice*> fPageDevices;
-    if (fPageDevices.isEmpty()) {
+bool SkPDFDocument::EmitPDF(const SkTDArray<SkPDFDevice*>& pageDevices,
+                            SkWStream* stream) {
+    if (pageDevices.isEmpty()) {
         return false;
     }
     SkTDArray<SkPDFPage*> pages;
-    for (int i = 0; i < fPageDevices.count(); i++) {
+    for (int i = 0; i < pageDevices.count(); i++) {
+        SkASSERT(pageDevices[i]);
         // Reference from new passed to pages.
-        pages.push(SkNEW_ARGS(SkPDFPage, (fPageDevices[i])));
+        pages.push(SkNEW_ARGS(SkPDFPage, (pageDevices[i])));
     }
     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);
 
@@ skipping 96 matching lines @@
 
     firstPageResources.safeUnrefAll();
     otherPageResources.safeUnrefAll();
 
     substitutes.unrefAll();
     docCatalog.reset(NULL);
     return true;
 }
 
 // TODO(halcanary): expose notEmbeddableCount in SkDocument
-void SkPDFDocument::getCountOfFontTypes(
+void SkPDFDocument::GetCountOfFontTypes(
+        const SkTDArray<SkPDFDevice*>& pageDevices,
         int counts[SkAdvancedTypefaceMetrics::kOther_Font + 1],
         int* notSubsettableCount,
-        int* notEmbeddableCount) const {
+        int* notEmbeddableCount) {
     sk_bzero(counts, sizeof(int) *
                      (SkAdvancedTypefaceMetrics::kOther_Font + 1));
     SkTDArray<SkFontID> seenFonts;
     int notSubsettable = 0;
     int notEmbeddable = 0;
 
-    for (int pageNumber = 0; pageNumber < fPageDevices.count(); pageNumber++) {
+    for (int pageNumber = 0; pageNumber < pageDevices.count(); pageNumber++) {
         const SkTDArray<SkPDFFont*>& fontResources =
-                fPageDevices[pageNumber]->getFontResources();
+                pageDevices[pageNumber]->getFontResources();
         for (int font = 0; font < fontResources.count(); font++) {
             SkFontID fontID = fontResources[font]->typeface()->uniqueID();
             if (seenFonts.find(fontID) == -1) {
                 counts[fontResources[font]->getType()]++;
                 seenFonts.push(fontID);
                 if (!fontResources[font]->canSubset()) {
                     notSubsettable++;
                 }
                 if (!fontResources[font]->canEmbed()) {
                     notEmbeddable++;
                 }
             }
         }
     }
     if (notSubsettableCount) {
         *notSubsettableCount = notSubsettable;
 
     }
     if (notEmbeddableCount) {
         *notEmbeddableCount = notEmbeddable;
     }
 }