few steps in the direction of to encapsulating podofo, so the client is not aware podofo is used.

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"
@@ skipping 43 matching lines @@
                           const char* abr,
                           std::string* data);
 
 class SkPdfDictionary;
 bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc,
                               const PdfDictionary& dict,
                               const char* key,
                               const char* abr,
                               SkPdfDictionary** data);
 
+template <typename T>
+bool DictionaryFromDictionary2(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        T** data);
+
 class SkPdfObject;
 bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfObject** data);
 
 
 #include "pdf_auto_gen.h"
 
 /*
- * TODO(edisonn): ASAP so skp -> pdf -> png looks greap
- * - load gs/ especially smask and already known prop
- * - use transparency (I think ca and CA ops)
+ * TODO(edisonn):
+ * - encapsulate podofo in the pdf api so the skpdf does not know anything about podofo
+ * - ASAP so skp -> pdf -> png looks great
+ * - load gs/ especially smask and already known prop (skp)
+ * - use transparency (I think ca and CA ops) (skp)
+ * - all font types
+ * - word spacing
  * - load font for baidu.pdf
  * - load font for youtube.pdf
 */
 
 //#define PDF_TRACE
 //#define PDF_TRACE_DIFF_IN_PNG
 //#define PDF_DEBUG_NO_CLIPING
 //#define PDF_DEBUG_NO_PAGE_CLIPING
 //#define PDF_DEBUG_3X
 
@@ skipping 105 matching lines @@
     SkPath              fClipPath;
 
     PdfColorOperator    fStroking;
     PdfColorOperator    fNonStroking;
 
     double              fLineWidth;
     double              fTextLeading;
     double              fWordSpace;
     double              fCharSpace;
 
-    const PdfObject*    fObjectWithResources;
+    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;
-        fObjectWithResources = NULL;
         fHasClipPathToApply = false;
     }
 };
 
 // TODO(edisonn): better class design.
 struct PdfInlineImage {
     std::map<std::string, std::string> fKeyValuePairs;
     std::string fImageData;
 
 };
@@ skipping 674 matching lines @@
                               const PdfDictionary& dict,
                               const char* key,
                               SkPdfDictionary** data) {
     const PdfObject* value = resolveReferenceObject(pdfDoc,
                                               dict.GetKey(PdfName(key)),
                                               true);
     if (value == NULL || !value->IsDictionary()) {
         return false;
     }
 
-    return PodofoMapper::mapDictionary(*pdfDoc, *value, (SkPdfObject**)data);
+    return PodofoMapper::map(*pdfDoc, *value, (SkPdfObject**)data);
 }
 
 bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfDictionary** data) {
     if (DictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
     if (abr == NULL || *abr == '\0') return false;
     return DictionaryFromDictionary(pdfDoc, dict, abr, data);
 }
 
+template <typename T>
+bool DictionaryFromDictionary2(const PdfMemDocument* pdfDoc,
+                              const PdfDictionary& dict,
+                              const char* key,
+                              SkPdfDictionary** data) {
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)),
+                                              true);
+    if (value == NULL || !value->IsDictionary()) {
+        return false;
+    }
+
+    return PodofoMapper::map(*pdfDoc, *value, (T**)data);
+}
+
+template <typename T>
+bool DictionaryFromDictionary2(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        T** data) {
+    if (DictionaryFromDictionary2<T>(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return DictionaryFromDictionary2<T>(pdfDoc, dict, abr, data);
+}
+
 bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
                           const PdfDictionary& dict,
                           const char* key,
                           SkPdfObject** data) {
     const PdfObject* value = resolveReferenceObject(pdfDoc,
                                               dict.GetKey(PdfName(key)),
                                               true);
     if (value == NULL) {
         return false;
     }
-    return PodofoMapper::mapObject(*pdfDoc, *value, data);
+    return PodofoMapper::map(*pdfDoc, *value, data);
 }
 
 bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfObject** data) {
     if (ObjectFromDictionary(pdfDoc, dict, key, data)) return true;
     if (abr == NULL || *abr == '\0') return false;
     return ObjectFromDictionary(pdfDoc, dict, abr, data);
 }
 
 
+
 // TODO(edisonn): perf!!!
 
 static SkColorTable* getGrayColortable() {
     static SkColorTable* grayColortable = NULL;
     if (grayColortable == NULL) {
         SkPMColor* colors = new SkPMColor[256];
         for (int i = 0 ; i < 256; i++) {
             colors[i] = SkPreMultiplyARGB(255, i, i, i);
         }
         grayColortable = new SkColorTable(colors, 256);
@@ skipping 287 matching lines @@
         array[i] = elem->GetReal();
     }
 
     *rect = SkRect::MakeLTRB(SkDoubleToScalar(array[0]),
                              SkDoubleToScalar(array[1]),
                              SkDoubleToScalar(array[2]),
                              SkDoubleToScalar(array[3]));
     return true;
 }
 
-PdfResult doXObject_Form(PdfContext* pdfContext, SkCanvas* canvas, const PdfObject& obj) {
-    if (!obj.HasStream() || obj.GetStream() == NULL || obj.GetStream()->GetLength() == 0) {
+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();
 
-    pdfContext->fGraphicsState.fObjectWithResources = &obj;
+    if (get(skobj, "Resources")) {
+        SkPdfResourceDictionary* res = NULL;
+
+        PodofoMapper::map(*get(skobj, "Resources"), &res);
+
+        if (res) {
+            pdfContext->fGraphicsState.fResources = *res;
+            delete res;
+        }
+    }
 
     SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Current matrix");
 
     SkMatrix matrix;
-    if (SkMatrixFromDictionary(pdfContext, obj.GetDictionary(), "Matrix", &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, obj.GetDictionary(), "BBox", &bbox)) {
+    if (SkRectFromDictionary(pdfContext, 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 {
-        obj.GetStream()->GetFilteredCopy(&uncompressedStream, &uncompressedStreamLength);
+        skobj->podofo()->GetStream()->GetFilteredCopy(&uncompressedStream, &uncompressedStreamLength);
         if (uncompressedStream != NULL && uncompressedStreamLength != 0) {
             PdfContentsTokenizer tokenizer(uncompressedStream, uncompressedStreamLength);
             PdfMainLooper looper(NULL, &tokenizer, pdfContext, canvas);
             looper.loop();
         }
         free(uncompressedStream);
     } catch (PdfError& e) {
         ret = kIgnoreError_PdfResult;
     }
 
@@ skipping 30 matching lines @@
 
 PdfResult doXObject(PdfContext* pdfContext, SkCanvas* canvas, const PdfObject& obj) {
     if (CheckRecursiveRendering::IsInRendering(obj)) {
         // Oops, corrupt PDF!
         return kIgnoreError_PdfResult;
     }
 
     CheckRecursiveRendering checkRecursion(obj);
 
     // TODO(edisonn): check type
-    SkPdfObject* skobj = NULL;
-    if (!PodofoMapper::mapXObjectDictionary(*pdfContext->fPdfDoc, obj, &skobj)) return kIgnoreError_PdfResult;
+    SkPdfXObjectDictionary* skobj = NULL;
+    if (!PodofoMapper::map(*pdfContext->fPdfDoc, obj, &skobj)) return kIgnoreError_PdfResult;
 
     if (!skobj || !skobj->valid()) return kIgnoreError_PdfResult;
 
     PdfResult ret = kIgnoreError_PdfResult;
     switch (skobj->getType())
     {
         case kObjectDictionaryXObjectDictionaryImageDictionary_SkPdfObjectType:
             ret = doXObject_Image(pdfContext, canvas, skobj->asImageDictionary());
             break;
         case kObjectDictionaryXObjectDictionaryType1FormDictionary_SkPdfObjectType:
-            ret = doXObject_Form(pdfContext, canvas, obj);//skobj->asType1FormDictionary());
+            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) {
@@ skipping 725 matching lines @@
 
 //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();
 
 #ifdef PDF_TRACE
     std::string str;
 #endif
 
-    const PdfDictionary& pageDict = pdfContext->fGraphicsState.fObjectWithResources->GetDictionary();
-
-#ifdef PDF_TRACE
-    pdfContext->fGraphicsState.fObjectWithResources->ToString(str);
-    printf("Print Object with resources: %s\n", str.c_str());
-#endif
-
-    const PdfObject* resources = resolveReferenceObject(pdfContext->fPdfDoc,
-                                                        pageDict.GetKey("Resources"));
+    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);
@@ skipping 35 matching lines @@
         printf("Named object not found!\n");
 #endif
         return kIgnoreError_PdfResult;
     }
 
 #ifdef PDF_TRACE
     value->ToString(str);
     printf("gs object value: %s\n", str.c_str());
 #endif
 
+    SkPdfGraphicsStateDictionary gs(pdfContext->fPdfDoc, value);
+    printf("caCA %f %f\n", gs.ca(), gs.CA());
+
     // 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();
@@ skipping 63 matching lines @@
 PdfResult PdfOp_sh(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     pdfContext->fVarStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //name Do
 PdfResult PdfOp_Do(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     PdfName name = pdfContext->fVarStack.top().GetName();    pdfContext->fVarStack.pop();
 
-    const PdfDictionary& pageDict = pdfContext->fGraphicsState.fObjectWithResources->GetDictionary();
-    const PdfObject* resources = resolveReferenceObject(pdfContext->fPdfDoc,
-                                                        pageDict.GetKey("Resources"));
+    const PdfObject* resources = pdfContext->fGraphicsState.fResources.podofo();
 
     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;
@@ skipping 362 matching lines @@
                 const char*      pszToken = NULL;
                 PdfVariant       var;
                 EPdfContentsType eType;
 
                 PdfContentsTokenizer tokenizer( page );
 
                 PdfContext pdfContext;
                 pdfContext.fPdfPage = page;
                 pdfContext.fPdfDoc = &doc;
                 pdfContext.fOriginalMatrix = SkMatrix::I();
-                pdfContext.fGraphicsState.fObjectWithResources = pdfContext.fPdfPage->GetObject();
+                pdfContext.fGraphicsState.fResources = SkPdfResourceDictionary(pdfContext.fPdfDoc, resolveReferenceObject(pdfContext.fPdfDoc,
+                                                                                                                          pdfContext.fPdfPage->GetResources()));
 
                 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());
@@ skipping 264 matching lines @@
     }
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif