SkPDF: in-place font subsetting

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"
 #include "SkPDFDocument.h"
 #include "SkPDFUtils.h"
 #include "SkStream.h"
 
 SkPDFObjectSerializer::SkPDFObjectSerializer() : fBaseOffset(0), fNextToBeSerialized(0) {}
 
 template <class T> static void renew(T* t) { t->~T(); new (t) T; }
 
 SkPDFObjectSerializer::~SkPDFObjectSerializer() {
     for (int i = 0; i < fObjNumMap.objects().count(); ++i) {
         fObjNumMap.objects()[i]->drop();
     }
 }
 
 void SkPDFObjectSerializer::addObjectRecursively(const sk_sp<SkPDFObject>& object) {
-    fObjNumMap.addObjectRecursively(object.get(), fSubstituteMap);
+    fObjNumMap.addObjectRecursively(object.get());
 }
 
 #define SKPDF_MAGIC "\xD3\xEB\xE9\xE1"
 #ifndef SK_BUILD_FOR_WIN32
 static_assert((SKPDF_MAGIC[0] & 0x7F) == "Skia"[0], "");
 static_assert((SKPDF_MAGIC[1] & 0x7F) == "Skia"[1], "");
 static_assert((SKPDF_MAGIC[2] & 0x7F) == "Skia"[2], "");
 static_assert((SKPDF_MAGIC[3] & 0x7F) == "Skia"[3], "");
 #endif
 void SkPDFObjectSerializer::serializeHeader(SkWStream* wStream,
@@ skipping 14 matching lines @@
 void SkPDFObjectSerializer::serializeObjects(SkWStream* wStream) {
     const SkTArray<sk_sp<SkPDFObject>>& objects = fObjNumMap.objects();
     while (fNextToBeSerialized < objects.count()) {
         SkPDFObject* object = objects[fNextToBeSerialized].get();
         int32_t index = fNextToBeSerialized + 1;  // Skip object 0.
         // "The first entry in the [XREF] table (object number 0) is
         // always free and has a generation number of 65,535; it is
         // the head of the linked list of free objects."
         SkASSERT(fOffsets.count() == fNextToBeSerialized);
         fOffsets.push(this->offset(wStream));
-        SkASSERT(object == fSubstituteMap.getSubstitute(object));
         wStream->writeDecAsText(index);
         wStream->writeText(" 0 obj\n");  // Generation number is always 0.
-        object->emitObject(wStream, fObjNumMap, fSubstituteMap);
+        object->emitObject(wStream, fObjNumMap);
         wStream->writeText("\nendobj\n");
         object->drop();
         ++fNextToBeSerialized;
     }
 }
 
 // Xref table and footer
 void SkPDFObjectSerializer::serializeFooter(SkWStream* wStream,
                                             const sk_sp<SkPDFObject> docCatalog,
                                             sk_sp<SkPDFObject> id) {
@@ skipping 11 matching lines @@
     SkPDFDict trailerDict;
     trailerDict.insertInt("Size", objCount);
     SkASSERT(docCatalog);
     trailerDict.insertObjRef("Root", docCatalog);
     SkASSERT(fInfoDict);
     trailerDict.insertObjRef("Info", std::move(fInfoDict));
     if (id) {
         trailerDict.insertObject("ID", std::move(id));
     }
     wStream->writeText("trailer\n");
-    trailerDict.emitObject(wStream, fObjNumMap, fSubstituteMap);
+    trailerDict.emitObject(wStream, fObjNumMap);
     wStream->writeText("\nstartxref\n");
     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);
 }
@@ skipping 132 matching lines @@
     }
     auto contentObject = sk_make_sp<SkPDFStream>(fPageDevice->content());
     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() {
+    this->reset();
+}
+
+void SkPDFDocument::reset() {
     fCanvas.reset(nullptr);
     fPages.reset();
     fCanon.reset();
     renew(&fObjectSerializer);
-    renew(&fGlyphUsage);
+    fFonts.reset();
 }
 
 #ifdef SK_SUPPORT_LEGACY_DOCUMENT_API
 void SkPDFDocument::setMetadata(const SkDocument::Attribute info[],
                                 int infoCount,
                                 const SkTime::DateTime* creationDate,
                                 const SkTime::DateTime* modifiedDate) {
     for (int i = 0; i < infoCount; ++i) {
         const SkDocument::Attribute& kv = info[i];
         SkPDFMetadata::SetMetadataByKey(kv.fKey, kv.fValue, &fMetadata);
@@ skipping 148 matching lines @@
     outputIntent->insertObjRef("DestOutputProfile",
                                make_srgb_color_profile());
     auto intentArray = sk_make_sp<SkPDFArray>();
     intentArray->appendObject(std::move(outputIntent));
     return intentArray;
 }
 
 bool SkPDFDocument::onClose(SkWStream* stream) {
     SkASSERT(!fCanvas.get());
     if (fPages.empty()) {
-        fPages.reset();
-        fCanon.reset();
-        renew(&fObjectSerializer);
-        renew(&fGlyphUsage);
+        this->reset();
         return false;
     }
     auto docCatalog = sk_make_sp<SkPDFDict>("Catalog");
     if (fPDFA) {
         SkASSERT(fXMP);
         docCatalog->insertObjRef("Metadata", fXMP);
         // Don't specify OutputIntents if we are not in PDF/A mode since
         // no one has ever asked for this feature.
         docCatalog->insertObject("OutputIntents", make_srgb_output_intents());
     }
     SkASSERT(!fPages.empty());
     docCatalog->insertObjRef("Pages", generate_page_tree(&fPages));
     SkASSERT(fPages.empty());
 
     if (fDests->size() > 0) {
         docCatalog->insertObjRef("Dests", std::move(fDests));
     }
 
     // Build font subsetting info before calling addObjectRecursively().
-    for (const auto& entry : fGlyphUsage) {
-        sk_sp<SkPDFObject> subsetFont =
-            entry.fFont->getFontSubset(&fCanon, &entry.fGlyphSet);
-        if (subsetFont) {
-            fObjectSerializer.fSubstituteMap.setSubstitute(
-                    entry.fFont, subsetFont.get());
-        }
-    }
-
+    SkPDFCanon* canon = &fCanon;
+    fFonts.foreach([canon](SkPDFFont* p){ p->getFontSubset(canon); });
     fObjectSerializer.addObjectRecursively(docCatalog);
     fObjectSerializer.serializeObjects(this->getStream());
     fObjectSerializer.serializeFooter(this->getStream(), docCatalog, fID);
-    fCanon.reset();
-    renew(&fObjectSerializer);
-    renew(&fGlyphUsage);
+    this->reset();
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 sk_sp<SkDocument> SkPDFMakeDocument(SkWStream* stream,
                                     void (*proc)(SkWStream*, bool),
                                     SkScalar dpi,
                                     const SkDocument::PDFMetadata& metadata,
                                     sk_sp<SkPixelSerializer> jpeg,
@@ skipping 14 matching lines @@
 }
 
 sk_sp<SkDocument> SkDocument::MakePDF(SkWStream* stream,
                                       SkScalar dpi,
                                       const SkDocument::PDFMetadata& metadata,
                                       sk_sp<SkPixelSerializer> jpegEncoder,
                                       bool pdfa) {
     return SkPDFMakeDocument(stream, nullptr, dpi, metadata,
                              std::move(jpegEncoder), pdfa);
 }