pdfviewer: finish implementation of SkPdfObject.toString(), and include in debugging traces we leav…

experimental/PdfViewer/pdfparser/native/SkPdfObject.h

 #ifndef EXPERIMENTAL_PDFVIEWER_PDFPARSER_NATIVE_SKPDFOBJECT_H_
 #define EXPERIMENTAL_PDFVIEWER_PDFPARSER_NATIVE_SKPDFOBJECT_H_
 
 #include <stdint.h>
 #include <string.h>
 #include <string>
 #include "SkTDArray.h"
 #include "SkTDict.h"
 #include "SkRect.h"
 #include "SkMatrix.h"
@@ skipping 410 matching lines @@
 
     SkPdfObject* get(const unsigned char* key, size_t len) {
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
         SkASSERT(key);
         if (fObjectType != kDictionary_PdfObjectType) {
             // TODO(edisonn): report err
             return NULL;
         }
         SkPdfObject* ret = NULL;
         fMap->find((const char*)key, len, &ret);
+
+#ifdef PDF_TRACE
+        SkString _key;
+        _key.append((const char*)key, len);
+        printf("\nget(/%s) = %s\n", _key.c_str(), ret ? ret->toString(0, len + 9).c_str() : "_NOT_FOUND");
+#endif
+
         return ret;
     }
 
     const SkPdfObject* get(const SkPdfObject* key) const {
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
         SkASSERT(key->fObjectType == kName_PdfObjectType);
 
         if (key->fObjectType != kName_PdfObjectType || fObjectType != kDictionary_PdfObjectType) {
             // TODO(edisonn): report err
             return NULL;
@@ skipping 10 matching lines @@
 
     const SkPdfObject* get(const unsigned char* key, size_t len) const {
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
         SkASSERT(key);
         if (fObjectType != kDictionary_PdfObjectType) {
             // TODO(edisonn): report err
             return NULL;
         }
         SkPdfObject* ret = NULL;
         fMap->find((const char*)key, len, &ret);
+
+#ifdef PDF_TRACE
+        SkString _key;
+        _key.append((const char*)key, len);
+        printf("\nget(/%s) = %s\n", _key.c_str(), ret ? ret->toString(0, len + 9).c_str() : "_NOT_FOUND");
+#endif
+
         return ret;
     }
 
     const SkPdfObject* get(const char* key, const char* abr) const {
         const SkPdfObject* ret = get(key);
         // TODO(edisonn): / is a valid name, and it might be an abreviation, so "" should not be like NULL
         // make this distiontion in generator, and remove "" from condition
         if (ret != NULL || abr == NULL || *abr == '\0') {
             return ret;
         }
@@ skipping 338 matching lines @@
         if (!isDictionary() || hasStream()) {
             return false;
         }
 
         fStr.fBuffer = buffer;
         fStr.fBytes = (len << 2) + kUnfilteredStreamBit;
 
         return true;
     }
 
-    SkString toString() {
+    void appendSpaces(SkString* str, int level) {
+        for (int i = 0 ; i < level; i++) {
+            str->append(" ");
+        }
+    }
+
+    SkString toString(int firstRowLevel = 0, int level = 0) {
         SkString str;
+        appendSpaces(&str, firstRowLevel);
         switch (fObjectType) {
             case kInvalid_PdfObjectType:
-                str.append("Invalid");
+                str.append("__Invalid");
                 break;
 
             case kBoolean_PdfObjectType:
-                str.appendf("Boolean: %s", fBooleanValue ? "true" : "false");
+                str.appendf("%s", fBooleanValue ? "true" : "false");
                 break;
 
             case kInteger_PdfObjectType:
-                str.appendf("Integer: %i", (int)fIntegerValue);
+                str.appendf("%i", (int)fIntegerValue);
                 break;
 
             case kReal_PdfObjectType:
-                str.appendf("Real: %f", fRealValue);
+                str.appendf("%f", fRealValue);
                 break;
 
             case kString_PdfObjectType:
-                str.appendf("String, len() = %u: ", (unsigned int)fStr.fBytes);
+                str.append("\"");
                 str.append((const char*)fStr.fBuffer, fStr.fBytes);
+                str.append("\"");
                 break;
 
             case kHexString_PdfObjectType:
-                str.appendf("HexString, len() = %u: ", (unsigned int)fStr.fBytes);
+                str.append("<");
                 str.append((const char*)fStr.fBuffer, fStr.fBytes);
+                str.append(">");
                 break;
 
             case kName_PdfObjectType:
-                str.appendf("Name, len() = %u: ", (unsigned int)fStr.fBytes);
+                str.append("/");
                 str.append((const char*)fStr.fBuffer, fStr.fBytes);
                 break;
 
             case kKeyword_PdfObjectType:
-                str.appendf("Keyword, len() = %u: ", (unsigned int)fStr.fBytes);
                 str.append((const char*)fStr.fBuffer, fStr.fBytes);
                 break;
 
             case kArray_PdfObjectType:
-                str.append("Array, size() = %i [", size());
+                str.append("[\n");
                 for (unsigned int i = 0; i < size(); i++) {
-                    str.append(objAtAIndex(i)->toString());
+                    str.append(objAtAIndex(i)->toString(level + 1, level + 1));
+                    if (i < size() - 1) {
+                        str.append(",");
+                    }
+                    str.append("\n");
                 }
+                appendSpaces(&str, level);
                 str.append("]");
                 break;
 
-            case kDictionary_PdfObjectType:
-                // TODO(edisonn): NYI
-                str.append("Dictionary: NYI");
-                if (hasStream()) {
-                    str.append(" HAS_STREAM");
+            case kDictionary_PdfObjectType: {
+                    SkTDict<SkPdfObject*>::Iter iter(*fMap);
+                    SkPdfObject* obj = NULL;
+                    const char* key = NULL;
+                    str.append("<<\n");
+                    while ((key = iter.next(&obj)) != NULL) {
+                        appendSpaces(&str, level + 2);
+                        str.appendf("/%s %s\n", key, obj->toString(0, level + strlen(key) + 4).c_str());
+                    }
+                    appendSpaces(&str, level);
+                    str.append(">>");
+                    if (hasStream()) {
+                        str.append("stream HAS_STREAM endstream");
+                    }
                 }
                 break;
 
             case kNull_PdfObjectType:
                 str = "NULL";
                 break;
 
             case kReference_PdfObjectType:
-                str.appendf("Reference: %i %i", fRef.fId, fRef.fGen);
+                str.appendf("%i %i R", fRef.fId, fRef.fGen);
                 break;
 
             case kUndefined_PdfObjectType:
                 str = "Undefined";
                 break;
 
             default:
-                str = "Internal Error Object Type";
+                str = "Error";
                 break;
         }
 
         return str;
     }
 
 private:
     static void makeStringCore(const unsigned char* start, SkPdfObject* obj, ObjectType type) {
         makeStringCore(start, strlen((const char*)start), obj, type);
     }
@@ skipping 27 matching lines @@
     SkPdfName() : SkPdfObject() {
         SkPdfObject::makeName((const unsigned char*)"", this);
     }
 public:
     SkPdfName(char* name) : SkPdfObject() {
         this->makeName((const unsigned char*)name, this);
     }
 };
 
 #endif  // EXPERIMENTAL_PDFVIEWER_PDFPARSER_NATIVE_SKPDFOBJECT_H_