Add SkPDFResourceDict class, refactor existing code

src/pdf/SkPDFResourceDict.cpp

+

[vandebo (ex-Chrome), 2013/07/10 18:24:31]

Extra line

[ducky, 2013/07/10 22:54:34]

Done.

+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkPDFResourceDict.h"
+#include "SkPostConfig.h"
+
+SK_DEFINE_INST_COUNT(SkPDFResourceDict)
+
+SkPDFResourceDict::SkPDFResourceDict(bool createProcSets) : SkPDFDict() {
+    if (createProcSets) {
+        const char procs[][7] = {"PDF", "Text", "ImageB", "ImageC", "ImageI"};
+        SkPDFArray* procSets = SkNEW(SkPDFArray());
+
+        procSets->reserve(SK_ARRAY_COUNT(procs));
+        for (size_t i = 0; i < SK_ARRAY_COUNT(procs); i++) {
+            procSets->appendName(procs[i]);
+        }
+
+        insert("ProcSets", procSets)->unref();
+    }
+}
+
+const char* SkPDFResourceDict::getResourceTypePrefix(SkPDFResourceType type) {
+    switch (type) {
+        case kExtGState_ResourceType:

[vandebo (ex-Chrome), 2013/07/10 18:24:31]

Instead of this verbose switch statement, use compile asserts to ensure that the
enums have particular values and then use an array of chars in this case and and
an array of c-strings for the getResourceTypeName method.

[ducky, 2013/07/10 22:54:34]

Done.

+            return "G";
+            break;
+        case kColorSpace_ResourceType:
+            SkASSERT(false);    // not currently used, no definition exists
+            break;
+        case kPattern_ResourceType:
+            return "P";
+            break;
+        case kShading_ResourceType:
+            SkASSERT(false);    // not currently used, no definition exists
+            break;
+        case kXObject_ResourceType:
+            return "X";
+            break;
+        case kFont_ResourceType:
+            return "F";
+            break;
+        case kProperties_ResourceType:
+            SkASSERT(false);    // not currently used, no definition exists
+            break;
+        default:
+            SkASSERT(false);
+    }
+    SkASSERT(false);
+    return NULL;
+}
+
+const char* SkPDFResourceDict::getResourceTypeName(SkPDFResourceType type) {
+    switch (type) {
+        case kExtGState_ResourceType:
+            return "ExtGState";
+            break;
+        case kColorSpace_ResourceType:
+            return "ColorSpace";
+            break;
+        case kPattern_ResourceType:
+            return "Pattern";
+            break;
+        case kShading_ResourceType:
+            return "Shading";
+            break;
+        case kXObject_ResourceType:
+            return "XObject";
+            break;
+        case kFont_ResourceType:
+            return "Font";
+            break;
+        case kProperties_ResourceType:
+            return "Properties";
+            break;
+        default:
+            SkASSERT(false);
+    }
+    SkASSERT(false);
+    return NULL;
+}
+
+SkPDFObject* SkPDFResourceDict::insertResource(
+        SkPDFResourceType type, int key, SkPDFObject* value) {
+    SkPDFName* typeName = SkNEW_ARGS(SkPDFName, (getResourceTypeName(type)));
+    SkPDFDict* typeDict = getResourceTypeDict(typeName);
+
+    SkString keyString(getResourceTypePrefix(type));
+    keyString.appendS32(key);
+    SkPDFName* keyName = SkNEW_ARGS(SkPDFName, (keyString));
+    typeDict->insert(keyName, value);
+    return value;
+}
+
+SkPDFObject* SkPDFResourceDict::insertResourceAsRef(
+        SkPDFResourceType type, int key, SkPDFObject* value) {
+    SkAutoTUnref<SkPDFObjRef> ref(SkNEW_ARGS(SkPDFObjRef, (value)));
+    insertResource(type, key, ref);
+    fResources.add(value);
+
+    return value;
+}
+
+void SkPDFResourceDict::getResources(
+        const SkTSet<SkPDFObject*>& knownResourceObjects,
+        SkTSet<SkPDFObject*>* newResourceObjects,
+        bool recursive) const {
+    // TODO: reserve not correct if we need to recursively explore.
+    newResourceObjects->setReserve(newResourceObjects->count() +
+                                   fResources.count());
+
+    for (int i = 0; i < fResources.count(); i++) {
+        if (!knownResourceObjects.contains(fResources[i]) &&
+                !newResourceObjects->contains(fResources[i])) {
+            newResourceObjects->add(fResources[i]);
+            fResources[i]->ref();
+            if (recursive) {
+                fResources[i]->getResources(knownResourceObjects,
+                                            newResourceObjects);
+            }
+        }
+    }
+}
+
+SkPDFDict* SkPDFResourceDict::getResourceTypeDict(SkPDFName* type) {
+    for (int i = 0; i < fTypes.count(); i++) {
+        if (*(fTypes[i].key) == *type) {

[vandebo (ex-Chrome), 2013/07/10 18:24:31]

Instead of doing a string comparison for every insert, why not just store
pointers to the internal dicts in an array indexed by type?

[ducky, 2013/07/10 22:54:34]

Done. Good point.

+            return fTypes[i].value;
+        }
+    }
+
+    // If not found, create a new record.
+    struct DictRec* newEntry = fTypes.append();
+    newEntry->key = type;
+    SkAutoTUnref<SkPDFDict> newDict(SkNEW(SkPDFDict()));
+    newEntry->value = newDict;
+    insert(type, newDict);  // ref counting handled in SkPDFDict::insert
+    return newDict.get();
+}