(upload draf code for backup) pdfviewer: improve memory, son't allocate extra buffers, and put the …

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"
 #include "SkString.h"
 
 #include "SkPdfNYI.h"
 #include "SkPdfConfig.h"
 
 class SkPdfDictionary;
 class SkPdfStream;
 class SkPdfAllocator;
 
 // TODO(edisonn): macro it and move it to utils
 SkMatrix SkMatrixFromPdfMatrix(double array[6]);
 
 
 #define kFilteredStreamBit 0
 #define kUnfilteredStreamBit 1
-
+#define kOwnedStreamBit 2
 
 class SkPdfObject {
  public:
      enum ObjectType {
          kInvalid_PdfObjectType,
 
          kBoolean_PdfObjectType,
          kInteger_PdfObjectType,
          kReal_PdfObjectType,
          kString_PdfObjectType,
          kHexString_PdfObjectType,
          kName_PdfObjectType,
          kKeyword_PdfObjectType,
          //kStream_PdfObjectType,  //  attached to a Dictionary
          kArray_PdfObjectType,
          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
      };
 
 private:
-    struct NotOwnedString {
-        unsigned char* fBuffer;
-        size_t fBytes;
-    };
-
     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,
@@ skipping 33 matching lines @@
 //    }
 
     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;
     }
 
     ObjectType type() { return fObjectType; }
 
@@ skipping 84 matching lines @@
     }
 
     static SkPdfObject makeNull() {
         SkPdfObject obj;
         obj.fObjectType = kNull_PdfObjectType;
         return obj;
     }
 
     static SkPdfObject kNull;
 
-    static void makeNumeric(unsigned char* start, unsigned char* end, SkPdfObject* obj) {
+    static void makeNumeric(const unsigned char* start, const unsigned char* end, SkPdfObject* obj) {
         SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
 
         // TODO(edisonn): NYI properly
         // if has dot (impl), or exceeds max int, is real, otherwise is int
         bool isInt = true;
-        for (unsigned char* current = start; current < end; current++) {
+        for (const unsigned char* current = start; current < end; current++) {
             if (*current == '.') {
                 isInt = false;
                 break;
             }
             // TODO(edisonn): report parse issue with numbers like "24asdasd123"
         }
         if (isInt) {
             makeInteger(atol((const char*)start), obj);
         } else {
             makeReal(atof((const char*)start), obj);
         }
     }
 
     static void makeReference(unsigned int id, unsigned int gen, SkPdfObject* obj) {
         SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
 
         obj->fObjectType = kReference_PdfObjectType;
         obj->fRef.fId = id;
         obj->fRef.fGen = gen;
     }
 
 
-    static void makeString(unsigned char* start, SkPdfObject* obj) {
+    static void makeString(const unsigned char* start, SkPdfObject* obj) {
         makeStringCore(start, strlen((const char*)start), obj, kString_PdfObjectType);
     }
 
-    static void makeString(unsigned char* start, unsigned char* end, SkPdfObject* obj) {
+    static void makeString(const unsigned char* start, const unsigned char* end, SkPdfObject* obj) {
         makeStringCore(start, end - start, obj, kString_PdfObjectType);
     }
 
-    static void makeString(unsigned char* start, size_t bytes, SkPdfObject* obj) {
+    static void makeString(const unsigned char* start, size_t bytes, SkPdfObject* obj) {
         makeStringCore(start, bytes, obj, kString_PdfObjectType);
     }
 
 
-    static void makeHexString(unsigned char* start, SkPdfObject* obj) {
+    static void makeHexString(const unsigned char* start, SkPdfObject* obj) {
         makeStringCore(start, strlen((const char*)start), obj, kHexString_PdfObjectType);
     }
 
-    static void makeHexString(unsigned char* start, unsigned char* end, SkPdfObject* obj) {
+    static void makeHexString(const unsigned char* start, const unsigned char* end, SkPdfObject* obj) {
         makeStringCore(start, end - start, obj, kHexString_PdfObjectType);
     }
 
-    static void makeHexString(unsigned char* start, size_t bytes, SkPdfObject* obj) {
+    static void makeHexString(const unsigned char* start, size_t bytes, SkPdfObject* obj) {
         makeStringCore(start, bytes, obj, kHexString_PdfObjectType);
     }
 
 
-    static void makeName(unsigned char* start, SkPdfObject* obj) {
+    static void makeName(const unsigned char* start, SkPdfObject* obj) {
         makeStringCore(start, strlen((const char*)start), obj, kName_PdfObjectType);
     }
 
-    static void makeName(unsigned char* start, unsigned char* end, SkPdfObject* obj) {
+    static void makeName(const unsigned char* start, const unsigned char* end, SkPdfObject* obj) {
         makeStringCore(start, end - start, obj, kName_PdfObjectType);
     }
 
-    static void makeName(unsigned char* start, size_t bytes, SkPdfObject* obj) {
+    static void makeName(const unsigned char* start, size_t bytes, SkPdfObject* obj) {
         makeStringCore(start, bytes, obj, kName_PdfObjectType);
     }
 
 
-    static void makeKeyword(unsigned char* start, SkPdfObject* obj) {
+    static void makeKeyword(const unsigned char* start, SkPdfObject* obj) {
         makeStringCore(start, strlen((const char*)start), obj, kKeyword_PdfObjectType);
     }
 
-    static void makeKeyword(unsigned char* start, unsigned char* end, SkPdfObject* obj) {
+    static void makeKeyword(const unsigned char* start, const unsigned char* end, SkPdfObject* obj) {
         makeStringCore(start, end - start, obj, kKeyword_PdfObjectType);
     }
 
-    static void makeKeyword(unsigned char* start, size_t bytes, SkPdfObject* obj) {
+    static void makeKeyword(const unsigned char* start, size_t bytes, SkPdfObject* obj) {
         makeStringCore(start, bytes, obj, kKeyword_PdfObjectType);
     }
 
 
 
     // TODO(edisonn): make the functions to return SkPdfArray, move these functions in SkPdfArray
     static void makeEmptyArray(SkPdfObject* obj) {
         SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
 
         obj->fObjectType = kArray_PdfObjectType;
@@ skipping 72 matching lines @@
     // TODO(edisonn): setting the same key twike, will make the value undefined!
     bool set(SkPdfObject* key, SkPdfObject* value) {
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
         SkASSERT(key->fObjectType == kName_PdfObjectType);
 
         if (key->fObjectType != kName_PdfObjectType || fObjectType != kDictionary_PdfObjectType) {
             // TODO(edisonn): report err
             return false;
         }
 
-        // we rewrite all delimiters and white spaces with '\0', so we expect the end of name to be '\0'
-        SkASSERT(key->fStr.fBuffer[key->fStr.fBytes] == '\0');
+        //// we rewrite all delimiters and white spaces with '\0', so we expect the end of name to be '\0'
+        //SkASSERT(key->fStr.fBuffer[key->fStr.fBytes] == '\0');
 
         return set(key->fStr.fBuffer, key->fStr.fBytes, value);
     }
 
     bool set(const char* key, SkPdfObject* value) {
         return set((const unsigned char*)key, strlen(key), value);
     }
 
     bool set(const unsigned char* key, size_t len, SkPdfObject* value) {
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
 
         if (fObjectType != kDictionary_PdfObjectType) {
             // TODO(edisonn): report err
             return false;
         }
 
         return fMap->set((const char*)key, len, value);
     }
 
     SkPdfObject* get(SkPdfObject* key) {
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
         SkASSERT(key->fObjectType == kName_PdfObjectType);
 
         if (key->fObjectType != kName_PdfObjectType || fObjectType != kDictionary_PdfObjectType) {
             // TODO(edisonn): report err
             return NULL;
         }
 
-        SkASSERT(key->fStr.fBuffer[key->fStr.fBytes] == '\0');
+        //SkASSERT(key->fStr.fBuffer[key->fStr.fBytes] == '\0');
 
         return get(key->fStr.fBuffer, key->fStr.fBytes);
     }
 
     SkPdfObject* get(const char* key) {
         return get((const unsigned char*)key, strlen(key));
     }
 
     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);
         return ret;
     }
 
     const SkPdfObject* get(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;
         }
 
-        SkASSERT(key->fStr.fBuffer[key->fStr.fBytes] == '\0');
+        //SkASSERT(key->fStr.fBuffer[key->fStr.fBytes] == '\0');
 
         return get(key->fStr.fBuffer, key->fStr.fBytes);
     }
 
     const SkPdfObject* get(const char* key) const {
         return get((const unsigned char*)key, strlen(key));
     }
 
     const SkPdfObject* get(const unsigned char* key, size_t len) const {
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
@@ skipping 175 matching lines @@
     inline const char* stringValue() const {
         SkASSERT(fObjectType == kString_PdfObjectType || fObjectType == kHexString_PdfObjectType);
 
         if (fObjectType != kString_PdfObjectType && fObjectType != kHexString_PdfObjectType) {
             // TODO(edisonn): log err
             return "";
         }
         return (const char*)fStr.fBuffer;
     }
 
+    inline NotOwnedString strRef() {
+        switch (fObjectType) {
+            case kString_PdfObjectType:
+            case kHexString_PdfObjectType:
+            case kKeyword_PdfObjectType:
+                return fStr;
+
+            default:
+                // TODO(edisonn): report/warning
+                return NotOwnedString();
+        }
+    }
+
     // TODO(edisonn): nameValue2 and stringValue2 are used to make code generation easy,
     // but it is not a performat way to do it, since it will create an extra copy
     // remove these functions and make code generated faster
     inline std::string nameValue2() const {
         SkASSERT(fObjectType == kName_PdfObjectType);
 
         if (fObjectType != kName_PdfObjectType) {
             // TODO(edisonn): log err
             return "";
         }
-        return (const char*)fStr.fBuffer;
+        return std::string((const char*)fStr.fBuffer, fStr.fBytes);
     }
 
     inline std::string stringValue2() const {
         SkASSERT(fObjectType == kString_PdfObjectType || fObjectType == kHexString_PdfObjectType);
 
         if (fObjectType != kString_PdfObjectType && fObjectType != kHexString_PdfObjectType) {
             // TODO(edisonn): log err
             return "";
         }
-        return (const char*)fStr.fBuffer;
+        return std::string((const char*)fStr.fBuffer, fStr.fBytes);
     }
 
     inline bool boolValue() const {
         SkASSERT(fObjectType == kBoolean_PdfObjectType);
 
         if (fObjectType == kBoolean_PdfObjectType) {
             // TODO(edisonn): log err
             return false;
         }
         return fBooleanValue;
@@ skipping 35 matching lines @@
             if (elem == NULL || !elem->isNumber()) {
                 // TODO(edisonn): report error
                 return SkMatrix::I();
             }
             array[i] = elem->numberValue();
         }
 
         return SkMatrixFromPdfMatrix(array);
     }
 
-    bool filterStream(SkPdfAllocator* allocator);
+    bool filterStream();
 
 
-    bool GetFilteredStreamRef(unsigned char** buffer, size_t* len, SkPdfAllocator* allocator) {
+    bool GetFilteredStreamRef(unsigned char const** buffer, size_t* len) {
         // TODO(edisonn): add params that couls let the last filter in place if it is jpeg or png to fast load images
         if (!hasStream()) {
             return false;
         }
 
-        filterStream(allocator);
+        filterStream();
 
         if (buffer) {
             *buffer = fStr.fBuffer;
         }
 
         if (len) {
-            *len = fStr.fBytes >> 1;  // last bit
+            *len = fStr.fBytes >> 2;  // last 2 bits
         }
 
         return true;
     }
 
     bool isStreamFiltered() const {
         return hasStream() && ((fStr.fBytes & 1) == kFilteredStreamBit);
     }
 
-    bool GetUnfilteredStreamRef(unsigned char** buffer, size_t* len) const {
+    bool isStreamOwned() const {
+        return hasStream() && ((fStr.fBytes & 2) == kOwnedStreamBit);
+    }
+
+    bool GetUnfilteredStreamRef(unsigned char const** buffer, size_t* len) const {
         if (isStreamFiltered()) {
             return false;
         }
 
         if (!hasStream()) {
             return false;
         }
 
         if (buffer) {
             *buffer = fStr.fBuffer;
         }
 
         if (len) {
-            *len = fStr.fBytes >> 1;  // remove slast bit
+            *len = fStr.fBytes >> 2;  // remove last 2 bits
         }
 
         return true;
     }
 
-    bool addStream(unsigned char* buffer, size_t len) {
+    bool addStream(const unsigned char* buffer, size_t len) {
         SkASSERT(!hasStream());
         SkASSERT(isDictionary());
 
         if (!isDictionary() || hasStream()) {
             return false;
         }
 
         fStr.fBuffer = buffer;
         fStr.fBytes = (len << 2) + kUnfilteredStreamBit;
 
@@ skipping 69 matching lines @@
 
             default:
                 str = "Internal Error Object Type";
                 break;
         }
 
         return str;
     }
 
 private:
-    static void makeStringCore(unsigned char* start, SkPdfObject* obj, ObjectType type) {
+    static void makeStringCore(const unsigned char* start, SkPdfObject* obj, ObjectType type) {
         makeStringCore(start, strlen((const char*)start), obj, type);
     }
 
-    static void makeStringCore(unsigned char* start, unsigned char* end, SkPdfObject* obj, ObjectType type) {
+    static void makeStringCore(const unsigned char* start, const unsigned char* end, SkPdfObject* obj, ObjectType type) {
         makeStringCore(start, end - start, obj, type);
     }
 
-    static void makeStringCore(unsigned char* start, size_t bytes, SkPdfObject* obj, ObjectType type) {
+    static void makeStringCore(const unsigned char* start, size_t bytes, SkPdfObject* obj, ObjectType type) {
         SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
 
         obj->fObjectType = type;
         obj->fStr.fBuffer = start;
         obj->fStr.fBytes = bytes;
     }
 
-    bool applyFilter(const char* name, SkPdfAllocator* allocator);
-    bool applyFlateDecodeFilter(SkPdfAllocator* allocator);
-    bool applyDCTDecodeFilter(SkPdfAllocator* allocator);
+    bool applyFilter(const char* name);
+    bool applyFlateDecodeFilter();
+    bool applyDCTDecodeFilter();
 };
 
 class SkPdfStream : public SkPdfObject {};
 class SkPdfArray : public SkPdfObject {};
 class SkPdfString : public SkPdfObject {};
 class SkPdfHexString : public SkPdfObject {};
 class SkPdfInteger : public SkPdfObject {};
 class SkPdfReal : public SkPdfObject {};
 class SkPdfNumber : public SkPdfObject {};
 
 class SkPdfName : public SkPdfObject {
     SkPdfName() : SkPdfObject() {
-        SkPdfObject::makeName((unsigned char*)"", this);
+        SkPdfObject::makeName((const unsigned char*)"", this);
     }
 public:
     SkPdfName(char* name) : SkPdfObject() {
-        this->makeName((unsigned char*)name, this);
+        this->makeName((const unsigned char*)name, this);
     }
 };
 
 #endif  // EXPERIMENTAL_PDFVIEWER_PDFPARSER_NATIVE_SKPDFOBJECT_H_