pdfviewer: more load references dinamically plumming

experimental/PdfViewer/pdfparser/native/SkNativeParsedPDF.cpp

 #include "SkNativeParsedPDF.h"
 #include "SkPdfNativeTokenizer.h"
 #include "SkPdfBasics.h"
 #include "SkPdfObject.h"
 
 #include <stdio.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
@@ skipping 110 matching lines @@
     delete fAllocator;
 }
 
 unsigned char* SkNativeParsedPDF::readCrossReferenceSection(unsigned char* xrefStart, unsigned char* trailerEnd) {
     unsigned char* current = ignoreLine(xrefStart, trailerEnd);  // TODO(edisonn): verify next keyord is "xref", use nextObject here
 
     SkPdfObject token;
     while (current < trailerEnd) {
         token.reset();
         unsigned char* previous = current;
-        current = nextObject(current, trailerEnd, &token, NULL);
+        current = nextObject(current, trailerEnd, &token, NULL, NULL);
         if (!token.isInteger()) {
             return previous;
         }
 
         int startId = (int)token.intValue();
         token.reset();
-        current = nextObject(current, trailerEnd, &token, NULL);
+        current = nextObject(current, trailerEnd, &token, NULL, NULL);
 
         if (!token.isInteger()) {
             // TODO(edisonn): report/warning
             return current;
         }
 
         int entries = (int)token.intValue();
 
         for (int i = 0; i < entries; i++) {
             token.reset();
-            current = nextObject(current, trailerEnd, &token, NULL);
+            current = nextObject(current, trailerEnd, &token, NULL, NULL);
             if (!token.isInteger()) {
                 // TODO(edisonn): report/warning
                 return current;
             }
             int offset = (int)token.intValue();
 
             token.reset();
-            current = nextObject(current, trailerEnd, &token, NULL);
+            current = nextObject(current, trailerEnd, &token, NULL, NULL);
             if (!token.isInteger()) {
                 // TODO(edisonn): report/warning
                 return current;
             }
             int generation = (int)token.intValue();
 
             token.reset();
-            current = nextObject(current, trailerEnd, &token, NULL);
+            current = nextObject(current, trailerEnd, &token, NULL, NULL);
             if (!token.isKeyword() || token.len() != 1 || (*token.c_str() != 'f' && *token.c_str() != 'n')) {
                 // TODO(edisonn): report/warning
                 return current;
             }
 
             addCrossSectionInfo(startId + i, generation, offset, *token.c_str() == 'f');
         }
     }
     // TODO(edisonn): it should never get here? there is no trailer?
     return current;
 }
 
 long SkNativeParsedPDF::readTrailer(unsigned char* trailerStart, unsigned char* trailerEnd, bool storeCatalog) {
     unsigned char* current = ignoreLine(trailerStart, trailerEnd);  // TODO(edisonn): verify next keyord is "trailer" use nextObject here
 
     SkPdfObject token;
-    current = nextObject(current, trailerEnd, &token, fAllocator);
+    current = nextObject(current, trailerEnd, &token, fAllocator, NULL);
     if (!token.isDictionary()) {
         return -1;
     }
     SkPdfFileTrailerDictionary* trailer = (SkPdfFileTrailerDictionary*)&token;
     if (!trailer->valid()) {
         return -1;
     }
 
     if (storeCatalog) {
         const SkPdfObject* ref = trailer->Root(NULL);
@@ skipping 14 matching lines @@
 void SkNativeParsedPDF::addCrossSectionInfo(int id, int generation, int offset, bool isFreed) {
     // TODO(edisonn): security here
     while (fObjects.count() < id + 1) {
         reset(fObjects.append());
     }
 
     fObjects[id].fOffset = offset;
     fObjects[id].fObj = NULL;
 }
 
-SkPdfObject* SkNativeParsedPDF::readObject(int id/*, int expectedGeneration*/) const {
+SkPdfObject* SkNativeParsedPDF::readObject(int id/*, int expectedGeneration*/) {
     long startOffset = fObjects[id].fOffset;
     //long endOffset = fObjects[id].fOffsetEnd;
     // TODO(edisonn): use hinted endOffset
     // TODO(edisonn): current implementation will result in a lot of memory usage
     // to decrease memory usage, we wither need to be smart and know where objects end, and we will
     // alocate only the chancks needed, or the tokenizer will not make copies, but then it needs to
     // cache the results so it does not go twice on the same buffer
     unsigned char* current = fFileContent + startOffset;
     unsigned char* end = fFileContent + fContentLength;
 
-    SkPdfNativeTokenizer tokenizer(current, end - current, fMapper, fAllocator);
+    SkPdfNativeTokenizer tokenizer(current, end - current, fMapper, fAllocator, this);
 
     SkPdfObject idObj;
     SkPdfObject generationObj;
     SkPdfObject objKeyword;
     SkPdfObject* dict = fAllocator->allocObject();
 
-    current = nextObject(current, end, &idObj, NULL);
+    current = nextObject(current, end, &idObj, NULL, NULL);
     if (current >= end) {
         // TODO(edisonn): report warning/error
         return NULL;
     }
 
-    current = nextObject(current, end, &generationObj, NULL);
+    current = nextObject(current, end, &generationObj, NULL, NULL);
     if (current >= end) {
         // TODO(edisonn): report warning/error
         return NULL;
     }
 
-    current = nextObject(current, end, &objKeyword, NULL);
+    current = nextObject(current, end, &objKeyword, NULL, NULL);
     if (current >= end) {
         // TODO(edisonn): report warning/error
         return NULL;
     }
 
     if (!idObj.isInteger() || !generationObj.isInteger() || id != idObj.intValue()/* || generation != generationObj.intValue()*/) {
         // TODO(edisonn): report warning/error
     }
 
     if (!objKeyword.isKeyword() || strcmp(objKeyword.c_str(), "obj") != 0) {
         // TODO(edisonn): report warning/error
     }
 
-    current = nextObject(current, end, dict, fAllocator);
+    current = nextObject(current, end, dict, fAllocator, this);
 
     // TODO(edisonn): report warning/error - verify last token is endobj
 
     return dict;
 }
 
 void SkNativeParsedPDF::fillPages(SkPdfPageTreeNodeDictionary* tree) {
     const SkPdfArray* kids = tree->Kids(this);
     if (kids == NULL) {
         *fPages.append() = (SkPdfPageObjectDictionary*)tree;
@@ skipping 14 matching lines @@
 
 int SkNativeParsedPDF::pages() const {
     return fPages.count();
 }
 
 SkPdfResourceDictionary* SkNativeParsedPDF::pageResources(int page) {
     return fPages[page]->Resources(this);
 }
 
 // TODO(edisonn): Partial implemented. Move the logics directly in the code generator for inheritable and default value?
-SkRect SkNativeParsedPDF::MediaBox(int page) const {
+SkRect SkNativeParsedPDF::MediaBox(int page) {
     SkPdfPageObjectDictionary* current = fPages[page];
     while (!current->has_MediaBox() && current->has_Parent()) {
         current = (SkPdfPageObjectDictionary*)current->Parent(this);
     }
     if (current) {
         return current->MediaBox(this);
     }
     return SkRect::MakeEmpty();
 }
 
 // TODO(edisonn): stream or array ... ? for now only array
-SkPdfNativeTokenizer* SkNativeParsedPDF::tokenizerOfPage(int page) const {
+SkPdfNativeTokenizer* SkNativeParsedPDF::tokenizerOfPage(int page) {
     if (fPages[page]->isContentsAStream(this)) {
         return tokenizerOfStream(fPages[page]->getContentsAsStream(this));
     } else {
         // TODO(edisonn): NYI, we need to concatenate all streams in the array or make the tokenizer smart
         // so we don't allocate new memory
         return NULL;
     }
 }
 
-SkPdfNativeTokenizer* SkNativeParsedPDF::tokenizerOfStream(SkPdfObject* stream) const {
+SkPdfNativeTokenizer* SkNativeParsedPDF::tokenizerOfStream(SkPdfObject* stream) {
     if (stream == NULL) {
         return NULL;
     }
 
-    return new SkPdfNativeTokenizer(stream, fMapper, fAllocator);
+    return new SkPdfNativeTokenizer(stream, fMapper, fAllocator, this);
 }
 
 // TODO(edisonn): NYI
-SkPdfNativeTokenizer* SkNativeParsedPDF::tokenizerOfBuffer(unsigned char* buffer, size_t len) const {
+SkPdfNativeTokenizer* SkNativeParsedPDF::tokenizerOfBuffer(unsigned char* buffer, size_t len) {
     // warning does not track two calls in the same buffer! the buffer is updated!
     // make a clean copy if needed!
-    return new SkPdfNativeTokenizer(buffer, len, fMapper, fAllocator);
+    return new SkPdfNativeTokenizer(buffer, len, fMapper, fAllocator, this);
 }
 
 size_t SkNativeParsedPDF::objects() const {
     return fObjects.count();
 }
 
 SkPdfObject* SkNativeParsedPDF::object(int i) {
     SkASSERT(!(i < 0 || i > fObjects.count()));
 
     if (i < 0 || i > fObjects.count()) {
@@ skipping 28 matching lines @@
 SkPdfString* SkNativeParsedPDF::createString(unsigned char* sz, size_t len) const {
     SkPdfObject* obj = fAllocator->allocObject();
     SkPdfObject::makeString(sz, len, obj);
     return (SkPdfString*)obj;
 }
 
 SkPdfAllocator* SkNativeParsedPDF::allocator() const {
     return fAllocator;
 }
 
-SkPdfObject* SkNativeParsedPDF::resolveReference(SkPdfObject* ref) const {
-    return (SkPdfObject*)resolveReference((const SkPdfObject*)ref);
-}
-
 // TODO(edisonn): fix infinite loop if ref to itself!
 // TODO(edisonn): perf, fix refs at load, and resolve will simply return fResolvedReference?
-SkPdfObject* SkNativeParsedPDF::resolveReference(const SkPdfObject* ref) const {
+SkPdfObject* SkNativeParsedPDF::resolveReference(const SkPdfObject* ref) {
     if (ref && ref->isReference()) {
         int id = ref->referenceId();
         // TODO(edisonn): generation/updates not supported now
         //int gen = ref->referenceGeneration();
 
         SkASSERT(!(id < 0 || id > fObjects.count()));
 
         if (id < 0 || id > fObjects.count()) {
             return NULL;
         }
@@ skipping 14 matching lines @@
             } else {
                 fObjects[id].fResolvedReference = resolveReference(fObjects[id].fObj);
             }
         }
 
         return fObjects[id].fResolvedReference;
     }
     // TODO(edisonn): fix the mess with const, probably we need to remove it pretty much everywhere
     return (SkPdfObject*)ref;
 }