pdf viewer: refactor and fix a bug (SkPdfobject should not reset on destruct)

experimental/PdfViewer/pdfparser/native/SkPdfNativeTokenizer.cpp

 
 #include "SkPdfNativeTokenizer.h"
 #include "SkPdfObject.h"
 #include "SkPdfConfig.h"
 
 #include "SkPdfStreamCommonDictionary_autogen.h"
 
 static unsigned char* skipPdfWhiteSpaces(unsigned char* start, unsigned char* end) {
     while (start < end && isPdfWhiteSpace(*start)) {
         if (*start == kComment_PdfDelimiter) {
@@ skipping 638 matching lines @@
 
 SkPdfObject* SkPdfAllocator::allocBlock() {
     return new SkPdfObject[BUFFER_SIZE];
 }
 
 SkPdfAllocator::~SkPdfAllocator() {
     for (int i = 0 ; i < fHandles.count(); i++) {
         free(fHandles[i]);
     }
     for (int i = 0 ; i < fHistory.count(); i++) {
+        for (int j = 0 ; j < BUFFER_SIZE; j++) {
+            fHistory[i][j].reset();
+        }
         delete[] fHistory[i];
     }
+    for (int j = 0 ; j < BUFFER_SIZE; j++) {
+        fCurrent[j].reset();
+    }
     delete[] fCurrent;
 }
 
 SkPdfObject* SkPdfAllocator::allocObject() {
     if (fCurrentUsed >= BUFFER_SIZE) {
         fHistory.push(fCurrent);
         fCurrent = allocBlock();
         fCurrentUsed = 0;
     }
-
     fCurrentUsed++;
     return &fCurrent[fCurrentUsed - 1];
 }
 
 // TODO(edisonn): perf: do no copy the buffers, but use them, and mark cache the result, so there is no need of a second pass
 SkPdfNativeTokenizer::SkPdfNativeTokenizer(SkPdfObject* objWithStream, const SkPdfMapper* mapper, SkPdfAllocator* allocator) : fMapper(mapper), fAllocator(allocator), fUncompressedStream(NULL), fUncompressedStreamEnd(NULL), fEmpty(false), fHasPutBack(false) {
     unsigned char* buffer = NULL;
     size_t len = 0;
     objWithStream->GetFilteredStreamRef(&buffer, &len, fAllocator);
+    // TODO(edisonn): hack, find end of object
+//    char* endobj = strstr((char*)buffer, "endobj");
+//    if (endobj) {
+//        len = endobj - (char*)buffer + strlen("endobj");
+//    }
     fUncompressedStreamStart = fUncompressedStream = (unsigned char*)fAllocator->alloc(len);
     fUncompressedStreamEnd = fUncompressedStream + len;
-    memcpy(fUncompressedStream, buffer, len);}
+    memcpy(fUncompressedStream, buffer, len);
+}
 
 SkPdfNativeTokenizer::SkPdfNativeTokenizer(unsigned char* buffer, int len, const SkPdfMapper* mapper, SkPdfAllocator* allocator) : fMapper(mapper), fAllocator(allocator), fEmpty(false), fHasPutBack(false) {
+    // TODO(edisonn): hack, find end of object
+//    char* endobj = strstr((char*)buffer, "endobj");
+//    if (endobj) {
+//        len = endobj - (char*)buffer + strlen("endobj");
+//    }
     fUncompressedStreamStart = fUncompressedStream = (unsigned char*)fAllocator->alloc(len);
     fUncompressedStreamEnd = fUncompressedStream + len;
     memcpy(fUncompressedStream, buffer, len);
 }
 
 SkPdfNativeTokenizer::~SkPdfNativeTokenizer() {
-    // free the unparsed stream, we don't need it.
-    // the parsed one is locked as it contains the strings and keywords referenced in objects
-    if (fUncompressedStream) {
-        void* dummy = realloc(fUncompressedStreamStart, fUncompressedStream - fUncompressedStreamStart);
-        //SkASSERT(dummy == fUncompressedStreamStart);
-        fUncompressedStreamStart = (unsigned char*)dummy;  // suppress compiler warning
-    } else {
-        SkASSERT(false);
-    }
 }
 
 bool SkPdfNativeTokenizer::readTokenCore(PdfToken* token) {
     token->fKeyword = NULL;
     token->fObject = NULL;
 
     fUncompressedStream = skipPdfWhiteSpaces(fUncompressedStream, fUncompressedStreamEnd);
     if (fUncompressedStream >= fUncompressedStreamEnd) {
         return false;
     }
 
     SkPdfObject obj;
     fUncompressedStream = nextObject(fUncompressedStream, fUncompressedStreamEnd, &obj, fAllocator);
 
     // If it is a keyword, we will only get the pointer of the string
     if (obj.type() == SkPdfObject::kKeyword_PdfObjectType) {
         token->fKeyword = obj.c_str();
         token->fKeywordLength = obj.len();
         token->fType = kKeyword_TokenType;
     } else {
         SkPdfObject* pobj = fAllocator->allocObject();
         *pobj = obj;
         token->fObject = pobj;
         token->fType = kObject_TokenType;
     }
 
 #ifdef PDF_TRACE
     static int read_op = 0;
     read_op++;
-    if (182749 == read_op) {
+    if (548 == read_op) {
         printf("break;\n");
     }
     printf("%i READ %s %s\n", read_op, token->fType == kKeyword_TokenType ? "Keyword" : "Object", token->fKeyword ? std::string(token->fKeyword, token->fKeywordLength).c_str() : token->fObject->toString().c_str());
 #endif
 
     return true;
 }
 
 void SkPdfNativeTokenizer::PutBack(PdfToken token) {
     SkASSERT(!fHasPutBack);
@@ skipping 16 matching lines @@
 
     if (fEmpty) {
 #ifdef PDF_TRACE
     printf("EMPTY TOKENIZER\n");
 #endif
         return false;
     }
 
     return readTokenCore(token);
 }
+