put each generated pdf api class in a file

experimental/PdfViewer/pdf_viewer_main.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkDevice.h"
 #include "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkPicture.h"
 #include "SkStream.h"
 #include "SkTypeface.h"
 #include "SkTArray.h"
 #include "picture_utils.h"
 
 #include <iostream>
 #include <cstdio>
 #include <stack>
 
 #include "podofo.h"
 using namespace PoDoFo;
 
+const PdfObject* resolveReferenceObject(const PdfMemDocument* pdfDoc,
+                                  const PdfObject* obj,
+                                  bool resolveOneElementArrays = false);
+
 bool LongFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         long* data);
 
 bool DoubleFromDictionary(const PdfMemDocument* pdfDoc,
                           const PdfDictionary& dict,
                           const char* key,
                           const char* abr,
@@ skipping 84 matching lines @@
                         const char* abr,
                         SkRect* data);
 
 bool FunctionFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfFunction* data);
 
 
-#include "pdf_auto_gen.h"
+#include "SkPdfHeaders_autogen.h"
+#include "SkPdfPodofoMapper_autogen.h"
+#include "SkPdfParser.h"
 
 bool ArrayFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfArray* data) {return false;}
 
 bool FileSpecFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
@@ skipping 11 matching lines @@
                         const char* key,
                         const char* abr,
                         SkPdfTree** data) {return false;}
 
 bool DateFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfDate* data) {return false;}
 
-bool SkRectFromDictionary(const PdfMemDocument* pdfDoc,
-                        const PdfDictionary& dict,
-                        const char* key,
-                        const char* abr,
-                        SkRect* data) {return false;}
-
 bool FunctionFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfFunction* data) {return false;}
 
 
 
 /*
  * TODO(edisonn):
@@ skipping 49 matching lines @@
             colorSpace == "CalRGB" ||
             colorSpace == "Lab") {
         return 3;
     } else {
         return 0;
     }
 }
 
 const PdfObject* resolveReferenceObject(const PdfMemDocument* pdfDoc,
                                   const PdfObject* obj,
-                                  bool resolveOneElementArrays = false) {
+                                  bool resolveOneElementArrays) {
     while (obj && (obj->IsReference() || (resolveOneElementArrays &&
                                           obj->IsArray() &&
                                           obj->GetArray().GetSize() == 1))) {
         if (obj->IsReference()) {
             // We need to force the non const, the only update we will do is for recurssion checks.
             PdfReference& ref = (PdfReference&)obj->GetReference();
             obj = pdfDoc->GetObjects().GetObject(ref);
         } else {
             obj = &obj->GetArray()[0];
         }
@@ skipping 51 matching lines @@
     SkPath              fClipPath;
 
     PdfColorOperator    fStroking;
     PdfColorOperator    fNonStroking;
 
     double              fLineWidth;
     double              fTextLeading;
     double              fWordSpace;
     double              fCharSpace;
 
-    SkPdfResourceDictionary fResources;
+    SkPdfResourceDictionary* fResources;
 
     SkBitmap            fSMask;
 
     PdfGraphicsState() {
         fCurPosX      = 0.0;
         fCurPosY      = 0.0;
         fCurFontSize  = 0.0;
         fTextBlock    = false;
         fCurFont      = NULL;
         fMatrix       = SkMatrix::I();
         fMatrixTm     = SkMatrix::I();
         fMatrixTlm    = SkMatrix::I();
         fPathClosed   = true;
         fLineWidth    = 0;
         fTextLeading  = 0;
         fWordSpace    = 0;
         fCharSpace    = 0;
         fHasClipPathToApply = false;
+        fResources = NULL;
     }
 };
 
 // TODO(edisonn): better class design.
 struct PdfInlineImage {
     std::map<std::string, std::string> fKeyValuePairs;
     std::string fImageData;
 
 };
 
 // TODO(edisonn): better class design.
 struct PdfContext {
-    std::stack<PdfVariant>          fVarStack;
+    std::stack<SkPdfObject*>        fObjectStack;
     std::stack<PdfGraphicsState>    fStateStack;
     PdfGraphicsState                fGraphicsState;
-    PoDoFo::PdfPage*                fPdfPage;
-    PdfMemDocument*                 fPdfDoc;
+    SkPdfDoc&                       fPdfDoc;
     SkMatrix                        fOriginalMatrix;
 
     PdfInlineImage                  fInlineImage;
 
-    PdfContext() :  fPdfPage(NULL),
-                    fPdfDoc(NULL) {}
+    PdfContext(SkPdfDoc& doc) :  fPdfDoc(doc) {}
 
 };
 
 //  TODO(edisonn): temporary code, to report how much of the PDF we actually think we rendered.
 enum PdfResult {
     kOK_PdfResult,
     kPartial_PdfResult,
     kNYI_PdfResult,
     kIgnoreError_PdfResult,
     kError_PdfResult,
     kUnsupported_PdfResult,
 
     kCount_PdfResult
 };
 
-struct PdfToken {
-    const char*      pszToken;
-    PdfVariant       var;
-    EPdfContentsType eType;
-
-    PdfToken() : pszToken(NULL) {}
-};
-
 PdfContext* gPdfContext = NULL;
 SkBitmap* gDumpBitmap = NULL;
 SkCanvas* gDumpCanvas = NULL;
 char gLastKeyword[100] = "";
 int gLastOpKeyword = -1;
-char allOpWithVisualEffects[100] = ",S,s,f,F,f*,B,B*,b,b*,n,Tj,TJ,\',\",d0,d1,sh,EI,Do,EX";
+char allOpWithVisualEffects[100] = ",S,s,f,F,f*,B,B*,b,b*,n,Tj,TJ,\',\",d0,d1,sh,EI,Do,EX,";
 int gReadOp = 0;
 
 
 
 bool hasVisualEffect(const char* pdfOp) {
     return true;
     if (*pdfOp == '\0') return false;
 
     char markedPdfOp[100] = ",";
     strcat(markedPdfOp, pdfOp);
     strcat(markedPdfOp, ",");
 
     return (strstr(allOpWithVisualEffects, markedPdfOp) != NULL);
 }
 
 // TODO(edisonn): Pass PdfContext and SkCanvasd only with the define for instrumentation.
-static bool readToken(PdfContentsTokenizer* fTokenizer, PdfToken* token) {
-    bool ret = fTokenizer->ReadNext(token->eType, token->pszToken, token->var);
+static bool readToken(SkPdfTokenizer fTokenizer, PdfToken* token) {
+    bool ret = fTokenizer.readToken(token);
 
     gReadOp++;
 
 #ifdef PDF_TRACE_DIFF_IN_PNG
     // TODO(edisonn): compare with old bitmap, and save only new bits are available, and save
     // the numbar and name of last operation, so the file name will reflect op that changed.
     if (hasVisualEffect(gLastKeyword)) {  // TODO(edisonn): and has dirty bits.
         gDumpCanvas->flush();
 
         SkBitmap bitmap;
@@ skipping 58 matching lines @@
 
         SkString out;
 
         // TODO(edisonn): get the image, and overlay on top of it, the clip , grafic state, teh stack,
         // ... and other properties, to be able to debug th code easily
 
         out.appendf("/usr/local/google/home/edisonn/log_view2/step-%i-%s.png", gLastOpKeyword, gLastKeyword);
         SkImageEncoder::EncodeFile(out.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100);
     }
 
-    if (token->eType == ePdfContentsType_Keyword) {
-        strcpy(gLastKeyword, token->pszToken);
+    if (token->fType == kKeyword_TokenType) {
+        strcpy(gLastKeyword, token->fKeyword);
         gLastOpKeyword = gReadOp;
     } else {
         strcpy(gLastKeyword, "");
     }
 #endif
 
     return ret;
 }
 
 // TODO(edisonn): Document PdfTokenLooper and subclasses.
 class PdfTokenLooper {
 protected:
     PdfTokenLooper* fParent;
-    PdfContentsTokenizer* fTokenizer;
+    SkPdfTokenizer fTokenizer;
     PdfContext* fPdfContext;
     SkCanvas* fCanvas;
 
 public:
     PdfTokenLooper(PdfTokenLooper* parent,
-                   PdfContentsTokenizer* tokenizer,
+                   SkPdfTokenizer tokenizer,
                    PdfContext* pdfContext,
                    SkCanvas* canvas)
         : fParent(parent), fTokenizer(tokenizer), fPdfContext(pdfContext), fCanvas(canvas) {}
 
     virtual PdfResult consumeToken(PdfToken& token) = 0;
     virtual void loop() = 0;
 
     void setUp(PdfTokenLooper* parent) {
         fParent = parent;
         fTokenizer = parent->fTokenizer;
         fPdfContext = parent->fPdfContext;
         fCanvas = parent->fCanvas;
     }
 };
 
 class PdfMainLooper : public PdfTokenLooper {
 public:
     PdfMainLooper(PdfTokenLooper* parent,
-                  PdfContentsTokenizer* tokenizer,
+                  SkPdfTokenizer tokenizer,
                   PdfContext* pdfContext,
                   SkCanvas* canvas)
         : PdfTokenLooper(parent, tokenizer, pdfContext, canvas) {}
 
     virtual PdfResult consumeToken(PdfToken& token);
     virtual void loop();
 };
 
 class PdfInlineImageLooper : public PdfTokenLooper {
 public:
     PdfInlineImageLooper()
-        : PdfTokenLooper(NULL, NULL, NULL, NULL) {}
+        : PdfTokenLooper(NULL, SkPdfTokenizer(), NULL, NULL) {}
 
     virtual PdfResult consumeToken(PdfToken& token);
     virtual void loop();
     PdfResult done();
 };
 
 class PdfCompatibilitySectionLooper : public PdfTokenLooper {
 public:
     PdfCompatibilitySectionLooper()
-        : PdfTokenLooper(NULL, NULL, NULL, NULL) {}
+        : PdfTokenLooper(NULL, SkPdfTokenizer(), NULL, NULL) {}
 
     virtual PdfResult consumeToken(PdfToken& token);
     virtual void loop();
 };
 
 typedef PdfResult (*PdfOperatorRenderer)(PdfContext*, SkCanvas*, PdfTokenLooper**);
 
 map<std::string, PdfOperatorRenderer> gPdfOps;
 
 map<std::string, int> gRenderStats[kCount_PdfResult];
@@ skipping 159 matching lines @@
 
 // TODO(edisonn): move this code in podofo, so we don't have to fix the font.
 // This logic needs to be moved in PdfEncodingObjectFactory::CreateEncoding
 std::map<PdfFont*, PdfCMapEncoding*> gFontsFixed;
 PdfEncoding* FixPdfFont(PdfContext* pdfContext, PdfFont* fCurFont) {
     // TODO(edisonn): and is Identity-H
     if (gFontsFixed.find(fCurFont) == gFontsFixed.end()) {
         if (fCurFont->GetObject()->IsDictionary() && fCurFont->GetObject()->GetDictionary().HasKey(PdfName("ToUnicode"))) {
             PdfCMapEncoding* enc = new PdfCMapEncoding(
                     fCurFont->GetObject(),
-                    (PdfObject*)resolveReferenceObject(pdfContext->fPdfDoc,
+                    (PdfObject*)resolveReferenceObject(&pdfContext->fPdfDoc.podofo(),
                                            fCurFont->GetObject()->GetDictionary().GetKey(PdfName("ToUnicode"))),
                     PdfCMapEncoding::eBaseEncoding_Identity);  // todo, read the base encoding
             gFontsFixed[fCurFont] = enc;
             return enc;
         }
 
         return NULL;
     }
 
     return gFontsFixed[fCurFont];
@@ skipping 545 matching lines @@
             width, height, bytesPerLine,
             bpc, colorSpace,
             transparencyMask);
 
     free(uncompressedStream);
 
     return bitmap;
 }
 
 SkBitmap getSmaskFromObject(PdfContext* pdfContext, const SkPdfImageDictionary* obj) {
-    const PdfObject* sMask = resolveReferenceObject(pdfContext->fPdfDoc,
+    const PdfObject* sMask = resolveReferenceObject(&pdfContext->fPdfDoc.podofo(),
                                               obj->podofo()->GetDictionary().GetKey(PdfName("SMask")));
 
 #ifdef PDF_TRACE
     std::string str;
     if (sMask) {
         sMask->ToString(str);
         printf("/SMask of /Subtype /Image: %s\n", str.c_str());
     }
 #endif
 
     if (sMask) {
-        SkPdfImageDictionary skxobjmask(pdfContext->fPdfDoc, sMask);
+        SkPdfImageDictionary skxobjmask(&pdfContext->fPdfDoc.podofo(), sMask);
         return getImageFromObject(pdfContext, &skxobjmask, true);
     }
 
     // TODO(edisonn): implement GS SMask. Default to empty right now.
     return pdfContext->fGraphicsState.fSMask;
 }
 
 PdfResult doXObject_Image(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfImageDictionary* skpdfimage) {
     if (skpdfimage == NULL || !skpdfimage->valid()) {
         return kIgnoreError_PdfResult;
@@ skipping 19 matching lines @@
 
     canvas->restore();
 
     return kPartial_PdfResult;
 }
 
 bool SkMatrixFromDictionary(PdfContext* pdfContext,
                             const PdfDictionary& dict,
                             const char* key,
                             SkMatrix* matrix) {
-    const PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
+    const PdfObject* value = resolveReferenceObject(&pdfContext->fPdfDoc.podofo(),
                                                     dict.GetKey(PdfName(key)));
 
     if (value == NULL || !value->IsArray()) {
         return false;
     }
 
     if (value->GetArray().GetSize() != 6) {
         return false;
     }
 
     double array[6];
     for (int i = 0; i < 6; i++) {
-        const PdfObject* elem = resolveReferenceObject(pdfContext->fPdfDoc, &value->GetArray()[i]);
+        const PdfObject* elem = resolveReferenceObject(&pdfContext->fPdfDoc.podofo(), &value->GetArray()[i]);
         if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
             return false;
         }
         array[i] = elem->GetReal();
     }
 
     *matrix = SkMatrixFromPdfMatrix(array);
     return true;
 }
 
-bool SkRectFromDictionary(PdfContext* pdfContext,
+bool SkRectFromDictionary(const PdfMemDocument* pdfDoc,
                           const PdfDictionary& dict,
                           const char* key,
                           SkRect* rect) {
-    const PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
                                                     dict.GetKey(PdfName(key)));
 
     if (value == NULL || !value->IsArray()) {
         return false;
     }
 
     if (value->GetArray().GetSize() != 4) {
         return false;
     }
 
     double array[4];
     for (int i = 0; i < 4; i++) {
-        const PdfObject* elem = resolveReferenceObject(pdfContext->fPdfDoc, &value->GetArray()[i]);
+        const PdfObject* elem = resolveReferenceObject(pdfDoc, &value->GetArray()[i]);
         if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
             return false;
         }
         array[i] = elem->GetReal();
     }
 
     *rect = SkRect::MakeLTRB(SkDoubleToScalar(array[0]),
                              SkDoubleToScalar(array[1]),
                              SkDoubleToScalar(array[2]),
                              SkDoubleToScalar(array[3]));
     return true;
 }
 
+bool SkRectFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        SkRect* data) {
+    if (SkRectFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return SkRectFromDictionary(pdfDoc, dict, abr, data);
+
+}
+
+
 SkPdfObject* get(const SkPdfObject* obj, const char* key, const char* abr = "") {
     SkPdfObject* ret = NULL;
     if (obj == NULL) return NULL;
     const SkPdfDictionary* dict = obj->asDictionary();
     if (dict == NULL) return NULL;
     if (!dict->podofo()->IsDictionary()) return NULL;
     ObjectFromDictionary(dict->doc(), dict->podofo()->GetDictionary(), key, abr, &ret);
     return ret;
 }
 
 PdfResult doXObject_Form(PdfContext* pdfContext, SkCanvas* canvas, SkPdfType1FormDictionary* skobj) {
     if (!skobj || !skobj->podofo() || !skobj->podofo()->HasStream() || skobj->podofo()->GetStream() == NULL || skobj->podofo()->GetStream()->GetLength() == 0) {
         return kOK_PdfResult;
     }
 
     PdfOp_q(pdfContext, canvas, NULL);
     canvas->save();
 
     if (get(skobj, "Resources")) {
         SkPdfResourceDictionary* res = NULL;
 
         PodofoMapper::map(*get(skobj, "Resources"), &res);
 
         if (res) {
-            pdfContext->fGraphicsState.fResources = *res;
-            delete res;
+            pdfContext->fGraphicsState.fResources = res;
         }
     }
 
     SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Current matrix");
 
     SkMatrix matrix;
     if (SkMatrixFromDictionary(pdfContext, skobj->podofo()->GetDictionary(), "Matrix", &matrix)) {
         pdfContext->fGraphicsState.fMatrix.preConcat(matrix);
         pdfContext->fGraphicsState.fMatrixTm = pdfContext->fGraphicsState.fMatrix;
         pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrix;
         // TODO(edisonn) reset matrixTm and matricTlm also?
     }
 
     SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Total matrix");
 
     canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
 
     SkRect bbox;
-    if (SkRectFromDictionary(pdfContext, skobj->podofo()->GetDictionary(), "BBox", &bbox)) {
+    if (SkRectFromDictionary(&pdfContext->fPdfDoc.podofo(), skobj->podofo()->GetDictionary(), "BBox", &bbox)) {
         canvas->clipRect(bbox, SkRegion::kIntersect_Op, true);  // TODO(edisonn): AA from settings.
     }
 
     // TODO(edisonn): iterate smart on the stream even if it is compressed, tokenize it as we go.
     // For this PdfContentsTokenizer needs to be extended.
 
     char* uncompressedStream = NULL;
     pdf_long uncompressedStreamLength = 0;
 
     PdfResult ret = kPartial_PdfResult;
 
     // TODO(edisonn): get rid of try/catch exceptions! We should not throw on user data!
     try {
         skobj->podofo()->GetStream()->GetFilteredCopy(&uncompressedStream, &uncompressedStreamLength);
         if (uncompressedStream != NULL && uncompressedStreamLength != 0) {
-            PdfContentsTokenizer tokenizer(uncompressedStream, uncompressedStreamLength);
-            PdfMainLooper looper(NULL, &tokenizer, pdfContext, canvas);
+            SkPdfTokenizer tokenizer = pdfContext->fPdfDoc.tokenizerOfStream(uncompressedStream, uncompressedStreamLength);
+            PdfMainLooper looper(NULL, tokenizer, pdfContext, canvas);
             looper.loop();
         }
         free(uncompressedStream);
     } catch (PdfError& e) {
         ret = kIgnoreError_PdfResult;
     }
 
     // TODO(edisonn): should we restore the variable stack at the same state?
     // There could be operands left, that could be consumed by a parent tokenizer when we pop.
     canvas->restore();
     PdfOp_Q(pdfContext, canvas, NULL);
     return ret;
 }
 
 PdfResult doXObject_PS(PdfContext* pdfContext, SkCanvas* canvas, const PdfObject& obj) {
     return kNYI_PdfResult;
 }
 
-// TODO(edisonn): faster, have the property on the PdfObject itself.
+// TODO(edisonn): faster, have the property on the SkPdfObject itself?
 std::set<const PdfObject*> gInRendering;
 
 class CheckRecursiveRendering {
     const PdfObject& fObj;
 public:
     CheckRecursiveRendering(const PdfObject& obj) : fObj(obj) {
         gInRendering.insert(&obj);
     }
 
     ~CheckRecursiveRendering() {
         //SkASSERT(fObj.fInRendering);
         gInRendering.erase(&fObj);
     }
 
     static bool IsInRendering(const PdfObject& obj) {
         return gInRendering.find(&obj) != gInRendering.end();
     }
 };
 
-PdfResult doXObject(PdfContext* pdfContext, SkCanvas* canvas, const PdfObject& obj) {
-    if (CheckRecursiveRendering::IsInRendering(obj)) {
+PdfResult doXObject(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfObject& obj) {
+    if (CheckRecursiveRendering::IsInRendering(*obj.podofo())) {
         // Oops, corrupt PDF!
         return kIgnoreError_PdfResult;
     }
 
-    CheckRecursiveRendering checkRecursion(obj);
+    CheckRecursiveRendering checkRecursion(*obj.podofo());
 
     // TODO(edisonn): check type
     SkPdfXObjectDictionary* skobj = NULL;
-    if (!PodofoMapper::map(*pdfContext->fPdfDoc, obj, &skobj)) return kIgnoreError_PdfResult;
+    if (!PodofoMapper::map(obj, &skobj)) return kIgnoreError_PdfResult;
 
     if (!skobj || !skobj->valid()) return kIgnoreError_PdfResult;
 
     PdfResult ret = kIgnoreError_PdfResult;
     switch (skobj->getType())
     {
-        case kObjectDictionaryXObjectDictionaryImageDictionary_SkPdfObjectType:
+        case kImageDictionary_SkPdfObjectType:
             ret = doXObject_Image(pdfContext, canvas, skobj->asImageDictionary());
             break;
-        case kObjectDictionaryXObjectDictionaryType1FormDictionary_SkPdfObjectType:
+        case kType1FormDictionary_SkPdfObjectType:
             ret = doXObject_Form(pdfContext, canvas, skobj->asType1FormDictionary());
             break;
         //case kObjectDictionaryXObjectPS_SkPdfObjectType:
             //return doXObject_PS(skxobj.asPS());
     }
 
     delete skobj;
     return ret;
 }
 
 PdfResult PdfOp_q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     pdfContext->fStateStack.push(pdfContext->fGraphicsState);
     canvas->save();
     return kOK_PdfResult;
 }
 
 PdfResult PdfOp_Q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     pdfContext->fGraphicsState = pdfContext->fStateStack.top();
     pdfContext->fStateStack.pop();
     canvas->restore();
     return kOK_PdfResult;
 }
 
 PdfResult PdfOp_cm(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     double array[6];
     for (int i = 0 ; i < 6 ; i++) {
-        array[5 - i] = pdfContext->fVarStack.top().GetReal();
-        pdfContext->fVarStack.pop();
+        array[5 - i] = pdfContext->fObjectStack.top()->asNumber()->value();
+        pdfContext->fObjectStack.pop();
     }
 
     // a b
     // c d
     // e f
 
     // 0 1
     // 2 3
     // 4 5
 
@@ skipping 13 matching lines @@
     SkTraceMatrix(pdfContext->fGraphicsState.fMatrix);
 #endif
 
     return kOK_PdfResult;
 }
 
 //leading TL Set the text leading, Tl
 //, to leading, which is a number expressed in unscaled text
 //space units. Text leading is used only by the T*, ', and " operators. Initial value: 0.
 PdfResult PdfOp_TL(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    double ty = pdfContext->fVarStack.top().GetReal(); pdfContext->fVarStack.pop();
+    double ty = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
 
     pdfContext->fGraphicsState.fTextLeading = ty;
 
     return kOK_PdfResult;
 }
 
 PdfResult PdfOp_Td(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    double ty = pdfContext->fVarStack.top().GetReal(); pdfContext->fVarStack.pop();
-    double tx = pdfContext->fVarStack.top().GetReal(); pdfContext->fVarStack.pop();
+    double ty = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+    double tx = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
 
     double array[6] = {1, 0, 0, 1, tx, ty};
     SkMatrix matrix = SkMatrixFromPdfMatrix(array);
 
     pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
     pdfContext->fGraphicsState.fMatrixTlm.preConcat(matrix);
 
     return kPartial_PdfResult;
 }
 
 PdfResult PdfOp_TD(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    double ty = pdfContext->fVarStack.top().GetReal(); pdfContext->fVarStack.pop();
-    double tx = pdfContext->fVarStack.top().GetReal(); pdfContext->fVarStack.pop();
+    double ty = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+    double tx = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
 
-    PdfVariant _ty(-ty);
-    pdfContext->fVarStack.push(_ty);
+    PdfObject _ty(PdfVariant(-ty));
+    pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc.podofo(), &_ty));
+
     PdfOp_TL(pdfContext, canvas, looper);
 
-    PdfVariant vtx(tx);
-    PdfVariant vty(ty);
-    pdfContext->fVarStack.push(vtx);
-    pdfContext->fVarStack.push(vty);
+    PdfObject vtx(PdfVariant(-(-tx)));  // TODO(edisonn) Hmm, the compiler thinks I have here a function pointer if we use (tx), but not -(-tx)
+    pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc.podofo(), &vtx));
+
+    PdfObject vty(PdfVariant(-(-ty)));
+    pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc.podofo(), &vty));
+
     return PdfOp_Td(pdfContext, canvas, looper);
 }
 
 PdfResult PdfOp_Tm(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    double f = pdfContext->fVarStack.top().GetReal(); pdfContext->fVarStack.pop();
-    double e = pdfContext->fVarStack.top().GetReal(); pdfContext->fVarStack.pop();
-    double d = pdfContext->fVarStack.top().GetReal(); pdfContext->fVarStack.pop();
-    double c = pdfContext->fVarStack.top().GetReal(); pdfContext->fVarStack.pop();
-    double b = pdfContext->fVarStack.top().GetReal(); pdfContext->fVarStack.pop();
-    double a = pdfContext->fVarStack.top().GetReal(); pdfContext->fVarStack.pop();
+    double f = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+    double e = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+    double d = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+    double c = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+    double b = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+    double a = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
 
     double array[6];
     array[0] = a;
     array[1] = b;
     array[2] = c;
     array[3] = d;
     array[4] = e;
     array[5] = f;
 
     SkMatrix matrix = SkMatrixFromPdfMatrix(array);
     matrix.postConcat(pdfContext->fGraphicsState.fMatrix);
 
     // TODO(edisonn): Text positioning.
     pdfContext->fGraphicsState.fMatrixTm = matrix;
     pdfContext->fGraphicsState.fMatrixTlm = matrix;;
 
     return kPartial_PdfResult;
 }
 
 //— T* Move to the start of the next line. This operator has the same effect as the code
 //0 Tl Td
 //where Tl is the current leading parameter in the text state
 PdfResult PdfOp_T_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    PdfVariant zero(0.0);
-    PdfVariant tl(pdfContext->fGraphicsState.fTextLeading);
+    PdfObject zero(PdfVariant(0.0));
+    PdfObject tl(PdfVariant(-(-pdfContext->fGraphicsState.fTextLeading)));
 
-    pdfContext->fVarStack.push(zero);
-    pdfContext->fVarStack.push(tl);
+    pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc.podofo(), &zero));
+    pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc.podofo(), &tl));
     return PdfOp_Td(pdfContext, canvas, looper);
 }
 
 PdfResult PdfOp_m(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     if (pdfContext->fGraphicsState.fPathClosed) {
         pdfContext->fGraphicsState.fPath.reset();
         pdfContext->fGraphicsState.fPathClosed = false;
     }
 
-    pdfContext->fGraphicsState.fCurPosY = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
-    pdfContext->fGraphicsState.fCurPosX = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
+    pdfContext->fGraphicsState.fCurPosY = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
+    pdfContext->fGraphicsState.fCurPosX = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
 
     pdfContext->fGraphicsState.fPath.moveTo(SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosX),
                                           SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosY));
 
     return kOK_PdfResult;
 }
 
 PdfResult PdfOp_l(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     if (pdfContext->fGraphicsState.fPathClosed) {
         pdfContext->fGraphicsState.fPath.reset();
         pdfContext->fGraphicsState.fPathClosed = false;
     }
 
-    pdfContext->fGraphicsState.fCurPosY = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
-    pdfContext->fGraphicsState.fCurPosX = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
+    pdfContext->fGraphicsState.fCurPosY = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
+    pdfContext->fGraphicsState.fCurPosX = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
 
     pdfContext->fGraphicsState.fPath.lineTo(SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosX),
                                           SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosY));
 
     return kOK_PdfResult;
 }
 
 PdfResult PdfOp_c(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     if (pdfContext->fGraphicsState.fPathClosed) {
         pdfContext->fGraphicsState.fPath.reset();
         pdfContext->fGraphicsState.fPathClosed = false;
     }
 
-    double y3 = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
-    double x3 = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
-    double y2 = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
-    double x2 = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
-    double y1 = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
-    double x1 = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
+    double y3 = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
+    double x3 = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
+    double y2 = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
+    double x2 = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
+    double y1 = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
+    double x1 = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
 
     pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1),
                                             SkDoubleToScalar(x2), SkDoubleToScalar(y2),
                                             SkDoubleToScalar(x3), SkDoubleToScalar(y3));
 
     pdfContext->fGraphicsState.fCurPosX = x3;
     pdfContext->fGraphicsState.fCurPosY = y3;
 
     return kOK_PdfResult;
 }
 
 PdfResult PdfOp_v(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     if (pdfContext->fGraphicsState.fPathClosed) {
         pdfContext->fGraphicsState.fPath.reset();
         pdfContext->fGraphicsState.fPathClosed = false;
     }
 
-    double y3 = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
-    double x3 = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
-    double y2 = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
-    double x2 = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
+    double y3 = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
+    double x3 = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
+    double y2 = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
+    double x2 = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
     double y1 = pdfContext->fGraphicsState.fCurPosY;
     double x1 = pdfContext->fGraphicsState.fCurPosX;
 
     pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1),
                                             SkDoubleToScalar(x2), SkDoubleToScalar(y2),
                                             SkDoubleToScalar(x3), SkDoubleToScalar(y3));
 
     pdfContext->fGraphicsState.fCurPosX = x3;
     pdfContext->fGraphicsState.fCurPosY = y3;
 
     return kOK_PdfResult;
 }
 
 PdfResult PdfOp_y(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     if (pdfContext->fGraphicsState.fPathClosed) {
         pdfContext->fGraphicsState.fPath.reset();
         pdfContext->fGraphicsState.fPathClosed = false;
     }
 
-    double y3 = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
-    double x3 = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
+    double y3 = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
+    double x3 = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
     double y2 = pdfContext->fGraphicsState.fCurPosY;
     double x2 = pdfContext->fGraphicsState.fCurPosX;
-    double y1 = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
-    double x1 = pdfContext->fVarStack.top().GetReal();    pdfContext->fVarStack.pop();
+    double y1 = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
+    double x1 = pdfContext->fObjectStack.top()->asNumber()->value();    pdfContext->fObjectStack.pop();
 
     pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1),
                                             SkDoubleToScalar(x2), SkDoubleToScalar(y2),
                                             SkDoubleToScalar(x3), SkDoubleToScalar(y3));
 
     pdfContext->fGraphicsState.fCurPosX = x3;
     pdfContext->fGraphicsState.fCurPosY = y3;
 
     return kOK_PdfResult;
 }
 
 PdfResult PdfOp_re(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     if (pdfContext->fGraphicsState.fPathClosed) {
         pdfContext->fGraphicsState.fPath.reset();
         pdfContext->fGraphicsState.fPathClosed = false;
     }
 
-    double height = pdfContext->fVarStack.top().GetReal();      pdfContext->fVarStack.pop();
-    double width = pdfContext->fVarStack.top().GetReal();       pdfContext->fVarStack.pop();
-    double y = pdfContext->fVarStack.top().GetReal();           pdfContext->fVarStack.pop();
-    double x = pdfContext->fVarStack.top().GetReal();           pdfContext->fVarStack.pop();
+    double height = pdfContext->fObjectStack.top()->asNumber()->value();      pdfContext->fObjectStack.pop();
+    double width = pdfContext->fObjectStack.top()->asNumber()->value();       pdfContext->fObjectStack.pop();
+    double y = pdfContext->fObjectStack.top()->asNumber()->value();           pdfContext->fObjectStack.pop();
+    double x = pdfContext->fObjectStack.top()->asNumber()->value();           pdfContext->fObjectStack.pop();
 
     pdfContext->fGraphicsState.fPath.addRect(SkDoubleToScalar(x), SkDoubleToScalar(y),
                                            SkDoubleToScalar(x + width), SkDoubleToScalar(y + height));
 
     pdfContext->fGraphicsState.fCurPosX = x;
     pdfContext->fGraphicsState.fCurPosY = y + height;
 
     return kOK_PdfResult;
 }
 
@@ skipping 131 matching lines @@
     // TODO(edisonn): anything else to be done once we are done with draw text? Like restore stack?
     return kPartial_PdfResult;
 }
 
 //font size Tf Set the text font, Tf
 //, to font and the text font size, Tfs, to size. font is the name of a
 //font resource in the Fontsubdictionary of the current resource dictionary; size is
 //a number representing a scale factor. There is no initial value for either font or
 //size; they must be specified explicitly using Tf before any text is shown.
 PdfResult PdfOp_Tf(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fGraphicsState.fCurFontSize = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
-    PdfName fontName = pdfContext->fVarStack.top().GetName();                           pdfContext->fVarStack.pop();
+    pdfContext->fGraphicsState.fCurFontSize = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
+    std::string fontName = pdfContext->fObjectStack.top()->asName()->value();                           pdfContext->fObjectStack.pop();
+
+#ifdef PDF_TRACE
+    printf("font name: %s\n", fontName.c_str());
+    std::string str;
+    pdfContext->fGraphicsState.fResources->podofo()->ToString(str);
+    printf("Print Tf font Resources: %s\n", str.c_str());
+#endif
 
     // TODO(edisonn): Load font from pdfContext->fGraphicsState.fObjectWithResources ?
-    PdfObject* pFont = pdfContext->fPdfPage->GetFromResources( PdfName("Font"), fontName );
+    const PdfObject* pFont = resolveReferenceObject(&pdfContext->fPdfDoc.podofo(),
+                                                    pdfContext->fGraphicsState.fResources->Font()->get(fontName.c_str()).podofo());
     if( !pFont )
     {
         // TODO(edisonn): try to ignore the error, make sure we do not crash.
         return kIgnoreError_PdfResult;
     }
 
-    pdfContext->fGraphicsState.fCurFont = pdfContext->fPdfDoc->GetFont( pFont );
+    pdfContext->fGraphicsState.fCurFont = pdfContext->fPdfDoc.podofo().GetFont( (PdfObject*)pFont );
     if( !pdfContext->fGraphicsState.fCurFont )
     {
         // TODO(edisonn): check ~/crasing, for one of the files PoDoFo throws exception
         // when calling pFont->Reference(), with Linked list corruption.
         return kIgnoreError_PdfResult;
     }
 
     return kPartial_PdfResult;
 }
 
 PdfResult PdfOp_Tj(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     if (!pdfContext->fGraphicsState.fTextBlock) {
         // TODO(edisonn): try to recover and draw it any way?
         return kIgnoreError_PdfResult;
     }
 
     PdfResult ret = DrawText(pdfContext,
                              pdfContext->fGraphicsState.fCurFont,
-                             pdfContext->fVarStack.top().GetString(),
+                             pdfContext->fObjectStack.top()->podofo()->GetString(),
                              canvas);
-    pdfContext->fVarStack.pop();
+    pdfContext->fObjectStack.pop();
 
     return ret;
 }
 
 PdfResult PdfOp_quote(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     if (!pdfContext->fGraphicsState.fTextBlock) {
         // TODO(edisonn): try to recover and draw it any way?
         return kIgnoreError_PdfResult;
     }
 
     PdfOp_T_star(pdfContext, canvas, looper);
     // Do not pop, and push, just transfer the param to Tj
     return PdfOp_Tj(pdfContext, canvas, looper);
 }
 
 PdfResult PdfOp_doublequote(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     if (!pdfContext->fGraphicsState.fTextBlock) {
         // TODO(edisonn): try to recover and draw it any way?
         return kIgnoreError_PdfResult;
     }
 
-    PdfVariant str = pdfContext->fVarStack.top();       pdfContext->fVarStack.pop();
-    PdfVariant ac = pdfContext->fVarStack.top();        pdfContext->fVarStack.pop();
-    PdfVariant aw = pdfContext->fVarStack.top();        pdfContext->fVarStack.pop();
+    SkPdfObject* str = pdfContext->fObjectStack.top();       pdfContext->fObjectStack.pop();
+    SkPdfObject* ac = pdfContext->fObjectStack.top();        pdfContext->fObjectStack.pop();
+    SkPdfObject* aw = pdfContext->fObjectStack.top();        pdfContext->fObjectStack.pop();
 
-    pdfContext->fVarStack.push(aw);
+    pdfContext->fObjectStack.push(aw);
     PdfOp_Tw(pdfContext, canvas, looper);
 
-    pdfContext->fVarStack.push(ac);
+    pdfContext->fObjectStack.push(ac);
     PdfOp_Tc(pdfContext, canvas, looper);
 
-    pdfContext->fVarStack.push(str);
+    pdfContext->fObjectStack.push(str);
     PdfOp_quote(pdfContext, canvas, looper);
 
     return kPartial_PdfResult;
 }
 
 PdfResult PdfOp_TJ(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     if (!pdfContext->fGraphicsState.fTextBlock) {
         // TODO(edisonn): try to recover and draw it any way?
         return kIgnoreError_PdfResult;
     }
 
-    PdfArray array = pdfContext->fVarStack.top().GetArray();
-    pdfContext->fVarStack.pop();
+    SkPdfArray* array = pdfContext->fObjectStack.top()->asArray();
+    pdfContext->fObjectStack.pop();
 
-    for( int i=0; i<static_cast<int>(array.GetSize()); i++ )
+    for( int i=0; i<static_cast<int>(array->size()); i++ )
     {
-        if( array[i].IsString() || array[i].IsHexString() ) {
+        if( (*array)[i].asString()) {
             DrawText(pdfContext,
                            pdfContext->fGraphicsState.fCurFont,
-                           array[i].GetString(),
+                           (*array)[i].podofo()->GetString(),
                            canvas);
-        } else if (array[i].IsReal() || array[i].IsNumber()) {
-            double dx = array[i].GetReal();
+        } else if ((*array)[i].asInteger() || (*array)[i].asNumber()) {
+            double dx = (*array)[i].asNumber()->value();
             SkMatrix matrix;
             matrix.setAll(SkDoubleToScalar(1),
                           SkDoubleToScalar(0),
                           // TODO(edisonn): use writing mode, vertical/horizontal.
                           SkDoubleToScalar(-dx),  // amount is substracted!!!
                           SkDoubleToScalar(0),
                           SkDoubleToScalar(1),
                           SkDoubleToScalar(0),
                           SkDoubleToScalar(0),
                           SkDoubleToScalar(0),
                           SkDoubleToScalar(1));
 
             pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
         }
     }
     return kPartial_PdfResult;  // TODO(edisonn): Implement fully DrawText before returing OK.
 }
 
 PdfResult PdfOp_CS_cs(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
-    colorOperator->fColorSpace = pdfContext->fVarStack.top().GetName().GetName();    pdfContext->fVarStack.pop();
+    colorOperator->fColorSpace = pdfContext->fObjectStack.top()->asName()->value();    pdfContext->fObjectStack.pop();
     return kOK_PdfResult;
 }
 
 PdfResult PdfOp_CS(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
 PdfResult PdfOp_cs(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
 }
 
 PdfResult PdfOp_SC_sc(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
     double c[4];
     pdf_int64 v[4];
 
     int n = GetColorSpaceComponents(colorOperator->fColorSpace);
 
     bool doubles = true;
     if (colorOperator->fColorSpace == "Indexed") {
         doubles = false;
     }
 
 #ifdef PDF_TRACE
     printf("color space = %s, N = %i\n", colorOperator->fColorSpace.c_str(), n);
 #endif
 
     for (int i = n - 1; i >= 0 ; i--) {
         if (doubles) {
-            c[i] = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
+            c[i] = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
         } else {
-            v[i] = pdfContext->fVarStack.top().GetNumber();   pdfContext->fVarStack.pop();
+            v[i] = pdfContext->fObjectStack.top()->asInteger()->value();   pdfContext->fObjectStack.pop();
         }
     }
 
     // TODO(edisonn): Now, set that color. Only DeviceRGB supported.
     if (colorOperator->fColorSpace == "DeviceRGB") {
         colorOperator->setRGBColor(SkColorSetRGB(255*c[0], 255*c[1], 255*c[2]));
     }
     return kPartial_PdfResult;
 }
 
 PdfResult PdfOp_SC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
 PdfResult PdfOp_sc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
 }
 
 PdfResult PdfOp_SCN_scn(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
     PdfString name;
 
-    if (pdfContext->fVarStack.top().IsName()) {
-        pdfContext->fVarStack.pop();
+    if (pdfContext->fObjectStack.top()->asName()) {
+        pdfContext->fObjectStack.pop();
     }
 
     // TODO(edisonn): SCN supports more color spaces than SCN. Read and implement spec.
     PdfOp_SC_sc(pdfContext, canvas, colorOperator);
 
     return kPartial_PdfResult;
 }
 
 PdfResult PdfOp_SCN(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
 PdfResult PdfOp_scn(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
 }
 
 PdfResult PdfOp_G_g(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
-    double gray = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
+    double gray = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
     return kNYI_PdfResult;
 }
 
 PdfResult PdfOp_G(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
 PdfResult PdfOp_g(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
 }
 
 PdfResult PdfOp_RG_rg(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
-    double b = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
-    double g = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
-    double r = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
+    double b = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
+    double g = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
+    double r = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
 
     colorOperator->fColorSpace = "DeviceRGB";
     colorOperator->setRGBColor(SkColorSetRGB(255*r, 255*g, 255*b));
     return kOK_PdfResult;
 }
 
 PdfResult PdfOp_RG(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
 PdfResult PdfOp_rg(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
 }
 
 PdfResult PdfOp_K_k(PdfContext* pdfContext, SkCanvas* canvas, PdfColorOperator* colorOperator) {
     // TODO(edisonn): spec has some rules about overprint, implement them.
-    double k = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
-    double y = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
-    double m = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
-    double c = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
+    double k = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
+    double y = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
+    double m = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
+    double c = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
 
     colorOperator->fColorSpace = "DeviceCMYK";
     // TODO(edisonn): Set color.
     return kNYI_PdfResult;
 }
 
 PdfResult PdfOp_K(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
@@ skipping 53 matching lines @@
 PdfResult PdfOp_EI(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
 #ifdef ASSERT_BAD_PDF_OPS
     SkASSERT(false);  // must be processed in inline image looper, but let's
                       // have the assert when testing good pdfs.
 #endif
     return kIgnoreError_PdfResult;
 }
 
 //lineWidth w Set the line width in the graphics state (see “Line Width” on page 152).
 PdfResult PdfOp_w(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    double lineWidth = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
+    double lineWidth = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
     pdfContext->fGraphicsState.fLineWidth = lineWidth;
 
     return kOK_PdfResult;
 }
 
 //lineCap J Set the line cap style in the graphics state (see “Line Cap Style” on page 153).
 PdfResult PdfOp_J(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fVarStack.pop();
-    //double lineCap = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
+    pdfContext->fObjectStack.pop();
+    //double lineCap = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //lineJoin j Set the line join style in the graphics state (see “Line Join Style” on page 153).
 PdfResult PdfOp_j(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fVarStack.pop();
-    //double lineJoin = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
+    pdfContext->fObjectStack.pop();
+    //double lineJoin = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //miterLimit M Set the miter limit in the graphics state (see “Miter Limit” on page 153).
 PdfResult PdfOp_M(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fVarStack.pop();
-    //double miterLimit = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
+    pdfContext->fObjectStack.pop();
+    //double miterLimit = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //dashArray dashPhase d Set the line dash pattern in the graphics state (see “Line Dash Pattern” on
 //page 155).
 PdfResult PdfOp_d(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fVarStack.pop();
-    pdfContext->fVarStack.pop();
+    pdfContext->fObjectStack.pop();
+    pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //intent ri (PDF 1.1) Set the color rendering intent in the graphics state (see “Rendering Intents” on page 197).
 PdfResult PdfOp_ri(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fVarStack.pop();
+    pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //flatness i Set the flatness tolerance in the graphics state (see Section 6.5.1, “Flatness
 //Tolerance”). flatness is a number in the range 0 to 100; a value of 0 speci-
 //fies the output device’s default flatness tolerance.
 PdfResult PdfOp_i(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fVarStack.pop();
+    pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //dictName gs (PDF 1.2) Set the specified parameters in the graphics state. dictName is
 //the name of a graphics state parameter dictionary in the ExtGState subdictionary of the current resource dictionary (see the next section).
 PdfResult PdfOp_gs(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    PdfName name = pdfContext->fVarStack.top().GetName();    pdfContext->fVarStack.pop();
+    std::string name = pdfContext->fObjectStack.top()->asName()->value();    pdfContext->fObjectStack.pop();
 
 #ifdef PDF_TRACE
     std::string str;
 #endif
 
-    const PdfObject* resources = pdfContext->fGraphicsState.fResources.podofo();
-
-    if (resources == NULL) {
-#ifdef PDF_TRACE
-        printf("WARNING: No Resources for a page with 'gs' operator!\n");
-#endif
-        return kIgnoreError_PdfResult;
-    }
-
-#ifdef PDF_TRACE
-    resources->ToString(str);
-    printf("Print gs Page Resources: %s\n", str.c_str());
-#endif
-
-    if (!resources->IsDictionary()) {
-#ifdef PDF_TRACE
-        printf("Resources is not a dictionary!\n");
-#endif
-        return kIgnoreError_PdfResult;
-    }
-
-    const PdfDictionary& resourceDict = resources->GetDictionary();
     //Next, get the ExtGState Dictionary from the Resource Dictionary:
-    const PdfObject* extGStateDictionary = resolveReferenceObject(pdfContext->fPdfDoc,
-                                                                resourceDict.GetKey("ExtGState"));
+    const SkPdfDictionary* extGStateDictionary = pdfContext->fGraphicsState.fResources->ExtGState();
 
     if (extGStateDictionary == NULL) {
 #ifdef PDF_TRACE
         printf("ExtGState is NULL!\n");
 #endif
         return kIgnoreError_PdfResult;
     }
 
-    if (!extGStateDictionary->IsDictionary()) {
-#ifdef PDF_TRACE
-        printf("extGStateDictionary is not a dictionary!\n");
-#endif
-        return kIgnoreError_PdfResult;
-    }
-
-    const PdfObject* value =
-            resolveReferenceObject(pdfContext->fPdfDoc,
-                                   extGStateDictionary->GetDictionary().GetKey(name));
-
-    if (value == NULL) {
-#ifdef PDF_TRACE
-        printf("Named object not found!\n");
-#endif
-        return kIgnoreError_PdfResult;
-    }
+    SkPdfObject value = extGStateDictionary->get(name.c_str());
 
 #ifdef PDF_TRACE
-    value->ToString(str);
-    printf("gs object value: %s\n", str.c_str());
+//    value->ToString(str);
+//    printf("gs object value: %s\n", str.c_str());
 #endif
 
-    SkPdfGraphicsStateDictionary gs(pdfContext->fPdfDoc, value);
+    SkPdfGraphicsStateDictionary* gs = NULL;
+    PodofoMapper::map(value, &gs);
 
     // TODO(edisonn): now load all those properties in graphic state.
 
     return kNYI_PdfResult;
 }
 
 //charSpace Tc Set the character spacing, Tc
 //, to charSpace, which is a number expressed in unscaled text space units. Character spacing is used by the Tj, TJ, and ' operators.
 //Initial value: 0.
 PdfResult PdfOp_Tc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    double charSpace = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
+    double charSpace = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
     pdfContext->fGraphicsState.fCharSpace = charSpace;
 
     return kOK_PdfResult;
 }
 
 //wordSpace Tw Set the word spacing, T
 //w
 //, to wordSpace, which is a number expressed in unscaled
 //text space units. Word spacing is used by the Tj, TJ, and ' operators. Initial
 //value: 0.
 PdfResult PdfOp_Tw(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    double wordSpace = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
+    double wordSpace = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
     pdfContext->fGraphicsState.fWordSpace = wordSpace;
 
     return kOK_PdfResult;
 }
 
 //scale Tz Set the horizontal scaling, Th
 //, to (scale ˜ 100). scale is a number specifying the
 //percentage of the normal width. Initial value: 100 (normal width).
 PdfResult PdfOp_Tz(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    double scale = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
+    double scale = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //render Tr Set the text rendering mode, T
 //mode, to render, which is an integer. Initial value: 0.
 PdfResult PdfOp_Tr(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    double render = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
+    double render = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //rise Ts Set the text rise, Trise, to rise, which is a number expressed in unscaled text space
 //units. Initial value: 0.
 PdfResult PdfOp_Ts(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    double rise = pdfContext->fVarStack.top().GetReal();     pdfContext->fVarStack.pop();
+    double rise = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //wx wy d0
 PdfResult PdfOp_d0(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fVarStack.pop();
-    pdfContext->fVarStack.pop();
+    pdfContext->fObjectStack.pop();
+    pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //wx wy llx lly urx ury d1
 PdfResult PdfOp_d1(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fVarStack.pop();
-    pdfContext->fVarStack.pop();
-    pdfContext->fVarStack.pop();
-    pdfContext->fVarStack.pop();
-    pdfContext->fVarStack.pop();
-    pdfContext->fVarStack.pop();
+    pdfContext->fObjectStack.pop();
+    pdfContext->fObjectStack.pop();
+    pdfContext->fObjectStack.pop();
+    pdfContext->fObjectStack.pop();
+    pdfContext->fObjectStack.pop();
+    pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //name sh
 PdfResult PdfOp_sh(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fVarStack.pop();
+    pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //name Do
 PdfResult PdfOp_Do(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    PdfName name = pdfContext->fVarStack.top().GetName();    pdfContext->fVarStack.pop();
+    std::string name = pdfContext->fObjectStack.top()->asName()->value();    pdfContext->fObjectStack.pop();
 
-    const PdfObject* resources = pdfContext->fGraphicsState.fResources.podofo();
+    SkPdfDictionary* xObject =  pdfContext->fGraphicsState.fResources->XObject();
 
-    if (resources == NULL) {
-#ifdef PDF_TRACE
-        printf("WARNING: No Resources for a page with 'Do' operator!s\n");
-#endif
-        return kIgnoreError_PdfResult;
-    }
-
-#ifdef PDF_TRACE
-    std::string str;
-    resources->ToString(str);
-    printf("Print Do Page Resources: %s\n", str.c_str());
-#endif
-
-    if (!resources->IsDictionary()) {
-#ifdef PDF_TRACE
-        printf("Resources is not a dictionary!\n");
-#endif
-        return kIgnoreError_PdfResult;
-    }
-
-    const PdfDictionary& resourceDict = resources->GetDictionary();
-    //Next, get the XObject Dictionary from the Resource Dictionary:
-    const PdfObject* xObjectDictionary = resolveReferenceObject(pdfContext->fPdfDoc,
-                                                                resourceDict.GetKey("XObject"));
-
-    if (xObjectDictionary == NULL) {
+    if (xObject == NULL) {
 #ifdef PDF_TRACE
         printf("XObject is NULL!\n");
 #endif
         return kIgnoreError_PdfResult;
     }
 
-    if (!xObjectDictionary->IsDictionary()) {
-#ifdef PDF_TRACE
-        printf("xObjectDictionary is not a dictionary!\n");
-#endif
-        return kIgnoreError_PdfResult;
-    }
-
-    const PdfObject* value =
-            resolveReferenceObject(pdfContext->fPdfDoc,
-                                   xObjectDictionary->GetDictionary().GetKey(name));
-
-    if (value == NULL) {
-#ifdef PDF_TRACE
-        printf("Named object not found!\n");
-#endif
-        return kIgnoreError_PdfResult;
-    }
+    SkPdfObject value = xObject->get(name.c_str());
 
 #ifdef PDF_TRACE
-    value->ToString(str);
-    printf("Do object value: %s\n", str.c_str());
+//    value->ToString(str);
+//    printf("Do object value: %s\n", str.c_str());
 #endif
 
-    return doXObject(pdfContext, canvas, *value);
+    return doXObject(pdfContext, canvas, value);
 }
 
-
 //tag MP Designate a marked-content point. tag is a name object indicating the role or
 //significance of the point.
 PdfResult PdfOp_MP(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fVarStack.pop();
+    pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //tag properties DP Designate a marked-content point with an associated property list. tag is a
 //name object indicating the role or significance of the point; properties is
 //either an inline dictionary containing the property list or a name object
 //associated with it in the Properties subdictionary of the current resource
 //dictionary (see Section 9.5.1, “Property Lists”).
 PdfResult PdfOp_DP(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fVarStack.pop();
-    pdfContext->fVarStack.pop();
+    pdfContext->fObjectStack.pop();
+    pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //tag BMC Begin a marked-content sequence terminated by a balancing EMC operator.
 //tag is a name object indicating the role or significance of the sequence.
 PdfResult PdfOp_BMC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fVarStack.pop();
+    pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //tag properties BDC Begin a marked-content sequence with an associated property list, terminated
 //by a balancing EMCoperator. tag is a name object indicating the role or significance of the sequence; propertiesis either an inline dictionary containing the
 //property list or a name object associated with it in the Properties subdictionary of the current resource dictionary (see Section 9.5.1, “Property Lists”).
 PdfResult PdfOp_BDC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fVarStack.pop();
-    pdfContext->fVarStack.pop();
+    pdfContext->fObjectStack.pop();
+    pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //— EMC End a marked-content sequence begun by a BMC or BDC operator.
 PdfResult PdfOp_EMC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return kNYI_PdfResult;
 }
 
 void initPdfOperatorRenderes() {
@@ skipping 98 matching lines @@
     std::map<std::string, int>::iterator iter;
 
     for (int i = 0 ; i < kCount_PdfResult; i++) {
         for (iter = gRenderStats[i].begin(); iter != gRenderStats[i].end(); ++iter) {
             printf("%s: %s -> count %i\n", gRenderStatsNames[i], iter->first.c_str(), iter->second);
         }
     }
 }
 
 PdfResult PdfMainLooper::consumeToken(PdfToken& token) {
-    if( token.eType == ePdfContentsType_Keyword )
+    if (token.fType == kKeyword_TokenType)
     {
         // TODO(edisonn): log trace flag (verbose, error, info, warning, ...)
 #ifdef PDF_TRACE
-        printf("KEYWORD: %s\n", token.pszToken);
+        printf("KEYWORD: %s\n", token.fKeyword);
 #endif
-        PdfOperatorRenderer pdfOperatorRenderer = gPdfOps[token.pszToken];
+        PdfOperatorRenderer pdfOperatorRenderer = gPdfOps[token.fKeyword];
         if (pdfOperatorRenderer) {
             // caller, main work is done by pdfOperatorRenderer(...)
             PdfTokenLooper* childLooper = NULL;
-            gRenderStats[pdfOperatorRenderer(fPdfContext, fCanvas, &childLooper)][token.pszToken]++;
+            gRenderStats[pdfOperatorRenderer(fPdfContext, fCanvas, &childLooper)][token.fKeyword]++;
 
             if (childLooper) {
                 childLooper->setUp(this);
                 childLooper->loop();
                 delete childLooper;
             }
         } else {
-            gRenderStats[kUnsupported_PdfResult][token.pszToken]++;
+            gRenderStats[kUnsupported_PdfResult][token.fKeyword]++;
         }
     }
-    else if ( token.eType == ePdfContentsType_Variant )
+    else if (token.fType == kObject_TokenType)
     {
 #ifdef PDF_TRACE
         std::string _var;
-        token.var.ToString(_var);
+        token.fObject->podofo()->ToString(_var);
         printf("var: %s\n", _var.c_str());
 #endif
-        fPdfContext->fVarStack.push( token.var );
+        fPdfContext->fObjectStack.push( token.fObject );
     }
-    else if ( token.eType == ePdfContentsType_ImageData) {
+    else if ( token.fType == kImageData_TokenType) {
         // TODO(edisonn): implement inline image.
     }
     else {
         return kIgnoreError_PdfResult;
     }
     return kOK_PdfResult;
 }
 
 void PdfMainLooper::loop() {
     PdfToken token;
     while (readToken(fTokenizer, &token)) {
         consumeToken(token);
     }
 }
 
 PdfResult PdfInlineImageLooper::consumeToken(PdfToken& token) {
     //pdfContext.fInlineImage.fKeyValuePairs[key] = value;
     return kNYI_PdfResult;
 }
 
 void PdfInlineImageLooper::loop() {
     PdfToken token;
     while (readToken(fTokenizer, &token)) {
-        if (token.eType == ePdfContentsType_Keyword && strcmp(token.pszToken, "BX") == 0) {
+        if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") == 0) {
             PdfTokenLooper* looper = new PdfCompatibilitySectionLooper();
             looper->setUp(this);
             looper->loop();
         } else {
-            if (token.eType == ePdfContentsType_Keyword && strcmp(token.pszToken, "EI") == 0) {
+            if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "EI") == 0) {
                 done();
                 return;
             }
 
             consumeToken(token);
         }
     }
     // TODO(edisonn): report error/warning, EOF without EI.
 }
 
@@ skipping 20 matching lines @@
     return fParent->consumeToken(token);
 }
 
 void PdfCompatibilitySectionLooper::loop() {
     // TODO(edisonn): save stacks position, or create a new stack?
     // TODO(edisonn): what happens if we pop out more variables then when we started?
     // restore them? fail? We could create a new operands stack for every new BX/EX section,
     // pop-ing too much will not affect outside the section.
     PdfToken token;
     while (readToken(fTokenizer, &token)) {
-        if (token.eType == ePdfContentsType_Keyword && strcmp(token.pszToken, "BX") == 0) {
+        if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") == 0) {
             PdfTokenLooper* looper = new PdfCompatibilitySectionLooper();
             looper->setUp(this);
             looper->loop();
             delete looper;
         } else {
-            if (token.eType == ePdfContentsType_Keyword && strcmp(token.pszToken, "EX") == 0) break;
+            if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "EX") == 0) break;
             fParent->consumeToken(token);
         }
     }
     // TODO(edisonn): restore stack.
 }
 
 // TODO(edisonn): fix PoDoFo load ~/crashing/Shading.pdf
 // TODO(edisonn): Add API for Forms viewing and editing
 // e.g. SkBitmap getPage(int page);
 //      int formsCount();
 //      SkForm getForm(int formID); // SkForm(SkRect, .. other data)
 // TODO (edisonn): Add intend when loading pdf, for example: for viewing, parsing all content, ...
 // if we load the first page, and we zoom to fit to screen horizontally, then load only those
 // resources needed, so the preview is fast.
 // TODO (edisonn): hide parser/tokenizer behind and interface and a query language, and resolve
 // references automatically.
 class SkPdfViewer : public SkRefCnt {
 public:
 
   bool load(const SkString inputFileName, SkPicture* out) {
 
     initPdfOperatorRenderes();
 
     try
     {
         std::cout << "Init: " << inputFileName.c_str() << std::endl;
 
-        PdfMemDocument doc(inputFileName.c_str());
-        if( !doc.GetPageCount() )
+        SkPdfDoc doc(inputFileName.c_str());
+        if( !doc.pages() )
         {
             std::cout << "ERROR: Empty Document" << inputFileName.c_str() << std::endl;
             return false;
         } else {
 
-            for (int pn = 0; pn < doc.GetPageCount(); ++pn) {
-                PoDoFo::PdfPage* page = doc.GetPage(pn);
-                PdfRect rect = page->GetMediaBox();
+            for (int pn = 0; pn < doc.pages(); ++pn) {
+                SkPdfPageObjectDictionary* page = doc.page(pn);
+
+                // TODO(edisonn): implement inheritance properties as per PDF spec
+                //SkRect rect = page->MediaBox();
+                SkRect rect = doc.MediaBox(pn);
+
 #ifdef PDF_TRACE
-                printf("Page Width: %f, Page Height: %f\n", rect.GetWidth(), rect.GetHeight());
+                printf("Page Width: %f, Page Height: %f\n", SkScalarToDouble(rect.width()), SkScalarToDouble(rect.height()));
 #endif
 
                 // TODO(edisonn): page->GetCropBox(), page->GetTrimBox() ... how to use?
 
                 SkBitmap bitmap;
 #ifdef PDF_DEBUG_3X
-                setup_bitmap(&bitmap, 3*rect.GetWidth(), 3*rect.GetHeight());
+                setup_bitmap(&bitmap, 3 * (int)SkScalarToDouble(rect.width()), 3 * (int)SkScalarToDouble(rect.height()))
 #else
-                setup_bitmap(&bitmap, rect.GetWidth(), rect.GetHeight());
+                setup_bitmap(&bitmap, (int)SkScalarToDouble(rect.width()), (int)SkScalarToDouble(rect.height()));
 #endif
                 SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (bitmap)));
                 SkCanvas canvas(device);
 
+                SkPdfTokenizer tokenizer = doc.tokenizerOfPage(pn);
 
-                const char*      pszToken = NULL;
-                PdfVariant       var;
-                EPdfContentsType eType;
-
-                PdfContentsTokenizer tokenizer( page );
-
-                PdfContext pdfContext;
-                pdfContext.fPdfPage = page;
-                pdfContext.fPdfDoc = &doc;
+                PdfContext pdfContext(doc);
                 pdfContext.fOriginalMatrix = SkMatrix::I();
-                pdfContext.fGraphicsState.fResources = SkPdfResourceDictionary(pdfContext.fPdfDoc, resolveReferenceObject(pdfContext.fPdfDoc,
-                                                                                                                          pdfContext.fPdfPage->GetResources()));
+                pdfContext.fGraphicsState.fResources = NULL;
+                PodofoMapper::map(*page->Resources(), &pdfContext.fGraphicsState.fResources);
 
                 gPdfContext = &pdfContext;
                 gDumpBitmap = &bitmap;
                 gDumpCanvas = &canvas;
 
 
                 // TODO(edisonn): get matrix stuff right.
                 // TODO(edisonn): add DPI/scale/zoom.
                 SkScalar z = SkIntToScalar(0);
-                SkScalar w = SkDoubleToScalar(rect.GetWidth());
-                SkScalar h = SkDoubleToScalar(rect.GetHeight());
+                SkScalar w = rect.width();
+                SkScalar h = rect.height();
 
                 SkPoint pdfSpace[4] = {SkPoint::Make(z, z), SkPoint::Make(w, z), SkPoint::Make(w, h), SkPoint::Make(z, h)};
 //                SkPoint skiaSpace[4] = {SkPoint::Make(z, h), SkPoint::Make(w, h), SkPoint::Make(w, z), SkPoint::Make(z, z)};
 
                 // TODO(edisonn): add flag for this app to create sourunding buffer zone
                 // TODO(edisonn): add flagg for no clipping.
                 // Use larger image to make sure we do not draw anything outside of page
                 // could be used in tests.
 
 #ifdef PDF_DEBUG_3X
@@ skipping 17 matching lines @@
                 pdfContext.fGraphicsState.fMatrix = pdfContext.fOriginalMatrix;
                 pdfContext.fGraphicsState.fMatrixTm = pdfContext.fGraphicsState.fMatrix;
                 pdfContext.fGraphicsState.fMatrixTlm = pdfContext.fGraphicsState.fMatrix;
 
                 canvas.setMatrix(pdfContext.fOriginalMatrix);
 
 #ifndef PDF_DEBUG_NO_PAGE_CLIPING
                 canvas.clipRect(SkRect::MakeXYWH(z, z, w, h), SkRegion::kIntersect_Op, true);
 #endif
 
-                PdfMainLooper looper(NULL, &tokenizer, &pdfContext, &canvas);
+                PdfMainLooper looper(NULL, tokenizer, &pdfContext, &canvas);
                 looper.loop();
 
                 canvas.flush();
 
                 SkString out;
                 out.appendf("%s-%i.png", inputFileName.c_str(), pn);
                 SkImageEncoder::EncodeFile(out.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100);
             }
             return true;
         }
@@ skipping 215 matching lines @@
     }
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif