SkPDF: in-place font subsetting

src/pdf/SkPDFTypes.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 "SkData.h"
 #include "SkDeflate.h"
 #include "SkPDFTypes.h"
@@ skipping 95 matching lines @@
             buffer[1] = kHex[(*n >> 4) & 0xF];
             buffer[2] = kHex[*n & 0xF];
             o->write(buffer, sizeof(buffer));
         } else {
             o->write(n, 1);
         }
     }
 }
 
 void SkPDFUnion::emitObject(SkWStream* stream,
-                            const SkPDFObjNumMap& objNumMap,
-                            const SkPDFSubstituteMap& substitutes) const {
+                            const SkPDFObjNumMap& objNumMap) const {
     switch (fType) {
         case Type::kInt:
             stream->writeDecAsText(fIntValue);
             return;
         case Type::kColorComponent:
             SkPDFUtils::AppendColorComponent(SkToU8(fIntValue), stream);
             return;
         case Type::kBool:
             stream->writeText(fBoolValue ? "true" : "false");
             return;
@@ skipping 12 matching lines @@
             return;
         case Type::kNameSkS:
             stream->writeText("/");
             write_name_escaped(stream, pun(fSkString)->c_str());
             return;
         case Type::kStringSkS:
             SkPDFUtils::WriteString(stream, pun(fSkString)->c_str(),
                                     pun(fSkString)->size());
             return;
         case Type::kObjRef:
-            stream->writeDecAsText(objNumMap.getObjectNumber(
-                    substitutes.getSubstitute(fObject)));
+            stream->writeDecAsText(objNumMap.getObjectNumber(fObject));
             stream->writeText(" 0 R");  // Generation number is always 0.
             return;
         case Type::kObject:
-            fObject->emitObject(stream, objNumMap, substitutes);
+            fObject->emitObject(stream, objNumMap);
             return;
         default:
             SkDEBUGFAIL("SkPDFUnion::emitObject with bad type");
     }
 }
 
-void SkPDFUnion::addResources(SkPDFObjNumMap* objNumMap,
-                              const SkPDFSubstituteMap& substituteMap) const {
+void SkPDFUnion::addResources(SkPDFObjNumMap* objNumMap) const {
     switch (fType) {
         case Type::kInt:
         case Type::kColorComponent:
         case Type::kBool:
         case Type::kScalar:
         case Type::kName:
         case Type::kString:
         case Type::kNameSkS:
         case Type::kStringSkS:
             return;  // These have no resources.
-        case Type::kObjRef: {
-            SkPDFObject* obj = substituteMap.getSubstitute(fObject);
-            objNumMap->addObjectRecursively(obj, substituteMap);
+        case Type::kObjRef:
+            objNumMap->addObjectRecursively(fObject);
             return;
-        }
         case Type::kObject:
-            fObject->addResources(objNumMap, substituteMap);
+            fObject->addResources(objNumMap);
             return;
         default:
             SkDEBUGFAIL("SkPDFUnion::addResources with bad type");
     }
 }
 
 SkPDFUnion SkPDFUnion::Int(int32_t value) {
     SkPDFUnion u(Type::kInt);
     u.fIntValue = value;
     return u;
@@ skipping 55 matching lines @@
     SkPDFUnion u(Type::kObject);
     SkASSERT(objSp.get());
     u.fObject = objSp.release();  // take ownership into union{}
     return u;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #if 0  // Enable if needed.
 void SkPDFAtom::emitObject(SkWStream* stream,
-                           const SkPDFObjNumMap& objNumMap,
-                           const SkPDFSubstituteMap& substitutes) const {
-    fValue.emitObject(stream, objNumMap, substitutes);
+                           const SkPDFObjNumMap& objNumMap) const {
+    fValue.emitObject(stream, objNumMap);
 }
-void SkPDFAtom::addResources(SkPDFObjNumMap* map,
-                             const SkPDFSubstituteMap& substitutes) const {
-    fValue.addResources(map, substitutes);
+void SkPDFAtom::addResources(SkPDFObjNumMap* map) const {
+    fValue.addResources(map);
 }
 #endif  // 0
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFArray::SkPDFArray() { SkDEBUGCODE(fDumped = false;) }
 
 SkPDFArray::~SkPDFArray() { this->drop(); }
 
 void SkPDFArray::drop() {
     fValues.reset();
     SkDEBUGCODE(fDumped = true;)
 }
 
 int SkPDFArray::size() const { return fValues.count(); }
 
 void SkPDFArray::reserve(int length) {
     // TODO(halcanary): implement SkTArray<T>::reserve() or change the
     // contstructor of SkPDFArray to take reserve size.
 }
 
 void SkPDFArray::emitObject(SkWStream* stream,
-                            const SkPDFObjNumMap& objNumMap,
-                            const SkPDFSubstituteMap& substitutes) const {
+                            const SkPDFObjNumMap& objNumMap) const {
     SkASSERT(!fDumped);
     stream->writeText("[");
     for (int i = 0; i < fValues.count(); i++) {
-        fValues[i].emitObject(stream, objNumMap, substitutes);
+        fValues[i].emitObject(stream, objNumMap);
         if (i + 1 < fValues.count()) {
             stream->writeText(" ");
         }
     }
     stream->writeText("]");
 }
 
-void SkPDFArray::addResources(SkPDFObjNumMap* catalog,
-                              const SkPDFSubstituteMap& substitutes) const {
+void SkPDFArray::addResources(SkPDFObjNumMap* catalog) const {
     SkASSERT(!fDumped);
     for (const SkPDFUnion& value : fValues) {
-        value.addResources(catalog, substitutes);
+        value.addResources(catalog);
     }
 }
 
 void SkPDFArray::append(SkPDFUnion&& value) {
     fValues.emplace_back(std::move(value));
 }
 
 void SkPDFArray::appendInt(int32_t value) {
     this->append(SkPDFUnion::Int(value));
 }
@@ skipping 44 matching lines @@
 }
 
 SkPDFDict::SkPDFDict(const char type[]) {
     SkDEBUGCODE(fDumped = false;)
     if (type) {
         this->insertName("Type", type);
     }
 }
 
 void SkPDFDict::emitObject(SkWStream* stream,
-                           const SkPDFObjNumMap& objNumMap,
-                           const SkPDFSubstituteMap& substitutes) const {
+                           const SkPDFObjNumMap& objNumMap) const {
     stream->writeText("<<");
-    this->emitAll(stream, objNumMap, substitutes);
+    this->emitAll(stream, objNumMap);
     stream->writeText(">>");
 }
 
 void SkPDFDict::emitAll(SkWStream* stream,
-                        const SkPDFObjNumMap& objNumMap,
-                        const SkPDFSubstituteMap& substitutes) const {
+                        const SkPDFObjNumMap& objNumMap) const {
     SkASSERT(!fDumped);
     for (int i = 0; i < fRecords.count(); i++) {
-        fRecords[i].fKey.emitObject(stream, objNumMap, substitutes);
+        fRecords[i].fKey.emitObject(stream, objNumMap);
         stream->writeText(" ");
-        fRecords[i].fValue.emitObject(stream, objNumMap, substitutes);
+        fRecords[i].fValue.emitObject(stream, objNumMap);
         if (i + 1 < fRecords.count()) {
             stream->writeText("\n");
         }
     }
 }
 
-void SkPDFDict::addResources(SkPDFObjNumMap* catalog,
-                             const SkPDFSubstituteMap& substitutes) const {
+void SkPDFDict::addResources(SkPDFObjNumMap* catalog) const {
     SkASSERT(!fDumped);
     for (int i = 0; i < fRecords.count(); i++) {
-        fRecords[i].fKey.addResources(catalog, substitutes);
-        fRecords[i].fValue.addResources(catalog, substitutes);
+        fRecords[i].fKey.addResources(catalog);
+        fRecords[i].fValue.addResources(catalog);
     }
 }
 
 SkPDFDict::Record::Record(SkPDFUnion&& k, SkPDFUnion&& v)
     : fKey(std::move(k)), fValue(std::move(v)) {}
 
 int SkPDFDict::size() const { return fRecords.count(); }
 
 void SkPDFDict::insertObjRef(const char key[], sk_sp<SkPDFObject> objSp) {
     fRecords.emplace_back(SkPDFUnion::Name(key), SkPDFUnion::ObjRef(std::move(objSp)));
@@ skipping 52 matching lines @@
 SkPDFSharedStream::~SkPDFSharedStream() { this->drop(); }
 
 void SkPDFSharedStream::drop() {
     fAsset = nullptr;;
     fDict.drop();
 }
 
 #ifdef SK_PDF_LESS_COMPRESSION
 void SkPDFSharedStream::emitObject(
         SkWStream* stream,
-        const SkPDFObjNumMap& objNumMap,
-        const SkPDFSubstituteMap& substitutes) const {
+        const SkPDFObjNumMap& objNumMap) const {
     SkASSERT(fAsset);
     std::unique_ptr<SkStreamAsset> dup(fAsset->duplicate());
     SkASSERT(dup && dup->hasLength());
     size_t length = dup->getLength();
     stream->writeText("<<");
-    fDict.emitAll(stream, objNumMap, substitutes);
+    fDict.emitAll(stream, objNumMap);
     stream->writeText("\n");
-    SkPDFUnion::Name("Length").emitObject(
-            stream, objNumMap, substitutes);
+    SkPDFUnion::Name("Length").emitObject(stream, objNumMap);
     stream->writeText(" ");
-    SkPDFUnion::Int(length).emitObject(
-            stream, objNumMap, substitutes);
+    SkPDFUnion::Int(length).emitObject(stream, objNumMap);
     stream->writeText("\n>>stream\n");
     SkStreamCopy(stream, dup.get());
     stream->writeText("\nendstream");
 }
 #else
 void SkPDFSharedStream::emitObject(
         SkWStream* stream,
-        const SkPDFObjNumMap& objNumMap,
-        const SkPDFSubstituteMap& substitutes) const {
+        const SkPDFObjNumMap& objNumMap) const {
     SkASSERT(fAsset);
     SkDynamicMemoryWStream buffer;
     SkDeflateWStream deflateWStream(&buffer);
     // Since emitObject is const, this function doesn't change the dictionary.
     std::unique_ptr<SkStreamAsset> dup(fAsset->duplicate());  // Cheap copy
     SkASSERT(dup);
     SkStreamCopy(&deflateWStream, dup.get());
     deflateWStream.finalize();
     size_t length = buffer.bytesWritten();
     stream->writeText("<<");
-    fDict.emitAll(stream, objNumMap, substitutes);
+    fDict.emitAll(stream, objNumMap);
     stream->writeText("\n");
-    SkPDFUnion::Name("Length").emitObject(stream, objNumMap, substitutes);
+    SkPDFUnion::Name("Length").emitObject(stream, objNumMap);
     stream->writeText(" ");
-    SkPDFUnion::Int(length).emitObject(stream, objNumMap, substitutes);
+    SkPDFUnion::Int(length).emitObject(stream, objNumMap);
     stream->writeText("\n");
-    SkPDFUnion::Name("Filter").emitObject(stream, objNumMap, substitutes);
+    SkPDFUnion::Name("Filter").emitObject(stream, objNumMap);
     stream->writeText(" ");
-    SkPDFUnion::Name("FlateDecode").emitObject(stream, objNumMap, substitutes);
+    SkPDFUnion::Name("FlateDecode").emitObject(stream, objNumMap);
     stream->writeText(">>");
     stream->writeText(" stream\n");
     buffer.writeToStream(stream);
     stream->writeText("\nendstream");
 }
 #endif
 
 void SkPDFSharedStream::addResources(
-        SkPDFObjNumMap* catalog, const SkPDFSubstituteMap& substitutes) const {
+        SkPDFObjNumMap* catalog) const {
     SkASSERT(fAsset);
-    fDict.addResources(catalog, substitutes);
+    fDict.addResources(catalog);
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFStream:: SkPDFStream(sk_sp<SkData> data) {
     this->setData(std::unique_ptr<SkStreamAsset>(
                           new SkMemoryStream(std::move(data))));
 }
 
 SkPDFStream::SkPDFStream(std::unique_ptr<SkStreamAsset> stream) {
     this->setData(std::move(stream));
 }
 
 SkPDFStream::SkPDFStream() {}
 
 SkPDFStream::~SkPDFStream() {}
 
-void SkPDFStream::addResources(
-        SkPDFObjNumMap* catalog, const SkPDFSubstituteMap& substitutes) const {
+void SkPDFStream::addResources(SkPDFObjNumMap* catalog) const {
     SkASSERT(fCompressedData);
-    fDict.addResources(catalog, substitutes);
+    fDict.addResources(catalog);
 }
 
 void SkPDFStream::drop() {
     fCompressedData.reset(nullptr);
     fDict.drop();
 }
 
 void SkPDFStream::emitObject(SkWStream* stream,
-                             const SkPDFObjNumMap& objNumMap,
-                             const SkPDFSubstituteMap& substitutes) const {
+                             const SkPDFObjNumMap& objNumMap) const {
     SkASSERT(fCompressedData);
-    fDict.emitObject(stream, objNumMap, substitutes);
+    fDict.emitObject(stream, objNumMap);
     // duplicate (a cheap operation) preserves const on fCompressedData.
     std::unique_ptr<SkStreamAsset> dup(fCompressedData->duplicate());
     SkASSERT(dup);
     SkASSERT(dup->hasLength());
     stream->writeText(" stream\n");
     stream->writeStream(dup.get(), dup->getLength());
     stream->writeText("\nendstream");
 }
 
 void SkPDFStream::setData(std::unique_ptr<SkStreamAsset> stream) {
@@ skipping 24 matching lines @@
         return;
     }
     fCompressedData.reset(compressedData.detachAsStream());
     fDict.insertName("Filter", "FlateDecode");
     fDict.insertInt("Length", compressedLength);
     #endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-SkPDFSubstituteMap::~SkPDFSubstituteMap() {
-    fSubstituteMap.foreach(
-            [](SkPDFObject*, SkPDFObject** v) { (*v)->unref(); });
-}
-
-void SkPDFSubstituteMap::setSubstitute(SkPDFObject* original,
-                                       SkPDFObject* substitute) {
-    SkASSERT(original != substitute);
-    SkASSERT(!fSubstituteMap.find(original));
-    fSubstituteMap.set(original, SkRef(substitute));
-}
-
-SkPDFObject* SkPDFSubstituteMap::getSubstitute(SkPDFObject* object) const {
-    SkPDFObject** found = fSubstituteMap.find(object);
-    return found ? *found : object;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
 bool SkPDFObjNumMap::addObject(SkPDFObject* obj) {
     if (fObjectNumbers.find(obj)) {
         return false;
     }
     fObjectNumbers.set(obj, fObjectNumbers.count() + 1);
     fObjects.emplace_back(sk_ref_sp(obj));
     return true;
 }
 
-void SkPDFObjNumMap::addObjectRecursively(SkPDFObject* obj,
-                                          const SkPDFSubstituteMap& subs) {
+void SkPDFObjNumMap::addObjectRecursively(SkPDFObject* obj) {
     if (obj && this->addObject(obj)) {
-        obj->addResources(this, subs);
+        obj->addResources(this);
     }
 }
 
 int32_t SkPDFObjNumMap::getObjectNumber(SkPDFObject* obj) const {
     int32_t* objectNumberFound = fObjectNumbers.find(obj);
     SkASSERT(objectNumberFound);
     return *objectNumberFound;
 }
 
 #ifdef SK_PDF_IMAGE_STATS
 SkAtomic<int> gDrawImageCalls(0);
 SkAtomic<int> gJpegImageObjects(0);
 SkAtomic<int> gRegularImageObjects(0);
 
 void SkPDFImageDumpStats() {
     SkDebugf("\ntotal PDF drawImage/drawBitmap calls: %d\n"
              "total PDF jpeg images: %d\n"
              "total PDF regular images: %d\n",
              gDrawImageCalls.load(),
              gJpegImageObjects.load(),
              gRegularImageObjects.load());
 }
 #endif // SK_PDF_IMAGE_STATS