pdfviewer: add indexed rbg image support, enhanche caching(setData) for SkPdfObject

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 31 matching lines @@
          kDictionary_PdfObjectType,
          kNull_PdfObjectType,
 
          // TODO(edisonn): after the pdf has been loaded completely, resolve all references
          // try the same thing with delayed loaded ...
          kReference_PdfObjectType,
 
          kUndefined_PdfObjectType,  // per 1.4 spec, if the same key appear twice in the dictionary, the value is undefined
      };
 
+     enum DataType {
+         kEmpty_Data,
+         kFont_Data,
+         kBitmap_Data,
+     };
+
 private:
     struct Reference {
         unsigned int fId;
         unsigned int fGen;
     };
 
     // TODO(edisonn): add stream start, stream end, where stream is weither the file
     // or decoded/filtered pdf stream
 
     // TODO(edisonn): add warning/report per object
     // TODO(edisonn): add flag fUsed, to be used once the parsing is complete,
     // so we could show what parts have been proccessed, ignored, or generated errors
 
     ObjectType fObjectType;
 
     union {
         bool fBooleanValue;
         int64_t fIntegerValue;
         // TODO(edisonn): double, float? typedefed
         double fRealValue;
         NotOwnedString fStr;
 
         // TODO(edisonn): make sure the foorprint of fArray and fMap is small, otherwise, use pointers, or classes with up to 8 bytes in footprint
         SkTDArray<SkPdfObject*>* fArray;
         Reference fRef;
     };
     SkTDict<SkPdfObject*>* fMap;
+
+    // TODO(edisonn): rename data with cache
     void* fData;
+    DataType fDataType;
 
 
 public:
 
-    SkPdfObject() : fObjectType(kInvalid_PdfObjectType), fMap(NULL), fData(NULL) {}
+    SkPdfObject() : fObjectType(kInvalid_PdfObjectType), fMap(NULL), fData(NULL), fDataType(kEmpty_Data) {}
 
-    inline void* data() {
-        return fData;
+
+    inline bool hasData(DataType type) {
+        return type == fDataType;
     }
 
-    inline void setData(void* data) {
+    inline void* data(DataType type) {
+        return type == fDataType ? fData : NULL;
+    }
+
+    inline void setData(void* data, DataType type) {
+        releaseData();
+        fDataType = type;
         fData = data;
     }
 
+    void releaseData();
+
 //    ~SkPdfObject() {
 //        //reset();  must be called manually!
 //    }
 
     void reset() {
         switch (fObjectType) {
             case kArray_PdfObjectType:
                 delete fArray;
                 break;
 
             case kDictionary_PdfObjectType:
                 delete fMap;
                 if (isStreamOwned()) {
                     delete[] fStr.fBuffer;
                     fStr.fBuffer = NULL;
                     fStr.fBytes = 0;
                 }
                 break;
 
             default:
                 break;
         }
         fObjectType = kInvalid_PdfObjectType;
+        releaseData();
     }
 
     ObjectType type() { return fObjectType; }
 
     const char* c_str() const {
         switch (fObjectType) {
             case kString_PdfObjectType:
             case kHexString_PdfObjectType:
             case kKeyword_PdfObjectType:
             case kName_PdfObjectType:
@@ skipping 470 matching lines @@
     }
 
     SkPdfStream* getStream() {
         return hasStream() ? (SkPdfStream*)this : NULL;
     }
 
     bool isAnyString() const {
         return fObjectType == kString_PdfObjectType || fObjectType == kHexString_PdfObjectType;
     }
 
+    bool isHexString() const {
+        return fObjectType == kHexString_PdfObjectType;
+    }
+
     bool isMatrix() const {
         return fObjectType == kArray_PdfObjectType && fArray->count() == 6; // NYI + and elems are numbers
     }
 
     inline int64_t intValue() const {
         SkASSERT(fObjectType == kInteger_PdfObjectType);
 
         if (fObjectType != kInteger_PdfObjectType) {
             // TODO(edisonn): log err
             return 0;
@@ skipping 243 matching lines @@
                 break;
 
             case kString_PdfObjectType:
                 str.append("\"");
                 str.append((const char*)fStr.fBuffer, fStr.fBytes);
                 str.append("\"");
                 break;
 
             case kHexString_PdfObjectType:
                 str.append("<");
-                str.append((const char*)fStr.fBuffer, fStr.fBytes);
+                for (unsigned int i = 0 ; i < fStr.fBytes; i++) {
+                    str.appendf("%02x", (unsigned int)fStr.fBuffer[i]);
+                }
                 str.append(">");
                 break;
 
             case kName_PdfObjectType:
                 str.append("/");
                 str.append((const char*)fStr.fBuffer, fStr.fBytes);
                 break;
 
             case kKeyword_PdfObjectType:
                 str.append((const char*)fStr.fBuffer, fStr.fBytes);
@@ skipping 20 matching lines @@
                     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()) {
                         const unsigned char* stream = NULL;
                         size_t length = 0;
                         if (GetFilteredStreamRef(&stream, &length)) {
-                            str.append("stream");
+                            str.append("stream\n");
                             str.append((const char*)stream, length > 256 ? 256 : length);
-                            str.append("endstream");
+                            str.append("\nendstream");
                         } else {
                             str.append("stream STREAM_ERROR endstream");
                         }
                     }
                 }
                 break;
 
             case kNull_PdfObjectType:
                 str = "NULL";
                 break;
@@ skipping 48 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_