SkPDF: Factor SkPDFCatalog into SkPDFObjNumMap and SkPDFSubstituteMap

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 "SkPDFCatalog.h"
 #include "SkPDFTypes.h"
 #include "SkStream.h"
 
 #ifdef SK_BUILD_FOR_WIN
     #define SNPRINTF    _snprintf
 #else
     #define SNPRINTF    snprintf
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFObjRef::SkPDFObjRef(SkPDFObject* obj) : fObj(obj) {
     SkSafeRef(obj);
 }
 
 SkPDFObjRef::~SkPDFObjRef() {}
 
-void SkPDFObjRef::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
-    SkPDFObject* obj = catalog->getSubstituteObject(fObj);
-    stream->writeDecAsText(catalog->getObjectNumber(obj));
+void SkPDFObjRef::emitObject(SkWStream* stream,
+                             const SkPDFObjNumMap& objNumMap,
+                             const SkPDFSubstituteMap& substitutes) {
+    SkPDFObject* obj = substitutes.getSubstitute(fObj);
+    stream->writeDecAsText(objNumMap.getObjectNumber(obj));
     stream->writeText(" 0 R");  // Generation number is always 0.
 }
 
-void SkPDFObjRef::addResources(SkPDFCatalog* catalog) const {
-    SkPDFObject* obj = catalog->getSubstituteObject(fObj);
+void SkPDFObjRef::addResources(SkPDFObjNumMap* catalog,
+                               const SkPDFSubstituteMap& substitutes) const {
+    SkPDFObject* obj = substitutes.getSubstitute(fObj);
     SkASSERT(obj);
     if (catalog->addObject(obj)) {
-        obj->addResources(catalog);
+        obj->addResources(catalog, substitutes);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFInt::SkPDFInt(int32_t value) : fValue(value) {}
 SkPDFInt::~SkPDFInt() {}
 
-void SkPDFInt::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
+void SkPDFInt::emitObject(SkWStream* stream,
+                          const SkPDFObjNumMap&,
+                          const SkPDFSubstituteMap&) {
     stream->writeDecAsText(fValue);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFBool::SkPDFBool(bool value) : fValue(value) {}
 SkPDFBool::~SkPDFBool() {}
 
-void SkPDFBool::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
-    if (fValue) {
-        stream->writeText("true");
-    } else {
-        stream->writeText("false");
-    }
+void SkPDFBool::emitObject(SkWStream* stream,
+                          const SkPDFObjNumMap&,
+                          const SkPDFSubstituteMap&) {
+    stream->writeText(fValue ? "true" : "false");
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFScalar::SkPDFScalar(SkScalar value) : fValue(value) {}
 SkPDFScalar::~SkPDFScalar() {}
 
-void SkPDFScalar::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
-    Append(fValue, stream);
+void SkPDFScalar::emitObject(SkWStream* stream,
+                             const SkPDFObjNumMap&,
+                             const SkPDFSubstituteMap&) {
+    SkPDFScalar::Append(fValue, stream);
 }
 
 // static
 void SkPDFScalar::Append(SkScalar value, SkWStream* stream) {
     // The range of reals in PDF/A is the same as SkFixed: +/- 32,767 and
     // +/- 1/65,536 (though integers can range from 2^31 - 1 to -2^31).
     // When using floats that are outside the whole value range, we can use
     // integers instead.
 
 #if !defined(SK_ALLOW_LARGE_PDF_SCALARS)
@@ skipping 47 matching lines @@
 SkPDFString::SkPDFString(const SkString& value)
     : fValue(FormatString(value.c_str(), value.size())) {
 }
 
 SkPDFString::SkPDFString(const uint16_t* value, size_t len, bool wideChars)
     : fValue(FormatString(value, len, wideChars)) {
 }
 
 SkPDFString::~SkPDFString() {}
 
-void SkPDFString::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
+void SkPDFString::emitObject(SkWStream* stream,
+                             const SkPDFObjNumMap&,
+                             const SkPDFSubstituteMap&) {
     stream->write(fValue.c_str(), fValue.size());
 }
 
 // static
 SkString SkPDFString::FormatString(const char* input, size_t len) {
     return DoFormatString(input, len, false, false);
 }
 
 SkString SkPDFString::FormatString(const uint16_t* input, size_t len,
                                    bool wideChars) {
@@ skipping 58 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFName::SkPDFName(const char name[]) : fValue(FormatName(SkString(name))) {}
 SkPDFName::SkPDFName(const SkString& name) : fValue(FormatName(name)) {}
 SkPDFName::~SkPDFName() {}
 
 bool SkPDFName::operator==(const SkPDFName& b) const {
     return fValue == b.fValue;
 }
 
-void SkPDFName::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
+void SkPDFName::emitObject(SkWStream* stream,
+                             const SkPDFObjNumMap&,
+                             const SkPDFSubstituteMap&) {
     stream->write(fValue.c_str(), fValue.size());
 }
 
 // static
 SkString SkPDFName::FormatName(const SkString& input) {
     SkASSERT(input.size() <= kMaxLen);
     // TODO(vandebo) If more escaping is needed, improve the linear scan.
     static const char escaped[] = "#/%()<>[]{}";
 
     SkString result("/");
@@ skipping 10 matching lines @@
     return result;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFArray::SkPDFArray() {}
 SkPDFArray::~SkPDFArray() {
     fValue.unrefAll();
 }
 
-void SkPDFArray::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
+void SkPDFArray::emitObject(SkWStream* stream,
+                             const SkPDFObjNumMap& objNumMap,
+                             const SkPDFSubstituteMap& substitutes) {
     stream->writeText("[");
     for (int i = 0; i < fValue.count(); i++) {
-        catalog->getSubstituteObject(fValue[i])->emitObject(stream, catalog);
+        SkASSERT(substitutes.getSubstitute(fValue[i]) == fValue[i]);
+        fValue[i]->emitObject(stream, objNumMap, substitutes);
         if (i + 1 < fValue.count()) {
             stream->writeText(" ");
         }
     }
     stream->writeText("]");
 }
 
-void SkPDFArray::addResources(SkPDFCatalog* catalog) const {
+void SkPDFArray::addResources(SkPDFObjNumMap* catalog,
+                              const SkPDFSubstituteMap& substitutes) const {
     for (int i = 0; i < fValue.count(); i++) {
-        catalog->getSubstituteObject(fValue[i])->addResources(catalog);
+        SkASSERT(substitutes.getSubstitute(fValue[i]) == fValue[i]);
+        fValue[i]->addResources(catalog, substitutes);
     }
 }
 
 void SkPDFArray::reserve(int length) {
     SkASSERT(length <= kMaxLen);
     fValue.setReserve(length);
 }
 
 SkPDFObject* SkPDFArray::setAt(int offset, SkPDFObject* value) {
     SkASSERT(offset < fValue.count());
@@ skipping 34 matching lines @@
 }
 
 SkPDFDict::~SkPDFDict() {
     clear();
 }
 
 int SkPDFDict::size() const {
     return fValue.count();
 }
 
-void SkPDFDict::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
+void SkPDFDict::emitObject(SkWStream* stream,
+                           const SkPDFObjNumMap& objNumMap,
+                           const SkPDFSubstituteMap& substitutes) {
     stream->writeText("<<");
     for (int i = 0; i < fValue.count(); i++) {
         SkASSERT(fValue[i].key);
         SkASSERT(fValue[i].value);
-        fValue[i].key->emitObject(stream, catalog);
+        SkASSERT(substitutes.getSubstitute(fValue[i].key) == fValue[i].key);
+        SkASSERT(substitutes.getSubstitute(fValue[i].value) == fValue[i].value);
+        fValue[i].key->emitObject(stream, objNumMap, substitutes);
         stream->writeText(" ");
-        catalog->getSubstituteObject(fValue[i].value)
-                ->emitObject(stream, catalog);
-        stream->writeText("\n");
+        fValue[i].value->emitObject(stream, objNumMap, substitutes);
+        if (i + 1 < fValue.count()) {
+            stream->writeText("\n");
+        }
     }
     stream->writeText(">>");
 }
 
-void SkPDFDict::addResources(SkPDFCatalog* catalog) const {
+void SkPDFDict::addResources(SkPDFObjNumMap* catalog,
+                             const SkPDFSubstituteMap& substitutes) const {
     for (int i = 0; i < fValue.count(); i++) {
         SkASSERT(fValue[i].key);
         SkASSERT(fValue[i].value);
-        fValue[i].key->addResources(catalog);
-        catalog->getSubstituteObject(fValue[i].value)->addResources(catalog);
+        fValue[i].key->addResources(catalog, substitutes);
+        SkASSERT(substitutes.getSubstitute(fValue[i].value) == fValue[i].value);
+        fValue[i].value->addResources(catalog, substitutes);
     }
 }
 
 SkPDFObject*  SkPDFDict::append(SkPDFName* key, SkPDFObject* value) {
     SkASSERT(key);
     SkASSERT(value);
     *(fValue.append()) = Rec(key, value);
     return value;
 }
 
@@ skipping 41 matching lines @@
         }
     }
 }
 
 void SkPDFDict::mergeFrom(const SkPDFDict& other) {
     for (int i = 0; i < other.fValue.count(); i++) {
         *(fValue.append()) =
                 Rec(SkRef(other.fValue[i].key), SkRef(other.fValue[i].value));
     }
 }
+
+////////////////////////////////////////////////////////////////////////////////
+
+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.push(obj);
+    return true;
+}
+
+int32_t SkPDFObjNumMap::getObjectNumber(SkPDFObject* obj) const {
+    int32_t* objectNumberFound = fObjectNumbers.find(obj);
+    SkASSERT(objectNumberFound);
+    return *objectNumberFound;
+}
+