diff --git a/experimental/PdfViewer/SkPdfBasics.h b/experimental/PdfViewer/SkPdfBasics.h
index 126e63d..27e21f1 100644
--- a/experimental/PdfViewer/SkPdfBasics.h
+++ b/experimental/PdfViewer/SkPdfBasics.h
@@ -4,6 +4,9 @@
 #include "podofo.h"
 using namespace PoDoFo;
 
+#include "SkCanvas.h"
+#include "SkPaint.h"
+
 #include <iostream>
 #include <cstdio>
 #include <stack>
@@ -16,6 +19,8 @@
 
 class SkPdfFont;
 class SkPdfDoc;
+class SkPdfObject;
+class SkPdfResourceDictionary;
 
 // TODO(edisonn): better class design.
 struct PdfColorOperator {
diff --git a/experimental/PdfViewer/SkPdfFont.cpp b/experimental/PdfViewer/SkPdfFont.cpp
index a4d70ab..4fac286 100644
--- a/experimental/PdfViewer/SkPdfFont.cpp
+++ b/experimental/PdfViewer/SkPdfFont.cpp
@@ -1,4 +1,5 @@
 #include "SkPdfFont.h"
+#include "SkPdfParser.h"
 
 std::map<std::string, SkPdfStandardFontEntry>& getStandardFonts() {
     static std::map<std::string, SkPdfStandardFontEntry> gPdfStandardFonts;
diff --git a/experimental/PdfViewer/SkPdfFont.h b/experimental/PdfViewer/SkPdfFont.h
index a3f0d36..85b9fc4 100644
--- a/experimental/PdfViewer/SkPdfFont.h
+++ b/experimental/PdfViewer/SkPdfFont.h
@@ -7,6 +7,7 @@
 #include <map>
 #include <string>
 
+#include "SkTypeface.h"
 #include "SkUtils.h"
 #include "SkPdfBasics.h"
 #include "SkPdfUtils.h"
diff --git a/experimental/PdfViewer/SkPdfParser.cpp b/experimental/PdfViewer/SkPdfParser.cpp
new file mode 100644
index 0000000..6d5ccae
--- /dev/null
+++ b/experimental/PdfViewer/SkPdfParser.cpp
@@ -0,0 +1,2352 @@
+/*
+ * 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 "SkForceLinking.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;
+
+
+__SK_FORCE_IMAGE_DECODER_LINKING;
+
+// TODO(edisonn): tool, show what objects were read at least, show the ones not even read
+// keep for each object pos in file
+// plug in for VS? syntax coloring, show selected object ... from the text, or from rendered x,y
+
+// TODO(edisonn): security - validate all the user input, all pdf!
+
+
+#include "SkPdfHeaders_autogen.h"
+#include "SkPdfPodofoMapper_autogen.h"
+#include "SkPdfParser.h"
+
+#include "SkPdfBasics.h"
+#include "SkPdfUtils.h"
+
+#include "SkPdfFont.h"
+
+bool skpdfmap(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out) {
+    return mapObject(podofoDoc, podofoObj, out);
+}
+
+
+/*
+ * TODO(edisonn):
+ * - all font types and all ppdf font features
+ *      - word spacing
+ *      - load font for baidu.pdf
+ *      - load font for youtube.pdf
+ *      - parser for pdf from the definition already available in pdfspec_autogen.py
+ *      - all docs from ~/work
+ * - encapsulate podofo in the pdf api so the skpdf does not know anything about podofo ... in progress
+ * - load gs/ especially smask and already known prop (skp) ... in progress
+ * - wrapper on classes for customizations? e.g.
+ * SkPdfPageObjectVanila - has only the basic loaders/getters
+ * SkPdfPageObject : public SkPdfPageObjectVanila, extends, and I can add customizations here
+ * need to find a nice object model for all this with constructors and factories
+ * - deal with inheritable automatically ?
+ * - deal with specific type in spec directly, add all dictionary types to known types
+*/
+
+using namespace std;
+using namespace PoDoFo;
+
+// Utilities
+static void setup_bitmap(SkBitmap* bitmap, int width, int height, SkColor color = SK_ColorWHITE) {
+    bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height);
+
+    bitmap->allocPixels();
+    bitmap->eraseColor(color);
+}
+
+// TODO(edisonn): synonyms? DeviceRGB and RGB ...
+int GetColorSpaceComponents(const std::string& colorSpace) {
+    if (colorSpace == "DeviceCMYK") {
+        return 4;
+    } else if (colorSpace == "DeviceGray" ||
+            colorSpace == "CalGray" ||
+            colorSpace == "Indexed") {
+        return 1;
+    } else if (colorSpace == "DeviceRGB" ||
+            colorSpace == "CalRGB" ||
+            colorSpace == "Lab") {
+        return 3;
+    } else {
+        return 0;
+    }
+}
+
+const PdfObject* resolveReferenceObject(const PdfMemDocument* pdfDoc,
+                                  const PdfObject* obj,
+                                  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];
+        }
+    }
+
+    return obj;
+}
+
+static SkMatrix SkMatrixFromPdfMatrix(double array[6]) {
+    SkMatrix matrix;
+    matrix.setAll(SkDoubleToScalar(array[0]),
+                  SkDoubleToScalar(array[2]),
+                  SkDoubleToScalar(array[4]),
+                  SkDoubleToScalar(array[1]),
+                  SkDoubleToScalar(array[3]),
+                  SkDoubleToScalar(array[5]),
+                  SkDoubleToScalar(0),
+                  SkDoubleToScalar(0),
+                  SkDoubleToScalar(1));
+
+    return matrix;
+}
+
+SkMatrix SkMatrixFromPdfArray(SkPdfArray* pdfArray) {
+    double array[6];
+
+    // TODO(edisonn): security issue, ret if size() != 6
+    for (int i = 0; i < 6; i++) {
+        const PdfObject* elem = resolveReferenceObject(pdfArray->doc(), (*pdfArray)[i]->podofo());
+        if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
+            return SkMatrix::I();  // TODO(edisonn): report issue
+        }
+        array[i] = elem->GetReal();
+    }
+
+    return SkMatrixFromPdfMatrix(array);
+}
+
+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,";
+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(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;
+        setup_bitmap(&bitmap, gDumpBitmap->width(), gDumpBitmap->height());
+
+        memcpy(bitmap.getPixels(), gDumpBitmap->getPixels(), gDumpBitmap->getSize());
+
+        SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (bitmap)));
+        SkCanvas canvas(device);
+
+        // draw context stuff here
+        SkPaint blueBorder;
+        blueBorder.setColor(SK_ColorBLUE);
+        blueBorder.setStyle(SkPaint::kStroke_Style);
+        blueBorder.setTextSize(SkDoubleToScalar(20));
+
+        SkString str;
+
+        const SkClipStack* clipStack = gDumpCanvas->getClipStack();
+        if (clipStack) {
+            SkClipStack::Iter iter(*clipStack, SkClipStack::Iter::kBottom_IterStart);
+            const SkClipStack::Element* elem;
+            double y = 0;
+            int total = 0;
+            while (elem = iter.next()) {
+                total++;
+                y += 30;
+
+                switch (elem->getType()) {
+                    case SkClipStack::Element::kRect_Type:
+                        canvas.drawRect(elem->getRect(), blueBorder);
+                        canvas.drawText("Rect Clip", strlen("Rect Clip"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
+                        break;
+                    case SkClipStack::Element::kPath_Type:
+                        canvas.drawPath(elem->getPath(), blueBorder);
+                        canvas.drawText("Path Clip", strlen("Path Clip"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
+                        break;
+                    case SkClipStack::Element::kEmpty_Type:
+                        canvas.drawText("Empty Clip!!!", strlen("Empty Clip!!!"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
+                        break;
+                    default:
+                        canvas.drawText("Unkown Clip!!!", strlen("Unkown Clip!!!"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
+                        break;
+                }
+            }
+
+            y += 30;
+            str.printf("Number of clips in stack: %i", total);
+            canvas.drawText(str.c_str(), str.size(), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
+        }
+
+        const SkRegion& clipRegion = gDumpCanvas->getTotalClip();
+        SkPath clipPath;
+        if (clipRegion.getBoundaryPath(&clipPath)) {
+            SkPaint redBorder;
+            redBorder.setColor(SK_ColorRED);
+            redBorder.setStyle(SkPaint::kStroke_Style);
+            canvas.drawPath(clipPath, redBorder);
+        }
+
+        canvas.flush();
+
+        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->fType == kKeyword_TokenType) {
+        strcpy(gLastKeyword, token->fKeyword);
+        gLastOpKeyword = gReadOp;
+    } else {
+        strcpy(gLastKeyword, "");
+    }
+#endif
+
+    return ret;
+}
+
+
+
+typedef PdfResult (*PdfOperatorRenderer)(PdfContext*, SkCanvas*, PdfTokenLooper**);
+
+map<std::string, PdfOperatorRenderer> gPdfOps;
+
+map<std::string, int> gRenderStats[kCount_PdfResult];
+
+char* gRenderStatsNames[kCount_PdfResult] = {
+    "Success",
+    "Partially implemented",
+    "Not yet implemented",
+    "Ignore Error",
+    "Error",
+    "Unsupported/Unknown"
+};
+
+static SkTypeface* SkTypefaceFromPdfFont(PdfFont* font) {
+    if (font == NULL) {
+        return SkTypeface::CreateFromName("Times New Roman", SkTypeface::kNormal);
+    }
+
+    PdfObject* fontObject = font->GetObject();
+
+    PdfObject* pBaseFont = NULL;
+    // TODO(edisonn): warning, PoDoFo has a bug in PdfFont constructor, does not call InitVars()
+    // for now fixed locally.
+    pBaseFont = fontObject->GetIndirectKey( "BaseFont" );
+    const char* pszBaseFontName = pBaseFont->GetName().GetName().c_str();
+
+#ifdef PDF_TRACE
+    std::string str;
+    fontObject->ToString(str);
+    printf("Base Font Name: %s\n", pszBaseFontName);
+    printf("Font Object Data: %s\n", str.c_str());
+#endif
+
+    SkTypeface* typeface = SkTypefaceFromPdfStandardFont(pszBaseFontName, font->IsBold(), font->IsItalic());
+
+    if (typeface != NULL) {
+        return typeface;
+    }
+
+    char name[1000];
+    // HACK
+    strncpy(name, pszBaseFontName, 1000);
+    char* comma = strstr(name, ",");
+    char* dash = strstr(name, "-");
+    if (comma) *comma = '\0';
+    if (dash) *dash = '\0';
+
+    typeface = SkTypeface::CreateFromName(
+                name,
+                SkTypeface::Style((font->IsBold() ? SkTypeface::kBold : 0) |
+                                  (font->IsItalic() ? SkTypeface::kItalic : 0)));
+
+    if (typeface != NULL) {
+#ifdef PDF_TRACE
+    printf("HACKED FONT found %s\n", name);
+#endif
+        return typeface;
+    }
+
+#ifdef PDF_TRACE
+    printf("FONT_NOT_FOUND %s\n", pszBaseFontName);
+#endif
+
+    // TODO(edisonn): Report Warning, NYI
+    return SkTypeface::CreateFromName(
+                "Times New Roman",
+                SkTypeface::Style((font->IsBold() ? SkTypeface::kBold : 0) |
+                                  (font->IsItalic() ? SkTypeface::kItalic : 0)));
+}
+
+PdfResult DrawText(PdfContext* pdfContext,
+                   const SkPdfObject* str,
+                   SkCanvas* canvas)
+{
+
+    SkPdfFont* skfont = pdfContext->fGraphicsState.fSkFont;
+    if (skfont == NULL) {
+        skfont = SkPdfFont::Default();
+    }
+
+    SkUnencodedText binary(str);
+
+    SkDecodedText decoded;
+
+    if (skfont->encoding() == NULL) {
+        // TODO(edisonn): report warning
+        return kNYI_PdfResult;
+    }
+
+    skfont->encoding()->decodeText(binary, &decoded);
+
+    SkPaint paint;
+    // TODO(edisonn): when should fCurFont->GetFontSize() used? When cur is fCurFontSize == 0?
+    // Or maybe just not call setTextSize at all?
+    if (pdfContext->fGraphicsState.fCurFontSize != 0) {
+        paint.setTextSize(SkDoubleToScalar(pdfContext->fGraphicsState.fCurFontSize));
+    }
+
+//    if (fCurFont && fCurFont->GetFontScale() != 0) {
+//        paint.setTextScaleX(SkFloatToScalar(fCurFont->GetFontScale() / 100.0));
+//    }
+
+    pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
+
+    canvas->save();
+
+#if 1
+    SkMatrix matrix = pdfContext->fGraphicsState.fMatrixTm;
+
+    SkPoint point1;
+    pdfContext->fGraphicsState.fMatrixTm.mapXY(SkIntToScalar(0), SkIntToScalar(0), &point1);
+
+    SkMatrix mirror;
+    mirror.setTranslate(0, -point1.y());
+    // TODO(edisonn): fix rotated text, and skewed too
+    mirror.postScale(SK_Scalar1, -SK_Scalar1);
+    // TODO(edisonn): post rotate, skew
+    mirror.postTranslate(0, point1.y());
+
+    matrix.postConcat(mirror);
+
+    canvas->setMatrix(matrix);
+
+    SkTraceMatrix(matrix, "mirrored");
+#endif
+
+    skfont->drawText(decoded, &paint, pdfContext, canvas, &pdfContext->fGraphicsState.fMatrixTm);
+    canvas->restore();
+
+    return kPartial_PdfResult;
+}
+
+// TODO(edisonn): create header files with declarations!
+PdfResult PdfOp_q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
+PdfResult PdfOp_Q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
+PdfResult PdfOp_Tw(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
+PdfResult PdfOp_Tc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
+
+// TODO(edisonn): deal with synonyms (/BPC == /BitsPerComponent), here or in GetKey?
+// Always pass long form in key, and have a map of long -> short key
+bool LongFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        long* data) {
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)));
+
+    if (value == NULL || !value->IsNumber()) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+
+    *data = value->GetNumber();
+    return true;
+}
+
+bool LongFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        long* data) {
+    if (LongFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return LongFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool DoubleFromDictionary(const PdfMemDocument* pdfDoc,
+                          const PdfDictionary& dict,
+                          const char* key,
+                          double* data) {
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)));
+
+    if (value == NULL || (!value->IsReal() && !value->IsNumber())) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+
+    *data = value->GetReal();
+    return true;
+}
+
+bool DoubleFromDictionary(const PdfMemDocument* pdfDoc,
+                          const PdfDictionary& dict,
+                          const char* key,
+                          const char* abr,
+                          double* data) {
+    if (DoubleFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return DoubleFromDictionary(pdfDoc, dict, abr, data);
+}
+
+
+bool BoolFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        bool* data) {
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)));
+
+    if (value == NULL || !value->IsBool()) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+
+    *data = value->GetBool();
+    return true;
+}
+
+bool BoolFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        bool* data) {
+    if (BoolFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return BoolFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool NameFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        std::string* data) {
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)),
+                                              true);
+    if (value == NULL || !value->IsName()) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+
+    *data = value->GetName().GetName();
+    return true;
+}
+
+bool NameFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        std::string* data) {
+    if (NameFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return NameFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool StringFromDictionary(const PdfMemDocument* pdfDoc,
+                          const PdfDictionary& dict,
+                          const char* key,
+                          std::string* data) {
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)),
+                                              true);
+    if (value == NULL || (!value->IsString() && !value->IsHexString())) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+
+    *data = value->GetString().GetString();
+    return true;
+}
+
+bool StringFromDictionary(const PdfMemDocument* pdfDoc,
+                          const PdfDictionary& dict,
+                          const char* key,
+                          const char* abr,
+                          std::string* data) {
+    if (StringFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return StringFromDictionary(pdfDoc, dict, abr, data);
+}
+
+/*
+bool ArrayFromDictionary(const PdfMemDocument* pdfDoc,
+                              const PdfDictionary& dict,
+                              const char* key,
+                              SkPdfArray** data) {
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)),
+                                              true);
+    if (value == NULL || !value->IsArray()) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+
+    return mapArray(*pdfDoc, *value, data);
+}
+
+
+bool ArrayFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        SkPdfArray** data) {
+    if (ArrayFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return ArrayFromDictionary(pdfDoc, dict, abr, data);
+}
+
+
+bool DictionaryFromDictionary(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;
+    }
+    if (data == NULL) {
+        return true;
+    }
+
+    return mapDictionary(*pdfDoc, *value, 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);
+}
+
+
+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;
+    }
+    if (data == NULL) {
+        return true;
+    }
+    return mapObject(*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);
+}
+
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc,
+                          const PdfDictionary& dict,
+                          const char* key,
+                          SkPdfStream** data) {
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)),
+                                              true);
+    if (value == NULL) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+    return mapStream(*pdfDoc, *value, data);
+}
+
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        SkPdfStream** data) {
+    if (StreamFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return StreamFromDictionary(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);
+    }
+    return grayColortable;
+}
+
+SkBitmap transferImageStreamToBitmap(unsigned char* uncompressedStream, pdf_long uncompressedStreamLength,
+                                     int width, int height, int bytesPerLine,
+                                     int bpc, const std::string& colorSpace,
+                                     bool transparencyMask) {
+    SkBitmap bitmap;
+
+    int components = GetColorSpaceComponents(colorSpace);
+//#define MAX_COMPONENTS 10
+
+    int bitsPerLine = width * components * bpc;
+    // TODO(edisonn): assume start of lines are aligned at 32 bits?
+    // Is there a faster way to load the uncompressed stream into a bitmap?
+
+    // minimal support for now
+    if ((colorSpace == "DeviceRGB" || colorSpace == "RGB") && bpc == 8) {
+        SkColor* uncompressedStreamArgb = (SkColor*)malloc(width * height * sizeof(SkColor));
+
+        for (int h = 0 ; h < height; h++) {
+            long i = width * (height - 1 - h);
+            for (int w = 0 ; w < width; w++) {
+                uncompressedStreamArgb[i] = SkColorSetRGB(uncompressedStream[3 * w],
+                                                          uncompressedStream[3 * w + 1],
+                                                          uncompressedStream[3 * w + 2]);
+                i++;
+            }
+            uncompressedStream += bytesPerLine;
+        }
+
+        bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
+        bitmap.setPixels(uncompressedStreamArgb);
+    }
+    else if ((colorSpace == "DeviceGray" || colorSpace == "Gray") && bpc == 8) {
+        unsigned char* uncompressedStreamA8 = (unsigned char*)malloc(width * height);
+
+        for (int h = 0 ; h < height; h++) {
+            long i = width * (height - 1 - h);
+            for (int w = 0 ; w < width; w++) {
+                uncompressedStreamA8[i] = transparencyMask ? 255 - uncompressedStream[w] :
+                                                             uncompressedStream[w];
+                i++;
+            }
+            uncompressedStream += bytesPerLine;
+        }
+
+        bitmap.setConfig(transparencyMask ? SkBitmap::kA8_Config : SkBitmap::kIndex8_Config,
+                         width, height);
+        bitmap.setPixels(uncompressedStreamA8, transparencyMask ? NULL : getGrayColortable());
+    }
+
+    // TODO(edisonn): Report Warning, NYI, or error
+    return bitmap;
+}
+
+bool transferImageStreamToARGB(unsigned char* uncompressedStream, pdf_long uncompressedStreamLength,
+                               int width, int bytesPerLine,
+                               int bpc, const std::string& colorSpace,
+                               SkColor** uncompressedStreamArgb,
+                               pdf_long* uncompressedStreamLengthInBytesArgb) {
+    int components = GetColorSpaceComponents(colorSpace);
+//#define MAX_COMPONENTS 10
+
+    int bitsPerLine = width * components * bpc;
+    // TODO(edisonn): assume start of lines are aligned at 32 bits?
+    int height = uncompressedStreamLength / bytesPerLine;
+
+    // minimal support for now
+    if ((colorSpace == "DeviceRGB" || colorSpace == "RGB") && bpc == 8) {
+        *uncompressedStreamLengthInBytesArgb = width * height * 4;
+        *uncompressedStreamArgb = (SkColor*)malloc(*uncompressedStreamLengthInBytesArgb);
+
+        for (int h = 0 ; h < height; h++) {
+            long i = width * (height - 1 - h);
+            for (int w = 0 ; w < width; w++) {
+                (*uncompressedStreamArgb)[i] = SkColorSetRGB(uncompressedStream[3 * w],
+                                                             uncompressedStream[3 * w + 1],
+                                                             uncompressedStream[3 * w + 2]);
+                i++;
+            }
+            uncompressedStream += bytesPerLine;
+        }
+        return true;
+    }
+
+    if ((colorSpace == "DeviceGray" || colorSpace == "Gray") && bpc == 8) {
+        *uncompressedStreamLengthInBytesArgb = width * height * 4;
+        *uncompressedStreamArgb = (SkColor*)malloc(*uncompressedStreamLengthInBytesArgb);
+
+        for (int h = 0 ; h < height; h++) {
+            long i = width * (height - 1 - h);
+            for (int w = 0 ; w < width; w++) {
+                (*uncompressedStreamArgb)[i] = SkColorSetRGB(uncompressedStream[w],
+                                                             uncompressedStream[w],
+                                                             uncompressedStream[w]);
+                i++;
+            }
+            uncompressedStream += bytesPerLine;
+        }
+        return true;
+    }
+
+    return false;
+}
+
+// utils
+
+// TODO(edisonn): add cache, or put the bitmap property directly on the PdfObject
+// TODO(edisonn): deal with colorSpaces, we could add them to SkBitmap::Config
+// TODO(edisonn): preserve A1 format that skia knows, + fast convert from 111, 222, 444 to closest
+// skia format, through a table
+
+// this functions returns the image, it does not look at the smask.
+
+SkBitmap getImageFromObject(PdfContext* pdfContext, const SkPdfImageDictionary* image, bool transparencyMask) {
+    if (image == NULL || !image->valid()) {
+        // TODO(edisonn): report warning to be used in testing.
+        return SkBitmap();
+    }
+
+    // TODO (edisonn): Fast Jpeg(DCTDecode) draw, or fast PNG(FlateDecode) draw ...
+//    PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
+//                                              obj.GetDictionary().GetKey(PdfName("Filter")));
+//    if (value && value->IsArray() && value->GetArray().GetSize() == 1) {
+//        value = resolveReferenceObject(pdfContext->fPdfDoc,
+//                                       &value->GetArray()[0]);
+//    }
+//    if (value && value->IsName() && value->GetName().GetName() == "DCTDecode") {
+//        SkStream stream = SkStream::
+//        SkImageDecoder::Factory()
+//    }
+
+    long bpc = image->BitsPerComponent();
+    long width = image->Width();
+    long height = image->Height();
+    std::string colorSpace = "DeviceRGB";
+
+    // TODO(edisonn): color space can be an array too!
+    if (image->isColorSpaceAName()) {
+        colorSpace = image->getColorSpaceAsName();
+    }
+
+/*
+    bool imageMask = image->imageMask();
+
+    if (imageMask) {
+        if (bpc != 0 && bpc != 1) {
+            // TODO(edisonn): report warning to be used in testing.
+            return SkBitmap();
+        }
+        bpc = 1;
+    }
+*/
+
+    const PdfObject* obj = image->podofo();
+
+    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);
+    } catch (PdfError& e) {
+        // TODO(edisonn): report warning to be used in testing.
+        return SkBitmap();
+    }
+
+    int bytesPerLine = uncompressedStreamLength / height;
+#ifdef PDF_TRACE
+    if (uncompressedStreamLength % height != 0) {
+        printf("Warning uncompressedStreamLength % height != 0 !!!\n");
+    }
+#endif
+
+    SkBitmap bitmap = transferImageStreamToBitmap(
+            (unsigned char*)uncompressedStream, uncompressedStreamLength,
+            width, height, bytesPerLine,
+            bpc, colorSpace,
+            transparencyMask);
+
+    free(uncompressedStream);
+
+    return bitmap;
+}
+
+SkBitmap getSmaskFromObject(PdfContext* pdfContext, const SkPdfImageDictionary* obj) {
+    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->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;
+    }
+
+    SkBitmap image = getImageFromObject(pdfContext, skpdfimage, false);
+    SkBitmap sMask = getSmaskFromObject(pdfContext, skpdfimage);
+
+    canvas->save();
+    canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
+    SkRect dst = SkRect::MakeXYWH(SkDoubleToScalar(0.0), SkDoubleToScalar(0.0), SkDoubleToScalar(1.0), SkDoubleToScalar(1.0));
+
+    if (sMask.empty()) {
+        canvas->drawBitmapRect(image, dst, NULL);
+    } else {
+        canvas->saveLayer(&dst, NULL);
+        canvas->drawBitmapRect(image, dst, NULL);
+        SkPaint xfer;
+        pdfContext->fGraphicsState.applyGraphicsState(&xfer, false);
+        xfer.setXfermodeMode(SkXfermode::kSrcOut_Mode); // SkXfermode::kSdtOut_Mode
+        canvas->drawBitmapRect(sMask, dst, &xfer);
+        canvas->restore();
+    }
+
+    canvas->restore();
+
+    return kPartial_PdfResult;
+}
+
+bool SkMatrixFromDictionary(const PdfMemDocument* pdfDoc,
+                            const PdfDictionary& dict,
+                            const char* key,
+                            SkMatrix** matrix) {
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                                    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(pdfDoc, &value->GetArray()[i]);
+        if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
+            return false;
+        }
+        array[i] = elem->GetReal();
+    }
+
+    *matrix = new SkMatrix();
+    **matrix = SkMatrixFromPdfMatrix(array);
+    return true;
+}
+
+bool SkMatrixFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        SkMatrix** data) {
+    if (SkMatrixFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return SkMatrixFromDictionary(pdfDoc, dict, abr, data);
+
+}
+
+bool SkRectFromDictionary(const PdfMemDocument* pdfDoc,
+                          const PdfDictionary& dict,
+                          const char* key,
+                          SkRect** rect) {
+    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(pdfDoc, &value->GetArray()[i]);
+        if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
+            return false;
+        }
+        array[i] = elem->GetReal();
+    }
+
+    *rect = new SkRect();
+    **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 (skobj->Resources()) {
+        pdfContext->fGraphicsState.fResources = skobj->Resources();
+    }
+
+    SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Current matrix");
+
+    if (skobj->Matrix()) {
+        pdfContext->fGraphicsState.fMatrix.preConcat(*skobj->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);
+
+    if (skobj->BBox()) {
+        canvas->clipRect(*skobj->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.
+
+    PdfResult ret = kPartial_PdfResult;
+    SkPdfTokenizer tokenizer(skobj);
+    PdfMainLooper looper(NULL, &tokenizer, pdfContext, canvas);
+    looper.loop();
+
+    // 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;
+}
+
+PdfResult doType3Char(PdfContext* pdfContext, SkCanvas* canvas, SkPdfObject* skobj, SkRect bBox, SkMatrix matrix, double textSize) {
+    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.fMatrixTm.preConcat(matrix);
+    pdfContext->fGraphicsState.fMatrixTm.preScale(SkDoubleToScalar(textSize), SkDoubleToScalar(textSize));
+
+    pdfContext->fGraphicsState.fMatrix = pdfContext->fGraphicsState.fMatrixTm;
+    pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrix;
+
+    SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Total matrix");
+
+    canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
+
+    SkRect rm = bBox;
+    pdfContext->fGraphicsState.fMatrix.mapRect(&rm);
+
+    SkTraceRect(rm, "bbox mapped");
+
+    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.
+
+    PdfResult ret = kPartial_PdfResult;
+    SkPdfTokenizer tokenizer(skobj);
+    PdfMainLooper looper(NULL, &tokenizer, pdfContext, canvas);
+    looper.loop();
+
+    // 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;
+}
+
+
+// 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 SkPdfObject& obj) {
+    if (CheckRecursiveRendering::IsInRendering(*obj.podofo())) {
+        // Oops, corrupt PDF!
+        return kIgnoreError_PdfResult;
+    }
+
+    CheckRecursiveRendering checkRecursion(*obj.podofo());
+
+    // TODO(edisonn): check type
+    SkPdfXObjectDictionary* skobj = NULL;
+    if (!mapXObjectDictionary(obj, &skobj)) return kIgnoreError_PdfResult;
+
+    if (!skobj || !skobj->valid()) return kIgnoreError_PdfResult;
+
+    PdfResult ret = kIgnoreError_PdfResult;
+    switch (skobj->getType())
+    {
+        case kImageDictionary_SkPdfObjectType:
+            ret = doXObject_Image(pdfContext, canvas, skobj->asImageDictionary());
+            break;
+        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->fObjectStack.top()->asNumber()->value();
+        pdfContext->fObjectStack.pop();
+    }
+
+    // a b
+    // c d
+    // e f
+
+    // 0 1
+    // 2 3
+    // 4 5
+
+    // sx ky
+    // kx sy
+    // tx ty
+    SkMatrix matrix = SkMatrixFromPdfMatrix(array);
+
+    pdfContext->fGraphicsState.fMatrix.preConcat(matrix);
+
+#ifdef PDF_TRACE
+    printf("cm ");
+    for (int i = 0 ; i < 6 ; i++) {
+        printf("%f ", array[i]);
+    }
+    printf("\n");
+    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->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->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->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+    double tx = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
+
+    // TODO(edisonn): Create factory methods or constructors so podofo is hidden
+    PdfObject _ty(PdfVariant(-ty));
+    pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc->podofo(), &_ty));
+
+    PdfOp_TL(pdfContext, canvas, looper);
+
+    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->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) {
+    PdfObject zero(PdfVariant(0.0));
+    PdfObject tl(PdfVariant(-(-pdfContext->fGraphicsState.fTextLeading)));
+
+    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->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->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->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->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->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->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->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;
+}
+
+PdfResult PdfOp_h(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    pdfContext->fGraphicsState.fPath.close();
+    return kOK_PdfResult;
+}
+
+PdfResult PdfOp_fillAndStroke(PdfContext* pdfContext, SkCanvas* canvas, bool fill, bool stroke, bool close, bool evenOdd) {
+    SkPath path = pdfContext->fGraphicsState.fPath;
+
+    if (close) {
+        path.close();
+    }
+
+    canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
+
+    SkPaint paint;
+
+    SkPoint line[2];
+    if (fill && !stroke && path.isLine(line)) {
+        paint.setStyle(SkPaint::kStroke_Style);
+
+        pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
+        paint.setStrokeWidth(SkDoubleToScalar(0));
+
+        canvas->drawPath(path, paint);
+    } else {
+        if (fill) {
+            paint.setStyle(SkPaint::kFill_Style);
+            if (evenOdd) {
+                path.setFillType(SkPath::kEvenOdd_FillType);
+            }
+
+            pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
+
+            canvas->drawPath(path, paint);
+        }
+
+        if (stroke) {
+            paint.setStyle(SkPaint::kStroke_Style);
+
+            pdfContext->fGraphicsState.applyGraphicsState(&paint, true);
+
+            path.setFillType(SkPath::kWinding_FillType);  // reset it, just in case it messes up the stroke
+            canvas->drawPath(path, paint);
+        }
+    }
+
+    pdfContext->fGraphicsState.fPath.reset();
+    // todo zoom ... other stuff ?
+
+    if (pdfContext->fGraphicsState.fHasClipPathToApply) {
+#ifndef PDF_DEBUG_NO_CLIPING
+        canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kIntersect_Op, true);
+#endif
+    }
+
+    //pdfContext->fGraphicsState.fClipPath.reset();
+    pdfContext->fGraphicsState.fHasClipPathToApply = false;
+
+    return kPartial_PdfResult;
+
+}
+
+PdfResult PdfOp_S(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    return PdfOp_fillAndStroke(pdfContext, canvas, false, true, false, false);
+}
+
+PdfResult PdfOp_s(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    return PdfOp_fillAndStroke(pdfContext, canvas, false, true, true, false);
+}
+
+PdfResult PdfOp_F(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false);
+}
+
+PdfResult PdfOp_f(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false);
+}
+
+PdfResult PdfOp_f_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, true);
+}
+
+PdfResult PdfOp_B(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, false);
+}
+
+PdfResult PdfOp_B_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, true);
+}
+
+PdfResult PdfOp_b(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, false);
+}
+
+PdfResult PdfOp_b_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, true);
+}
+
+PdfResult PdfOp_n(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
+    if (pdfContext->fGraphicsState.fHasClipPathToApply) {
+#ifndef PDF_DEBUG_NO_CLIPING
+        canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kIntersect_Op, true);
+#endif
+    }
+
+    //pdfContext->fGraphicsState.fClipPath.reset();
+    pdfContext->fGraphicsState.fHasClipPathToApply = false;
+
+    pdfContext->fGraphicsState.fPathClosed = true;
+
+    return kOK_PdfResult;
+}
+
+PdfResult PdfOp_BT(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    pdfContext->fGraphicsState.fTextBlock   = true;
+    pdfContext->fGraphicsState.fMatrixTm = pdfContext->fGraphicsState.fMatrix;
+    pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrix;
+
+    return kPartial_PdfResult;
+}
+
+PdfResult PdfOp_ET(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    if (!pdfContext->fGraphicsState.fTextBlock) {
+        return kIgnoreError_PdfResult;
+    }
+    // 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 speciﬁed explicitly using Tf before any text is shown.
+PdfResult PdfOp_Tf(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    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 Resources: %s\n", str.c_str());
+    pdfContext->fGraphicsState.fResources->Font()->podofo()->ToString(str);
+    printf("Print Tf Resources/Font: %s\n", str.c_str());
+#endif
+
+    SkPdfFontDictionary* fd = NULL;
+    if (pdfContext->fGraphicsState.fResources->Font()) {
+        SkPdfObject* objFont = pdfContext->fGraphicsState.fResources->Font()->get(fontName.c_str());
+        mapFontDictionary(*objFont, &fd);
+
+#ifdef PDF_TRACE
+        objFont->podofo()->ToString(str);
+        printf("Print Font loaded: %s\n", str.c_str());
+        fd->podofo()->ToString(str);
+        printf("Print Font loaded and resolved and upgraded: %s\n", str.c_str());
+#endif
+
+    }
+
+    SkPdfFont* skfont = SkPdfFont::fontFromPdfDictionary(fd);
+
+    if (skfont) {
+        pdfContext->fGraphicsState.fSkFont = skfont;
+    }
+
+    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->fObjectStack.top(),
+                             canvas);
+    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;
+    }
+
+    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->fObjectStack.push(aw);
+    PdfOp_Tw(pdfContext, canvas, looper);
+
+    pdfContext->fObjectStack.push(ac);
+    PdfOp_Tc(pdfContext, canvas, looper);
+
+    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;
+    }
+
+    SkPdfArray* array = pdfContext->fObjectStack.top()->asArray();
+    pdfContext->fObjectStack.pop();
+
+    for( int i=0; i<static_cast<int>(array->size()); i++ )
+    {
+        if( (*array)[i]->asString()) {
+            SkPdfObject* obj = (*array)[i];
+            DrawText(pdfContext,
+                     obj,
+                     canvas);
+        } 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->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->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
+        } else {
+            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->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->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->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->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);
+}
+
+PdfResult PdfOp_k(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
+}
+
+PdfResult PdfOp_W(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath;
+    pdfContext->fGraphicsState.fHasClipPathToApply = true;
+
+    return kOK_PdfResult;
+}
+
+PdfResult PdfOp_W_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath;
+
+#ifdef PDF_TRACE
+    if (pdfContext->fGraphicsState.fClipPath.isRect(NULL)) {
+        printf("CLIP IS RECT\n");
+    }
+#endif
+
+    // TODO(edisonn): there seem to be a bug with clipPath of a rect with even odd.
+    pdfContext->fGraphicsState.fClipPath.setFillType(SkPath::kEvenOdd_FillType);
+    pdfContext->fGraphicsState.fHasClipPathToApply = true;
+
+    return kPartial_PdfResult;
+}
+
+PdfResult PdfOp_BX(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    *looper = new PdfCompatibilitySectionLooper();
+    return kOK_PdfResult;
+}
+
+PdfResult PdfOp_EX(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+#ifdef ASSERT_BAD_PDF_OPS
+    SkASSERT(false);  // EX must be consumed by PdfCompatibilitySectionLooper, but let's
+                      // have the assert when testing good pdfs.
+#endif
+    return kIgnoreError_PdfResult;
+}
+
+PdfResult PdfOp_BI(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    *looper = new PdfInlineImageLooper();
+    return kOK_PdfResult;
+}
+
+PdfResult PdfOp_ID(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;
+}
+
+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->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->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->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->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->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->fObjectStack.pop();
+
+    return kNYI_PdfResult;
+}
+
+//ﬂatness i Set the ﬂatness tolerance in the graphics state (see Section 6.5.1, “Flatness
+//Tolerance”). ﬂatness is a number in the range 0 to 100; a value of 0 speci-
+//ﬁes the output device’s default ﬂatness tolerance.
+PdfResult PdfOp_i(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    pdfContext->fObjectStack.pop();
+
+    return kNYI_PdfResult;
+}
+
+//dictName gs (PDF 1.2) Set the speciﬁed 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) {
+    std::string name = pdfContext->fObjectStack.top()->asName()->value();    pdfContext->fObjectStack.pop();
+
+#ifdef PDF_TRACE
+    std::string str;
+#endif
+
+    //Next, get the ExtGState Dictionary from the Resource Dictionary:
+    const SkPdfDictionary* extGStateDictionary = pdfContext->fGraphicsState.fResources->ExtGState();
+
+    if (extGStateDictionary == NULL) {
+#ifdef PDF_TRACE
+        printf("ExtGState is NULL!\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());
+#endif
+
+    SkPdfGraphicsStateDictionary* gs = NULL;
+    mapGraphicsStateDictionary(*value, &gs);
+
+    // TODO(edisonn): now load all those properties in graphic state.
+    if (gs == NULL) {
+        return kIgnoreError_PdfResult;
+    }
+
+    if (gs->has_CA()) {
+        pdfContext->fGraphicsState.fStroking.fOpacity = gs->CA();
+    }
+
+    if (gs->has_ca()) {
+        pdfContext->fGraphicsState.fNonStroking.fOpacity = gs->ca();
+    }
+
+    if (gs->has_LW()) {
+        pdfContext->fGraphicsState.fLineWidth = gs->LW();
+    }
+
+
+
+    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->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->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->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->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->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
+
+    return kNYI_PdfResult;
+}
+
+//wx wy d0
+PdfResult PdfOp_d0(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    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->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->fObjectStack.pop();
+
+    return kNYI_PdfResult;
+}
+
+//name Do
+PdfResult PdfOp_Do(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    std::string name = pdfContext->fObjectStack.top()->asName()->value();    pdfContext->fObjectStack.pop();
+
+    SkPdfDictionary* xObject =  pdfContext->fGraphicsState.fResources->XObject();
+
+    if (xObject == NULL) {
+#ifdef PDF_TRACE
+        printf("XObject is NULL!\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());
+#endif
+
+    return doXObject(pdfContext, canvas, *value);
+}
+
+//tag MP Designate a marked-content point. tag is a name object indicating the role or
+//signiﬁcance of the point.
+PdfResult PdfOp_MP(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    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 signiﬁcance 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->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 signiﬁcance of the sequence.
+PdfResult PdfOp_BMC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
+    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->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() {
+    static bool gInitialized = false;
+    if (gInitialized) {
+        return;
+    }
+
+    gPdfOps["q"] =      PdfOp_q;
+    gPdfOps["Q"] =      PdfOp_Q;
+    gPdfOps["cm"] =     PdfOp_cm;
+
+    gPdfOps["TD"] =     PdfOp_TD;
+    gPdfOps["Td"] =     PdfOp_Td;
+    gPdfOps["Tm"] =     PdfOp_Tm;
+    gPdfOps["T*"] =     PdfOp_T_star;
+
+    gPdfOps["m"] =      PdfOp_m;
+    gPdfOps["l"] =      PdfOp_l;
+    gPdfOps["c"] =      PdfOp_c;
+    gPdfOps["v"] =      PdfOp_v;
+    gPdfOps["y"] =      PdfOp_y;
+    gPdfOps["h"] =      PdfOp_h;
+    gPdfOps["re"] =     PdfOp_re;
+
+    gPdfOps["S"] =      PdfOp_S;
+    gPdfOps["s"] =      PdfOp_s;
+    gPdfOps["f"] =      PdfOp_f;
+    gPdfOps["F"] =      PdfOp_F;
+    gPdfOps["f*"] =     PdfOp_f_star;
+    gPdfOps["B"] =      PdfOp_B;
+    gPdfOps["B*"] =     PdfOp_B_star;
+    gPdfOps["b"] =      PdfOp_b;
+    gPdfOps["b*"] =     PdfOp_b_star;
+    gPdfOps["n"] =      PdfOp_n;
+
+    gPdfOps["BT"] =     PdfOp_BT;
+    gPdfOps["ET"] =     PdfOp_ET;
+
+    gPdfOps["Tj"] =     PdfOp_Tj;
+    gPdfOps["'"] =      PdfOp_quote;
+    gPdfOps["\""] =     PdfOp_doublequote;
+    gPdfOps["TJ"] =     PdfOp_TJ;
+
+    gPdfOps["CS"] =     PdfOp_CS;
+    gPdfOps["cs"] =     PdfOp_cs;
+    gPdfOps["SC"] =     PdfOp_SC;
+    gPdfOps["SCN"] =    PdfOp_SCN;
+    gPdfOps["sc"] =     PdfOp_sc;
+    gPdfOps["scn"] =    PdfOp_scn;
+    gPdfOps["G"] =      PdfOp_G;
+    gPdfOps["g"] =      PdfOp_g;
+    gPdfOps["RG"] =     PdfOp_RG;
+    gPdfOps["rg"] =     PdfOp_rg;
+    gPdfOps["K"] =      PdfOp_K;
+    gPdfOps["k"] =      PdfOp_k;
+
+    gPdfOps["W"] =      PdfOp_W;
+    gPdfOps["W*"] =     PdfOp_W_star;
+
+    gPdfOps["BX"] =     PdfOp_BX;
+    gPdfOps["EX"] =     PdfOp_EX;
+
+    gPdfOps["BI"] =     PdfOp_BI;
+    gPdfOps["ID"] =     PdfOp_ID;
+    gPdfOps["EI"] =     PdfOp_EI;
+
+    gPdfOps["w"] =      PdfOp_w;
+    gPdfOps["J"] =      PdfOp_J;
+    gPdfOps["j"] =      PdfOp_j;
+    gPdfOps["M"] =      PdfOp_M;
+    gPdfOps["d"] =      PdfOp_d;
+    gPdfOps["ri"] =     PdfOp_ri;
+    gPdfOps["i"] =      PdfOp_i;
+    gPdfOps["gs"] =     PdfOp_gs;
+
+    gPdfOps["Tc"] =     PdfOp_Tc;
+    gPdfOps["Tw"] =     PdfOp_Tw;
+    gPdfOps["Tz"] =     PdfOp_Tz;
+    gPdfOps["TL"] =     PdfOp_TL;
+    gPdfOps["Tf"] =     PdfOp_Tf;
+    gPdfOps["Tr"] =     PdfOp_Tr;
+    gPdfOps["Ts"] =     PdfOp_Ts;
+
+    gPdfOps["d0"] =     PdfOp_d0;
+    gPdfOps["d1"] =     PdfOp_d1;
+
+    gPdfOps["sh"] =     PdfOp_sh;
+
+    gPdfOps["Do"] =     PdfOp_Do;
+
+    gPdfOps["MP"] =     PdfOp_MP;
+    gPdfOps["DP"] =     PdfOp_DP;
+    gPdfOps["BMC"] =    PdfOp_BMC;
+    gPdfOps["BDC"] =    PdfOp_BDC;
+    gPdfOps["EMC"] =    PdfOp_EMC;
+
+    gInitialized = true;
+}
+
+class InitPdfOps {
+public:
+    InitPdfOps() {
+        initPdfOperatorRenderes();
+    }
+};
+
+InitPdfOps gInitPdfOps;
+
+void reportPdfRenderStats() {
+    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.fType == kKeyword_TokenType)
+    {
+        // TODO(edisonn): log trace flag (verbose, error, info, warning, ...)
+        PdfOperatorRenderer pdfOperatorRenderer = gPdfOps[token.fKeyword];
+        if (pdfOperatorRenderer) {
+            // caller, main work is done by pdfOperatorRenderer(...)
+            PdfTokenLooper* childLooper = NULL;
+            gRenderStats[pdfOperatorRenderer(fPdfContext, fCanvas, &childLooper)][token.fKeyword]++;
+
+            if (childLooper) {
+                childLooper->setUp(this);
+                childLooper->loop();
+                delete childLooper;
+            }
+        } else {
+            gRenderStats[kUnsupported_PdfResult][token.fKeyword]++;
+        }
+    }
+    else if (token.fType == kObject_TokenType)
+    {
+        fPdfContext->fObjectStack.push( token.fObject );
+    }
+    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.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") == 0) {
+            PdfTokenLooper* looper = new PdfCompatibilitySectionLooper();
+            looper->setUp(this);
+            looper->loop();
+        } else {
+            if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "EI") == 0) {
+                done();
+                return;
+            }
+
+            consumeToken(token);
+        }
+    }
+    // TODO(edisonn): report error/warning, EOF without EI.
+}
+
+PdfResult PdfInlineImageLooper::done() {
+
+    // TODO(edisonn): long to short names
+    // TODO(edisonn): set properties in a map
+    // TODO(edisonn): extract bitmap stream, check if PoDoFo has public utilities to uncompress
+    // the stream.
+
+    SkBitmap bitmap;
+    setup_bitmap(&bitmap, 50, 50, SK_ColorRED);
+
+    // TODO(edisonn): matrix use.
+    // Draw dummy red square, to show the prezence of the inline image.
+    fCanvas->drawBitmap(bitmap,
+                       SkDoubleToScalar(0),
+                       SkDoubleToScalar(0),
+                       NULL);
+    return kNYI_PdfResult;
+}
+
+PdfResult PdfCompatibilitySectionLooper::consumeToken(PdfToken& token) {
+    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.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") == 0) {
+            PdfTokenLooper* looper = new PdfCompatibilitySectionLooper();
+            looper->setUp(this);
+            looper->loop();
+            delete looper;
+        } else {
+            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.
+
+bool SkPdfViewer::load(const SkString inputFileName, SkPicture* out) {
+    try
+    {
+        std::cout << "Init: " << inputFileName.c_str() << std::endl;
+
+        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.pages(); ++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", 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 * (int)SkScalarToDouble(rect.width()), 3 * (int)SkScalarToDouble(rect.height()));
+    #else
+                setup_bitmap(&bitmap, (int)SkScalarToDouble(rect.width()), (int)SkScalarToDouble(rect.height()));
+    #endif
+                SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (bitmap)));
+                SkCanvas canvas(device);
+
+                gDumpBitmap = &bitmap;
+
+                doc.drawPage(pn, &canvas);
+
+                SkString out;
+                out.appendf("%s-%i.png", inputFileName.c_str(), pn);
+                SkImageEncoder::EncodeFile(out.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100);
+            }
+            return true;
+        }
+    }
+    catch( PdfError & e )
+    {
+        std::cout << "ERROR: PDF can't be parsed!" << inputFileName.c_str() << std::endl;
+        return false;
+    }
+
+    return true;
+}
+
+
diff --git a/experimental/PdfViewer/SkPdfParser.h b/experimental/PdfViewer/SkPdfParser.h
index 7e2cd0e..c156004 100644
--- a/experimental/PdfViewer/SkPdfParser.h
+++ b/experimental/PdfViewer/SkPdfParser.h
@@ -28,8 +28,8 @@
 };
 
 class SkPdfTokenizer {
-    PdfContentsTokenizer* fTokenizer;
     PdfMemDocument* fDoc;
+    PdfContentsTokenizer* fTokenizer;
 
     char* fUncompressedStream;
     pdf_long fUncompressedStreamLength;
@@ -39,8 +39,8 @@
     PdfToken fPutBack;
 
 public:
-    SkPdfTokenizer(PdfMemDocument* doc = NULL, PdfContentsTokenizer* tokenizer = NULL) : fDoc(doc), fTokenizer(tokenizer), fEmpty(false), fUncompressedStream(NULL), fUncompressedStreamLength(0), fHasPutBack(false) {}
-    SkPdfTokenizer(const SkPdfObject* objWithStream) : fDoc(NULL), fTokenizer(NULL), fHasPutBack(false), fEmpty(false) {
+    SkPdfTokenizer(PdfMemDocument* doc = NULL, PdfContentsTokenizer* tokenizer = NULL) : fDoc(doc), fTokenizer(tokenizer), fUncompressedStream(NULL), fUncompressedStreamLength(0),  fEmpty(false), fHasPutBack(false) {}
+    SkPdfTokenizer(const SkPdfObject* objWithStream) : fDoc(NULL), fTokenizer(NULL), fEmpty(false), fHasPutBack(false) {
         fUncompressedStream = NULL;
         fUncompressedStreamLength = 0;
 
@@ -60,7 +60,7 @@
 
     }
 
-    SkPdfTokenizer(const char* buffer, int len) : fDoc(NULL), fTokenizer(NULL), fHasPutBack(false), fUncompressedStream(NULL), fUncompressedStreamLength(0), fEmpty(false) {
+    SkPdfTokenizer(const char* buffer, int len) : fDoc(NULL), fTokenizer(NULL), fUncompressedStream(NULL), fUncompressedStreamLength(0), fEmpty(false), fHasPutBack(false) {
         try {
             fTokenizer = new PdfContentsTokenizer(buffer, len);
         } catch (PdfError& e) {
@@ -107,7 +107,7 @@
             case ePdfContentsType_Variant: {
                     token->fType = kObject_TokenType;
                     PdfObject* obj = new PdfObject(var);
-                    PodofoMapper::map(*fDoc, *obj, &token->fObject);
+                    mapObject(*fDoc, *obj, &token->fObject);
                 }
                 break;
 
@@ -127,6 +127,91 @@
     }
 };
 
+extern "C" PdfContext* gPdfContext;
+extern "C" SkBitmap* gDumpBitmap;
+extern "C" SkCanvas* gDumpCanvas;
+
+// TODO(edisonn): move in trace util.
+#ifdef PDF_TRACE
+static void SkTraceMatrix(const SkMatrix& matrix, const char* sz = "") {
+    printf("SkMatrix %s ", sz);
+    for (int i = 0 ; i < 9 ; i++) {
+        printf("%f ", SkScalarToDouble(matrix.get(i)));
+    }
+    printf("\n");
+}
+
+static void SkTraceRect(const SkRect& rect, const char* sz = "") {
+    printf("SkRect %s ", sz);
+    printf("x = %f ", SkScalarToDouble(rect.x()));
+    printf("y = %f ", SkScalarToDouble(rect.y()));
+    printf("w = %f ", SkScalarToDouble(rect.width()));
+    printf("h = %f ", SkScalarToDouble(rect.height()));
+    printf("\n");
+}
+
+#else
+#define SkTraceMatrix(a,b)
+#define SkTraceRect(a,b)
+#endif
+
+// TODO(edisonn): Document PdfTokenLooper and subclasses.
+class PdfTokenLooper {
+protected:
+    PdfTokenLooper* fParent;
+    SkPdfTokenizer* fTokenizer;
+    PdfContext* fPdfContext;
+    SkCanvas* fCanvas;
+
+public:
+    PdfTokenLooper(PdfTokenLooper* parent,
+                   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,
+                  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) {}
+
+    virtual PdfResult consumeToken(PdfToken& token);
+    virtual void loop();
+    PdfResult done();
+};
+
+class PdfCompatibilitySectionLooper : public PdfTokenLooper {
+public:
+    PdfCompatibilitySectionLooper()
+        : PdfTokenLooper(NULL, NULL, NULL, NULL) {}
+
+    virtual PdfResult consumeToken(PdfToken& token);
+    virtual void loop();
+};
+
 class SkPdfDoc {
     PdfMemDocument fDoc;
 public:
@@ -139,10 +224,20 @@
         return fDoc.GetPageCount();
     }
 
+    double width(int n) {
+        PdfRect rect = fDoc.GetPage(n)->GetMediaBox();
+        return rect.GetWidth() + rect.GetLeft();
+    }
+
+    double height(int n) {
+        PdfRect rect = fDoc.GetPage(n)->GetMediaBox();
+        return rect.GetHeight() + rect.GetBottom();
+    }
+
     // Can return NULL
     SkPdfPageObjectDictionary* page(int n) {
         SkPdfPageObjectDictionary* page = NULL;
-        PodofoMapper::map(fDoc, *fDoc.GetPage(n)->GetObject(), &page);
+        mapPageObjectDictionary(fDoc, *fDoc.GetPage(n)->GetObject(), &page);
         return page;
     }
 
@@ -155,10 +250,89 @@
         return skrect;
     }
 
+    void drawPage(int n, SkCanvas* canvas) {
+        SkPdfPageObjectDictionary* pg = page(n);
+        SkPdfTokenizer* tokenizer = tokenizerOfPage(n);
+
+        PdfContext pdfContext(this);
+        pdfContext.fOriginalMatrix = SkMatrix::I();
+        pdfContext.fGraphicsState.fResources = NULL;
+        mapResourceDictionary(*pg->Resources(), &pdfContext.fGraphicsState.fResources);
+
+        gPdfContext = &pdfContext;
+        gDumpCanvas = canvas;
+
+        // TODO(edisonn): get matrix stuff right.
+        // TODO(edisonn): add DPI/scale/zoom.
+        SkScalar z = SkIntToScalar(0);
+        SkRect rect = MediaBox(n);
+        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
+        SkPoint skiaSpace[4] = {SkPoint::Make(w+z, h+h), SkPoint::Make(w+w, h+h), SkPoint::Make(w+w, h+z), SkPoint::Make(w+z, h+z)};
+#else
+        SkPoint skiaSpace[4] = {SkPoint::Make(z, h), SkPoint::Make(w, h), SkPoint::Make(w, z), SkPoint::Make(z, z)};
+#endif
+        //SkPoint pdfSpace[2] = {SkPoint::Make(z, z), SkPoint::Make(w, h)};
+        //SkPoint skiaSpace[2] = {SkPoint::Make(w, z), SkPoint::Make(z, h)};
+
+        //SkPoint pdfSpace[2] = {SkPoint::Make(z, z), SkPoint::Make(z, h)};
+        //SkPoint skiaSpace[2] = {SkPoint::Make(z, h), SkPoint::Make(z, z)};
+
+        //SkPoint pdfSpace[3] = {SkPoint::Make(z, z), SkPoint::Make(z, h), SkPoint::Make(w, h)};
+        //SkPoint skiaSpace[3] = {SkPoint::Make(z, h), SkPoint::Make(z, z), SkPoint::Make(w, 0)};
+
+        SkAssertResult(pdfContext.fOriginalMatrix.setPolyToPoly(pdfSpace, skiaSpace, 4));
+        SkTraceMatrix(pdfContext.fOriginalMatrix, "Original matrix");
+
+
+        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
+
+// erase with red before?
+//        SkPaint paint;
+//        paint.setColor(SK_ColorRED);
+//        canvas->drawRect(rect, paint);
+
+        PdfMainLooper looper(NULL, tokenizer, &pdfContext, canvas);
+        looper.loop();
+
+        delete tokenizer;
+
+
+        canvas->flush();
+    }
+
     SkPdfTokenizer* tokenizerOfPage(int n) {
         PdfContentsTokenizer* t = new PdfContentsTokenizer(fDoc.GetPage(n));
         return new SkPdfTokenizer(&fDoc, t);
     }
 };
 
+// TODO(edisonn): move in another file
+class SkPdfViewer : public SkRefCnt {
+public:
+
+  bool load(const SkString inputFileName, SkPicture* out);
+  bool write(void*) const { return false; }
+};
+
+void reportPdfRenderStats();
+
 #endif  // SkPdfParser_DEFINED
diff --git a/experimental/PdfViewer/SkPdfUtils.cpp b/experimental/PdfViewer/SkPdfUtils.cpp
index e69de29..29e3548 100644
--- a/experimental/PdfViewer/SkPdfUtils.cpp
+++ b/experimental/PdfViewer/SkPdfUtils.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfUtils.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,
+                         const char* abr,
+                         SkPdfFileSpec* data) {return false;}
+
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc,
+                         const PdfDictionary& dict,
+                         const char* key,
+                         const char* abr,
+                         SkPdfStream** data);
+
+bool TreeFromDictionary(const PdfMemDocument* pdfDoc,
+                         const PdfDictionary& dict,
+                         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 FunctionFromDictionary(const PdfMemDocument* pdfDoc,
+                         const PdfDictionary& dict,
+                         const char* key,
+                         const char* abr,
+                         SkPdfFunction* data) {return false;}
diff --git a/experimental/PdfViewer/SkPdfUtils.h b/experimental/PdfViewer/SkPdfUtils.h
index 970b6c1..858ab8e 100644
--- a/experimental/PdfViewer/SkPdfUtils.h
+++ b/experimental/PdfViewer/SkPdfUtils.h
@@ -39,20 +39,17 @@
                           const char* key,
                           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);
+bool skpdfmap(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out);
+
 
 class SkPdfObject;
 bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
@@ -118,9 +115,10 @@
                         const char* abr,
                         SkPdfFunction* data);
 
-bool skpdfmap(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out);
 SkMatrix SkMatrixFromPdfArray(SkPdfArray* pdfArray);
 
 PdfResult doType3Char(PdfContext* pdfContext, SkCanvas* canvas, SkPdfObject* skobj, SkRect bBox, SkMatrix matrix, double textSize);
 
+#include "SkPdfPodofoMapper_autogen.h"
+
 #endif   // __DEFINED__SkPdfUtils
diff --git a/experimental/PdfViewer/autogen/SkPdfALinkAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfALinkAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..38d8fb8
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfALinkAnnotationDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfALinkAnnotationDictionary_autogen.h"
+
+std::string SkPdfALinkAnnotationDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfALinkAnnotationDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfALinkAnnotationDictionary::getDestAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfALinkAnnotationDictionary::getDestAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfALinkAnnotationDictionary::getDestAsString() const {
+  std::string ret = "";
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfALinkAnnotationDictionary::H() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfALinkAnnotationDictionary::PA() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PA", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfALinkAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfALinkAnnotationDictionary_autogen.h
index 920043b..e2ba74e 100644
--- a/experimental/PdfViewer/autogen/SkPdfALinkAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfALinkAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Optional; PDF 1.4) An alternate representation of the annotation's contents in
  *  human-readable form, useful when extracting the document's contents in sup-
  *  port of accessibility to disabled users or for other purposes (see Section 9.8.2,
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Optional; not permitted if an A entry is present) A destination to be displayed
  *  when the annotation is activated (see Section 8.2.1, "Destinations"; see also
  *  implementation note 66 in Appendix H).
@@ -569,39 +557,21 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getDestAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getDestAsArray() const;
   bool isDestAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getDestAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getDestAsName() const;
   bool isDestAString() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  std::string getDestAsString() const {
-    std::string ret = "";
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getDestAsString() const;
 /** (Optional; PDF 1.2) The annotation's highlighting mode, the visual effect to be
  *  used when the mouse button is pressed or held down inside its active area:
  *      N    (None) No highlighting.
@@ -620,13 +590,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", NULL));
   }
 
-  std::string H() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string H() const;
 /** (Optional; PDF 1.3) A URI action (see "URI Actions" on page 523) formerly
  *  associated with this annotation. When Web Capture (Section 9.9, "Web Cap-
  *  ture") changes an annotation from a URI to a go-to action ("Go-To Actions"
@@ -638,13 +602,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PA", "", NULL));
   }
 
-  SkPdfDictionary* PA() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PA", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* PA() const;
 };
 
 #endif  // __DEFINED__SkPdfALinkAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfActionDictionary_autogen.cpp
new file mode 100644
index 0000000..ed91efc
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfActionDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfActionDictionary_autogen.h"
+
+std::string SkPdfActionDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfActionDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfActionDictionary::getNextAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfActionDictionary::getNextAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfActionDictionary_autogen.h
index b7fa6d0..56f648e 100644
--- a/experimental/PdfViewer/autogen/SkPdfActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfActionDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The type of action that this dictionary describes; see Table 8.34
  *  on page 518 for specific values.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Optional; PDF 1.2) The next action, or sequence of actions, to be per-
  *  formed after this one. The value is either a single action dictionary or an
  *  array of action dictionaries to be performed in order; see below for fur-
@@ -568,26 +556,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getNextAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getNextAsDictionary() const;
   bool isNextAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getNextAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getNextAsArray() const;
 };
 
 #endif  // __DEFINED__SkPdfActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfAlternateImageDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfAlternateImageDictionary_autogen.cpp
new file mode 100644
index 0000000..3d262e4
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfAlternateImageDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfAlternateImageDictionary_autogen.h"
+
+SkPdfStream* SkPdfAlternateImageDictionary::Image() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Image", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+bool SkPdfAlternateImageDictionary::DefaultForPrinting() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DefaultForPrinting", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfAlternateImageDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfAlternateImageDictionary_autogen.h
index 5ab6a9d..4e9b886 100644
--- a/experimental/PdfViewer/autogen/SkPdfAlternateImageDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfAlternateImageDictionary_autogen.h
@@ -531,13 +531,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Image", "", NULL));
   }
 
-  SkPdfStream* Image() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Image", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* Image() const;
 /** (Optional) A flag indicating whether this alternate image is the default ver-
  *  sion to be used for printing. At most one alternate for a given base image may
  *  be so designated. If no alternate has this entry set to true, the base image itself
@@ -547,13 +541,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DefaultForPrinting", "", NULL));
   }
 
-  bool DefaultForPrinting() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DefaultForPrinting", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool DefaultForPrinting() const;
 };
 
 #endif  // __DEFINED__SkPdfAlternateImageDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfAnnotationActionsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfAnnotationActionsDictionary_autogen.cpp
new file mode 100644
index 0000000..183dbd1
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfAnnotationActionsDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfAnnotationActionsDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfAnnotationActionsDictionary::E() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationActionsDictionary::X() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "X", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationActionsDictionary::D() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationActionsDictionary::U() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationActionsDictionary::Fo() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fo", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationActionsDictionary::Bl() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bl", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfAnnotationActionsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfAnnotationActionsDictionary_autogen.h
index 01e1ffe..9ded5ee 100644
--- a/experimental/PdfViewer/autogen/SkPdfAnnotationActionsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfAnnotationActionsDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", NULL));
   }
 
-  SkPdfDictionary* E() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* E() const;
 /** (Optional; PDF 1.2) An action to be performed when the cursor exits the annotation's
  *  active area.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "X", "", NULL));
   }
 
-  SkPdfDictionary* X() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "X", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* X() const;
 /** (Optional; PDF 1.2) An action to be performed when the mouse button is pressed
  *  inside the annotation's active area. (The name D stands for "down.")
 **/
@@ -560,13 +548,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", NULL));
   }
 
-  SkPdfDictionary* D() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* D() const;
 /** (Optional; PDF 1.2) An action to be performed when the mouse button is released
  *  inside the annotation's active area. (The name U stands for "up.")
  *  Note: For backward compatibility, the A entry in an annotation dictionary, if present,
@@ -576,13 +558,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", NULL));
   }
 
-  SkPdfDictionary* U() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* U() const;
 /** (Optional; PDF 1.2; widget annotations only) An action to be performed when the
  *  annotation receives the input focus.
 **/
@@ -590,13 +566,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fo", "", NULL));
   }
 
-  SkPdfDictionary* Fo() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fo", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Fo() const;
 /** (Optional; PDF 1.2; widget annotations only) (Uppercase B, lowercase L) An action to
  *  be performed when the annotation loses the input focus. (The name Bl stands for
  *  "blurred.")
@@ -605,13 +575,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bl", "", NULL));
   }
 
-  SkPdfDictionary* Bl() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bl", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Bl() const;
 };
 
 #endif  // __DEFINED__SkPdfAnnotationActionsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..0e29966
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfAnnotationDictionary_autogen.cpp
@@ -0,0 +1,135 @@
+#include "SkPdfAnnotationDictionary_autogen.h"
+
+std::string SkPdfAnnotationDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfAnnotationDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfAnnotationDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfAnnotationDictionary::P() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkRect* SkPdfAnnotationDictionary::Rect() const {
+  SkRect* ret;
+  if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rect", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDate SkPdfAnnotationDictionary::getMAsDate() const {
+  SkPdfDate ret = SkPdfDate();
+  if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfDate();
+}
+
+std::string SkPdfAnnotationDictionary::getMAsString() const {
+  std::string ret = "";
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfAnnotationDictionary::F() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfDictionary* SkPdfAnnotationDictionary::BS() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfAnnotationDictionary::Border() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Border", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationDictionary::AP() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfAnnotationDictionary::AS() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfAnnotationDictionary::C() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+double SkPdfAnnotationDictionary::CA() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfAnnotationDictionary::T() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfAnnotationDictionary::Popup() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Popup", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationDictionary::A() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfAnnotationDictionary::AA() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfAnnotationDictionary::StructParent() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfAnnotationDictionary_autogen.h
index 5276f64..9b7f08a 100644
--- a/experimental/PdfViewer/autogen/SkPdfAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The type of annotation that this dictionary describes; see Table
  *  8.14 on page 499 for specific values.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required or optional, depending on the annotation type) Text to be displayed
  *  for the annotation or, if this type of annotation does not display text, an al-
  *  ternate description of the annotation's contents in human-readable form. In
@@ -564,13 +552,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Optional; PDF 1.3; not used in FDF files) An indirect reference to the page
  *  object with which this annotation is associated.
 **/
@@ -578,13 +560,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", NULL));
   }
 
-  SkPdfDictionary* P() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* P() const;
 /** (Required) The annotation rectangle, defining the location of the annotation
  *  on the page in default user space units.
 **/
@@ -592,13 +568,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rect", "", NULL));
   }
 
-  SkRect* Rect() const {
-    SkRect* ret;
-    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rect", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkRect* Rect() const;
 /** (Optional; PDF 1.4) The annotation name, a text string uniquely identifying
  *  it among all the annotations on its page.
 **/
@@ -621,26 +591,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfDate getMAsDate() const {
-    SkPdfDate ret = SkPdfDate();
-    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfDate();
-  }
-
+  SkPdfDate getMAsDate() const;
   bool isMAString() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  std::string getMAsString() const {
-    std::string ret = "";
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getMAsString() const;
 /** (Optional; PDF 1.1) A set of flags specifying various characteristics of the an-
  *  notation (see Section 8.4.2, "Annotation Flags"). Default value: 0.
 **/
@@ -648,13 +606,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  long F() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long F() const;
 /** (Optional; PDF 1.2) A border style dictionary specifying the characteristics of
  *  the annotation's border (see Section 8.4.3, "Border Styles"; see also imple-
  *  mentation note 60 in Appendix H).
@@ -666,13 +618,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", NULL));
   }
 
-  SkPdfDictionary* BS() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* BS() const;
 /** (Optional) An array specifying the characteristics of the annotation's border.
  *  The border is specified as a "rounded rectangle."
  *  In PDF 1.0, the array consists of three numbers defining the horizontal cor-
@@ -700,13 +646,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Border", "", NULL));
   }
 
-  SkPdfArray* Border() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Border", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Border() const;
 /** (Optional; PDF 1.2) An appearance dictionary specifying how the annotation
  *  is presented visually on the page (see Section 8.4.4, "Appearance Streams";
  *  see also implementation note 60 in Appendix H).
@@ -715,13 +655,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", NULL));
   }
 
-  SkPdfDictionary* AP() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* AP() const;
 /** (Required if the appearance dictionary AP contains one or more subdictionaries;
  *  PDF 1.2) The annotation's appearance state, which selects the applicable
  *  appearance stream from an appearance subdictionary (see Section 8.4.4,
@@ -731,13 +665,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AS", "", NULL));
   }
 
-  std::string AS() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string AS() const;
 /** (Optional; PDF 1.1) An array of three numbers in the range 0.0 to 1.0, repre-
  *  senting the components of a color in the DeviceRGB color space. This color
  *  will be used for the following purposes:
@@ -749,13 +677,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
   }
 
-  SkPdfArray* C() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* C() const;
 /** (Optional; PDF 1.4) The constant opacity value to be used in painting the
  *  annotation (see Sections 7.1, "Overview of Transparency," and 7.2.6, "Shape
  *  and Opacity Computations"). This value applies to all visible elements of
@@ -777,13 +699,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", NULL));
   }
 
-  double CA() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double CA() const;
 /** (Optional; PDF 1.1) The text label to be displayed in the title bar of the anno-
  *  tation's pop-up window when open and active.
 **/
@@ -791,13 +707,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", NULL));
   }
 
-  std::string T() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string T() const;
 /** (Optional; PDF 1.3) An indirect reference to a pop-up annotation for enter-
  *  ing or editing the text associated with this annotation.
 **/
@@ -805,13 +715,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Popup", "", NULL));
   }
 
-  SkPdfDictionary* Popup() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Popup", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Popup() const;
 /** (Optional; PDF 1.1) An action to be performed when the annotation is acti-
  *  vated (see Section 8.5, "Actions").
  *  Note: This entry is not permitted in link annotations if a Dest entry is present
@@ -822,13 +726,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", NULL));
   }
 
-  SkPdfDictionary* A() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* A() const;
 /** (Optional; PDF 1.2) An additional-actions dictionary defining the anno-
  *  tation's behavior in response to various trigger events (see Section 8.5.2,
  *  "Trigger Events"). At the time of publication, this entry is used only by wid-
@@ -838,13 +736,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", NULL));
   }
 
-  SkPdfDictionary* AA() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* AA() const;
 /** (Required if the annotation is a structural content item; PDF 1.3) The integer
  *  key of the annotation's entry in the structural parent tree (see "Finding Struc-
  *  ture Elements from Content Items" on page 600).
@@ -853,13 +745,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", NULL));
   }
 
-  long StructParent() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long StructParent() const;
 };
 
 #endif  // __DEFINED__SkPdfAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfAppearanceCharacteristicsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfAppearanceCharacteristicsDictionary_autogen.cpp
new file mode 100644
index 0000000..96b6b4e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfAppearanceCharacteristicsDictionary_autogen.cpp
@@ -0,0 +1,79 @@
+#include "SkPdfAppearanceCharacteristicsDictionary_autogen.h"
+
+long SkPdfAppearanceCharacteristicsDictionary::R() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfAppearanceCharacteristicsDictionary::BC() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfAppearanceCharacteristicsDictionary::BG() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfAppearanceCharacteristicsDictionary::CA() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfAppearanceCharacteristicsDictionary::RC() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RC", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfAppearanceCharacteristicsDictionary::AC() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AC", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfStream* SkPdfAppearanceCharacteristicsDictionary::I() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfAppearanceCharacteristicsDictionary::RI() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfAppearanceCharacteristicsDictionary::IX() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IX", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfAppearanceCharacteristicsDictionary::IF() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IF", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfAppearanceCharacteristicsDictionary::TP() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TP", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfAppearanceCharacteristicsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfAppearanceCharacteristicsDictionary_autogen.h
index 75a0038..a3814a6 100644
--- a/experimental/PdfViewer/autogen/SkPdfAppearanceCharacteristicsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfAppearanceCharacteristicsDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", NULL));
   }
 
-  long R() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long R() const;
 /** (Optional) An array of numbers in the range 0.0 to 1.0 specifying the color of the
  *  widget annotation's border. The number of array elements determines the color
  *  space in which the color is defined:
@@ -552,13 +546,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", NULL));
   }
 
-  SkPdfArray* BC() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* BC() const;
 /** (Optional) An array of numbers in the range 0.0 to 1.0 specifying the color of the
  *  widget annotation's background. The number of array elements determines the
  *  color space, as described above for BC.
@@ -567,13 +555,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", NULL));
   }
 
-  SkPdfArray* BG() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* BG() const;
 /** (Optional; button fields only) The widget annotation's normal caption, displayed
  *  when it is not interacting with the user.
  *  Note: Unlike the remaining entries listed below, which apply only to widget annota-
@@ -585,13 +567,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", NULL));
   }
 
-  std::string CA() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string CA() const;
 /** (Optional; pushbutton fields only) The widget annotation's rollover caption, dis-
  *  played when the user rolls the cursor into its active area without pressing the
  *  mouse button.
@@ -600,13 +576,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RC", "", NULL));
   }
 
-  std::string RC() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RC", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string RC() const;
 /** (Optional; pushbutton fields only) The widget annotation's alternate (down)
  *  caption, displayed when the mouse button is pressed within its active area.
 **/
@@ -614,13 +584,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AC", "", NULL));
   }
 
-  std::string AC() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AC", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string AC() const;
 /** (Optional; pushbutton fields only; must be an indirect reference) A form XObject
  *  defining the widget annotation's normal icon, displayed when it is not inter-
  *  acting with the user.
@@ -629,13 +593,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", NULL));
   }
 
-  SkPdfStream* I() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* I() const;
 /** (Optional; pushbutton fields only; must be an indirect reference) A form XObject
  *  defining the widget annotation's rollover icon, displayed when the user rolls the
  *  cursor into its active area without pressing the mouse button.
@@ -644,13 +602,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", NULL));
   }
 
-  SkPdfStream* RI() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* RI() const;
 /** (Optional; pushbutton fields only; must be an indirect reference) A form XObject
  *  defining the widget annotation's alternate (down) icon, displayed when the
  *  mouse button is pressed within its active area.
@@ -659,13 +611,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IX", "", NULL));
   }
 
-  SkPdfStream* IX() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IX", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* IX() const;
 /** (Optional; pushbutton fields only) An icon fit dictionary (see Table 8.73 on page
  *  566) specifying how to display the widget annotation's icon within its
  *  annotation rectangle. If present, the icon fit dictionary applies to all of the anno-
@@ -675,13 +621,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IF", "", NULL));
   }
 
-  SkPdfDictionary* IF() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IF", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* IF() const;
 /** (Optional; pushbutton fields only) A code indicating where to position the text of
  *  the widget annotation's caption relative to its icon:
  *      0    No icon; caption only
@@ -697,13 +637,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TP", "", NULL));
   }
 
-  long TP() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TP", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long TP() const;
 };
 
 #endif  // __DEFINED__SkPdfAppearanceCharacteristicsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfAppearanceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfAppearanceDictionary_autogen.cpp
new file mode 100644
index 0000000..54ba878
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfAppearanceDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfAppearanceDictionary_autogen.h"
+
+SkPdfStream* SkPdfAppearanceDictionary::getNAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfAppearanceDictionary::getNAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfAppearanceDictionary::getRAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfAppearanceDictionary::getRAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfAppearanceDictionary::getDAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfAppearanceDictionary::getDAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfAppearanceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfAppearanceDictionary_autogen.h
index 1554916..3e8782b 100644
--- a/experimental/PdfViewer/autogen/SkPdfAppearanceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfAppearanceDictionary_autogen.h
@@ -537,26 +537,14 @@
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getNAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getNAsStream() const;
   bool isNADictionary() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getNAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getNAsDictionary() const;
 /** (Optional) The annotation's rollover appearance. Default value: the value of
  *  the N entry.
 **/
@@ -570,26 +558,14 @@
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getRAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getRAsStream() const;
   bool isRADictionary() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getRAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getRAsDictionary() const;
 /** (Optional) The annotation's down appearance. Default value: the value of the
  *  N entry.
 **/
@@ -603,26 +579,14 @@
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getDAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getDAsStream() const;
   bool isDADictionary() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getDAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getDAsDictionary() const;
 };
 
 #endif  // __DEFINED__SkPdfAppearanceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfApplicationDataDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfApplicationDataDictionary_autogen.cpp
new file mode 100644
index 0000000..ff3a3a1
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfApplicationDataDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfApplicationDataDictionary_autogen.h"
+
+SkPdfDate SkPdfApplicationDataDictionary::LastModified() const {
+  SkPdfDate ret;
+  if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfDate();
+}
+
+SkPdfObject* SkPdfApplicationDataDictionary::Private() const {
+  SkPdfObject* ret;
+  if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Private", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfApplicationDataDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfApplicationDataDictionary_autogen.h
index 4bf61d8..e82ecc3 100644
--- a/experimental/PdfViewer/autogen/SkPdfApplicationDataDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfApplicationDataDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", NULL));
   }
 
-  SkPdfDate LastModified() const {
-    SkPdfDate ret;
-    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfDate();
-  }
-
+  SkPdfDate LastModified() const;
 /** (Optional) Any private data appropriate to the application, typically
  *  in the form of a dictionary.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Private", "", NULL));
   }
 
-  SkPdfObject* Private() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Private", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfObject* Private() const;
 };
 
 #endif  // __DEFINED__SkPdfApplicationDataDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfArray_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfArray_autogen.cpp
new file mode 100644
index 0000000..fd25276
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfArray_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfArray_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfArtifactsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfArtifactsDictionary_autogen.cpp
new file mode 100644
index 0000000..bac501d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfArtifactsDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfArtifactsDictionary_autogen.h"
+
+std::string SkPdfArtifactsDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkRect* SkPdfArtifactsDictionary::BBox() const {
+  SkRect* ret;
+  if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfArtifactsDictionary::Attached() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Attached", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfArtifactsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfArtifactsDictionary_autogen.h
index 9cae252..d63a649 100644
--- a/experimental/PdfViewer/autogen/SkPdfArtifactsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfArtifactsDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Optional) An array of four numbers in default user space units giving the coor-
  *  dinates of the left, bottom, right, and top edges, respectively, of the artifact's
  *  bounding box (the rectangle that completely encloses its visible extent).
@@ -547,13 +541,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", NULL));
   }
 
-  SkRect* BBox() const {
-    SkRect* ret;
-    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkRect* BBox() const;
 /** (Optional; pagination artifacts only) An array of name objects containing one to
  *  four of the names Top, Bottom, Left, and Right, specifying the edges of the page, if
  *  any, to which the artifact is logically attached. Page edges are defined by the
@@ -565,13 +553,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Attached", "", NULL));
   }
 
-  SkPdfArray* Attached() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Attached", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Attached() const;
 };
 
 #endif  // __DEFINED__SkPdfArtifactsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfAttributeObjectDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfAttributeObjectDictionary_autogen.cpp
new file mode 100644
index 0000000..7810f46
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfAttributeObjectDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfAttributeObjectDictionary_autogen.h"
+
+std::string SkPdfAttributeObjectDictionary::O() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfAttributeObjectDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfAttributeObjectDictionary_autogen.h
index d389fc4..6c07fa8 100644
--- a/experimental/PdfViewer/autogen/SkPdfAttributeObjectDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfAttributeObjectDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", NULL));
   }
 
-  std::string O() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string O() const;
 };
 
 #endif  // __DEFINED__SkPdfAttributeObjectDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfBeadDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfBeadDictionary_autogen.cpp
new file mode 100644
index 0000000..69c6b07
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfBeadDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfBeadDictionary_autogen.h"
+
+std::string SkPdfBeadDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfBeadDictionary::T() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfBeadDictionary::N() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfBeadDictionary::V() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfBeadDictionary::P() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkRect* SkPdfBeadDictionary::R() const {
+  SkRect* ret;
+  if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfBeadDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfBeadDictionary_autogen.h
index 4b479c0..24611f7 100644
--- a/experimental/PdfViewer/autogen/SkPdfBeadDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfBeadDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required for the first bead of a thread; optional for all others; must be an indirect refer-
  *  ence) The thread to which this bead belongs.
  *  Note: In PDF 1.1, this entry is permitted only for the first bead of a thread. In PDF 1.2
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", NULL));
   }
 
-  SkPdfDictionary* T() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* T() const;
 /** (Required; must be an indirect reference) The next bead in the thread. In the last bead,
  *  this entry points to the first.
 **/
@@ -562,13 +550,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", NULL));
   }
 
-  SkPdfDictionary* N() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* N() const;
 /** (Required; must be an indirect reference) The previous bead in the thread. In the first
  *  bead, this entry points to the last.
 **/
@@ -576,13 +558,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", NULL));
   }
 
-  SkPdfDictionary* V() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* V() const;
 /** (Required; must be an indirect reference) The page object representing the page on
  *  which this bead appears.
 **/
@@ -590,26 +566,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", NULL));
   }
 
-  SkPdfDictionary* P() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* P() const;
 /** (Required) A rectangle specifying the location of this bead on the page.
 **/
   bool has_R() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", NULL));
   }
 
-  SkRect* R() const {
-    SkRect* ret;
-    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkRect* R() const;
 };
 
 #endif  // __DEFINED__SkPdfBeadDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfBlockLevelStructureElementsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfBlockLevelStructureElementsDictionary_autogen.cpp
new file mode 100644
index 0000000..720eaca
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfBlockLevelStructureElementsDictionary_autogen.cpp
@@ -0,0 +1,93 @@
+#include "SkPdfBlockLevelStructureElementsDictionary_autogen.h"
+
+double SkPdfBlockLevelStructureElementsDictionary::SpaceBefore() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpaceBefore", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfBlockLevelStructureElementsDictionary::SpaceAfter() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpaceAfter", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfBlockLevelStructureElementsDictionary::StartIndent() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StartIndent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfBlockLevelStructureElementsDictionary::EndIndent() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndIndent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfBlockLevelStructureElementsDictionary::TextIndent() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TextIndent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfBlockLevelStructureElementsDictionary::TextAlign() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TextAlign", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkRect* SkPdfBlockLevelStructureElementsDictionary::BBox() const {
+  SkRect* ret;
+  if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+double SkPdfBlockLevelStructureElementsDictionary::getWidthAsNumber() const {
+  double ret = 0;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfBlockLevelStructureElementsDictionary::getWidthAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+double SkPdfBlockLevelStructureElementsDictionary::getHeightAsNumber() const {
+  double ret = 0;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfBlockLevelStructureElementsDictionary::getHeightAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfBlockLevelStructureElementsDictionary::BlockAlign() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlockAlign", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfBlockLevelStructureElementsDictionary::InlineAlign() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InlineAlign", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfBlockLevelStructureElementsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfBlockLevelStructureElementsDictionary_autogen.h
index 88dd0c7..777911a 100644
--- a/experimental/PdfViewer/autogen/SkPdfBlockLevelStructureElementsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfBlockLevelStructureElementsDictionary_autogen.h
@@ -538,13 +538,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpaceBefore", "", NULL));
   }
 
-  double SpaceBefore() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpaceBefore", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double SpaceBefore() const;
 /** (Optional) The amount of extra space following the after edge of the BLSE,
  *  measured in default user space units in the block-progression direction. This
  *  value is added to any adjustments induced by the LineHeight attributes of
@@ -558,13 +552,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpaceAfter", "", NULL));
   }
 
-  double SpaceAfter() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpaceAfter", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double SpaceAfter() const;
 /** (Optional) The distance from the start edge of the reference area to that of the
  *  BLSE, measured in default user space units in the inline-progression direc-
  *  tion. This attribute applies only to structure elements with a Placement
@@ -584,13 +572,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StartIndent", "", NULL));
   }
 
-  double StartIndent() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StartIndent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double StartIndent() const;
 /** (Optional) The distance from the end edge of the BLSE to that of the ref-
  *  erence area, measured in default user space units in the inline-progression
  *  direction. This attribute applies only to structure elements with a Placement
@@ -608,13 +590,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndIndent", "", NULL));
   }
 
-  double EndIndent() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndIndent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double EndIndent() const;
 /** (Optional; applies only to some BLSEs, as described below) The additional
  *  distance, measured in default user space units in the inline-progression
  *  direction, from the start edge of the BLSE, as specified by StartIndent
@@ -628,13 +604,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TextIndent", "", NULL));
   }
 
-  double TextIndent() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TextIndent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double TextIndent() const;
 /** (Optional; applies only to BLSEs containing text) The alignment, in the inline-
  *  progression direction, of text and other content within lines of the BLSE:
  *  Start        Aligned with the start edge.
@@ -650,13 +620,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TextAlign", "", NULL));
   }
 
-  std::string TextAlign() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TextAlign", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string TextAlign() const;
 /** (Illustrations and tables only; required if the element appears in its entirety on a
  *  single page) An array of four numbers in default user space units giving the
  *  coordinates of the left, bottom, right, and top edges, respectively, of the ele-
@@ -668,13 +632,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", NULL));
   }
 
-  SkRect* BBox() const {
-    SkRect* ret;
-    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkRect* BBox() const;
 /** (Optional; illustrations, tables, table headers, and table cells only; strongly
  *  recommended for table cells) The desired width of the element's content
  *  rectangle (see "Content and Allocation Rectangles" on page 648), measured
@@ -695,26 +653,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Real || ret->podofo()->GetDataType() == ePdfDataType_Number;
   }
 
-  double getWidthAsNumber() const {
-    double ret = 0;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double getWidthAsNumber() const;
   bool isWidthAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getWidthAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getWidthAsName() const;
 /** (Optional; illustrations, tables, table headers, and table cells only) The desired
  *  height of the element's content rectangle (see "Content and Allocation
  *  Rectangles" on page 648), measured in default user space units in the block-
@@ -734,26 +680,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Real || ret->podofo()->GetDataType() == ePdfDataType_Number;
   }
 
-  double getHeightAsNumber() const {
-    double ret = 0;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double getHeightAsNumber() const;
   bool isHeightAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getHeightAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getHeightAsName() const;
 /** (Optional; table cells only) The alignment, in the block-progression direction,
  *  of content within the table cell:
  *       Before        Before edge of the first child's allocation rectangle aligned
@@ -780,13 +714,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlockAlign", "", NULL));
   }
 
-  std::string BlockAlign() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlockAlign", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string BlockAlign() const;
 /** (Optional; table cells only) The alignment, in the inline-progression direction,
  *  of content within the table cell:
  *     Start         Start edge of each child's allocation rectangle aligned with
@@ -807,13 +735,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InlineAlign", "", NULL));
   }
 
-  std::string InlineAlign() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InlineAlign", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string InlineAlign() const;
 };
 
 #endif  // __DEFINED__SkPdfBlockLevelStructureElementsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfBoolean_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfBoolean_autogen.cpp
new file mode 100644
index 0000000..1528b04
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfBoolean_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfBoolean_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfBorderStyleDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfBorderStyleDictionary_autogen.cpp
new file mode 100644
index 0000000..f26588a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfBorderStyleDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfBorderStyleDictionary_autogen.h"
+
+std::string SkPdfBorderStyleDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+double SkPdfBorderStyleDictionary::W() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfBorderStyleDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfBorderStyleDictionary::D() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfBorderStyleDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfBorderStyleDictionary_autogen.h
index 5513a0e..e4d66b9 100644
--- a/experimental/PdfViewer/autogen/SkPdfBorderStyleDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfBorderStyleDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Optional) The border width in points. If this value is 0, no border is drawn. Default
  *  value: 1.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", NULL));
   }
 
-  double W() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double W() const;
 /** (Optional) The border style:
  *      S    (Solid) A solid rectangle surrounding the annotation.
  *      D    (Dashed) A dashed rectangle surrounding the annotation. The dash pattern
@@ -569,13 +557,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Optional) A dash array defining a pattern of dashes and gaps to be used in drawing a
  *  dashed border (border style D above). The dash array is specified in the same format
  *  as in the line dash pattern parameter of the graphics state (see "Line Dash Pattern" on
@@ -587,13 +569,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", NULL));
   }
 
-  SkPdfArray* D() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* D() const;
 };
 
 #endif  // __DEFINED__SkPdfBorderStyleDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfBoxColorInformationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfBoxColorInformationDictionary_autogen.cpp
new file mode 100644
index 0000000..7ce6524
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfBoxColorInformationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfBoxColorInformationDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfBoxColorInformationDictionary::CropBox() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfBoxColorInformationDictionary::BleedBox() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfBoxColorInformationDictionary::TrimBox() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfBoxColorInformationDictionary::ArtBox() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfBoxColorInformationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfBoxColorInformationDictionary_autogen.h
index c50cfea..bd28198 100644
--- a/experimental/PdfViewer/autogen/SkPdfBoxColorInformationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfBoxColorInformationDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", NULL));
   }
 
-  SkPdfDictionary* CropBox() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* CropBox() const;
 /** (Optional) A box style dictionary (see Table 9.42) specifying the visual characteris-
  *  tics for displaying guidelines for the page's bleed box. This entry is ignored if no
  *  bleed box is defined in the page object.
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", NULL));
   }
 
-  SkPdfDictionary* BleedBox() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* BleedBox() const;
 /** (Optional) A box style dictionary (see Table 9.42) specifying the visual characteris-
  *  tics for displaying guidelines for the page's trim box. This entry is ignored if no trim
  *  box is defined in the page object.
@@ -563,13 +551,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", NULL));
   }
 
-  SkPdfDictionary* TrimBox() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* TrimBox() const;
 /** (Optional) A box style dictionary (see Table 9.42) specifying the visual characteris-
  *  tics for displaying guidelines for the page's art box. This entry is ignored if no art
  *  box is defined in the page object.
@@ -578,13 +560,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", NULL));
   }
 
-  SkPdfDictionary* ArtBox() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* ArtBox() const;
 };
 
 #endif  // __DEFINED__SkPdfBoxColorInformationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfBoxStyleDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfBoxStyleDictionary_autogen.cpp
new file mode 100644
index 0000000..d2dccef
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfBoxStyleDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfBoxStyleDictionary_autogen.h"
+
+SkPdfArray* SkPdfBoxStyleDictionary::C() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+double SkPdfBoxStyleDictionary::W() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfBoxStyleDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfBoxStyleDictionary::D() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfBoxStyleDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfBoxStyleDictionary_autogen.h
index d68b868..92d2b5a 100644
--- a/experimental/PdfViewer/autogen/SkPdfBoxStyleDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfBoxStyleDictionary_autogen.h
@@ -533,26 +533,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
   }
 
-  SkPdfArray* C() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* C() const;
 /** (Optional) The guideline width in default user space units. Default value: 1.
 **/
   bool has_W() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", NULL));
   }
 
-  double W() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double W() const;
 /** (Optional) The guideline style:
  *      S    (Solid) A solid rectangle.
  *      D    (Dashed) A dashed rectangle. The dash pattern is specified by the D entry
@@ -563,13 +551,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Optional) A dash array defining a pattern of dashes and gaps to be used in drawing
  *  dashed guidelines (guideline style D above). The dash array is specified in default
  *  user space units, in the same format as in the line dash pattern parameter of the
@@ -581,13 +563,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", NULL));
   }
 
-  SkPdfArray* D() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* D() const;
 };
 
 #endif  // __DEFINED__SkPdfBoxStyleDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCIDFontDescriptorDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCIDFontDescriptorDictionary_autogen.cpp
new file mode 100644
index 0000000..56ece28
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCIDFontDescriptorDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfCIDFontDescriptorDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfCIDFontDescriptorDictionary::Style() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Style", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfCIDFontDescriptorDictionary::Lang() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfCIDFontDescriptorDictionary::FD() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FD", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfCIDFontDescriptorDictionary::CIDSet() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSet", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCIDFontDescriptorDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCIDFontDescriptorDictionary_autogen.h
index 4693429..f544eaa 100644
--- a/experimental/PdfViewer/autogen/SkPdfCIDFontDescriptorDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCIDFontDescriptorDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Style", "", NULL));
   }
 
-  SkPdfDictionary* Style() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Style", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Style() const;
 /** (Optional) A name specifying the language of the font, used for encodings where
  *  the language is not implied by the encoding itself. The possible values are the
  *  2-character language codes defined by ISO 639-for example, en for English and ja
@@ -549,13 +543,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", NULL));
   }
 
-  std::string Lang() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Lang() const;
 /** (Optional) A dictionary whose keys identify a class of characters in a CIDFont.
  *  Each value is a dictionary containing entries that override the corresponding
  *  values in the main font descriptor dictionary for that class of characters (see "FD,"
@@ -565,13 +553,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FD", "", NULL));
   }
 
-  SkPdfDictionary* FD() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FD", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* FD() const;
 /** (Optional) A stream identifying which CIDs are present in the CIDFont file. If this
  *  entry is present, the CIDFont contains only a subset of the glyphs in the character
  *  collection defined by the CIDSystemInfo dictionary. If it is absent, the only indica-
@@ -585,13 +567,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSet", "", NULL));
   }
 
-  SkPdfStream* CIDSet() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSet", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* CIDSet() const;
 };
 
 #endif  // __DEFINED__SkPdfCIDFontDescriptorDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCIDFontDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCIDFontDictionary_autogen.cpp
new file mode 100644
index 0000000..069a631
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCIDFontDictionary_autogen.cpp
@@ -0,0 +1,79 @@
+#include "SkPdfCIDFontDictionary_autogen.h"
+
+std::string SkPdfCIDFontDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfCIDFontDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfCIDFontDictionary::BaseFont() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfCIDFontDictionary::CIDSystemInfo() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfCIDFontDictionary::FontDescriptor() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontDescriptor", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfCIDFontDictionary::DW() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfCIDFontDictionary::W() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfCIDFontDictionary::DW2() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW2", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfCIDFontDictionary::W2() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W2", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfCIDFontDictionary::getCIDToGIDMapAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfCIDFontDictionary::getCIDToGIDMapAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCIDFontDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCIDFontDictionary_autogen.h
index c213bad..1ebc2ee 100644
--- a/experimental/PdfViewer/autogen/SkPdfCIDFontDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCIDFontDictionary_autogen.h
@@ -49,26 +49,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The type of CIDFont; CIDFontType0 or CIDFontType2.
 **/
   bool has_Subtype() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required) The PostScript name of the CIDFont. For Type 0 CIDFonts, this
  *  is usually the value of the CIDFontName entry in the CIDFont program. For
  *  Type 2 CIDFonts, it is derived the same way as for a simple TrueType font;
@@ -79,13 +67,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", NULL));
   }
 
-  std::string BaseFont() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string BaseFont() const;
 /** (Required) A dictionary containing entries that define the character collec-
  *  tion of the CIDFont. See Table 5.12 on page 337.
 **/
@@ -93,13 +75,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", NULL));
   }
 
-  SkPdfDictionary* CIDSystemInfo() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* CIDSystemInfo() const;
 /** (Required; must be an indirect reference) A font descriptor describing the
  *  CIDFont's default metrics other than its glyph widths (see Section 5.7,
  *  "Font Descriptors").
@@ -108,13 +84,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontDescriptor", "", NULL));
   }
 
-  SkPdfDictionary* FontDescriptor() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontDescriptor", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* FontDescriptor() const;
 /** (Optional) The default width for glyphs in the CIDFont (see "Glyph Met-
  *  rics in CIDFonts" on page 340). Default value: 1000.
 **/
@@ -122,13 +92,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW", "", NULL));
   }
 
-  long DW() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long DW() const;
 /** (Optional) A description of the widths for the glyphs in the CIDFont. The
  *  array's elements have a variable format that can specify individual widths
  *  for consecutive CIDs or one width for a range of CIDs (see "Glyph Metrics
@@ -139,13 +103,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", NULL));
   }
 
-  SkPdfArray* W() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* W() const;
 /** (Optional; applies only to CIDFonts used for vertical writing) An array of two
  *  numbers specifying the default metrics for vertical writing (see "Glyph
  *  Metrics in CIDFonts" on page 340). Default value: [880 -1000].
@@ -154,13 +112,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW2", "", NULL));
   }
 
-  SkPdfArray* DW2() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DW2", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* DW2() const;
 /** (Optional; applies only to CIDFonts used for vertical writing) A description of
  *  the metrics for vertical writing for the glyphs in the CIDFont (see "Glyph
  *  Metrics in CIDFonts" on page 340). Default value: none (the DW2 value is
@@ -170,13 +122,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W2", "", NULL));
   }
 
-  SkPdfArray* W2() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "W2", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* W2() const;
 /** (Optional; Type 2 CIDFonts only) A specification of the mapping from CIDs
  *  to glyph indices. If the value is a stream, the bytes in the stream contain the
  *  mapping from CIDs to glyph indices: the glyph index for a particular CID
@@ -197,26 +143,14 @@
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getCIDToGIDMapAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getCIDToGIDMapAsStream() const;
   bool isCIDToGIDMapAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getCIDToGIDMapAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDToGIDMap", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getCIDToGIDMapAsName() const;
 };
 
 #endif  // __DEFINED__SkPdfCIDFontDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCIDSystemInfoDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCIDSystemInfoDictionary_autogen.cpp
new file mode 100644
index 0000000..37223f1
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCIDSystemInfoDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfCIDSystemInfoDictionary_autogen.h"
+
+std::string SkPdfCIDSystemInfoDictionary::Registry() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Registry", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfCIDSystemInfoDictionary::Ordering() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ordering", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfCIDSystemInfoDictionary::Supplement() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Supplement", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCIDSystemInfoDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCIDSystemInfoDictionary_autogen.h
index a23f106..9dfcb72 100644
--- a/experimental/PdfViewer/autogen/SkPdfCIDSystemInfoDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCIDSystemInfoDictionary_autogen.h
@@ -534,13 +534,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Registry", "", NULL));
   }
 
-  std::string Registry() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Registry", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Registry() const;
 /** (Required) A string that uniquely names the character collection within the speci-
  *  fied registry-for example, Japan1.
 **/
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ordering", "", NULL));
   }
 
-  std::string Ordering() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ordering", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Ordering() const;
 /** (Required) The supplement number of the character collection. An original charac-
  *  ter collection has a supplement number of 0. Whenever additional CIDs are
  *  assigned in a character collection, the supplement number is increased. Supple-
@@ -565,13 +553,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Supplement", "", NULL));
   }
 
-  long Supplement() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Supplement", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Supplement() const;
 };
 
 #endif  // __DEFINED__SkPdfCIDSystemInfoDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCMapDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCMapDictionary_autogen.cpp
new file mode 100644
index 0000000..203dca4
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCMapDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfCMapDictionary_autogen.h"
+
+std::string SkPdfCMapDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfCMapDictionary::CMapName() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CMapName", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfCMapDictionary::getCIDSystemInfoAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfCMapDictionary::getCIDSystemInfoAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfCMapDictionary::WMode() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WMode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfCMapDictionary::getUseCMapAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfStream* SkPdfCMapDictionary::getUseCMapAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCMapDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCMapDictionary_autogen.h
index 98d95f4..4f4538b 100644
--- a/experimental/PdfViewer/autogen/SkPdfCMapDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCMapDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The PostScript name of the CMap. This should be the same as the
  *  value of CMapName in the CMap file itself.
 **/
@@ -547,13 +541,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CMapName", "", NULL));
   }
 
-  std::string CMapName() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CMapName", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string CMapName() const;
 /** (Required) A dictionary or array containing entries that define the character
  *  collection for the CIDFont or CIDFonts associated with the CMap. If the
  *  CMap selects only font number 0 and specifies character selectors that are
@@ -580,26 +568,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getCIDSystemInfoAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getCIDSystemInfoAsDictionary() const;
   bool isCIDSystemInfoAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getCIDSystemInfoAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CIDSystemInfo", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getCIDSystemInfoAsArray() const;
 /** (Optional) A code that determines the writing mode for any CIDFont with
  *  which this CMap is combined:
  *      0    Horizontal
@@ -612,13 +588,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WMode", "", NULL));
   }
 
-  long WMode() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WMode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long WMode() const;
 /** (Optional) The name of a predefined CMap, or a stream containing a CMap,
  *  that is to be used as the base for this CMap. This allows the CMap to be de-
  *  fined differentially, specifying only the character mappings that differ from
@@ -634,26 +604,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getUseCMapAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getUseCMapAsName() const;
   bool isUseCMapAStream() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return false;
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getUseCMapAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UseCMap", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getUseCMapAsStream() const;
 };
 
 #endif  // __DEFINED__SkPdfCMapDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCalgrayColorSpaceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCalgrayColorSpaceDictionary_autogen.cpp
new file mode 100644
index 0000000..72e9cc7
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCalgrayColorSpaceDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfCalgrayColorSpaceDictionary_autogen.h"
+
+SkPdfArray* SkPdfCalgrayColorSpaceDictionary::WhitePoint() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfCalgrayColorSpaceDictionary::BlackPoint() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+double SkPdfCalgrayColorSpaceDictionary::Gamma() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCalgrayColorSpaceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCalgrayColorSpaceDictionary_autogen.h
index e7b79e1..635ba2e 100644
--- a/experimental/PdfViewer/autogen/SkPdfCalgrayColorSpaceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCalgrayColorSpaceDictionary_autogen.h
@@ -534,13 +534,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", NULL));
   }
 
-  SkPdfArray* WhitePoint() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* WhitePoint() const;
 /** (Optional) An array of three numbers [ XB YB ZB ] specifying the tristimulus
  *  value, in the CIE 1931 XYZ space, of the diffuse black point; see "CalRGB
  *  Color Spaces," below, for further discussion. All three of these numbers must
@@ -550,13 +544,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", NULL));
   }
 
-  SkPdfArray* BlackPoint() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* BlackPoint() const;
 /** (Optional) A number G defining the gamma for the gray (A) component. G
  *  must be positive and will generally be greater than or equal to 1. Default
  *  value: 1.
@@ -565,13 +553,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", NULL));
   }
 
-  double Gamma() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double Gamma() const;
 };
 
 #endif  // __DEFINED__SkPdfCalgrayColorSpaceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCalrgbColorSpaceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCalrgbColorSpaceDictionary_autogen.cpp
new file mode 100644
index 0000000..f2faeaf
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCalrgbColorSpaceDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfCalrgbColorSpaceDictionary_autogen.h"
+
+SkPdfArray* SkPdfCalrgbColorSpaceDictionary::WhitePoint() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfCalrgbColorSpaceDictionary::BlackPoint() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfCalrgbColorSpaceDictionary::Gamma() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfCalrgbColorSpaceDictionary::Matrix() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCalrgbColorSpaceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCalrgbColorSpaceDictionary_autogen.h
index b3b5a3d..500fad6 100644
--- a/experimental/PdfViewer/autogen/SkPdfCalrgbColorSpaceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCalrgbColorSpaceDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", NULL));
   }
 
-  SkPdfArray* WhitePoint() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* WhitePoint() const;
 /** (Optional) An array of three numbers [ XB YB ZB ] specifying the tristimulus value, in
  *  the CIE 1931 XYZ space, of the diffuse black point; see below for further discussion.
  *  All three of these numbers must be nonnegative. Default value: [0.0 0.0 0.0].
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", NULL));
   }
 
-  SkPdfArray* BlackPoint() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* BlackPoint() const;
 /** (Optional) An array of three numbers [ GR GG GB ] specifying the gamma for the red,
  *  green, and blue (A, B, and C) components of the color space. Default value:
  *  [1.0 1.0 1.0].
@@ -563,13 +551,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", NULL));
   }
 
-  SkPdfArray* Gamma() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Gamma", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Gamma() const;
 /** (Optional) An array of nine numbers [ XA YA ZA XB YB ZB XC YC ZC ] specifying
  *  the linear interpretation of the decoded A, B, and C components of the color space
  *  with respect to the final XYZ representation. Default value: the identity matrix
@@ -579,13 +561,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", NULL));
   }
 
-  SkPdfArray* Matrix() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Matrix() const;
 };
 
 #endif  // __DEFINED__SkPdfCalrgbColorSpaceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCatalogDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCatalogDictionary_autogen.cpp
new file mode 100644
index 0000000..bbe7861
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCatalogDictionary_autogen.cpp
@@ -0,0 +1,163 @@
+#include "SkPdfCatalogDictionary_autogen.h"
+
+std::string SkPdfCatalogDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfCatalogDictionary::Version() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::Pages() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+double SkPdfCatalogDictionary::getPageLabelsAsNumber() const {
+  double ret = 0;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfTree* SkPdfCatalogDictionary::getPageLabelsAsTree() const {
+  SkPdfTree* ret = NULL;
+  if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::Names() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::Dests() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::ViewerPreferences() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewerPreferences", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfCatalogDictionary::PageLayout() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLayout", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfCatalogDictionary::PageMode() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageMode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::Outlines() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Outlines", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfCatalogDictionary::Threads() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Threads", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfCatalogDictionary::getOpenActionAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::getOpenActionAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::AA() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::URI() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URI", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::AcroForm() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AcroForm", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfCatalogDictionary::Metadata() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::StructTreeRoot() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructTreeRoot", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::MarkInfo() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MarkInfo", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfCatalogDictionary::Lang() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfCatalogDictionary::SpiderInfo() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpiderInfo", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfCatalogDictionary::OutputIntents() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputIntents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCatalogDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCatalogDictionary_autogen.h
index 021f118..f98e413 100644
--- a/experimental/PdfViewer/autogen/SkPdfCatalogDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCatalogDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Optional; PDF 1.4) The version of the PDF specification to which the
  *  document conforms (for example, 1.4), if later than the version specified
  *  in the file's header (see Section 3.4.1, "File Header"). If the header speci-
@@ -555,13 +549,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", NULL));
   }
 
-  std::string Version() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Version() const;
 /** (Required; must be an indirect reference) The page tree node that is the
  *  root of the document's page tree (see Section 3.6.2, "Page Tree").
 **/
@@ -569,13 +557,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", NULL));
   }
 
-  SkPdfDictionary* Pages() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Pages() const;
 /** (Optional; PDF 1.3) A number tree (see Section 3.8.5, "Number Trees")
  *  defining the page labeling for the document. The keys in this tree are
  *  page indices; the corresponding values are page label dictionaries (see
@@ -593,26 +575,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Real || ret->podofo()->GetDataType() == ePdfDataType_Number;
   }
 
-  double getPageLabelsAsNumber() const {
-    double ret = 0;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double getPageLabelsAsNumber() const;
   bool isPageLabelsATree() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfTree* getPageLabelsAsTree() const {
-    SkPdfTree* ret = NULL;
-    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLabels", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfTree* getPageLabelsAsTree() const;
 /** (Optional; PDF 1.2) The document's name dictionary (see Section 3.6.3,
  *  "Name Dictionary").
 **/
@@ -620,13 +590,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", NULL));
   }
 
-  SkPdfDictionary* Names() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Names() const;
 /** (Optional; PDF 1.1; must be an indirect reference) A dictionary of names
  *  and corresponding destinations (see "Named Destinations" on page
  *  476).
@@ -635,13 +599,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", NULL));
   }
 
-  SkPdfDictionary* Dests() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Dests() const;
 /** (Optional; PDF 1.2) A viewer preferences dictionary (see Section 8.1,
  *  "Viewer Preferences") specifying the way the document is to be dis-
  *  played on the screen. If this entry is absent, viewer applications should
@@ -651,13 +609,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewerPreferences", "", NULL));
   }
 
-  SkPdfDictionary* ViewerPreferences() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewerPreferences", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* ViewerPreferences() const;
 /** (Optional) A name object specifying the page layout to be used when the
  *  document is opened:
  *      SinglePage           Display one page at a time.
@@ -672,13 +624,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLayout", "", NULL));
   }
 
-  std::string PageLayout() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageLayout", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string PageLayout() const;
 /** (Optional) A name object specifying how the document should be dis-
  *  played when opened:
  *      UseNone              Neither document outline nor thumbnail im-
@@ -693,13 +639,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageMode", "", NULL));
   }
 
-  std::string PageMode() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PageMode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string PageMode() const;
 /** (Optional; must be an indirect reference) The outline dictionary that is the
  *  root of the document's outline hierarchy (see Section 8.2.2, "Document
  *  Outline").
@@ -708,13 +648,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Outlines", "", NULL));
   }
 
-  SkPdfDictionary* Outlines() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Outlines", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Outlines() const;
 /** (Optional; PDF 1.1; must be an indirect reference) An array of thread
  *  dictionaries representing the document's article threads (see Section
  *  8.3.2, "Articles").
@@ -723,13 +657,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Threads", "", NULL));
   }
 
-  SkPdfArray* Threads() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Threads", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Threads() const;
 /** (Optional; PDF 1.1) A value specifying a destination to be displayed or
  *  an action to be performed when the document is opened. The value is
  *  either an array defining a destination (see Section 8.2.1, "Destinations")
@@ -747,26 +675,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getOpenActionAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getOpenActionAsArray() const;
   bool isOpenActionADictionary() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getOpenActionAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OpenAction", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getOpenActionAsDictionary() const;
 /** (Optional; PDF 1.4) An additional-actions dictionary defining the actions
  *  to be taken in response to various trigger events affecting the document
  *  as a whole (see "Trigger Events" on page 514). (See also implementation
@@ -776,13 +692,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", NULL));
   }
 
-  SkPdfDictionary* AA() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* AA() const;
 /** (Optional) A URI dictionary containing document-level information for
  *  URI (uniform resource identifier) actions (see "URI Actions" on page
  *  523).
@@ -791,13 +701,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URI", "", NULL));
   }
 
-  SkPdfDictionary* URI() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URI", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* URI() const;
 /** (Optional; PDF 1.2) The document's interactive form (AcroForm) dic-
  *  tionary (see Section 8.6.1, "Interactive Form Dictionary").
 **/
@@ -805,13 +709,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AcroForm", "", NULL));
   }
 
-  SkPdfDictionary* AcroForm() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AcroForm", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* AcroForm() const;
 /** (Optional; PDF 1.4; must be an indirect reference) A metadata stream
  *  containing metadata for the document (see Section 9.2.2, "Metadata
  *  Streams").
@@ -820,13 +718,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", NULL));
   }
 
-  SkPdfStream* Metadata() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* Metadata() const;
 /** (Optional; PDF 1.3) The document's structure tree root dictionary (see
  *  Section 9.6.1, "Structure Hierarchy").
 **/
@@ -834,13 +726,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructTreeRoot", "", NULL));
   }
 
-  SkPdfDictionary* StructTreeRoot() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructTreeRoot", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* StructTreeRoot() const;
 /** (Optional; PDF 1.4) A mark information dictionary containing informa-
  *  tion about the document's usage of Tagged PDF conventions (see Sec-
  *  tion 9.7.1, "Mark Information Dictionary").
@@ -849,13 +735,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MarkInfo", "", NULL));
   }
 
-  SkPdfDictionary* MarkInfo() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MarkInfo", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* MarkInfo() const;
 /** (Optional; PDF 1.4) A language identifier specifying the natural language
  *  for all text in the document except where overridden by language speci-
  *  fications for structure elements or marked content (see Section 9.8.1,
@@ -866,13 +746,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", NULL));
   }
 
-  std::string Lang() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Lang() const;
 /** (Optional; PDF 1.3) A Web Capture information dictionary containing
  *  state information used by the Acrobat Web Capture (AcroSpider) plug-
  *  in extension (see Section 9.9.1, "Web Capture Information Dictionary").
@@ -881,13 +755,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpiderInfo", "", NULL));
   }
 
-  SkPdfDictionary* SpiderInfo() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpiderInfo", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* SpiderInfo() const;
 /** (Optional; PDF 1.4) An array of output intent dictionaries describing the
  *  color characteristics of output devices on which the document might be
  *  rendered (see "Output Intents" on page 684).
@@ -896,13 +764,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputIntents", "", NULL));
   }
 
-  SkPdfArray* OutputIntents() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputIntents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* OutputIntents() const;
 };
 
 #endif  // __DEFINED__SkPdfCatalogDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCcittfaxdecodeFilterDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCcittfaxdecodeFilterDictionary_autogen.cpp
new file mode 100644
index 0000000..a7da6c6
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCcittfaxdecodeFilterDictionary_autogen.cpp
@@ -0,0 +1,58 @@
+#include "SkPdfCcittfaxdecodeFilterDictionary_autogen.h"
+
+long SkPdfCcittfaxdecodeFilterDictionary::K() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+bool SkPdfCcittfaxdecodeFilterDictionary::EndOfLine() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfLine", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+bool SkPdfCcittfaxdecodeFilterDictionary::EncodedByteAlign() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncodedByteAlign", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+long SkPdfCcittfaxdecodeFilterDictionary::Columns() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Columns", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfCcittfaxdecodeFilterDictionary::Rows() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rows", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+bool SkPdfCcittfaxdecodeFilterDictionary::EndOfBlock() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfBlock", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+bool SkPdfCcittfaxdecodeFilterDictionary::BlackIs1() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackIs1", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+long SkPdfCcittfaxdecodeFilterDictionary::DamagedRowsBeforeError() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DamagedRowsBeforeError", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCcittfaxdecodeFilterDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCcittfaxdecodeFilterDictionary_autogen.h
index d4701fb..a594476 100644
--- a/experimental/PdfViewer/autogen/SkPdfCcittfaxdecodeFilterDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCcittfaxdecodeFilterDictionary_autogen.h
@@ -539,13 +539,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", NULL));
   }
 
-  long K() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long K() const;
 /** ()A flag indicating whether end-of-line bit patterns are required to be
  *  present in the encoding. The CCITTFaxDecode filter always accepts
  *  end-of-line bit patterns, but requires them only if EndOfLine is true.
@@ -555,13 +549,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfLine", "", NULL));
   }
 
-  bool EndOfLine() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfLine", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool EndOfLine() const;
 /** ()A flag indicating whether the filter expects extra 0 bits before each
  *  encoded line so that the line begins on a byte boundary. If true, the
  *  filter skips over encoded bits to begin decoding each line at a byte
@@ -572,13 +560,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncodedByteAlign", "", NULL));
   }
 
-  bool EncodedByteAlign() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncodedByteAlign", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool EncodedByteAlign() const;
 /** ()The width of the image in pixels. If the value is not a multiple of 8,
  *  the filter adjusts the width of the unencoded image to the next mul-
  *  tiple of 8, so that each line starts on a byte boundary. Default value:
@@ -588,13 +570,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Columns", "", NULL));
   }
 
-  long Columns() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Columns", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Columns() const;
 /** ()The height of the image in scan lines. If the value is 0 or absent, the
  *  image's height is not predetermined, and the encoded data must be
  *  terminated by an end-of-block bit pattern or by the end of the fil-
@@ -604,13 +580,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rows", "", NULL));
   }
 
-  long Rows() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rows", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Rows() const;
 /** ()A flag indicating whether the filter expects the encoded data to be
  *  terminated by an end-of-block pattern, overriding the Rows pa-
  *  rameter. If false, the filter stops when it has decoded the number of
@@ -623,13 +593,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfBlock", "", NULL));
   }
 
-  bool EndOfBlock() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EndOfBlock", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool EndOfBlock() const;
 /** ()A flag indicating whether 1 bits are to be interpreted as black pixels
  *  and 0 bits as white pixels, the reverse of the normal PDF convention
  *  for image data. Default value: false.
@@ -638,13 +602,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackIs1", "", NULL));
   }
 
-  bool BlackIs1() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackIs1", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool BlackIs1() const;
 /** ()The number of damaged rows of data to be tolerated before an
  *  error occurs. This entry applies only if EndOfLine is true and K is
  *  nonnegative. Tolerating a damaged row means locating its end in
@@ -657,13 +615,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DamagedRowsBeforeError", "", NULL));
   }
 
-  long DamagedRowsBeforeError() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DamagedRowsBeforeError", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long DamagedRowsBeforeError() const;
 };
 
 #endif  // __DEFINED__SkPdfCcittfaxdecodeFilterDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfCheckboxFieldDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfCheckboxFieldDictionary_autogen.cpp
new file mode 100644
index 0000000..947fdf4
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfCheckboxFieldDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfCheckboxFieldDictionary_autogen.h"
+
+std::string SkPdfCheckboxFieldDictionary::Opt() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfCheckboxFieldDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfCheckboxFieldDictionary_autogen.h
index 9661ed9..1509c97 100644
--- a/experimental/PdfViewer/autogen/SkPdfCheckboxFieldDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfCheckboxFieldDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", NULL));
   }
 
-  std::string Opt() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Opt() const;
 };
 
 #endif  // __DEFINED__SkPdfCheckboxFieldDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfChoiceFieldDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfChoiceFieldDictionary_autogen.cpp
new file mode 100644
index 0000000..39ba54c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfChoiceFieldDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfChoiceFieldDictionary_autogen.h"
+
+SkPdfArray* SkPdfChoiceFieldDictionary::Opt() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfChoiceFieldDictionary::TI() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TI", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfChoiceFieldDictionary::I() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfChoiceFieldDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfChoiceFieldDictionary_autogen.h
index 6aec3e8..17d74ba 100644
--- a/experimental/PdfViewer/autogen/SkPdfChoiceFieldDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfChoiceFieldDictionary_autogen.h
@@ -535,13 +535,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", NULL));
   }
 
-  SkPdfArray* Opt() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Opt() const;
 /** (Optional; inheritable) For scrollable list boxes, the top index (the index in the Opt array
  *  of the first option visible in the list).
 **/
@@ -549,13 +543,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TI", "", NULL));
   }
 
-  long TI() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TI", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long TI() const;
 /** (Sometimes required, otherwise optional; inheritable; PDF 1.4) For choice fields that allow
  *  multiple selection (MultiSelect flag set), an array of integers, sorted in ascending order,
  *  representing the zero-based indices in the Opt array of the currently selected option
@@ -568,13 +556,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", NULL));
   }
 
-  SkPdfArray* I() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* I() const;
 };
 
 #endif  // __DEFINED__SkPdfChoiceFieldDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfComponentsWithMetadataDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfComponentsWithMetadataDictionary_autogen.cpp
new file mode 100644
index 0000000..80b5cf3
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfComponentsWithMetadataDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfComponentsWithMetadataDictionary_autogen.h"
+
+SkPdfStream* SkPdfComponentsWithMetadataDictionary::Metadata() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfComponentsWithMetadataDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfComponentsWithMetadataDictionary_autogen.h
index 401b090..7d77ce7 100644
--- a/experimental/PdfViewer/autogen/SkPdfComponentsWithMetadataDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfComponentsWithMetadataDictionary_autogen.h
@@ -531,13 +531,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", NULL));
   }
 
-  SkPdfStream* Metadata() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* Metadata() const;
 };
 
 #endif  // __DEFINED__SkPdfComponentsWithMetadataDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfDctdecodeFilterDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfDctdecodeFilterDictionary_autogen.cpp
new file mode 100644
index 0000000..66ff159
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfDctdecodeFilterDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfDctdecodeFilterDictionary_autogen.h"
+
+long SkPdfDctdecodeFilterDictionary::ColorTransform() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorTransform", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfDctdecodeFilterDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfDctdecodeFilterDictionary_autogen.h
index 7d13d01..71f1a83 100644
--- a/experimental/PdfViewer/autogen/SkPdfDctdecodeFilterDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfDctdecodeFilterDictionary_autogen.h
@@ -548,13 +548,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorTransform", "", NULL));
   }
 
-  long ColorTransform() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorTransform", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long ColorTransform() const;
 };
 
 #endif  // __DEFINED__SkPdfDctdecodeFilterDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfDeviceNColorSpaceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfDeviceNColorSpaceDictionary_autogen.cpp
new file mode 100644
index 0000000..c41bc24
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfDeviceNColorSpaceDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfDeviceNColorSpaceDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfDeviceNColorSpaceDictionary::Colorants() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colorants", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfDeviceNColorSpaceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfDeviceNColorSpaceDictionary_autogen.h
index ec96dbc..b1bd765 100644
--- a/experimental/PdfViewer/autogen/SkPdfDeviceNColorSpaceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfDeviceNColorSpaceDictionary_autogen.h
@@ -542,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colorants", "", NULL));
   }
 
-  SkPdfDictionary* Colorants() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colorants", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Colorants() const;
 };
 
 #endif  // __DEFINED__SkPdfDeviceNColorSpaceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfDictionary_autogen.cpp
new file mode 100644
index 0000000..ca56507
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfDictionary_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfDictionary_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfDocumentCatalogActionsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfDocumentCatalogActionsDictionary_autogen.cpp
new file mode 100644
index 0000000..78df9e3
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfDocumentCatalogActionsDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfDocumentCatalogActionsDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfDocumentCatalogActionsDictionary::DC() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DC", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfDocumentCatalogActionsDictionary::WS() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfDocumentCatalogActionsDictionary::DS() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfDocumentCatalogActionsDictionary::WP() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WP", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfDocumentCatalogActionsDictionary::DP() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DP", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfDocumentCatalogActionsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfDocumentCatalogActionsDictionary_autogen.h
index 515825a..201792f 100644
--- a/experimental/PdfViewer/autogen/SkPdfDocumentCatalogActionsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfDocumentCatalogActionsDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DC", "", NULL));
   }
 
-  SkPdfDictionary* DC() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DC", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* DC() const;
 /** (Optional; PDF 1.4) A JavaScript action to be performed before saving a document.
  *  (The name WS stands for "will save.")
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WS", "", NULL));
   }
 
-  SkPdfDictionary* WS() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* WS() const;
 /** (Optional; PDF 1.4) A JavaScript action to be performed after saving a document. (The
  *  name DS stands for "did save.")
 **/
@@ -560,13 +548,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DS", "", NULL));
   }
 
-  SkPdfDictionary* DS() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* DS() const;
 /** (Optional; PDF 1.4) A JavaScript action to be performed before printing a document.
  *  (The name WP stands for "will print.")
 **/
@@ -574,13 +556,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WP", "", NULL));
   }
 
-  SkPdfDictionary* WP() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WP", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* WP() const;
 /** (Optional; PDF 1.4) A JavaScript action to be performed after printing a document.
  *  (The name DP stands for "did print.")
 **/
@@ -588,13 +564,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DP", "", NULL));
   }
 
-  SkPdfDictionary* DP() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DP", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* DP() const;
 };
 
 #endif  // __DEFINED__SkPdfDocumentCatalogActionsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfDocumentInformationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfDocumentInformationDictionary_autogen.cpp
new file mode 100644
index 0000000..1b0cb1c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfDocumentInformationDictionary_autogen.cpp
@@ -0,0 +1,65 @@
+#include "SkPdfDocumentInformationDictionary_autogen.h"
+
+std::string SkPdfDocumentInformationDictionary::Title() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Title", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfDocumentInformationDictionary::Author() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Author", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfDocumentInformationDictionary::Subject() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subject", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfDocumentInformationDictionary::Keywords() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Keywords", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfDocumentInformationDictionary::Creator() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Creator", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfDocumentInformationDictionary::Producer() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Producer", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDate SkPdfDocumentInformationDictionary::CreationDate() const {
+  SkPdfDate ret;
+  if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfDate();
+}
+
+SkPdfDate SkPdfDocumentInformationDictionary::ModDate() const {
+  SkPdfDate ret;
+  if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfDate();
+}
+
+std::string SkPdfDocumentInformationDictionary::Trapped() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Trapped", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfDocumentInformationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfDocumentInformationDictionary_autogen.h
index 34e88fa..e4e80e0 100644
--- a/experimental/PdfViewer/autogen/SkPdfDocumentInformationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfDocumentInformationDictionary_autogen.h
@@ -531,52 +531,28 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Title", "", NULL));
   }
 
-  std::string Title() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Title", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Title() const;
 /** (Optional) The name of the person who created the document.
 **/
   bool has_Author() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Author", "", NULL));
   }
 
-  std::string Author() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Author", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Author() const;
 /** (Optional; PDF 1.1) The subject of the document.
 **/
   bool has_Subject() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subject", "", NULL));
   }
 
-  std::string Subject() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subject", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subject() const;
 /** (Optional; PDF 1.1) Keywords associated with the document.
 **/
   bool has_Keywords() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Keywords", "", NULL));
   }
 
-  std::string Keywords() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Keywords", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Keywords() const;
 /** (Optional) If the document was converted to PDF from another format, the
  *  name of the application (for example, Adobe FrameMaker(R)) that created the
  *  original document from which it was converted.
@@ -585,13 +561,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Creator", "", NULL));
   }
 
-  std::string Creator() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Creator", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Creator() const;
 /** (Optional) If the document was converted to PDF from another format, the
  *  name of the application (for example, Acrobat Distiller) that converted it to
  *  PDF.
@@ -600,13 +570,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Producer", "", NULL));
   }
 
-  std::string Producer() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Producer", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Producer() const;
 /** (Optional) The date and time the document was created, in human-readable
  *  form (see Section 3.8.2, "Dates").
 **/
@@ -614,13 +578,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", NULL));
   }
 
-  SkPdfDate CreationDate() const {
-    SkPdfDate ret;
-    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfDate();
-  }
-
+  SkPdfDate CreationDate() const;
 /** (Optional; PDF 1.1) The date and time the document was most recently
  *  modified, in human-readable form (see Section 3.8.2, "Dates").
 **/
@@ -628,13 +586,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", NULL));
   }
 
-  SkPdfDate ModDate() const {
-    SkPdfDate ret;
-    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfDate();
-  }
-
+  SkPdfDate ModDate() const;
 /** (Optional; PDF 1.3) A name object indicating whether the document has
  *  been modified to include trapping information (see Section 9.10.5, "Trap-
  *  ping Support"):
@@ -656,13 +608,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Trapped", "", NULL));
   }
 
-  std::string Trapped() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Trapped", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Trapped() const;
 };
 
 #endif  // __DEFINED__SkPdfDocumentInformationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfEmbeddedFileParameterDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileParameterDictionary_autogen.cpp
new file mode 100644
index 0000000..86e0a2b
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileParameterDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfEmbeddedFileParameterDictionary_autogen.h"
+
+long SkPdfEmbeddedFileParameterDictionary::Size() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfDate SkPdfEmbeddedFileParameterDictionary::CreationDate() const {
+  SkPdfDate ret;
+  if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfDate();
+}
+
+SkPdfDate SkPdfEmbeddedFileParameterDictionary::ModDate() const {
+  SkPdfDate ret;
+  if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfDate();
+}
+
+SkPdfDictionary* SkPdfEmbeddedFileParameterDictionary::Mac() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfEmbeddedFileParameterDictionary::CheckSum() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CheckSum", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfEmbeddedFileParameterDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileParameterDictionary_autogen.h
index fedb722..7248bfb 100644
--- a/experimental/PdfViewer/autogen/SkPdfEmbeddedFileParameterDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileParameterDictionary_autogen.h
@@ -531,39 +531,21 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", NULL));
   }
 
-  long Size() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Size() const;
 /** (Optional) The date and time when the embedded file was created.
 **/
   bool has_CreationDate() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", NULL));
   }
 
-  SkPdfDate CreationDate() const {
-    SkPdfDate ret;
-    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CreationDate", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfDate();
-  }
-
+  SkPdfDate CreationDate() const;
 /** (Optional) The date and time when the embedded file was last modified.
 **/
   bool has_ModDate() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", NULL));
   }
 
-  SkPdfDate ModDate() const {
-    SkPdfDate ret;
-    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ModDate", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfDate();
-  }
-
+  SkPdfDate ModDate() const;
 /** (Optional) A subdictionary containing additional information specific to
  *  Mac OS files (see Table 3.35).
 **/
@@ -571,13 +553,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", NULL));
   }
 
-  SkPdfDictionary* Mac() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Mac() const;
 /** (Optional) A 16-byte string that is the checksum of the bytes of the uncom-
  *  pressed embedded file. The checksum is calculated by applying the standard
  *  MD5 message-digest algorithm (described in Internet RFC 1321, The MD5
@@ -588,13 +564,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CheckSum", "", NULL));
   }
 
-  std::string CheckSum() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CheckSum", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string CheckSum() const;
 };
 
 #endif  // __DEFINED__SkPdfEmbeddedFileParameterDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfEmbeddedFileStreamDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileStreamDictionary_autogen.cpp
new file mode 100644
index 0000000..1f3367f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileStreamDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfEmbeddedFileStreamDictionary_autogen.h"
+
+std::string SkPdfEmbeddedFileStreamDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfEmbeddedFileStreamDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfEmbeddedFileStreamDictionary::Params() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Params", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfEmbeddedFileStreamDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileStreamDictionary_autogen.h
index 96479fc..cd43e74 100644
--- a/experimental/PdfViewer/autogen/SkPdfEmbeddedFileStreamDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfEmbeddedFileStreamDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Optional) The subtype of the embedded file. The value of this entry must be
  *  a first-class name, as defined in Appendix E. Names without a registered pre-
  *  fix must conform to the MIME media type names defined in Internet RFC
@@ -551,13 +545,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Optional) An embedded file parameter dictionary containing additional, file-
  *  specific information (see Table 3.34).
 **/
@@ -565,13 +553,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Params", "", NULL));
   }
 
-  SkPdfDictionary* Params() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Params", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Params() const;
 };
 
 #endif  // __DEFINED__SkPdfEmbeddedFileStreamDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfEmbeddedFontStreamDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfEmbeddedFontStreamDictionary_autogen.cpp
new file mode 100644
index 0000000..8b01a5d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfEmbeddedFontStreamDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfEmbeddedFontStreamDictionary_autogen.h"
+
+long SkPdfEmbeddedFontStreamDictionary::Length1() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length1", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfEmbeddedFontStreamDictionary::Length2() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length2", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfEmbeddedFontStreamDictionary::Length3() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length3", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfEmbeddedFontStreamDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfStream* SkPdfEmbeddedFontStreamDictionary::Metadata() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfEmbeddedFontStreamDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfEmbeddedFontStreamDictionary_autogen.h
index 1c55026..25e12d8 100644
--- a/experimental/PdfViewer/autogen/SkPdfEmbeddedFontStreamDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfEmbeddedFontStreamDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length1", "", NULL));
   }
 
-  long Length1() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length1", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Length1() const;
 /** (Required for Type 1 fonts) The length in bytes of the encrypted portion of the Type 1
  *  font program (see below) after it has been decoded using the filters specified by the
  *  stream's Filter entry.
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length2", "", NULL));
   }
 
-  long Length2() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length2", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Length2() const;
 /** (Required for Type 1 fonts) The length in bytes of the fixed-content portion of the
  *  Type 1 font program (see below), after it has been decoded using the filters specified
  *  by the stream's Filter entry. If Length3 is 0, it indicates that the 512 zeros and clearto-
@@ -564,13 +552,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length3", "", NULL));
   }
 
-  long Length3() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length3", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Length3() const;
 /** (Required if referenced from FontFile3; PDF 1.2) A name specifying the format of the
  *  embedded font program. The name must be Type1C for Type 1 compact fonts or CID-
  *  FontType0C for Type 0 compact CIDFonts. When additional font formats are added
@@ -580,13 +562,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Optional; PDF 1.4) A metadata stream containing metadata for the embedded font
  *  program (see Section 9.2.2, "Metadata Streams").
 **/
@@ -594,13 +570,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", NULL));
   }
 
-  SkPdfStream* Metadata() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* Metadata() const;
 };
 
 #endif  // __DEFINED__SkPdfEmbeddedFontStreamDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfEncodingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfEncodingDictionary_autogen.cpp
new file mode 100644
index 0000000..c305d3b
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfEncodingDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfEncodingDictionary_autogen.h"
+
+std::string SkPdfEncodingDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfEncodingDictionary::BaseEncoding() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseEncoding", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfEncodingDictionary::Differences() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfEncodingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfEncodingDictionary_autogen.h
index 293bba4..6ec291b 100644
--- a/experimental/PdfViewer/autogen/SkPdfEncodingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfEncodingDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Optional) The base encoding-that is, the encoding from which the Differences
  *  entry (if present) describes differences-specified as the name of a predefined
  *  encoding MacRomanEncoding, MacExpertEncoding, or WinAnsiEncoding (see
@@ -554,13 +548,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseEncoding", "", NULL));
   }
 
-  std::string BaseEncoding() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseEncoding", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string BaseEncoding() const;
 /** (Optional; not recommended with TrueType fonts) An array describing the differ-
  *  ences from the encoding specified by BaseEncoding or, if BaseEncoding is ab-
  *  sent, from an implicit base encoding. The Differences array is described above.
@@ -583,13 +571,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", NULL));
   }
 
-  SkPdfArray* Differences() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Differences() const;
 };
 
 #endif  // __DEFINED__SkPdfEncodingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.cpp
new file mode 100644
index 0000000..3126cf0
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.h"
+
+long SkPdfEncryptedEmbeddedFileStreamDictionary::EncryptionRevision() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncryptionRevision", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.h
index 77be6d7..2cad87b 100644
--- a/experimental/PdfViewer/autogen/SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncryptionRevision", "", NULL));
   }
 
-  long EncryptionRevision() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EncryptionRevision", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long EncryptionRevision() const;
 };
 
 #endif  // __DEFINED__SkPdfEncryptedEmbeddedFileStreamDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfEncryptionCommonDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfEncryptionCommonDictionary_autogen.cpp
new file mode 100644
index 0000000..a38f329
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfEncryptionCommonDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfEncryptionCommonDictionary_autogen.h"
+
+std::string SkPdfEncryptionCommonDictionary::Filter() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+double SkPdfEncryptionCommonDictionary::V() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfEncryptionCommonDictionary::Length() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfEncryptionCommonDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfEncryptionCommonDictionary_autogen.h
index 5470b9b..4716986 100644
--- a/experimental/PdfViewer/autogen/SkPdfEncryptionCommonDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfEncryptionCommonDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", NULL));
   }
 
-  std::string Filter() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Filter() const;
 /** (Optional but strongly recommended) A code specifying the algorithm to be used in en-
  *  crypting and decrypting the document:
  *     0     An algorithm that is undocumented and no longer supported, and whose use is
@@ -557,13 +551,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", NULL));
   }
 
-  double V() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double V() const;
 /** (Optional; PDF 1.4; only if V is 2 or 3) The length of the encryption key, in bits. The value
  *  must be a multiple of 8, in the range 40 to 128. Default value: 40.
 **/
@@ -571,13 +559,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length", "", NULL));
   }
 
-  long Length() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Length() const;
 };
 
 #endif  // __DEFINED__SkPdfEncryptionCommonDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFCatalogDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFCatalogDictionary_autogen.cpp
new file mode 100644
index 0000000..e57079e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFCatalogDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfFDFCatalogDictionary_autogen.h"
+
+std::string SkPdfFDFCatalogDictionary::Version() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfFDFCatalogDictionary::FDF() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDF", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFCatalogDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFCatalogDictionary_autogen.h
index baddd5f..77f066f 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFCatalogDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFCatalogDictionary_autogen.h
@@ -538,26 +538,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", NULL));
   }
 
-  std::string Version() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Version() const;
 /** (Required) The FDF dictionary for this file (see Table 8.69).
 **/
   bool has_FDF() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDF", "", NULL));
   }
 
-  SkPdfDictionary* FDF() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDF", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* FDF() const;
 };
 
 #endif  // __DEFINED__SkPdfFDFCatalogDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFDictionary_autogen.cpp
new file mode 100644
index 0000000..0f749e1
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFDictionary_autogen.cpp
@@ -0,0 +1,79 @@
+#include "SkPdfFDFDictionary_autogen.h"
+
+SkPdfFileSpec SkPdfFDFDictionary::F() const {
+  SkPdfFileSpec ret;
+  if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFileSpec();
+}
+
+SkPdfArray* SkPdfFDFDictionary::ID() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfFDFDictionary::Fields() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfFDFDictionary::Status() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Status", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfFDFDictionary::Pages() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfFDFDictionary::Encoding() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfFDFDictionary::Annots() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfFDFDictionary::Differences() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfFDFDictionary::Target() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Target", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfFDFDictionary::EmbeddedFDFs() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFDFs", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfFDFDictionary::JavaScript() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFDictionary_autogen.h
index af7fc69..cd73ba9 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  SkPdfFileSpec F() const {
-    SkPdfFileSpec ret;
-    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFileSpec();
-  }
-
+  SkPdfFileSpec F() const;
 /** (Optional) An array of two strings constituting a file identifier (see
  *  Section 9.3, "File Identifiers") for the source or target file designated
  *  by F, taken from the ID entry in the file's trailer dictionary (see Sec-
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
   }
 
-  SkPdfArray* ID() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* ID() const;
 /** (Optional) An array of FDF field dictionaries (see "FDF Fields" on
  *  page 564) describing the root fields (those with no ancestors in
  *  the field hierarchy) to be exported or imported. This entry and
@@ -564,13 +552,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", NULL));
   }
 
-  SkPdfArray* Fields() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Fields() const;
 /** (Optional) A status string to be displayed indicating the result of an
  *  action, typically a submit-form action (see "Submit-Form Actions"
  *  on page 550). The string is encoded with PDFDocEncoding. (See
@@ -581,13 +563,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Status", "", NULL));
   }
 
-  std::string Status() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Status", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Status() const;
 /** (Optional; PDF 1.3) An array of FDF page dictionaries (see "FDF
  *  Pages" on page 566) describing new pages to be added to a PDF
  *  target document. The Fields and Status entries may not be present
@@ -597,13 +573,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", NULL));
   }
 
-  SkPdfArray* Pages() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Pages() const;
 /** (Optional; PDF 1.3) The encoding to be used for any FDF field
  *  value or option (V or Opt in the field dictionary; see Table 8.72 on
  *  page 564) that is a string and does not begin with the Unicode pre-
@@ -614,13 +584,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", NULL));
   }
 
-  std::string Encoding() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Encoding() const;
 /** (Optional; PDF 1.3) An array of FDF annotation dictionaries (see
  *  "FDF Annotation Dictionaries" on page 568). The array can in-
  *  clude annotations of any of the standard types listed in Table 8.14
@@ -630,13 +594,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", NULL));
   }
 
-  SkPdfArray* Annots() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Annots() const;
 /** (Optional; PDF 1.4) A stream containing all the bytes in all incre-
  *  mental updates made to the underlying PDF document since it was
  *  opened (see Section 3.4.5, "Incremental Updates"). If a submit-
@@ -660,13 +618,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", NULL));
   }
 
-  SkPdfStream* Differences() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Differences", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* Differences() const;
 /** (Optional; PDF 1.4) The name of a browser frame in which the un-
  *  derlying PDF document is to be opened. This mimics the behavior
  *  of the target attribute in HTML <href> tags.
@@ -675,13 +627,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Target", "", NULL));
   }
 
-  std::string Target() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Target", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Target() const;
 /** (Optional; PDF 1.4) An array of file specifications (see Section 3.10,
  *  "File Specifications") representing other FDF files embedded with-
  *  in this one (Section 3.10.3, "Embedded File Streams").
@@ -690,13 +636,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFDFs", "", NULL));
   }
 
-  SkPdfArray* EmbeddedFDFs() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFDFs", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* EmbeddedFDFs() const;
 /** (Optional; PDF 1.4) A JavaScript dictionary (see Table 8.71) defin-
  *  ing document-level JavaScript scripts.
 **/
@@ -704,13 +644,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", NULL));
   }
 
-  SkPdfDictionary* JavaScript() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* JavaScript() const;
 };
 
 #endif  // __DEFINED__SkPdfFDFDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFFieldDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFFieldDictionary_autogen.cpp
new file mode 100644
index 0000000..a16545f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFFieldDictionary_autogen.cpp
@@ -0,0 +1,107 @@
+#include "SkPdfFDFFieldDictionary_autogen.h"
+
+SkPdfArray* SkPdfFDFFieldDictionary::Kids() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfFDFFieldDictionary::T() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfObject* SkPdfFDFFieldDictionary::V() const {
+  SkPdfObject* ret;
+  if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfFDFFieldDictionary::Ff() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ff", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfFDFFieldDictionary::SetFf() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SetFf", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfFDFFieldDictionary::ClrFf() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClrFf", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfFDFFieldDictionary::F() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfFDFFieldDictionary::SetF() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SetF", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfFDFFieldDictionary::ClrF() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClrF", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfDictionary* SkPdfFDFFieldDictionary::AP() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfFDFFieldDictionary::APRef() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "APRef", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfFDFFieldDictionary::IF() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IF", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfFDFFieldDictionary::Opt() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfFDFFieldDictionary::A() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfFDFFieldDictionary::AA() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFFieldDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFFieldDictionary_autogen.h
index 9ece7a9..bcdf0c5 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFFieldDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFFieldDictionary_autogen.h
@@ -533,26 +533,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", NULL));
   }
 
-  SkPdfArray* Kids() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Kids() const;
 /** (Required) The partial field name (see "Field Names" on page 532).
 **/
   bool has_T() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", NULL));
   }
 
-  std::string T() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string T() const;
 /** (Optional) The field's value, whose format varies depending on the field type; see
  *  the descriptions of individual field types in Section 8.6.3 for further information.
 **/
@@ -560,13 +548,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", NULL));
   }
 
-  SkPdfObject* V() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfObject* V() const;
 /** (Optional) A set of flags specifying various characteristics of the field (see Tables
  *  8.50 on page 532, 8.53 on page 538, 8.56 on page 543, and 8.58 on page 546). When
  *  imported into an interactive form, the value of this entry replaces that of the Ff
@@ -577,13 +559,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ff", "", NULL));
   }
 
-  long Ff() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ff", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Ff() const;
 /** (Optional) A set of flags to be set (turned on) in the Ff entry of the form's cor-
  *  responding field dictionary. Bits equal to 1 in SetFf cause the corresponding bits in
  *  Ff to be set to 1. This entry is ignored if an Ff entry is present in the FDF field
@@ -593,13 +569,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SetFf", "", NULL));
   }
 
-  long SetFf() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SetFf", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long SetFf() const;
 /** (Optional) A set of flags to be cleared (turned off) in the Ff entry of the form's cor-
  *  responding field dictionary. Bits equal to 1 in ClrFf cause the corresponding bits in
  *  Ff to be set to 0. If a SetFf entry is also present in the FDF field dictionary, it is
@@ -610,13 +580,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClrFf", "", NULL));
   }
 
-  long ClrFf() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClrFf", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long ClrFf() const;
 /** (Optional) A set of flags specifying various characteristics of the field's widget anno-
  *  tation (see Section 8.4.2, "Annotation Flags"). When imported into an interactive
  *  form, the value of this entry replaces that of the F entry in the form's corresponding
@@ -627,13 +591,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  long F() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long F() const;
 /** (Optional) A set of flags to be set (turned on) in the F entry of the form's corre-
  *  sponding widget annotation dictionary. Bits equal to 1 in SetF cause the corre-
  *  sponding bits in F to be set to 1. This entry is ignored if an F entry is present in the
@@ -643,13 +601,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SetF", "", NULL));
   }
 
-  long SetF() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SetF", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long SetF() const;
 /** (Optional) A set of flags to be cleared (turned off) in the F entry of the form's corre-
  *  sponding widget annotation dictionary. Bits equal to 1 in ClrF cause the corre-
  *  sponding bits in F to be set to 0. If a SetF entry is also present in the FDF field
@@ -660,13 +612,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClrF", "", NULL));
   }
 
-  long ClrF() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClrF", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long ClrF() const;
 /** (Optional) An appearance dictionary specifying the appearance of a pushbutton
  *  field (see "Pushbuttons" on page 539). The appearance dictionary's contents are as
  *  shown in Table 8.13 on page 497, except that the values of the N, R, and D entries
@@ -676,13 +622,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", NULL));
   }
 
-  SkPdfDictionary* AP() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* AP() const;
 /** (Optional; PDF 1.3) A dictionary holding references to external PDF files contain-
  *  ing the pages to use for the appearances of a pushbutton field. This dictionary is
  *  similar to an appearance dictionary (see Table 8.13 on page 497), except that the
@@ -693,13 +633,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "APRef", "", NULL));
   }
 
-  SkPdfDictionary* APRef() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "APRef", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* APRef() const;
 /** (Optional; PDF 1.3; button fields only) An icon fit dictionary (see Table 8.73) speci-
  *  fying how to display a button field's icon within the annotation rectangle of its wid-
  *  get annotation.
@@ -708,13 +642,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IF", "", NULL));
   }
 
-  SkPdfDictionary* IF() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IF", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* IF() const;
 /** (Required; choice fields only) An array of options to be presented to the user. Each
  *  element of the array can take either of two forms:
  *  *  A text string representing one of the available options
@@ -726,13 +654,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", NULL));
   }
 
-  SkPdfArray* Opt() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Opt() const;
 /** (Optional) An action to be performed when this field's widget annotation is activat-
  *  ed (see Section 8.5, "Actions").
 **/
@@ -740,13 +662,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", NULL));
   }
 
-  SkPdfDictionary* A() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* A() const;
 /** (Optional) An additional-actions dictionary defining the field's behavior in re-
  *  sponse to various trigger events (see Section 8.5.2, "Trigger Events").
 **/
@@ -754,13 +670,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", NULL));
   }
 
-  SkPdfDictionary* AA() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* AA() const;
 };
 
 #endif  // __DEFINED__SkPdfFDFFieldDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFFileAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFFileAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..f34d1d6
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFFileAnnotationDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfFDFFileAnnotationDictionary_autogen.h"
+
+long SkPdfFDFFileAnnotationDictionary::Page() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFFileAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFFileAnnotationDictionary_autogen.h
index 1e5b26a..dab235e 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFFileAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFFileAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", NULL));
   }
 
-  long Page() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Page() const;
 };
 
 #endif  // __DEFINED__SkPdfFDFFileAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFNamedPageReferenceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFNamedPageReferenceDictionary_autogen.cpp
new file mode 100644
index 0000000..9fdda2d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFNamedPageReferenceDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfFDFNamedPageReferenceDictionary_autogen.h"
+
+std::string SkPdfFDFNamedPageReferenceDictionary::Name() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfFileSpec SkPdfFDFNamedPageReferenceDictionary::F() const {
+  SkPdfFileSpec ret;
+  if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFileSpec();
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFNamedPageReferenceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFNamedPageReferenceDictionary_autogen.h
index 41b765f..6cdbe93 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFNamedPageReferenceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFNamedPageReferenceDictionary_autogen.h
@@ -531,13 +531,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
   }
 
-  std::string Name() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Name() const;
 /** (Optional) The file containing the named page. If this key is absent, it is
  *  assumed that the page resides in the associated PDF file.
 **/
@@ -545,13 +539,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  SkPdfFileSpec F() const {
-    SkPdfFileSpec ret;
-    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFileSpec();
-  }
-
+  SkPdfFileSpec F() const;
 };
 
 #endif  // __DEFINED__SkPdfFDFNamedPageReferenceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFPageDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFPageDictionary_autogen.cpp
new file mode 100644
index 0000000..6e25ecb
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFPageDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfFDFPageDictionary_autogen.h"
+
+SkPdfArray* SkPdfFDFPageDictionary::Templates() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfFDFPageDictionary::Info() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFPageDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFPageDictionary_autogen.h
index 509bd7b..32d1719 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFPageDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFPageDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", NULL));
   }
 
-  SkPdfArray* Templates() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Templates() const;
 /** (Optional) An FDF page information dictionary containing additional informa-
  *  tion about the page. At the time of publication, no entries have been defined for
  *  this dictionary.
@@ -547,13 +541,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", NULL));
   }
 
-  SkPdfDictionary* Info() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Info() const;
 };
 
 #endif  // __DEFINED__SkPdfFDFPageDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFTemplateDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFTemplateDictionary_autogen.cpp
new file mode 100644
index 0000000..9aa27b7
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFTemplateDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfFDFTemplateDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfFDFTemplateDictionary::TRef() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TRef", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfFDFTemplateDictionary::Fields() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+bool SkPdfFDFTemplateDictionary::Rename() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rename", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFTemplateDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFTemplateDictionary_autogen.h
index 92bfa1a..3123a93 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFTemplateDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFTemplateDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TRef", "", NULL));
   }
 
-  SkPdfDictionary* TRef() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TRef", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* TRef() const;
 /** (Optional) An array of references to FDF field dictionaries (see Table 8.72 on
  *  page 564) describing the root fields to be imported (those with no ancestors in
  *  the field hierarchy).
@@ -547,13 +541,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", NULL));
   }
 
-  SkPdfArray* Fields() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Fields() const;
 /** (Optional) A flag specifying whether fields imported from the template may be
  *  renamed in the event of name conflicts with existing fields; see below for further
  *  discussion. Default value: true.
@@ -562,13 +550,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rename", "", NULL));
   }
 
-  bool Rename() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rename", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool Rename() const;
 };
 
 #endif  // __DEFINED__SkPdfFDFTemplateDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFTrailerDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFDFTrailerDictionary_autogen.cpp
new file mode 100644
index 0000000..f376306
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFDFTrailerDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfFDFTrailerDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfFDFTrailerDictionary::Root() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Root", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFDFTrailerDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFDFTrailerDictionary_autogen.h
index 12ac84c..ca381e0 100644
--- a/experimental/PdfViewer/autogen/SkPdfFDFTrailerDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFDFTrailerDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Root", "", NULL));
   }
 
-  SkPdfDictionary* Root() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Root", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Root() const;
 };
 
 #endif  // __DEFINED__SkPdfFDFTrailerDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFieldDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFieldDictionary_autogen.cpp
new file mode 100644
index 0000000..94f3a21
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFieldDictionary_autogen.cpp
@@ -0,0 +1,72 @@
+#include "SkPdfFieldDictionary_autogen.h"
+
+std::string SkPdfFieldDictionary::FT() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FT", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfFieldDictionary::Parent() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfFieldDictionary::Kids() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfFieldDictionary::T() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfFieldDictionary::TU() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TU", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfFieldDictionary::TM() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TM", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfFieldDictionary::Ff() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ff", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfObject* SkPdfFieldDictionary::V() const {
+  SkPdfObject* ret;
+  if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfObject* SkPdfFieldDictionary::DV() const {
+  SkPdfObject* ret;
+  if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DV", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfFieldDictionary::AA() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFieldDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFieldDictionary_autogen.h
index 6a67ff4..8333eba 100644
--- a/experimental/PdfViewer/autogen/SkPdfFieldDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFieldDictionary_autogen.h
@@ -541,13 +541,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FT", "", NULL));
   }
 
-  std::string FT() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FT", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string FT() const;
 /** (Required if this field is the child of another in the field hierarchy; absent other-
  *  wise) The field that is the immediate parent of this one (the field, if any,
  *  whose Kids array includes this field). A field can have at most one parent; that
@@ -557,13 +551,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", NULL));
   }
 
-  SkPdfDictionary* Parent() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Parent() const;
 /** (Optional) An array of indirect references to the immediate children of this
  *  field.
 **/
@@ -571,13 +559,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", NULL));
   }
 
-  SkPdfArray* Kids() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Kids() const;
 /** (Optional) The partial field name (see "Field Names," below; see also imple-
  *  mentation notes 82 and 83 in Appendix H).
 **/
@@ -585,13 +567,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", NULL));
   }
 
-  std::string T() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string T() const;
 /** (Optional; PDF 1.3) An alternate field name, to be used in place of the actual
  *  field name wherever the field must be identified in the user interface (such as
  *  in error or status messages referring to the field). This text is also useful
@@ -603,13 +579,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TU", "", NULL));
   }
 
-  std::string TU() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TU", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string TU() const;
 /** (Optional; PDF 1.3) The mapping name to be used when exporting inter-
  *  active form field data from the document.
 **/
@@ -617,13 +587,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TM", "", NULL));
   }
 
-  std::string TM() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TM", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string TM() const;
 /** (Optional; inheritable) A set of flags specifying various characteristics of the
  *  field (see Table 8.50). Default value: 0.
 **/
@@ -631,13 +595,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ff", "", NULL));
   }
 
-  long Ff() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ff", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Ff() const;
 /** (Optional; inheritable) The field's value, whose format varies depending on
  *  the field type; see the descriptions of individual field types for further infor-
  *  mation.
@@ -646,13 +604,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", NULL));
   }
 
-  SkPdfObject* V() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfObject* V() const;
 /** (Optional; inheritable) The default value to which the field reverts when a
  *  reset-form action is executed (see "Reset-Form Actions" on page 554). The
  *  format of this value is the same as that of V.
@@ -661,13 +613,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DV", "", NULL));
   }
 
-  SkPdfObject* DV() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DV", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfObject* DV() const;
 /** (Optional; PDF 1.2) An additional-actions dictionary defining the field's
  *  behavior in response to various trigger events (see Section 8.5.2, "Trigger
  *  Events"). This entry has exactly the same meaning as the AA entry in an
@@ -677,13 +623,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", NULL));
   }
 
-  SkPdfDictionary* AA() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* AA() const;
 };
 
 #endif  // __DEFINED__SkPdfFieldDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFileAttachmentAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFileAttachmentAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..fed0cf6
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFileAttachmentAnnotationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfFileAttachmentAnnotationDictionary_autogen.h"
+
+std::string SkPdfFileAttachmentAnnotationDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfFileSpec SkPdfFileAttachmentAnnotationDictionary::FS() const {
+  SkPdfFileSpec ret;
+  if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFileSpec();
+}
+
+std::string SkPdfFileAttachmentAnnotationDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfFileAttachmentAnnotationDictionary::Name() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFileAttachmentAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFileAttachmentAnnotationDictionary_autogen.h
index 2187f76..99b60af 100644
--- a/experimental/PdfViewer/autogen/SkPdfFileAttachmentAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFileAttachmentAnnotationDictionary_autogen.h
@@ -532,26 +532,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required) The file associated with this annotation.
 **/
   bool has_FS() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", NULL));
   }
 
-  SkPdfFileSpec FS() const {
-    SkPdfFileSpec ret;
-    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFileSpec();
-  }
-
+  SkPdfFileSpec FS() const;
 /** (Required) The text to be displayed in the pop-up window when the annota-
  *  tion is opened. Carriage returns may be used to separate the text into para-
  *  graphs.
@@ -560,13 +548,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Optional) The name of an icon to be used in displaying the annotation.
  *  Viewer applications should provide predefined icon appearances for at least
  *  the following standard names:
@@ -581,13 +563,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
   }
 
-  std::string Name() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Name() const;
 };
 
 #endif  // __DEFINED__SkPdfFileAttachmentAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFileSpecificationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFileSpecificationDictionary_autogen.cpp
new file mode 100644
index 0000000..e87539e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFileSpecificationDictionary_autogen.cpp
@@ -0,0 +1,72 @@
+#include "SkPdfFileSpecificationDictionary_autogen.h"
+
+std::string SkPdfFileSpecificationDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfFileSpecificationDictionary::FS() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfFileSpecificationDictionary::F() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfFileSpecificationDictionary::DOS() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DOS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfFileSpecificationDictionary::Mac() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfFileSpecificationDictionary::Unix() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Unix", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfFileSpecificationDictionary::ID() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+bool SkPdfFileSpecificationDictionary::V() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+SkPdfDictionary* SkPdfFileSpecificationDictionary::EF() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EF", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfFileSpecificationDictionary::RF() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RF", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFileSpecificationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFileSpecificationDictionary_autogen.h
index d233724..494b0d6 100644
--- a/experimental/PdfViewer/autogen/SkPdfFileSpecificationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFileSpecificationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Optional) The name of the file system to be used to interpret this file specification. If
  *  this entry is present, all other entries in the dictionary are interpreted by the desig-
  *  nated file system. PDF defines only one standard file system, URL (see Section 3.10.4,
@@ -550,13 +544,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", NULL));
   }
 
-  std::string FS() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string FS() const;
 /** (Required if the DOS, Mac, and Unix entries are all absent) A file specification string of
  *  the form described in Section 3.10.1, "File Specification Strings," or (if the file system
  *  is URL) a uniform resource locator, as described in Section 3.10.4, "URL Specifica-
@@ -566,13 +554,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  std::string F() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string F() const;
 /** (Optional) A file specification string (see Section 3.10.1, "File Specification Strings")
  *  representing a DOS file name.
 **/
@@ -580,13 +562,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DOS", "", NULL));
   }
 
-  std::string DOS() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DOS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string DOS() const;
 /** (Optional) A file specification string (see Section 3.10.1, "File Specification Strings")
  *  representing a Mac OS file name.
 **/
@@ -594,13 +570,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", NULL));
   }
 
-  std::string Mac() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Mac() const;
 /** (Optional) A file specification string (see Section 3.10.1, "File Specification Strings")
  *  representing a UNIX file name.
 **/
@@ -608,13 +578,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Unix", "", NULL));
   }
 
-  std::string Unix() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Unix", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Unix() const;
 /** (Optional) An array of two strings constituting a file identifier (see Section 9.3, "File
  *  Identifiers") that is also included in the referenced file. The use of this entry improves
  *  a viewer application's chances of finding the intended file and allows it to warn the
@@ -624,13 +588,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
   }
 
-  SkPdfArray* ID() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* ID() const;
 /** (Optional; PDF 1.2) A flag indicating whether the file referenced by the file specifica-
  *  tion is volatile (changes frequently with time). If the value is true, viewer applications
  *  should never cache a copy of the file. For example, a movie annotation referencing a
@@ -641,13 +599,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", NULL));
   }
 
-  bool V() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool V() const;
 /** (Required if RF is present; PDF 1.3) A dictionary containing a subset of the keys F,
  *  DOS, Mac, and Unix, corresponding to the entries by those names in the file specifica-
  *  tion dictionary. The value of each such key is an embedded file stream (see Section
@@ -659,13 +611,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EF", "", NULL));
   }
 
-  SkPdfDictionary* EF() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EF", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* EF() const;
 /** (Optional; PDF 1.3) A dictionary with the same structure as the EF dictionary, which
  *  must also be present. Each key in the RF dictionary must also be present in the EF dic-
  *  tionary. Each value is a related files array (see "Related Files Arrays" on page 125)
@@ -677,13 +623,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RF", "", NULL));
   }
 
-  SkPdfDictionary* RF() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RF", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* RF() const;
 };
 
 #endif  // __DEFINED__SkPdfFileSpecificationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFileTrailerDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFileTrailerDictionary_autogen.cpp
new file mode 100644
index 0000000..7b82356
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFileTrailerDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfFileTrailerDictionary_autogen.h"
+
+long SkPdfFileTrailerDictionary::Size() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfFileTrailerDictionary::Prev() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Prev", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfDictionary* SkPdfFileTrailerDictionary::Root() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Root", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfFileTrailerDictionary::Encrypt() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encrypt", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfFileTrailerDictionary::Info() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfFileTrailerDictionary::ID() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFileTrailerDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFileTrailerDictionary_autogen.h
index 4978695..2cec231 100644
--- a/experimental/PdfViewer/autogen/SkPdfFileTrailerDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFileTrailerDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", NULL));
   }
 
-  long Size() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Size() const;
 /** (Present only if the file has more than one cross-reference section) The byte offset from
  *  the beginning of the file to the beginning of the previous cross-reference section.
 **/
@@ -547,13 +541,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Prev", "", NULL));
   }
 
-  long Prev() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Prev", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Prev() const;
 /** (Required; must be an indirect reference) The catalog dictionary for the PDF docu-
  *  ment contained in the file (see Section 3.6.1, "Document Catalog").
 **/
@@ -561,13 +549,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Root", "", NULL));
   }
 
-  SkPdfDictionary* Root() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Root", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Root() const;
 /** (Required if document is encrypted; PDF 1.1) The document's encryption dictionary
  *  (see Section 3.5, "Encryption").
 **/
@@ -575,13 +557,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encrypt", "", NULL));
   }
 
-  SkPdfDictionary* Encrypt() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encrypt", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Encrypt() const;
 /** (Optional; must be an indirect reference) The document's information dictionary
  *  (see Section 9.2.1, "Document Information Dictionary").
 **/
@@ -589,13 +565,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", NULL));
   }
 
-  SkPdfDictionary* Info() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Info() const;
 /** (Optional; PDF 1.1) An array of two strings constituting a file identifier (see Section
  *  9.3, "File Identifiers") for the file.
 **/
@@ -603,13 +573,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
   }
 
-  SkPdfArray* ID() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* ID() const;
 };
 
 #endif  // __DEFINED__SkPdfFileTrailerDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFontDescriptorDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFontDescriptorDictionary_autogen.cpp
new file mode 100644
index 0000000..58a2a47
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFontDescriptorDictionary_autogen.cpp
@@ -0,0 +1,135 @@
+#include "SkPdfFontDescriptorDictionary_autogen.h"
+
+std::string SkPdfFontDescriptorDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfFontDescriptorDictionary::FontName() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontName", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfFontDescriptorDictionary::Flags() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkRect* SkPdfFontDescriptorDictionary::FontBBox() const {
+  SkRect* ret;
+  if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+double SkPdfFontDescriptorDictionary::ItalicAngle() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ItalicAngle", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfFontDescriptorDictionary::Ascent() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ascent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfFontDescriptorDictionary::Descent() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Descent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfFontDescriptorDictionary::Leading() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Leading", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfFontDescriptorDictionary::CapHeight() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CapHeight", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfFontDescriptorDictionary::XHeight() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XHeight", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfFontDescriptorDictionary::StemV() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StemV", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfFontDescriptorDictionary::StemH() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StemH", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfFontDescriptorDictionary::AvgWidth() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AvgWidth", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfFontDescriptorDictionary::MaxWidth() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MaxWidth", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfFontDescriptorDictionary::MissingWidth() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MissingWidth", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfStream* SkPdfFontDescriptorDictionary::FontFile() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfFontDescriptorDictionary::FontFile2() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile2", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfFontDescriptorDictionary::FontFile3() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile3", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfFontDescriptorDictionary::CharSet() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CharSet", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFontDescriptorDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFontDescriptorDictionary_autogen.h
index 2d57f71..724c8fa 100644
--- a/experimental/PdfViewer/autogen/SkPdfFontDescriptorDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFontDescriptorDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The PostScript name of the font. This should be the same as the
  *  value of BaseFont in the font or CIDFont dictionary that refers to this font
  *  descriptor.
@@ -547,13 +541,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontName", "", NULL));
   }
 
-  std::string FontName() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontName", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string FontName() const;
 /** (Required) A collection of flags defining various characteristics of the font
  *  (see Section 5.7.1, "Font Descriptor Flags").
 **/
@@ -561,13 +549,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", NULL));
   }
 
-  long Flags() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Flags() const;
 /** (Required) A rectangle (see Section 3.8.3, "Rectangles"), expressed in the
  *  glyph coordinate system, specifying the font bounding box. This is the small-
  *  est rectangle enclosing the shape that would result if all of the glyphs of the
@@ -577,13 +559,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", NULL));
   }
 
-  SkRect* FontBBox() const {
-    SkRect* ret;
-    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkRect* FontBBox() const;
 /** (Required) The angle, expressed in degrees counterclockwise from the verti-
  *  cal, of the dominant vertical strokes of the font. (For example, the 9-o'clock
  *  position is 90 degrees, and the 3-o'clock position is '90 degrees.) The value is
@@ -593,13 +569,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ItalicAngle", "", NULL));
   }
 
-  double ItalicAngle() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ItalicAngle", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double ItalicAngle() const;
 /** (Required) The maximum height above the baseline reached by glyphs in this
  *  font, excluding the height of glyphs for accented characters.
 **/
@@ -607,13 +577,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ascent", "", NULL));
   }
 
-  double Ascent() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ascent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double Ascent() const;
 /** (Required) The maximum depth below the baseline reached by glyphs in this
  *  font. The value is a negative number.
 **/
@@ -621,13 +585,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Descent", "", NULL));
   }
 
-  double Descent() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Descent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double Descent() const;
 /** (Optional) The desired spacing between baselines of consecutive lines of text.
  *  Default value: 0.
 **/
@@ -635,13 +593,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Leading", "", NULL));
   }
 
-  double Leading() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Leading", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double Leading() const;
 /** (Required) The vertical coordinate of the top of flat capital letters, measured
  *  from the baseline.
 **/
@@ -649,13 +601,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CapHeight", "", NULL));
   }
 
-  double CapHeight() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CapHeight", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double CapHeight() const;
 /** (Optional) The font's x height: the vertical coordinate of the top of flat non-
  *  ascending lowercase letters (like the letter x), measured from the baseline.
  *  Default value: 0.
@@ -664,13 +610,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XHeight", "", NULL));
   }
 
-  double XHeight() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XHeight", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double XHeight() const;
 /** (Required) The thickness, measured horizontally, of the dominant vertical
  *  stems of glyphs in the font.
 **/
@@ -678,13 +618,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StemV", "", NULL));
   }
 
-  double StemV() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StemV", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double StemV() const;
 /** (Optional) The thickness, measured invertically, of the dominant horizontal
  *  stems of glyphs in the font. Default value: 0.
 **/
@@ -692,39 +626,21 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StemH", "", NULL));
   }
 
-  double StemH() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StemH", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double StemH() const;
 /** (Optional) The average width of glyphs in the font. Default value: 0.
 **/
   bool has_AvgWidth() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AvgWidth", "", NULL));
   }
 
-  double AvgWidth() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AvgWidth", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double AvgWidth() const;
 /** (Optional) The maximum width of glyphs in the font. Default value: 0.
 **/
   bool has_MaxWidth() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MaxWidth", "", NULL));
   }
 
-  double MaxWidth() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MaxWidth", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double MaxWidth() const;
 /** (Optional) The width to use for character codes whose widths are not speci-
  *  fied in a font dictionary's Widths array. This has a predictable effect only if all
  *  such codes map to glyphs whose actual widths are the same as the Missing-
@@ -734,13 +650,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MissingWidth", "", NULL));
   }
 
-  double MissingWidth() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MissingWidth", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double MissingWidth() const;
 /** (Optional) A stream containing a Type 1 font program (see Section 5.8,
  *  "Embedded Font Programs").
 **/
@@ -748,13 +658,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile", "", NULL));
   }
 
-  SkPdfStream* FontFile() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* FontFile() const;
 /** (Optional; PDF 1.1) A stream containing a TrueType font program (see Sec-
  *  tion 5.8, "Embedded Font Programs").
 **/
@@ -762,13 +666,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile2", "", NULL));
   }
 
-  SkPdfStream* FontFile2() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile2", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* FontFile2() const;
 /** (Optional; PDF 1.2) A stream containing a font program other than Type 1 or
  *  TrueType. The format of the font program is specified by the Subtype entry
  *  in the stream dictionary (see Section 5.8, "Embedded Font Programs," and
@@ -780,13 +678,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile3", "", NULL));
   }
 
-  SkPdfStream* FontFile3() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFile3", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* FontFile3() const;
 /** (Optional; meaningful only in Type 1 fonts; PDF 1.1) A string listing the char-
  *  acter names defined in a font subset. The names in this string must be in PDF
  *  syntax-that is, each name preceded by a slash (/). The names can appear in
@@ -798,13 +690,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CharSet", "", NULL));
   }
 
-  std::string CharSet() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CharSet", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string CharSet() const;
 };
 
 #endif  // __DEFINED__SkPdfFontDescriptorDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFontDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFontDictionary_autogen.cpp
new file mode 100644
index 0000000..759cbf5
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFontDictionary_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfFontDictionary_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFormFieldActionsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFormFieldActionsDictionary_autogen.cpp
new file mode 100644
index 0000000..7a5eb41
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFormFieldActionsDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfFormFieldActionsDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfFormFieldActionsDictionary::K() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfFormFieldActionsDictionary::F() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfFormFieldActionsDictionary::V() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfFormFieldActionsDictionary::C() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFormFieldActionsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFormFieldActionsDictionary_autogen.h
index 2792bf1..0b7573f 100644
--- a/experimental/PdfViewer/autogen/SkPdfFormFieldActionsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFormFieldActionsDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", NULL));
   }
 
-  SkPdfDictionary* K() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* K() const;
 /** (Optional; PDF 1.3) A JavaScript action to be performed before the field is formatted
  *  to display its current value. This allows the field's value to be modified before format-
  *  ting.
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  SkPdfDictionary* F() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* F() const;
 /** (Optional; PDF 1.3) A JavaScript action to be performed when the field's value is
  *  changed. This allows the new value to be checked for validity. (The name V stands for
  *  "validate.")
@@ -563,13 +551,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", NULL));
   }
 
-  SkPdfDictionary* V() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* V() const;
 /** (Optional; PDF 1.3) A JavaScript action to be performed in order to recalculate the
  *  value of this field when that of another field changes. (The name C stands for
  *  "calculate.") The order in which the document's fields are recalculated is defined by the
@@ -580,13 +562,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
   }
 
-  SkPdfDictionary* C() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* C() const;
 };
 
 #endif  // __DEFINED__SkPdfFormFieldActionsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFreeTextAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFreeTextAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..0a1929f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFreeTextAnnotationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfFreeTextAnnotationDictionary_autogen.h"
+
+std::string SkPdfFreeTextAnnotationDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfFreeTextAnnotationDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfFreeTextAnnotationDictionary::DA() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfFreeTextAnnotationDictionary::Q() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFreeTextAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFreeTextAnnotationDictionary_autogen.h
index 795e9bf..ebbf92e 100644
--- a/experimental/PdfViewer/autogen/SkPdfFreeTextAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFreeTextAnnotationDictionary_autogen.h
@@ -532,26 +532,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required) The text to be displayed.
 **/
   bool has_Contents() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Required) The default appearance string to be used in formatting the text (see
  *  "Variable Text" on page 533).
  *  Note: The annotation dictionary's AP entry, if present, takes precedence over the DA
@@ -561,13 +549,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", NULL));
   }
 
-  std::string DA() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string DA() const;
 /** (Optional; PDF 1.4) A code specifying the form of quadding (justification) to be
  *  used in displaying the annotation's text:
  *     0     Left-justified
@@ -579,13 +561,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", NULL));
   }
 
-  long Q() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Q() const;
 };
 
 #endif  // __DEFINED__SkPdfFreeTextAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfFunctionCommonDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfFunctionCommonDictionary_autogen.cpp
new file mode 100644
index 0000000..ac63bae
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfFunctionCommonDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfFunctionCommonDictionary_autogen.h"
+
+long SkPdfFunctionCommonDictionary::FunctionType() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FunctionType", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfFunctionCommonDictionary::Domain() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfFunctionCommonDictionary::Range() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfFunctionCommonDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfFunctionCommonDictionary_autogen.h
index 5633dcb..f308a0c 100644
--- a/experimental/PdfViewer/autogen/SkPdfFunctionCommonDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfFunctionCommonDictionary_autogen.h
@@ -535,13 +535,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FunctionType", "", NULL));
   }
 
-  long FunctionType() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FunctionType", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long FunctionType() const;
 /** (Required) An array of 2 x m numbers, where m is the number of input
  *  values. For each i from 0 to m - 1, Domain2i must be less than or equal to
  *  Domain2i+1 , and the ith input value, xi , must lie in the interval
@@ -552,13 +546,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", NULL));
   }
 
-  SkPdfArray* Domain() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Domain() const;
 /** (Required for type 0 and type 4 functions, optional otherwise; see below) An
  *  array of 2 x n numbers, where n is the number of output values. For each j
  *  from 0 to n - 1, Range2j must be less than or equal to Range2j+1 , and the jth
@@ -570,13 +558,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", NULL));
   }
 
-  SkPdfArray* Range() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Range() const;
 };
 
 #endif  // __DEFINED__SkPdfFunctionCommonDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfGoToActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfGoToActionDictionary_autogen.cpp
new file mode 100644
index 0000000..2b3fbc3
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfGoToActionDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfGoToActionDictionary_autogen.h"
+
+std::string SkPdfGoToActionDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfGoToActionDictionary::getDAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfGoToActionDictionary::getDAsString() const {
+  std::string ret = "";
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfGoToActionDictionary::getDAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfGoToActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfGoToActionDictionary_autogen.h
index 2e04730..3f40dc3 100644
--- a/experimental/PdfViewer/autogen/SkPdfGoToActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfGoToActionDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required) The destination to jump to (see Section 8.2.1, "Destinations").
 **/
   bool has_D() const {
@@ -551,39 +545,21 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getDAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getDAsName() const;
   bool isDAString() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  std::string getDAsString() const {
-    std::string ret = "";
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getDAsString() const;
   bool isDAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getDAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getDAsArray() const;
 };
 
 #endif  // __DEFINED__SkPdfGoToActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfGraphicsStateDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfGraphicsStateDictionary_autogen.cpp
new file mode 100644
index 0000000..440588c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfGraphicsStateDictionary_autogen.cpp
@@ -0,0 +1,261 @@
+#include "SkPdfGraphicsStateDictionary_autogen.h"
+
+std::string SkPdfGraphicsStateDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+double SkPdfGraphicsStateDictionary::LW() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LW", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfGraphicsStateDictionary::LC() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LC", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfGraphicsStateDictionary::LJ() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LJ", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfGraphicsStateDictionary::ML() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ML", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfGraphicsStateDictionary::D() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfGraphicsStateDictionary::RI() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+bool SkPdfGraphicsStateDictionary::OP() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OP", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+bool SkPdfGraphicsStateDictionary::op() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "op", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+long SkPdfGraphicsStateDictionary::OPM() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPM", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfGraphicsStateDictionary::Font() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfFunction SkPdfGraphicsStateDictionary::BG() const {
+  SkPdfFunction ret;
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
+SkPdfFunction SkPdfGraphicsStateDictionary::getBG2AsFunction() const {
+  SkPdfFunction ret = SkPdfFunction();
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
+std::string SkPdfGraphicsStateDictionary::getBG2AsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfFunction SkPdfGraphicsStateDictionary::UCR() const {
+  SkPdfFunction ret;
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
+SkPdfFunction SkPdfGraphicsStateDictionary::getUCR2AsFunction() const {
+  SkPdfFunction ret = SkPdfFunction();
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
+std::string SkPdfGraphicsStateDictionary::getUCR2AsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfFunction SkPdfGraphicsStateDictionary::getTRAsFunction() const {
+  SkPdfFunction ret = SkPdfFunction();
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
+SkPdfArray* SkPdfGraphicsStateDictionary::getTRAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfGraphicsStateDictionary::getTRAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfFunction SkPdfGraphicsStateDictionary::getTR2AsFunction() const {
+  SkPdfFunction ret = SkPdfFunction();
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
+SkPdfArray* SkPdfGraphicsStateDictionary::getTR2AsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfGraphicsStateDictionary::getTR2AsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfGraphicsStateDictionary::getHTAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfGraphicsStateDictionary::getHTAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfGraphicsStateDictionary::getHTAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+double SkPdfGraphicsStateDictionary::FL() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FL", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfGraphicsStateDictionary::SM() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SM", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+bool SkPdfGraphicsStateDictionary::SA() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SA", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+std::string SkPdfGraphicsStateDictionary::getBMAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfGraphicsStateDictionary::getBMAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfGraphicsStateDictionary::getSMaskAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfGraphicsStateDictionary::getSMaskAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+double SkPdfGraphicsStateDictionary::CA() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfGraphicsStateDictionary::ca() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ca", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+bool SkPdfGraphicsStateDictionary::AIS() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AIS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+bool SkPdfGraphicsStateDictionary::TK() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TK", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfGraphicsStateDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfGraphicsStateDictionary_autogen.h
index 7cb5f01..63947df 100644
--- a/experimental/PdfViewer/autogen/SkPdfGraphicsStateDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfGraphicsStateDictionary_autogen.h
@@ -532,65 +532,35 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Optional; PDF 1.3) The line width (see "Line Width" on page 152).
 **/
   bool has_LW() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LW", "", NULL));
   }
 
-  double LW() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LW", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double LW() const;
 /** (Optional; PDF 1.3) The line cap style (see "Line Cap Style" on page 153).
 **/
   bool has_LC() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LC", "", NULL));
   }
 
-  long LC() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LC", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long LC() const;
 /** (Optional; PDF 1.3) The line join style (see "Line Join Style" on page 153).
 **/
   bool has_LJ() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LJ", "", NULL));
   }
 
-  long LJ() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LJ", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long LJ() const;
 /** (Optional; PDF 1.3) The miter limit (see "Miter Limit" on page 153).
 **/
   bool has_ML() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ML", "", NULL));
   }
 
-  double ML() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ML", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double ML() const;
 /** (Optional; PDF 1.3) The line dash pattern, expressed as an array of the form
  *  [dashArray dashPhase], where dashArray is itself an array and dashPhase is an
  *  integer (see "Line Dash Pattern" on page 155).
@@ -599,13 +569,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", NULL));
   }
 
-  SkPdfArray* D() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* D() const;
 /** (Optional; PDF 1.3) The name of the rendering intent (see "Rendering
  *  Intents" on page 197).
 **/
@@ -613,13 +577,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", NULL));
   }
 
-  std::string RI() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RI", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string RI() const;
 /** (Optional) A flag specifying whether to apply overprint (see Section 4.5.6,
  *  "Overprint Control"). In PDF 1.2 and earlier, there is a single overprint
  *  parameter that applies to all painting operations. Beginning with PDF 1.3,
@@ -632,13 +590,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OP", "", NULL));
   }
 
-  bool OP() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OP", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool OP() const;
 /** (Optional; PDF 1.3) A flag specifying whether to apply overprint (see Section
  *  4.5.6, "Overprint Control") for painting operations other than stroking. If
  *  this entry is absent, the OP entry, if any, sets this parameter.
@@ -647,13 +599,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "op", "", NULL));
   }
 
-  bool op() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "op", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool op() const;
 /** (Optional; PDF 1.3) The overprint mode (see Section 4.5.6, "Overprint Con-
  *  trol").
 **/
@@ -661,13 +607,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPM", "", NULL));
   }
 
-  long OPM() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPM", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long OPM() const;
 /** (Optional; PDF 1.3) An array of the form [font size], where font is an indirect
  *  reference to a font dictionary and size is a number expressed in text space
  *  units. These two objects correspond to the operands of the Tf operator (see
@@ -678,13 +618,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", NULL));
   }
 
-  SkPdfArray* Font() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Font() const;
 /** (Optional) The black-generation function, which maps the interval [0.0 1.0]
  *  to the interval [0.0 1.0] (see Section 6.2.3, "Conversion from DeviceRGB to
  *  DeviceCMYK").
@@ -693,13 +627,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", NULL));
   }
 
-  SkPdfFunction BG() const {
-    SkPdfFunction ret;
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction BG() const;
 /** (Optional; PDF 1.3) Same as BG except that the value may also be the name
  *  Default, denoting the black-generation function that was in effect at the start
  *  of the page. If both BG and BG2 are present in the same graphics state param-
@@ -715,26 +643,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfFunction getBG2AsFunction() const {
-    SkPdfFunction ret = SkPdfFunction();
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction getBG2AsFunction() const;
   bool isBG2AName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getBG2AsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BG2", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getBG2AsName() const;
 /** (Optional) The undercolor-removal function, which maps the interval
  *  [0.0 1.0] to the interval [-1.0 1.0] (see Section 6.2.3, "Conversion from
  *  DeviceRGB to DeviceCMYK").
@@ -743,13 +659,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR", "", NULL));
   }
 
-  SkPdfFunction UCR() const {
-    SkPdfFunction ret;
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction UCR() const;
 /** (Optional; PDF 1.3) Same as UCR except that the value may also be the name
  *  Default, denoting the undercolor-removal function that was in effect at the
  *  start of the page. If both UCR and UCR2 are present in the same graphics state
@@ -765,26 +675,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfFunction getUCR2AsFunction() const {
-    SkPdfFunction ret = SkPdfFunction();
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction getUCR2AsFunction() const;
   bool isUCR2AName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getUCR2AsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "UCR2", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getUCR2AsName() const;
 /** (Optional) The transfer function, which maps the interval [0.0 1.0] to the
  *  interval [0.0 1.0] (see Section 6.3, "Transfer Functions"). The value is either
  *  a single function (which applies to all process colorants) or an array of four
@@ -801,39 +699,21 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfFunction getTRAsFunction() const {
-    SkPdfFunction ret = SkPdfFunction();
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction getTRAsFunction() const;
   bool isTRAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getTRAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getTRAsArray() const;
   bool isTRAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getTRAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getTRAsName() const;
 /** (Optional; PDF 1.3) Same as TR except that the value may also be the name
  *  Default, denoting the transfer function that was in effect at the start of the
  *  page. If both TR and TR2 are present in the same graphics state parameter dic-
@@ -849,39 +729,21 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfFunction getTR2AsFunction() const {
-    SkPdfFunction ret = SkPdfFunction();
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction getTR2AsFunction() const;
   bool isTR2AArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getTR2AsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getTR2AsArray() const;
   bool isTR2AName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getTR2AsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR2", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getTR2AsName() const;
 /** (Optional) The halftone dictionary or stream (see Section 6.4, "Halftones")
  *  or the name Default, denoting the halftone that was in effect at the start of the
  *  page.
@@ -896,39 +758,21 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getHTAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getHTAsDictionary() const;
   bool isHTAStream() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return false;
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getHTAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getHTAsStream() const;
   bool isHTAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getHTAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HT", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getHTAsName() const;
 /** (Optional; PDF 1.3) The flatness tolerance (see Section 6.5.1, "Flatness Toler-
  *  ance").
 **/
@@ -936,13 +780,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FL", "", NULL));
   }
 
-  double FL() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FL", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double FL() const;
 /** (Optional; PDF 1.3) The smoothness tolerance (see Section 6.5.2, "Smooth-
  *  ness Tolerance").
 **/
@@ -950,13 +788,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SM", "", NULL));
   }
 
-  double SM() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SM", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double SM() const;
 /** (Optional) A flag specifying whether to apply automatic stroke adjustment
  *  (see Section 6.5.4, "Automatic Stroke Adjustment").
 **/
@@ -964,13 +796,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SA", "", NULL));
   }
 
-  bool SA() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SA", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool SA() const;
 /** (Optional; PDF 1.4) The current blend mode to be used in the transparent
  *  imaging model (see Sections 7.2.4, "Blend Mode," and 7.5.2, "Specifying
  *  Blending Color Space and Blend Mode").
@@ -985,26 +811,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getBMAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getBMAsName() const;
   bool isBMAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getBMAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BM", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getBMAsArray() const;
 /** (Optional; PDF 1.4) The current soft mask, specifying the mask shape or
  *  mask opacity values to be used in the transparent imaging model (see
  *  "Source Shape and Opacity" on page 421 and "Mask Shape and Opacity" on
@@ -1024,26 +838,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getSMaskAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getSMaskAsDictionary() const;
   bool isSMaskAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getSMaskAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getSMaskAsName() const;
 /** (Optional; PDF 1.4) The current stroking alpha constant, specifying the con-
  *  stant shape or constant opacity value to be used for stroking operations in the
  *  transparent imaging model (see "Source Shape and Opacity" on page 421
@@ -1053,26 +855,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", NULL));
   }
 
-  double CA() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CA", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double CA() const;
 /** (Optional; PDF 1.4) Same as CA, but for nonstroking operations.
 **/
   bool has_ca() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ca", "", NULL));
   }
 
-  double ca() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ca", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double ca() const;
 /** (Optional; PDF 1.4) The alpha source flag ("alpha is shape"), specifying
  *  whether the current soft mask and alpha constant are to be interpreted as
  *  shape values (true) or opacity values (false).
@@ -1081,13 +871,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AIS", "", NULL));
   }
 
-  bool AIS() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AIS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool AIS() const;
 /** (Optional; PDF 1.4) The text knockout flag, which determines the behavior
  *  of overlapping glyphs within a text object in the transparent imaging model
  *  (see Section 5.2.7, "Text Knockout").
@@ -1096,13 +880,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TK", "", NULL));
   }
 
-  bool TK() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TK", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool TK() const;
 };
 
 #endif  // __DEFINED__SkPdfGraphicsStateDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfGroupAttributesDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfGroupAttributesDictionary_autogen.cpp
new file mode 100644
index 0000000..17d0354
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfGroupAttributesDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfGroupAttributesDictionary_autogen.h"
+
+std::string SkPdfGroupAttributesDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfGroupAttributesDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfGroupAttributesDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfGroupAttributesDictionary_autogen.h
index 7ac962b..e630507 100644
--- a/experimental/PdfViewer/autogen/SkPdfGroupAttributesDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfGroupAttributesDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The group subtype, which identifies the type of group whose at-
  *  tributes this dictionary describes and determines the format and meaning of the
  *  dictionary's remaining entries. The only group subtype defined in PDF 1.4 is
@@ -550,13 +544,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 };
 
 #endif  // __DEFINED__SkPdfGroupAttributesDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfHeaders_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfHeaders_autogen.cpp
new file mode 100644
index 0000000..86217e1
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfHeaders_autogen.cpp
@@ -0,0 +1,180 @@
+#include "SkPdfHeaders_autogen.h"
+#include "SkPdfJavascriptActionDictionary_autogen.cpp"
+#include "SkPdfMovieAnnotationDictionary_autogen.cpp"
+#include "SkPdfMetadataStreamDictionary_autogen.cpp"
+#include "SkPdfPageTreeNodeDictionary_autogen.cpp"
+#include "SkPdfWebCaptureCommandDictionary_autogen.cpp"
+#include "SkPdfAnnotationActionsDictionary_autogen.cpp"
+#include "SkPdfInkAnnotationDictionary_autogen.cpp"
+#include "SkPdfWindowsLaunchActionDictionary_autogen.cpp"
+#include "SkPdfBeadDictionary_autogen.cpp"
+#include "SkPdfPageObjectDictionary_autogen.cpp"
+#include "SkPdfType16HalftoneDictionary_autogen.cpp"
+#include "SkPdfObject_autogen.cpp"
+#include "SkPdfFontDescriptorDictionary_autogen.cpp"
+#include "SkPdfLaunchActionDictionary_autogen.cpp"
+#include "SkPdfType3FontDictionary_autogen.cpp"
+#include "SkPdfMovieActionDictionary_autogen.cpp"
+#include "SkPdfBorderStyleDictionary_autogen.cpp"
+#include "SkPdfNamedActionsDictionary_autogen.cpp"
+#include "SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.cpp"
+#include "SkPdfTrueTypeFontDictionary_autogen.cpp"
+#include "SkPdfJavascriptDictionary_autogen.cpp"
+#include "SkPdfFDFTrailerDictionary_autogen.cpp"
+#include "SkPdfMultiMasterFontDictionary_autogen.cpp"
+#include "SkPdfEmbeddedFileStreamDictionary_autogen.cpp"
+#include "SkPdfAppearanceDictionary_autogen.cpp"
+#include "SkPdfRadioButtonFieldDictionary_autogen.cpp"
+#include "SkPdfType6HalftoneDictionary_autogen.cpp"
+#include "SkPdfFDFNamedPageReferenceDictionary_autogen.cpp"
+#include "SkPdfReference_autogen.cpp"
+#include "SkPdfWebCaptureImageSetDictionary_autogen.cpp"
+#include "SkPdfBlockLevelStructureElementsDictionary_autogen.cpp"
+#include "SkPdfViewerPreferencesDictionary_autogen.cpp"
+#include "SkPdfType3FunctionDictionary_autogen.cpp"
+#include "SkPdfFieldDictionary_autogen.cpp"
+#include "SkPdfAnnotationDictionary_autogen.cpp"
+#include "SkPdfType3ShadingDictionary_autogen.cpp"
+#include "SkPdfType1HalftoneDictionary_autogen.cpp"
+#include "SkPdfActionDictionary_autogen.cpp"
+#include "SkPdfDocumentInformationDictionary_autogen.cpp"
+#include "SkPdfStructureElementDictionary_autogen.cpp"
+#include "SkPdfIccProfileStreamDictionary_autogen.cpp"
+#include "SkPdfType1FontDictionary_autogen.cpp"
+#include "SkPdfTextFieldDictionary_autogen.cpp"
+#include "SkPdfGroupAttributesDictionary_autogen.cpp"
+#include "SkPdfFileSpecificationDictionary_autogen.cpp"
+#include "SkPdfRubberStampAnnotationDictionary_autogen.cpp"
+#include "SkPdfSoftMaskImageDictionary_autogen.cpp"
+#include "SkPdfTrapNetworkAnnotationDictionary_autogen.cpp"
+#include "SkPdfRemoteGoToActionDictionary_autogen.cpp"
+#include "SkPdfMarkInformationDictionary_autogen.cpp"
+#include "SkPdfComponentsWithMetadataDictionary_autogen.cpp"
+#include "SkPdfString_autogen.cpp"
+#include "SkPdfAlternateImageDictionary_autogen.cpp"
+#include "SkPdfArtifactsDictionary_autogen.cpp"
+#include "SkPdfPrinterMarkFormDictionary_autogen.cpp"
+#include "SkPdfFreeTextAnnotationDictionary_autogen.cpp"
+#include "SkPdfLineAnnotationDictionary_autogen.cpp"
+#include "SkPdfFDFFileAnnotationDictionary_autogen.cpp"
+#include "SkPdfWebCaptureDictionary_autogen.cpp"
+#include "SkPdfPageObjectActionsDictionary_autogen.cpp"
+#include "SkPdfSeparationDictionary_autogen.cpp"
+#include "SkPdfSoftMaskDictionary_autogen.cpp"
+#include "SkPdfURLAliasDictionary_autogen.cpp"
+#include "SkPdfListAttributeDictionary_autogen.cpp"
+#include "SkPdfResourceDictionary_autogen.cpp"
+#include "SkPdfNameTreeNodeDictionary_autogen.cpp"
+#include "SkPdfIconFitDictionary_autogen.cpp"
+#include "SkPdfImportDataActionDictionary_autogen.cpp"
+#include "SkPdfTransparencyGroupDictionary_autogen.cpp"
+#include "SkPdfInteractiveFormDictionary_autogen.cpp"
+#include "SkPdfMovieActivationDictionary_autogen.cpp"
+#include "SkPdfPageLabelDictionary_autogen.cpp"
+#include "SkPdfLabColorSpaceDictionary_autogen.cpp"
+#include "SkPdfFDFCatalogDictionary_autogen.cpp"
+#include "SkPdfALinkAnnotationDictionary_autogen.cpp"
+#include "SkPdfAppearanceCharacteristicsDictionary_autogen.cpp"
+#include "SkPdfStream_autogen.cpp"
+#include "SkPdfTransitionDictionary_autogen.cpp"
+#include "SkPdfApplicationDataDictionary_autogen.cpp"
+#include "SkPdfFileAttachmentAnnotationDictionary_autogen.cpp"
+#include "SkPdfGraphicsStateDictionary_autogen.cpp"
+#include "SkPdfType0FontDictionary_autogen.cpp"
+#include "SkPdfMacOsFileInformationDictionary_autogen.cpp"
+#include "SkPdfWebCapturePageSetDictionary_autogen.cpp"
+#include "SkPdfNumberTreeNodeDictionary_autogen.cpp"
+#include "SkPdfURIActionDictionary_autogen.cpp"
+#include "SkPdfVariableTextFieldDictionary_autogen.cpp"
+#include "SkPdfJbig2DecodeFilterDictionary_autogen.cpp"
+#include "SkPdfSourceInformationDictionary_autogen.cpp"
+#include "SkPdfFDFDictionary_autogen.cpp"
+#include "SkPdfThreadActionDictionary_autogen.cpp"
+#include "SkPdfReferenceDictionary_autogen.cpp"
+#include "SkPdfEncodingDictionary_autogen.cpp"
+#include "SkPdfFDFFieldDictionary_autogen.cpp"
+#include "SkPdfAttributeObjectDictionary_autogen.cpp"
+#include "SkPdfCIDSystemInfoDictionary_autogen.cpp"
+#include "SkPdfMarkedContentReferenceDictionary_autogen.cpp"
+#include "SkPdfResetFormActionDictionary_autogen.cpp"
+#include "SkPdfDictionary_autogen.cpp"
+#include "SkPdfCalgrayColorSpaceDictionary_autogen.cpp"
+#include "SkPdfSquareOrCircleAnnotation_autogen.cpp"
+#include "SkPdfTableAttributesDictionary_autogen.cpp"
+#include "SkPdfSubmitFormActionDictionary_autogen.cpp"
+#include "SkPdfType2FunctionDictionary_autogen.cpp"
+#include "SkPdfCheckboxFieldDictionary_autogen.cpp"
+#include "SkPdfBoxStyleDictionary_autogen.cpp"
+#include "SkPdfInteger_autogen.cpp"
+#include "SkPdfType1PatternDictionary_autogen.cpp"
+#include "SkPdfHexString_autogen.cpp"
+#include "SkPdfPagePieceDictionary_autogen.cpp"
+#include "SkPdfEncryptedEmbeddedFileStreamDictionary_autogen.cpp"
+#include "SkPdfWebCaptureCommandSettingsDictionary_autogen.cpp"
+#include "SkPdfType2ShadingDictionary_autogen.cpp"
+#include "SkPdfInlineLevelStructureElementsDictionary_autogen.cpp"
+#include "SkPdfMarkupAnnotationsDictionary_autogen.cpp"
+#include "SkPdfPopUpAnnotationDictionary_autogen.cpp"
+#include "SkPdfFormFieldActionsDictionary_autogen.cpp"
+#include "SkPdfTrapNetworkAppearanceStreamDictionary_autogen.cpp"
+#include "SkPdfSoundObjectDictionary_autogen.cpp"
+#include "SkPdfOutlineItemDictionary_autogen.cpp"
+#include "SkPdfCIDFontDescriptorDictionary_autogen.cpp"
+#include "SkPdfCMapDictionary_autogen.cpp"
+#include "SkPdfNumber_autogen.cpp"
+#include "SkPdfTextAnnotationDictionary_autogen.cpp"
+#include "SkPdfType2PatternDictionary_autogen.cpp"
+#include "SkPdfPSXobjectDictionary_autogen.cpp"
+#include "SkPdfOutlineDictionary_autogen.cpp"
+#include "SkPdfThreadDictionary_autogen.cpp"
+#include "SkPdfImageDictionary_autogen.cpp"
+#include "SkPdfCIDFontDictionary_autogen.cpp"
+#include "SkPdfType5ShadingDictionary_autogen.cpp"
+#include "SkPdfType5HalftoneDictionary_autogen.cpp"
+#include "SkPdfOpiVersionDictionary_autogen.cpp"
+#include "SkPdfStructureElementAccessDictionary_autogen.cpp"
+#include "SkPdfDocumentCatalogActionsDictionary_autogen.cpp"
+#include "SkPdfDeviceNColorSpaceDictionary_autogen.cpp"
+#include "SkPdfMovieDictionary_autogen.cpp"
+#include "SkPdfWidgetAnnotationDictionary_autogen.cpp"
+#include "SkPdfShadingDictionary_autogen.cpp"
+#include "SkPdfCatalogDictionary_autogen.cpp"
+#include "SkPdfStructureTreeRootDictionary_autogen.cpp"
+#include "SkPdfType6ShadingDictionary_autogen.cpp"
+#include "SkPdfFileTrailerDictionary_autogen.cpp"
+#include "SkPdfFDFTemplateDictionary_autogen.cpp"
+#include "SkPdfEmbeddedFileParameterDictionary_autogen.cpp"
+#include "SkPdfBoxColorInformationDictionary_autogen.cpp"
+#include "SkPdfXObjectDictionary_autogen.cpp"
+#include "SkPdfGoToActionDictionary_autogen.cpp"
+#include "SkPdfObjectReferenceDictionary_autogen.cpp"
+#include "SkPdfBoolean_autogen.cpp"
+#include "SkPdfWebCaptureInformationDictionary_autogen.cpp"
+#include "SkPdfStreamCommonDictionary_autogen.cpp"
+#include "SkPdfDctdecodeFilterDictionary_autogen.cpp"
+#include "SkPdfPrinterMarkAnnotationDictionary_autogen.cpp"
+#include "SkPdfStandardStructureDictionary_autogen.cpp"
+#include "SkPdfName_autogen.cpp"
+#include "SkPdfEncryptionCommonDictionary_autogen.cpp"
+#include "SkPdfStandardSecurityHandlerDictionary_autogen.cpp"
+#include "SkPdfSoundAnnotationDictionary_autogen.cpp"
+#include "SkPdfChoiceFieldDictionary_autogen.cpp"
+#include "SkPdfPDF_XOutputIntentDictionary_autogen.cpp"
+#include "SkPdfType4ShadingDictionary_autogen.cpp"
+#include "SkPdfSoundActionDictionary_autogen.cpp"
+#include "SkPdfNull_autogen.cpp"
+#include "SkPdfType10HalftoneDictionary_autogen.cpp"
+#include "SkPdfEmbeddedFontStreamDictionary_autogen.cpp"
+#include "SkPdfType1ShadingDictionary_autogen.cpp"
+#include "SkPdfNameDictionary_autogen.cpp"
+#include "SkPdfCcittfaxdecodeFilterDictionary_autogen.cpp"
+#include "SkPdfType1FormDictionary_autogen.cpp"
+#include "SkPdfFontDictionary_autogen.cpp"
+#include "SkPdfFunctionCommonDictionary_autogen.cpp"
+#include "SkPdfHideActionDictionary_autogen.cpp"
+#include "SkPdfURIDictionary_autogen.cpp"
+#include "SkPdfSignatureDictionary_autogen.cpp"
+#include "SkPdfArray_autogen.cpp"
+#include "SkPdfType0FunctionDictionary_autogen.cpp"
+#include "SkPdfFDFPageDictionary_autogen.cpp"
+#include "SkPdfCalrgbColorSpaceDictionary_autogen.cpp"
diff --git a/experimental/PdfViewer/autogen/SkPdfHexString_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfHexString_autogen.cpp
new file mode 100644
index 0000000..18d112d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfHexString_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfHexString_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfHideActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfHideActionDictionary_autogen.cpp
new file mode 100644
index 0000000..8c80d7a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfHideActionDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfHideActionDictionary_autogen.h"
+
+std::string SkPdfHideActionDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfHideActionDictionary::getTAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfHideActionDictionary::getTAsString() const {
+  std::string ret = "";
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfHideActionDictionary::getTAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+bool SkPdfHideActionDictionary::H() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfHideActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfHideActionDictionary_autogen.h
index e7a97fd..125f339 100644
--- a/experimental/PdfViewer/autogen/SkPdfHideActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfHideActionDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required) The annotation or annotations to be hidden or shown, specified in any
  *  of the following forms:
  *  *  An indirect reference to an annotation dictionary
@@ -557,39 +551,21 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getTAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getTAsDictionary() const;
   bool isTAString() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  std::string getTAsString() const {
-    std::string ret = "";
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getTAsString() const;
   bool isTAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getTAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getTAsArray() const;
 /** (Optional) A flag indicating whether to hide the annotation (true) or show it (false).
  *  Default value: true.
 **/
@@ -597,13 +573,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", NULL));
   }
 
-  bool H() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool H() const;
 };
 
 #endif  // __DEFINED__SkPdfHideActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfIccProfileStreamDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfIccProfileStreamDictionary_autogen.cpp
new file mode 100644
index 0000000..4bffd73
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfIccProfileStreamDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfIccProfileStreamDictionary_autogen.h"
+
+long SkPdfIccProfileStreamDictionary::N() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfIccProfileStreamDictionary::getAlternateAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfIccProfileStreamDictionary::getAlternateAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfIccProfileStreamDictionary::Range() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfIccProfileStreamDictionary::Metadata() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfIccProfileStreamDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfIccProfileStreamDictionary_autogen.h
index 565cb34..e163528 100644
--- a/experimental/PdfViewer/autogen/SkPdfIccProfileStreamDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfIccProfileStreamDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", NULL));
   }
 
-  long N() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long N() const;
 /** (Optional) An alternate color space to be used in case the one specified in the stream
  *  data is not supported (for example, by viewer applications designed for earlier
  *  versions of PDF). The alternate space may be any valid color space (except a Pattern
@@ -562,26 +556,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getAlternateAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getAlternateAsArray() const;
   bool isAlternateAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getAlternateAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternate", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getAlternateAsName() const;
 /** (Optional) An array of 2 x N numbers [min0 max0 min1 max1 ... ] specifying the
  *  minimum and maximum valid values of the corresponding color components.
  *  These values must match the information in the ICC profile. Default value:
@@ -591,13 +573,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", NULL));
   }
 
-  SkPdfArray* Range() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Range() const;
 /** (Optional; PDF 1.4) A metadata stream containing metadata for the color space (see
  *  Section 9.2.2, "Metadata Streams").
 **/
@@ -605,13 +581,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", NULL));
   }
 
-  SkPdfStream* Metadata() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* Metadata() const;
 };
 
 #endif  // __DEFINED__SkPdfIccProfileStreamDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfIconFitDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfIconFitDictionary_autogen.cpp
new file mode 100644
index 0000000..d271706
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfIconFitDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfIconFitDictionary_autogen.h"
+
+std::string SkPdfIconFitDictionary::SW() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SW", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfIconFitDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfIconFitDictionary::A() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfIconFitDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfIconFitDictionary_autogen.h
index 60f7889..b9b49cb 100644
--- a/experimental/PdfViewer/autogen/SkPdfIconFitDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfIconFitDictionary_autogen.h
@@ -537,13 +537,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SW", "", NULL));
   }
 
-  std::string SW() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SW", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string SW() const;
 /** (Required) The type of scaling to use:
  *      A    Anamorphic scaling: scale the icon to fill the annotation rectangle exactly, with-
  *           out regard to its original aspect ratio (ratio of width to height).
@@ -557,13 +551,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required) An array of two numbers between 0.0 and 1.0 indicating the fraction of left-
  *  over space to allocate at the left and bottom of the icon. A value of [0.0 0.0] positions the
  *  icon at the bottom-left corner of the annotation rectangle; a value of [0.5 0.5] centers it
@@ -574,13 +562,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", NULL));
   }
 
-  SkPdfArray* A() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* A() const;
 };
 
 #endif  // __DEFINED__SkPdfIconFitDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfImageDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfImageDictionary_autogen.cpp
new file mode 100644
index 0000000..a2c5eef
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfImageDictionary_autogen.cpp
@@ -0,0 +1,142 @@
+#include "SkPdfImageDictionary_autogen.h"
+
+std::string SkPdfImageDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfImageDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfImageDictionary::Width() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfImageDictionary::Height() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfImageDictionary::getColorSpaceAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfImageDictionary::getColorSpaceAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfImageDictionary::BitsPerComponent() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfImageDictionary::Intent() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Intent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+bool SkPdfImageDictionary::ImageMask() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ImageMask", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+SkPdfStream* SkPdfImageDictionary::getMaskAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfImageDictionary::getMaskAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfImageDictionary::SMask() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfImageDictionary::Decode() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+bool SkPdfImageDictionary::Interpolate() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Interpolate", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+SkPdfArray* SkPdfImageDictionary::Alternates() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternates", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfImageDictionary::Name() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfImageDictionary::StructParent() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfImageDictionary::ID() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfImageDictionary::OPI() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPI", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfImageDictionary::Metadata() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfImageDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfImageDictionary_autogen.h
index c46cf5f..8eb481a 100644
--- a/experimental/PdfViewer/autogen/SkPdfImageDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfImageDictionary_autogen.h
@@ -37,13 +37,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The type of XObject that this dictionary describes; must be
  *  Image for an image XObject.
 **/
@@ -51,39 +45,21 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required) The width of the image, in samples.
 **/
   bool has_Width() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", NULL));
   }
 
-  long Width() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Width() const;
 /** (Required) The height of the image, in samples.
 **/
   bool has_Height() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", NULL));
   }
 
-  long Height() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Height() const;
 /** (Required except for image masks; not allowed for image masks) The color
  *  space in which image samples are specified. This may be any type of color
  *  space except Pattern.
@@ -98,26 +74,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getColorSpaceAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getColorSpaceAsName() const;
   bool isColorSpaceAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getColorSpaceAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getColorSpaceAsArray() const;
 /** (Required except for image masks; optional for image masks) The number of
  *  bits used to represent each color component. Only a single value may be
  *  specified; the number of bits is the same for all color components. Valid
@@ -134,13 +98,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", NULL));
   }
 
-  long BitsPerComponent() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long BitsPerComponent() const;
 /** (Optional; PDF 1.1) The name of a color rendering intent to be used in
  *  rendering the image (see "Rendering Intents" on page 197). Default value:
  *  the current rendering intent in the graphics state.
@@ -149,13 +107,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Intent", "", NULL));
   }
 
-  std::string Intent() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Intent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Intent() const;
 /** (Optional) A flag indicating whether the image is to be treated as an image
  *  mask (see Section 4.8.5, "Masked Images"). If this flag is true, the value of
  *  BitsPerComponent must be 1 and Mask and ColorSpace should not be
@@ -166,13 +118,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ImageMask", "", NULL));
   }
 
-  bool ImageMask() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ImageMask", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool ImageMask() const;
 /** (Optional except for image masks; not allowed for image masks; PDF 1.3) An
  *  image XObject defining an image mask to be applied to this image (see
  *  "Explicit Masking" on page 277), or an array specifying a range of colors
@@ -190,26 +136,14 @@
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getMaskAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getMaskAsStream() const;
   bool isMaskAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getMaskAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mask", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getMaskAsArray() const;
 /** (Optional; PDF 1.4) A subsidiary image XObject defining a soft-mask
  *  image (see "Soft-Mask Images" on page 447) to be used as a source of
  *  mask shape or mask opacity values in the transparent imaging model. The
@@ -225,13 +159,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", NULL));
   }
 
-  SkPdfStream* SMask() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SMask", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* SMask() const;
 /** (Optional) An array of numbers describing how to map image samples
  *  into the range of values appropriate for the image's color space (see
  *  "Decode Arrays" on page 271). If ImageMask is true, the array must be
@@ -243,13 +171,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", NULL));
   }
 
-  SkPdfArray* Decode() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Decode() const;
 /** (Optional) A flag indicating whether image interpolation is to be per-
  *  formed (see "Image Interpolation" on page 273). Default value: false.
 **/
@@ -257,13 +179,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Interpolate", "", NULL));
   }
 
-  bool Interpolate() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Interpolate", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool Interpolate() const;
 /** (Optional; PDF 1.3) An array of alternate image dictionaries for this image
  *  (see "Alternate Images" on page 273). The order of elements within the
  *  array has no significance. This entry may not be present in an image
@@ -273,13 +189,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternates", "", NULL));
   }
 
-  SkPdfArray* Alternates() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alternates", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Alternates() const;
 /** (Required in PDF 1.0; optional otherwise) The name by which this image
  *  XObject is referenced in the XObject subdictionary of the current resource
  *  dictionary (see Section 3.7.2, "Resource Dictionaries").
@@ -290,13 +200,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
   }
 
-  std::string Name() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Name() const;
 /** (Required if the image is a structural content item; PDF 1.3) The integer key
  *  of the image's entry in the structural parent tree (see "Finding Structure
  *  Elements from Content Items" on page 600).
@@ -305,13 +209,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", NULL));
   }
 
-  long StructParent() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long StructParent() const;
 /** (Optional; PDF 1.3; indirect reference preferred) The digital identifier of the
  *  image's parent Web Capture content set (see Section 9.9.5, "Object At-
  *  tributes Related to Web Capture").
@@ -320,13 +218,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
   }
 
-  std::string ID() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string ID() const;
 /** (Optional; PDF 1.2) An OPI version dictionary for the image (see Section
  *  9.10.6, "Open Prepress Interface (OPI)"). If ImageMask is true, this entry
  *  is ignored.
@@ -335,13 +227,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPI", "", NULL));
   }
 
-  SkPdfDictionary* OPI() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPI", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* OPI() const;
 /** (Optional; PDF 1.4) A metadata stream containing metadata for the image
  *  (see Section 9.2.2, "Metadata Streams").
 **/
@@ -349,13 +235,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", NULL));
   }
 
-  SkPdfStream* Metadata() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* Metadata() const;
 };
 
 #endif  // __DEFINED__SkPdfImageDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfImportDataActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfImportDataActionDictionary_autogen.cpp
new file mode 100644
index 0000000..0b1d026
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfImportDataActionDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfImportDataActionDictionary_autogen.h"
+
+std::string SkPdfImportDataActionDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfFileSpec SkPdfImportDataActionDictionary::F() const {
+  SkPdfFileSpec ret;
+  if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFileSpec();
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfImportDataActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfImportDataActionDictionary_autogen.h
index 896dd6b..8c51cd2 100644
--- a/experimental/PdfViewer/autogen/SkPdfImportDataActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfImportDataActionDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required) The FDF file from which to import the data. (See implementation
  *  notes 87 and 88 in Appendix H.)
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  SkPdfFileSpec F() const {
-    SkPdfFileSpec ret;
-    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFileSpec();
-  }
-
+  SkPdfFileSpec F() const;
 };
 
 #endif  // __DEFINED__SkPdfImportDataActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfInkAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfInkAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..351d9cc
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfInkAnnotationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfInkAnnotationDictionary_autogen.h"
+
+std::string SkPdfInkAnnotationDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfInkAnnotationDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfInkAnnotationDictionary::InkList() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InkList", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfInkAnnotationDictionary::BS() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfInkAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfInkAnnotationDictionary_autogen.h
index 7347299..943846b 100644
--- a/experimental/PdfViewer/autogen/SkPdfInkAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfInkAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required) The text to be displayed in the pop-up window when the annotation
  *  is opened. Carriage returns may be used to separate the text into paragraphs.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Required) An array of n arrays, each representing a stroked path. Each array is a
  *  series of alternating horizontal and vertical coordinates in default user space,
  *  specifying points along the path. When drawn, the points are connected by
@@ -563,13 +551,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InkList", "", NULL));
   }
 
-  SkPdfArray* InkList() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "InkList", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* InkList() const;
 /** (Optional) A border style dictionary (see Table 8.12 on page 495) specifying the
  *  line width and dash pattern to be used in drawing the paths.
  *  Note: The annotation dictionary's AP entry, if present, takes precedence over the
@@ -580,13 +562,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", NULL));
   }
 
-  SkPdfDictionary* BS() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* BS() const;
 };
 
 #endif  // __DEFINED__SkPdfInkAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfInlineLevelStructureElementsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfInlineLevelStructureElementsDictionary_autogen.cpp
new file mode 100644
index 0000000..495d722
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfInlineLevelStructureElementsDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfInlineLevelStructureElementsDictionary_autogen.h"
+
+double SkPdfInlineLevelStructureElementsDictionary::getLineHeightAsNumber() const {
+  double ret = 0;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfInlineLevelStructureElementsDictionary::getLineHeightAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfInlineLevelStructureElementsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfInlineLevelStructureElementsDictionary_autogen.h
index 1c8a9bd..1fad174 100644
--- a/experimental/PdfViewer/autogen/SkPdfInlineLevelStructureElementsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfInlineLevelStructureElementsDictionary_autogen.h
@@ -547,26 +547,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Real || ret->podofo()->GetDataType() == ePdfDataType_Number;
   }
 
-  double getLineHeightAsNumber() const {
-    double ret = 0;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double getLineHeightAsNumber() const;
   bool isLineHeightAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getLineHeightAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LineHeight", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getLineHeightAsName() const;
 };
 
 #endif  // __DEFINED__SkPdfInlineLevelStructureElementsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfInteger_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfInteger_autogen.cpp
new file mode 100644
index 0000000..a95fd0d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfInteger_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfInteger_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfInteractiveFormDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfInteractiveFormDictionary_autogen.cpp
new file mode 100644
index 0000000..301c91d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfInteractiveFormDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfInteractiveFormDictionary_autogen.h"
+
+SkPdfArray* SkPdfInteractiveFormDictionary::Fields() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+bool SkPdfInteractiveFormDictionary::NeedAppearances() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NeedAppearances", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+long SkPdfInteractiveFormDictionary::SigFlags() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SigFlags", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfInteractiveFormDictionary::CO() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfInteractiveFormDictionary::DR() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DR", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfInteractiveFormDictionary::DA() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfInteractiveFormDictionary::Q() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfInteractiveFormDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfInteractiveFormDictionary_autogen.h
index 2837857..8720dce 100644
--- a/experimental/PdfViewer/autogen/SkPdfInteractiveFormDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfInteractiveFormDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", NULL));
   }
 
-  SkPdfArray* Fields() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Fields() const;
 /** (Optional) A flag specifying whether to construct appearance streams and
  *  appearance dictionaries for all widget annotations in the document (see
  *  "Variable Text" on page 533). Default value: false.
@@ -547,13 +541,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NeedAppearances", "", NULL));
   }
 
-  bool NeedAppearances() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NeedAppearances", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool NeedAppearances() const;
 /** (Optional; PDF 1.3) A set of flags specifying various document-level char-
  *  acteristics related to signature fields (see Table 8.48, below, and "Signature
  *  Fields" on page 547). Default value: 0.
@@ -562,13 +550,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SigFlags", "", NULL));
   }
 
-  long SigFlags() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SigFlags", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long SigFlags() const;
 /** (Required if any fields in the document have additional-actions dictionaries
  *  containing a C entry; PDF 1.3) An array of indirect references to field dic-
  *  tionaries with calculation actions, defining the calculation order in which
@@ -579,13 +561,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", NULL));
   }
 
-  SkPdfArray* CO() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* CO() const;
 /** (Optional) A document-wide default value for the DR attribute of variable
  *  text fields (see "Variable Text" on page 533).
 **/
@@ -593,13 +569,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DR", "", NULL));
   }
 
-  SkPdfDictionary* DR() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DR", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* DR() const;
 /** (Optional) A document-wide default value for the DA attribute of variable
  *  text fields (see "Variable Text" on page 533).
 **/
@@ -607,13 +577,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", NULL));
   }
 
-  std::string DA() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string DA() const;
 /** (Optional) A document-wide default value for the Q attribute of variable
  *  text fields (see "Variable Text" on page 533).
 **/
@@ -621,13 +585,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", NULL));
   }
 
-  long Q() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Q() const;
 };
 
 #endif  // __DEFINED__SkPdfInteractiveFormDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfJavascriptActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfJavascriptActionDictionary_autogen.cpp
new file mode 100644
index 0000000..c31145f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfJavascriptActionDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfJavascriptActionDictionary_autogen.h"
+
+std::string SkPdfJavascriptActionDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfJavascriptActionDictionary::getJSAsString() const {
+  std::string ret = "";
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfStream* SkPdfJavascriptActionDictionary::getJSAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfJavascriptActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfJavascriptActionDictionary_autogen.h
index fdac070..fa3a1ae 100644
--- a/experimental/PdfViewer/autogen/SkPdfJavascriptActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfJavascriptActionDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required) A string or stream containing the JavaScript script to be executed.
  *  Note: PDFDocEncoding or Unicode encoding (the latter identified by the Unicode
  *  prefix U+ FEFF) is used to encode the contents of the string or stream. (See imple-
@@ -554,26 +548,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  std::string getJSAsString() const {
-    std::string ret = "";
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getJSAsString() const;
   bool isJSAStream() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return false;
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getJSAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getJSAsStream() const;
 };
 
 #endif  // __DEFINED__SkPdfJavascriptActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfJavascriptDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfJavascriptDictionary_autogen.cpp
new file mode 100644
index 0000000..8204e69
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfJavascriptDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfJavascriptDictionary_autogen.h"
+
+std::string SkPdfJavascriptDictionary::getBeforeAsString() const {
+  std::string ret = "";
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfStream* SkPdfJavascriptDictionary::getBeforeAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfJavascriptDictionary::getAfterAsString() const {
+  std::string ret = "";
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfStream* SkPdfJavascriptDictionary::getAfterAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfJavascriptDictionary::Doc() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Doc", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfJavascriptDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfJavascriptDictionary_autogen.h
index 4a1ee00..42f3ba5 100644
--- a/experimental/PdfViewer/autogen/SkPdfJavascriptDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfJavascriptDictionary_autogen.h
@@ -538,26 +538,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  std::string getBeforeAsString() const {
-    std::string ret = "";
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getBeforeAsString() const;
   bool isBeforeAStream() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return false;
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getBeforeAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Before", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getBeforeAsStream() const;
 /** (Optional) A string or stream containing a JavaScript script to be executed
  *  just after the FDF file is imported.
 **/
@@ -571,26 +559,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  std::string getAfterAsString() const {
-    std::string ret = "";
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getAfterAsString() const;
   bool isAfterAStream() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return false;
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getAfterAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "After", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getAfterAsStream() const;
 /** (Optional) An array defining additional JavaScript scripts to be added to
  *  those defined in the JavaScript entry of the document's name dictionary (see
  *  Section 3.6.3, "Name Dictionary"). The array contains an even number of
@@ -605,13 +581,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Doc", "", NULL));
   }
 
-  SkPdfArray* Doc() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Doc", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Doc() const;
 };
 
 #endif  // __DEFINED__SkPdfJavascriptDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfJbig2DecodeFilterDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfJbig2DecodeFilterDictionary_autogen.cpp
new file mode 100644
index 0000000..d86a9cf
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfJbig2DecodeFilterDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfJbig2DecodeFilterDictionary_autogen.h"
+
+SkPdfStream* SkPdfJbig2DecodeFilterDictionary::JBIG2Globals() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JBIG2Globals", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfJbig2DecodeFilterDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfJbig2DecodeFilterDictionary_autogen.h
index 2f457fb..ecb6fc7 100644
--- a/experimental/PdfViewer/autogen/SkPdfJbig2DecodeFilterDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfJbig2DecodeFilterDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JBIG2Globals", "", NULL));
   }
 
-  SkPdfStream* JBIG2Globals() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JBIG2Globals", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* JBIG2Globals() const;
 };
 
 #endif  // __DEFINED__SkPdfJbig2DecodeFilterDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfLabColorSpaceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfLabColorSpaceDictionary_autogen.cpp
new file mode 100644
index 0000000..ddc3a19
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfLabColorSpaceDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfLabColorSpaceDictionary_autogen.h"
+
+SkPdfArray* SkPdfLabColorSpaceDictionary::WhitePoint() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfLabColorSpaceDictionary::BlackPoint() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfLabColorSpaceDictionary::Range() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfLabColorSpaceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfLabColorSpaceDictionary_autogen.h
index 52fb023..bc8dd7e 100644
--- a/experimental/PdfViewer/autogen/SkPdfLabColorSpaceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfLabColorSpaceDictionary_autogen.h
@@ -534,13 +534,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", NULL));
   }
 
-  SkPdfArray* WhitePoint() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WhitePoint", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* WhitePoint() const;
 /** (Optional) An array of three numbers [ XB YB ZB ] specifying the tristimulus value, in
  *  the CIE 1931 XYZ space, of the diffuse black point; see "CalRGB Color Spaces" on
  *  page 184 for further discussion. All three of these numbers must be nonnegative.
@@ -550,13 +544,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", NULL));
   }
 
-  SkPdfArray* BlackPoint() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BlackPoint", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* BlackPoint() const;
 /** (Optional) An array of four numbers [ amin amax bmin bmax ] specifying the range of
  *  valid values for the a* and b* (B and C) components of the color space-that is,
  *        a min <= a* <= a max
@@ -569,13 +557,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", NULL));
   }
 
-  SkPdfArray* Range() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Range", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Range() const;
 };
 
 #endif  // __DEFINED__SkPdfLabColorSpaceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfLaunchActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfLaunchActionDictionary_autogen.cpp
new file mode 100644
index 0000000..b643d15
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfLaunchActionDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfLaunchActionDictionary_autogen.h"
+
+std::string SkPdfLaunchActionDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfFileSpec SkPdfLaunchActionDictionary::F() const {
+  SkPdfFileSpec ret;
+  if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFileSpec();
+}
+
+SkPdfDictionary* SkPdfLaunchActionDictionary::Win() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Win", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfObject* SkPdfLaunchActionDictionary::Mac() const {
+  SkPdfObject* ret;
+  if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfObject* SkPdfLaunchActionDictionary::Unix() const {
+  SkPdfObject* ret;
+  if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Unix", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+bool SkPdfLaunchActionDictionary::NewWindow() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfLaunchActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfLaunchActionDictionary_autogen.h
index 5fbb763..f3bc768 100644
--- a/experimental/PdfViewer/autogen/SkPdfLaunchActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfLaunchActionDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required if none of the entries Win, Mac, or Unix is present) The application to
  *  be launched or the document to be opened or printed. If this entry is absent
  *  and the viewer application does not understand any of the alternative entries,
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  SkPdfFileSpec F() const {
-    SkPdfFileSpec ret;
-    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFileSpec();
-  }
-
+  SkPdfFileSpec F() const;
 /** (Optional) A dictionary containing Windows-specific launch parameters (see
  *  the Table 8.38; see also implementation note 73 in Appendix H).
 **/
@@ -562,39 +550,21 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Win", "", NULL));
   }
 
-  SkPdfDictionary* Win() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Win", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Win() const;
 /** (Optional) Mac OS'specific launch parameters; not yet defined.
 **/
   bool has_Mac() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", NULL));
   }
 
-  SkPdfObject* Mac() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mac", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfObject* Mac() const;
 /** (Optional) UNIX-specific launch parameters; not yet defined.
 **/
   bool has_Unix() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Unix", "", NULL));
   }
 
-  SkPdfObject* Unix() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Unix", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfObject* Unix() const;
 /** (Optional; PDF 1.2) A flag specifying whether to open the destination docu-
  *  ment in a new window. If this flag is false, the destination document will
  *  replace the current document in the same window. If this entry is absent, the
@@ -606,13 +576,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", NULL));
   }
 
-  bool NewWindow() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool NewWindow() const;
 };
 
 #endif  // __DEFINED__SkPdfLaunchActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfLineAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfLineAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..d5c040a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfLineAnnotationDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfLineAnnotationDictionary_autogen.h"
+
+std::string SkPdfLineAnnotationDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfLineAnnotationDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfLineAnnotationDictionary::L() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfLineAnnotationDictionary::BS() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfLineAnnotationDictionary::LE() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LE", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfLineAnnotationDictionary::IC() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfLineAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfLineAnnotationDictionary_autogen.h
index 29f5758..0a0716b 100644
--- a/experimental/PdfViewer/autogen/SkPdfLineAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfLineAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required) The text to be displayed in the pop-up window when the annotation
  *  is opened. Carriage returns may be used to separate the text into paragraphs.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Required) An array of four numbers, [x1 y1 x2 y2 ], specifying the starting and
  *  ending coordinates of the line in default user space.
 **/
@@ -560,13 +548,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", NULL));
   }
 
-  SkPdfArray* L() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* L() const;
 /** (Optional) A border style dictionary (see Table 8.12 on page 495) specifying the
  *  width and dash pattern to be used in drawing the line.
  *  Note: The annotation dictionary's AP entry, if present, takes precedence over the L
@@ -576,13 +558,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", NULL));
   }
 
-  SkPdfDictionary* BS() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* BS() const;
 /** (Optional; PDF 1.4) An array of two names specifying the line ending styles to be
  *  used in drawing the line. The first and second elements of the array specify the
  *  line ending styles for the endpoints defined, respectively, by the first and second
@@ -593,13 +569,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LE", "", NULL));
   }
 
-  SkPdfArray* LE() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LE", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* LE() const;
 /** (Optional; PDF 1.4) An array of three numbers in the range 0.0 to 1.0 specifying
  *  the components, in the DeviceRGB color space, of the interior color with which to
  *  fill the annotation's line endings (see Table 8.19). If this entry is absent, the inte-
@@ -609,13 +579,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", NULL));
   }
 
-  SkPdfArray* IC() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* IC() const;
 };
 
 #endif  // __DEFINED__SkPdfLineAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfListAttributeDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfListAttributeDictionary_autogen.cpp
new file mode 100644
index 0000000..8d6b29e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfListAttributeDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfListAttributeDictionary_autogen.h"
+
+std::string SkPdfListAttributeDictionary::ListNumbering() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ListNumbering", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfListAttributeDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfListAttributeDictionary_autogen.h
index 8b8bbe3..7463e3b 100644
--- a/experimental/PdfViewer/autogen/SkPdfListAttributeDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfListAttributeDictionary_autogen.h
@@ -548,13 +548,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ListNumbering", "", NULL));
   }
 
-  std::string ListNumbering() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ListNumbering", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string ListNumbering() const;
 };
 
 #endif  // __DEFINED__SkPdfListAttributeDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.cpp
new file mode 100644
index 0000000..8b3541d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.h"
+
+long SkPdfLzwdecodeAndFlatedecodeFiltersDictionary::Predictor() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Predictor", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfLzwdecodeAndFlatedecodeFiltersDictionary::Colors() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colors", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfLzwdecodeAndFlatedecodeFiltersDictionary::BitsPerComponent() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfLzwdecodeAndFlatedecodeFiltersDictionary::Columns() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Columns", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfLzwdecodeAndFlatedecodeFiltersDictionary::EarlyChange() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EarlyChange", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.h
index eb43ba2..08f8e00 100644
--- a/experimental/PdfViewer/autogen/SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfLzwdecodeAndFlatedecodeFiltersDictionary_autogen.h
@@ -536,13 +536,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Predictor", "", NULL));
   }
 
-  long Predictor() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Predictor", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Predictor() const;
 /** (Used only if Predictor is greater than 1) The number of interleaved color com-
  *  ponents per sample. Valid values are 1 to 4 in PDF 1.2 or earlier, and 1 or
  *  greater in PDF 1.3 or later. Default value: 1.
@@ -551,13 +545,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colors", "", NULL));
   }
 
-  long Colors() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colors", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Colors() const;
 /** (Used only if Predictor is greater than 1) The number of bits used to represent
  *  each color component in a sample. Valid values are 1, 2, 4, and 8. Default
  *  value: 8.
@@ -566,13 +554,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", NULL));
   }
 
-  long BitsPerComponent() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long BitsPerComponent() const;
 /** (Used only if Predictor is greater than 1) The number of samples in each row.
  *  Default value: 1.
 **/
@@ -580,13 +562,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Columns", "", NULL));
   }
 
-  long Columns() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Columns", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Columns() const;
 /** (LZWDecode only) An indication of when to increase the code length. If the
  *  value of this entry is 0, code length increases are postponed as long as pos-
  *  sible. If it is 1, they occur one code early. This parameter is included because
@@ -597,13 +573,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EarlyChange", "", NULL));
   }
 
-  long EarlyChange() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EarlyChange", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long EarlyChange() const;
 };
 
 #endif  // __DEFINED__SkPdfLzwdecodeAndFlatedecodeFiltersDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMacOsFileInformationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMacOsFileInformationDictionary_autogen.cpp
new file mode 100644
index 0000000..d43e0e7
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMacOsFileInformationDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfMacOsFileInformationDictionary_autogen.h"
+
+std::string SkPdfMacOsFileInformationDictionary::Subtype() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfMacOsFileInformationDictionary::Creator() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Creator", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfStream* SkPdfMacOsFileInformationDictionary::ResFork() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ResFork", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMacOsFileInformationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMacOsFileInformationDictionary_autogen.h
index 5e070c8..f6b2eaa 100644
--- a/experimental/PdfViewer/autogen/SkPdfMacOsFileInformationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMacOsFileInformationDictionary_autogen.h
@@ -531,39 +531,21 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Optional) The embedded file's creator signature.
 **/
   bool has_Creator() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Creator", "", NULL));
   }
 
-  std::string Creator() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Creator", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Creator() const;
 /** (Optional) The binary contents of the embedded file's resource fork.
 **/
   bool has_ResFork() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ResFork", "", NULL));
   }
 
-  SkPdfStream* ResFork() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ResFork", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* ResFork() const;
 };
 
 #endif  // __DEFINED__SkPdfMacOsFileInformationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMarkInformationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMarkInformationDictionary_autogen.cpp
new file mode 100644
index 0000000..2a5c8ec
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMarkInformationDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfMarkInformationDictionary_autogen.h"
+
+bool SkPdfMarkInformationDictionary::Marked() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Marked", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMarkInformationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMarkInformationDictionary_autogen.h
index c88d491..3a3a2b9 100644
--- a/experimental/PdfViewer/autogen/SkPdfMarkInformationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMarkInformationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Marked", "", NULL));
   }
 
-  bool Marked() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Marked", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool Marked() const;
 };
 
 #endif  // __DEFINED__SkPdfMarkInformationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMarkedContentReferenceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMarkedContentReferenceDictionary_autogen.cpp
new file mode 100644
index 0000000..0b8cf8a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMarkedContentReferenceDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfMarkedContentReferenceDictionary_autogen.h"
+
+std::string SkPdfMarkedContentReferenceDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfMarkedContentReferenceDictionary::Pg() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfMarkedContentReferenceDictionary::Stm() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Stm", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfObject* SkPdfMarkedContentReferenceDictionary::StmOwn() const {
+  SkPdfObject* ret;
+  if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StmOwn", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfMarkedContentReferenceDictionary::MCID() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MCID", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMarkedContentReferenceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMarkedContentReferenceDictionary_autogen.h
index bf0f64f..1e3522b 100644
--- a/experimental/PdfViewer/autogen/SkPdfMarkedContentReferenceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMarkedContentReferenceDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Optional; must be an indirect reference) The page object representing the page on
  *  which the graphics objects in the marked-content sequence are rendered. This
  *  entry overrides any Pg entry in the structure element containing the marked-
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", NULL));
   }
 
-  SkPdfDictionary* Pg() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Pg() const;
 /** (Optional; must be an indirect reference) The content stream containing the
  *  marked-content sequence. This entry is needed only if the marked-content
  *  sequence resides in some other content stream associated with the page-for
@@ -566,13 +554,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Stm", "", NULL));
   }
 
-  SkPdfStream* Stm() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Stm", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* Stm() const;
 /** (Optional; must be an indirect reference) The PDF object owning the stream
  *  identified by Stm-for example, the annotation to which an appearance stream
  *  belongs.
@@ -581,13 +563,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StmOwn", "", NULL));
   }
 
-  SkPdfObject* StmOwn() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StmOwn", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfObject* StmOwn() const;
 /** (Required) The marked-content identifier of the marked-content sequence with-
  *  in its content stream.
 **/
@@ -595,13 +571,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MCID", "", NULL));
   }
 
-  long MCID() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MCID", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long MCID() const;
 };
 
 #endif  // __DEFINED__SkPdfMarkedContentReferenceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMarkupAnnotationsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMarkupAnnotationsDictionary_autogen.cpp
new file mode 100644
index 0000000..440c92a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMarkupAnnotationsDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfMarkupAnnotationsDictionary_autogen.h"
+
+std::string SkPdfMarkupAnnotationsDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfMarkupAnnotationsDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfMarkupAnnotationsDictionary::QuadPoints() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "QuadPoints", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMarkupAnnotationsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMarkupAnnotationsDictionary_autogen.h
index dc754b2..747ac24 100644
--- a/experimental/PdfViewer/autogen/SkPdfMarkupAnnotationsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMarkupAnnotationsDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required) The text to be displayed in the pop-up window when the annota-
  *  tion is opened. Carriage returns may be used to separate the text into para-
  *  graphs.
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Required) An array of 8 x n numbers specifying the coordinates of n quadri-
  *  laterals in default user space. Each quadrilateral encompasses a word or
  *  group of contiguous words in the text underlying the annotation. The coor-
@@ -579,13 +567,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "QuadPoints", "", NULL));
   }
 
-  SkPdfArray* QuadPoints() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "QuadPoints", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* QuadPoints() const;
 };
 
 #endif  // __DEFINED__SkPdfMarkupAnnotationsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMetadataStreamDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMetadataStreamDictionary_autogen.cpp
new file mode 100644
index 0000000..6ce1677
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMetadataStreamDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfMetadataStreamDictionary_autogen.h"
+
+std::string SkPdfMetadataStreamDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfMetadataStreamDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMetadataStreamDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMetadataStreamDictionary_autogen.h
index 0c8798f..2724d10 100644
--- a/experimental/PdfViewer/autogen/SkPdfMetadataStreamDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMetadataStreamDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The type of metadata stream that this dictionary describes; must be
  *  XML.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 };
 
 #endif  // __DEFINED__SkPdfMetadataStreamDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMovieActionDictionary_autogen.cpp
new file mode 100644
index 0000000..9211e45
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMovieActionDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfMovieActionDictionary_autogen.h"
+
+std::string SkPdfMovieActionDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfMovieActionDictionary::Annot() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annot", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfMovieActionDictionary::T() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfMovieActionDictionary::Operation() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Operation", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMovieActionDictionary_autogen.h
index 2b2e193..41348bc 100644
--- a/experimental/PdfViewer/autogen/SkPdfMovieActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMovieActionDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Optional) An indirect reference to a movie annotation identifying the movie
  *  to be played.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annot", "", NULL));
   }
 
-  SkPdfDictionary* Annot() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annot", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Annot() const;
 /** (Optional) The title of a movie annotation identifying the movie to be
  *  played.
  *  Note: The dictionary must include either an Annot or a T entry, but not both.
@@ -561,13 +549,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", NULL));
   }
 
-  std::string T() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string T() const;
 /** (Optional) The operation to be performed on the movie:
  *     Play         Start playing the movie, using the play mode specified by the
  *                  dictionary's Mode entry (see Table 8.79 on page 571). If the
@@ -583,13 +565,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Operation", "", NULL));
   }
 
-  std::string Operation() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Operation", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Operation() const;
 };
 
 #endif  // __DEFINED__SkPdfMovieActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieActivationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMovieActivationDictionary_autogen.cpp
new file mode 100644
index 0000000..1d327a5
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMovieActivationDictionary_autogen.cpp
@@ -0,0 +1,65 @@
+#include "SkPdfMovieActivationDictionary_autogen.h"
+
+SkPdfObject* SkPdfMovieActivationDictionary::Start() const {
+  SkPdfObject* ret;
+  if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Start", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfObject* SkPdfMovieActivationDictionary::Duration() const {
+  SkPdfObject* ret;
+  if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Duration", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+double SkPdfMovieActivationDictionary::Rate() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rate", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfMovieActivationDictionary::Volume() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Volume", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+bool SkPdfMovieActivationDictionary::ShowControls() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShowControls", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+std::string SkPdfMovieActivationDictionary::Mode() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+bool SkPdfMovieActivationDictionary::Synchronous() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+SkPdfArray* SkPdfMovieActivationDictionary::FWScale() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWScale", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfMovieActivationDictionary::FWPosition() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWPosition", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieActivationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMovieActivationDictionary_autogen.h
index 88fe52b..b3702db 100644
--- a/experimental/PdfViewer/autogen/SkPdfMovieActivationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMovieActivationDictionary_autogen.h
@@ -544,13 +544,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Start", "", NULL));
   }
 
-  SkPdfObject* Start() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Start", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfObject* Start() const;
 /** (Optional) The duration of the movie segment to be played, specified in the
  *  same form as Start. Negative values specify that the movie is to be played
  *  backward. If this entry is omitted, the movie is played to the end.
@@ -559,13 +553,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Duration", "", NULL));
   }
 
-  SkPdfObject* Duration() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Duration", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfObject* Duration() const;
 /** (Optional) The initial speed at which to play the movie. If the value of this
  *  entry is negative, the movie is played backward with respect to Start and
  *  Duration. Default value: 1.0.
@@ -574,13 +562,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rate", "", NULL));
   }
 
-  double Rate() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rate", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double Rate() const;
 /** (Optional) The initial sound volume at which to play the movie, in the range
  *  -1.0 to 1.0. Higher values denote greater volume; negative values mute the
  *  sound. Default value: 1.0.
@@ -589,13 +571,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Volume", "", NULL));
   }
 
-  double Volume() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Volume", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double Volume() const;
 /** (Optional) A flag specifying whether to display a movie controller bar while
  *  playing the movie. Default value: false.
 **/
@@ -603,13 +579,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShowControls", "", NULL));
   }
 
-  bool ShowControls() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShowControls", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool ShowControls() const;
 /** (Optional) The play mode for playing the movie:
  *      Once              Play once and stop.
  *      Open              Play and leave the movie controller bar open.
@@ -621,13 +591,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mode", "", NULL));
   }
 
-  std::string Mode() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Mode() const;
 /** (Optional) A flag specifying whether to play the movie synchronously or
  *  asynchronously. If this value is true, the movie player will retain control until
  *  the movie is completed or dismissed by the user; if false, it will return control
@@ -638,13 +602,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", NULL));
   }
 
-  bool Synchronous() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool Synchronous() const;
 /** (Optional) The magnification (zoom) factor at which to play the movie. The
  *  presence of this entry implies that the movie is to be played in a floating win-
  *  dow; if the entry is absent, it will be played in the annotation rectangle.
@@ -658,13 +616,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWScale", "", NULL));
   }
 
-  SkPdfArray* FWScale() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWScale", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* FWScale() const;
 /** (Optional) For floating play windows, the relative position of the window on
  *  the screen. The value is an array of two numbers
  *      [horiz vert]
@@ -677,13 +629,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWPosition", "", NULL));
   }
 
-  SkPdfArray* FWPosition() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FWPosition", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* FWPosition() const;
 };
 
 #endif  // __DEFINED__SkPdfMovieActivationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMovieAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..d2e375e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMovieAnnotationDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfMovieAnnotationDictionary_autogen.h"
+
+std::string SkPdfMovieAnnotationDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfMovieAnnotationDictionary::Movie() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Movie", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfMovieAnnotationDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+bool SkPdfMovieAnnotationDictionary::getAAsBoolean() const {
+  bool ret = false;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+SkPdfDictionary* SkPdfMovieAnnotationDictionary::getAAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMovieAnnotationDictionary_autogen.h
index db13412..5f0218e 100644
--- a/experimental/PdfViewer/autogen/SkPdfMovieAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMovieAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required) A movie dictionary describing the movie's static characteristics (see
  *  Section 8.8, "Movies").
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Movie", "", NULL));
   }
 
-  SkPdfDictionary* Movie() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Movie", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Movie() const;
 /** (Optional; PDF 1.4) An alternate representation of the annotation's contents in
  *  human-readable form, useful when extracting the document's contents in sup-
  *  port of accessibility to disabled users or for other purposes (see Section 9.8.2,
@@ -562,13 +550,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Optional) A flag or dictionary specifying whether and how to play the movie
  *  when the annotation is activated. If this value is a dictionary, it is a movie activa-
  *  tion dictionary (see Section 8.8, "Movies") specifying how to play the movie; if it
@@ -586,26 +568,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Bool;
   }
 
-  bool getAAsBoolean() const {
-    bool ret = false;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool getAAsBoolean() const;
   bool isAADictionary() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getAAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getAAsDictionary() const;
 };
 
 #endif  // __DEFINED__SkPdfMovieAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMovieDictionary_autogen.cpp
new file mode 100644
index 0000000..8f3ba01
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMovieDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfMovieDictionary_autogen.h"
+
+SkPdfFileSpec SkPdfMovieDictionary::F() const {
+  SkPdfFileSpec ret;
+  if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFileSpec();
+}
+
+SkPdfArray* SkPdfMovieDictionary::Aspect() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Aspect", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfMovieDictionary::Rotate() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rotate", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+bool SkPdfMovieDictionary::getPosterAsBoolean() const {
+  bool ret = false;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+SkPdfStream* SkPdfMovieDictionary::getPosterAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMovieDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMovieDictionary_autogen.h
index 9173414..2fe0d5b 100644
--- a/experimental/PdfViewer/autogen/SkPdfMovieDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMovieDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  SkPdfFileSpec F() const {
-    SkPdfFileSpec ret;
-    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFileSpec();
-  }
-
+  SkPdfFileSpec F() const;
 /** (Optional) The width and height of the movie's bounding box, in pixels,
  *  specified as [width height]. This entry should be omitted for a movie consist-
  *  ing entirely of sound with no visible images.
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Aspect", "", NULL));
   }
 
-  SkPdfArray* Aspect() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Aspect", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Aspect() const;
 /** (Optional) The number of degrees by which the movie is rotated clockwise
  *  relative to the page. The value must be a multiple of 90. Default value: 0.
 **/
@@ -562,13 +550,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rotate", "", NULL));
   }
 
-  long Rotate() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rotate", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Rotate() const;
 /** (Optional) A flag or stream specifying whether and how to display a poster
  *  image representing the movie. If this value is a stream, it contains an image
  *  XObject (see Section 4.8, "Images") to be displayed as the poster; if it is the
@@ -585,26 +567,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Bool;
   }
 
-  bool getPosterAsBoolean() const {
-    bool ret = false;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool getPosterAsBoolean() const;
   bool isPosterAStream() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return false;
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getPosterAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Poster", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getPosterAsStream() const;
 };
 
 #endif  // __DEFINED__SkPdfMovieDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfMultiMasterFontDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfMultiMasterFontDictionary_autogen.cpp
new file mode 100644
index 0000000..7cc1b8f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfMultiMasterFontDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfMultiMasterFontDictionary_autogen.h"
+
+std::string SkPdfMultiMasterFontDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfMultiMasterFontDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfMultiMasterFontDictionary_autogen.h
index 766cf06..6009cb3 100644
--- a/experimental/PdfViewer/autogen/SkPdfMultiMasterFontDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfMultiMasterFontDictionary_autogen.h
@@ -36,13 +36,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 };
 
 #endif  // __DEFINED__SkPdfMultiMasterFontDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfNameDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfNameDictionary_autogen.cpp
new file mode 100644
index 0000000..8cbdd45
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfNameDictionary_autogen.cpp
@@ -0,0 +1,114 @@
+#include "SkPdfNameDictionary_autogen.h"
+
+std::string SkPdfNameDictionary::getDestsAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getDestsAsTree() const {
+  SkPdfTree* ret = NULL;
+  if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfNameDictionary::getAPAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getAPAsTree() const {
+  SkPdfTree* ret = NULL;
+  if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfNameDictionary::getJavaScriptAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getJavaScriptAsTree() const {
+  SkPdfTree* ret = NULL;
+  if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfNameDictionary::getPagesAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getPagesAsTree() const {
+  SkPdfTree* ret = NULL;
+  if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfNameDictionary::getTemplatesAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getTemplatesAsTree() const {
+  SkPdfTree* ret = NULL;
+  if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfNameDictionary::getIDSAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getIDSAsTree() const {
+  SkPdfTree* ret = NULL;
+  if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfNameDictionary::getURLSAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getURLSAsTree() const {
+  SkPdfTree* ret = NULL;
+  if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfNameDictionary::getEmbeddedFilesAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfTree* SkPdfNameDictionary::getEmbeddedFilesAsTree() const {
+  SkPdfTree* ret = NULL;
+  if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfNameDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfNameDictionary_autogen.h
index 2e1e824..45afd1f 100644
--- a/experimental/PdfViewer/autogen/SkPdfNameDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfNameDictionary_autogen.h
@@ -538,26 +538,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getDestsAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getDestsAsName() const;
   bool isDestsATree() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfTree* getDestsAsTree() const {
-    SkPdfTree* ret = NULL;
-    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dests", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfTree* getDestsAsTree() const;
 /** (Optional; PDF 1.3) A name tree mapping name strings to annotation
  *  appearance streams (see Section 8.4.4, "Appearance Streams").
 **/
@@ -571,26 +559,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getAPAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getAPAsName() const;
   bool isAPATree() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfTree* getAPAsTree() const {
-    SkPdfTree* ret = NULL;
-    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AP", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfTree* getAPAsTree() const;
 /** (Optional; PDF 1.3) A name tree mapping name strings to document-level
  *  JavaScript(R) actions (see "JavaScript Actions" on page 556).
 **/
@@ -604,26 +580,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getJavaScriptAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getJavaScriptAsName() const;
   bool isJavaScriptATree() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfTree* getJavaScriptAsTree() const {
-    SkPdfTree* ret = NULL;
-    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "JavaScript", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfTree* getJavaScriptAsTree() const;
 /** (Optional; PDF 1.3) A name tree mapping name strings to visible pages for
  *  use in interactive forms (see Section 8.6.5, "Named Pages").
 **/
@@ -637,26 +601,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getPagesAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getPagesAsName() const;
   bool isPagesATree() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfTree* getPagesAsTree() const {
-    SkPdfTree* ret = NULL;
-    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfTree* getPagesAsTree() const;
 /** (Optional; PDF 1.3) A name tree mapping name strings to invisible (tem-
  *  plate) pages for use in interactive forms (see Section 8.6.5, "Named Pages").
 **/
@@ -670,26 +622,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getTemplatesAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getTemplatesAsName() const;
   bool isTemplatesATree() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfTree* getTemplatesAsTree() const {
-    SkPdfTree* ret = NULL;
-    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Templates", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfTree* getTemplatesAsTree() const;
 /** (Optional; PDF 1.3) A name tree mapping digital identifiers to Web Capture
  *  content sets (see Section 9.9.3, "Content Sets").
 **/
@@ -703,26 +643,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getIDSAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getIDSAsName() const;
   bool isIDSATree() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfTree* getIDSAsTree() const {
-    SkPdfTree* ret = NULL;
-    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfTree* getIDSAsTree() const;
 /** (Optional; PDF 1.3) A name tree mapping uniform resource locators (URLs)
  *  to Web Capture content sets (see Section 9.9.3, "Content Sets").
 **/
@@ -736,26 +664,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getURLSAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getURLSAsName() const;
   bool isURLSATree() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfTree* getURLSAsTree() const {
-    SkPdfTree* ret = NULL;
-    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URLS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfTree* getURLSAsTree() const;
 /** (Optional; PDF 1.4) A name tree mapping name strings to embedded file
  *  streams (see Section 3.10.3, "Embedded File Streams").
 **/
@@ -769,26 +685,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getEmbeddedFilesAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getEmbeddedFilesAsName() const;
   bool isEmbeddedFilesATree() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfTree* getEmbeddedFilesAsTree() const {
-    SkPdfTree* ret = NULL;
-    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "EmbeddedFiles", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfTree* getEmbeddedFilesAsTree() const;
 };
 
 #endif  // __DEFINED__SkPdfNameDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfNameTreeNodeDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfNameTreeNodeDictionary_autogen.cpp
new file mode 100644
index 0000000..e677440
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfNameTreeNodeDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfNameTreeNodeDictionary_autogen.h"
+
+SkPdfArray* SkPdfNameTreeNodeDictionary::Kids() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfNameTreeNodeDictionary::Names() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfNameTreeNodeDictionary::Limits() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfNameTreeNodeDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfNameTreeNodeDictionary_autogen.h
index 6a9afd4..e92e293 100644
--- a/experimental/PdfViewer/autogen/SkPdfNameTreeNodeDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfNameTreeNodeDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", NULL));
   }
 
-  SkPdfArray* Kids() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Kids() const;
 /** (Root and leaf nodes only; required in leaf nodes; present in the root node if and only if Kids
  *  is not present) An array of the form
  *      [key1 value1 key2 value2 ... keyn valuen ]
@@ -550,13 +544,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", NULL));
   }
 
-  SkPdfArray* Names() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Names", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Names() const;
 /** (Intermediate and leaf nodes only; required) An array of two strings, specifying the (lexi-
  *  cally) least and greatest keys included in the Names array of a leaf node or in the Names
  *  arrays of any leaf nodes that are descendants of an intermediate node.
@@ -565,13 +553,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", NULL));
   }
 
-  SkPdfArray* Limits() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Limits() const;
 };
 
 #endif  // __DEFINED__SkPdfNameTreeNodeDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfName_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfName_autogen.cpp
new file mode 100644
index 0000000..d986d32
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfName_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfName_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfNamedActionsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfNamedActionsDictionary_autogen.cpp
new file mode 100644
index 0000000..b2b83f0
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfNamedActionsDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfNamedActionsDictionary_autogen.h"
+
+std::string SkPdfNamedActionsDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfNamedActionsDictionary::N() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfNamedActionsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfNamedActionsDictionary_autogen.h
index 8545683..2f18b39 100644
--- a/experimental/PdfViewer/autogen/SkPdfNamedActionsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfNamedActionsDictionary_autogen.h
@@ -532,26 +532,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required) The name of the action to be performed (see Table 8.45).
 **/
   bool has_N() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", NULL));
   }
 
-  std::string N() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string N() const;
 };
 
 #endif  // __DEFINED__SkPdfNamedActionsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfNull_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfNull_autogen.cpp
new file mode 100644
index 0000000..1e65ded
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfNull_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfNull_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfNumberTreeNodeDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfNumberTreeNodeDictionary_autogen.cpp
new file mode 100644
index 0000000..002b2bf
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfNumberTreeNodeDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfNumberTreeNodeDictionary_autogen.h"
+
+SkPdfArray* SkPdfNumberTreeNodeDictionary::Kids() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfNumberTreeNodeDictionary::Nums() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Nums", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfNumberTreeNodeDictionary::Limits() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfNumberTreeNodeDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfNumberTreeNodeDictionary_autogen.h
index 3cce6af..596744a 100644
--- a/experimental/PdfViewer/autogen/SkPdfNumberTreeNodeDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfNumberTreeNodeDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", NULL));
   }
 
-  SkPdfArray* Kids() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Kids() const;
 /** (Root and leaf nodes only; required in leaf nodes; present in the root node if and only if Kids
  *  is not present) An array of the form
  *      [key1 value1 key2 value2 ... keyn valuen ]
@@ -551,13 +545,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Nums", "", NULL));
   }
 
-  SkPdfArray* Nums() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Nums", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Nums() const;
 /** (Intermediate and leaf nodes only; required) An array of two integers, specifying the
  *  (numerically) least and greatest keys included in the Nums array of a leaf node or in the
  *  Nums arrays of any leaf nodes that are descendants of an intermediate node.
@@ -566,13 +554,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", NULL));
   }
 
-  SkPdfArray* Limits() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Limits", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Limits() const;
 };
 
 #endif  // __DEFINED__SkPdfNumberTreeNodeDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfNumber_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfNumber_autogen.cpp
new file mode 100644
index 0000000..f342fff
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfNumber_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfNumber_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfObjectReferenceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfObjectReferenceDictionary_autogen.cpp
new file mode 100644
index 0000000..684aeba
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfObjectReferenceDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfObjectReferenceDictionary_autogen.h"
+
+std::string SkPdfObjectReferenceDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfObjectReferenceDictionary::Pg() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfObject* SkPdfObjectReferenceDictionary::Obj() const {
+  SkPdfObject* ret;
+  if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Obj", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfObjectReferenceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfObjectReferenceDictionary_autogen.h
index f6cff49..ea4bc36 100644
--- a/experimental/PdfViewer/autogen/SkPdfObjectReferenceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfObjectReferenceDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Optional; must be an indirect reference) The page object representing the page on
  *  which the object is rendered. This entry overrides any Pg entry in the structure ele-
  *  ment containing the object reference; it is required if the structure element has no such
@@ -548,26 +542,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", NULL));
   }
 
-  SkPdfDictionary* Pg() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Pg() const;
 /** (Required; must be an indirect reference) The referenced object.
 **/
   bool has_Obj() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Obj", "", NULL));
   }
 
-  SkPdfObject* Obj() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Obj", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfObject* Obj() const;
 };
 
 #endif  // __DEFINED__SkPdfObjectReferenceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfObject_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfObject_autogen.cpp
new file mode 100644
index 0000000..f1eb09b
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfObject_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfObject_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfOpiVersionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfOpiVersionDictionary_autogen.cpp
new file mode 100644
index 0000000..d02be22
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfOpiVersionDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfOpiVersionDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfOpiVersionDictionary::version_number() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "version_number", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfOpiVersionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfOpiVersionDictionary_autogen.h
index 7da516a..9318fab 100644
--- a/experimental/PdfViewer/autogen/SkPdfOpiVersionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfOpiVersionDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "version_number", "", NULL));
   }
 
-  SkPdfDictionary* version_number() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "version_number", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* version_number() const;
 };
 
 #endif  // __DEFINED__SkPdfOpiVersionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfOutlineDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfOutlineDictionary_autogen.cpp
new file mode 100644
index 0000000..6869d9f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfOutlineDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfOutlineDictionary_autogen.h"
+
+std::string SkPdfOutlineDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfOutlineDictionary::First() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "First", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfOutlineDictionary::Last() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Last", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfOutlineDictionary::Count() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfOutlineDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfOutlineDictionary_autogen.h
index 55a13c0..f7163a1 100644
--- a/experimental/PdfViewer/autogen/SkPdfOutlineDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfOutlineDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required; must be an indirect reference) An outline item dictionary represent-
  *  ing the first top-level item in the outline.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "First", "", NULL));
   }
 
-  SkPdfDictionary* First() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "First", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* First() const;
 /** (Required; must be an indirect reference) An outline item dictionary represent-
  *  ing the last top-level item in the outline.
 **/
@@ -560,13 +548,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Last", "", NULL));
   }
 
-  SkPdfDictionary* Last() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Last", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Last() const;
 /** (Required if the document has any open outline entries) The total number of
  *  open items at all levels of the outline. This entry should be omitted if there
  *  are no open outline items.
@@ -575,13 +557,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", NULL));
   }
 
-  long Count() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Count() const;
 };
 
 #endif  // __DEFINED__SkPdfOutlineDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfOutlineItemDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfOutlineItemDictionary_autogen.cpp
new file mode 100644
index 0000000..05f5ef8
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfOutlineItemDictionary_autogen.cpp
@@ -0,0 +1,100 @@
+#include "SkPdfOutlineItemDictionary_autogen.h"
+
+std::string SkPdfOutlineItemDictionary::Title() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Title", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfOutlineItemDictionary::Parent() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfOutlineItemDictionary::Prev() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Prev", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfOutlineItemDictionary::Next() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfOutlineItemDictionary::First() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "First", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfOutlineItemDictionary::Last() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Last", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfOutlineItemDictionary::Count() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfOutlineItemDictionary::getDestAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfOutlineItemDictionary::getDestAsString() const {
+  std::string ret = "";
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfOutlineItemDictionary::getDestAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfOutlineItemDictionary::A() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfOutlineItemDictionary::SE() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SE", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfOutlineItemDictionary::C() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfOutlineItemDictionary::F() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfOutlineItemDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfOutlineItemDictionary_autogen.h
index eb74f64..7ca070a 100644
--- a/experimental/PdfViewer/autogen/SkPdfOutlineItemDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfOutlineItemDictionary_autogen.h
@@ -531,13 +531,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Title", "", NULL));
   }
 
-  std::string Title() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Title", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Title() const;
 /** (Required; must be an indirect reference) The parent of this item in the outline
  *  hierarchy. The parent of a top-level item is the outline dictionary itself.
 **/
@@ -545,13 +539,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", NULL));
   }
 
-  SkPdfDictionary* Parent() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Parent() const;
 /** (Required for all but the first item at each level; must be an indirect reference)
  *  The previous item at this outline level.
 **/
@@ -559,13 +547,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Prev", "", NULL));
   }
 
-  SkPdfDictionary* Prev() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Prev", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Prev() const;
 /** (Required for all but the last item at each level; must be an indirect reference)
  *  The next item at this outline level.
 **/
@@ -573,13 +555,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", NULL));
   }
 
-  SkPdfDictionary* Next() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Next", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Next() const;
 /** (Required if the item has any descendants; must be an indirect reference) The
  *  first of this item's immediate children in the outline hierarchy.
 **/
@@ -587,13 +563,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "First", "", NULL));
   }
 
-  SkPdfDictionary* First() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "First", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* First() const;
 /** (Required if the item has any descendants; must be an indirect reference) The
  *  last of this item's immediate children in the outline hierarchy.
 **/
@@ -601,13 +571,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Last", "", NULL));
   }
 
-  SkPdfDictionary* Last() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Last", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Last() const;
 /** (Required if the item has any descendants) If the item is open, the total num-
  *  ber of its open descendants at all lower levels of the outline hierarchy. If the
  *  item is closed, a negative integer whose absolute value specifies how many
@@ -617,13 +581,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", NULL));
   }
 
-  long Count() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Count() const;
 /** (Optional; not permitted if an A entry is present) The destination to be
  *  displayed when this item is activated (see Section 8.2.1, "Destinations"; see
  *  also implementation note 56 in Appendix H).
@@ -638,39 +596,21 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getDestAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getDestAsName() const;
   bool isDestAString() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  std::string getDestAsString() const {
-    std::string ret = "";
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getDestAsString() const;
   bool isDestAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getDestAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dest", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getDestAsArray() const;
 /** (Optional; PDF 1.1; not permitted if a Dest entry is present) The action to be
  *  performed when this item is activated (see Section 8.5, "Actions").
 **/
@@ -678,13 +618,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", NULL));
   }
 
-  SkPdfDictionary* A() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* A() const;
 /** (Optional; PDF 1.3; must be an indirect reference) The structure element to
  *  which the item refers (see Section 9.6.1, "Structure Hierarchy").
  *  Note: The ability to associate an outline item with a structure element (such as
@@ -697,13 +631,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SE", "", NULL));
   }
 
-  SkPdfDictionary* SE() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SE", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* SE() const;
 /** (Optional; PDF 1.4) An array of three numbers in the range 0.0 to 1.0, repre-
  *  senting the components in the DeviceRGB color space of the color to be used
  *  for the outline entry's text. Default value: [0.0 0.0 0.0].
@@ -712,13 +640,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
   }
 
-  SkPdfArray* C() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* C() const;
 /** (Optional; PDF 1.4) A set of flags specifying style characteristics for display-
  *  ing the outline item's text (see Table 8.5). Default value: 0.
 **/
@@ -726,13 +648,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  long F() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long F() const;
 };
 
 #endif  // __DEFINED__SkPdfOutlineItemDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPDF_XOutputIntentDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPDF_XOutputIntentDictionary_autogen.cpp
new file mode 100644
index 0000000..1d7e095
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPDF_XOutputIntentDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfPDF_XOutputIntentDictionary_autogen.h"
+
+std::string SkPdfPDF_XOutputIntentDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfPDF_XOutputIntentDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfPDF_XOutputIntentDictionary::OutputCondition() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputCondition", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfPDF_XOutputIntentDictionary::OutputConditionIdentifier() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputConditionIdentifier", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfPDF_XOutputIntentDictionary::RegistryName() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RegistryName", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfPDF_XOutputIntentDictionary::Info() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfStream* SkPdfPDF_XOutputIntentDictionary::DestOutputProfile() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DestOutputProfile", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPDF_XOutputIntentDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPDF_XOutputIntentDictionary_autogen.h
index 8b21fcf..1d90217 100644
--- a/experimental/PdfViewer/autogen/SkPdfPDF_XOutputIntentDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPDF_XOutputIntentDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The output intent subtype; must be GTS_PDFX for a
  *  PDF/X output intent.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Optional) A text string concisely identifying the intended out-
  *  put device or production condition in human-readable form.
  *  This is the preferred method of defining such a string for pre-
@@ -562,13 +550,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputCondition", "", NULL));
   }
 
-  std::string OutputCondition() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputCondition", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string OutputCondition() const;
 /** (Required) A string identifying the intended output device or
  *  production condition in human- or machine-readable form. If
  *  human-readable, this string may be used in lieu of an Output-
@@ -588,13 +570,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputConditionIdentifier", "", NULL));
   }
 
-  std::string OutputConditionIdentifier() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OutputConditionIdentifier", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string OutputConditionIdentifier() const;
 /** (Optional) A string (conventionally a uniform resource identifi-
  *  er, or URI) identifying the registry in which the condition desig-
  *  nated by OutputConditionIdentifier is defined.
@@ -603,13 +579,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RegistryName", "", NULL));
   }
 
-  std::string RegistryName() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RegistryName", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string RegistryName() const;
 /** (Required if OutputConditionIdentifier does not specify a standard
  *  production condition; optional otherwise) A human-readable text
  *  string containing additional information or comments about
@@ -619,13 +589,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", NULL));
   }
 
-  std::string Info() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Info", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Info() const;
 /** (Required if OutputConditionIdentifier does not specify a standard
  *  production condition; optional otherwise) An ICC profile stream
  *  defining the transformation from the PDF document's source
@@ -643,13 +607,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DestOutputProfile", "", NULL));
   }
 
-  SkPdfStream* DestOutputProfile() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DestOutputProfile", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* DestOutputProfile() const;
 };
 
 #endif  // __DEFINED__SkPdfPDF_XOutputIntentDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPSXobjectDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPSXobjectDictionary_autogen.cpp
new file mode 100644
index 0000000..85b6802
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPSXobjectDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfPSXobjectDictionary_autogen.h"
+
+std::string SkPdfPSXobjectDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfPSXobjectDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfStream* SkPdfPSXobjectDictionary::Level1() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Level1", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPSXobjectDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPSXobjectDictionary_autogen.h
index a136f45..d091a0f 100644
--- a/experimental/PdfViewer/autogen/SkPdfPSXobjectDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPSXobjectDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The type of XObject that this dictionary describes; must be PS for a
  *  PostScript XObject.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Optional) A stream whose contents are to be used in place of the PostScript
  *  XObject's stream when the target PostScript interpreter is known to support only
  *  LanguageLevel 1.
@@ -561,13 +549,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Level1", "", NULL));
   }
 
-  SkPdfStream* Level1() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Level1", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* Level1() const;
 };
 
 #endif  // __DEFINED__SkPdfPSXobjectDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPageLabelDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPageLabelDictionary_autogen.cpp
new file mode 100644
index 0000000..171b2b5
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPageLabelDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfPageLabelDictionary_autogen.h"
+
+std::string SkPdfPageLabelDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfPageLabelDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfPageLabelDictionary::P() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfPageLabelDictionary::St() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "St", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPageLabelDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPageLabelDictionary_autogen.h
index dceaf55..0912661 100644
--- a/experimental/PdfViewer/autogen/SkPdfPageLabelDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPageLabelDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Optional) The numbering style to be used for the numeric portion of each page label:
  *     D     Decimal arabic numerals
  *     R     Uppercase roman numerals
@@ -554,26 +548,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Optional) The label prefix for page labels in this range.
 **/
   bool has_P() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", NULL));
   }
 
-  std::string P() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string P() const;
 /** (Optional) The value of the numeric portion for the first page label in the range. Sub-
  *  sequent pages will be numbered sequentially from this value, which must be greater than
  *  or equal to 1. Default value: 1.
@@ -582,13 +564,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "St", "", NULL));
   }
 
-  long St() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "St", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long St() const;
 };
 
 #endif  // __DEFINED__SkPdfPageLabelDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPageObjectActionsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPageObjectActionsDictionary_autogen.cpp
new file mode 100644
index 0000000..e724a83
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPageObjectActionsDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfPageObjectActionsDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfPageObjectActionsDictionary::O() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfPageObjectActionsDictionary::C() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPageObjectActionsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPageObjectActionsDictionary_autogen.h
index 9a582ce..84bb4f9 100644
--- a/experimental/PdfViewer/autogen/SkPdfPageObjectActionsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPageObjectActionsDictionary_autogen.h
@@ -535,13 +535,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", NULL));
   }
 
-  SkPdfDictionary* O() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* O() const;
 /** (Optional; PDF 1.2) An action to be performed when the page is closed (for example,
  *  when the user navigates to the next or previous page or follows a link annotation or an
  *  outline item). This action applies to the page being closed, and is executed before any
@@ -551,13 +545,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
   }
 
-  SkPdfDictionary* C() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* C() const;
 };
 
 #endif  // __DEFINED__SkPdfPageObjectActionsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPageObjectDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPageObjectDictionary_autogen.cpp
new file mode 100644
index 0000000..573fb41
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPageObjectDictionary_autogen.cpp
@@ -0,0 +1,184 @@
+#include "SkPdfPageObjectDictionary_autogen.h"
+
+std::string SkPdfPageObjectDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::Parent() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDate SkPdfPageObjectDictionary::LastModified() const {
+  SkPdfDate ret;
+  if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfDate();
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::Resources() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkRect* SkPdfPageObjectDictionary::MediaBox() const {
+  SkRect* ret;
+  if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MediaBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkRect* SkPdfPageObjectDictionary::CropBox() const {
+  SkRect* ret;
+  if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkRect* SkPdfPageObjectDictionary::BleedBox() const {
+  SkRect* ret;
+  if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkRect* SkPdfPageObjectDictionary::TrimBox() const {
+  SkRect* ret;
+  if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkRect* SkPdfPageObjectDictionary::ArtBox() const {
+  SkRect* ret;
+  if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::BoxColorInfo() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BoxColorInfo", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfPageObjectDictionary::getContentsAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfPageObjectDictionary::getContentsAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfPageObjectDictionary::Rotate() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rotate", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::Group() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Group", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfPageObjectDictionary::Thumb() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Thumb", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfPageObjectDictionary::B() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+double SkPdfPageObjectDictionary::Dur() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dur", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::Trans() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Trans", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfPageObjectDictionary::Annots() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::AA() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfPageObjectDictionary::Metadata() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::PieceInfo() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PieceInfo", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfPageObjectDictionary::StructParents() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfPageObjectDictionary::ID() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+double SkPdfPageObjectDictionary::PZ() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PZ", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfDictionary* SkPdfPageObjectDictionary::SeparationInfo() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationInfo", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPageObjectDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPageObjectDictionary_autogen.h
index 46d686e..287f8c4 100644
--- a/experimental/PdfViewer/autogen/SkPdfPageObjectDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPageObjectDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required; must be an indirect reference) The page tree node that is the im-
  *  mediate parent of this page object.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", NULL));
   }
 
-  SkPdfDictionary* Parent() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Parent() const;
 /** (Required if PieceInfo is present; optional otherwise; PDF 1.3) The date and
  *  time (see Section 3.8.2, "Dates") when the page's contents were most re-
  *  cently modified. If a page-piece dictionary (PieceInfo) is present, the
@@ -564,13 +552,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", NULL));
   }
 
-  SkPdfDate LastModified() const {
-    SkPdfDate ret;
-    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfDate();
-  }
-
+  SkPdfDate LastModified() const;
 /** (Required; inheritable) A dictionary containing any resources required by
  *  the page (see Section 3.7.2, "Resource Dictionaries"). If the page requires
  *  no resources, the value of this entry should be an empty dictionary; omit-
@@ -581,13 +563,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", NULL));
   }
 
-  SkPdfDictionary* Resources() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Resources() const;
 /** (Required; inheritable) A rectangle (see Section 3.8.3, "Rectangles"), ex-
  *  pressed in default user space units, defining the boundaries of the physical
  *  medium on which the page is intended to be displayed or printed (see
@@ -597,13 +573,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MediaBox", "", NULL));
   }
 
-  SkRect* MediaBox() const {
-    SkRect* ret;
-    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MediaBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkRect* MediaBox() const;
 /** (Optional; inheritable) A rectangle, expressed in default user space units,
  *  defining the visible region of default user space. When the page is dis-
  *  played or printed, its contents are to be clipped (cropped) to this rectangle
@@ -615,13 +585,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", NULL));
   }
 
-  SkRect* CropBox() const {
-    SkRect* ret;
-    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CropBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkRect* CropBox() const;
 /** (Optional; PDF 1.3) A rectangle, expressed in default user space units, de-
  *  fining the region to which the contents of the page should be clipped
  *  when output in a production environment (see Section 9.10.1, "Page
@@ -631,13 +595,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", NULL));
   }
 
-  SkRect* BleedBox() const {
-    SkRect* ret;
-    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BleedBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkRect* BleedBox() const;
 /** (Optional; PDF 1.3) A rectangle, expressed in default user space units, de-
  *  fining the intended dimensions of the finished page after trimming (see
  *  Section 9.10.1, "Page Boundaries"). Default value: the value of CropBox.
@@ -646,13 +604,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", NULL));
   }
 
-  SkRect* TrimBox() const {
-    SkRect* ret;
-    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrimBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkRect* TrimBox() const;
 /** (Optional; PDF 1.3) A rectangle, expressed in default user space units, de-
  *  fining the extent of the page's meaningful content (including potential
  *  white space) as intended by the page's creator (see Section 9.10.1, "Page
@@ -662,13 +614,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", NULL));
   }
 
-  SkRect* ArtBox() const {
-    SkRect* ret;
-    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ArtBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkRect* ArtBox() const;
 /** (Optional) A box color information dictionary specifying the colors and
  *  other visual characteristics to be used in displaying guidelines on the
  *  screen for the various page boundaries (see "Display of Page Boundaries"
@@ -679,13 +625,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BoxColorInfo", "", NULL));
   }
 
-  SkPdfDictionary* BoxColorInfo() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BoxColorInfo", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* BoxColorInfo() const;
 /** (Optional) A content stream (see Section 3.7.1, "Content Streams") de-
  *  scribing the contents of this page. If this entry is absent, the page is empty.
  *  The value may be either a single stream or an array of streams. If it is an
@@ -709,26 +649,14 @@
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getContentsAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getContentsAsStream() const;
   bool isContentsAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getContentsAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getContentsAsArray() const;
 /** (Optional; inheritable) The number of degrees by which the page should
  *  be rotated clockwise when displayed or printed. The value must be a mul-
  *  tiple of 90. Default value: 0.
@@ -737,13 +665,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rotate", "", NULL));
   }
 
-  long Rotate() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Rotate", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Rotate() const;
 /** (Optional; PDF 1.4) A group attributes dictionary specifying the attributes
  *  of the page's page group for use in the transparent imaging model (see
  *  Sections 7.3.6, "Page Group," and 7.5.5, "Transparency Group XObjects").
@@ -752,13 +674,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Group", "", NULL));
   }
 
-  SkPdfDictionary* Group() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Group", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Group() const;
 /** (Optional) A stream object defining the page's thumbnail image (see Sec-
  *  tion 8.2.3, "Thumbnail Images").
 **/
@@ -766,13 +682,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Thumb", "", NULL));
   }
 
-  SkPdfStream* Thumb() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Thumb", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* Thumb() const;
 /** (Optional; PDF 1.1; recommended if the page contains article beads) An ar-
  *  ray of indirect references to article beads appearing on the page (see Sec-
  *  tion 8.3.2, "Articles"; see also implementation note 23 in Appendix H).
@@ -782,13 +692,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", NULL));
   }
 
-  SkPdfArray* B() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* B() const;
 /** (Optional; PDF 1.1) The page's display duration (also called its advance
  *  timing): the maximum length of time, in seconds, that the page will be
  *  displayed during presentations before the viewer application automati-
@@ -799,13 +703,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dur", "", NULL));
   }
 
-  double Dur() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dur", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double Dur() const;
 /** (Optional; PDF 1.1) A transition dictionary describing the transition effect
  *  to be used when displaying the page during presentations (see Section
  *  8.3.3, "Presentations").
@@ -814,13 +712,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Trans", "", NULL));
   }
 
-  SkPdfDictionary* Trans() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Trans", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Trans() const;
 /** (Optional) An array of annotation dictionaries representing annotations
  *  associated with the page (see Section 8.4, "Annotations").
 **/
@@ -828,13 +720,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", NULL));
   }
 
-  SkPdfArray* Annots() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Annots", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Annots() const;
 /** (Optional; PDF 1.2) An additional-actions dictionary defining actions to
  *  be performed when the page is opened or closed (see Section 8.5.2, "Trig-
  *  ger Events"; see also implementation note 24 in Appendix H).
@@ -843,13 +729,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", NULL));
   }
 
-  SkPdfDictionary* AA() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AA", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* AA() const;
 /** (Optional; PDF 1.4) A metadata stream containing metadata for the page
  *  (see Section 9.2.2, "Metadata Streams").
 **/
@@ -857,13 +737,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", NULL));
   }
 
-  SkPdfStream* Metadata() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* Metadata() const;
 /** (Optional; PDF 1.3) A page-piece dictionary associated with the page (see
  *  Section 9.4, "Page-Piece Dictionaries").
 **/
@@ -871,13 +745,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PieceInfo", "", NULL));
   }
 
-  SkPdfDictionary* PieceInfo() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PieceInfo", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* PieceInfo() const;
 /** (Required if the page contains structural content items; PDF 1.3) The inte-
  *  ger key of the page's entry in the structural parent tree (see "Finding Struc-
  *  ture Elements from Content Items" on page 600).
@@ -886,13 +754,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", NULL));
   }
 
-  long StructParents() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long StructParents() const;
 /** (Optional; PDF 1.3; indirect reference preferred) The digital identifier of the
  *  page's parent Web Capture content set (see Section 9.9.5, "Object At-
  *  tributes Related to Web Capture").
@@ -901,13 +763,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
   }
 
-  std::string ID() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string ID() const;
 /** (Optional; PDF 1.3) The page's preferred zoom (magnification) factor: the
  *  factor by which it should be scaled to achieve the "natural" display magni-
  *  fication (see Section 9.9.5, "Object Attributes Related to Web Capture").
@@ -916,13 +772,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PZ", "", NULL));
   }
 
-  double PZ() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PZ", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double PZ() const;
 /** (Optional; PDF 1.3) A separation dictionary containing information need-
  *  ed to generate color separations for the page (see Section 9.10.3, "Separa-
  *  tion Dictionaries").
@@ -931,13 +781,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationInfo", "", NULL));
   }
 
-  SkPdfDictionary* SeparationInfo() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationInfo", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* SeparationInfo() const;
 };
 
 #endif  // __DEFINED__SkPdfPageObjectDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPagePieceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPagePieceDictionary_autogen.cpp
new file mode 100644
index 0000000..1252e48
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPagePieceDictionary_autogen.cpp
@@ -0,0 +1,11 @@
+#include "SkPdfPagePieceDictionary_autogen.h"
+
+/*
+SkPdfDictionary* SkPdfPagePieceDictionary::[any_application_name_or_well_known_data_type]() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_application_name_or_well_known_data_type]", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+*/
diff --git a/experimental/PdfViewer/autogen/SkPdfPagePieceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPagePieceDictionary_autogen.h
index 9ffd819..2e6b812 100644
--- a/experimental/PdfViewer/autogen/SkPdfPagePieceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPagePieceDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_application_name_or_well_known_data_type]", "", NULL));
   }
 
-  SkPdfDictionary* [any_application_name_or_well_known_data_type]() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_application_name_or_well_known_data_type]", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* [any_application_name_or_well_known_data_type]() const;
 */
 };
 
diff --git a/experimental/PdfViewer/autogen/SkPdfPageTreeNodeDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPageTreeNodeDictionary_autogen.cpp
new file mode 100644
index 0000000..6103597
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPageTreeNodeDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfPageTreeNodeDictionary_autogen.h"
+
+std::string SkPdfPageTreeNodeDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfPageTreeNodeDictionary::Parent() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfPageTreeNodeDictionary::Kids() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfPageTreeNodeDictionary::Count() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPageTreeNodeDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPageTreeNodeDictionary_autogen.h
index b1d6d7c..8d370eb 100644
--- a/experimental/PdfViewer/autogen/SkPdfPageTreeNodeDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPageTreeNodeDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required except in root node; must be an indirect reference) The page tree node that
  *  is the immediate parent of this one.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", NULL));
   }
 
-  SkPdfDictionary* Parent() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Parent() const;
 /** (Required) An array of indirect references to the immediate children of this node.
  *  The children may be page objects or other page tree nodes.
 **/
@@ -560,13 +548,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", NULL));
   }
 
-  SkPdfArray* Kids() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Kids", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Kids() const;
 /** (Required) The number of leaf nodes (page objects) that are descendants of this
  *  node within the page tree.
 **/
@@ -574,13 +556,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", NULL));
   }
 
-  long Count() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Count", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Count() const;
 };
 
 #endif  // __DEFINED__SkPdfPageTreeNodeDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.cpp
new file mode 100644
index 0000000..5d2df72
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.cpp
@@ -0,0 +1,5402 @@
+#include "SkPdfPodofoMapper_autogen.h"
+bool mapObject(const SkPdfObject& in, SkPdfObject** out) {
+  return mapObject(*in.doc(), *in.podofo(), out);
+}
+
+bool mapObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out) {
+  if (!isObject(podofoDoc, podofoObj)) return false;
+
+  if (mapArray(podofoDoc, podofoObj, (SkPdfArray**)out)) return true;
+  if (mapBoolean(podofoDoc, podofoObj, (SkPdfBoolean**)out)) return true;
+  if (mapDictionary(podofoDoc, podofoObj, (SkPdfDictionary**)out)) return true;
+  if (mapInteger(podofoDoc, podofoObj, (SkPdfInteger**)out)) return true;
+  if (mapName(podofoDoc, podofoObj, (SkPdfName**)out)) return true;
+  if (mapNull(podofoDoc, podofoObj, (SkPdfNull**)out)) return true;
+  if (mapReference(podofoDoc, podofoObj, (SkPdfReference**)out)) return true;
+  if (mapString(podofoDoc, podofoObj, (SkPdfString**)out)) return true;
+  if (mapStream(podofoDoc, podofoObj, (SkPdfStream**)out)) return true;
+
+  *out = new SkPdfObject(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapNull(const SkPdfObject& in, SkPdfNull** out) {
+  return mapNull(*in.doc(), *in.podofo(), out);
+}
+
+bool mapNull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNull** out) {
+  if (!isNull(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfNull(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapBoolean(const SkPdfObject& in, SkPdfBoolean** out) {
+  return mapBoolean(*in.doc(), *in.podofo(), out);
+}
+
+bool mapBoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoolean** out) {
+  if (!isBoolean(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfBoolean(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapInteger(const SkPdfObject& in, SkPdfInteger** out) {
+  return mapInteger(*in.doc(), *in.podofo(), out);
+}
+
+bool mapInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInteger** out) {
+  if (!isInteger(podofoDoc, podofoObj)) return false;
+
+  if (mapNumber(podofoDoc, podofoObj, (SkPdfNumber**)out)) return true;
+
+  *out = new SkPdfInteger(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapNumber(const SkPdfObject& in, SkPdfNumber** out) {
+  return mapNumber(*in.doc(), *in.podofo(), out);
+}
+
+bool mapNumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNumber** out) {
+  if (!isNumber(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfNumber(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapName(const SkPdfObject& in, SkPdfName** out) {
+  return mapName(*in.doc(), *in.podofo(), out);
+}
+
+bool mapName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfName** out) {
+  if (!isName(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfName(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapReference(const SkPdfObject& in, SkPdfReference** out) {
+  return mapReference(*in.doc(), *in.podofo(), out);
+}
+
+bool mapReference(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfReference** out) {
+  if (!isReference(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfReference(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapArray(const SkPdfObject& in, SkPdfArray** out) {
+  return mapArray(*in.doc(), *in.podofo(), out);
+}
+
+bool mapArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfArray** out) {
+  if (!isArray(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfArray(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapString(const SkPdfObject& in, SkPdfString** out) {
+  return mapString(*in.doc(), *in.podofo(), out);
+}
+
+bool mapString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfString** out) {
+  if (!isString(podofoDoc, podofoObj)) return false;
+
+  if (mapHexString(podofoDoc, podofoObj, (SkPdfHexString**)out)) return true;
+
+  *out = new SkPdfString(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapHexString(const SkPdfObject& in, SkPdfHexString** out) {
+  return mapHexString(*in.doc(), *in.podofo(), out);
+}
+
+bool mapHexString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfHexString** out) {
+  if (!isHexString(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfHexString(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapDictionary(const SkPdfObject& in, SkPdfDictionary** out) {
+  return mapDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDictionary** out) {
+  if (!isDictionary(podofoDoc, podofoObj)) return false;
+
+  if (mapALinkAnnotationDictionary(podofoDoc, podofoObj, (SkPdfALinkAnnotationDictionary**)out)) return true;
+  if (mapActionDictionary(podofoDoc, podofoObj, (SkPdfActionDictionary**)out)) return true;
+  if (mapAlternateImageDictionary(podofoDoc, podofoObj, (SkPdfAlternateImageDictionary**)out)) return true;
+  if (mapAnnotationActionsDictionary(podofoDoc, podofoObj, (SkPdfAnnotationActionsDictionary**)out)) return true;
+  if (mapAnnotationDictionary(podofoDoc, podofoObj, (SkPdfAnnotationDictionary**)out)) return true;
+  if (mapAppearanceCharacteristicsDictionary(podofoDoc, podofoObj, (SkPdfAppearanceCharacteristicsDictionary**)out)) return true;
+  if (mapAppearanceDictionary(podofoDoc, podofoObj, (SkPdfAppearanceDictionary**)out)) return true;
+  if (mapApplicationDataDictionary(podofoDoc, podofoObj, (SkPdfApplicationDataDictionary**)out)) return true;
+  if (mapArtifactsDictionary(podofoDoc, podofoObj, (SkPdfArtifactsDictionary**)out)) return true;
+  if (mapAttributeObjectDictionary(podofoDoc, podofoObj, (SkPdfAttributeObjectDictionary**)out)) return true;
+  if (mapBeadDictionary(podofoDoc, podofoObj, (SkPdfBeadDictionary**)out)) return true;
+  if (mapBlockLevelStructureElementsDictionary(podofoDoc, podofoObj, (SkPdfBlockLevelStructureElementsDictionary**)out)) return true;
+  if (mapBorderStyleDictionary(podofoDoc, podofoObj, (SkPdfBorderStyleDictionary**)out)) return true;
+  if (mapBoxColorInformationDictionary(podofoDoc, podofoObj, (SkPdfBoxColorInformationDictionary**)out)) return true;
+  if (mapBoxStyleDictionary(podofoDoc, podofoObj, (SkPdfBoxStyleDictionary**)out)) return true;
+  if (mapCIDFontDescriptorDictionary(podofoDoc, podofoObj, (SkPdfCIDFontDescriptorDictionary**)out)) return true;
+  if (mapCIDSystemInfoDictionary(podofoDoc, podofoObj, (SkPdfCIDSystemInfoDictionary**)out)) return true;
+  if (mapCMapDictionary(podofoDoc, podofoObj, (SkPdfCMapDictionary**)out)) return true;
+  if (mapCalgrayColorSpaceDictionary(podofoDoc, podofoObj, (SkPdfCalgrayColorSpaceDictionary**)out)) return true;
+  if (mapCalrgbColorSpaceDictionary(podofoDoc, podofoObj, (SkPdfCalrgbColorSpaceDictionary**)out)) return true;
+  if (mapCatalogDictionary(podofoDoc, podofoObj, (SkPdfCatalogDictionary**)out)) return true;
+  if (mapCcittfaxdecodeFilterDictionary(podofoDoc, podofoObj, (SkPdfCcittfaxdecodeFilterDictionary**)out)) return true;
+  if (mapCheckboxFieldDictionary(podofoDoc, podofoObj, (SkPdfCheckboxFieldDictionary**)out)) return true;
+  if (mapChoiceFieldDictionary(podofoDoc, podofoObj, (SkPdfChoiceFieldDictionary**)out)) return true;
+  if (mapComponentsWithMetadataDictionary(podofoDoc, podofoObj, (SkPdfComponentsWithMetadataDictionary**)out)) return true;
+  if (mapDctdecodeFilterDictionary(podofoDoc, podofoObj, (SkPdfDctdecodeFilterDictionary**)out)) return true;
+  if (mapDeviceNColorSpaceDictionary(podofoDoc, podofoObj, (SkPdfDeviceNColorSpaceDictionary**)out)) return true;
+  if (mapDocumentCatalogActionsDictionary(podofoDoc, podofoObj, (SkPdfDocumentCatalogActionsDictionary**)out)) return true;
+  if (mapDocumentInformationDictionary(podofoDoc, podofoObj, (SkPdfDocumentInformationDictionary**)out)) return true;
+  if (mapEmbeddedFileParameterDictionary(podofoDoc, podofoObj, (SkPdfEmbeddedFileParameterDictionary**)out)) return true;
+  if (mapEmbeddedFileStreamDictionary(podofoDoc, podofoObj, (SkPdfEmbeddedFileStreamDictionary**)out)) return true;
+  if (mapEmbeddedFontStreamDictionary(podofoDoc, podofoObj, (SkPdfEmbeddedFontStreamDictionary**)out)) return true;
+  if (mapEncodingDictionary(podofoDoc, podofoObj, (SkPdfEncodingDictionary**)out)) return true;
+  if (mapEncryptedEmbeddedFileStreamDictionary(podofoDoc, podofoObj, (SkPdfEncryptedEmbeddedFileStreamDictionary**)out)) return true;
+  if (mapEncryptionCommonDictionary(podofoDoc, podofoObj, (SkPdfEncryptionCommonDictionary**)out)) return true;
+  if (mapFDFCatalogDictionary(podofoDoc, podofoObj, (SkPdfFDFCatalogDictionary**)out)) return true;
+  if (mapFDFDictionary(podofoDoc, podofoObj, (SkPdfFDFDictionary**)out)) return true;
+  if (mapFDFFieldDictionary(podofoDoc, podofoObj, (SkPdfFDFFieldDictionary**)out)) return true;
+  if (mapFDFFileAnnotationDictionary(podofoDoc, podofoObj, (SkPdfFDFFileAnnotationDictionary**)out)) return true;
+  if (mapFDFNamedPageReferenceDictionary(podofoDoc, podofoObj, (SkPdfFDFNamedPageReferenceDictionary**)out)) return true;
+  if (mapFDFPageDictionary(podofoDoc, podofoObj, (SkPdfFDFPageDictionary**)out)) return true;
+  if (mapFDFTemplateDictionary(podofoDoc, podofoObj, (SkPdfFDFTemplateDictionary**)out)) return true;
+  if (mapFDFTrailerDictionary(podofoDoc, podofoObj, (SkPdfFDFTrailerDictionary**)out)) return true;
+  if (mapFieldDictionary(podofoDoc, podofoObj, (SkPdfFieldDictionary**)out)) return true;
+  if (mapFileAttachmentAnnotationDictionary(podofoDoc, podofoObj, (SkPdfFileAttachmentAnnotationDictionary**)out)) return true;
+  if (mapFileSpecificationDictionary(podofoDoc, podofoObj, (SkPdfFileSpecificationDictionary**)out)) return true;
+  if (mapFileTrailerDictionary(podofoDoc, podofoObj, (SkPdfFileTrailerDictionary**)out)) return true;
+  if (mapFontDescriptorDictionary(podofoDoc, podofoObj, (SkPdfFontDescriptorDictionary**)out)) return true;
+  if (mapFontDictionary(podofoDoc, podofoObj, (SkPdfFontDictionary**)out)) return true;
+  if (mapFormFieldActionsDictionary(podofoDoc, podofoObj, (SkPdfFormFieldActionsDictionary**)out)) return true;
+  if (mapFreeTextAnnotationDictionary(podofoDoc, podofoObj, (SkPdfFreeTextAnnotationDictionary**)out)) return true;
+  if (mapFunctionCommonDictionary(podofoDoc, podofoObj, (SkPdfFunctionCommonDictionary**)out)) return true;
+  if (mapGoToActionDictionary(podofoDoc, podofoObj, (SkPdfGoToActionDictionary**)out)) return true;
+  if (mapGraphicsStateDictionary(podofoDoc, podofoObj, (SkPdfGraphicsStateDictionary**)out)) return true;
+  if (mapGroupAttributesDictionary(podofoDoc, podofoObj, (SkPdfGroupAttributesDictionary**)out)) return true;
+  if (mapHideActionDictionary(podofoDoc, podofoObj, (SkPdfHideActionDictionary**)out)) return true;
+  if (mapIccProfileStreamDictionary(podofoDoc, podofoObj, (SkPdfIccProfileStreamDictionary**)out)) return true;
+  if (mapIconFitDictionary(podofoDoc, podofoObj, (SkPdfIconFitDictionary**)out)) return true;
+  if (mapImportDataActionDictionary(podofoDoc, podofoObj, (SkPdfImportDataActionDictionary**)out)) return true;
+  if (mapInkAnnotationDictionary(podofoDoc, podofoObj, (SkPdfInkAnnotationDictionary**)out)) return true;
+  if (mapInlineLevelStructureElementsDictionary(podofoDoc, podofoObj, (SkPdfInlineLevelStructureElementsDictionary**)out)) return true;
+  if (mapInteractiveFormDictionary(podofoDoc, podofoObj, (SkPdfInteractiveFormDictionary**)out)) return true;
+  if (mapJavascriptActionDictionary(podofoDoc, podofoObj, (SkPdfJavascriptActionDictionary**)out)) return true;
+  if (mapJavascriptDictionary(podofoDoc, podofoObj, (SkPdfJavascriptDictionary**)out)) return true;
+  if (mapJbig2DecodeFilterDictionary(podofoDoc, podofoObj, (SkPdfJbig2DecodeFilterDictionary**)out)) return true;
+  if (mapLabColorSpaceDictionary(podofoDoc, podofoObj, (SkPdfLabColorSpaceDictionary**)out)) return true;
+  if (mapLaunchActionDictionary(podofoDoc, podofoObj, (SkPdfLaunchActionDictionary**)out)) return true;
+  if (mapLineAnnotationDictionary(podofoDoc, podofoObj, (SkPdfLineAnnotationDictionary**)out)) return true;
+  if (mapListAttributeDictionary(podofoDoc, podofoObj, (SkPdfListAttributeDictionary**)out)) return true;
+  if (mapLzwdecodeAndFlatedecodeFiltersDictionary(podofoDoc, podofoObj, (SkPdfLzwdecodeAndFlatedecodeFiltersDictionary**)out)) return true;
+  if (mapMacOsFileInformationDictionary(podofoDoc, podofoObj, (SkPdfMacOsFileInformationDictionary**)out)) return true;
+  if (mapMarkInformationDictionary(podofoDoc, podofoObj, (SkPdfMarkInformationDictionary**)out)) return true;
+  if (mapMarkedContentReferenceDictionary(podofoDoc, podofoObj, (SkPdfMarkedContentReferenceDictionary**)out)) return true;
+  if (mapMarkupAnnotationsDictionary(podofoDoc, podofoObj, (SkPdfMarkupAnnotationsDictionary**)out)) return true;
+  if (mapMetadataStreamDictionary(podofoDoc, podofoObj, (SkPdfMetadataStreamDictionary**)out)) return true;
+  if (mapMovieActionDictionary(podofoDoc, podofoObj, (SkPdfMovieActionDictionary**)out)) return true;
+  if (mapMovieActivationDictionary(podofoDoc, podofoObj, (SkPdfMovieActivationDictionary**)out)) return true;
+  if (mapMovieAnnotationDictionary(podofoDoc, podofoObj, (SkPdfMovieAnnotationDictionary**)out)) return true;
+  if (mapMovieDictionary(podofoDoc, podofoObj, (SkPdfMovieDictionary**)out)) return true;
+  if (mapNameDictionary(podofoDoc, podofoObj, (SkPdfNameDictionary**)out)) return true;
+  if (mapNameTreeNodeDictionary(podofoDoc, podofoObj, (SkPdfNameTreeNodeDictionary**)out)) return true;
+  if (mapNamedActionsDictionary(podofoDoc, podofoObj, (SkPdfNamedActionsDictionary**)out)) return true;
+  if (mapNumberTreeNodeDictionary(podofoDoc, podofoObj, (SkPdfNumberTreeNodeDictionary**)out)) return true;
+  if (mapObjectReferenceDictionary(podofoDoc, podofoObj, (SkPdfObjectReferenceDictionary**)out)) return true;
+  if (mapOpiVersionDictionary(podofoDoc, podofoObj, (SkPdfOpiVersionDictionary**)out)) return true;
+  if (mapOutlineDictionary(podofoDoc, podofoObj, (SkPdfOutlineDictionary**)out)) return true;
+  if (mapOutlineItemDictionary(podofoDoc, podofoObj, (SkPdfOutlineItemDictionary**)out)) return true;
+  if (mapPDF_XOutputIntentDictionary(podofoDoc, podofoObj, (SkPdfPDF_XOutputIntentDictionary**)out)) return true;
+  if (mapPSXobjectDictionary(podofoDoc, podofoObj, (SkPdfPSXobjectDictionary**)out)) return true;
+  if (mapPageLabelDictionary(podofoDoc, podofoObj, (SkPdfPageLabelDictionary**)out)) return true;
+  if (mapPageObjectActionsDictionary(podofoDoc, podofoObj, (SkPdfPageObjectActionsDictionary**)out)) return true;
+  if (mapPageObjectDictionary(podofoDoc, podofoObj, (SkPdfPageObjectDictionary**)out)) return true;
+  if (mapPagePieceDictionary(podofoDoc, podofoObj, (SkPdfPagePieceDictionary**)out)) return true;
+  if (mapPageTreeNodeDictionary(podofoDoc, podofoObj, (SkPdfPageTreeNodeDictionary**)out)) return true;
+  if (mapPopUpAnnotationDictionary(podofoDoc, podofoObj, (SkPdfPopUpAnnotationDictionary**)out)) return true;
+  if (mapPrinterMarkAnnotationDictionary(podofoDoc, podofoObj, (SkPdfPrinterMarkAnnotationDictionary**)out)) return true;
+  if (mapPrinterMarkFormDictionary(podofoDoc, podofoObj, (SkPdfPrinterMarkFormDictionary**)out)) return true;
+  if (mapRadioButtonFieldDictionary(podofoDoc, podofoObj, (SkPdfRadioButtonFieldDictionary**)out)) return true;
+  if (mapReferenceDictionary(podofoDoc, podofoObj, (SkPdfReferenceDictionary**)out)) return true;
+  if (mapRemoteGoToActionDictionary(podofoDoc, podofoObj, (SkPdfRemoteGoToActionDictionary**)out)) return true;
+  if (mapResetFormActionDictionary(podofoDoc, podofoObj, (SkPdfResetFormActionDictionary**)out)) return true;
+  if (mapResourceDictionary(podofoDoc, podofoObj, (SkPdfResourceDictionary**)out)) return true;
+  if (mapRubberStampAnnotationDictionary(podofoDoc, podofoObj, (SkPdfRubberStampAnnotationDictionary**)out)) return true;
+  if (mapSeparationDictionary(podofoDoc, podofoObj, (SkPdfSeparationDictionary**)out)) return true;
+  if (mapShadingDictionary(podofoDoc, podofoObj, (SkPdfShadingDictionary**)out)) return true;
+  if (mapSignatureDictionary(podofoDoc, podofoObj, (SkPdfSignatureDictionary**)out)) return true;
+  if (mapSoftMaskDictionary(podofoDoc, podofoObj, (SkPdfSoftMaskDictionary**)out)) return true;
+  if (mapSoftMaskImageDictionary(podofoDoc, podofoObj, (SkPdfSoftMaskImageDictionary**)out)) return true;
+  if (mapSoundActionDictionary(podofoDoc, podofoObj, (SkPdfSoundActionDictionary**)out)) return true;
+  if (mapSoundAnnotationDictionary(podofoDoc, podofoObj, (SkPdfSoundAnnotationDictionary**)out)) return true;
+  if (mapSoundObjectDictionary(podofoDoc, podofoObj, (SkPdfSoundObjectDictionary**)out)) return true;
+  if (mapSourceInformationDictionary(podofoDoc, podofoObj, (SkPdfSourceInformationDictionary**)out)) return true;
+  if (mapSquareOrCircleAnnotation(podofoDoc, podofoObj, (SkPdfSquareOrCircleAnnotation**)out)) return true;
+  if (mapStandardSecurityHandlerDictionary(podofoDoc, podofoObj, (SkPdfStandardSecurityHandlerDictionary**)out)) return true;
+  if (mapStandardStructureDictionary(podofoDoc, podofoObj, (SkPdfStandardStructureDictionary**)out)) return true;
+  if (mapStreamCommonDictionary(podofoDoc, podofoObj, (SkPdfStreamCommonDictionary**)out)) return true;
+  if (mapStructureElementAccessDictionary(podofoDoc, podofoObj, (SkPdfStructureElementAccessDictionary**)out)) return true;
+  if (mapStructureElementDictionary(podofoDoc, podofoObj, (SkPdfStructureElementDictionary**)out)) return true;
+  if (mapStructureTreeRootDictionary(podofoDoc, podofoObj, (SkPdfStructureTreeRootDictionary**)out)) return true;
+  if (mapSubmitFormActionDictionary(podofoDoc, podofoObj, (SkPdfSubmitFormActionDictionary**)out)) return true;
+  if (mapTableAttributesDictionary(podofoDoc, podofoObj, (SkPdfTableAttributesDictionary**)out)) return true;
+  if (mapTextAnnotationDictionary(podofoDoc, podofoObj, (SkPdfTextAnnotationDictionary**)out)) return true;
+  if (mapTextFieldDictionary(podofoDoc, podofoObj, (SkPdfTextFieldDictionary**)out)) return true;
+  if (mapThreadActionDictionary(podofoDoc, podofoObj, (SkPdfThreadActionDictionary**)out)) return true;
+  if (mapThreadDictionary(podofoDoc, podofoObj, (SkPdfThreadDictionary**)out)) return true;
+  if (mapTransitionDictionary(podofoDoc, podofoObj, (SkPdfTransitionDictionary**)out)) return true;
+  if (mapTransparencyGroupDictionary(podofoDoc, podofoObj, (SkPdfTransparencyGroupDictionary**)out)) return true;
+  if (mapTrapNetworkAnnotationDictionary(podofoDoc, podofoObj, (SkPdfTrapNetworkAnnotationDictionary**)out)) return true;
+  if (mapTrapNetworkAppearanceStreamDictionary(podofoDoc, podofoObj, (SkPdfTrapNetworkAppearanceStreamDictionary**)out)) return true;
+  if (mapType0FunctionDictionary(podofoDoc, podofoObj, (SkPdfType0FunctionDictionary**)out)) return true;
+  if (mapType10HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType10HalftoneDictionary**)out)) return true;
+  if (mapType16HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType16HalftoneDictionary**)out)) return true;
+  if (mapType1HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType1HalftoneDictionary**)out)) return true;
+  if (mapType1PatternDictionary(podofoDoc, podofoObj, (SkPdfType1PatternDictionary**)out)) return true;
+  if (mapType2FunctionDictionary(podofoDoc, podofoObj, (SkPdfType2FunctionDictionary**)out)) return true;
+  if (mapType2PatternDictionary(podofoDoc, podofoObj, (SkPdfType2PatternDictionary**)out)) return true;
+  if (mapType3FunctionDictionary(podofoDoc, podofoObj, (SkPdfType3FunctionDictionary**)out)) return true;
+  if (mapType5HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType5HalftoneDictionary**)out)) return true;
+  if (mapType6HalftoneDictionary(podofoDoc, podofoObj, (SkPdfType6HalftoneDictionary**)out)) return true;
+  if (mapURIActionDictionary(podofoDoc, podofoObj, (SkPdfURIActionDictionary**)out)) return true;
+  if (mapURIDictionary(podofoDoc, podofoObj, (SkPdfURIDictionary**)out)) return true;
+  if (mapURLAliasDictionary(podofoDoc, podofoObj, (SkPdfURLAliasDictionary**)out)) return true;
+  if (mapVariableTextFieldDictionary(podofoDoc, podofoObj, (SkPdfVariableTextFieldDictionary**)out)) return true;
+  if (mapViewerPreferencesDictionary(podofoDoc, podofoObj, (SkPdfViewerPreferencesDictionary**)out)) return true;
+  if (mapWebCaptureCommandDictionary(podofoDoc, podofoObj, (SkPdfWebCaptureCommandDictionary**)out)) return true;
+  if (mapWebCaptureCommandSettingsDictionary(podofoDoc, podofoObj, (SkPdfWebCaptureCommandSettingsDictionary**)out)) return true;
+  if (mapWebCaptureDictionary(podofoDoc, podofoObj, (SkPdfWebCaptureDictionary**)out)) return true;
+  if (mapWebCaptureImageSetDictionary(podofoDoc, podofoObj, (SkPdfWebCaptureImageSetDictionary**)out)) return true;
+  if (mapWebCaptureInformationDictionary(podofoDoc, podofoObj, (SkPdfWebCaptureInformationDictionary**)out)) return true;
+  if (mapWebCapturePageSetDictionary(podofoDoc, podofoObj, (SkPdfWebCapturePageSetDictionary**)out)) return true;
+  if (mapWidgetAnnotationDictionary(podofoDoc, podofoObj, (SkPdfWidgetAnnotationDictionary**)out)) return true;
+  if (mapWindowsLaunchActionDictionary(podofoDoc, podofoObj, (SkPdfWindowsLaunchActionDictionary**)out)) return true;
+  if (mapXObjectDictionary(podofoDoc, podofoObj, (SkPdfXObjectDictionary**)out)) return true;
+
+  *out = new SkPdfDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapStream(const SkPdfObject& in, SkPdfStream** out) {
+  return mapStream(*in.doc(), *in.podofo(), out);
+}
+
+bool mapStream(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStream** out) {
+  if (!isStream(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfStream(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapXObjectDictionary(const SkPdfObject& in, SkPdfXObjectDictionary** out) {
+  return mapXObjectDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfXObjectDictionary** out) {
+  if (!isXObjectDictionary(podofoDoc, podofoObj)) return false;
+
+  if (mapImageDictionary(podofoDoc, podofoObj, (SkPdfImageDictionary**)out)) return true;
+  if (mapType1FormDictionary(podofoDoc, podofoObj, (SkPdfType1FormDictionary**)out)) return true;
+
+  *out = new SkPdfXObjectDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFontDictionary(const SkPdfObject& in, SkPdfFontDictionary** out) {
+  return mapFontDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFontDictionary** out) {
+  if (!isFontDictionary(podofoDoc, podofoObj)) return false;
+
+  if (mapCIDFontDictionary(podofoDoc, podofoObj, (SkPdfCIDFontDictionary**)out)) return true;
+  if (mapType0FontDictionary(podofoDoc, podofoObj, (SkPdfType0FontDictionary**)out)) return true;
+  if (mapType1FontDictionary(podofoDoc, podofoObj, (SkPdfType1FontDictionary**)out)) return true;
+
+  *out = new SkPdfFontDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapTrueTypeFontDictionary(const SkPdfObject& in, SkPdfTrueTypeFontDictionary** out) {
+  return mapTrueTypeFontDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrueTypeFontDictionary** out) {
+  if (!isTrueTypeFontDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfTrueTypeFontDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapStreamCommonDictionary(const SkPdfObject& in, SkPdfStreamCommonDictionary** out) {
+  return mapStreamCommonDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapStreamCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStreamCommonDictionary** out) {
+  if (!isStreamCommonDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfStreamCommonDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapLzwdecodeAndFlatedecodeFiltersDictionary(const SkPdfObject& in, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** out) {
+  return mapLzwdecodeAndFlatedecodeFiltersDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapLzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** out) {
+  if (!isLzwdecodeAndFlatedecodeFiltersDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfLzwdecodeAndFlatedecodeFiltersDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapCcittfaxdecodeFilterDictionary(const SkPdfObject& in, SkPdfCcittfaxdecodeFilterDictionary** out) {
+  return mapCcittfaxdecodeFilterDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCcittfaxdecodeFilterDictionary** out) {
+  if (!isCcittfaxdecodeFilterDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfCcittfaxdecodeFilterDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapJbig2DecodeFilterDictionary(const SkPdfObject& in, SkPdfJbig2DecodeFilterDictionary** out) {
+  return mapJbig2DecodeFilterDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJbig2DecodeFilterDictionary** out) {
+  if (!isJbig2DecodeFilterDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfJbig2DecodeFilterDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapDctdecodeFilterDictionary(const SkPdfObject& in, SkPdfDctdecodeFilterDictionary** out) {
+  return mapDctdecodeFilterDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapDctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDctdecodeFilterDictionary** out) {
+  if (!isDctdecodeFilterDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfDctdecodeFilterDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFileTrailerDictionary(const SkPdfObject& in, SkPdfFileTrailerDictionary** out) {
+  return mapFileTrailerDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFileTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileTrailerDictionary** out) {
+  if (!isFileTrailerDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFileTrailerDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapEncryptionCommonDictionary(const SkPdfObject& in, SkPdfEncryptionCommonDictionary** out) {
+  return mapEncryptionCommonDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncryptionCommonDictionary** out) {
+  if (!isEncryptionCommonDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfEncryptionCommonDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapStandardSecurityHandlerDictionary(const SkPdfObject& in, SkPdfStandardSecurityHandlerDictionary** out) {
+  return mapStandardSecurityHandlerDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardSecurityHandlerDictionary** out) {
+  if (!isStandardSecurityHandlerDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfStandardSecurityHandlerDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapCatalogDictionary(const SkPdfObject& in, SkPdfCatalogDictionary** out) {
+  return mapCatalogDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCatalogDictionary** out) {
+  if (!isCatalogDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfCatalogDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapPageTreeNodeDictionary(const SkPdfObject& in, SkPdfPageTreeNodeDictionary** out) {
+  return mapPageTreeNodeDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageTreeNodeDictionary** out) {
+  if (!isPageTreeNodeDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfPageTreeNodeDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapPageObjectDictionary(const SkPdfObject& in, SkPdfPageObjectDictionary** out) {
+  return mapPageObjectDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageObjectDictionary** out) {
+  if (!isPageObjectDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfPageObjectDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapNameDictionary(const SkPdfObject& in, SkPdfNameDictionary** out) {
+  return mapNameDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapNameDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameDictionary** out) {
+  if (!isNameDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfNameDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapResourceDictionary(const SkPdfObject& in, SkPdfResourceDictionary** out) {
+  return mapResourceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfResourceDictionary** out) {
+  if (!isResourceDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfResourceDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapNameTreeNodeDictionary(const SkPdfObject& in, SkPdfNameTreeNodeDictionary** out) {
+  return mapNameTreeNodeDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapNameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameTreeNodeDictionary** out) {
+  if (!isNameTreeNodeDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfNameTreeNodeDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapNumberTreeNodeDictionary(const SkPdfObject& in, SkPdfNumberTreeNodeDictionary** out) {
+  return mapNumberTreeNodeDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapNumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNumberTreeNodeDictionary** out) {
+  if (!isNumberTreeNodeDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfNumberTreeNodeDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFunctionCommonDictionary(const SkPdfObject& in, SkPdfFunctionCommonDictionary** out) {
+  return mapFunctionCommonDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFunctionCommonDictionary** out) {
+  if (!isFunctionCommonDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFunctionCommonDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType0FunctionDictionary(const SkPdfObject& in, SkPdfType0FunctionDictionary** out) {
+  return mapType0FunctionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType0FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType0FunctionDictionary** out) {
+  if (!isType0FunctionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType0FunctionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType2FunctionDictionary(const SkPdfObject& in, SkPdfType2FunctionDictionary** out) {
+  return mapType2FunctionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType2FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2FunctionDictionary** out) {
+  if (!isType2FunctionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType2FunctionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType3FunctionDictionary(const SkPdfObject& in, SkPdfType3FunctionDictionary** out) {
+  return mapType3FunctionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType3FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3FunctionDictionary** out) {
+  if (!isType3FunctionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType3FunctionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFileSpecificationDictionary(const SkPdfObject& in, SkPdfFileSpecificationDictionary** out) {
+  return mapFileSpecificationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFileSpecificationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileSpecificationDictionary** out) {
+  if (!isFileSpecificationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFileSpecificationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapEmbeddedFileStreamDictionary(const SkPdfObject& in, SkPdfEmbeddedFileStreamDictionary** out) {
+  return mapEmbeddedFileStreamDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFileStreamDictionary** out) {
+  if (!isEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfEmbeddedFileStreamDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapEmbeddedFileParameterDictionary(const SkPdfObject& in, SkPdfEmbeddedFileParameterDictionary** out) {
+  return mapEmbeddedFileParameterDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFileParameterDictionary** out) {
+  if (!isEmbeddedFileParameterDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfEmbeddedFileParameterDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapMacOsFileInformationDictionary(const SkPdfObject& in, SkPdfMacOsFileInformationDictionary** out) {
+  return mapMacOsFileInformationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMacOsFileInformationDictionary** out) {
+  if (!isMacOsFileInformationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfMacOsFileInformationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapGraphicsStateDictionary(const SkPdfObject& in, SkPdfGraphicsStateDictionary** out) {
+  return mapGraphicsStateDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGraphicsStateDictionary** out) {
+  if (!isGraphicsStateDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfGraphicsStateDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapCalgrayColorSpaceDictionary(const SkPdfObject& in, SkPdfCalgrayColorSpaceDictionary** out) {
+  return mapCalgrayColorSpaceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCalgrayColorSpaceDictionary** out) {
+  if (!isCalgrayColorSpaceDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfCalgrayColorSpaceDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapCalrgbColorSpaceDictionary(const SkPdfObject& in, SkPdfCalrgbColorSpaceDictionary** out) {
+  return mapCalrgbColorSpaceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCalrgbColorSpaceDictionary** out) {
+  if (!isCalrgbColorSpaceDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfCalrgbColorSpaceDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapLabColorSpaceDictionary(const SkPdfObject& in, SkPdfLabColorSpaceDictionary** out) {
+  return mapLabColorSpaceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapLabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLabColorSpaceDictionary** out) {
+  if (!isLabColorSpaceDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfLabColorSpaceDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapIccProfileStreamDictionary(const SkPdfObject& in, SkPdfIccProfileStreamDictionary** out) {
+  return mapIccProfileStreamDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfIccProfileStreamDictionary** out) {
+  if (!isIccProfileStreamDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfIccProfileStreamDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapDeviceNColorSpaceDictionary(const SkPdfObject& in, SkPdfDeviceNColorSpaceDictionary** out) {
+  return mapDeviceNColorSpaceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapDeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDeviceNColorSpaceDictionary** out) {
+  if (!isDeviceNColorSpaceDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfDeviceNColorSpaceDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType1PatternDictionary(const SkPdfObject& in, SkPdfType1PatternDictionary** out) {
+  return mapType1PatternDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType1PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1PatternDictionary** out) {
+  if (!isType1PatternDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType1PatternDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType2PatternDictionary(const SkPdfObject& in, SkPdfType2PatternDictionary** out) {
+  return mapType2PatternDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType2PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2PatternDictionary** out) {
+  if (!isType2PatternDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType2PatternDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapShadingDictionary(const SkPdfObject& in, SkPdfShadingDictionary** out) {
+  return mapShadingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfShadingDictionary** out) {
+  if (!isShadingDictionary(podofoDoc, podofoObj)) return false;
+
+  if (mapType1ShadingDictionary(podofoDoc, podofoObj, (SkPdfType1ShadingDictionary**)out)) return true;
+  if (mapType2ShadingDictionary(podofoDoc, podofoObj, (SkPdfType2ShadingDictionary**)out)) return true;
+  if (mapType3ShadingDictionary(podofoDoc, podofoObj, (SkPdfType3ShadingDictionary**)out)) return true;
+  if (mapType4ShadingDictionary(podofoDoc, podofoObj, (SkPdfType4ShadingDictionary**)out)) return true;
+  if (mapType5ShadingDictionary(podofoDoc, podofoObj, (SkPdfType5ShadingDictionary**)out)) return true;
+  if (mapType6ShadingDictionary(podofoDoc, podofoObj, (SkPdfType6ShadingDictionary**)out)) return true;
+
+  *out = new SkPdfShadingDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType1ShadingDictionary(const SkPdfObject& in, SkPdfType1ShadingDictionary** out) {
+  return mapType1ShadingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType1ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1ShadingDictionary** out) {
+  if (!isType1ShadingDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType1ShadingDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType2ShadingDictionary(const SkPdfObject& in, SkPdfType2ShadingDictionary** out) {
+  return mapType2ShadingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType2ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2ShadingDictionary** out) {
+  if (!isType2ShadingDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType2ShadingDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType3ShadingDictionary(const SkPdfObject& in, SkPdfType3ShadingDictionary** out) {
+  return mapType3ShadingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType3ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3ShadingDictionary** out) {
+  if (!isType3ShadingDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType3ShadingDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType4ShadingDictionary(const SkPdfObject& in, SkPdfType4ShadingDictionary** out) {
+  return mapType4ShadingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType4ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType4ShadingDictionary** out) {
+  if (!isType4ShadingDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType4ShadingDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType5ShadingDictionary(const SkPdfObject& in, SkPdfType5ShadingDictionary** out) {
+  return mapType5ShadingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType5ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5ShadingDictionary** out) {
+  if (!isType5ShadingDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType5ShadingDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType6ShadingDictionary(const SkPdfObject& in, SkPdfType6ShadingDictionary** out) {
+  return mapType6ShadingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType6ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6ShadingDictionary** out) {
+  if (!isType6ShadingDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType6ShadingDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapImageDictionary(const SkPdfObject& in, SkPdfImageDictionary** out) {
+  return mapImageDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfImageDictionary** out) {
+  if (!isImageDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfImageDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapAlternateImageDictionary(const SkPdfObject& in, SkPdfAlternateImageDictionary** out) {
+  return mapAlternateImageDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapAlternateImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAlternateImageDictionary** out) {
+  if (!isAlternateImageDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfAlternateImageDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType1FormDictionary(const SkPdfObject& in, SkPdfType1FormDictionary** out) {
+  return mapType1FormDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1FormDictionary** out) {
+  if (!isType1FormDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType1FormDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapGroupAttributesDictionary(const SkPdfObject& in, SkPdfGroupAttributesDictionary** out) {
+  return mapGroupAttributesDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGroupAttributesDictionary** out) {
+  if (!isGroupAttributesDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfGroupAttributesDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapReferenceDictionary(const SkPdfObject& in, SkPdfReferenceDictionary** out) {
+  return mapReferenceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfReferenceDictionary** out) {
+  if (!isReferenceDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfReferenceDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapPSXobjectDictionary(const SkPdfObject& in, SkPdfPSXobjectDictionary** out) {
+  return mapPSXobjectDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPSXobjectDictionary** out) {
+  if (!isPSXobjectDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfPSXobjectDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType1FontDictionary(const SkPdfObject& in, SkPdfType1FontDictionary** out) {
+  return mapType1FontDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1FontDictionary** out) {
+  if (!isType1FontDictionary(podofoDoc, podofoObj)) return false;
+
+  if (mapMultiMasterFontDictionary(podofoDoc, podofoObj, (SkPdfMultiMasterFontDictionary**)out)) return true;
+  if (mapTrueTypeFontDictionary(podofoDoc, podofoObj, (SkPdfTrueTypeFontDictionary**)out)) return true;
+  if (mapType3FontDictionary(podofoDoc, podofoObj, (SkPdfType3FontDictionary**)out)) return true;
+
+  *out = new SkPdfType1FontDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType3FontDictionary(const SkPdfObject& in, SkPdfType3FontDictionary** out) {
+  return mapType3FontDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3FontDictionary** out) {
+  if (!isType3FontDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType3FontDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapEncodingDictionary(const SkPdfObject& in, SkPdfEncodingDictionary** out) {
+  return mapEncodingDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncodingDictionary** out) {
+  if (!isEncodingDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfEncodingDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapCIDSystemInfoDictionary(const SkPdfObject& in, SkPdfCIDSystemInfoDictionary** out) {
+  return mapCIDSystemInfoDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDSystemInfoDictionary** out) {
+  if (!isCIDSystemInfoDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfCIDSystemInfoDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapCIDFontDictionary(const SkPdfObject& in, SkPdfCIDFontDictionary** out) {
+  return mapCIDFontDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDFontDictionary** out) {
+  if (!isCIDFontDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfCIDFontDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapCMapDictionary(const SkPdfObject& in, SkPdfCMapDictionary** out) {
+  return mapCMapDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCMapDictionary** out) {
+  if (!isCMapDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfCMapDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType0FontDictionary(const SkPdfObject& in, SkPdfType0FontDictionary** out) {
+  return mapType0FontDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType0FontDictionary** out) {
+  if (!isType0FontDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType0FontDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFontDescriptorDictionary(const SkPdfObject& in, SkPdfFontDescriptorDictionary** out) {
+  return mapFontDescriptorDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFontDescriptorDictionary** out) {
+  if (!isFontDescriptorDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFontDescriptorDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapCIDFontDescriptorDictionary(const SkPdfObject& in, SkPdfCIDFontDescriptorDictionary** out) {
+  return mapCIDFontDescriptorDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDFontDescriptorDictionary** out) {
+  if (!isCIDFontDescriptorDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfCIDFontDescriptorDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapEmbeddedFontStreamDictionary(const SkPdfObject& in, SkPdfEmbeddedFontStreamDictionary** out) {
+  return mapEmbeddedFontStreamDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFontStreamDictionary** out) {
+  if (!isEmbeddedFontStreamDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfEmbeddedFontStreamDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType1HalftoneDictionary(const SkPdfObject& in, SkPdfType1HalftoneDictionary** out) {
+  return mapType1HalftoneDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1HalftoneDictionary** out) {
+  if (!isType1HalftoneDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType1HalftoneDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType6HalftoneDictionary(const SkPdfObject& in, SkPdfType6HalftoneDictionary** out) {
+  return mapType6HalftoneDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6HalftoneDictionary** out) {
+  if (!isType6HalftoneDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType6HalftoneDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType10HalftoneDictionary(const SkPdfObject& in, SkPdfType10HalftoneDictionary** out) {
+  return mapType10HalftoneDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType10HalftoneDictionary** out) {
+  if (!isType10HalftoneDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType10HalftoneDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType16HalftoneDictionary(const SkPdfObject& in, SkPdfType16HalftoneDictionary** out) {
+  return mapType16HalftoneDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType16HalftoneDictionary** out) {
+  if (!isType16HalftoneDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType16HalftoneDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapType5HalftoneDictionary(const SkPdfObject& in, SkPdfType5HalftoneDictionary** out) {
+  return mapType5HalftoneDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5HalftoneDictionary** out) {
+  if (!isType5HalftoneDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfType5HalftoneDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapSoftMaskDictionary(const SkPdfObject& in, SkPdfSoftMaskDictionary** out) {
+  return mapSoftMaskDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoftMaskDictionary** out) {
+  if (!isSoftMaskDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfSoftMaskDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapSoftMaskImageDictionary(const SkPdfObject& in, SkPdfSoftMaskImageDictionary** out) {
+  return mapSoftMaskImageDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoftMaskImageDictionary** out) {
+  if (!isSoftMaskImageDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfSoftMaskImageDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapTransparencyGroupDictionary(const SkPdfObject& in, SkPdfTransparencyGroupDictionary** out) {
+  return mapTransparencyGroupDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTransparencyGroupDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTransparencyGroupDictionary** out) {
+  if (!isTransparencyGroupDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfTransparencyGroupDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapViewerPreferencesDictionary(const SkPdfObject& in, SkPdfViewerPreferencesDictionary** out) {
+  return mapViewerPreferencesDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfViewerPreferencesDictionary** out) {
+  if (!isViewerPreferencesDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfViewerPreferencesDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapOutlineDictionary(const SkPdfObject& in, SkPdfOutlineDictionary** out) {
+  return mapOutlineDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineDictionary** out) {
+  if (!isOutlineDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfOutlineDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapOutlineItemDictionary(const SkPdfObject& in, SkPdfOutlineItemDictionary** out) {
+  return mapOutlineItemDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapOutlineItemDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineItemDictionary** out) {
+  if (!isOutlineItemDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfOutlineItemDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapPageLabelDictionary(const SkPdfObject& in, SkPdfPageLabelDictionary** out) {
+  return mapPageLabelDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageLabelDictionary** out) {
+  if (!isPageLabelDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfPageLabelDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapThreadDictionary(const SkPdfObject& in, SkPdfThreadDictionary** out) {
+  return mapThreadDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadDictionary** out) {
+  if (!isThreadDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfThreadDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapBeadDictionary(const SkPdfObject& in, SkPdfBeadDictionary** out) {
+  return mapBeadDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapBeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBeadDictionary** out) {
+  if (!isBeadDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfBeadDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapTransitionDictionary(const SkPdfObject& in, SkPdfTransitionDictionary** out) {
+  return mapTransitionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTransitionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTransitionDictionary** out) {
+  if (!isTransitionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfTransitionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapAnnotationDictionary(const SkPdfObject& in, SkPdfAnnotationDictionary** out) {
+  return mapAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAnnotationDictionary** out) {
+  if (!isAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapBorderStyleDictionary(const SkPdfObject& in, SkPdfBorderStyleDictionary** out) {
+  return mapBorderStyleDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapBorderStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBorderStyleDictionary** out) {
+  if (!isBorderStyleDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfBorderStyleDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapAppearanceDictionary(const SkPdfObject& in, SkPdfAppearanceDictionary** out) {
+  return mapAppearanceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAppearanceDictionary** out) {
+  if (!isAppearanceDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfAppearanceDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapTextAnnotationDictionary(const SkPdfObject& in, SkPdfTextAnnotationDictionary** out) {
+  return mapTextAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTextAnnotationDictionary** out) {
+  if (!isTextAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfTextAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapALinkAnnotationDictionary(const SkPdfObject& in, SkPdfALinkAnnotationDictionary** out) {
+  return mapALinkAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfALinkAnnotationDictionary** out) {
+  if (!isALinkAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfALinkAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFreeTextAnnotationDictionary(const SkPdfObject& in, SkPdfFreeTextAnnotationDictionary** out) {
+  return mapFreeTextAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFreeTextAnnotationDictionary** out) {
+  if (!isFreeTextAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFreeTextAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapLineAnnotationDictionary(const SkPdfObject& in, SkPdfLineAnnotationDictionary** out) {
+  return mapLineAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapLineAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLineAnnotationDictionary** out) {
+  if (!isLineAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfLineAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapSquareOrCircleAnnotation(const SkPdfObject& in, SkPdfSquareOrCircleAnnotation** out) {
+  return mapSquareOrCircleAnnotation(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSquareOrCircleAnnotation** out) {
+  if (!isSquareOrCircleAnnotation(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfSquareOrCircleAnnotation(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapMarkupAnnotationsDictionary(const SkPdfObject& in, SkPdfMarkupAnnotationsDictionary** out) {
+  return mapMarkupAnnotationsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkupAnnotationsDictionary** out) {
+  if (!isMarkupAnnotationsDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfMarkupAnnotationsDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapRubberStampAnnotationDictionary(const SkPdfObject& in, SkPdfRubberStampAnnotationDictionary** out) {
+  return mapRubberStampAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapRubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRubberStampAnnotationDictionary** out) {
+  if (!isRubberStampAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfRubberStampAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapInkAnnotationDictionary(const SkPdfObject& in, SkPdfInkAnnotationDictionary** out) {
+  return mapInkAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInkAnnotationDictionary** out) {
+  if (!isInkAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfInkAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapPopUpAnnotationDictionary(const SkPdfObject& in, SkPdfPopUpAnnotationDictionary** out) {
+  return mapPopUpAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPopUpAnnotationDictionary** out) {
+  if (!isPopUpAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfPopUpAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFileAttachmentAnnotationDictionary(const SkPdfObject& in, SkPdfFileAttachmentAnnotationDictionary** out) {
+  return mapFileAttachmentAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileAttachmentAnnotationDictionary** out) {
+  if (!isFileAttachmentAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFileAttachmentAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapSoundAnnotationDictionary(const SkPdfObject& in, SkPdfSoundAnnotationDictionary** out) {
+  return mapSoundAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundAnnotationDictionary** out) {
+  if (!isSoundAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfSoundAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapMovieAnnotationDictionary(const SkPdfObject& in, SkPdfMovieAnnotationDictionary** out) {
+  return mapMovieAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieAnnotationDictionary** out) {
+  if (!isMovieAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfMovieAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapWidgetAnnotationDictionary(const SkPdfObject& in, SkPdfWidgetAnnotationDictionary** out) {
+  return mapWidgetAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWidgetAnnotationDictionary** out) {
+  if (!isWidgetAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfWidgetAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapActionDictionary(const SkPdfObject& in, SkPdfActionDictionary** out) {
+  return mapActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfActionDictionary** out) {
+  if (!isActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfActionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapAnnotationActionsDictionary(const SkPdfObject& in, SkPdfAnnotationActionsDictionary** out) {
+  return mapAnnotationActionsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAnnotationActionsDictionary** out) {
+  if (!isAnnotationActionsDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfAnnotationActionsDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapPageObjectActionsDictionary(const SkPdfObject& in, SkPdfPageObjectActionsDictionary** out) {
+  return mapPageObjectActionsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageObjectActionsDictionary** out) {
+  if (!isPageObjectActionsDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfPageObjectActionsDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFormFieldActionsDictionary(const SkPdfObject& in, SkPdfFormFieldActionsDictionary** out) {
+  return mapFormFieldActionsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFormFieldActionsDictionary** out) {
+  if (!isFormFieldActionsDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFormFieldActionsDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapDocumentCatalogActionsDictionary(const SkPdfObject& in, SkPdfDocumentCatalogActionsDictionary** out) {
+  return mapDocumentCatalogActionsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapDocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentCatalogActionsDictionary** out) {
+  if (!isDocumentCatalogActionsDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfDocumentCatalogActionsDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapGoToActionDictionary(const SkPdfObject& in, SkPdfGoToActionDictionary** out) {
+  return mapGoToActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGoToActionDictionary** out) {
+  if (!isGoToActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfGoToActionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapRemoteGoToActionDictionary(const SkPdfObject& in, SkPdfRemoteGoToActionDictionary** out) {
+  return mapRemoteGoToActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapRemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRemoteGoToActionDictionary** out) {
+  if (!isRemoteGoToActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfRemoteGoToActionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapLaunchActionDictionary(const SkPdfObject& in, SkPdfLaunchActionDictionary** out) {
+  return mapLaunchActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLaunchActionDictionary** out) {
+  if (!isLaunchActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfLaunchActionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapWindowsLaunchActionDictionary(const SkPdfObject& in, SkPdfWindowsLaunchActionDictionary** out) {
+  return mapWindowsLaunchActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWindowsLaunchActionDictionary** out) {
+  if (!isWindowsLaunchActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfWindowsLaunchActionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapThreadActionDictionary(const SkPdfObject& in, SkPdfThreadActionDictionary** out) {
+  return mapThreadActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapThreadActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadActionDictionary** out) {
+  if (!isThreadActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfThreadActionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapURIActionDictionary(const SkPdfObject& in, SkPdfURIActionDictionary** out) {
+  return mapURIActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURIActionDictionary** out) {
+  if (!isURIActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfURIActionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapURIDictionary(const SkPdfObject& in, SkPdfURIDictionary** out) {
+  return mapURIDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURIDictionary** out) {
+  if (!isURIDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfURIDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapSoundActionDictionary(const SkPdfObject& in, SkPdfSoundActionDictionary** out) {
+  return mapSoundActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSoundActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundActionDictionary** out) {
+  if (!isSoundActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfSoundActionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapMovieActionDictionary(const SkPdfObject& in, SkPdfMovieActionDictionary** out) {
+  return mapMovieActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMovieActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActionDictionary** out) {
+  if (!isMovieActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfMovieActionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapHideActionDictionary(const SkPdfObject& in, SkPdfHideActionDictionary** out) {
+  return mapHideActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfHideActionDictionary** out) {
+  if (!isHideActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfHideActionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapNamedActionsDictionary(const SkPdfObject& in, SkPdfNamedActionsDictionary** out) {
+  return mapNamedActionsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapNamedActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNamedActionsDictionary** out) {
+  if (!isNamedActionsDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfNamedActionsDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapInteractiveFormDictionary(const SkPdfObject& in, SkPdfInteractiveFormDictionary** out) {
+  return mapInteractiveFormDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInteractiveFormDictionary** out) {
+  if (!isInteractiveFormDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfInteractiveFormDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFieldDictionary(const SkPdfObject& in, SkPdfFieldDictionary** out) {
+  return mapFieldDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFieldDictionary** out) {
+  if (!isFieldDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFieldDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapVariableTextFieldDictionary(const SkPdfObject& in, SkPdfVariableTextFieldDictionary** out) {
+  return mapVariableTextFieldDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfVariableTextFieldDictionary** out) {
+  if (!isVariableTextFieldDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfVariableTextFieldDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapAppearanceCharacteristicsDictionary(const SkPdfObject& in, SkPdfAppearanceCharacteristicsDictionary** out) {
+  return mapAppearanceCharacteristicsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapAppearanceCharacteristicsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAppearanceCharacteristicsDictionary** out) {
+  if (!isAppearanceCharacteristicsDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfAppearanceCharacteristicsDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapCheckboxFieldDictionary(const SkPdfObject& in, SkPdfCheckboxFieldDictionary** out) {
+  return mapCheckboxFieldDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapCheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCheckboxFieldDictionary** out) {
+  if (!isCheckboxFieldDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfCheckboxFieldDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapRadioButtonFieldDictionary(const SkPdfObject& in, SkPdfRadioButtonFieldDictionary** out) {
+  return mapRadioButtonFieldDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapRadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRadioButtonFieldDictionary** out) {
+  if (!isRadioButtonFieldDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfRadioButtonFieldDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapTextFieldDictionary(const SkPdfObject& in, SkPdfTextFieldDictionary** out) {
+  return mapTextFieldDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTextFieldDictionary** out) {
+  if (!isTextFieldDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfTextFieldDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapChoiceFieldDictionary(const SkPdfObject& in, SkPdfChoiceFieldDictionary** out) {
+  return mapChoiceFieldDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfChoiceFieldDictionary** out) {
+  if (!isChoiceFieldDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfChoiceFieldDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapSignatureDictionary(const SkPdfObject& in, SkPdfSignatureDictionary** out) {
+  return mapSignatureDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSignatureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSignatureDictionary** out) {
+  if (!isSignatureDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfSignatureDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapSubmitFormActionDictionary(const SkPdfObject& in, SkPdfSubmitFormActionDictionary** out) {
+  return mapSubmitFormActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSubmitFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSubmitFormActionDictionary** out) {
+  if (!isSubmitFormActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfSubmitFormActionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapResetFormActionDictionary(const SkPdfObject& in, SkPdfResetFormActionDictionary** out) {
+  return mapResetFormActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapResetFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfResetFormActionDictionary** out) {
+  if (!isResetFormActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfResetFormActionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapImportDataActionDictionary(const SkPdfObject& in, SkPdfImportDataActionDictionary** out) {
+  return mapImportDataActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapImportDataActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfImportDataActionDictionary** out) {
+  if (!isImportDataActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfImportDataActionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapJavascriptActionDictionary(const SkPdfObject& in, SkPdfJavascriptActionDictionary** out) {
+  return mapJavascriptActionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapJavascriptActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJavascriptActionDictionary** out) {
+  if (!isJavascriptActionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfJavascriptActionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFDFTrailerDictionary(const SkPdfObject& in, SkPdfFDFTrailerDictionary** out) {
+  return mapFDFTrailerDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTrailerDictionary** out) {
+  if (!isFDFTrailerDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFDFTrailerDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFDFCatalogDictionary(const SkPdfObject& in, SkPdfFDFCatalogDictionary** out) {
+  return mapFDFCatalogDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFCatalogDictionary** out) {
+  if (!isFDFCatalogDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFDFCatalogDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFDFDictionary(const SkPdfObject& in, SkPdfFDFDictionary** out) {
+  return mapFDFDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFDictionary** out) {
+  if (!isFDFDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFDFDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapEncryptedEmbeddedFileStreamDictionary(const SkPdfObject& in, SkPdfEncryptedEmbeddedFileStreamDictionary** out) {
+  return mapEncryptedEmbeddedFileStreamDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncryptedEmbeddedFileStreamDictionary** out) {
+  if (!isEncryptedEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfEncryptedEmbeddedFileStreamDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapJavascriptDictionary(const SkPdfObject& in, SkPdfJavascriptDictionary** out) {
+  return mapJavascriptDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJavascriptDictionary** out) {
+  if (!isJavascriptDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfJavascriptDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFDFFieldDictionary(const SkPdfObject& in, SkPdfFDFFieldDictionary** out) {
+  return mapFDFFieldDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFFieldDictionary** out) {
+  if (!isFDFFieldDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFDFFieldDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapIconFitDictionary(const SkPdfObject& in, SkPdfIconFitDictionary** out) {
+  return mapIconFitDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfIconFitDictionary** out) {
+  if (!isIconFitDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfIconFitDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFDFPageDictionary(const SkPdfObject& in, SkPdfFDFPageDictionary** out) {
+  return mapFDFPageDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFPageDictionary** out) {
+  if (!isFDFPageDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFDFPageDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFDFTemplateDictionary(const SkPdfObject& in, SkPdfFDFTemplateDictionary** out) {
+  return mapFDFTemplateDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTemplateDictionary** out) {
+  if (!isFDFTemplateDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFDFTemplateDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFDFNamedPageReferenceDictionary(const SkPdfObject& in, SkPdfFDFNamedPageReferenceDictionary** out) {
+  return mapFDFNamedPageReferenceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFNamedPageReferenceDictionary** out) {
+  if (!isFDFNamedPageReferenceDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFDFNamedPageReferenceDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapFDFFileAnnotationDictionary(const SkPdfObject& in, SkPdfFDFFileAnnotationDictionary** out) {
+  return mapFDFFileAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFFileAnnotationDictionary** out) {
+  if (!isFDFFileAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfFDFFileAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapSoundObjectDictionary(const SkPdfObject& in, SkPdfSoundObjectDictionary** out) {
+  return mapSoundObjectDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSoundObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundObjectDictionary** out) {
+  if (!isSoundObjectDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfSoundObjectDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapMovieDictionary(const SkPdfObject& in, SkPdfMovieDictionary** out) {
+  return mapMovieDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieDictionary** out) {
+  if (!isMovieDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfMovieDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapMovieActivationDictionary(const SkPdfObject& in, SkPdfMovieActivationDictionary** out) {
+  return mapMovieActivationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMovieActivationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActivationDictionary** out) {
+  if (!isMovieActivationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfMovieActivationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapDocumentInformationDictionary(const SkPdfObject& in, SkPdfDocumentInformationDictionary** out) {
+  return mapDocumentInformationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapDocumentInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentInformationDictionary** out) {
+  if (!isDocumentInformationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfDocumentInformationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapMetadataStreamDictionary(const SkPdfObject& in, SkPdfMetadataStreamDictionary** out) {
+  return mapMetadataStreamDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMetadataStreamDictionary** out) {
+  if (!isMetadataStreamDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfMetadataStreamDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapComponentsWithMetadataDictionary(const SkPdfObject& in, SkPdfComponentsWithMetadataDictionary** out) {
+  return mapComponentsWithMetadataDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfComponentsWithMetadataDictionary** out) {
+  if (!isComponentsWithMetadataDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfComponentsWithMetadataDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapPagePieceDictionary(const SkPdfObject& in, SkPdfPagePieceDictionary** out) {
+  return mapPagePieceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPagePieceDictionary** out) {
+  if (!isPagePieceDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfPagePieceDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapApplicationDataDictionary(const SkPdfObject& in, SkPdfApplicationDataDictionary** out) {
+  return mapApplicationDataDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapApplicationDataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfApplicationDataDictionary** out) {
+  if (!isApplicationDataDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfApplicationDataDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapStructureTreeRootDictionary(const SkPdfObject& in, SkPdfStructureTreeRootDictionary** out) {
+  return mapStructureTreeRootDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureTreeRootDictionary** out) {
+  if (!isStructureTreeRootDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfStructureTreeRootDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapStructureElementDictionary(const SkPdfObject& in, SkPdfStructureElementDictionary** out) {
+  return mapStructureElementDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapStructureElementDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementDictionary** out) {
+  if (!isStructureElementDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfStructureElementDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapMarkedContentReferenceDictionary(const SkPdfObject& in, SkPdfMarkedContentReferenceDictionary** out) {
+  return mapMarkedContentReferenceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkedContentReferenceDictionary** out) {
+  if (!isMarkedContentReferenceDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfMarkedContentReferenceDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapObjectReferenceDictionary(const SkPdfObject& in, SkPdfObjectReferenceDictionary** out) {
+  return mapObjectReferenceDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObjectReferenceDictionary** out) {
+  if (!isObjectReferenceDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfObjectReferenceDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapStructureElementAccessDictionary(const SkPdfObject& in, SkPdfStructureElementAccessDictionary** out) {
+  return mapStructureElementAccessDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapStructureElementAccessDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementAccessDictionary** out) {
+  if (!isStructureElementAccessDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfStructureElementAccessDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapAttributeObjectDictionary(const SkPdfObject& in, SkPdfAttributeObjectDictionary** out) {
+  return mapAttributeObjectDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAttributeObjectDictionary** out) {
+  if (!isAttributeObjectDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfAttributeObjectDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapMarkInformationDictionary(const SkPdfObject& in, SkPdfMarkInformationDictionary** out) {
+  return mapMarkInformationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMarkInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkInformationDictionary** out) {
+  if (!isMarkInformationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfMarkInformationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapArtifactsDictionary(const SkPdfObject& in, SkPdfArtifactsDictionary** out) {
+  return mapArtifactsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfArtifactsDictionary** out) {
+  if (!isArtifactsDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfArtifactsDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapStandardStructureDictionary(const SkPdfObject& in, SkPdfStandardStructureDictionary** out) {
+  return mapStandardStructureDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapStandardStructureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardStructureDictionary** out) {
+  if (!isStandardStructureDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfStandardStructureDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapBlockLevelStructureElementsDictionary(const SkPdfObject& in, SkPdfBlockLevelStructureElementsDictionary** out) {
+  return mapBlockLevelStructureElementsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapBlockLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBlockLevelStructureElementsDictionary** out) {
+  if (!isBlockLevelStructureElementsDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfBlockLevelStructureElementsDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapInlineLevelStructureElementsDictionary(const SkPdfObject& in, SkPdfInlineLevelStructureElementsDictionary** out) {
+  return mapInlineLevelStructureElementsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapInlineLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInlineLevelStructureElementsDictionary** out) {
+  if (!isInlineLevelStructureElementsDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfInlineLevelStructureElementsDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapListAttributeDictionary(const SkPdfObject& in, SkPdfListAttributeDictionary** out) {
+  return mapListAttributeDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapListAttributeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfListAttributeDictionary** out) {
+  if (!isListAttributeDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfListAttributeDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapTableAttributesDictionary(const SkPdfObject& in, SkPdfTableAttributesDictionary** out) {
+  return mapTableAttributesDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTableAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTableAttributesDictionary** out) {
+  if (!isTableAttributesDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfTableAttributesDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapWebCaptureInformationDictionary(const SkPdfObject& in, SkPdfWebCaptureInformationDictionary** out) {
+  return mapWebCaptureInformationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureInformationDictionary** out) {
+  if (!isWebCaptureInformationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfWebCaptureInformationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapWebCaptureDictionary(const SkPdfObject& in, SkPdfWebCaptureDictionary** out) {
+  return mapWebCaptureDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureDictionary** out) {
+  if (!isWebCaptureDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfWebCaptureDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapWebCapturePageSetDictionary(const SkPdfObject& in, SkPdfWebCapturePageSetDictionary** out) {
+  return mapWebCapturePageSetDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCapturePageSetDictionary** out) {
+  if (!isWebCapturePageSetDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfWebCapturePageSetDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapWebCaptureImageSetDictionary(const SkPdfObject& in, SkPdfWebCaptureImageSetDictionary** out) {
+  return mapWebCaptureImageSetDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureImageSetDictionary** out) {
+  if (!isWebCaptureImageSetDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfWebCaptureImageSetDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapSourceInformationDictionary(const SkPdfObject& in, SkPdfSourceInformationDictionary** out) {
+  return mapSourceInformationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSourceInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSourceInformationDictionary** out) {
+  if (!isSourceInformationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfSourceInformationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapURLAliasDictionary(const SkPdfObject& in, SkPdfURLAliasDictionary** out) {
+  return mapURLAliasDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURLAliasDictionary** out) {
+  if (!isURLAliasDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfURLAliasDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapWebCaptureCommandDictionary(const SkPdfObject& in, SkPdfWebCaptureCommandDictionary** out) {
+  return mapWebCaptureCommandDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureCommandDictionary** out) {
+  if (!isWebCaptureCommandDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfWebCaptureCommandDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapWebCaptureCommandSettingsDictionary(const SkPdfObject& in, SkPdfWebCaptureCommandSettingsDictionary** out) {
+  return mapWebCaptureCommandSettingsDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureCommandSettingsDictionary** out) {
+  if (!isWebCaptureCommandSettingsDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfWebCaptureCommandSettingsDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapBoxColorInformationDictionary(const SkPdfObject& in, SkPdfBoxColorInformationDictionary** out) {
+  return mapBoxColorInformationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapBoxColorInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoxColorInformationDictionary** out) {
+  if (!isBoxColorInformationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfBoxColorInformationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapBoxStyleDictionary(const SkPdfObject& in, SkPdfBoxStyleDictionary** out) {
+  return mapBoxStyleDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapBoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoxStyleDictionary** out) {
+  if (!isBoxStyleDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfBoxStyleDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapPrinterMarkAnnotationDictionary(const SkPdfObject& in, SkPdfPrinterMarkAnnotationDictionary** out) {
+  return mapPrinterMarkAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPrinterMarkAnnotationDictionary** out) {
+  if (!isPrinterMarkAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfPrinterMarkAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapPrinterMarkFormDictionary(const SkPdfObject& in, SkPdfPrinterMarkFormDictionary** out) {
+  return mapPrinterMarkFormDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPrinterMarkFormDictionary** out) {
+  if (!isPrinterMarkFormDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfPrinterMarkFormDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapSeparationDictionary(const SkPdfObject& in, SkPdfSeparationDictionary** out) {
+  return mapSeparationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapSeparationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSeparationDictionary** out) {
+  if (!isSeparationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfSeparationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapPDF_XOutputIntentDictionary(const SkPdfObject& in, SkPdfPDF_XOutputIntentDictionary** out) {
+  return mapPDF_XOutputIntentDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPDF_XOutputIntentDictionary** out) {
+  if (!isPDF_XOutputIntentDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfPDF_XOutputIntentDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapTrapNetworkAnnotationDictionary(const SkPdfObject& in, SkPdfTrapNetworkAnnotationDictionary** out) {
+  return mapTrapNetworkAnnotationDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrapNetworkAnnotationDictionary** out) {
+  if (!isTrapNetworkAnnotationDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfTrapNetworkAnnotationDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapTrapNetworkAppearanceStreamDictionary(const SkPdfObject& in, SkPdfTrapNetworkAppearanceStreamDictionary** out) {
+  return mapTrapNetworkAppearanceStreamDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapTrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrapNetworkAppearanceStreamDictionary** out) {
+  if (!isTrapNetworkAppearanceStreamDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfTrapNetworkAppearanceStreamDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapOpiVersionDictionary(const SkPdfObject& in, SkPdfOpiVersionDictionary** out) {
+  return mapOpiVersionDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOpiVersionDictionary** out) {
+  if (!isOpiVersionDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfOpiVersionDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool mapMultiMasterFontDictionary(const SkPdfObject& in, SkPdfMultiMasterFontDictionary** out) {
+  return mapMultiMasterFontDictionary(*in.doc(), *in.podofo(), out);
+}
+
+bool mapMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMultiMasterFontDictionary** out) {
+  if (!isMultiMasterFontDictionary(podofoDoc, podofoObj)) return false;
+
+
+  *out = new SkPdfMultiMasterFontDictionary(&podofoDoc, &podofoObj);
+  return true;
+}
+
+bool isObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+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; }
+  if (data == NULL) { return true; }
+  return mapObject(*pdfDoc, *value, (SkPdfObject**)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);
+}
+
+bool isNull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return podofoObj.GetDataType() == ePdfDataType_Null;
+}
+
+bool NullFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNull** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapNull(*pdfDoc, *value, (SkPdfNull**)data);
+}
+
+bool NullFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNull** data) {
+  if (NullFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return NullFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isBoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return podofoObj.GetDataType() == ePdfDataType_Bool;
+}
+
+bool BooleanFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBoolean** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapBoolean(*pdfDoc, *value, (SkPdfBoolean**)data);
+}
+
+bool BooleanFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBoolean** data) {
+  if (BooleanFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return BooleanFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return podofoObj.GetDataType() == ePdfDataType_Number || podofoObj.GetDataType() == ePdfDataType_Real;
+}
+
+bool IntegerFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInteger** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapInteger(*pdfDoc, *value, (SkPdfInteger**)data);
+}
+
+bool IntegerFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInteger** data) {
+  if (IntegerFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return IntegerFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isNumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return podofoObj.GetDataType() == ePdfDataType_Number || podofoObj.GetDataType() == ePdfDataType_Real;
+}
+
+bool NumberFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNumber** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapNumber(*pdfDoc, *value, (SkPdfNumber**)data);
+}
+
+bool NumberFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNumber** data) {
+  if (NumberFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return NumberFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return podofoObj.GetDataType() == ePdfDataType_Name;
+}
+
+bool NameFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfName** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapName(*pdfDoc, *value, (SkPdfName**)data);
+}
+
+bool NameFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfName** data) {
+  if (NameFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return NameFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isReference(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return podofoObj.GetDataType() == ePdfDataType_Reference;
+}
+
+bool ReferenceFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfReference** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapReference(*pdfDoc, *value, (SkPdfReference**)data);
+}
+
+bool ReferenceFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfReference** data) {
+  if (ReferenceFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ReferenceFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return podofoObj.GetDataType() == ePdfDataType_Array;
+}
+
+bool ArrayFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfArray** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapArray(*pdfDoc, *value, (SkPdfArray**)data);
+}
+
+bool ArrayFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfArray** data) {
+  if (ArrayFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ArrayFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return podofoObj.GetDataType() == ePdfDataType_String || podofoObj.GetDataType() == ePdfDataType_HexString;
+}
+
+bool StringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfString** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapString(*pdfDoc, *value, (SkPdfString**)data);
+}
+
+bool StringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfString** data) {
+  if (StringFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return StringFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isHexString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return podofoObj.GetDataType() == ePdfDataType_HexString;
+}
+
+bool HexStringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfHexString** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapHexString(*pdfDoc, *value, (SkPdfHexString**)data);
+}
+
+bool HexStringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfHexString** data) {
+  if (HexStringFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return HexStringFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return podofoObj.GetDataType() == ePdfDataType_Dictionary;
+}
+
+bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapDictionary(*pdfDoc, *value, (SkPdfDictionary**)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);
+}
+
+bool isStream(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStream** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapStream(*pdfDoc, *value, (SkPdfStream**)data);
+}
+
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStream** data) {
+  if (StreamFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return StreamFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool XObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfXObjectDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapXObjectDictionary(*pdfDoc, *value, (SkPdfXObjectDictionary**)data);
+}
+
+bool XObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfXObjectDictionary** data) {
+  if (XObjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return XObjectDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFontDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFontDictionary(*pdfDoc, *value, (SkPdfFontDictionary**)data);
+}
+
+bool FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFontDictionary** data) {
+  if (FontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FontDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  std::string Subtype;
+  if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+  if ((Subtype != "TrueType")) return false;
+
+  return true;
+}
+
+bool TrueTypeFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTrueTypeFontDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapTrueTypeFontDictionary(*pdfDoc, *value, (SkPdfTrueTypeFontDictionary**)data);
+}
+
+bool TrueTypeFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTrueTypeFontDictionary** data) {
+  if (TrueTypeFontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return TrueTypeFontDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isStreamCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool StreamCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStreamCommonDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapStreamCommonDictionary(*pdfDoc, *value, (SkPdfStreamCommonDictionary**)data);
+}
+
+bool StreamCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStreamCommonDictionary** data) {
+  if (StreamCommonDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return StreamCommonDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isLzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapLzwdecodeAndFlatedecodeFiltersDictionary(*pdfDoc, *value, (SkPdfLzwdecodeAndFlatedecodeFiltersDictionary**)data);
+}
+
+bool LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** data) {
+  if (LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool CcittfaxdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCcittfaxdecodeFilterDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapCcittfaxdecodeFilterDictionary(*pdfDoc, *value, (SkPdfCcittfaxdecodeFilterDictionary**)data);
+}
+
+bool CcittfaxdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCcittfaxdecodeFilterDictionary** data) {
+  if (CcittfaxdecodeFilterDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return CcittfaxdecodeFilterDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Jbig2DecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfJbig2DecodeFilterDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapJbig2DecodeFilterDictionary(*pdfDoc, *value, (SkPdfJbig2DecodeFilterDictionary**)data);
+}
+
+bool Jbig2DecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfJbig2DecodeFilterDictionary** data) {
+  if (Jbig2DecodeFilterDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Jbig2DecodeFilterDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isDctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool DctdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDctdecodeFilterDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapDctdecodeFilterDictionary(*pdfDoc, *value, (SkPdfDctdecodeFilterDictionary**)data);
+}
+
+bool DctdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDctdecodeFilterDictionary** data) {
+  if (DctdecodeFilterDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return DctdecodeFilterDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFileTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FileTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFileTrailerDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFileTrailerDictionary(*pdfDoc, *value, (SkPdfFileTrailerDictionary**)data);
+}
+
+bool FileTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFileTrailerDictionary** data) {
+  if (FileTrailerDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FileTrailerDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool EncryptionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEncryptionCommonDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapEncryptionCommonDictionary(*pdfDoc, *value, (SkPdfEncryptionCommonDictionary**)data);
+}
+
+bool EncryptionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEncryptionCommonDictionary** data) {
+  if (EncryptionCommonDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return EncryptionCommonDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool StandardSecurityHandlerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStandardSecurityHandlerDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapStandardSecurityHandlerDictionary(*pdfDoc, *value, (SkPdfStandardSecurityHandlerDictionary**)data);
+}
+
+bool StandardSecurityHandlerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStandardSecurityHandlerDictionary** data) {
+  if (StandardSecurityHandlerDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return StandardSecurityHandlerDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool CatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCatalogDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapCatalogDictionary(*pdfDoc, *value, (SkPdfCatalogDictionary**)data);
+}
+
+bool CatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCatalogDictionary** data) {
+  if (CatalogDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return CatalogDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool PageTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageTreeNodeDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapPageTreeNodeDictionary(*pdfDoc, *value, (SkPdfPageTreeNodeDictionary**)data);
+}
+
+bool PageTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageTreeNodeDictionary** data) {
+  if (PageTreeNodeDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return PageTreeNodeDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool PageObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageObjectDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapPageObjectDictionary(*pdfDoc, *value, (SkPdfPageObjectDictionary**)data);
+}
+
+bool PageObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageObjectDictionary** data) {
+  if (PageObjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return PageObjectDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isNameDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool NameDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNameDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapNameDictionary(*pdfDoc, *value, (SkPdfNameDictionary**)data);
+}
+
+bool NameDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNameDictionary** data) {
+  if (NameDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return NameDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ResourceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfResourceDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapResourceDictionary(*pdfDoc, *value, (SkPdfResourceDictionary**)data);
+}
+
+bool ResourceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfResourceDictionary** data) {
+  if (ResourceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ResourceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isNameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool NameTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNameTreeNodeDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapNameTreeNodeDictionary(*pdfDoc, *value, (SkPdfNameTreeNodeDictionary**)data);
+}
+
+bool NameTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNameTreeNodeDictionary** data) {
+  if (NameTreeNodeDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return NameTreeNodeDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isNumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool NumberTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNumberTreeNodeDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapNumberTreeNodeDictionary(*pdfDoc, *value, (SkPdfNumberTreeNodeDictionary**)data);
+}
+
+bool NumberTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNumberTreeNodeDictionary** data) {
+  if (NumberTreeNodeDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return NumberTreeNodeDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FunctionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFunctionCommonDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFunctionCommonDictionary(*pdfDoc, *value, (SkPdfFunctionCommonDictionary**)data);
+}
+
+bool FunctionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFunctionCommonDictionary** data) {
+  if (FunctionCommonDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FunctionCommonDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType0FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type0FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType0FunctionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType0FunctionDictionary(*pdfDoc, *value, (SkPdfType0FunctionDictionary**)data);
+}
+
+bool Type0FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType0FunctionDictionary** data) {
+  if (Type0FunctionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type0FunctionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType2FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type2FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType2FunctionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType2FunctionDictionary(*pdfDoc, *value, (SkPdfType2FunctionDictionary**)data);
+}
+
+bool Type2FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType2FunctionDictionary** data) {
+  if (Type2FunctionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type2FunctionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType3FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type3FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType3FunctionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType3FunctionDictionary(*pdfDoc, *value, (SkPdfType3FunctionDictionary**)data);
+}
+
+bool Type3FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType3FunctionDictionary** data) {
+  if (Type3FunctionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type3FunctionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFileSpecificationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FileSpecificationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFileSpecificationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFileSpecificationDictionary(*pdfDoc, *value, (SkPdfFileSpecificationDictionary**)data);
+}
+
+bool FileSpecificationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFileSpecificationDictionary** data) {
+  if (FileSpecificationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FileSpecificationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool EmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEmbeddedFileStreamDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapEmbeddedFileStreamDictionary(*pdfDoc, *value, (SkPdfEmbeddedFileStreamDictionary**)data);
+}
+
+bool EmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFileStreamDictionary** data) {
+  if (EmbeddedFileStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return EmbeddedFileStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool EmbeddedFileParameterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEmbeddedFileParameterDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapEmbeddedFileParameterDictionary(*pdfDoc, *value, (SkPdfEmbeddedFileParameterDictionary**)data);
+}
+
+bool EmbeddedFileParameterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFileParameterDictionary** data) {
+  if (EmbeddedFileParameterDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return EmbeddedFileParameterDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool MacOsFileInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMacOsFileInformationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapMacOsFileInformationDictionary(*pdfDoc, *value, (SkPdfMacOsFileInformationDictionary**)data);
+}
+
+bool MacOsFileInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMacOsFileInformationDictionary** data) {
+  if (MacOsFileInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return MacOsFileInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool GraphicsStateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfGraphicsStateDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapGraphicsStateDictionary(*pdfDoc, *value, (SkPdfGraphicsStateDictionary**)data);
+}
+
+bool GraphicsStateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfGraphicsStateDictionary** data) {
+  if (GraphicsStateDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return GraphicsStateDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool CalgrayColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCalgrayColorSpaceDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapCalgrayColorSpaceDictionary(*pdfDoc, *value, (SkPdfCalgrayColorSpaceDictionary**)data);
+}
+
+bool CalgrayColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCalgrayColorSpaceDictionary** data) {
+  if (CalgrayColorSpaceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return CalgrayColorSpaceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool CalrgbColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCalrgbColorSpaceDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapCalrgbColorSpaceDictionary(*pdfDoc, *value, (SkPdfCalrgbColorSpaceDictionary**)data);
+}
+
+bool CalrgbColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCalrgbColorSpaceDictionary** data) {
+  if (CalrgbColorSpaceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return CalrgbColorSpaceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isLabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool LabColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLabColorSpaceDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapLabColorSpaceDictionary(*pdfDoc, *value, (SkPdfLabColorSpaceDictionary**)data);
+}
+
+bool LabColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLabColorSpaceDictionary** data) {
+  if (LabColorSpaceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return LabColorSpaceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool IccProfileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfIccProfileStreamDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapIccProfileStreamDictionary(*pdfDoc, *value, (SkPdfIccProfileStreamDictionary**)data);
+}
+
+bool IccProfileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfIccProfileStreamDictionary** data) {
+  if (IccProfileStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return IccProfileStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isDeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool DeviceNColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDeviceNColorSpaceDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapDeviceNColorSpaceDictionary(*pdfDoc, *value, (SkPdfDeviceNColorSpaceDictionary**)data);
+}
+
+bool DeviceNColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDeviceNColorSpaceDictionary** data) {
+  if (DeviceNColorSpaceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return DeviceNColorSpaceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType1PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type1PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1PatternDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType1PatternDictionary(*pdfDoc, *value, (SkPdfType1PatternDictionary**)data);
+}
+
+bool Type1PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1PatternDictionary** data) {
+  if (Type1PatternDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type1PatternDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType2PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type2PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType2PatternDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType2PatternDictionary(*pdfDoc, *value, (SkPdfType2PatternDictionary**)data);
+}
+
+bool Type2PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType2PatternDictionary** data) {
+  if (Type2PatternDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type2PatternDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfShadingDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapShadingDictionary(*pdfDoc, *value, (SkPdfShadingDictionary**)data);
+}
+
+bool ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfShadingDictionary** data) {
+  if (ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType1ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type1ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1ShadingDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType1ShadingDictionary(*pdfDoc, *value, (SkPdfType1ShadingDictionary**)data);
+}
+
+bool Type1ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1ShadingDictionary** data) {
+  if (Type1ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type1ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType2ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type2ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType2ShadingDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType2ShadingDictionary(*pdfDoc, *value, (SkPdfType2ShadingDictionary**)data);
+}
+
+bool Type2ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType2ShadingDictionary** data) {
+  if (Type2ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type2ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType3ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type3ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType3ShadingDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType3ShadingDictionary(*pdfDoc, *value, (SkPdfType3ShadingDictionary**)data);
+}
+
+bool Type3ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType3ShadingDictionary** data) {
+  if (Type3ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type3ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType4ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type4ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType4ShadingDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType4ShadingDictionary(*pdfDoc, *value, (SkPdfType4ShadingDictionary**)data);
+}
+
+bool Type4ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType4ShadingDictionary** data) {
+  if (Type4ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type4ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType5ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type5ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType5ShadingDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType5ShadingDictionary(*pdfDoc, *value, (SkPdfType5ShadingDictionary**)data);
+}
+
+bool Type5ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType5ShadingDictionary** data) {
+  if (Type5ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type5ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType6ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type6ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType6ShadingDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType6ShadingDictionary(*pdfDoc, *value, (SkPdfType6ShadingDictionary**)data);
+}
+
+bool Type6ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType6ShadingDictionary** data) {
+  if (Type6ShadingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type6ShadingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  std::string Subtype;
+  if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+  if ((Subtype != "Image")) return false;
+
+  return true;
+}
+
+bool ImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfImageDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapImageDictionary(*pdfDoc, *value, (SkPdfImageDictionary**)data);
+}
+
+bool ImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfImageDictionary** data) {
+  if (ImageDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ImageDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isAlternateImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool AlternateImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAlternateImageDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapAlternateImageDictionary(*pdfDoc, *value, (SkPdfAlternateImageDictionary**)data);
+}
+
+bool AlternateImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAlternateImageDictionary** data) {
+  if (AlternateImageDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return AlternateImageDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  std::string Subtype;
+  if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+  if ((Subtype != "Form")) return false;
+
+  return true;
+}
+
+bool Type1FormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1FormDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType1FormDictionary(*pdfDoc, *value, (SkPdfType1FormDictionary**)data);
+}
+
+bool Type1FormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1FormDictionary** data) {
+  if (Type1FormDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type1FormDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool GroupAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfGroupAttributesDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapGroupAttributesDictionary(*pdfDoc, *value, (SkPdfGroupAttributesDictionary**)data);
+}
+
+bool GroupAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfGroupAttributesDictionary** data) {
+  if (GroupAttributesDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return GroupAttributesDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfReferenceDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapReferenceDictionary(*pdfDoc, *value, (SkPdfReferenceDictionary**)data);
+}
+
+bool ReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfReferenceDictionary** data) {
+  if (ReferenceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ReferenceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool PSXobjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPSXobjectDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapPSXobjectDictionary(*pdfDoc, *value, (SkPdfPSXobjectDictionary**)data);
+}
+
+bool PSXobjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPSXobjectDictionary** data) {
+  if (PSXobjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return PSXobjectDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  std::string Subtype;
+  if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+  if ((Subtype != "MMType1") && (Subtype != "TrueType") && (Subtype != "Type3") && (Subtype != "Type1")) return false;
+
+  return true;
+}
+
+bool Type1FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1FontDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType1FontDictionary(*pdfDoc, *value, (SkPdfType1FontDictionary**)data);
+}
+
+bool Type1FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1FontDictionary** data) {
+  if (Type1FontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type1FontDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  std::string Subtype;
+  if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+  if ((Subtype != "Type3")) return false;
+
+  return true;
+}
+
+bool Type3FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType3FontDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType3FontDictionary(*pdfDoc, *value, (SkPdfType3FontDictionary**)data);
+}
+
+bool Type3FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType3FontDictionary** data) {
+  if (Type3FontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type3FontDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool EncodingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEncodingDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapEncodingDictionary(*pdfDoc, *value, (SkPdfEncodingDictionary**)data);
+}
+
+bool EncodingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEncodingDictionary** data) {
+  if (EncodingDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return EncodingDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool CIDSystemInfoDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCIDSystemInfoDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapCIDSystemInfoDictionary(*pdfDoc, *value, (SkPdfCIDSystemInfoDictionary**)data);
+}
+
+bool CIDSystemInfoDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCIDSystemInfoDictionary** data) {
+  if (CIDSystemInfoDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return CIDSystemInfoDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  std::string Subtype;
+  if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+  if ((Subtype != "CIDFontType0") && (Subtype != "CIDFontType2")) return false;
+
+  return true;
+}
+
+bool CIDFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCIDFontDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapCIDFontDictionary(*pdfDoc, *value, (SkPdfCIDFontDictionary**)data);
+}
+
+bool CIDFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCIDFontDictionary** data) {
+  if (CIDFontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return CIDFontDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool CMapDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCMapDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapCMapDictionary(*pdfDoc, *value, (SkPdfCMapDictionary**)data);
+}
+
+bool CMapDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCMapDictionary** data) {
+  if (CMapDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return CMapDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  std::string Subtype;
+  if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+  if ((Subtype != "Type0")) return false;
+
+  return true;
+}
+
+bool Type0FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType0FontDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType0FontDictionary(*pdfDoc, *value, (SkPdfType0FontDictionary**)data);
+}
+
+bool Type0FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType0FontDictionary** data) {
+  if (Type0FontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type0FontDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFontDescriptorDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFontDescriptorDictionary(*pdfDoc, *value, (SkPdfFontDescriptorDictionary**)data);
+}
+
+bool FontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFontDescriptorDictionary** data) {
+  if (FontDescriptorDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FontDescriptorDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool CIDFontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCIDFontDescriptorDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapCIDFontDescriptorDictionary(*pdfDoc, *value, (SkPdfCIDFontDescriptorDictionary**)data);
+}
+
+bool CIDFontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCIDFontDescriptorDictionary** data) {
+  if (CIDFontDescriptorDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return CIDFontDescriptorDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool EmbeddedFontStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEmbeddedFontStreamDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapEmbeddedFontStreamDictionary(*pdfDoc, *value, (SkPdfEmbeddedFontStreamDictionary**)data);
+}
+
+bool EmbeddedFontStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFontStreamDictionary** data) {
+  if (EmbeddedFontStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return EmbeddedFontStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type1HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1HalftoneDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType1HalftoneDictionary(*pdfDoc, *value, (SkPdfType1HalftoneDictionary**)data);
+}
+
+bool Type1HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1HalftoneDictionary** data) {
+  if (Type1HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type1HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type6HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType6HalftoneDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType6HalftoneDictionary(*pdfDoc, *value, (SkPdfType6HalftoneDictionary**)data);
+}
+
+bool Type6HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType6HalftoneDictionary** data) {
+  if (Type6HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type6HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type10HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType10HalftoneDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType10HalftoneDictionary(*pdfDoc, *value, (SkPdfType10HalftoneDictionary**)data);
+}
+
+bool Type10HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType10HalftoneDictionary** data) {
+  if (Type10HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type10HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type16HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType16HalftoneDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType16HalftoneDictionary(*pdfDoc, *value, (SkPdfType16HalftoneDictionary**)data);
+}
+
+bool Type16HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType16HalftoneDictionary** data) {
+  if (Type16HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type16HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool Type5HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType5HalftoneDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapType5HalftoneDictionary(*pdfDoc, *value, (SkPdfType5HalftoneDictionary**)data);
+}
+
+bool Type5HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType5HalftoneDictionary** data) {
+  if (Type5HalftoneDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return Type5HalftoneDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool SoftMaskDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoftMaskDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapSoftMaskDictionary(*pdfDoc, *value, (SkPdfSoftMaskDictionary**)data);
+}
+
+bool SoftMaskDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoftMaskDictionary** data) {
+  if (SoftMaskDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return SoftMaskDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool SoftMaskImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoftMaskImageDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapSoftMaskImageDictionary(*pdfDoc, *value, (SkPdfSoftMaskImageDictionary**)data);
+}
+
+bool SoftMaskImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoftMaskImageDictionary** data) {
+  if (SoftMaskImageDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return SoftMaskImageDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTransparencyGroupDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool TransparencyGroupDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTransparencyGroupDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapTransparencyGroupDictionary(*pdfDoc, *value, (SkPdfTransparencyGroupDictionary**)data);
+}
+
+bool TransparencyGroupDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTransparencyGroupDictionary** data) {
+  if (TransparencyGroupDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return TransparencyGroupDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ViewerPreferencesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfViewerPreferencesDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapViewerPreferencesDictionary(*pdfDoc, *value, (SkPdfViewerPreferencesDictionary**)data);
+}
+
+bool ViewerPreferencesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfViewerPreferencesDictionary** data) {
+  if (ViewerPreferencesDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ViewerPreferencesDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool OutlineDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfOutlineDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapOutlineDictionary(*pdfDoc, *value, (SkPdfOutlineDictionary**)data);
+}
+
+bool OutlineDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfOutlineDictionary** data) {
+  if (OutlineDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return OutlineDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isOutlineItemDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool OutlineItemDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfOutlineItemDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapOutlineItemDictionary(*pdfDoc, *value, (SkPdfOutlineItemDictionary**)data);
+}
+
+bool OutlineItemDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfOutlineItemDictionary** data) {
+  if (OutlineItemDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return OutlineItemDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool PageLabelDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageLabelDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapPageLabelDictionary(*pdfDoc, *value, (SkPdfPageLabelDictionary**)data);
+}
+
+bool PageLabelDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageLabelDictionary** data) {
+  if (PageLabelDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return PageLabelDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ThreadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfThreadDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapThreadDictionary(*pdfDoc, *value, (SkPdfThreadDictionary**)data);
+}
+
+bool ThreadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfThreadDictionary** data) {
+  if (ThreadDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ThreadDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isBeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool BeadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBeadDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapBeadDictionary(*pdfDoc, *value, (SkPdfBeadDictionary**)data);
+}
+
+bool BeadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBeadDictionary** data) {
+  if (BeadDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return BeadDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTransitionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool TransitionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTransitionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapTransitionDictionary(*pdfDoc, *value, (SkPdfTransitionDictionary**)data);
+}
+
+bool TransitionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTransitionDictionary** data) {
+  if (TransitionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return TransitionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool AnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapAnnotationDictionary(*pdfDoc, *value, (SkPdfAnnotationDictionary**)data);
+}
+
+bool AnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAnnotationDictionary** data) {
+  if (AnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return AnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isBorderStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool BorderStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBorderStyleDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapBorderStyleDictionary(*pdfDoc, *value, (SkPdfBorderStyleDictionary**)data);
+}
+
+bool BorderStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBorderStyleDictionary** data) {
+  if (BorderStyleDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return BorderStyleDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool AppearanceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAppearanceDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapAppearanceDictionary(*pdfDoc, *value, (SkPdfAppearanceDictionary**)data);
+}
+
+bool AppearanceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAppearanceDictionary** data) {
+  if (AppearanceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return AppearanceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool TextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTextAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapTextAnnotationDictionary(*pdfDoc, *value, (SkPdfTextAnnotationDictionary**)data);
+}
+
+bool TextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTextAnnotationDictionary** data) {
+  if (TextAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return TextAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ALinkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfALinkAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapALinkAnnotationDictionary(*pdfDoc, *value, (SkPdfALinkAnnotationDictionary**)data);
+}
+
+bool ALinkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfALinkAnnotationDictionary** data) {
+  if (ALinkAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ALinkAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FreeTextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFreeTextAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFreeTextAnnotationDictionary(*pdfDoc, *value, (SkPdfFreeTextAnnotationDictionary**)data);
+}
+
+bool FreeTextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFreeTextAnnotationDictionary** data) {
+  if (FreeTextAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FreeTextAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isLineAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool LineAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLineAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapLineAnnotationDictionary(*pdfDoc, *value, (SkPdfLineAnnotationDictionary**)data);
+}
+
+bool LineAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLineAnnotationDictionary** data) {
+  if (LineAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return LineAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool SquareOrCircleAnnotationFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSquareOrCircleAnnotation** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapSquareOrCircleAnnotation(*pdfDoc, *value, (SkPdfSquareOrCircleAnnotation**)data);
+}
+
+bool SquareOrCircleAnnotationFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSquareOrCircleAnnotation** data) {
+  if (SquareOrCircleAnnotationFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return SquareOrCircleAnnotationFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool MarkupAnnotationsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMarkupAnnotationsDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapMarkupAnnotationsDictionary(*pdfDoc, *value, (SkPdfMarkupAnnotationsDictionary**)data);
+}
+
+bool MarkupAnnotationsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkupAnnotationsDictionary** data) {
+  if (MarkupAnnotationsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return MarkupAnnotationsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isRubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool RubberStampAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfRubberStampAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapRubberStampAnnotationDictionary(*pdfDoc, *value, (SkPdfRubberStampAnnotationDictionary**)data);
+}
+
+bool RubberStampAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfRubberStampAnnotationDictionary** data) {
+  if (RubberStampAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return RubberStampAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool InkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInkAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapInkAnnotationDictionary(*pdfDoc, *value, (SkPdfInkAnnotationDictionary**)data);
+}
+
+bool InkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInkAnnotationDictionary** data) {
+  if (InkAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return InkAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool PopUpAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPopUpAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapPopUpAnnotationDictionary(*pdfDoc, *value, (SkPdfPopUpAnnotationDictionary**)data);
+}
+
+bool PopUpAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPopUpAnnotationDictionary** data) {
+  if (PopUpAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return PopUpAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FileAttachmentAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFileAttachmentAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFileAttachmentAnnotationDictionary(*pdfDoc, *value, (SkPdfFileAttachmentAnnotationDictionary**)data);
+}
+
+bool FileAttachmentAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFileAttachmentAnnotationDictionary** data) {
+  if (FileAttachmentAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FileAttachmentAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool SoundAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoundAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapSoundAnnotationDictionary(*pdfDoc, *value, (SkPdfSoundAnnotationDictionary**)data);
+}
+
+bool SoundAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoundAnnotationDictionary** data) {
+  if (SoundAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return SoundAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool MovieAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapMovieAnnotationDictionary(*pdfDoc, *value, (SkPdfMovieAnnotationDictionary**)data);
+}
+
+bool MovieAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieAnnotationDictionary** data) {
+  if (MovieAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return MovieAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool WidgetAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWidgetAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapWidgetAnnotationDictionary(*pdfDoc, *value, (SkPdfWidgetAnnotationDictionary**)data);
+}
+
+bool WidgetAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWidgetAnnotationDictionary** data) {
+  if (WidgetAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return WidgetAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfActionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapActionDictionary(*pdfDoc, *value, (SkPdfActionDictionary**)data);
+}
+
+bool ActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfActionDictionary** data) {
+  if (ActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool AnnotationActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAnnotationActionsDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapAnnotationActionsDictionary(*pdfDoc, *value, (SkPdfAnnotationActionsDictionary**)data);
+}
+
+bool AnnotationActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAnnotationActionsDictionary** data) {
+  if (AnnotationActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return AnnotationActionsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool PageObjectActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageObjectActionsDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapPageObjectActionsDictionary(*pdfDoc, *value, (SkPdfPageObjectActionsDictionary**)data);
+}
+
+bool PageObjectActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageObjectActionsDictionary** data) {
+  if (PageObjectActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return PageObjectActionsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FormFieldActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFormFieldActionsDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFormFieldActionsDictionary(*pdfDoc, *value, (SkPdfFormFieldActionsDictionary**)data);
+}
+
+bool FormFieldActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFormFieldActionsDictionary** data) {
+  if (FormFieldActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FormFieldActionsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isDocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool DocumentCatalogActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDocumentCatalogActionsDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapDocumentCatalogActionsDictionary(*pdfDoc, *value, (SkPdfDocumentCatalogActionsDictionary**)data);
+}
+
+bool DocumentCatalogActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDocumentCatalogActionsDictionary** data) {
+  if (DocumentCatalogActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return DocumentCatalogActionsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool GoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfGoToActionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapGoToActionDictionary(*pdfDoc, *value, (SkPdfGoToActionDictionary**)data);
+}
+
+bool GoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfGoToActionDictionary** data) {
+  if (GoToActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return GoToActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isRemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool RemoteGoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfRemoteGoToActionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapRemoteGoToActionDictionary(*pdfDoc, *value, (SkPdfRemoteGoToActionDictionary**)data);
+}
+
+bool RemoteGoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfRemoteGoToActionDictionary** data) {
+  if (RemoteGoToActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return RemoteGoToActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool LaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLaunchActionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapLaunchActionDictionary(*pdfDoc, *value, (SkPdfLaunchActionDictionary**)data);
+}
+
+bool LaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLaunchActionDictionary** data) {
+  if (LaunchActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return LaunchActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool WindowsLaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWindowsLaunchActionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapWindowsLaunchActionDictionary(*pdfDoc, *value, (SkPdfWindowsLaunchActionDictionary**)data);
+}
+
+bool WindowsLaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWindowsLaunchActionDictionary** data) {
+  if (WindowsLaunchActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return WindowsLaunchActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isThreadActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ThreadActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfThreadActionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapThreadActionDictionary(*pdfDoc, *value, (SkPdfThreadActionDictionary**)data);
+}
+
+bool ThreadActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfThreadActionDictionary** data) {
+  if (ThreadActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ThreadActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool URIActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfURIActionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapURIActionDictionary(*pdfDoc, *value, (SkPdfURIActionDictionary**)data);
+}
+
+bool URIActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfURIActionDictionary** data) {
+  if (URIActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return URIActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool URIDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfURIDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapURIDictionary(*pdfDoc, *value, (SkPdfURIDictionary**)data);
+}
+
+bool URIDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfURIDictionary** data) {
+  if (URIDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return URIDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSoundActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool SoundActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoundActionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapSoundActionDictionary(*pdfDoc, *value, (SkPdfSoundActionDictionary**)data);
+}
+
+bool SoundActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoundActionDictionary** data) {
+  if (SoundActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return SoundActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMovieActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool MovieActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieActionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapMovieActionDictionary(*pdfDoc, *value, (SkPdfMovieActionDictionary**)data);
+}
+
+bool MovieActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieActionDictionary** data) {
+  if (MovieActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return MovieActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool HideActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfHideActionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapHideActionDictionary(*pdfDoc, *value, (SkPdfHideActionDictionary**)data);
+}
+
+bool HideActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfHideActionDictionary** data) {
+  if (HideActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return HideActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isNamedActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool NamedActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNamedActionsDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapNamedActionsDictionary(*pdfDoc, *value, (SkPdfNamedActionsDictionary**)data);
+}
+
+bool NamedActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNamedActionsDictionary** data) {
+  if (NamedActionsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return NamedActionsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool InteractiveFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInteractiveFormDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapInteractiveFormDictionary(*pdfDoc, *value, (SkPdfInteractiveFormDictionary**)data);
+}
+
+bool InteractiveFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInteractiveFormDictionary** data) {
+  if (InteractiveFormDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return InteractiveFormDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFieldDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFieldDictionary(*pdfDoc, *value, (SkPdfFieldDictionary**)data);
+}
+
+bool FieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFieldDictionary** data) {
+  if (FieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FieldDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool VariableTextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfVariableTextFieldDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapVariableTextFieldDictionary(*pdfDoc, *value, (SkPdfVariableTextFieldDictionary**)data);
+}
+
+bool VariableTextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfVariableTextFieldDictionary** data) {
+  if (VariableTextFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return VariableTextFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isAppearanceCharacteristicsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool AppearanceCharacteristicsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAppearanceCharacteristicsDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapAppearanceCharacteristicsDictionary(*pdfDoc, *value, (SkPdfAppearanceCharacteristicsDictionary**)data);
+}
+
+bool AppearanceCharacteristicsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAppearanceCharacteristicsDictionary** data) {
+  if (AppearanceCharacteristicsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return AppearanceCharacteristicsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isCheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool CheckboxFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCheckboxFieldDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapCheckboxFieldDictionary(*pdfDoc, *value, (SkPdfCheckboxFieldDictionary**)data);
+}
+
+bool CheckboxFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCheckboxFieldDictionary** data) {
+  if (CheckboxFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return CheckboxFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isRadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool RadioButtonFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfRadioButtonFieldDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapRadioButtonFieldDictionary(*pdfDoc, *value, (SkPdfRadioButtonFieldDictionary**)data);
+}
+
+bool RadioButtonFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfRadioButtonFieldDictionary** data) {
+  if (RadioButtonFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return RadioButtonFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool TextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTextFieldDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapTextFieldDictionary(*pdfDoc, *value, (SkPdfTextFieldDictionary**)data);
+}
+
+bool TextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTextFieldDictionary** data) {
+  if (TextFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return TextFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ChoiceFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfChoiceFieldDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapChoiceFieldDictionary(*pdfDoc, *value, (SkPdfChoiceFieldDictionary**)data);
+}
+
+bool ChoiceFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfChoiceFieldDictionary** data) {
+  if (ChoiceFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ChoiceFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSignatureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool SignatureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSignatureDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapSignatureDictionary(*pdfDoc, *value, (SkPdfSignatureDictionary**)data);
+}
+
+bool SignatureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSignatureDictionary** data) {
+  if (SignatureDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return SignatureDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSubmitFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool SubmitFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSubmitFormActionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapSubmitFormActionDictionary(*pdfDoc, *value, (SkPdfSubmitFormActionDictionary**)data);
+}
+
+bool SubmitFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSubmitFormActionDictionary** data) {
+  if (SubmitFormActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return SubmitFormActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isResetFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ResetFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfResetFormActionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapResetFormActionDictionary(*pdfDoc, *value, (SkPdfResetFormActionDictionary**)data);
+}
+
+bool ResetFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfResetFormActionDictionary** data) {
+  if (ResetFormActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ResetFormActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isImportDataActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ImportDataActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfImportDataActionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapImportDataActionDictionary(*pdfDoc, *value, (SkPdfImportDataActionDictionary**)data);
+}
+
+bool ImportDataActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfImportDataActionDictionary** data) {
+  if (ImportDataActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ImportDataActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isJavascriptActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool JavascriptActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfJavascriptActionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapJavascriptActionDictionary(*pdfDoc, *value, (SkPdfJavascriptActionDictionary**)data);
+}
+
+bool JavascriptActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfJavascriptActionDictionary** data) {
+  if (JavascriptActionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return JavascriptActionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FDFTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFTrailerDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFDFTrailerDictionary(*pdfDoc, *value, (SkPdfFDFTrailerDictionary**)data);
+}
+
+bool FDFTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFTrailerDictionary** data) {
+  if (FDFTrailerDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FDFTrailerDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FDFCatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFCatalogDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFDFCatalogDictionary(*pdfDoc, *value, (SkPdfFDFCatalogDictionary**)data);
+}
+
+bool FDFCatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFCatalogDictionary** data) {
+  if (FDFCatalogDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FDFCatalogDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FDFDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFDFDictionary(*pdfDoc, *value, (SkPdfFDFDictionary**)data);
+}
+
+bool FDFDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFDictionary** data) {
+  if (FDFDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FDFDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool EncryptedEmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEncryptedEmbeddedFileStreamDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapEncryptedEmbeddedFileStreamDictionary(*pdfDoc, *value, (SkPdfEncryptedEmbeddedFileStreamDictionary**)data);
+}
+
+bool EncryptedEmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEncryptedEmbeddedFileStreamDictionary** data) {
+  if (EncryptedEmbeddedFileStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return EncryptedEmbeddedFileStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool JavascriptDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfJavascriptDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapJavascriptDictionary(*pdfDoc, *value, (SkPdfJavascriptDictionary**)data);
+}
+
+bool JavascriptDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfJavascriptDictionary** data) {
+  if (JavascriptDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return JavascriptDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FDFFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFFieldDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFDFFieldDictionary(*pdfDoc, *value, (SkPdfFDFFieldDictionary**)data);
+}
+
+bool FDFFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFFieldDictionary** data) {
+  if (FDFFieldDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FDFFieldDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool IconFitDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfIconFitDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapIconFitDictionary(*pdfDoc, *value, (SkPdfIconFitDictionary**)data);
+}
+
+bool IconFitDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfIconFitDictionary** data) {
+  if (IconFitDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return IconFitDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FDFPageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFPageDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFDFPageDictionary(*pdfDoc, *value, (SkPdfFDFPageDictionary**)data);
+}
+
+bool FDFPageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFPageDictionary** data) {
+  if (FDFPageDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FDFPageDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FDFTemplateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFTemplateDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFDFTemplateDictionary(*pdfDoc, *value, (SkPdfFDFTemplateDictionary**)data);
+}
+
+bool FDFTemplateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFTemplateDictionary** data) {
+  if (FDFTemplateDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FDFTemplateDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FDFNamedPageReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFNamedPageReferenceDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFDFNamedPageReferenceDictionary(*pdfDoc, *value, (SkPdfFDFNamedPageReferenceDictionary**)data);
+}
+
+bool FDFNamedPageReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFNamedPageReferenceDictionary** data) {
+  if (FDFNamedPageReferenceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FDFNamedPageReferenceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool FDFFileAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFFileAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapFDFFileAnnotationDictionary(*pdfDoc, *value, (SkPdfFDFFileAnnotationDictionary**)data);
+}
+
+bool FDFFileAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFFileAnnotationDictionary** data) {
+  if (FDFFileAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return FDFFileAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSoundObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool SoundObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoundObjectDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapSoundObjectDictionary(*pdfDoc, *value, (SkPdfSoundObjectDictionary**)data);
+}
+
+bool SoundObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoundObjectDictionary** data) {
+  if (SoundObjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return SoundObjectDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool MovieDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapMovieDictionary(*pdfDoc, *value, (SkPdfMovieDictionary**)data);
+}
+
+bool MovieDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieDictionary** data) {
+  if (MovieDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return MovieDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMovieActivationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool MovieActivationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieActivationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapMovieActivationDictionary(*pdfDoc, *value, (SkPdfMovieActivationDictionary**)data);
+}
+
+bool MovieActivationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieActivationDictionary** data) {
+  if (MovieActivationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return MovieActivationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isDocumentInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool DocumentInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDocumentInformationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapDocumentInformationDictionary(*pdfDoc, *value, (SkPdfDocumentInformationDictionary**)data);
+}
+
+bool DocumentInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDocumentInformationDictionary** data) {
+  if (DocumentInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return DocumentInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool MetadataStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMetadataStreamDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapMetadataStreamDictionary(*pdfDoc, *value, (SkPdfMetadataStreamDictionary**)data);
+}
+
+bool MetadataStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMetadataStreamDictionary** data) {
+  if (MetadataStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return MetadataStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ComponentsWithMetadataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfComponentsWithMetadataDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapComponentsWithMetadataDictionary(*pdfDoc, *value, (SkPdfComponentsWithMetadataDictionary**)data);
+}
+
+bool ComponentsWithMetadataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfComponentsWithMetadataDictionary** data) {
+  if (ComponentsWithMetadataDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ComponentsWithMetadataDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool PagePieceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPagePieceDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapPagePieceDictionary(*pdfDoc, *value, (SkPdfPagePieceDictionary**)data);
+}
+
+bool PagePieceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPagePieceDictionary** data) {
+  if (PagePieceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return PagePieceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isApplicationDataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ApplicationDataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfApplicationDataDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapApplicationDataDictionary(*pdfDoc, *value, (SkPdfApplicationDataDictionary**)data);
+}
+
+bool ApplicationDataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfApplicationDataDictionary** data) {
+  if (ApplicationDataDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ApplicationDataDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool StructureTreeRootDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStructureTreeRootDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapStructureTreeRootDictionary(*pdfDoc, *value, (SkPdfStructureTreeRootDictionary**)data);
+}
+
+bool StructureTreeRootDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureTreeRootDictionary** data) {
+  if (StructureTreeRootDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return StructureTreeRootDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isStructureElementDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool StructureElementDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStructureElementDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapStructureElementDictionary(*pdfDoc, *value, (SkPdfStructureElementDictionary**)data);
+}
+
+bool StructureElementDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureElementDictionary** data) {
+  if (StructureElementDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return StructureElementDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool MarkedContentReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMarkedContentReferenceDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapMarkedContentReferenceDictionary(*pdfDoc, *value, (SkPdfMarkedContentReferenceDictionary**)data);
+}
+
+bool MarkedContentReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkedContentReferenceDictionary** data) {
+  if (MarkedContentReferenceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return MarkedContentReferenceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ObjectReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfObjectReferenceDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapObjectReferenceDictionary(*pdfDoc, *value, (SkPdfObjectReferenceDictionary**)data);
+}
+
+bool ObjectReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfObjectReferenceDictionary** data) {
+  if (ObjectReferenceDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ObjectReferenceDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isStructureElementAccessDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool StructureElementAccessDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStructureElementAccessDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapStructureElementAccessDictionary(*pdfDoc, *value, (SkPdfStructureElementAccessDictionary**)data);
+}
+
+bool StructureElementAccessDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureElementAccessDictionary** data) {
+  if (StructureElementAccessDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return StructureElementAccessDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool AttributeObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAttributeObjectDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapAttributeObjectDictionary(*pdfDoc, *value, (SkPdfAttributeObjectDictionary**)data);
+}
+
+bool AttributeObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAttributeObjectDictionary** data) {
+  if (AttributeObjectDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return AttributeObjectDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMarkInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool MarkInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMarkInformationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapMarkInformationDictionary(*pdfDoc, *value, (SkPdfMarkInformationDictionary**)data);
+}
+
+bool MarkInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkInformationDictionary** data) {
+  if (MarkInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return MarkInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ArtifactsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfArtifactsDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapArtifactsDictionary(*pdfDoc, *value, (SkPdfArtifactsDictionary**)data);
+}
+
+bool ArtifactsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfArtifactsDictionary** data) {
+  if (ArtifactsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ArtifactsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isStandardStructureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool StandardStructureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStandardStructureDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapStandardStructureDictionary(*pdfDoc, *value, (SkPdfStandardStructureDictionary**)data);
+}
+
+bool StandardStructureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStandardStructureDictionary** data) {
+  if (StandardStructureDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return StandardStructureDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isBlockLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool BlockLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBlockLevelStructureElementsDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapBlockLevelStructureElementsDictionary(*pdfDoc, *value, (SkPdfBlockLevelStructureElementsDictionary**)data);
+}
+
+bool BlockLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBlockLevelStructureElementsDictionary** data) {
+  if (BlockLevelStructureElementsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return BlockLevelStructureElementsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isInlineLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool InlineLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInlineLevelStructureElementsDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapInlineLevelStructureElementsDictionary(*pdfDoc, *value, (SkPdfInlineLevelStructureElementsDictionary**)data);
+}
+
+bool InlineLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInlineLevelStructureElementsDictionary** data) {
+  if (InlineLevelStructureElementsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return InlineLevelStructureElementsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isListAttributeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool ListAttributeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfListAttributeDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapListAttributeDictionary(*pdfDoc, *value, (SkPdfListAttributeDictionary**)data);
+}
+
+bool ListAttributeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfListAttributeDictionary** data) {
+  if (ListAttributeDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return ListAttributeDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTableAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool TableAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTableAttributesDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapTableAttributesDictionary(*pdfDoc, *value, (SkPdfTableAttributesDictionary**)data);
+}
+
+bool TableAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTableAttributesDictionary** data) {
+  if (TableAttributesDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return TableAttributesDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool WebCaptureInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureInformationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapWebCaptureInformationDictionary(*pdfDoc, *value, (SkPdfWebCaptureInformationDictionary**)data);
+}
+
+bool WebCaptureInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureInformationDictionary** data) {
+  if (WebCaptureInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return WebCaptureInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool WebCaptureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapWebCaptureDictionary(*pdfDoc, *value, (SkPdfWebCaptureDictionary**)data);
+}
+
+bool WebCaptureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureDictionary** data) {
+  if (WebCaptureDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return WebCaptureDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool WebCapturePageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCapturePageSetDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapWebCapturePageSetDictionary(*pdfDoc, *value, (SkPdfWebCapturePageSetDictionary**)data);
+}
+
+bool WebCapturePageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCapturePageSetDictionary** data) {
+  if (WebCapturePageSetDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return WebCapturePageSetDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool WebCaptureImageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureImageSetDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapWebCaptureImageSetDictionary(*pdfDoc, *value, (SkPdfWebCaptureImageSetDictionary**)data);
+}
+
+bool WebCaptureImageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureImageSetDictionary** data) {
+  if (WebCaptureImageSetDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return WebCaptureImageSetDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSourceInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool SourceInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSourceInformationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapSourceInformationDictionary(*pdfDoc, *value, (SkPdfSourceInformationDictionary**)data);
+}
+
+bool SourceInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSourceInformationDictionary** data) {
+  if (SourceInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return SourceInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool URLAliasDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfURLAliasDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapURLAliasDictionary(*pdfDoc, *value, (SkPdfURLAliasDictionary**)data);
+}
+
+bool URLAliasDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfURLAliasDictionary** data) {
+  if (URLAliasDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return URLAliasDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool WebCaptureCommandDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureCommandDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapWebCaptureCommandDictionary(*pdfDoc, *value, (SkPdfWebCaptureCommandDictionary**)data);
+}
+
+bool WebCaptureCommandDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureCommandDictionary** data) {
+  if (WebCaptureCommandDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return WebCaptureCommandDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool WebCaptureCommandSettingsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureCommandSettingsDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapWebCaptureCommandSettingsDictionary(*pdfDoc, *value, (SkPdfWebCaptureCommandSettingsDictionary**)data);
+}
+
+bool WebCaptureCommandSettingsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureCommandSettingsDictionary** data) {
+  if (WebCaptureCommandSettingsDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return WebCaptureCommandSettingsDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isBoxColorInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool BoxColorInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBoxColorInformationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapBoxColorInformationDictionary(*pdfDoc, *value, (SkPdfBoxColorInformationDictionary**)data);
+}
+
+bool BoxColorInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBoxColorInformationDictionary** data) {
+  if (BoxColorInformationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return BoxColorInformationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isBoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool BoxStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBoxStyleDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapBoxStyleDictionary(*pdfDoc, *value, (SkPdfBoxStyleDictionary**)data);
+}
+
+bool BoxStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBoxStyleDictionary** data) {
+  if (BoxStyleDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return BoxStyleDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool PrinterMarkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPrinterMarkAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapPrinterMarkAnnotationDictionary(*pdfDoc, *value, (SkPdfPrinterMarkAnnotationDictionary**)data);
+}
+
+bool PrinterMarkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPrinterMarkAnnotationDictionary** data) {
+  if (PrinterMarkAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return PrinterMarkAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool PrinterMarkFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPrinterMarkFormDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapPrinterMarkFormDictionary(*pdfDoc, *value, (SkPdfPrinterMarkFormDictionary**)data);
+}
+
+bool PrinterMarkFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPrinterMarkFormDictionary** data) {
+  if (PrinterMarkFormDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return PrinterMarkFormDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isSeparationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool SeparationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSeparationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapSeparationDictionary(*pdfDoc, *value, (SkPdfSeparationDictionary**)data);
+}
+
+bool SeparationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSeparationDictionary** data) {
+  if (SeparationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return SeparationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool PDF_XOutputIntentDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPDF_XOutputIntentDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapPDF_XOutputIntentDictionary(*pdfDoc, *value, (SkPdfPDF_XOutputIntentDictionary**)data);
+}
+
+bool PDF_XOutputIntentDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPDF_XOutputIntentDictionary** data) {
+  if (PDF_XOutputIntentDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return PDF_XOutputIntentDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool TrapNetworkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTrapNetworkAnnotationDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapTrapNetworkAnnotationDictionary(*pdfDoc, *value, (SkPdfTrapNetworkAnnotationDictionary**)data);
+}
+
+bool TrapNetworkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTrapNetworkAnnotationDictionary** data) {
+  if (TrapNetworkAnnotationDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return TrapNetworkAnnotationDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isTrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool TrapNetworkAppearanceStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTrapNetworkAppearanceStreamDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapTrapNetworkAppearanceStreamDictionary(*pdfDoc, *value, (SkPdfTrapNetworkAppearanceStreamDictionary**)data);
+}
+
+bool TrapNetworkAppearanceStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTrapNetworkAppearanceStreamDictionary** data) {
+  if (TrapNetworkAppearanceStreamDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return TrapNetworkAppearanceStreamDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  return true;
+}
+
+bool OpiVersionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfOpiVersionDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapOpiVersionDictionary(*pdfDoc, *value, (SkPdfOpiVersionDictionary**)data);
+}
+
+bool OpiVersionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfOpiVersionDictionary** data) {
+  if (OpiVersionDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return OpiVersionDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool isMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
+  std::string Subtype;
+  if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
+  if ((Subtype != "MMType1")) return false;
+
+  return true;
+}
+
+bool MultiMasterFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMultiMasterFontDictionary** data) {
+  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);
+  if (value == NULL) { return false; }
+  if (data == NULL) { return true; }
+  return mapMultiMasterFontDictionary(*pdfDoc, *value, (SkPdfMultiMasterFontDictionary**)data);
+}
+
+bool MultiMasterFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMultiMasterFontDictionary** data) {
+  if (MultiMasterFontDictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+  if (abr == NULL || *abr == '\0') return false;
+  return MultiMasterFontDictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.h b/experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.h
index f4c52b4..c611eb8 100644
--- a/experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.h
@@ -2,3082 +2,900 @@
 #define __DEFINED__SkPdfPodofoMapper
 
 #include "SkPdfHeaders_autogen.h"
-class PodofoMapper {
-public:
-  static bool map(const SkPdfObject& in, SkPdfObject** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out) {
-    if (!isObject(podofoDoc, podofoObj)) return false;
-
-    if (map(podofoDoc, podofoObj, (SkPdfArray**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfBoolean**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfInteger**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfName**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfNull**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfReference**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfString**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfStream**)out)) return true;
-
-    *out = new SkPdfObject(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfNull** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNull** out) {
-    if (!isNull(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfNull(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfBoolean** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoolean** out) {
-    if (!isBoolean(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfBoolean(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfInteger** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInteger** out) {
-    if (!isInteger(podofoDoc, podofoObj)) return false;
-
-    if (map(podofoDoc, podofoObj, (SkPdfNumber**)out)) return true;
-
-    *out = new SkPdfInteger(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfNumber** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNumber** out) {
-    if (!isNumber(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfNumber(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfName** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfName** out) {
-    if (!isName(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfName(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfReference** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfReference** out) {
-    if (!isReference(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfReference(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfArray** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfArray** out) {
-    if (!isArray(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfArray(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfString** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfString** out) {
-    if (!isString(podofoDoc, podofoObj)) return false;
-
-    if (map(podofoDoc, podofoObj, (SkPdfHexString**)out)) return true;
-
-    *out = new SkPdfString(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfHexString** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfHexString** out) {
-    if (!isHexString(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfHexString(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDictionary** out) {
-    if (!isDictionary(podofoDoc, podofoObj)) return false;
-
-    if (map(podofoDoc, podofoObj, (SkPdfALinkAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfActionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfAlternateImageDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfAnnotationActionsDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfAppearanceCharacteristicsDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfAppearanceDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfApplicationDataDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfArtifactsDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfAttributeObjectDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfBeadDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfBlockLevelStructureElementsDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfBorderStyleDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfBoxColorInformationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfBoxStyleDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfCIDFontDescriptorDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfCIDSystemInfoDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfCMapDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfCalgrayColorSpaceDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfCalrgbColorSpaceDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfCatalogDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfCcittfaxdecodeFilterDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfCheckboxFieldDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfChoiceFieldDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfComponentsWithMetadataDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfDctdecodeFilterDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfDeviceNColorSpaceDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfDocumentCatalogActionsDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfDocumentInformationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfEmbeddedFileParameterDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfEmbeddedFileStreamDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfEmbeddedFontStreamDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfEncodingDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfEncryptedEmbeddedFileStreamDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfEncryptionCommonDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFDFCatalogDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFDFDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFDFFieldDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFDFFileAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFDFNamedPageReferenceDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFDFPageDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFDFTemplateDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFDFTrailerDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFieldDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFileAttachmentAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFileSpecificationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFileTrailerDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFontDescriptorDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFontDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFormFieldActionsDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFreeTextAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfFunctionCommonDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfGoToActionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfGraphicsStateDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfGroupAttributesDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfHideActionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfIccProfileStreamDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfIconFitDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfImportDataActionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfInkAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfInlineLevelStructureElementsDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfInteractiveFormDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfJavascriptActionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfJavascriptDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfJbig2DecodeFilterDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfLabColorSpaceDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfLaunchActionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfLineAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfListAttributeDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfLzwdecodeAndFlatedecodeFiltersDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfMacOsFileInformationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfMarkInformationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfMarkedContentReferenceDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfMarkupAnnotationsDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfMetadataStreamDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfMovieActionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfMovieActivationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfMovieAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfMovieDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfNameDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfNameTreeNodeDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfNamedActionsDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfNumberTreeNodeDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfObjectReferenceDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfOpiVersionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfOutlineDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfOutlineItemDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfPDF_XOutputIntentDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfPSXobjectDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfPageLabelDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfPageObjectActionsDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfPageObjectDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfPagePieceDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfPageTreeNodeDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfPopUpAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfPrinterMarkAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfPrinterMarkFormDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfRadioButtonFieldDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfReferenceDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfRemoteGoToActionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfResetFormActionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfResourceDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfRubberStampAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfSeparationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfShadingDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfSignatureDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfSoftMaskDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfSoftMaskImageDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfSoundActionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfSoundAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfSoundObjectDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfSourceInformationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfSquareOrCircleAnnotation**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfStandardSecurityHandlerDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfStandardStructureDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfStreamCommonDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfStructureElementAccessDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfStructureElementDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfStructureTreeRootDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfSubmitFormActionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfTableAttributesDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfTextAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfTextFieldDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfThreadActionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfThreadDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfTransitionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfTransparencyGroupDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfTrapNetworkAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfTrapNetworkAppearanceStreamDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType0FunctionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType10HalftoneDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType16HalftoneDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType1HalftoneDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType1PatternDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType2FunctionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType2PatternDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType3FunctionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType5HalftoneDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType6HalftoneDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfURIActionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfURIDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfURLAliasDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfVariableTextFieldDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfViewerPreferencesDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfWebCaptureCommandDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfWebCaptureCommandSettingsDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfWebCaptureDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfWebCaptureImageSetDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfWebCaptureInformationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfWebCapturePageSetDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfWidgetAnnotationDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfWindowsLaunchActionDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfXObjectDictionary**)out)) return true;
-
-    *out = new SkPdfDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfStream** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStream** out) {
-    if (!isStream(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfStream(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfXObjectDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfXObjectDictionary** out) {
-    if (!isXObjectDictionary(podofoDoc, podofoObj)) return false;
-
-    if (map(podofoDoc, podofoObj, (SkPdfImageDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType1FormDictionary**)out)) return true;
-
-    *out = new SkPdfXObjectDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFontDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFontDictionary** out) {
-    if (!isFontDictionary(podofoDoc, podofoObj)) return false;
-
-    if (map(podofoDoc, podofoObj, (SkPdfCIDFontDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType0FontDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType1FontDictionary**)out)) return true;
-
-    *out = new SkPdfFontDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfTrueTypeFontDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrueTypeFontDictionary** out) {
-    if (!isTrueTypeFontDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfTrueTypeFontDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfStreamCommonDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStreamCommonDictionary** out) {
-    if (!isStreamCommonDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfStreamCommonDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** out) {
-    if (!isLzwdecodeAndFlatedecodeFiltersDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfLzwdecodeAndFlatedecodeFiltersDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfCcittfaxdecodeFilterDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCcittfaxdecodeFilterDictionary** out) {
-    if (!isCcittfaxdecodeFilterDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfCcittfaxdecodeFilterDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfJbig2DecodeFilterDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJbig2DecodeFilterDictionary** out) {
-    if (!isJbig2DecodeFilterDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfJbig2DecodeFilterDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfDctdecodeFilterDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDctdecodeFilterDictionary** out) {
-    if (!isDctdecodeFilterDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfDctdecodeFilterDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFileTrailerDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileTrailerDictionary** out) {
-    if (!isFileTrailerDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFileTrailerDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfEncryptionCommonDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncryptionCommonDictionary** out) {
-    if (!isEncryptionCommonDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfEncryptionCommonDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfStandardSecurityHandlerDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardSecurityHandlerDictionary** out) {
-    if (!isStandardSecurityHandlerDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfStandardSecurityHandlerDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfCatalogDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCatalogDictionary** out) {
-    if (!isCatalogDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfCatalogDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfPageTreeNodeDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageTreeNodeDictionary** out) {
-    if (!isPageTreeNodeDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfPageTreeNodeDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfPageObjectDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageObjectDictionary** out) {
-    if (!isPageObjectDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfPageObjectDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfNameDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameDictionary** out) {
-    if (!isNameDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfNameDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfResourceDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfResourceDictionary** out) {
-    if (!isResourceDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfResourceDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfNameTreeNodeDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameTreeNodeDictionary** out) {
-    if (!isNameTreeNodeDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfNameTreeNodeDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfNumberTreeNodeDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNumberTreeNodeDictionary** out) {
-    if (!isNumberTreeNodeDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfNumberTreeNodeDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFunctionCommonDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFunctionCommonDictionary** out) {
-    if (!isFunctionCommonDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFunctionCommonDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType0FunctionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType0FunctionDictionary** out) {
-    if (!isType0FunctionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType0FunctionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType2FunctionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2FunctionDictionary** out) {
-    if (!isType2FunctionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType2FunctionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType3FunctionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3FunctionDictionary** out) {
-    if (!isType3FunctionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType3FunctionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFileSpecificationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileSpecificationDictionary** out) {
-    if (!isFileSpecificationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFileSpecificationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfEmbeddedFileStreamDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFileStreamDictionary** out) {
-    if (!isEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfEmbeddedFileStreamDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfEmbeddedFileParameterDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFileParameterDictionary** out) {
-    if (!isEmbeddedFileParameterDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfEmbeddedFileParameterDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfMacOsFileInformationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMacOsFileInformationDictionary** out) {
-    if (!isMacOsFileInformationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfMacOsFileInformationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfGraphicsStateDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGraphicsStateDictionary** out) {
-    if (!isGraphicsStateDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfGraphicsStateDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfCalgrayColorSpaceDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCalgrayColorSpaceDictionary** out) {
-    if (!isCalgrayColorSpaceDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfCalgrayColorSpaceDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfCalrgbColorSpaceDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCalrgbColorSpaceDictionary** out) {
-    if (!isCalrgbColorSpaceDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfCalrgbColorSpaceDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfLabColorSpaceDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLabColorSpaceDictionary** out) {
-    if (!isLabColorSpaceDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfLabColorSpaceDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfIccProfileStreamDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfIccProfileStreamDictionary** out) {
-    if (!isIccProfileStreamDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfIccProfileStreamDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfDeviceNColorSpaceDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDeviceNColorSpaceDictionary** out) {
-    if (!isDeviceNColorSpaceDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfDeviceNColorSpaceDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType1PatternDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1PatternDictionary** out) {
-    if (!isType1PatternDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType1PatternDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType2PatternDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2PatternDictionary** out) {
-    if (!isType2PatternDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType2PatternDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfShadingDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfShadingDictionary** out) {
-    if (!isShadingDictionary(podofoDoc, podofoObj)) return false;
-
-    if (map(podofoDoc, podofoObj, (SkPdfType1ShadingDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType2ShadingDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType3ShadingDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType4ShadingDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType5ShadingDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType6ShadingDictionary**)out)) return true;
-
-    *out = new SkPdfShadingDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType1ShadingDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1ShadingDictionary** out) {
-    if (!isType1ShadingDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType1ShadingDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType2ShadingDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2ShadingDictionary** out) {
-    if (!isType2ShadingDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType2ShadingDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType3ShadingDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3ShadingDictionary** out) {
-    if (!isType3ShadingDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType3ShadingDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType4ShadingDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType4ShadingDictionary** out) {
-    if (!isType4ShadingDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType4ShadingDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType5ShadingDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5ShadingDictionary** out) {
-    if (!isType5ShadingDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType5ShadingDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType6ShadingDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6ShadingDictionary** out) {
-    if (!isType6ShadingDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType6ShadingDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfImageDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfImageDictionary** out) {
-    if (!isImageDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfImageDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfAlternateImageDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAlternateImageDictionary** out) {
-    if (!isAlternateImageDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfAlternateImageDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType1FormDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1FormDictionary** out) {
-    if (!isType1FormDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType1FormDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfGroupAttributesDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGroupAttributesDictionary** out) {
-    if (!isGroupAttributesDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfGroupAttributesDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfReferenceDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfReferenceDictionary** out) {
-    if (!isReferenceDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfReferenceDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfPSXobjectDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPSXobjectDictionary** out) {
-    if (!isPSXobjectDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfPSXobjectDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType1FontDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1FontDictionary** out) {
-    if (!isType1FontDictionary(podofoDoc, podofoObj)) return false;
-
-    if (map(podofoDoc, podofoObj, (SkPdfMultiMasterFontDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfTrueTypeFontDictionary**)out)) return true;
-    if (map(podofoDoc, podofoObj, (SkPdfType3FontDictionary**)out)) return true;
-
-    *out = new SkPdfType1FontDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType3FontDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3FontDictionary** out) {
-    if (!isType3FontDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType3FontDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfEncodingDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncodingDictionary** out) {
-    if (!isEncodingDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfEncodingDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfCIDSystemInfoDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDSystemInfoDictionary** out) {
-    if (!isCIDSystemInfoDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfCIDSystemInfoDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfCIDFontDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDFontDictionary** out) {
-    if (!isCIDFontDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfCIDFontDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfCMapDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCMapDictionary** out) {
-    if (!isCMapDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfCMapDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType0FontDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType0FontDictionary** out) {
-    if (!isType0FontDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType0FontDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFontDescriptorDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFontDescriptorDictionary** out) {
-    if (!isFontDescriptorDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFontDescriptorDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfCIDFontDescriptorDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDFontDescriptorDictionary** out) {
-    if (!isCIDFontDescriptorDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfCIDFontDescriptorDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfEmbeddedFontStreamDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFontStreamDictionary** out) {
-    if (!isEmbeddedFontStreamDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfEmbeddedFontStreamDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType1HalftoneDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1HalftoneDictionary** out) {
-    if (!isType1HalftoneDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType1HalftoneDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType6HalftoneDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6HalftoneDictionary** out) {
-    if (!isType6HalftoneDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType6HalftoneDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType10HalftoneDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType10HalftoneDictionary** out) {
-    if (!isType10HalftoneDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType10HalftoneDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType16HalftoneDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType16HalftoneDictionary** out) {
-    if (!isType16HalftoneDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType16HalftoneDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfType5HalftoneDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5HalftoneDictionary** out) {
-    if (!isType5HalftoneDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfType5HalftoneDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfSoftMaskDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoftMaskDictionary** out) {
-    if (!isSoftMaskDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfSoftMaskDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfSoftMaskImageDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoftMaskImageDictionary** out) {
-    if (!isSoftMaskImageDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfSoftMaskImageDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfTransparencyGroupDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTransparencyGroupDictionary** out) {
-    if (!isTransparencyGroupDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfTransparencyGroupDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfViewerPreferencesDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfViewerPreferencesDictionary** out) {
-    if (!isViewerPreferencesDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfViewerPreferencesDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfOutlineDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineDictionary** out) {
-    if (!isOutlineDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfOutlineDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfOutlineItemDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineItemDictionary** out) {
-    if (!isOutlineItemDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfOutlineItemDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfPageLabelDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageLabelDictionary** out) {
-    if (!isPageLabelDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfPageLabelDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfThreadDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadDictionary** out) {
-    if (!isThreadDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfThreadDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfBeadDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBeadDictionary** out) {
-    if (!isBeadDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfBeadDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfTransitionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTransitionDictionary** out) {
-    if (!isTransitionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfTransitionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAnnotationDictionary** out) {
-    if (!isAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfBorderStyleDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBorderStyleDictionary** out) {
-    if (!isBorderStyleDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfBorderStyleDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfAppearanceDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAppearanceDictionary** out) {
-    if (!isAppearanceDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfAppearanceDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfTextAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTextAnnotationDictionary** out) {
-    if (!isTextAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfTextAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfALinkAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfALinkAnnotationDictionary** out) {
-    if (!isALinkAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfALinkAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFreeTextAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFreeTextAnnotationDictionary** out) {
-    if (!isFreeTextAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFreeTextAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfLineAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLineAnnotationDictionary** out) {
-    if (!isLineAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfLineAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfSquareOrCircleAnnotation** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSquareOrCircleAnnotation** out) {
-    if (!isSquareOrCircleAnnotation(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfSquareOrCircleAnnotation(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfMarkupAnnotationsDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkupAnnotationsDictionary** out) {
-    if (!isMarkupAnnotationsDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfMarkupAnnotationsDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfRubberStampAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRubberStampAnnotationDictionary** out) {
-    if (!isRubberStampAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfRubberStampAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfInkAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInkAnnotationDictionary** out) {
-    if (!isInkAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfInkAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfPopUpAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPopUpAnnotationDictionary** out) {
-    if (!isPopUpAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfPopUpAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFileAttachmentAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileAttachmentAnnotationDictionary** out) {
-    if (!isFileAttachmentAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFileAttachmentAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfSoundAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundAnnotationDictionary** out) {
-    if (!isSoundAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfSoundAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfMovieAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieAnnotationDictionary** out) {
-    if (!isMovieAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfMovieAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfWidgetAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWidgetAnnotationDictionary** out) {
-    if (!isWidgetAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfWidgetAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfActionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfActionDictionary** out) {
-    if (!isActionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfActionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfAnnotationActionsDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAnnotationActionsDictionary** out) {
-    if (!isAnnotationActionsDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfAnnotationActionsDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfPageObjectActionsDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageObjectActionsDictionary** out) {
-    if (!isPageObjectActionsDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfPageObjectActionsDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFormFieldActionsDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFormFieldActionsDictionary** out) {
-    if (!isFormFieldActionsDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFormFieldActionsDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfDocumentCatalogActionsDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentCatalogActionsDictionary** out) {
-    if (!isDocumentCatalogActionsDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfDocumentCatalogActionsDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfGoToActionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGoToActionDictionary** out) {
-    if (!isGoToActionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfGoToActionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfRemoteGoToActionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRemoteGoToActionDictionary** out) {
-    if (!isRemoteGoToActionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfRemoteGoToActionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfLaunchActionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLaunchActionDictionary** out) {
-    if (!isLaunchActionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfLaunchActionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfWindowsLaunchActionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWindowsLaunchActionDictionary** out) {
-    if (!isWindowsLaunchActionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfWindowsLaunchActionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfThreadActionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadActionDictionary** out) {
-    if (!isThreadActionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfThreadActionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfURIActionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURIActionDictionary** out) {
-    if (!isURIActionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfURIActionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfURIDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURIDictionary** out) {
-    if (!isURIDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfURIDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfSoundActionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundActionDictionary** out) {
-    if (!isSoundActionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfSoundActionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfMovieActionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActionDictionary** out) {
-    if (!isMovieActionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfMovieActionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfHideActionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfHideActionDictionary** out) {
-    if (!isHideActionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfHideActionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfNamedActionsDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNamedActionsDictionary** out) {
-    if (!isNamedActionsDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfNamedActionsDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfInteractiveFormDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInteractiveFormDictionary** out) {
-    if (!isInteractiveFormDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfInteractiveFormDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFieldDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFieldDictionary** out) {
-    if (!isFieldDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFieldDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfVariableTextFieldDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfVariableTextFieldDictionary** out) {
-    if (!isVariableTextFieldDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfVariableTextFieldDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfAppearanceCharacteristicsDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAppearanceCharacteristicsDictionary** out) {
-    if (!isAppearanceCharacteristicsDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfAppearanceCharacteristicsDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfCheckboxFieldDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCheckboxFieldDictionary** out) {
-    if (!isCheckboxFieldDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfCheckboxFieldDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfRadioButtonFieldDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRadioButtonFieldDictionary** out) {
-    if (!isRadioButtonFieldDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfRadioButtonFieldDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfTextFieldDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTextFieldDictionary** out) {
-    if (!isTextFieldDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfTextFieldDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfChoiceFieldDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfChoiceFieldDictionary** out) {
-    if (!isChoiceFieldDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfChoiceFieldDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfSignatureDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSignatureDictionary** out) {
-    if (!isSignatureDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfSignatureDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfSubmitFormActionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSubmitFormActionDictionary** out) {
-    if (!isSubmitFormActionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfSubmitFormActionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfResetFormActionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfResetFormActionDictionary** out) {
-    if (!isResetFormActionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfResetFormActionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfImportDataActionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfImportDataActionDictionary** out) {
-    if (!isImportDataActionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfImportDataActionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfJavascriptActionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJavascriptActionDictionary** out) {
-    if (!isJavascriptActionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfJavascriptActionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFDFTrailerDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTrailerDictionary** out) {
-    if (!isFDFTrailerDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFDFTrailerDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFDFCatalogDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFCatalogDictionary** out) {
-    if (!isFDFCatalogDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFDFCatalogDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFDFDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFDictionary** out) {
-    if (!isFDFDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFDFDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfEncryptedEmbeddedFileStreamDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncryptedEmbeddedFileStreamDictionary** out) {
-    if (!isEncryptedEmbeddedFileStreamDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfEncryptedEmbeddedFileStreamDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfJavascriptDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJavascriptDictionary** out) {
-    if (!isJavascriptDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfJavascriptDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFDFFieldDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFFieldDictionary** out) {
-    if (!isFDFFieldDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFDFFieldDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfIconFitDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfIconFitDictionary** out) {
-    if (!isIconFitDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfIconFitDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFDFPageDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFPageDictionary** out) {
-    if (!isFDFPageDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFDFPageDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFDFTemplateDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTemplateDictionary** out) {
-    if (!isFDFTemplateDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFDFTemplateDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFDFNamedPageReferenceDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFNamedPageReferenceDictionary** out) {
-    if (!isFDFNamedPageReferenceDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFDFNamedPageReferenceDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfFDFFileAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFFileAnnotationDictionary** out) {
-    if (!isFDFFileAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfFDFFileAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfSoundObjectDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundObjectDictionary** out) {
-    if (!isSoundObjectDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfSoundObjectDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfMovieDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieDictionary** out) {
-    if (!isMovieDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfMovieDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfMovieActivationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActivationDictionary** out) {
-    if (!isMovieActivationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfMovieActivationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfDocumentInformationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentInformationDictionary** out) {
-    if (!isDocumentInformationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfDocumentInformationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfMetadataStreamDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMetadataStreamDictionary** out) {
-    if (!isMetadataStreamDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfMetadataStreamDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfComponentsWithMetadataDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfComponentsWithMetadataDictionary** out) {
-    if (!isComponentsWithMetadataDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfComponentsWithMetadataDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfPagePieceDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPagePieceDictionary** out) {
-    if (!isPagePieceDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfPagePieceDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfApplicationDataDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfApplicationDataDictionary** out) {
-    if (!isApplicationDataDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfApplicationDataDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfStructureTreeRootDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureTreeRootDictionary** out) {
-    if (!isStructureTreeRootDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfStructureTreeRootDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfStructureElementDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementDictionary** out) {
-    if (!isStructureElementDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfStructureElementDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfMarkedContentReferenceDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkedContentReferenceDictionary** out) {
-    if (!isMarkedContentReferenceDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfMarkedContentReferenceDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfObjectReferenceDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObjectReferenceDictionary** out) {
-    if (!isObjectReferenceDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfObjectReferenceDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfStructureElementAccessDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementAccessDictionary** out) {
-    if (!isStructureElementAccessDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfStructureElementAccessDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfAttributeObjectDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAttributeObjectDictionary** out) {
-    if (!isAttributeObjectDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfAttributeObjectDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfMarkInformationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkInformationDictionary** out) {
-    if (!isMarkInformationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfMarkInformationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfArtifactsDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfArtifactsDictionary** out) {
-    if (!isArtifactsDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfArtifactsDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfStandardStructureDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardStructureDictionary** out) {
-    if (!isStandardStructureDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfStandardStructureDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfBlockLevelStructureElementsDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBlockLevelStructureElementsDictionary** out) {
-    if (!isBlockLevelStructureElementsDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfBlockLevelStructureElementsDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfInlineLevelStructureElementsDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInlineLevelStructureElementsDictionary** out) {
-    if (!isInlineLevelStructureElementsDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfInlineLevelStructureElementsDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfListAttributeDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfListAttributeDictionary** out) {
-    if (!isListAttributeDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfListAttributeDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfTableAttributesDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTableAttributesDictionary** out) {
-    if (!isTableAttributesDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfTableAttributesDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfWebCaptureInformationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureInformationDictionary** out) {
-    if (!isWebCaptureInformationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfWebCaptureInformationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfWebCaptureDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureDictionary** out) {
-    if (!isWebCaptureDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfWebCaptureDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfWebCapturePageSetDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCapturePageSetDictionary** out) {
-    if (!isWebCapturePageSetDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfWebCapturePageSetDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfWebCaptureImageSetDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureImageSetDictionary** out) {
-    if (!isWebCaptureImageSetDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfWebCaptureImageSetDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfSourceInformationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSourceInformationDictionary** out) {
-    if (!isSourceInformationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfSourceInformationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfURLAliasDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURLAliasDictionary** out) {
-    if (!isURLAliasDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfURLAliasDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfWebCaptureCommandDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureCommandDictionary** out) {
-    if (!isWebCaptureCommandDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfWebCaptureCommandDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfWebCaptureCommandSettingsDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureCommandSettingsDictionary** out) {
-    if (!isWebCaptureCommandSettingsDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfWebCaptureCommandSettingsDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfBoxColorInformationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoxColorInformationDictionary** out) {
-    if (!isBoxColorInformationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfBoxColorInformationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfBoxStyleDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoxStyleDictionary** out) {
-    if (!isBoxStyleDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfBoxStyleDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfPrinterMarkAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPrinterMarkAnnotationDictionary** out) {
-    if (!isPrinterMarkAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfPrinterMarkAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfPrinterMarkFormDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPrinterMarkFormDictionary** out) {
-    if (!isPrinterMarkFormDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfPrinterMarkFormDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfSeparationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSeparationDictionary** out) {
-    if (!isSeparationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfSeparationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfPDF_XOutputIntentDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPDF_XOutputIntentDictionary** out) {
-    if (!isPDF_XOutputIntentDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfPDF_XOutputIntentDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfTrapNetworkAnnotationDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrapNetworkAnnotationDictionary** out) {
-    if (!isTrapNetworkAnnotationDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfTrapNetworkAnnotationDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfTrapNetworkAppearanceStreamDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrapNetworkAppearanceStreamDictionary** out) {
-    if (!isTrapNetworkAppearanceStreamDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfTrapNetworkAppearanceStreamDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfOpiVersionDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOpiVersionDictionary** out) {
-    if (!isOpiVersionDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfOpiVersionDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool map(const SkPdfObject& in, SkPdfMultiMasterFontDictionary** out) {
-    return map(*in.doc(), *in.podofo(), out);
-  }
-
-  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMultiMasterFontDictionary** out) {
-    if (!isMultiMasterFontDictionary(podofoDoc, podofoObj)) return false;
-
-
-    *out = new SkPdfMultiMasterFontDictionary(&podofoDoc, &podofoObj);
-    return true;
-  }
-
-  static bool isObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isNull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return podofoObj.GetDataType() == ePdfDataType_Null;
-  }
-
-  static bool isBoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return podofoObj.GetDataType() == ePdfDataType_Bool;
-  }
-
-  static bool isInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return podofoObj.GetDataType() == ePdfDataType_Number || podofoObj.GetDataType() == ePdfDataType_Real;
-  }
-
-  static bool isNumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return podofoObj.GetDataType() == ePdfDataType_Number || podofoObj.GetDataType() == ePdfDataType_Real;
-  }
-
-  static bool isName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return podofoObj.GetDataType() == ePdfDataType_Name;
-  }
-
-  static bool isReference(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return podofoObj.GetDataType() == ePdfDataType_Reference;
-  }
-
-  static bool isArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return podofoObj.GetDataType() == ePdfDataType_Array;
-  }
-
-  static bool isString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return podofoObj.GetDataType() == ePdfDataType_String || podofoObj.GetDataType() == ePdfDataType_HexString;
-  }
-
-  static bool isHexString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return podofoObj.GetDataType() == ePdfDataType_HexString;
-  }
-
-  static bool isDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return podofoObj.GetDataType() == ePdfDataType_Dictionary;
-  }
-
-  static bool isStream(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isTrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    std::string Subtype;
-    if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
-    if ((Subtype != "TrueType")) return false;
-
-    return true;
-  }
-
-  static bool isStreamCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isLzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isCcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isDctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFileTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isNameDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isNameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isNumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType0FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType2FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType3FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFileSpecificationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isCalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isCalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isLabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isDeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType1PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType2PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType1ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType2ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType3ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType4ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType5ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType6ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    std::string Subtype;
-    if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
-    if ((Subtype != "Image")) return false;
-
-    return true;
-  }
-
-  static bool isAlternateImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    std::string Subtype;
-    if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
-    if ((Subtype != "Form")) return false;
-
-    return true;
-  }
-
-  static bool isGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    std::string Subtype;
-    if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
-    if ((Subtype != "MMType1") && (Subtype != "TrueType") && (Subtype != "Type3") && (Subtype != "Type1")) return false;
-
-    return true;
-  }
-
-  static bool isType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    std::string Subtype;
-    if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
-    if ((Subtype != "Type3")) return false;
-
-    return true;
-  }
-
-  static bool isEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isCIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isCIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    std::string Subtype;
-    if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
-    if ((Subtype != "CIDFontType0") && (Subtype != "CIDFontType2")) return false;
-
-    return true;
-  }
-
-  static bool isCMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    std::string Subtype;
-    if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
-    if ((Subtype != "Type0")) return false;
-
-    return true;
-  }
-
-  static bool isFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isCIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isSoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isSoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isTransparencyGroupDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isOutlineItemDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isBeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isTransitionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isBorderStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isLineAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isSquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isRubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isSoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isDocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isRemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isThreadActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isSoundActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isMovieActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isNamedActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isAppearanceCharacteristicsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isCheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isRadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isSignatureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isSubmitFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isResetFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isImportDataActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isJavascriptActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isSoundObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isMovieActivationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isDocumentInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isApplicationDataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isStructureElementDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isStructureElementAccessDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isMarkInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isStandardStructureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isBlockLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isInlineLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isListAttributeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isTableAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isSourceInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isBoxColorInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isBoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isSeparationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isTrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isTrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    return true;
-  }
-
-  static bool isMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {
-    std::string Subtype;
-    if (!NameFromDictionary(&podofoDoc, podofoObj.GetDictionary(), "Subtype", "", &Subtype)) return false;
-    if ((Subtype != "MMType1")) return false;
-
-    return true;
-  }
-
-};
+bool mapObject(const SkPdfObject& in, SkPdfObject** out);
+bool mapObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out);
+bool mapNull(const SkPdfObject& in, SkPdfNull** out);
+bool mapNull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNull** out);
+bool mapBoolean(const SkPdfObject& in, SkPdfBoolean** out);
+bool mapBoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoolean** out);
+bool mapInteger(const SkPdfObject& in, SkPdfInteger** out);
+bool mapInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInteger** out);
+bool mapNumber(const SkPdfObject& in, SkPdfNumber** out);
+bool mapNumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNumber** out);
+bool mapName(const SkPdfObject& in, SkPdfName** out);
+bool mapName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfName** out);
+bool mapReference(const SkPdfObject& in, SkPdfReference** out);
+bool mapReference(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfReference** out);
+bool mapArray(const SkPdfObject& in, SkPdfArray** out);
+bool mapArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfArray** out);
+bool mapString(const SkPdfObject& in, SkPdfString** out);
+bool mapString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfString** out);
+bool mapHexString(const SkPdfObject& in, SkPdfHexString** out);
+bool mapHexString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfHexString** out);
+bool mapDictionary(const SkPdfObject& in, SkPdfDictionary** out);
+bool mapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDictionary** out);
+bool mapStream(const SkPdfObject& in, SkPdfStream** out);
+bool mapStream(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStream** out);
+bool mapXObjectDictionary(const SkPdfObject& in, SkPdfXObjectDictionary** out);
+bool mapXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfXObjectDictionary** out);
+bool mapFontDictionary(const SkPdfObject& in, SkPdfFontDictionary** out);
+bool mapFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFontDictionary** out);
+bool mapTrueTypeFontDictionary(const SkPdfObject& in, SkPdfTrueTypeFontDictionary** out);
+bool mapTrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrueTypeFontDictionary** out);
+bool mapStreamCommonDictionary(const SkPdfObject& in, SkPdfStreamCommonDictionary** out);
+bool mapStreamCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStreamCommonDictionary** out);
+bool mapLzwdecodeAndFlatedecodeFiltersDictionary(const SkPdfObject& in, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** out);
+bool mapLzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** out);
+bool mapCcittfaxdecodeFilterDictionary(const SkPdfObject& in, SkPdfCcittfaxdecodeFilterDictionary** out);
+bool mapCcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCcittfaxdecodeFilterDictionary** out);
+bool mapJbig2DecodeFilterDictionary(const SkPdfObject& in, SkPdfJbig2DecodeFilterDictionary** out);
+bool mapJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJbig2DecodeFilterDictionary** out);
+bool mapDctdecodeFilterDictionary(const SkPdfObject& in, SkPdfDctdecodeFilterDictionary** out);
+bool mapDctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDctdecodeFilterDictionary** out);
+bool mapFileTrailerDictionary(const SkPdfObject& in, SkPdfFileTrailerDictionary** out);
+bool mapFileTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileTrailerDictionary** out);
+bool mapEncryptionCommonDictionary(const SkPdfObject& in, SkPdfEncryptionCommonDictionary** out);
+bool mapEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncryptionCommonDictionary** out);
+bool mapStandardSecurityHandlerDictionary(const SkPdfObject& in, SkPdfStandardSecurityHandlerDictionary** out);
+bool mapStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardSecurityHandlerDictionary** out);
+bool mapCatalogDictionary(const SkPdfObject& in, SkPdfCatalogDictionary** out);
+bool mapCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCatalogDictionary** out);
+bool mapPageTreeNodeDictionary(const SkPdfObject& in, SkPdfPageTreeNodeDictionary** out);
+bool mapPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageTreeNodeDictionary** out);
+bool mapPageObjectDictionary(const SkPdfObject& in, SkPdfPageObjectDictionary** out);
+bool mapPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageObjectDictionary** out);
+bool mapNameDictionary(const SkPdfObject& in, SkPdfNameDictionary** out);
+bool mapNameDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameDictionary** out);
+bool mapResourceDictionary(const SkPdfObject& in, SkPdfResourceDictionary** out);
+bool mapResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfResourceDictionary** out);
+bool mapNameTreeNodeDictionary(const SkPdfObject& in, SkPdfNameTreeNodeDictionary** out);
+bool mapNameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNameTreeNodeDictionary** out);
+bool mapNumberTreeNodeDictionary(const SkPdfObject& in, SkPdfNumberTreeNodeDictionary** out);
+bool mapNumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNumberTreeNodeDictionary** out);
+bool mapFunctionCommonDictionary(const SkPdfObject& in, SkPdfFunctionCommonDictionary** out);
+bool mapFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFunctionCommonDictionary** out);
+bool mapType0FunctionDictionary(const SkPdfObject& in, SkPdfType0FunctionDictionary** out);
+bool mapType0FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType0FunctionDictionary** out);
+bool mapType2FunctionDictionary(const SkPdfObject& in, SkPdfType2FunctionDictionary** out);
+bool mapType2FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2FunctionDictionary** out);
+bool mapType3FunctionDictionary(const SkPdfObject& in, SkPdfType3FunctionDictionary** out);
+bool mapType3FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3FunctionDictionary** out);
+bool mapFileSpecificationDictionary(const SkPdfObject& in, SkPdfFileSpecificationDictionary** out);
+bool mapFileSpecificationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileSpecificationDictionary** out);
+bool mapEmbeddedFileStreamDictionary(const SkPdfObject& in, SkPdfEmbeddedFileStreamDictionary** out);
+bool mapEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFileStreamDictionary** out);
+bool mapEmbeddedFileParameterDictionary(const SkPdfObject& in, SkPdfEmbeddedFileParameterDictionary** out);
+bool mapEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFileParameterDictionary** out);
+bool mapMacOsFileInformationDictionary(const SkPdfObject& in, SkPdfMacOsFileInformationDictionary** out);
+bool mapMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMacOsFileInformationDictionary** out);
+bool mapGraphicsStateDictionary(const SkPdfObject& in, SkPdfGraphicsStateDictionary** out);
+bool mapGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGraphicsStateDictionary** out);
+bool mapCalgrayColorSpaceDictionary(const SkPdfObject& in, SkPdfCalgrayColorSpaceDictionary** out);
+bool mapCalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCalgrayColorSpaceDictionary** out);
+bool mapCalrgbColorSpaceDictionary(const SkPdfObject& in, SkPdfCalrgbColorSpaceDictionary** out);
+bool mapCalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCalrgbColorSpaceDictionary** out);
+bool mapLabColorSpaceDictionary(const SkPdfObject& in, SkPdfLabColorSpaceDictionary** out);
+bool mapLabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLabColorSpaceDictionary** out);
+bool mapIccProfileStreamDictionary(const SkPdfObject& in, SkPdfIccProfileStreamDictionary** out);
+bool mapIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfIccProfileStreamDictionary** out);
+bool mapDeviceNColorSpaceDictionary(const SkPdfObject& in, SkPdfDeviceNColorSpaceDictionary** out);
+bool mapDeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDeviceNColorSpaceDictionary** out);
+bool mapType1PatternDictionary(const SkPdfObject& in, SkPdfType1PatternDictionary** out);
+bool mapType1PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1PatternDictionary** out);
+bool mapType2PatternDictionary(const SkPdfObject& in, SkPdfType2PatternDictionary** out);
+bool mapType2PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2PatternDictionary** out);
+bool mapShadingDictionary(const SkPdfObject& in, SkPdfShadingDictionary** out);
+bool mapShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfShadingDictionary** out);
+bool mapType1ShadingDictionary(const SkPdfObject& in, SkPdfType1ShadingDictionary** out);
+bool mapType1ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1ShadingDictionary** out);
+bool mapType2ShadingDictionary(const SkPdfObject& in, SkPdfType2ShadingDictionary** out);
+bool mapType2ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType2ShadingDictionary** out);
+bool mapType3ShadingDictionary(const SkPdfObject& in, SkPdfType3ShadingDictionary** out);
+bool mapType3ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3ShadingDictionary** out);
+bool mapType4ShadingDictionary(const SkPdfObject& in, SkPdfType4ShadingDictionary** out);
+bool mapType4ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType4ShadingDictionary** out);
+bool mapType5ShadingDictionary(const SkPdfObject& in, SkPdfType5ShadingDictionary** out);
+bool mapType5ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5ShadingDictionary** out);
+bool mapType6ShadingDictionary(const SkPdfObject& in, SkPdfType6ShadingDictionary** out);
+bool mapType6ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6ShadingDictionary** out);
+bool mapImageDictionary(const SkPdfObject& in, SkPdfImageDictionary** out);
+bool mapImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfImageDictionary** out);
+bool mapAlternateImageDictionary(const SkPdfObject& in, SkPdfAlternateImageDictionary** out);
+bool mapAlternateImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAlternateImageDictionary** out);
+bool mapType1FormDictionary(const SkPdfObject& in, SkPdfType1FormDictionary** out);
+bool mapType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1FormDictionary** out);
+bool mapGroupAttributesDictionary(const SkPdfObject& in, SkPdfGroupAttributesDictionary** out);
+bool mapGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGroupAttributesDictionary** out);
+bool mapReferenceDictionary(const SkPdfObject& in, SkPdfReferenceDictionary** out);
+bool mapReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfReferenceDictionary** out);
+bool mapPSXobjectDictionary(const SkPdfObject& in, SkPdfPSXobjectDictionary** out);
+bool mapPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPSXobjectDictionary** out);
+bool mapType1FontDictionary(const SkPdfObject& in, SkPdfType1FontDictionary** out);
+bool mapType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1FontDictionary** out);
+bool mapType3FontDictionary(const SkPdfObject& in, SkPdfType3FontDictionary** out);
+bool mapType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType3FontDictionary** out);
+bool mapEncodingDictionary(const SkPdfObject& in, SkPdfEncodingDictionary** out);
+bool mapEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncodingDictionary** out);
+bool mapCIDSystemInfoDictionary(const SkPdfObject& in, SkPdfCIDSystemInfoDictionary** out);
+bool mapCIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDSystemInfoDictionary** out);
+bool mapCIDFontDictionary(const SkPdfObject& in, SkPdfCIDFontDictionary** out);
+bool mapCIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDFontDictionary** out);
+bool mapCMapDictionary(const SkPdfObject& in, SkPdfCMapDictionary** out);
+bool mapCMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCMapDictionary** out);
+bool mapType0FontDictionary(const SkPdfObject& in, SkPdfType0FontDictionary** out);
+bool mapType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType0FontDictionary** out);
+bool mapFontDescriptorDictionary(const SkPdfObject& in, SkPdfFontDescriptorDictionary** out);
+bool mapFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFontDescriptorDictionary** out);
+bool mapCIDFontDescriptorDictionary(const SkPdfObject& in, SkPdfCIDFontDescriptorDictionary** out);
+bool mapCIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCIDFontDescriptorDictionary** out);
+bool mapEmbeddedFontStreamDictionary(const SkPdfObject& in, SkPdfEmbeddedFontStreamDictionary** out);
+bool mapEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEmbeddedFontStreamDictionary** out);
+bool mapType1HalftoneDictionary(const SkPdfObject& in, SkPdfType1HalftoneDictionary** out);
+bool mapType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType1HalftoneDictionary** out);
+bool mapType6HalftoneDictionary(const SkPdfObject& in, SkPdfType6HalftoneDictionary** out);
+bool mapType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType6HalftoneDictionary** out);
+bool mapType10HalftoneDictionary(const SkPdfObject& in, SkPdfType10HalftoneDictionary** out);
+bool mapType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType10HalftoneDictionary** out);
+bool mapType16HalftoneDictionary(const SkPdfObject& in, SkPdfType16HalftoneDictionary** out);
+bool mapType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType16HalftoneDictionary** out);
+bool mapType5HalftoneDictionary(const SkPdfObject& in, SkPdfType5HalftoneDictionary** out);
+bool mapType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfType5HalftoneDictionary** out);
+bool mapSoftMaskDictionary(const SkPdfObject& in, SkPdfSoftMaskDictionary** out);
+bool mapSoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoftMaskDictionary** out);
+bool mapSoftMaskImageDictionary(const SkPdfObject& in, SkPdfSoftMaskImageDictionary** out);
+bool mapSoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoftMaskImageDictionary** out);
+bool mapTransparencyGroupDictionary(const SkPdfObject& in, SkPdfTransparencyGroupDictionary** out);
+bool mapTransparencyGroupDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTransparencyGroupDictionary** out);
+bool mapViewerPreferencesDictionary(const SkPdfObject& in, SkPdfViewerPreferencesDictionary** out);
+bool mapViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfViewerPreferencesDictionary** out);
+bool mapOutlineDictionary(const SkPdfObject& in, SkPdfOutlineDictionary** out);
+bool mapOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineDictionary** out);
+bool mapOutlineItemDictionary(const SkPdfObject& in, SkPdfOutlineItemDictionary** out);
+bool mapOutlineItemDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOutlineItemDictionary** out);
+bool mapPageLabelDictionary(const SkPdfObject& in, SkPdfPageLabelDictionary** out);
+bool mapPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageLabelDictionary** out);
+bool mapThreadDictionary(const SkPdfObject& in, SkPdfThreadDictionary** out);
+bool mapThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadDictionary** out);
+bool mapBeadDictionary(const SkPdfObject& in, SkPdfBeadDictionary** out);
+bool mapBeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBeadDictionary** out);
+bool mapTransitionDictionary(const SkPdfObject& in, SkPdfTransitionDictionary** out);
+bool mapTransitionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTransitionDictionary** out);
+bool mapAnnotationDictionary(const SkPdfObject& in, SkPdfAnnotationDictionary** out);
+bool mapAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAnnotationDictionary** out);
+bool mapBorderStyleDictionary(const SkPdfObject& in, SkPdfBorderStyleDictionary** out);
+bool mapBorderStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBorderStyleDictionary** out);
+bool mapAppearanceDictionary(const SkPdfObject& in, SkPdfAppearanceDictionary** out);
+bool mapAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAppearanceDictionary** out);
+bool mapTextAnnotationDictionary(const SkPdfObject& in, SkPdfTextAnnotationDictionary** out);
+bool mapTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTextAnnotationDictionary** out);
+bool mapALinkAnnotationDictionary(const SkPdfObject& in, SkPdfALinkAnnotationDictionary** out);
+bool mapALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfALinkAnnotationDictionary** out);
+bool mapFreeTextAnnotationDictionary(const SkPdfObject& in, SkPdfFreeTextAnnotationDictionary** out);
+bool mapFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFreeTextAnnotationDictionary** out);
+bool mapLineAnnotationDictionary(const SkPdfObject& in, SkPdfLineAnnotationDictionary** out);
+bool mapLineAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLineAnnotationDictionary** out);
+bool mapSquareOrCircleAnnotation(const SkPdfObject& in, SkPdfSquareOrCircleAnnotation** out);
+bool mapSquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSquareOrCircleAnnotation** out);
+bool mapMarkupAnnotationsDictionary(const SkPdfObject& in, SkPdfMarkupAnnotationsDictionary** out);
+bool mapMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkupAnnotationsDictionary** out);
+bool mapRubberStampAnnotationDictionary(const SkPdfObject& in, SkPdfRubberStampAnnotationDictionary** out);
+bool mapRubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRubberStampAnnotationDictionary** out);
+bool mapInkAnnotationDictionary(const SkPdfObject& in, SkPdfInkAnnotationDictionary** out);
+bool mapInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInkAnnotationDictionary** out);
+bool mapPopUpAnnotationDictionary(const SkPdfObject& in, SkPdfPopUpAnnotationDictionary** out);
+bool mapPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPopUpAnnotationDictionary** out);
+bool mapFileAttachmentAnnotationDictionary(const SkPdfObject& in, SkPdfFileAttachmentAnnotationDictionary** out);
+bool mapFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFileAttachmentAnnotationDictionary** out);
+bool mapSoundAnnotationDictionary(const SkPdfObject& in, SkPdfSoundAnnotationDictionary** out);
+bool mapSoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundAnnotationDictionary** out);
+bool mapMovieAnnotationDictionary(const SkPdfObject& in, SkPdfMovieAnnotationDictionary** out);
+bool mapMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieAnnotationDictionary** out);
+bool mapWidgetAnnotationDictionary(const SkPdfObject& in, SkPdfWidgetAnnotationDictionary** out);
+bool mapWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWidgetAnnotationDictionary** out);
+bool mapActionDictionary(const SkPdfObject& in, SkPdfActionDictionary** out);
+bool mapActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfActionDictionary** out);
+bool mapAnnotationActionsDictionary(const SkPdfObject& in, SkPdfAnnotationActionsDictionary** out);
+bool mapAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAnnotationActionsDictionary** out);
+bool mapPageObjectActionsDictionary(const SkPdfObject& in, SkPdfPageObjectActionsDictionary** out);
+bool mapPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPageObjectActionsDictionary** out);
+bool mapFormFieldActionsDictionary(const SkPdfObject& in, SkPdfFormFieldActionsDictionary** out);
+bool mapFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFormFieldActionsDictionary** out);
+bool mapDocumentCatalogActionsDictionary(const SkPdfObject& in, SkPdfDocumentCatalogActionsDictionary** out);
+bool mapDocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentCatalogActionsDictionary** out);
+bool mapGoToActionDictionary(const SkPdfObject& in, SkPdfGoToActionDictionary** out);
+bool mapGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfGoToActionDictionary** out);
+bool mapRemoteGoToActionDictionary(const SkPdfObject& in, SkPdfRemoteGoToActionDictionary** out);
+bool mapRemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRemoteGoToActionDictionary** out);
+bool mapLaunchActionDictionary(const SkPdfObject& in, SkPdfLaunchActionDictionary** out);
+bool mapLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfLaunchActionDictionary** out);
+bool mapWindowsLaunchActionDictionary(const SkPdfObject& in, SkPdfWindowsLaunchActionDictionary** out);
+bool mapWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWindowsLaunchActionDictionary** out);
+bool mapThreadActionDictionary(const SkPdfObject& in, SkPdfThreadActionDictionary** out);
+bool mapThreadActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfThreadActionDictionary** out);
+bool mapURIActionDictionary(const SkPdfObject& in, SkPdfURIActionDictionary** out);
+bool mapURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURIActionDictionary** out);
+bool mapURIDictionary(const SkPdfObject& in, SkPdfURIDictionary** out);
+bool mapURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURIDictionary** out);
+bool mapSoundActionDictionary(const SkPdfObject& in, SkPdfSoundActionDictionary** out);
+bool mapSoundActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundActionDictionary** out);
+bool mapMovieActionDictionary(const SkPdfObject& in, SkPdfMovieActionDictionary** out);
+bool mapMovieActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActionDictionary** out);
+bool mapHideActionDictionary(const SkPdfObject& in, SkPdfHideActionDictionary** out);
+bool mapHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfHideActionDictionary** out);
+bool mapNamedActionsDictionary(const SkPdfObject& in, SkPdfNamedActionsDictionary** out);
+bool mapNamedActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfNamedActionsDictionary** out);
+bool mapInteractiveFormDictionary(const SkPdfObject& in, SkPdfInteractiveFormDictionary** out);
+bool mapInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInteractiveFormDictionary** out);
+bool mapFieldDictionary(const SkPdfObject& in, SkPdfFieldDictionary** out);
+bool mapFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFieldDictionary** out);
+bool mapVariableTextFieldDictionary(const SkPdfObject& in, SkPdfVariableTextFieldDictionary** out);
+bool mapVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfVariableTextFieldDictionary** out);
+bool mapAppearanceCharacteristicsDictionary(const SkPdfObject& in, SkPdfAppearanceCharacteristicsDictionary** out);
+bool mapAppearanceCharacteristicsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAppearanceCharacteristicsDictionary** out);
+bool mapCheckboxFieldDictionary(const SkPdfObject& in, SkPdfCheckboxFieldDictionary** out);
+bool mapCheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfCheckboxFieldDictionary** out);
+bool mapRadioButtonFieldDictionary(const SkPdfObject& in, SkPdfRadioButtonFieldDictionary** out);
+bool mapRadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfRadioButtonFieldDictionary** out);
+bool mapTextFieldDictionary(const SkPdfObject& in, SkPdfTextFieldDictionary** out);
+bool mapTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTextFieldDictionary** out);
+bool mapChoiceFieldDictionary(const SkPdfObject& in, SkPdfChoiceFieldDictionary** out);
+bool mapChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfChoiceFieldDictionary** out);
+bool mapSignatureDictionary(const SkPdfObject& in, SkPdfSignatureDictionary** out);
+bool mapSignatureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSignatureDictionary** out);
+bool mapSubmitFormActionDictionary(const SkPdfObject& in, SkPdfSubmitFormActionDictionary** out);
+bool mapSubmitFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSubmitFormActionDictionary** out);
+bool mapResetFormActionDictionary(const SkPdfObject& in, SkPdfResetFormActionDictionary** out);
+bool mapResetFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfResetFormActionDictionary** out);
+bool mapImportDataActionDictionary(const SkPdfObject& in, SkPdfImportDataActionDictionary** out);
+bool mapImportDataActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfImportDataActionDictionary** out);
+bool mapJavascriptActionDictionary(const SkPdfObject& in, SkPdfJavascriptActionDictionary** out);
+bool mapJavascriptActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJavascriptActionDictionary** out);
+bool mapFDFTrailerDictionary(const SkPdfObject& in, SkPdfFDFTrailerDictionary** out);
+bool mapFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTrailerDictionary** out);
+bool mapFDFCatalogDictionary(const SkPdfObject& in, SkPdfFDFCatalogDictionary** out);
+bool mapFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFCatalogDictionary** out);
+bool mapFDFDictionary(const SkPdfObject& in, SkPdfFDFDictionary** out);
+bool mapFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFDictionary** out);
+bool mapEncryptedEmbeddedFileStreamDictionary(const SkPdfObject& in, SkPdfEncryptedEmbeddedFileStreamDictionary** out);
+bool mapEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfEncryptedEmbeddedFileStreamDictionary** out);
+bool mapJavascriptDictionary(const SkPdfObject& in, SkPdfJavascriptDictionary** out);
+bool mapJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfJavascriptDictionary** out);
+bool mapFDFFieldDictionary(const SkPdfObject& in, SkPdfFDFFieldDictionary** out);
+bool mapFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFFieldDictionary** out);
+bool mapIconFitDictionary(const SkPdfObject& in, SkPdfIconFitDictionary** out);
+bool mapIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfIconFitDictionary** out);
+bool mapFDFPageDictionary(const SkPdfObject& in, SkPdfFDFPageDictionary** out);
+bool mapFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFPageDictionary** out);
+bool mapFDFTemplateDictionary(const SkPdfObject& in, SkPdfFDFTemplateDictionary** out);
+bool mapFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFTemplateDictionary** out);
+bool mapFDFNamedPageReferenceDictionary(const SkPdfObject& in, SkPdfFDFNamedPageReferenceDictionary** out);
+bool mapFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFNamedPageReferenceDictionary** out);
+bool mapFDFFileAnnotationDictionary(const SkPdfObject& in, SkPdfFDFFileAnnotationDictionary** out);
+bool mapFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfFDFFileAnnotationDictionary** out);
+bool mapSoundObjectDictionary(const SkPdfObject& in, SkPdfSoundObjectDictionary** out);
+bool mapSoundObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSoundObjectDictionary** out);
+bool mapMovieDictionary(const SkPdfObject& in, SkPdfMovieDictionary** out);
+bool mapMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieDictionary** out);
+bool mapMovieActivationDictionary(const SkPdfObject& in, SkPdfMovieActivationDictionary** out);
+bool mapMovieActivationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMovieActivationDictionary** out);
+bool mapDocumentInformationDictionary(const SkPdfObject& in, SkPdfDocumentInformationDictionary** out);
+bool mapDocumentInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfDocumentInformationDictionary** out);
+bool mapMetadataStreamDictionary(const SkPdfObject& in, SkPdfMetadataStreamDictionary** out);
+bool mapMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMetadataStreamDictionary** out);
+bool mapComponentsWithMetadataDictionary(const SkPdfObject& in, SkPdfComponentsWithMetadataDictionary** out);
+bool mapComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfComponentsWithMetadataDictionary** out);
+bool mapPagePieceDictionary(const SkPdfObject& in, SkPdfPagePieceDictionary** out);
+bool mapPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPagePieceDictionary** out);
+bool mapApplicationDataDictionary(const SkPdfObject& in, SkPdfApplicationDataDictionary** out);
+bool mapApplicationDataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfApplicationDataDictionary** out);
+bool mapStructureTreeRootDictionary(const SkPdfObject& in, SkPdfStructureTreeRootDictionary** out);
+bool mapStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureTreeRootDictionary** out);
+bool mapStructureElementDictionary(const SkPdfObject& in, SkPdfStructureElementDictionary** out);
+bool mapStructureElementDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementDictionary** out);
+bool mapMarkedContentReferenceDictionary(const SkPdfObject& in, SkPdfMarkedContentReferenceDictionary** out);
+bool mapMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkedContentReferenceDictionary** out);
+bool mapObjectReferenceDictionary(const SkPdfObject& in, SkPdfObjectReferenceDictionary** out);
+bool mapObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObjectReferenceDictionary** out);
+bool mapStructureElementAccessDictionary(const SkPdfObject& in, SkPdfStructureElementAccessDictionary** out);
+bool mapStructureElementAccessDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStructureElementAccessDictionary** out);
+bool mapAttributeObjectDictionary(const SkPdfObject& in, SkPdfAttributeObjectDictionary** out);
+bool mapAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfAttributeObjectDictionary** out);
+bool mapMarkInformationDictionary(const SkPdfObject& in, SkPdfMarkInformationDictionary** out);
+bool mapMarkInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMarkInformationDictionary** out);
+bool mapArtifactsDictionary(const SkPdfObject& in, SkPdfArtifactsDictionary** out);
+bool mapArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfArtifactsDictionary** out);
+bool mapStandardStructureDictionary(const SkPdfObject& in, SkPdfStandardStructureDictionary** out);
+bool mapStandardStructureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfStandardStructureDictionary** out);
+bool mapBlockLevelStructureElementsDictionary(const SkPdfObject& in, SkPdfBlockLevelStructureElementsDictionary** out);
+bool mapBlockLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBlockLevelStructureElementsDictionary** out);
+bool mapInlineLevelStructureElementsDictionary(const SkPdfObject& in, SkPdfInlineLevelStructureElementsDictionary** out);
+bool mapInlineLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfInlineLevelStructureElementsDictionary** out);
+bool mapListAttributeDictionary(const SkPdfObject& in, SkPdfListAttributeDictionary** out);
+bool mapListAttributeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfListAttributeDictionary** out);
+bool mapTableAttributesDictionary(const SkPdfObject& in, SkPdfTableAttributesDictionary** out);
+bool mapTableAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTableAttributesDictionary** out);
+bool mapWebCaptureInformationDictionary(const SkPdfObject& in, SkPdfWebCaptureInformationDictionary** out);
+bool mapWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureInformationDictionary** out);
+bool mapWebCaptureDictionary(const SkPdfObject& in, SkPdfWebCaptureDictionary** out);
+bool mapWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureDictionary** out);
+bool mapWebCapturePageSetDictionary(const SkPdfObject& in, SkPdfWebCapturePageSetDictionary** out);
+bool mapWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCapturePageSetDictionary** out);
+bool mapWebCaptureImageSetDictionary(const SkPdfObject& in, SkPdfWebCaptureImageSetDictionary** out);
+bool mapWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureImageSetDictionary** out);
+bool mapSourceInformationDictionary(const SkPdfObject& in, SkPdfSourceInformationDictionary** out);
+bool mapSourceInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSourceInformationDictionary** out);
+bool mapURLAliasDictionary(const SkPdfObject& in, SkPdfURLAliasDictionary** out);
+bool mapURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfURLAliasDictionary** out);
+bool mapWebCaptureCommandDictionary(const SkPdfObject& in, SkPdfWebCaptureCommandDictionary** out);
+bool mapWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureCommandDictionary** out);
+bool mapWebCaptureCommandSettingsDictionary(const SkPdfObject& in, SkPdfWebCaptureCommandSettingsDictionary** out);
+bool mapWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfWebCaptureCommandSettingsDictionary** out);
+bool mapBoxColorInformationDictionary(const SkPdfObject& in, SkPdfBoxColorInformationDictionary** out);
+bool mapBoxColorInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoxColorInformationDictionary** out);
+bool mapBoxStyleDictionary(const SkPdfObject& in, SkPdfBoxStyleDictionary** out);
+bool mapBoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfBoxStyleDictionary** out);
+bool mapPrinterMarkAnnotationDictionary(const SkPdfObject& in, SkPdfPrinterMarkAnnotationDictionary** out);
+bool mapPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPrinterMarkAnnotationDictionary** out);
+bool mapPrinterMarkFormDictionary(const SkPdfObject& in, SkPdfPrinterMarkFormDictionary** out);
+bool mapPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPrinterMarkFormDictionary** out);
+bool mapSeparationDictionary(const SkPdfObject& in, SkPdfSeparationDictionary** out);
+bool mapSeparationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfSeparationDictionary** out);
+bool mapPDF_XOutputIntentDictionary(const SkPdfObject& in, SkPdfPDF_XOutputIntentDictionary** out);
+bool mapPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfPDF_XOutputIntentDictionary** out);
+bool mapTrapNetworkAnnotationDictionary(const SkPdfObject& in, SkPdfTrapNetworkAnnotationDictionary** out);
+bool mapTrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrapNetworkAnnotationDictionary** out);
+bool mapTrapNetworkAppearanceStreamDictionary(const SkPdfObject& in, SkPdfTrapNetworkAppearanceStreamDictionary** out);
+bool mapTrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfTrapNetworkAppearanceStreamDictionary** out);
+bool mapOpiVersionDictionary(const SkPdfObject& in, SkPdfOpiVersionDictionary** out);
+bool mapOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfOpiVersionDictionary** out);
+bool mapMultiMasterFontDictionary(const SkPdfObject& in, SkPdfMultiMasterFontDictionary** out);
+bool mapMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfMultiMasterFontDictionary** out);
+bool isObject(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ObjectFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfObject** data);
+bool ObjectFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfObject** data);
+bool isNull(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool NullFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNull** data);
+bool NullFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNull** data);
+bool isBoolean(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool BooleanFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBoolean** data);
+bool BooleanFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBoolean** data);
+bool isInteger(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool IntegerFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInteger** data);
+bool IntegerFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInteger** data);
+bool isNumber(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool NumberFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNumber** data);
+bool NumberFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNumber** data);
+bool isName(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool NameFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfName** data);
+bool NameFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfName** data);
+bool isReference(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ReferenceFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfReference** data);
+bool ReferenceFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfReference** data);
+bool isArray(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ArrayFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfArray** data);
+bool ArrayFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfArray** data);
+bool isString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfString** data);
+bool StringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfString** data);
+bool isHexString(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool HexStringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfHexString** data);
+bool HexStringFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfHexString** data);
+bool isDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDictionary** data);
+bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDictionary** data);
+bool isStream(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStream** data);
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStream** data);
+bool isXObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool XObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfXObjectDictionary** data);
+bool XObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfXObjectDictionary** data);
+bool isFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFontDictionary** data);
+bool FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFontDictionary** data);
+bool isTrueTypeFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TrueTypeFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTrueTypeFontDictionary** data);
+bool TrueTypeFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTrueTypeFontDictionary** data);
+bool isStreamCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StreamCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStreamCommonDictionary** data);
+bool StreamCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStreamCommonDictionary** data);
+bool isLzwdecodeAndFlatedecodeFiltersDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** data);
+bool LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLzwdecodeAndFlatedecodeFiltersDictionary** data);
+bool isCcittfaxdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CcittfaxdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCcittfaxdecodeFilterDictionary** data);
+bool CcittfaxdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCcittfaxdecodeFilterDictionary** data);
+bool isJbig2DecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Jbig2DecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfJbig2DecodeFilterDictionary** data);
+bool Jbig2DecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfJbig2DecodeFilterDictionary** data);
+bool isDctdecodeFilterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool DctdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDctdecodeFilterDictionary** data);
+bool DctdecodeFilterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDctdecodeFilterDictionary** data);
+bool isFileTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FileTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFileTrailerDictionary** data);
+bool FileTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFileTrailerDictionary** data);
+bool isEncryptionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool EncryptionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEncryptionCommonDictionary** data);
+bool EncryptionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEncryptionCommonDictionary** data);
+bool isStandardSecurityHandlerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StandardSecurityHandlerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStandardSecurityHandlerDictionary** data);
+bool StandardSecurityHandlerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStandardSecurityHandlerDictionary** data);
+bool isCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCatalogDictionary** data);
+bool CatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCatalogDictionary** data);
+bool isPageTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PageTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageTreeNodeDictionary** data);
+bool PageTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageTreeNodeDictionary** data);
+bool isPageObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PageObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageObjectDictionary** data);
+bool PageObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageObjectDictionary** data);
+bool isNameDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool NameDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNameDictionary** data);
+bool NameDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNameDictionary** data);
+bool isResourceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ResourceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfResourceDictionary** data);
+bool ResourceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfResourceDictionary** data);
+bool isNameTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool NameTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNameTreeNodeDictionary** data);
+bool NameTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNameTreeNodeDictionary** data);
+bool isNumberTreeNodeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool NumberTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNumberTreeNodeDictionary** data);
+bool NumberTreeNodeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNumberTreeNodeDictionary** data);
+bool isFunctionCommonDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FunctionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFunctionCommonDictionary** data);
+bool FunctionCommonDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFunctionCommonDictionary** data);
+bool isType0FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type0FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType0FunctionDictionary** data);
+bool Type0FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType0FunctionDictionary** data);
+bool isType2FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type2FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType2FunctionDictionary** data);
+bool Type2FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType2FunctionDictionary** data);
+bool isType3FunctionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type3FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType3FunctionDictionary** data);
+bool Type3FunctionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType3FunctionDictionary** data);
+bool isFileSpecificationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FileSpecificationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFileSpecificationDictionary** data);
+bool FileSpecificationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFileSpecificationDictionary** data);
+bool isEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool EmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEmbeddedFileStreamDictionary** data);
+bool EmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFileStreamDictionary** data);
+bool isEmbeddedFileParameterDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool EmbeddedFileParameterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEmbeddedFileParameterDictionary** data);
+bool EmbeddedFileParameterDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFileParameterDictionary** data);
+bool isMacOsFileInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MacOsFileInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMacOsFileInformationDictionary** data);
+bool MacOsFileInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMacOsFileInformationDictionary** data);
+bool isGraphicsStateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool GraphicsStateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfGraphicsStateDictionary** data);
+bool GraphicsStateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfGraphicsStateDictionary** data);
+bool isCalgrayColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CalgrayColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCalgrayColorSpaceDictionary** data);
+bool CalgrayColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCalgrayColorSpaceDictionary** data);
+bool isCalrgbColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CalrgbColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCalrgbColorSpaceDictionary** data);
+bool CalrgbColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCalrgbColorSpaceDictionary** data);
+bool isLabColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool LabColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLabColorSpaceDictionary** data);
+bool LabColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLabColorSpaceDictionary** data);
+bool isIccProfileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool IccProfileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfIccProfileStreamDictionary** data);
+bool IccProfileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfIccProfileStreamDictionary** data);
+bool isDeviceNColorSpaceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool DeviceNColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDeviceNColorSpaceDictionary** data);
+bool DeviceNColorSpaceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDeviceNColorSpaceDictionary** data);
+bool isType1PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type1PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1PatternDictionary** data);
+bool Type1PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1PatternDictionary** data);
+bool isType2PatternDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type2PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType2PatternDictionary** data);
+bool Type2PatternDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType2PatternDictionary** data);
+bool isShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfShadingDictionary** data);
+bool ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfShadingDictionary** data);
+bool isType1ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type1ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1ShadingDictionary** data);
+bool Type1ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1ShadingDictionary** data);
+bool isType2ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type2ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType2ShadingDictionary** data);
+bool Type2ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType2ShadingDictionary** data);
+bool isType3ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type3ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType3ShadingDictionary** data);
+bool Type3ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType3ShadingDictionary** data);
+bool isType4ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type4ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType4ShadingDictionary** data);
+bool Type4ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType4ShadingDictionary** data);
+bool isType5ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type5ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType5ShadingDictionary** data);
+bool Type5ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType5ShadingDictionary** data);
+bool isType6ShadingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type6ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType6ShadingDictionary** data);
+bool Type6ShadingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType6ShadingDictionary** data);
+bool isImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfImageDictionary** data);
+bool ImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfImageDictionary** data);
+bool isAlternateImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool AlternateImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAlternateImageDictionary** data);
+bool AlternateImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAlternateImageDictionary** data);
+bool isType1FormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type1FormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1FormDictionary** data);
+bool Type1FormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1FormDictionary** data);
+bool isGroupAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool GroupAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfGroupAttributesDictionary** data);
+bool GroupAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfGroupAttributesDictionary** data);
+bool isReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfReferenceDictionary** data);
+bool ReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfReferenceDictionary** data);
+bool isPSXobjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PSXobjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPSXobjectDictionary** data);
+bool PSXobjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPSXobjectDictionary** data);
+bool isType1FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type1FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1FontDictionary** data);
+bool Type1FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1FontDictionary** data);
+bool isType3FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type3FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType3FontDictionary** data);
+bool Type3FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType3FontDictionary** data);
+bool isEncodingDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool EncodingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEncodingDictionary** data);
+bool EncodingDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEncodingDictionary** data);
+bool isCIDSystemInfoDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CIDSystemInfoDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCIDSystemInfoDictionary** data);
+bool CIDSystemInfoDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCIDSystemInfoDictionary** data);
+bool isCIDFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CIDFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCIDFontDictionary** data);
+bool CIDFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCIDFontDictionary** data);
+bool isCMapDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CMapDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCMapDictionary** data);
+bool CMapDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCMapDictionary** data);
+bool isType0FontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type0FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType0FontDictionary** data);
+bool Type0FontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType0FontDictionary** data);
+bool isFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFontDescriptorDictionary** data);
+bool FontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFontDescriptorDictionary** data);
+bool isCIDFontDescriptorDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CIDFontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCIDFontDescriptorDictionary** data);
+bool CIDFontDescriptorDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCIDFontDescriptorDictionary** data);
+bool isEmbeddedFontStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool EmbeddedFontStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEmbeddedFontStreamDictionary** data);
+bool EmbeddedFontStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEmbeddedFontStreamDictionary** data);
+bool isType1HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type1HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType1HalftoneDictionary** data);
+bool Type1HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType1HalftoneDictionary** data);
+bool isType6HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type6HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType6HalftoneDictionary** data);
+bool Type6HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType6HalftoneDictionary** data);
+bool isType10HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type10HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType10HalftoneDictionary** data);
+bool Type10HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType10HalftoneDictionary** data);
+bool isType16HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type16HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType16HalftoneDictionary** data);
+bool Type16HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType16HalftoneDictionary** data);
+bool isType5HalftoneDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool Type5HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfType5HalftoneDictionary** data);
+bool Type5HalftoneDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfType5HalftoneDictionary** data);
+bool isSoftMaskDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SoftMaskDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoftMaskDictionary** data);
+bool SoftMaskDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoftMaskDictionary** data);
+bool isSoftMaskImageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SoftMaskImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoftMaskImageDictionary** data);
+bool SoftMaskImageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoftMaskImageDictionary** data);
+bool isTransparencyGroupDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TransparencyGroupDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTransparencyGroupDictionary** data);
+bool TransparencyGroupDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTransparencyGroupDictionary** data);
+bool isViewerPreferencesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ViewerPreferencesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfViewerPreferencesDictionary** data);
+bool ViewerPreferencesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfViewerPreferencesDictionary** data);
+bool isOutlineDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool OutlineDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfOutlineDictionary** data);
+bool OutlineDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfOutlineDictionary** data);
+bool isOutlineItemDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool OutlineItemDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfOutlineItemDictionary** data);
+bool OutlineItemDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfOutlineItemDictionary** data);
+bool isPageLabelDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PageLabelDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageLabelDictionary** data);
+bool PageLabelDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageLabelDictionary** data);
+bool isThreadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ThreadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfThreadDictionary** data);
+bool ThreadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfThreadDictionary** data);
+bool isBeadDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool BeadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBeadDictionary** data);
+bool BeadDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBeadDictionary** data);
+bool isTransitionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TransitionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTransitionDictionary** data);
+bool TransitionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTransitionDictionary** data);
+bool isAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool AnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAnnotationDictionary** data);
+bool AnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAnnotationDictionary** data);
+bool isBorderStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool BorderStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBorderStyleDictionary** data);
+bool BorderStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBorderStyleDictionary** data);
+bool isAppearanceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool AppearanceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAppearanceDictionary** data);
+bool AppearanceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAppearanceDictionary** data);
+bool isTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTextAnnotationDictionary** data);
+bool TextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTextAnnotationDictionary** data);
+bool isALinkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ALinkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfALinkAnnotationDictionary** data);
+bool ALinkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfALinkAnnotationDictionary** data);
+bool isFreeTextAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FreeTextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFreeTextAnnotationDictionary** data);
+bool FreeTextAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFreeTextAnnotationDictionary** data);
+bool isLineAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool LineAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLineAnnotationDictionary** data);
+bool LineAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLineAnnotationDictionary** data);
+bool isSquareOrCircleAnnotation(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SquareOrCircleAnnotationFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSquareOrCircleAnnotation** data);
+bool SquareOrCircleAnnotationFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSquareOrCircleAnnotation** data);
+bool isMarkupAnnotationsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MarkupAnnotationsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMarkupAnnotationsDictionary** data);
+bool MarkupAnnotationsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkupAnnotationsDictionary** data);
+bool isRubberStampAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool RubberStampAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfRubberStampAnnotationDictionary** data);
+bool RubberStampAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfRubberStampAnnotationDictionary** data);
+bool isInkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool InkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInkAnnotationDictionary** data);
+bool InkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInkAnnotationDictionary** data);
+bool isPopUpAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PopUpAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPopUpAnnotationDictionary** data);
+bool PopUpAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPopUpAnnotationDictionary** data);
+bool isFileAttachmentAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FileAttachmentAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFileAttachmentAnnotationDictionary** data);
+bool FileAttachmentAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFileAttachmentAnnotationDictionary** data);
+bool isSoundAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SoundAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoundAnnotationDictionary** data);
+bool SoundAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoundAnnotationDictionary** data);
+bool isMovieAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MovieAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieAnnotationDictionary** data);
+bool MovieAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieAnnotationDictionary** data);
+bool isWidgetAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WidgetAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWidgetAnnotationDictionary** data);
+bool WidgetAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWidgetAnnotationDictionary** data);
+bool isActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfActionDictionary** data);
+bool ActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfActionDictionary** data);
+bool isAnnotationActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool AnnotationActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAnnotationActionsDictionary** data);
+bool AnnotationActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAnnotationActionsDictionary** data);
+bool isPageObjectActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PageObjectActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPageObjectActionsDictionary** data);
+bool PageObjectActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPageObjectActionsDictionary** data);
+bool isFormFieldActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FormFieldActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFormFieldActionsDictionary** data);
+bool FormFieldActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFormFieldActionsDictionary** data);
+bool isDocumentCatalogActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool DocumentCatalogActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDocumentCatalogActionsDictionary** data);
+bool DocumentCatalogActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDocumentCatalogActionsDictionary** data);
+bool isGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool GoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfGoToActionDictionary** data);
+bool GoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfGoToActionDictionary** data);
+bool isRemoteGoToActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool RemoteGoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfRemoteGoToActionDictionary** data);
+bool RemoteGoToActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfRemoteGoToActionDictionary** data);
+bool isLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool LaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfLaunchActionDictionary** data);
+bool LaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfLaunchActionDictionary** data);
+bool isWindowsLaunchActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WindowsLaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWindowsLaunchActionDictionary** data);
+bool WindowsLaunchActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWindowsLaunchActionDictionary** data);
+bool isThreadActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ThreadActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfThreadActionDictionary** data);
+bool ThreadActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfThreadActionDictionary** data);
+bool isURIActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool URIActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfURIActionDictionary** data);
+bool URIActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfURIActionDictionary** data);
+bool isURIDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool URIDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfURIDictionary** data);
+bool URIDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfURIDictionary** data);
+bool isSoundActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SoundActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoundActionDictionary** data);
+bool SoundActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoundActionDictionary** data);
+bool isMovieActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MovieActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieActionDictionary** data);
+bool MovieActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieActionDictionary** data);
+bool isHideActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool HideActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfHideActionDictionary** data);
+bool HideActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfHideActionDictionary** data);
+bool isNamedActionsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool NamedActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfNamedActionsDictionary** data);
+bool NamedActionsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfNamedActionsDictionary** data);
+bool isInteractiveFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool InteractiveFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInteractiveFormDictionary** data);
+bool InteractiveFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInteractiveFormDictionary** data);
+bool isFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFieldDictionary** data);
+bool FieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFieldDictionary** data);
+bool isVariableTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool VariableTextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfVariableTextFieldDictionary** data);
+bool VariableTextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfVariableTextFieldDictionary** data);
+bool isAppearanceCharacteristicsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool AppearanceCharacteristicsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAppearanceCharacteristicsDictionary** data);
+bool AppearanceCharacteristicsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAppearanceCharacteristicsDictionary** data);
+bool isCheckboxFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool CheckboxFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfCheckboxFieldDictionary** data);
+bool CheckboxFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfCheckboxFieldDictionary** data);
+bool isRadioButtonFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool RadioButtonFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfRadioButtonFieldDictionary** data);
+bool RadioButtonFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfRadioButtonFieldDictionary** data);
+bool isTextFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTextFieldDictionary** data);
+bool TextFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTextFieldDictionary** data);
+bool isChoiceFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ChoiceFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfChoiceFieldDictionary** data);
+bool ChoiceFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfChoiceFieldDictionary** data);
+bool isSignatureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SignatureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSignatureDictionary** data);
+bool SignatureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSignatureDictionary** data);
+bool isSubmitFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SubmitFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSubmitFormActionDictionary** data);
+bool SubmitFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSubmitFormActionDictionary** data);
+bool isResetFormActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ResetFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfResetFormActionDictionary** data);
+bool ResetFormActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfResetFormActionDictionary** data);
+bool isImportDataActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ImportDataActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfImportDataActionDictionary** data);
+bool ImportDataActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfImportDataActionDictionary** data);
+bool isJavascriptActionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool JavascriptActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfJavascriptActionDictionary** data);
+bool JavascriptActionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfJavascriptActionDictionary** data);
+bool isFDFTrailerDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFTrailerDictionary** data);
+bool FDFTrailerDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFTrailerDictionary** data);
+bool isFDFCatalogDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFCatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFCatalogDictionary** data);
+bool FDFCatalogDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFCatalogDictionary** data);
+bool isFDFDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFDictionary** data);
+bool FDFDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFDictionary** data);
+bool isEncryptedEmbeddedFileStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool EncryptedEmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfEncryptedEmbeddedFileStreamDictionary** data);
+bool EncryptedEmbeddedFileStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfEncryptedEmbeddedFileStreamDictionary** data);
+bool isJavascriptDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool JavascriptDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfJavascriptDictionary** data);
+bool JavascriptDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfJavascriptDictionary** data);
+bool isFDFFieldDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFFieldDictionary** data);
+bool FDFFieldDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFFieldDictionary** data);
+bool isIconFitDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool IconFitDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfIconFitDictionary** data);
+bool IconFitDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfIconFitDictionary** data);
+bool isFDFPageDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFPageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFPageDictionary** data);
+bool FDFPageDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFPageDictionary** data);
+bool isFDFTemplateDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFTemplateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFTemplateDictionary** data);
+bool FDFTemplateDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFTemplateDictionary** data);
+bool isFDFNamedPageReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFNamedPageReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFNamedPageReferenceDictionary** data);
+bool FDFNamedPageReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFNamedPageReferenceDictionary** data);
+bool isFDFFileAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool FDFFileAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfFDFFileAnnotationDictionary** data);
+bool FDFFileAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfFDFFileAnnotationDictionary** data);
+bool isSoundObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SoundObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSoundObjectDictionary** data);
+bool SoundObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSoundObjectDictionary** data);
+bool isMovieDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MovieDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieDictionary** data);
+bool MovieDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieDictionary** data);
+bool isMovieActivationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MovieActivationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMovieActivationDictionary** data);
+bool MovieActivationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMovieActivationDictionary** data);
+bool isDocumentInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool DocumentInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfDocumentInformationDictionary** data);
+bool DocumentInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfDocumentInformationDictionary** data);
+bool isMetadataStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MetadataStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMetadataStreamDictionary** data);
+bool MetadataStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMetadataStreamDictionary** data);
+bool isComponentsWithMetadataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ComponentsWithMetadataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfComponentsWithMetadataDictionary** data);
+bool ComponentsWithMetadataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfComponentsWithMetadataDictionary** data);
+bool isPagePieceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PagePieceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPagePieceDictionary** data);
+bool PagePieceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPagePieceDictionary** data);
+bool isApplicationDataDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ApplicationDataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfApplicationDataDictionary** data);
+bool ApplicationDataDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfApplicationDataDictionary** data);
+bool isStructureTreeRootDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StructureTreeRootDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStructureTreeRootDictionary** data);
+bool StructureTreeRootDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureTreeRootDictionary** data);
+bool isStructureElementDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StructureElementDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStructureElementDictionary** data);
+bool StructureElementDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureElementDictionary** data);
+bool isMarkedContentReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MarkedContentReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMarkedContentReferenceDictionary** data);
+bool MarkedContentReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkedContentReferenceDictionary** data);
+bool isObjectReferenceDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ObjectReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfObjectReferenceDictionary** data);
+bool ObjectReferenceDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfObjectReferenceDictionary** data);
+bool isStructureElementAccessDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StructureElementAccessDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStructureElementAccessDictionary** data);
+bool StructureElementAccessDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStructureElementAccessDictionary** data);
+bool isAttributeObjectDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool AttributeObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfAttributeObjectDictionary** data);
+bool AttributeObjectDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfAttributeObjectDictionary** data);
+bool isMarkInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MarkInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMarkInformationDictionary** data);
+bool MarkInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMarkInformationDictionary** data);
+bool isArtifactsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ArtifactsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfArtifactsDictionary** data);
+bool ArtifactsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfArtifactsDictionary** data);
+bool isStandardStructureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool StandardStructureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfStandardStructureDictionary** data);
+bool StandardStructureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfStandardStructureDictionary** data);
+bool isBlockLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool BlockLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBlockLevelStructureElementsDictionary** data);
+bool BlockLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBlockLevelStructureElementsDictionary** data);
+bool isInlineLevelStructureElementsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool InlineLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfInlineLevelStructureElementsDictionary** data);
+bool InlineLevelStructureElementsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfInlineLevelStructureElementsDictionary** data);
+bool isListAttributeDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool ListAttributeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfListAttributeDictionary** data);
+bool ListAttributeDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfListAttributeDictionary** data);
+bool isTableAttributesDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TableAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTableAttributesDictionary** data);
+bool TableAttributesDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTableAttributesDictionary** data);
+bool isWebCaptureInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WebCaptureInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureInformationDictionary** data);
+bool WebCaptureInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureInformationDictionary** data);
+bool isWebCaptureDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WebCaptureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureDictionary** data);
+bool WebCaptureDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureDictionary** data);
+bool isWebCapturePageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WebCapturePageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCapturePageSetDictionary** data);
+bool WebCapturePageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCapturePageSetDictionary** data);
+bool isWebCaptureImageSetDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WebCaptureImageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureImageSetDictionary** data);
+bool WebCaptureImageSetDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureImageSetDictionary** data);
+bool isSourceInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SourceInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSourceInformationDictionary** data);
+bool SourceInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSourceInformationDictionary** data);
+bool isURLAliasDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool URLAliasDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfURLAliasDictionary** data);
+bool URLAliasDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfURLAliasDictionary** data);
+bool isWebCaptureCommandDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WebCaptureCommandDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureCommandDictionary** data);
+bool WebCaptureCommandDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureCommandDictionary** data);
+bool isWebCaptureCommandSettingsDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool WebCaptureCommandSettingsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfWebCaptureCommandSettingsDictionary** data);
+bool WebCaptureCommandSettingsDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfWebCaptureCommandSettingsDictionary** data);
+bool isBoxColorInformationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool BoxColorInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBoxColorInformationDictionary** data);
+bool BoxColorInformationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBoxColorInformationDictionary** data);
+bool isBoxStyleDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool BoxStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfBoxStyleDictionary** data);
+bool BoxStyleDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfBoxStyleDictionary** data);
+bool isPrinterMarkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PrinterMarkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPrinterMarkAnnotationDictionary** data);
+bool PrinterMarkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPrinterMarkAnnotationDictionary** data);
+bool isPrinterMarkFormDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PrinterMarkFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPrinterMarkFormDictionary** data);
+bool PrinterMarkFormDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPrinterMarkFormDictionary** data);
+bool isSeparationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool SeparationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfSeparationDictionary** data);
+bool SeparationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfSeparationDictionary** data);
+bool isPDF_XOutputIntentDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool PDF_XOutputIntentDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfPDF_XOutputIntentDictionary** data);
+bool PDF_XOutputIntentDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfPDF_XOutputIntentDictionary** data);
+bool isTrapNetworkAnnotationDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TrapNetworkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTrapNetworkAnnotationDictionary** data);
+bool TrapNetworkAnnotationDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTrapNetworkAnnotationDictionary** data);
+bool isTrapNetworkAppearanceStreamDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool TrapNetworkAppearanceStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfTrapNetworkAppearanceStreamDictionary** data);
+bool TrapNetworkAppearanceStreamDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfTrapNetworkAppearanceStreamDictionary** data);
+bool isOpiVersionDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool OpiVersionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfOpiVersionDictionary** data);
+bool OpiVersionDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfOpiVersionDictionary** data);
+bool isMultiMasterFontDictionary(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);
+bool MultiMasterFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdfMultiMasterFontDictionary** data);
+bool MultiMasterFontDictionaryFromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdfMultiMasterFontDictionary** data);
 
 #endif  // __DEFINED__SkPdfPodofoMapper
diff --git a/experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..35f68a0
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfPopUpAnnotationDictionary_autogen.h"
+
+std::string SkPdfPopUpAnnotationDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfPopUpAnnotationDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfPopUpAnnotationDictionary::Parent() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+bool SkPdfPopUpAnnotationDictionary::Open() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.h
index 6c1e25f..b3dc293 100644
--- a/experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPopUpAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Optional; PDF 1.4) An alternate representation of the annotation's contents
  *  in human-readable form, useful when extracting the document's contents in
  *  support of accessibility to disabled users or for other purposes (see Section
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Optional; must be an indirect reference) The parent annotation with which
  *  this pop-up annotation is associated.
  *  Note: If this entry is present, the parent annotation's Contents, M, C, and T
@@ -565,13 +553,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", NULL));
   }
 
-  SkPdfDictionary* Parent() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Parent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Parent() const;
 /** (Optional) A flag specifying whether the pop-up annotation should initially
  *  be displayed open. Default value: false (closed).
 **/
@@ -579,13 +561,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", NULL));
   }
 
-  bool Open() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool Open() const;
 };
 
 #endif  // __DEFINED__SkPdfPopUpAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPrinterMarkAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPrinterMarkAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..8607e11
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPrinterMarkAnnotationDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfPrinterMarkAnnotationDictionary_autogen.h"
+
+std::string SkPdfPrinterMarkAnnotationDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfPrinterMarkAnnotationDictionary::MN() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MN", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPrinterMarkAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPrinterMarkAnnotationDictionary_autogen.h
index 07f7ff0..c6f8af3 100644
--- a/experimental/PdfViewer/autogen/SkPdfPrinterMarkAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPrinterMarkAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Optional) An arbitrary name identifying the type of printer's mark, such as Color-
  *  Bar or RegistrationTarget.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MN", "", NULL));
   }
 
-  std::string MN() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MN", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string MN() const;
 };
 
 #endif  // __DEFINED__SkPdfPrinterMarkAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfPrinterMarkFormDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfPrinterMarkFormDictionary_autogen.cpp
new file mode 100644
index 0000000..3d7c3f6
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfPrinterMarkFormDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfPrinterMarkFormDictionary_autogen.h"
+
+std::string SkPdfPrinterMarkFormDictionary::MarkStyle() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MarkStyle", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfPrinterMarkFormDictionary::Colorants() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colorants", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfPrinterMarkFormDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfPrinterMarkFormDictionary_autogen.h
index 1463783..3c2124b 100644
--- a/experimental/PdfViewer/autogen/SkPdfPrinterMarkFormDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfPrinterMarkFormDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MarkStyle", "", NULL));
   }
 
-  std::string MarkStyle() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MarkStyle", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string MarkStyle() const;
 /** (Optional; PDF 1.4) A dictionary identifying the individual colorants
  *  associated with a printer's mark such as a color bar. For each entry in this
  *  dictionary, the key is a colorant name and the value is an array defining a
@@ -550,13 +544,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colorants", "", NULL));
   }
 
-  SkPdfDictionary* Colorants() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Colorants", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Colorants() const;
 };
 
 #endif  // __DEFINED__SkPdfPrinterMarkFormDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfRadioButtonFieldDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfRadioButtonFieldDictionary_autogen.cpp
new file mode 100644
index 0000000..ac178fc
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfRadioButtonFieldDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfRadioButtonFieldDictionary_autogen.h"
+
+SkPdfArray* SkPdfRadioButtonFieldDictionary::Opt() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfRadioButtonFieldDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfRadioButtonFieldDictionary_autogen.h
index 35851bd..67fda2e 100644
--- a/experimental/PdfViewer/autogen/SkPdfRadioButtonFieldDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfRadioButtonFieldDictionary_autogen.h
@@ -535,13 +535,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", NULL));
   }
 
-  SkPdfArray* Opt() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Opt", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Opt() const;
 };
 
 #endif  // __DEFINED__SkPdfRadioButtonFieldDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfReferenceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfReferenceDictionary_autogen.cpp
new file mode 100644
index 0000000..e901c3e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfReferenceDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfReferenceDictionary_autogen.h"
+
+SkPdfFileSpec SkPdfReferenceDictionary::F() const {
+  SkPdfFileSpec ret;
+  if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFileSpec();
+}
+
+long SkPdfReferenceDictionary::getPageAsInteger() const {
+  long ret = 0;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfReferenceDictionary::getPageAsString() const {
+  std::string ret = "";
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfReferenceDictionary::ID() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfReferenceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfReferenceDictionary_autogen.h
index dc4d679..3a0253c 100644
--- a/experimental/PdfViewer/autogen/SkPdfReferenceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfReferenceDictionary_autogen.h
@@ -531,13 +531,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  SkPdfFileSpec F() const {
-    SkPdfFileSpec ret;
-    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFileSpec();
-  }
-
+  SkPdfFileSpec F() const;
 /** (Required) A page index or page label (see Section 8.3.1, "Page Labels")
  *  identifying the page of the target document containing the content to be
  *  imported. Note that the reference is a weak one and can be inadvertently in-
@@ -554,26 +548,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Number;
   }
 
-  long getPageAsInteger() const {
-    long ret = 0;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long getPageAsInteger() const;
   bool isPageAString() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  std::string getPageAsString() const {
-    std::string ret = "";
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Page", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getPageAsString() const;
 /** (Optional) An array of two strings constituting a file identifier (see Section 9.3,
  *  "File Identifiers") for the file containing the target document. The use of this
  *  entry improves a viewer application's chances of finding the intended file and
@@ -583,13 +565,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
   }
 
-  SkPdfArray* ID() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* ID() const;
 };
 
 #endif  // __DEFINED__SkPdfReferenceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfReference_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfReference_autogen.cpp
new file mode 100644
index 0000000..f78ef63
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfReference_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfReference_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfRemoteGoToActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfRemoteGoToActionDictionary_autogen.cpp
new file mode 100644
index 0000000..b867053
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfRemoteGoToActionDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfRemoteGoToActionDictionary_autogen.h"
+
+std::string SkPdfRemoteGoToActionDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfFileSpec SkPdfRemoteGoToActionDictionary::F() const {
+  SkPdfFileSpec ret;
+  if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFileSpec();
+}
+
+std::string SkPdfRemoteGoToActionDictionary::getDAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfRemoteGoToActionDictionary::getDAsString() const {
+  std::string ret = "";
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfRemoteGoToActionDictionary::getDAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+bool SkPdfRemoteGoToActionDictionary::NewWindow() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfRemoteGoToActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfRemoteGoToActionDictionary_autogen.h
index eb42612..9ae32ca 100644
--- a/experimental/PdfViewer/autogen/SkPdfRemoteGoToActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfRemoteGoToActionDictionary_autogen.h
@@ -532,26 +532,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required) The file in which the destination is located.
 **/
   bool has_F() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  SkPdfFileSpec F() const {
-    SkPdfFileSpec ret;
-    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFileSpec();
-  }
-
+  SkPdfFileSpec F() const;
 /** (Required) The destination to jump to (see Section 8.2.1, "Destinations"). If
  *  the value is an array defining an explicit destination (as described under
  *  "Explicit Destinations" on page 474), its first element must be a page number
@@ -568,39 +556,21 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getDAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getDAsName() const;
   bool isDAString() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  std::string getDAsString() const {
-    std::string ret = "";
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getDAsString() const;
   bool isDAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getDAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getDAsArray() const;
 /** (Optional; PDF 1.2) A flag specifying whether to open the destination docu-
  *  ment in a new window. If this flag is false, the destination document will
  *  replace the current document in the same window. If this entry is absent,
@@ -611,13 +581,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", NULL));
   }
 
-  bool NewWindow() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NewWindow", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool NewWindow() const;
 };
 
 #endif  // __DEFINED__SkPdfRemoteGoToActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfResetFormActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfResetFormActionDictionary_autogen.cpp
new file mode 100644
index 0000000..78a0eb4
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfResetFormActionDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfResetFormActionDictionary_autogen.h"
+
+std::string SkPdfResetFormActionDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfResetFormActionDictionary::Fields() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfResetFormActionDictionary::Flags() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfResetFormActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfResetFormActionDictionary_autogen.h
index b4efb99..206fa20 100644
--- a/experimental/PdfViewer/autogen/SkPdfResetFormActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfResetFormActionDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Optional) An array identifying which fields to reset or which to exclude
  *  from resetting, depending on the setting of the Include/Exclude flag in
  *  the Flags entry (see Table 8.64). Each element of the array is either an in-
@@ -552,13 +546,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", NULL));
   }
 
-  SkPdfArray* Fields() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Fields() const;
 /** (Optional; inheritable) A set of flags specifying various characteristics of
  *  the action (see Table 8.64). Default value: 0.
 **/
@@ -566,13 +554,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", NULL));
   }
 
-  long Flags() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Flags() const;
 };
 
 #endif  // __DEFINED__SkPdfResetFormActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfResourceDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfResourceDictionary_autogen.cpp
new file mode 100644
index 0000000..5f4e045
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfResourceDictionary_autogen.cpp
@@ -0,0 +1,58 @@
+#include "SkPdfResourceDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfResourceDictionary::ExtGState() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ExtGState", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfResourceDictionary::ColorSpace() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfResourceDictionary::Pattern() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pattern", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfResourceDictionary::Shading() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfResourceDictionary::XObject() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XObject", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfResourceDictionary::Font() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfResourceDictionary::ProcSet() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ProcSet", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfResourceDictionary::Properties() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Properties", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfResourceDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfResourceDictionary_autogen.h
index bd7079d..a339701 100644
--- a/experimental/PdfViewer/autogen/SkPdfResourceDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfResourceDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ExtGState", "", NULL));
   }
 
-  SkPdfDictionary* ExtGState() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ExtGState", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* ExtGState() const;
 /** (Optional) A dictionary mapping each resource name to either the name of a
  *  device-dependent color space or an array describing a color space (see Sec-
  *  tion 4.5, "Color Spaces").
@@ -547,13 +541,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", NULL));
   }
 
-  SkPdfDictionary* ColorSpace() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* ColorSpace() const;
 /** (Optional) A dictionary mapping resource names to pattern objects (see Sec-
  *  tion 4.6, "Patterns").
 **/
@@ -561,13 +549,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pattern", "", NULL));
   }
 
-  SkPdfDictionary* Pattern() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pattern", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Pattern() const;
 /** (Optional; PDF 1.3) A dictionary mapping resource names to shading dic-
  *  tionaries (see "Shading Dictionaries" on page 233).
 **/
@@ -575,13 +557,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", NULL));
   }
 
-  SkPdfDictionary* Shading() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Shading() const;
 /** (Optional) A dictionary mapping resource names to external objects (see Sec-
  *  tion 4.7, "External Objects").
 **/
@@ -589,13 +565,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XObject", "", NULL));
   }
 
-  SkPdfDictionary* XObject() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "XObject", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* XObject() const;
 /** (Optional) A dictionary mapping resource names to font dictionaries (see
  *  Chapter 5).
 **/
@@ -603,13 +573,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", NULL));
   }
 
-  SkPdfDictionary* Font() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Font", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Font() const;
 /** (Optional) An array of predefined procedure set names (see Section 9.1,
  *  "Procedure Sets").
 **/
@@ -617,13 +581,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ProcSet", "", NULL));
   }
 
-  SkPdfArray* ProcSet() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ProcSet", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* ProcSet() const;
 /** (Optional; PDF 1.2) A dictionary mapping resource names to property list
  *  dictionaries for marked content (see Section 9.5.1, "Property Lists").
 **/
@@ -631,13 +589,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Properties", "", NULL));
   }
 
-  SkPdfDictionary* Properties() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Properties", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Properties() const;
 };
 
 #endif  // __DEFINED__SkPdfResourceDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfRubberStampAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfRubberStampAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..6636d98
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfRubberStampAnnotationDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfRubberStampAnnotationDictionary_autogen.h"
+
+std::string SkPdfRubberStampAnnotationDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfRubberStampAnnotationDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfRubberStampAnnotationDictionary::Name() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfRubberStampAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfRubberStampAnnotationDictionary_autogen.h
index 1d56702..b810ebc 100644
--- a/experimental/PdfViewer/autogen/SkPdfRubberStampAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfRubberStampAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required) The text to be displayed in the pop-up window when the annotation
  *  is opened. Carriage returns may be used to separate the text into paragraphs.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Optional) The name of an icon to be used in displaying the annotation. Viewer
  *  applications should provide predefined icon appearances for at least the follow-
  *  ing standard names:
@@ -569,13 +557,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
   }
 
-  std::string Name() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Name() const;
 };
 
 #endif  // __DEFINED__SkPdfRubberStampAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSeparationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSeparationDictionary_autogen.cpp
new file mode 100644
index 0000000..533e5d5
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSeparationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfSeparationDictionary_autogen.h"
+
+SkPdfArray* SkPdfSeparationDictionary::Pages() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfSeparationDictionary::getDeviceColorantAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfSeparationDictionary::getDeviceColorantAsString() const {
+  std::string ret = "";
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfSeparationDictionary::ColorSpace() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSeparationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSeparationDictionary_autogen.h
index 1c48aba..d4a2c3e 100644
--- a/experimental/PdfViewer/autogen/SkPdfSeparationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSeparationDictionary_autogen.h
@@ -535,13 +535,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", NULL));
   }
 
-  SkPdfArray* Pages() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pages", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Pages() const;
 /** (Required) The name of the device colorant to be used in rendering this
  *  separation, such as Cyan or PANTONE 35 CV.
 **/
@@ -555,26 +549,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getDeviceColorantAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getDeviceColorantAsName() const;
   bool isDeviceColorantAString() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  std::string getDeviceColorantAsString() const {
-    std::string ret = "";
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DeviceColorant", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getDeviceColorantAsString() const;
 /** (Optional) An array defining a Separation or DeviceN color space (see "Separa-
  *  tion Color Spaces" on page 201 and "DeviceN Color Spaces" on page 205). This
  *  provides additional information about the color specified by DeviceColorant-
@@ -590,13 +572,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", NULL));
   }
 
-  SkPdfArray* ColorSpace() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* ColorSpace() const;
 };
 
 #endif  // __DEFINED__SkPdfSeparationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfShadingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfShadingDictionary_autogen.cpp
new file mode 100644
index 0000000..61b986a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfShadingDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfShadingDictionary_autogen.h"
+
+long SkPdfShadingDictionary::ShadingType() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShadingType", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfShadingDictionary::getColorSpaceAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfShadingDictionary::getColorSpaceAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfShadingDictionary::Background() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Background", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkRect* SkPdfShadingDictionary::BBox() const {
+  SkRect* ret;
+  if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+bool SkPdfShadingDictionary::AntiAlias() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AntiAlias", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfShadingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfShadingDictionary_autogen.h
index b859b46..2009666 100644
--- a/experimental/PdfViewer/autogen/SkPdfShadingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfShadingDictionary_autogen.h
@@ -520,13 +520,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShadingType", "", NULL));
   }
 
-  long ShadingType() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ShadingType", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long ShadingType() const;
 /** (Required) The color space in which color values are expressed. This may be
  *  any device, CIE-based, or special color space except a Pattern space. See
  *  "Color Space: Special Considerations," below, for further information.
@@ -541,26 +535,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getColorSpaceAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getColorSpaceAsName() const;
   bool isColorSpaceAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getColorSpaceAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColorSpace", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getColorSpaceAsArray() const;
 /** (Optional) An array of color components appropriate to the color space,
  *  specifying a single background color value. If present, this color is used be-
  *  fore any painting operation involving the shading, to fill those portions of the
@@ -575,13 +557,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Background", "", NULL));
   }
 
-  SkPdfArray* Background() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Background", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Background() const;
 /** (Optional) An array of four numbers giving the left, bottom, right, and top
  *  coordinates, respectively, of the shading's bounding box. The coordinates are
  *  interpreted in the shading's target coordinate space. If present, this bounding
@@ -593,13 +569,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", NULL));
   }
 
-  SkRect* BBox() const {
-    SkRect* ret;
-    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkRect* BBox() const;
 /** (Optional) A flag indicating whether to filter the shading function to prevent
  *  aliasing artifacts. The shading operators sample shading functions at a rate
  *  determined by the resolution of the output device. Aliasing can occur if the
@@ -614,13 +584,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AntiAlias", "", NULL));
   }
 
-  bool AntiAlias() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AntiAlias", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool AntiAlias() const;
 };
 
 #endif  // __DEFINED__SkPdfShadingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSignatureDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSignatureDictionary_autogen.cpp
new file mode 100644
index 0000000..924cb9a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSignatureDictionary_autogen.cpp
@@ -0,0 +1,65 @@
+#include "SkPdfSignatureDictionary_autogen.h"
+
+std::string SkPdfSignatureDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfSignatureDictionary::Filter() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfSignatureDictionary::SubFilter() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SubFilter", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfSignatureDictionary::ByteRange() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ByteRange", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfSignatureDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfSignatureDictionary::Name() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDate SkPdfSignatureDictionary::M() const {
+  SkPdfDate ret;
+  if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfDate();
+}
+
+std::string SkPdfSignatureDictionary::Location() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Location", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfSignatureDictionary::Reason() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Reason", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSignatureDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSignatureDictionary_autogen.h
index cdb249c..e365ef6 100644
--- a/experimental/PdfViewer/autogen/SkPdfSignatureDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSignatureDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required; inheritable) The name of the signature handler to be used for
  *  authenticating the field's contents, such as Adobe.PPKLite, Entrust.PPKEF,
  *  CICI.SignIt, or VeriSign.PPKVS.
@@ -547,26 +541,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", NULL));
   }
 
-  std::string Filter() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Filter() const;
 /** (Optional) The name of a specific submethod of the specified handler.
 **/
   bool has_SubFilter() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SubFilter", "", NULL));
   }
 
-  std::string SubFilter() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SubFilter", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string SubFilter() const;
 /** (Required) An array of pairs of integers (starting byte offset, length in bytes)
  *  describing the exact byte range for the digest calculation. Multiple discontig-
  *  uous byte ranges may be used to describe a digest that does not include the
@@ -576,39 +558,21 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ByteRange", "", NULL));
   }
 
-  SkPdfArray* ByteRange() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ByteRange", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* ByteRange() const;
 /** (Required) The encrypted signature token.
 **/
   bool has_Contents() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Optional) The name of the person or authority signing the document.
 **/
   bool has_Name() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
   }
 
-  std::string Name() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Name() const;
 /** (Optional) The time of signing. Depending on the signature handler, this
  *  may be a normal unverified computer time or a time generated in a verifiable
  *  way from a secure time server.
@@ -617,39 +581,21 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", NULL));
   }
 
-  SkPdfDate M() const {
-    SkPdfDate ret;
-    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfDate();
-  }
-
+  SkPdfDate M() const;
 /** (Optional) The CPU host name or physical location of the signing.
 **/
   bool has_Location() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Location", "", NULL));
   }
 
-  std::string Location() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Location", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Location() const;
 /** (Optional) The reason for the signing, such as (I agree...).
 **/
   bool has_Reason() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Reason", "", NULL));
   }
 
-  std::string Reason() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Reason", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Reason() const;
 };
 
 #endif  // __DEFINED__SkPdfSignatureDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSoftMaskDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSoftMaskDictionary_autogen.cpp
new file mode 100644
index 0000000..b6a7e48
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSoftMaskDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfSoftMaskDictionary_autogen.h"
+
+std::string SkPdfSoftMaskDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfSoftMaskDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfStream* SkPdfSoftMaskDictionary::G() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfSoftMaskDictionary::BC() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfFunction SkPdfSoftMaskDictionary::getTRAsFunction() const {
+  SkPdfFunction ret = SkPdfFunction();
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
+std::string SkPdfSoftMaskDictionary::getTRAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSoftMaskDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSoftMaskDictionary_autogen.h
index 73295e0..735a359 100644
--- a/experimental/PdfViewer/autogen/SkPdfSoftMaskDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSoftMaskDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) A subtype specifying the method to be used in deriving the mask
  *  values from the transparency group specified by the G entry:
  *     Alpha          Use the group's computed alpha, disregarding its color (see
@@ -551,13 +545,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required) A transparency group XObject (see Section 7.5.5, "Transparency
  *  Group XObjects") to be used as the source of alpha or color values for deriv-
  *  ing the mask. If the subtype S is Luminosity, the group attributes dictionary
@@ -568,13 +556,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", NULL));
   }
 
-  SkPdfStream* G() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* G() const;
 /** (Optional) An array of component values specifying the color to be used as
  *  the backdrop against which to composite the transparency group XObject G.
  *  This entry is consulted only if the subtype S is Luminosity. The array consists
@@ -587,13 +569,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", NULL));
   }
 
-  SkPdfArray* BC() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BC", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* BC() const;
 /** (Optional) A function object (see Section 3.9, "Functions") specifying the
  *  transfer function to be used in deriving the mask values. The function ac-
  *  cepts one input, the computed group alpha or luminosity (depending on the
@@ -613,26 +589,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfFunction getTRAsFunction() const {
-    SkPdfFunction ret = SkPdfFunction();
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction getTRAsFunction() const;
   bool isTRAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getTRAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TR", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getTRAsName() const;
 };
 
 #endif  // __DEFINED__SkPdfSoftMaskDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSoftMaskImageDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSoftMaskImageDictionary_autogen.cpp
new file mode 100644
index 0000000..c2fb208
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSoftMaskImageDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfSoftMaskImageDictionary_autogen.h"
+
+SkPdfArray* SkPdfSoftMaskImageDictionary::Matte() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matte", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSoftMaskImageDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSoftMaskImageDictionary_autogen.h
index 4ca3995..259a46b 100644
--- a/experimental/PdfViewer/autogen/SkPdfSoftMaskImageDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSoftMaskImageDictionary_autogen.h
@@ -536,13 +536,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matte", "", NULL));
   }
 
-  SkPdfArray* Matte() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matte", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Matte() const;
 };
 
 #endif  // __DEFINED__SkPdfSoftMaskImageDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSoundActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSoundActionDictionary_autogen.cpp
new file mode 100644
index 0000000..e98c8a0
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSoundActionDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfSoundActionDictionary_autogen.h"
+
+std::string SkPdfSoundActionDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfStream* SkPdfSoundActionDictionary::Sound() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+double SkPdfSoundActionDictionary::Volume() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Volume", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+bool SkPdfSoundActionDictionary::Synchronous() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+bool SkPdfSoundActionDictionary::Repeat() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Repeat", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+bool SkPdfSoundActionDictionary::Mix() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mix", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSoundActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSoundActionDictionary_autogen.h
index be04ec6..f300de4 100644
--- a/experimental/PdfViewer/autogen/SkPdfSoundActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSoundActionDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required) A sound object defining the sound to be played (see Section 8.7,
  *  "Sounds"; see also implementation note 76 in Appendix H).
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", NULL));
   }
 
-  SkPdfStream* Sound() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* Sound() const;
 /** (Optional) The volume at which to play the sound, in the range -1.0 to 1.0.
  *  Higher values denote greater volume; negative values mute the sound.
  *  Default value: 1.0.
@@ -561,13 +549,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Volume", "", NULL));
   }
 
-  double Volume() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Volume", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double Volume() const;
 /** (Optional) A flag specifying whether to play the sound synchronously or
  *  asynchronously. If this flag is true, the viewer application will retain control,
  *  allowing no further user interaction other than canceling the sound, until the
@@ -577,13 +559,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", NULL));
   }
 
-  bool Synchronous() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Synchronous", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool Synchronous() const;
 /** (Optional) A flag specifying whether to repeat the sound indefinitely. If this
  *  entry is present, the Synchronous entry is ignored. Default value: false.
 **/
@@ -591,13 +567,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Repeat", "", NULL));
   }
 
-  bool Repeat() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Repeat", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool Repeat() const;
 /** (Optional) A flag specifying whether to mix this sound with any other sound
  *  already playing. If this flag is false, any previously playing sound will be
  *  stopped before starting this sound; this can be used to stop a repeating sound
@@ -607,13 +577,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mix", "", NULL));
   }
 
-  bool Mix() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Mix", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool Mix() const;
 };
 
 #endif  // __DEFINED__SkPdfSoundActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSoundAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSoundAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..f9ad2bc
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSoundAnnotationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfSoundAnnotationDictionary_autogen.h"
+
+std::string SkPdfSoundAnnotationDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfStream* SkPdfSoundAnnotationDictionary::Sound() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfSoundAnnotationDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfSoundAnnotationDictionary::Name() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSoundAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSoundAnnotationDictionary_autogen.h
index 523ff1d..6e37c87 100644
--- a/experimental/PdfViewer/autogen/SkPdfSoundAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSoundAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required) A sound object defining the sound to be played when the annotation
  *  is activated (see Section 8.7, "Sounds").
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", NULL));
   }
 
-  SkPdfStream* Sound() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Sound", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* Sound() const;
 /** (Optional) Text to be displayed in a pop-up window for the annotation in place
  *  of the sound, useful when extracting the document's contents in support of
  *  accessibility to disabled users or for other purposes (see Section 9.8.2, "Alternate
@@ -562,13 +550,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Optional) The name of an icon to be used in displaying the annotation. Viewer
  *  applications should provide predefined icon appearances for at least the stan-
  *  dard names Speaker and Microphone; additional names may be supported as
@@ -580,13 +562,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
   }
 
-  std::string Name() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Name() const;
 };
 
 #endif  // __DEFINED__SkPdfSoundAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSoundObjectDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSoundObjectDictionary_autogen.cpp
new file mode 100644
index 0000000..f05bf22
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSoundObjectDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfSoundObjectDictionary_autogen.h"
+
+std::string SkPdfSoundObjectDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+double SkPdfSoundObjectDictionary::R() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfSoundObjectDictionary::C() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfSoundObjectDictionary::B() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfSoundObjectDictionary::E() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfSoundObjectDictionary::CO() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfObject* SkPdfSoundObjectDictionary::CP() const {
+  SkPdfObject* ret;
+  if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CP", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSoundObjectDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSoundObjectDictionary_autogen.h
index 09ff7d0..34a40b3 100644
--- a/experimental/PdfViewer/autogen/SkPdfSoundObjectDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSoundObjectDictionary_autogen.h
@@ -532,26 +532,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The sampling rate, in samples per second.
 **/
   bool has_R() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", NULL));
   }
 
-  double R() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double R() const;
 /** (Optional) The number of sound channels. Default value: 1. (See implementation
  *  note 101 in Appendix H.)
 **/
@@ -559,26 +547,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
   }
 
-  long C() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long C() const;
 /** (Optional) The number of bits per sample value per channel. Default value: 8.
 **/
   bool has_B() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", NULL));
   }
 
-  long B() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long B() const;
 /** (Optional) The encoding format for the sample data:
  *     Raw          Unspecified or unsigned values in the range 0 to 2B - 1
  *     Signed       Twos-complement values
@@ -590,13 +566,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", NULL));
   }
 
-  std::string E() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string E() const;
 /** (Optional) The sound compression format used on the sample data. (Note that this is
  *  separate from any stream compression specified by the sound object's Filter entry; see
  *  Table 3.4 on page 38 and Section 3.3, "Filters.") If this entry is absent, then no sound
@@ -607,13 +577,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", NULL));
   }
 
-  std::string CO() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CO", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string CO() const;
 /** (Optional) Optional parameters specific to the sound compression format used.
  *  Note: At the time of publication, no standard values have been defined for the CO and CP
  *  entries.
@@ -622,13 +586,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CP", "", NULL));
   }
 
-  SkPdfObject* CP() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CP", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfObject* CP() const;
 };
 
 #endif  // __DEFINED__SkPdfSoundObjectDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSourceInformationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSourceInformationDictionary_autogen.cpp
new file mode 100644
index 0000000..6bf902e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSourceInformationDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfSourceInformationDictionary_autogen.h"
+
+std::string SkPdfSourceInformationDictionary::getAUAsString() const {
+  std::string ret = "";
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfSourceInformationDictionary::getAUAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDate SkPdfSourceInformationDictionary::TS() const {
+  SkPdfDate ret;
+  if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfDate();
+}
+
+SkPdfDate SkPdfSourceInformationDictionary::E() const {
+  SkPdfDate ret;
+  if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfDate();
+}
+
+long SkPdfSourceInformationDictionary::S() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfDictionary* SkPdfSourceInformationDictionary::C() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSourceInformationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSourceInformationDictionary_autogen.h
index 27d01d5..83cfb9a 100644
--- a/experimental/PdfViewer/autogen/SkPdfSourceInformationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSourceInformationDictionary_autogen.h
@@ -538,26 +538,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  std::string getAUAsString() const {
-    std::string ret = "";
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getAUAsString() const;
   bool isAUADictionary() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getAUAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AU", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getAUAsDictionary() const;
 /** (Optional) A time stamp giving the most recent date and time at which the content
  *  set's contents were known to be up to date with the source data.
 **/
@@ -565,13 +553,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", NULL));
   }
 
-  SkPdfDate TS() const {
-    SkPdfDate ret;
-    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfDate();
-  }
-
+  SkPdfDate TS() const;
 /** (Optional) An expiration stamp giving the date and time at which the content set's
  *  contents should be considered out of date with the source data.
 **/
@@ -579,13 +561,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", NULL));
   }
 
-  SkPdfDate E() const {
-    SkPdfDate ret;
-    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "E", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfDate();
-  }
-
+  SkPdfDate E() const;
 /** (Optional) A code indicating the type of form submission, if any, by which the source
  *  data was accessed (see "Submit-Form Actions" on page 550):
  *      0    Not accessed via a form submission
@@ -598,13 +574,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  long S() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long S() const;
 /** (Optional; must be an indirect reference) A command dictionary (see "Command Dic-
  *  tionaries" on page 672) describing the command that caused the source data to be
  *  retrieved. This entry should be present only in source information dictionaries associ-
@@ -614,13 +584,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
   }
 
-  SkPdfDictionary* C() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* C() const;
 };
 
 #endif  // __DEFINED__SkPdfSourceInformationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSquareOrCircleAnnotation_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSquareOrCircleAnnotation_autogen.cpp
new file mode 100644
index 0000000..cdf2f68
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSquareOrCircleAnnotation_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfSquareOrCircleAnnotation_autogen.h"
+
+std::string SkPdfSquareOrCircleAnnotation::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfSquareOrCircleAnnotation::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfSquareOrCircleAnnotation::BS() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfSquareOrCircleAnnotation::IC() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSquareOrCircleAnnotation_autogen.h b/experimental/PdfViewer/autogen/SkPdfSquareOrCircleAnnotation_autogen.h
index 1c746d6..ce9864f 100644
--- a/experimental/PdfViewer/autogen/SkPdfSquareOrCircleAnnotation_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSquareOrCircleAnnotation_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required) The text to be displayed in the pop-up window when the annotation
  *  is opened. Carriage returns may be used to separate the text into paragraphs.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Optional) A border style dictionary (see Table 8.12 on page 495) specifying the
  *  line width and dash pattern to be used in drawing the rectangle or ellipse.
  *  Note: The annotation dictionary's AP entry, if present, takes precedence over the
@@ -563,13 +551,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", NULL));
   }
 
-  SkPdfDictionary* BS() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* BS() const;
 /** (Optional; PDF 1.4) An array of three numbers in the range 0.0 to 1.0 specifying
  *  the components, in the DeviceRGB color space, of the interior color with which to
  *  fill the annotation's rectangle or ellipse (see Table 8.19). If this entry is absent,
@@ -579,13 +561,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", NULL));
   }
 
-  SkPdfArray* IC() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IC", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* IC() const;
 };
 
 #endif  // __DEFINED__SkPdfSquareOrCircleAnnotation
diff --git a/experimental/PdfViewer/autogen/SkPdfStandardSecurityHandlerDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfStandardSecurityHandlerDictionary_autogen.cpp
new file mode 100644
index 0000000..d8adbcf
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfStandardSecurityHandlerDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfStandardSecurityHandlerDictionary_autogen.h"
+
+double SkPdfStandardSecurityHandlerDictionary::R() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfStandardSecurityHandlerDictionary::O() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfStandardSecurityHandlerDictionary::U() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfStandardSecurityHandlerDictionary::P() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfStandardSecurityHandlerDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfStandardSecurityHandlerDictionary_autogen.h
index 55ba347..079580c 100644
--- a/experimental/PdfViewer/autogen/SkPdfStandardSecurityHandlerDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfStandardSecurityHandlerDictionary_autogen.h
@@ -536,13 +536,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", NULL));
   }
 
-  double R() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double R() const;
 /** (Required) A 32-byte string, based on both the owner and user passwords, that is used in
  *  computing the encryption key and in determining whether a valid owner password was
  *  entered. For more information, see "Encryption Key Algorithm" on page 78 and "Pass-
@@ -552,13 +546,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", NULL));
   }
 
-  std::string O() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string O() const;
 /** (Required) A 32-byte string, based on the user password, that is used in determining
  *  whether to prompt the user for a password and, if so, whether a valid user or owner pass-
  *  word was entered. For more information, see "Password Algorithms" on page 79.
@@ -567,13 +555,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", NULL));
   }
 
-  std::string U() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string U() const;
 /** (Required) A set of flags specifying which operations are permitted when the document is
  *  opened with user access (see Table 3.15).
 **/
@@ -581,13 +563,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", NULL));
   }
 
-  long P() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long P() const;
 };
 
 #endif  // __DEFINED__SkPdfStandardSecurityHandlerDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfStandardStructureDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfStandardStructureDictionary_autogen.cpp
new file mode 100644
index 0000000..23829b5
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfStandardStructureDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfStandardStructureDictionary_autogen.h"
+
+std::string SkPdfStandardStructureDictionary::Placement() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Placement", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfStandardStructureDictionary::WritingMode() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WritingMode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfStandardStructureDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfStandardStructureDictionary_autogen.h
index 4f08d5e..281ff19 100644
--- a/experimental/PdfViewer/autogen/SkPdfStandardStructureDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfStandardStructureDictionary_autogen.h
@@ -569,13 +569,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Placement", "", NULL));
   }
 
-  std::string Placement() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Placement", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Placement() const;
 /** (Optional) The directions of layout progression for packing of ILSEs (inline
  *  progression) and stacking of BLSEs (block progression):
  *      LrTb         Inline progression from left to right; block progression from
@@ -605,13 +599,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WritingMode", "", NULL));
   }
 
-  std::string WritingMode() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "WritingMode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string WritingMode() const;
 };
 
 #endif  // __DEFINED__SkPdfStandardStructureDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfStreamCommonDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfStreamCommonDictionary_autogen.cpp
new file mode 100644
index 0000000..5b4b8fb
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfStreamCommonDictionary_autogen.cpp
@@ -0,0 +1,72 @@
+#include "SkPdfStreamCommonDictionary_autogen.h"
+
+long SkPdfStreamCommonDictionary::Length() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfStreamCommonDictionary::getFilterAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfStreamCommonDictionary::getFilterAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfStreamCommonDictionary::getDecodeParmsAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfStreamCommonDictionary::getDecodeParmsAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfFileSpec SkPdfStreamCommonDictionary::F() const {
+  SkPdfFileSpec ret;
+  if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFileSpec();
+}
+
+std::string SkPdfStreamCommonDictionary::getFFilterAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfStreamCommonDictionary::getFFilterAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfStreamCommonDictionary::getFDecodeParmsAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfStreamCommonDictionary::getFDecodeParmsAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfStreamCommonDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfStreamCommonDictionary_autogen.h
index b1f86c5..fddbb6f 100644
--- a/experimental/PdfViewer/autogen/SkPdfStreamCommonDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfStreamCommonDictionary_autogen.h
@@ -536,13 +536,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length", "", NULL));
   }
 
-  long Length() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Length", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Length() const;
 /** (Optional) The name of a filter to be applied in processing the stream
  *  data found between the keywords stream and endstream, or an array
  *  of such names. Multiple filters should be specified in the order in
@@ -558,26 +552,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getFilterAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getFilterAsName() const;
   bool isFilterAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getFilterAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Filter", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getFilterAsArray() const;
 /** (Optional) A parameter dictionary, or an array of such dictionaries,
  *  used by the filters specified by Filter. If there is only one filter and that
  *  filter has parameters, DecodeParms must be set to the filter's parame-
@@ -601,26 +583,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getDecodeParmsAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getDecodeParmsAsDictionary() const;
   bool isDecodeParmsAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getDecodeParmsAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DecodeParms", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getDecodeParmsAsArray() const;
 /** (Optional; PDF 1.2) The file containing the stream data. If this entry
  *  is present, the bytes between stream and endstream are ignored, the
  *  filters are specified by FFilter rather than Filter, and the filter parame-
@@ -632,13 +602,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  SkPdfFileSpec F() const {
-    SkPdfFileSpec ret;
-    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFileSpec();
-  }
-
+  SkPdfFileSpec F() const;
 /** (Optional; PDF 1.2) The name of a filter to be applied in processing
  *  the data found in the stream's external file, or an array of such names.
  *  The same rules apply as for Filter.
@@ -653,26 +617,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getFFilterAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getFFilterAsName() const;
   bool isFFilterAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getFFilterAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FFilter", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getFFilterAsArray() const;
 /** (Optional; PDF 1.2) A parameter dictionary, or an array of such dic-
  *  tionaries, used by the filters specified by FFilter. The same rules apply
  *  as for DecodeParms.
@@ -687,26 +639,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getFDecodeParmsAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getFDecodeParmsAsDictionary() const;
   bool isFDecodeParmsAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getFDecodeParmsAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FDecodeParms", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getFDecodeParmsAsArray() const;
 };
 
 #endif  // __DEFINED__SkPdfStreamCommonDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfStream_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfStream_autogen.cpp
new file mode 100644
index 0000000..b1fdd27
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfStream_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfStream_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfString_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfString_autogen.cpp
new file mode 100644
index 0000000..a967633
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfString_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfString_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/SkPdfStructureElementAccessDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfStructureElementAccessDictionary_autogen.cpp
new file mode 100644
index 0000000..7db9df2
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfStructureElementAccessDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfStructureElementAccessDictionary_autogen.h"
+
+long SkPdfStructureElementAccessDictionary::StructParent() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfStructureElementAccessDictionary::StructParents() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfStructureElementAccessDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfStructureElementAccessDictionary_autogen.h
index 1dc8bb0..fb868a5 100644
--- a/experimental/PdfViewer/autogen/SkPdfStructureElementAccessDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfStructureElementAccessDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", NULL));
   }
 
-  long StructParent() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long StructParent() const;
 /** (Required for all content streams containing marked-content sequences that are
  *  structural content items; PDF 1.3) The integer key of this object's entry in the
  *  structural parent tree.
@@ -550,13 +544,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", NULL));
   }
 
-  long StructParents() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long StructParents() const;
 };
 
 #endif  // __DEFINED__SkPdfStructureElementAccessDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfStructureElementDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfStructureElementDictionary_autogen.cpp
new file mode 100644
index 0000000..0126024
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfStructureElementDictionary_autogen.cpp
@@ -0,0 +1,100 @@
+#include "SkPdfStructureElementDictionary_autogen.h"
+
+std::string SkPdfStructureElementDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfStructureElementDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfStructureElementDictionary::P() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfStructureElementDictionary::ID() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfStructureElementDictionary::Pg() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfObject* SkPdfStructureElementDictionary::K() const {
+  SkPdfObject* ret;
+  if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfObject* SkPdfStructureElementDictionary::A() const {
+  SkPdfObject* ret;
+  if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfStructureElementDictionary::getCAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfStructureElementDictionary::getCAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfStructureElementDictionary::R() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfStructureElementDictionary::T() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfStructureElementDictionary::Lang() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfStructureElementDictionary::Alt() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alt", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfStructureElementDictionary::ActualText() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ActualText", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfStructureElementDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfStructureElementDictionary_autogen.h
index b7b90da..f666dd4 100644
--- a/experimental/PdfViewer/autogen/SkPdfStructureElementDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfStructureElementDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The structure type, a name object identifying the nature of the
  *  structure element and its role within the document, such as a chapter,
  *  paragraph, or footnote (see Section 9.6.2, "Structure Types"). Names of
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required; must be an indirect reference) The structure element that is the
  *  immediate parent of this one in the structure hierarchy.
 **/
@@ -562,13 +550,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", NULL));
   }
 
-  SkPdfDictionary* P() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* P() const;
 /** (Optional) The element identifier, a string designating this structure
  *  element. The string must be unique among all elements in the docu-
  *  ment's structure hierarchy. The IDTree entry in the structure tree root
@@ -579,13 +561,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
   }
 
-  std::string ID() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string ID() const;
 /** (Optional; must be an indirect reference) A page object representing a
  *  page on which some or all of the content items designated by the K entry
  *  are rendered.
@@ -594,13 +570,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", NULL));
   }
 
-  SkPdfDictionary* Pg() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Pg", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Pg() const;
 /** (Optional) The contents of this structure element, which may consist of
  *  one or more marked-content sequences, PDF objects, and other struc-
  *  ture elements. The value of this entry may be any of the following:
@@ -618,13 +588,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", NULL));
   }
 
-  SkPdfObject* K() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfObject* K() const;
 /** (Optional) The attribute object or objects, if any, associated with this
  *  structure element. Each attribute object is either a dictionary or a
  *  stream; the value of this entry may be either a single attribute object or
@@ -636,13 +600,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", NULL));
   }
 
-  SkPdfObject* A() const {
-    SkPdfObject* ret;
-    if (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "A", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfObject* A() const;
 /** (Optional) The attribute class or classes, if any, to which this structure
  *  element belongs. The value of this entry may be either a single class
  *  name or an array of class names together with their revision numbers
@@ -661,26 +619,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getCAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getCAsName() const;
   bool isCAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getCAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getCAsArray() const;
 /** (Optional) The current revision number of this structure element (see
  *  "Attribute Revision Numbers" on page 606). The value must be a non-
  *  negative integer. Default value: 0.
@@ -689,13 +635,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", NULL));
   }
 
-  long R() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long R() const;
 /** (Optional) The title of the structure element, a text string representing it
  *  in human-readable form. The title should characterize the specific struc-
  *  ture element, such as Chapter 1, rather than merely a generic element
@@ -705,13 +645,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", NULL));
   }
 
-  std::string T() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string T() const;
 /** (Optional; PDF 1.4) A language identifier specifying the natural language
  *  for all text in the structure element except where overridden by language
  *  specifications for nested structure elements or marked content (see Sec-
@@ -722,13 +656,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", NULL));
   }
 
-  std::string Lang() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Lang", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Lang() const;
 /** (Optional) An alternate description of the structure element and its
  *  children in human-readable form, useful when extracting the docu-
  *  ment's contents in support of accessibility to disabled users or for other
@@ -738,13 +666,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alt", "", NULL));
   }
 
-  std::string Alt() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Alt", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Alt() const;
 /** (Optional; PDF 1.4) Text that is an exact replacement for the structure
  *  element and its children. This replacement text (which should apply to
  *  as small a piece of content as possible) is useful when extracting the doc-
@@ -755,13 +677,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ActualText", "", NULL));
   }
 
-  std::string ActualText() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ActualText", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string ActualText() const;
 };
 
 #endif  // __DEFINED__SkPdfStructureElementDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfStructureTreeRootDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfStructureTreeRootDictionary_autogen.cpp
new file mode 100644
index 0000000..b6c9442
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfStructureTreeRootDictionary_autogen.cpp
@@ -0,0 +1,72 @@
+#include "SkPdfStructureTreeRootDictionary_autogen.h"
+
+std::string SkPdfStructureTreeRootDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfStructureTreeRootDictionary::getKAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfStructureTreeRootDictionary::getKAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfStructureTreeRootDictionary::getIDTreeAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfTree* SkPdfStructureTreeRootDictionary::getIDTreeAsTree() const {
+  SkPdfTree* ret = NULL;
+  if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+double SkPdfStructureTreeRootDictionary::getParentTreeAsNumber() const {
+  double ret = 0;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfTree* SkPdfStructureTreeRootDictionary::getParentTreeAsTree() const {
+  SkPdfTree* ret = NULL;
+  if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfStructureTreeRootDictionary::ParentTreeNextKey() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTreeNextKey", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfDictionary* SkPdfStructureTreeRootDictionary::RoleMap() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RoleMap", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfStructureTreeRootDictionary::ClassMap() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClassMap", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfStructureTreeRootDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfStructureTreeRootDictionary_autogen.h
index 83f337e..f722733 100644
--- a/experimental/PdfViewer/autogen/SkPdfStructureTreeRootDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfStructureTreeRootDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Optional) The immediate child or children of the structure tree root in
  *  the structure hierarchy. The value may be either a dictionary represent-
  *  ing a single structure element or an array of such dictionaries.
@@ -553,26 +547,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getKAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getKAsDictionary() const;
   bool isKAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getKAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "K", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getKAsArray() const;
 /** (Required if any structure elements have element identifiers) A name tree
  *  that maps element identifiers (see Table 9.10) to the structure elements
  *  they denote.
@@ -587,26 +569,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getIDTreeAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getIDTreeAsName() const;
   bool isIDTreeATree() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfTree* getIDTreeAsTree() const {
-    SkPdfTree* ret = NULL;
-    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IDTree", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfTree* getIDTreeAsTree() const;
 /** (Required if any structure element contains PDF objects or marked-content
  *  sequences as content items) A number tree (see Section 3.8.5, "Number
  *  Trees") used in finding the structure elements to which content items
@@ -635,26 +605,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Real || ret->podofo()->GetDataType() == ePdfDataType_Number;
   }
 
-  double getParentTreeAsNumber() const {
-    double ret = 0;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double getParentTreeAsNumber() const;
   bool isParentTreeATree() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfTree* getParentTreeAsTree() const {
-    SkPdfTree* ret = NULL;
-    if (TreeFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTree", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfTree* getParentTreeAsTree() const;
 /** (Optional) An integer greater than any key in the parent tree, to be used
  *  as a key for the next entry added to the tree.
 **/
@@ -662,13 +620,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTreeNextKey", "", NULL));
   }
 
-  long ParentTreeNextKey() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ParentTreeNextKey", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long ParentTreeNextKey() const;
 /** (Optional) A dictionary mapping the names of structure types used in
  *  the document to their approximate equivalents in the set of standard
  *  structure types (see Section 9.7.4, "Standard Structure Types").
@@ -677,13 +629,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RoleMap", "", NULL));
   }
 
-  SkPdfDictionary* RoleMap() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RoleMap", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* RoleMap() const;
 /** (Optional) A dictionary mapping name objects designating attribute
  *  classes to the corresponding attribute objects or arrays of attribute ob-
  *  jects (see "Attribute Classes" on page 605).
@@ -692,13 +638,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClassMap", "", NULL));
   }
 
-  SkPdfDictionary* ClassMap() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ClassMap", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* ClassMap() const;
 };
 
 #endif  // __DEFINED__SkPdfStructureTreeRootDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfSubmitFormActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfSubmitFormActionDictionary_autogen.cpp
new file mode 100644
index 0000000..0aa92a8
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfSubmitFormActionDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfSubmitFormActionDictionary_autogen.h"
+
+std::string SkPdfSubmitFormActionDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfFileSpec SkPdfSubmitFormActionDictionary::F() const {
+  SkPdfFileSpec ret;
+  if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFileSpec();
+}
+
+SkPdfArray* SkPdfSubmitFormActionDictionary::Fields() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfSubmitFormActionDictionary::Flags() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfSubmitFormActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfSubmitFormActionDictionary_autogen.h
index 178a223..3a7d6a6 100644
--- a/experimental/PdfViewer/autogen/SkPdfSubmitFormActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfSubmitFormActionDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required) A URL file specification (see Section 3.10.4, "URL Speci-
  *  fications") giving the uniform resource locator (URL) of the script
  *  at the Web server that will process the submission.
@@ -547,13 +541,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  SkPdfFileSpec F() const {
-    SkPdfFileSpec ret;
-    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFileSpec();
-  }
-
+  SkPdfFileSpec F() const;
 /** (Optional) An array identifying which fields to include in the sub-
  *  mission or which to exclude, depending on the setting of the
  *  Include/Exclude flag in the Flags entry (see Table 8.62). Each ele-
@@ -571,13 +559,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", NULL));
   }
 
-  SkPdfArray* Fields() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Fields", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Fields() const;
 /** (Optional; inheritable) A set of flags specifying various characteris-
  *  tics of the action (see Table 8.62). Default value: 0.
 **/
@@ -585,13 +567,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", NULL));
   }
 
-  long Flags() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Flags", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Flags() const;
 };
 
 #endif  // __DEFINED__SkPdfSubmitFormActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTableAttributesDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTableAttributesDictionary_autogen.cpp
new file mode 100644
index 0000000..dbdb373
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTableAttributesDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfTableAttributesDictionary_autogen.h"
+
+long SkPdfTableAttributesDictionary::RowSpan() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RowSpan", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfTableAttributesDictionary::ColSpan() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColSpan", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTableAttributesDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTableAttributesDictionary_autogen.h
index 2fd1fc0..a73508b 100644
--- a/experimental/PdfViewer/autogen/SkPdfTableAttributesDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTableAttributesDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RowSpan", "", NULL));
   }
 
-  long RowSpan() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "RowSpan", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long RowSpan() const;
 /** (Optional) The number of columns in the enclosing table that are spanned by
  *  the cell. The cell expands by adding columns in the inline-progression direction
  *  specified by the table's WritingMode attribute. Default value: 1.
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColSpan", "", NULL));
   }
 
-  long ColSpan() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ColSpan", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long ColSpan() const;
 };
 
 #endif  // __DEFINED__SkPdfTableAttributesDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTextAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTextAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..6b493a6
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTextAnnotationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfTextAnnotationDictionary_autogen.h"
+
+std::string SkPdfTextAnnotationDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfTextAnnotationDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+bool SkPdfTextAnnotationDictionary::Open() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+std::string SkPdfTextAnnotationDictionary::Name() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTextAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTextAnnotationDictionary_autogen.h
index a52d7bf..f164423 100644
--- a/experimental/PdfViewer/autogen/SkPdfTextAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTextAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required) The text to be displayed in the pop-up window when the annotation
  *  is opened. Carriage returns may be used to separate the text into paragraphs.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Optional) A flag specifying whether the annotation should initially be displayed
  *  open. Default value: false (closed).
 **/
@@ -560,13 +548,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", NULL));
   }
 
-  bool Open() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Open", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool Open() const;
 /** (Optional) The name of an icon to be used in displaying the annotation. Viewer
  *  applications should provide predefined icon appearances for at least the follow-
  *  ing standard names:
@@ -581,13 +563,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
   }
 
-  std::string Name() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Name() const;
 };
 
 #endif  // __DEFINED__SkPdfTextAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTextFieldDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTextFieldDictionary_autogen.cpp
new file mode 100644
index 0000000..ca3187c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTextFieldDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfTextFieldDictionary_autogen.h"
+
+long SkPdfTextFieldDictionary::MaxLen() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MaxLen", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTextFieldDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTextFieldDictionary_autogen.h
index 56c6472..30a7e41 100644
--- a/experimental/PdfViewer/autogen/SkPdfTextFieldDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTextFieldDictionary_autogen.h
@@ -531,13 +531,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MaxLen", "", NULL));
   }
 
-  long MaxLen() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MaxLen", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long MaxLen() const;
 };
 
 #endif  // __DEFINED__SkPdfTextFieldDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfThreadActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfThreadActionDictionary_autogen.cpp
new file mode 100644
index 0000000..8544c8c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfThreadActionDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfThreadActionDictionary_autogen.h"
+
+std::string SkPdfThreadActionDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfFileSpec SkPdfThreadActionDictionary::F() const {
+  SkPdfFileSpec ret;
+  if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFileSpec();
+}
+
+SkPdfDictionary* SkPdfThreadActionDictionary::getDAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfThreadActionDictionary::getDAsInteger() const {
+  long ret = 0;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfThreadActionDictionary::getDAsString() const {
+  std::string ret = "";
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfThreadActionDictionary::getBAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfThreadActionDictionary::getBAsInteger() const {
+  long ret = 0;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfThreadActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfThreadActionDictionary_autogen.h
index 3158d85..5b5a813 100644
--- a/experimental/PdfViewer/autogen/SkPdfThreadActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfThreadActionDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Optional) The file containing the desired thread. If this entry is absent, the
  *  thread is in the current file.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  SkPdfFileSpec F() const {
-    SkPdfFileSpec ret;
-    if (FileSpecFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFileSpec();
-  }
-
+  SkPdfFileSpec F() const;
 /** (Required) The desired destination thread, specified in one of the following
  *  forms:
  *  *  An indirect reference to a thread dictionary (see Section 8.3.2, "Articles").
@@ -574,39 +562,21 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getDAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getDAsDictionary() const;
   bool isDAInteger() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Number;
   }
 
-  long getDAsInteger() const {
-    long ret = 0;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long getDAsInteger() const;
   bool isDAString() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  std::string getDAsString() const {
-    std::string ret = "";
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getDAsString() const;
 /** (Optional) The desired bead in the destination thread, specified in one of the
  *  following forms:
  *  *  An indirect reference to a bead dictionary (see Section 8.3.2, "Articles"). In
@@ -624,26 +594,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getBAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getBAsDictionary() const;
   bool isBAInteger() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Number;
   }
 
-  long getBAsInteger() const {
-    long ret = 0;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "B", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long getBAsInteger() const;
 };
 
 #endif  // __DEFINED__SkPdfThreadActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfThreadDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfThreadDictionary_autogen.cpp
new file mode 100644
index 0000000..d3e75f8
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfThreadDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfThreadDictionary_autogen.h"
+
+std::string SkPdfThreadDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfThreadDictionary::F() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfThreadDictionary::I() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfThreadDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfThreadDictionary_autogen.h
index 98ccf37..afb1813 100644
--- a/experimental/PdfViewer/autogen/SkPdfThreadDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfThreadDictionary_autogen.h
@@ -532,26 +532,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required; must be an indirect reference) The first bead in the thread.
 **/
   bool has_F() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  SkPdfDictionary* F() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* F() const;
 /** (Optional) A thread information dictionary containing information about the
  *  thread, such as its title, author, and creation date. The contents of this dictionary are
  *  similar to those of the document information dictionary (see Section 9.2.1, "Docu-
@@ -561,13 +549,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", NULL));
   }
 
-  SkPdfDictionary* I() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "I", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* I() const;
 };
 
 #endif  // __DEFINED__SkPdfThreadDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTransitionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTransitionDictionary_autogen.cpp
new file mode 100644
index 0000000..dcd16e5
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTransitionDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfTransitionDictionary_autogen.h"
+
+std::string SkPdfTransitionDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+double SkPdfTransitionDictionary::D() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfTransitionDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfTransitionDictionary::Dm() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dm", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfTransitionDictionary::M() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+double SkPdfTransitionDictionary::Di() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Di", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTransitionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTransitionDictionary_autogen.h
index 64cbeb6..e3fa5b5 100644
--- a/experimental/PdfViewer/autogen/SkPdfTransitionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTransitionDictionary_autogen.h
@@ -532,26 +532,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Optional) The duration of the transition effect, in seconds. Default value: 1.
 **/
   bool has_D() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", NULL));
   }
 
-  double D() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double D() const;
 /** (Optional) The transition style to use when moving to this page from another during a
  *  presentation:
  *     Split       Two lines sweep across the screen, revealing the new page. The lines may
@@ -578,13 +566,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Optional; Split and Blinds transition styles only) The dimension in which the specified
  *  transition effect occurs:
  *       H         Horizontal
@@ -595,13 +577,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dm", "", NULL));
   }
 
-  std::string Dm() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Dm", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Dm() const;
 /** (Optional; Split and Box transition styles only) The direction of motion for the specified
  *  transition effect:
  *       I         Inward from the edges of the page
@@ -612,13 +588,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", NULL));
   }
 
-  std::string M() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "M", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string M() const;
 /** (Optional; Wipe and Glitter transition styles only) The direction in which the specified
  *  transition effect moves, expressed in degrees counterclockwise starting from a left-to-
  *  right direction. (Note that this differs from the page object's Rotate entry, which is
@@ -634,13 +604,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Di", "", NULL));
   }
 
-  double Di() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Di", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double Di() const;
 };
 
 #endif  // __DEFINED__SkPdfTransitionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTransparencyGroupDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTransparencyGroupDictionary_autogen.cpp
new file mode 100644
index 0000000..cb81161
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTransparencyGroupDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfTransparencyGroupDictionary_autogen.h"
+
+std::string SkPdfTransparencyGroupDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfTransparencyGroupDictionary::getCSAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfTransparencyGroupDictionary::getCSAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTransparencyGroupDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTransparencyGroupDictionary_autogen.h
index e883767..8424b4a 100644
--- a/experimental/PdfViewer/autogen/SkPdfTransparencyGroupDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTransparencyGroupDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Sometimes required, as discussed below) The group color space, which is used for
  *  the following purposes:
  *  *  As the color space into which colors are converted when painted into the
@@ -581,26 +575,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getCSAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getCSAsName() const;
   bool isCSAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getCSAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getCSAsArray() const;
 };
 
 #endif  // __DEFINED__SkPdfTransparencyGroupDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTrapNetworkAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..e59e974
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAnnotationDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfTrapNetworkAnnotationDictionary_autogen.h"
+
+std::string SkPdfTrapNetworkAnnotationDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfTrapNetworkAnnotationDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDate SkPdfTrapNetworkAnnotationDictionary::LastModified() const {
+  SkPdfDate ret;
+  if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfDate();
+}
+
+SkPdfArray* SkPdfTrapNetworkAnnotationDictionary::Version() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfTrapNetworkAnnotationDictionary::AnnotStates() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AnnotStates", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfTrapNetworkAnnotationDictionary::FontFauxing() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFauxing", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTrapNetworkAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAnnotationDictionary_autogen.h
index 6c7cf0e..79f3cbe 100644
--- a/experimental/PdfViewer/autogen/SkPdfTrapNetworkAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Optional; PDF 1.4) An alternate description of the annotation's contents in
  *  human-readable form, useful when extracting the document's contents in
  *  support of accessibility to disabled users or for other purposes (see Section
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Required if Version and AnnotStates are absent; must be absent if Version and
  *  AnnotStates are present; PDF 1.4) The date and time (see Section 3.8.2,
  *  "Dates") when the trap network was most recently modified.
@@ -563,13 +551,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", NULL));
   }
 
-  SkPdfDate LastModified() const {
-    SkPdfDate ret;
-    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfDate();
-  }
-
+  SkPdfDate LastModified() const;
 /** (Required if AnnotStates is present; must be absent if LastModified is present)
  *  An unordered array of all objects present in the page description at the time
  *  the trap networks were generated and that, if changed, could affect the
@@ -588,13 +570,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", NULL));
   }
 
-  SkPdfArray* Version() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Version", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Version() const;
 /** (Required if Version is present; must be absent if LastModified is present) An
  *  array of name objects representing the appearance states (value of the AS
  *  entry) for annotations associated with the page. The appearance states must
@@ -607,13 +583,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AnnotStates", "", NULL));
   }
 
-  SkPdfArray* AnnotStates() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AnnotStates", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* AnnotStates() const;
 /** (Optional) An array of font dictionaries representing fonts that were "fauxed"
  *  (replaced by substitute fonts) during the generation of trap networks for the
  *  page.
@@ -622,13 +592,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFauxing", "", NULL));
   }
 
-  SkPdfArray* FontFauxing() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontFauxing", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* FontFauxing() const;
 };
 
 #endif  // __DEFINED__SkPdfTrapNetworkAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTrapNetworkAppearanceStreamDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAppearanceStreamDictionary_autogen.cpp
new file mode 100644
index 0000000..729d96c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAppearanceStreamDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfTrapNetworkAppearanceStreamDictionary_autogen.h"
+
+std::string SkPdfTrapNetworkAppearanceStreamDictionary::PCM() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PCM", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfTrapNetworkAppearanceStreamDictionary::SeparationColorNames() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationColorNames", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfTrapNetworkAppearanceStreamDictionary::TrapRegions() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapRegions", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfTrapNetworkAppearanceStreamDictionary::TrapStyles() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapStyles", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTrapNetworkAppearanceStreamDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAppearanceStreamDictionary_autogen.h
index 289058c..5b4c745 100644
--- a/experimental/PdfViewer/autogen/SkPdfTrapNetworkAppearanceStreamDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTrapNetworkAppearanceStreamDictionary_autogen.h
@@ -536,13 +536,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PCM", "", NULL));
   }
 
-  std::string PCM() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PCM", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string PCM() const;
 /** (Optional) An array of names identifying the colorants that were
  *  assumed when this network was created; equivalent to the Post-
  *  Script page device parameter of the same name (see Section 6.2.5 of
@@ -555,13 +549,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationColorNames", "", NULL));
   }
 
-  SkPdfArray* SeparationColorNames() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SeparationColorNames", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* SeparationColorNames() const;
 /** (Optional) An array of indirect references to TrapRegion objects
  *  defining the page's trapping zones and the associated trapping
  *  parameters, as described in Adobe Technical Note #5620, Portable
@@ -575,13 +563,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapRegions", "", NULL));
   }
 
-  SkPdfArray* TrapRegions() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapRegions", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* TrapRegions() const;
 /** (Optional) A human-readable text string that applications can use
  *  to describe this trap network to the user (for example, to allow
  *  switching between trap networks).
@@ -590,13 +572,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapStyles", "", NULL));
   }
 
-  std::string TrapStyles() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TrapStyles", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string TrapStyles() const;
 };
 
 #endif  // __DEFINED__SkPdfTrapNetworkAppearanceStreamDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfTrueTypeFontDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfTrueTypeFontDictionary_autogen.cpp
new file mode 100644
index 0000000..1929a9e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfTrueTypeFontDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfTrueTypeFontDictionary_autogen.h"
+
+std::string SkPdfTrueTypeFontDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfTrueTypeFontDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfTrueTypeFontDictionary_autogen.h
index 8c2297f..c1bb7ef 100644
--- a/experimental/PdfViewer/autogen/SkPdfTrueTypeFontDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfTrueTypeFontDictionary_autogen.h
@@ -36,13 +36,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 };
 
 #endif  // __DEFINED__SkPdfTrueTypeFontDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType0FontDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType0FontDictionary_autogen.cpp
new file mode 100644
index 0000000..472b903
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType0FontDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfType0FontDictionary_autogen.h"
+
+std::string SkPdfType0FontDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfType0FontDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfType0FontDictionary::BaseFont() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfType0FontDictionary::getEncodingAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfStream* SkPdfType0FontDictionary::getEncodingAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfType0FontDictionary::DescendantFonts() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DescendantFonts", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfType0FontDictionary::ToUnicode() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType0FontDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType0FontDictionary_autogen.h
index c556575..4cbcd63 100644
--- a/experimental/PdfViewer/autogen/SkPdfType0FontDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType0FontDictionary_autogen.h
@@ -49,26 +49,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The type of font; must be Type0 for a Type 0 font.
 **/
   bool has_Subtype() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required) The PostScript name of the font. In principle, this is an arbitrary
  *  name, since there is no font program associated directly with a Type 0 font
  *  dictionary. The conventions described here ensure maximum compatibility
@@ -83,13 +71,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", NULL));
   }
 
-  std::string BaseFont() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string BaseFont() const;
 /** (Required) The name of a predefined CMap, or a stream containing a CMap
  *  program, that maps character codes to font numbers and CIDs. If the descen-
  *  dant is a Type 2 CIDFont whose associated TrueType font program is not em-
@@ -106,26 +88,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getEncodingAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getEncodingAsName() const;
   bool isEncodingAStream() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return false;
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getEncodingAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getEncodingAsStream() const;
 /** (Required) An array specifying one or more fonts or CIDFonts that are
  *  descendants of this composite font. This array is indexed by the font number
  *  that is obtained by mapping a character code through the CMap specified in
@@ -137,13 +107,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DescendantFonts", "", NULL));
   }
 
-  SkPdfArray* DescendantFonts() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DescendantFonts", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* DescendantFonts() const;
 /** (Optional) A stream containing a CMap file that maps character codes to
  *  Unicode values (see Section 5.9, "ToUnicode CMaps").
 **/
@@ -151,13 +115,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", NULL));
   }
 
-  SkPdfStream* ToUnicode() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* ToUnicode() const;
 };
 
 #endif  // __DEFINED__SkPdfType0FontDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType0FunctionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType0FunctionDictionary_autogen.cpp
new file mode 100644
index 0000000..c28bbc3
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType0FunctionDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfType0FunctionDictionary_autogen.h"
+
+SkPdfArray* SkPdfType0FunctionDictionary::Size() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfType0FunctionDictionary::BitsPerSample() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerSample", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType0FunctionDictionary::Order() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Order", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfType0FunctionDictionary::Encode() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfType0FunctionDictionary::Decode() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType0FunctionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType0FunctionDictionary_autogen.h
index a414a47..f14ec53 100644
--- a/experimental/PdfViewer/autogen/SkPdfType0FunctionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType0FunctionDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", NULL));
   }
 
-  SkPdfArray* Size() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Size", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Size() const;
 /** (Required) The number of bits used to represent each sample. (If the function
  *  has multiple output values, each one occupies BitsPerSample bits.) Valid
  *  values are 1, 2, 4, 8, 12, 16, 24, and 32.
@@ -547,13 +541,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerSample", "", NULL));
   }
 
-  long BitsPerSample() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerSample", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long BitsPerSample() const;
 /** (Optional) The order of interpolation between samples. Valid values are 1
  *  and 3, specifying linear and cubic spline interpolation, respectively. (See im-
  *  plementation note 26 in Appendix H.) Default value: 1.
@@ -562,13 +550,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Order", "", NULL));
   }
 
-  long Order() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Order", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Order() const;
 /** (Optional) An array of 2 x m numbers specifying the linear mapping of input
  *  values into the domain of the function's sample table. Default value:
  *  [0 (Size0 - 1) 0 (Size1 - 1) ...].
@@ -577,13 +559,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", NULL));
   }
 
-  SkPdfArray* Encode() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Encode() const;
 /** (Optional) An array of 2 x n numbers specifying the linear mapping of sam-
  *  ple values into the range appropriate for the function's output values. Default
  *  value: same as the value of Range.
@@ -592,13 +568,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", NULL));
   }
 
-  SkPdfArray* Decode() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Decode() const;
 };
 
 #endif  // __DEFINED__SkPdfType0FunctionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType10HalftoneDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType10HalftoneDictionary_autogen.cpp
new file mode 100644
index 0000000..3ac7e41
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType10HalftoneDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfType10HalftoneDictionary_autogen.h"
+
+std::string SkPdfType10HalftoneDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfType10HalftoneDictionary::HalftoneType() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfType10HalftoneDictionary::HalftoneName() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfType10HalftoneDictionary::Xsquare() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Xsquare", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType10HalftoneDictionary::Ysquare() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ysquare", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfFunction SkPdfType10HalftoneDictionary::getTransferFunctionAsFunction() const {
+  SkPdfFunction ret = SkPdfFunction();
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
+std::string SkPdfType10HalftoneDictionary::getTransferFunctionAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType10HalftoneDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType10HalftoneDictionary_autogen.h
index 30e6215..c993e0f 100644
--- a/experimental/PdfViewer/autogen/SkPdfType10HalftoneDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType10HalftoneDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) A code identifying the halftone type that this dictionary
  *  describes; must be 10 for this type of halftone.
 **/
@@ -546,52 +540,28 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", NULL));
   }
 
-  long HalftoneType() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long HalftoneType() const;
 /** (Optional) The name of the halftone dictionary.
 **/
   bool has_HalftoneName() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", NULL));
   }
 
-  std::string HalftoneName() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string HalftoneName() const;
 /** (Required) The side of square X, in device pixels; see below.
 **/
   bool has_Xsquare() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Xsquare", "", NULL));
   }
 
-  long Xsquare() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Xsquare", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Xsquare() const;
 /** (Required) The side of square Y, in device pixels; see below.
 **/
   bool has_Ysquare() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ysquare", "", NULL));
   }
 
-  long Ysquare() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ysquare", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Ysquare() const;
 /** (Optional) A transfer function, which overrides the current transfer
  *  function in the graphics state for the same component. This entry is
  *  required if the dictionary is a component of a type 5 halftone (see
@@ -610,26 +580,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfFunction getTransferFunctionAsFunction() const {
-    SkPdfFunction ret = SkPdfFunction();
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction getTransferFunctionAsFunction() const;
   bool isTransferFunctionAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getTransferFunctionAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getTransferFunctionAsName() const;
 };
 
 #endif  // __DEFINED__SkPdfType10HalftoneDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType16HalftoneDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType16HalftoneDictionary_autogen.cpp
new file mode 100644
index 0000000..2cc4180
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType16HalftoneDictionary_autogen.cpp
@@ -0,0 +1,65 @@
+#include "SkPdfType16HalftoneDictionary_autogen.h"
+
+std::string SkPdfType16HalftoneDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfType16HalftoneDictionary::HalftoneType() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfType16HalftoneDictionary::HalftoneName() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfType16HalftoneDictionary::Width() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType16HalftoneDictionary::Height() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType16HalftoneDictionary::Width2() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width2", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType16HalftoneDictionary::Height2() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height2", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfFunction SkPdfType16HalftoneDictionary::getTransferFunctionAsFunction() const {
+  SkPdfFunction ret = SkPdfFunction();
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
+std::string SkPdfType16HalftoneDictionary::getTransferFunctionAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType16HalftoneDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType16HalftoneDictionary_autogen.h
index 4eacd84..c62b2e5 100644
--- a/experimental/PdfViewer/autogen/SkPdfType16HalftoneDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType16HalftoneDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) A code identifying the halftone type that this dictionary
  *  describes; must be 16 for this type of halftone.
 **/
@@ -546,26 +540,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", NULL));
   }
 
-  long HalftoneType() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long HalftoneType() const;
 /** (Optional) The name of the halftone dictionary.
 **/
   bool has_HalftoneName() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", NULL));
   }
 
-  std::string HalftoneName() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string HalftoneName() const;
 /** (Required) The width of the first (or only) rectangle in the threshold
  *  array, in device pixels.
 **/
@@ -573,13 +555,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", NULL));
   }
 
-  long Width() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Width() const;
 /** (Required) The height of the first (or only) rectangle in the threshold
  *  array, in device pixels.
 **/
@@ -587,13 +563,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", NULL));
   }
 
-  long Height() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Height() const;
 /** (Optional) The width of the optional second rectangle in the threshold
  *  array, in device pixels. If this entry is present, the Height2 entry must
  *  be present as well; if this entry is absent, the Height2 entry must also be
@@ -603,13 +573,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width2", "", NULL));
   }
 
-  long Width2() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width2", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Width2() const;
 /** (Optional) The height of the optional second rectangle in the threshold
  *  array, in device pixels.
 **/
@@ -617,13 +581,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height2", "", NULL));
   }
 
-  long Height2() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height2", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Height2() const;
 /** (Optional) A transfer function, which overrides the current transfer
  *  function in the graphics state for the same component. This entry is
  *  required if the dictionary is a component of a type 5 halftone (see
@@ -642,26 +600,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfFunction getTransferFunctionAsFunction() const {
-    SkPdfFunction ret = SkPdfFunction();
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction getTransferFunctionAsFunction() const;
   bool isTransferFunctionAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getTransferFunctionAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getTransferFunctionAsName() const;
 };
 
 #endif  // __DEFINED__SkPdfType16HalftoneDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType1FontDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType1FontDictionary_autogen.cpp
new file mode 100644
index 0000000..319cb55
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType1FontDictionary_autogen.cpp
@@ -0,0 +1,79 @@
+#include "SkPdfType1FontDictionary_autogen.h"
+
+std::string SkPdfType1FontDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfType1FontDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfType1FontDictionary::Name() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfType1FontDictionary::BaseFont() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfType1FontDictionary::FirstChar() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FirstChar", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType1FontDictionary::LastChar() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastChar", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfType1FontDictionary::Widths() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Widths", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfType1FontDictionary::FontDescriptor() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontDescriptor", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfType1FontDictionary::getEncodingAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfType1FontDictionary::getEncodingAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfType1FontDictionary::ToUnicode() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType1FontDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType1FontDictionary_autogen.h
index bb5382b..371acc7 100644
--- a/experimental/PdfViewer/autogen/SkPdfType1FontDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType1FontDictionary_autogen.h
@@ -40,26 +40,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The type of font; must be Type1 for a Type 1 font.
 **/
   bool has_Subtype() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required in PDF 1.0; optional otherwise) The name by which this font is ref-
  *  erenced in the Font subdictionary of the current resource dictionary.
  *  Note: This entry is obsolescent and its use is no longer recommended. (See
@@ -69,13 +57,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
   }
 
-  std::string Name() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Name() const;
 /** (Required) The PostScript name of the font. For Type 1 fonts, this is usually
  *  the value of the FontName entry in the font program; for more information,
  *  see Section 5.2 of the PostScript Language Reference, Third Edition. The Post-
@@ -87,13 +69,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", NULL));
   }
 
-  std::string BaseFont() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BaseFont", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string BaseFont() const;
 /** (Required except for the standard 14 fonts) The first character code defined in
  *  the font's Widths array.
 **/
@@ -101,13 +77,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FirstChar", "", NULL));
   }
 
-  long FirstChar() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FirstChar", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long FirstChar() const;
 /** (Required except for the standard 14 fonts) The last character code defined in
  *  the font's Widths array.
 **/
@@ -115,13 +85,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastChar", "", NULL));
   }
 
-  long LastChar() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastChar", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long LastChar() const;
 /** (Required except for the standard 14 fonts; indirect reference preferred) An array
  *  of (LastChar - FirstChar + 1) widths, each element being the glyph width for
  *  the character whose code is FirstChar plus the array index. For character
@@ -137,13 +101,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Widths", "", NULL));
   }
 
-  SkPdfArray* Widths() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Widths", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Widths() const;
 /** (Required except for the standard 14 fonts; must be an indirect reference) A font
  *  descriptor describing the font's metrics other than its glyph widths (see Sec-
  *  tion 5.7, "Font Descriptors").
@@ -156,13 +114,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontDescriptor", "", NULL));
   }
 
-  SkPdfDictionary* FontDescriptor() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontDescriptor", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* FontDescriptor() const;
 /** (Optional) A specification of the font's character encoding, if different from
  *  its built-in encoding. The value of Encoding may be either the name of a pre-
  *  defined encoding (MacRomanEncoding, MacExpertEncoding, or WinAnsi-
@@ -180,26 +132,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getEncodingAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getEncodingAsName() const;
   bool isEncodingADictionary() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getEncodingAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getEncodingAsDictionary() const;
 /** (Optional; PDF 1.2) A stream containing a CMap file that maps character
  *  codes to Unicode values (see Section 5.9, "ToUnicode CMaps").
 **/
@@ -207,13 +147,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", NULL));
   }
 
-  SkPdfStream* ToUnicode() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* ToUnicode() const;
 };
 
 #endif  // __DEFINED__SkPdfType1FontDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType1FormDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType1FormDictionary_autogen.cpp
new file mode 100644
index 0000000..dd2736c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType1FormDictionary_autogen.cpp
@@ -0,0 +1,107 @@
+#include "SkPdfType1FormDictionary_autogen.h"
+
+std::string SkPdfType1FormDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfType1FormDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfType1FormDictionary::FormType() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FormType", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfType1FormDictionary::Name() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDate SkPdfType1FormDictionary::LastModified() const {
+  SkPdfDate ret;
+  if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfDate();
+}
+
+SkRect* SkPdfType1FormDictionary::BBox() const {
+  SkRect* ret;
+  if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkMatrix* SkPdfType1FormDictionary::Matrix() const {
+  SkMatrix* ret;
+  if (SkMatrixFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfResourceDictionary* SkPdfType1FormDictionary::Resources() const {
+  SkPdfResourceDictionary* ret;
+  if (ResourceDictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfType1FormDictionary::Group() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Group", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfType1FormDictionary::Ref() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ref", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfType1FormDictionary::Metadata() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfType1FormDictionary::PieceInfo() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PieceInfo", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfType1FormDictionary::StructParent() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType1FormDictionary::StructParents() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfDictionary* SkPdfType1FormDictionary::OPI() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPI", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType1FormDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType1FormDictionary_autogen.h
index e975649..083eb20 100644
--- a/experimental/PdfViewer/autogen/SkPdfType1FormDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType1FormDictionary_autogen.h
@@ -37,13 +37,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The type of XObject that this dictionary describes; must be Form
  *  for a form XObject.
 **/
@@ -51,13 +45,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Optional) A code identifying the type of form XObject that this dictionary
  *  describes. The only valid value defined at the time of publication is 1. Default
  *  value: 1.
@@ -66,13 +54,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FormType", "", NULL));
   }
 
-  long FormType() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FormType", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long FormType() const;
 /** (Required in PDF 1.0; optional otherwise) The name by which this form
  *  XObject is referenced in the XObject subdictionary of the current resource
  *  dictionary (see Section 3.7.2, "Resource Dictionaries").
@@ -83,13 +65,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
   }
 
-  std::string Name() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Name() const;
 /** (Required if PieceInfo is present; optional otherwise; PDF 1.3) The date and
  *  time (see Section 3.8.2, "Dates") when the form XObject's contents were
  *  most recently modified. If a page-piece dictionary (PieceInfo) is present, the
@@ -101,13 +77,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", NULL));
   }
 
-  SkPdfDate LastModified() const {
-    SkPdfDate ret;
-    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastModified", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfDate();
-  }
-
+  SkPdfDate LastModified() const;
 /** (Required) An array of four numbers in the form coordinate system (see
  *  below), giving the coordinates of the left, bottom, right, and top edges,
  *  respectively, of the form XObject's bounding box. These boundaries are used
@@ -117,13 +87,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", NULL));
   }
 
-  SkRect* BBox() const {
-    SkRect* ret;
-    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkRect* BBox() const;
 /** (Optional) An array of six numbers specifying the form matrix, which maps
  *  form space into user space (see Section 4.2.3, "Transformation Matrices").
  *  Default value: the identity matrix [1 0 0 1 0 0].
@@ -132,13 +96,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", NULL));
   }
 
-  SkMatrix* Matrix() const {
-    SkMatrix* ret;
-    if (SkMatrixFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkMatrix* Matrix() const;
 /** (Optional but strongly recommended; PDF 1.2) A dictionary specifying any
  *  resources (such as fonts and images) required by the form XObject (see Sec-
  *  tion 3.7, "Content Streams and Resources").
@@ -161,13 +119,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", NULL));
   }
 
-  SkPdfResourceDictionary* Resources() const {
-    SkPdfResourceDictionary* ret;
-    if (DictionaryFromDictionary2(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfResourceDictionary* Resources() const;
 /** (Optional; PDF 1.4) A group attributes dictionary indicating that the contents
  *  of the form XObject are to be treated as a group and specifying the attributes
  *  of that group (see Section 4.9.2, "Group XObjects").
@@ -179,13 +131,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Group", "", NULL));
   }
 
-  SkPdfDictionary* Group() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Group", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Group() const;
 /** (Optional; PDF 1.4) A reference dictionary identifying a page to be imported
  *  from another PDF file, and for which the form XObject serves as a proxy (see
  *  Section 4.9.3, "Reference XObjects").
@@ -194,13 +140,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ref", "", NULL));
   }
 
-  SkPdfDictionary* Ref() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Ref", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Ref() const;
 /** (Optional; PDF 1.4) A metadata stream containing metadata for the form
  *  XObject (see Section 9.2.2, "Metadata Streams").
 **/
@@ -208,13 +148,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", NULL));
   }
 
-  SkPdfStream* Metadata() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Metadata", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* Metadata() const;
 /** (Optional; PDF 1.3) A page-piece dictionary associated with the form
  *  XObject (see Section 9.4, "Page-Piece Dictionaries").
 **/
@@ -222,13 +156,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PieceInfo", "", NULL));
   }
 
-  SkPdfDictionary* PieceInfo() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PieceInfo", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* PieceInfo() const;
 /** (Required if the form XObject is a structural content item; PDF 1.3) The integer
  *  key of the form XObject's entry in the structural parent tree (see "Finding
  *  Structure Elements from Content Items" on page 600).
@@ -237,13 +165,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", NULL));
   }
 
-  long StructParent() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long StructParent() const;
 /** (Required if the form XObject contains marked-content sequences that are struc-
  *  tural content items; PDF 1.3) The integer key of the form XObject's entry in
  *  the structural parent tree (see "Finding Structure Elements from Content
@@ -256,13 +178,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", NULL));
   }
 
-  long StructParents() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "StructParents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long StructParents() const;
 /** (Optional; PDF 1.2) An OPI version dictionary for the form XObject (see
  *  Section 9.10.6, "Open Prepress Interface (OPI)").
 **/
@@ -270,13 +186,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPI", "", NULL));
   }
 
-  SkPdfDictionary* OPI() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "OPI", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* OPI() const;
 };
 
 #endif  // __DEFINED__SkPdfType1FormDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType1HalftoneDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType1HalftoneDictionary_autogen.cpp
new file mode 100644
index 0000000..dc756bd
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType1HalftoneDictionary_autogen.cpp
@@ -0,0 +1,72 @@
+#include "SkPdfType1HalftoneDictionary_autogen.h"
+
+std::string SkPdfType1HalftoneDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfType1HalftoneDictionary::HalftoneType() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfType1HalftoneDictionary::HalftoneName() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+double SkPdfType1HalftoneDictionary::Frequency() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Frequency", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+double SkPdfType1HalftoneDictionary::Angle() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Angle", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfFunction SkPdfType1HalftoneDictionary::getSpotFunctionAsFunction() const {
+  SkPdfFunction ret = SkPdfFunction();
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
+std::string SkPdfType1HalftoneDictionary::getSpotFunctionAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+bool SkPdfType1HalftoneDictionary::AccurateScreens() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AccurateScreens", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+SkPdfFunction SkPdfType1HalftoneDictionary::getTransferFunctionAsFunction() const {
+  SkPdfFunction ret = SkPdfFunction();
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
+std::string SkPdfType1HalftoneDictionary::getTransferFunctionAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType1HalftoneDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType1HalftoneDictionary_autogen.h
index 0f229d9..b70d0cf 100644
--- a/experimental/PdfViewer/autogen/SkPdfType1HalftoneDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType1HalftoneDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) A code identifying the halftone type that this dictionary
  *  describes; must be 1 for this type of halftone.
 **/
@@ -546,26 +540,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", NULL));
   }
 
-  long HalftoneType() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long HalftoneType() const;
 /** (Optional) The name of the halftone dictionary.
 **/
   bool has_HalftoneName() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", NULL));
   }
 
-  std::string HalftoneName() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string HalftoneName() const;
 /** (Required) The screen frequency, measured in halftone cells per inch in
  *  device space.
 **/
@@ -573,13 +555,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Frequency", "", NULL));
   }
 
-  double Frequency() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Frequency", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double Frequency() const;
 /** (Required) The screen angle, in degrees of rotation counterclockwise
  *  with respect to the device coordinate system. (Note that most output
  *  devices have left-handed device spaces; on such devices, a counter-
@@ -590,13 +566,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Angle", "", NULL));
   }
 
-  double Angle() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Angle", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double Angle() const;
 /** (Required) A function object defining the order in which device pixels
  *  within a screen cell are adjusted for different gray levels, or the name of
  *  one of the predefined spot functions (see Table 6.1 on page 385).
@@ -611,26 +581,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfFunction getSpotFunctionAsFunction() const {
-    SkPdfFunction ret = SkPdfFunction();
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction getSpotFunctionAsFunction() const;
   bool isSpotFunctionAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getSpotFunctionAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SpotFunction", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getSpotFunctionAsName() const;
 /** (Optional) A flag specifying whether to invoke a special halftone al-
  *  gorithm that is extremely precise, but computationally expensive; see
  *  below for further discussion. Default value: false.
@@ -639,13 +597,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AccurateScreens", "", NULL));
   }
 
-  bool AccurateScreens() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "AccurateScreens", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool AccurateScreens() const;
 /** (Optional) A transfer function, which overrides the current transfer
  *  function in the graphics state for the same component. This entry is
  *  required if the dictionary is a component of a type 5 halftone (see
@@ -664,26 +616,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfFunction getTransferFunctionAsFunction() const {
-    SkPdfFunction ret = SkPdfFunction();
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction getTransferFunctionAsFunction() const;
   bool isTransferFunctionAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getTransferFunctionAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getTransferFunctionAsName() const;
 };
 
 #endif  // __DEFINED__SkPdfType1HalftoneDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType1PatternDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType1PatternDictionary_autogen.cpp
new file mode 100644
index 0000000..f2ac93a
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType1PatternDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfType1PatternDictionary_autogen.h"
+
+std::string SkPdfType1PatternDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfType1PatternDictionary::PatternType() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PatternType", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType1PatternDictionary::PaintType() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PaintType", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType1PatternDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType1PatternDictionary_autogen.h
index d191df0..4589339 100644
--- a/experimental/PdfViewer/autogen/SkPdfType1PatternDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType1PatternDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) A code identifying the type of pattern that this dictionary de-
  *  scribes; must be 1 for a tiling pattern.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PatternType", "", NULL));
   }
 
-  long PatternType() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PatternType", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long PatternType() const;
 /** (Required) A code that determines how the color of the pattern cell is to be
  *  specified:
  *     1     Colored tiling pattern. The pattern's content stream itself specifies the
@@ -569,13 +557,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PaintType", "", NULL));
   }
 
-  long PaintType() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PaintType", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long PaintType() const;
 };
 
 #endif  // __DEFINED__SkPdfType1PatternDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType1ShadingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType1ShadingDictionary_autogen.cpp
new file mode 100644
index 0000000..be4929d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType1ShadingDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfType1ShadingDictionary_autogen.h"
+
+SkPdfArray* SkPdfType1ShadingDictionary::Domain() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfType1ShadingDictionary::Matrix() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfFunction SkPdfType1ShadingDictionary::Function() const {
+  SkPdfFunction ret;
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType1ShadingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType1ShadingDictionary_autogen.h
index 6d2b740..80f82cf 100644
--- a/experimental/PdfViewer/autogen/SkPdfType1ShadingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType1ShadingDictionary_autogen.h
@@ -50,13 +50,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", NULL));
   }
 
-  SkPdfArray* Domain() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Domain() const;
 /** (Optional) An array of six numbers specifying a transformation matrix mapping
  *  the coordinate space specified by the Domain entry into the shading's target co-
  *  ordinate space. For example, to map the domain rectangle [0.0 1.0 0.0 1.0] to a
@@ -68,13 +62,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", NULL));
   }
 
-  SkPdfArray* Matrix() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Matrix() const;
 /** (Required) A 2-in, n-out function or an array of n 2-in, 1-out functions (where n
  *  is the number of color components in the shading dictionary's color space).
  *  Each function's domain must be a superset of that of the shading dictionary. If
@@ -85,13 +73,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", NULL));
   }
 
-  SkPdfFunction Function() const {
-    SkPdfFunction ret;
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction Function() const;
 };
 
 #endif  // __DEFINED__SkPdfType1ShadingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType2FunctionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType2FunctionDictionary_autogen.cpp
new file mode 100644
index 0000000..c57e0f8
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType2FunctionDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfType2FunctionDictionary_autogen.h"
+
+SkPdfArray* SkPdfType2FunctionDictionary::C0() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C0", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfType2FunctionDictionary::C1() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C1", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+double SkPdfType2FunctionDictionary::N() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType2FunctionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType2FunctionDictionary_autogen.h
index accbfd1..549db11 100644
--- a/experimental/PdfViewer/autogen/SkPdfType2FunctionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType2FunctionDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C0", "", NULL));
   }
 
-  SkPdfArray* C0() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C0", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* C0() const;
 /** (Optional) An array of n numbers defining the function result when x = 1.0 (hence the "1"
  *  in the name). Default value: [1.0].
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C1", "", NULL));
   }
 
-  SkPdfArray* C1() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C1", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* C1() const;
 /** (Required) The interpolation exponent. Each input value x will return n values, given by
  *  yj = C0j + xN x (C1j - C0j ), for 0 <= j < n.
 **/
@@ -560,13 +548,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", NULL));
   }
 
-  double N() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "N", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double N() const;
 };
 
 #endif  // __DEFINED__SkPdfType2FunctionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType2PatternDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType2PatternDictionary_autogen.cpp
new file mode 100644
index 0000000..7f0976f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType2PatternDictionary_autogen.cpp
@@ -0,0 +1,44 @@
+#include "SkPdfType2PatternDictionary_autogen.h"
+
+long SkPdfType2PatternDictionary::Type() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType2PatternDictionary::PatternType() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PatternType", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfDictionary* SkPdfType2PatternDictionary::getShadingAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfType2PatternDictionary::getShadingAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfType2PatternDictionary::Matrix() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfType2PatternDictionary::ExtGState() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ExtGState", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType2PatternDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType2PatternDictionary_autogen.h
index d88fa8a..d97b721 100644
--- a/experimental/PdfViewer/autogen/SkPdfType2PatternDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType2PatternDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  long Type() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Type() const;
 /** (Required) A code identifying the type of pattern that this dictionary de-
  *  scribes; must be 2 for a shading pattern.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PatternType", "", NULL));
   }
 
-  long PatternType() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PatternType", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long PatternType() const;
 /** (Required) A shading object (see below) defining the shading pattern's gradient
  *  fill. The contents of the dictionary consist of the entries in Table 4.25 on page
  *  234, plus those in one of Tables 4.26 to 4.31 on pages 237 to 253.
@@ -567,26 +555,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getShadingAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getShadingAsDictionary() const;
   bool isShadingAStream() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return false;
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getShadingAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Shading", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getShadingAsStream() const;
 /** (Optional) An array of six numbers specifying the pattern matrix (see Section
  *  4.6.1, "General Properties of Patterns"). Default value: the identity matrix
  *  [1 0 0 1 0 0].
@@ -595,13 +571,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", NULL));
   }
 
-  SkPdfArray* Matrix() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Matrix", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Matrix() const;
 /** (Optional) A graphics state parameter dictionary (see Section 4.3.4, "Graph-
  *  ics State Parameter Dictionaries") containing graphics state parameters to be
  *  put into effect temporarily while the shading pattern is painted. Any parame-
@@ -613,13 +583,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ExtGState", "", NULL));
   }
 
-  SkPdfDictionary* ExtGState() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ExtGState", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* ExtGState() const;
 };
 
 #endif  // __DEFINED__SkPdfType2PatternDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType2ShadingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType2ShadingDictionary_autogen.cpp
new file mode 100644
index 0000000..b0069d0
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType2ShadingDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfType2ShadingDictionary_autogen.h"
+
+SkPdfArray* SkPdfType2ShadingDictionary::Coords() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfType2ShadingDictionary::Domain() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfFunction SkPdfType2ShadingDictionary::Function() const {
+  SkPdfFunction ret;
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
+SkPdfArray* SkPdfType2ShadingDictionary::Extend() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType2ShadingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType2ShadingDictionary_autogen.h
index 8b5667f..3b91dee 100644
--- a/experimental/PdfViewer/autogen/SkPdfType2ShadingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType2ShadingDictionary_autogen.h
@@ -50,13 +50,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", NULL));
   }
 
-  SkPdfArray* Coords() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Coords() const;
 /** (Optional) An array of two numbers [ t0 t1 ] specifying the limiting values of a
  *  parametric variable t. The variable is considered to vary linearly between these
  *  two values as the color gradient varies between the starting and ending points of
@@ -67,13 +61,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", NULL));
   }
 
-  SkPdfArray* Domain() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Domain() const;
 /** (Required) A 1-in, n-out function or an array of n 1-in, 1-out functions (where n
  *  is the number of color components in the shading dictionary's color space). The
  *  function(s) are called with values of the parametric variable t in the domain de-
@@ -85,13 +73,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", NULL));
   }
 
-  SkPdfFunction Function() const {
-    SkPdfFunction ret;
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction Function() const;
 /** (Optional) An array of two boolean values specifying whether to extend the
  *  shading beyond the starting and ending points of the axis, respectively. Default
  *  value: [false false].
@@ -100,13 +82,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", NULL));
   }
 
-  SkPdfArray* Extend() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Extend() const;
 };
 
 #endif  // __DEFINED__SkPdfType2ShadingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType3FontDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType3FontDictionary_autogen.cpp
new file mode 100644
index 0000000..7b413e3
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType3FontDictionary_autogen.cpp
@@ -0,0 +1,93 @@
+#include "SkPdfType3FontDictionary_autogen.h"
+
+std::string SkPdfType3FontDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfType3FontDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfType3FontDictionary::Name() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkRect* SkPdfType3FontDictionary::FontBBox() const {
+  SkRect* ret;
+  if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkMatrix* SkPdfType3FontDictionary::FontMatrix() const {
+  SkMatrix* ret;
+  if (SkMatrixFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontMatrix", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfType3FontDictionary::CharProcs() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CharProcs", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfType3FontDictionary::getEncodingAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfEncodingDictionary* SkPdfType3FontDictionary::getEncodingAsEncodingdictionary() const {
+  SkPdfEncodingDictionary* ret = NULL;
+  if (EncodingDictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+long SkPdfType3FontDictionary::FirstChar() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FirstChar", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType3FontDictionary::LastChar() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastChar", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfType3FontDictionary::Widths() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Widths", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfType3FontDictionary::Resources() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfType3FontDictionary::ToUnicode() const {
+  SkPdfStream* ret;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType3FontDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType3FontDictionary_autogen.h
index 079930e..0bd04be 100644
--- a/experimental/PdfViewer/autogen/SkPdfType3FontDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType3FontDictionary_autogen.h
@@ -40,39 +40,21 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The type of font; must be Type3 for a Type 3 font.
 **/
   bool has_Subtype() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Required in PDF 1.0; optional otherwise) See Table 5.8 on page 317.
 **/
   bool has_Name() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", NULL));
   }
 
-  std::string Name() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Name", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Name() const;
 /** (Required) A rectangle (see Section 3.8.3, "Rectangles"), expressed in the
  *  glyph coordinate system, specifying the font bounding box. This is the small-
  *  est rectangle enclosing the shape that would result if all of the glyphs of the
@@ -86,13 +68,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", NULL));
   }
 
-  SkRect* FontBBox() const {
-    SkRect* ret;
-    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontBBox", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkRect* FontBBox() const;
 /** (Required) An array of six numbers specifying the font matrix, mapping
  *  glyph space to text space (see Section 5.1.3, "Glyph Positioning and
  *  Metrics"). A common practice is to define glyphs in terms of a 1000-unit
@@ -103,13 +79,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontMatrix", "", NULL));
   }
 
-  SkMatrix* FontMatrix() const {
-    SkMatrix* ret;
-    if (SkMatrixFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FontMatrix", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkMatrix* FontMatrix() const;
 /** (Required) A dictionary in which each key is a character name and the value
  *  associated with that key is a content stream that constructs and paints the
  *  glyph for that character. The stream must include as its first operator either
@@ -121,13 +91,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CharProcs", "", NULL));
   }
 
-  SkPdfDictionary* CharProcs() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CharProcs", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* CharProcs() const;
 /** (Required) An encoding dictionary whose Differences array specifies the
  *  complete character encoding for this font (see Section 5.5.5, "Character
  *  Encoding"; also see implementation note 46 in Appendix H).
@@ -142,52 +106,28 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getEncodingAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getEncodingAsName() const;
   bool isEncodingAEncodingdictionary() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfEncodingDictionary* getEncodingAsEncodingdictionary() const {
-    SkPdfEncodingDictionary* ret = NULL;
-    if (DictionaryFromDictionary2(fPodofoDoc, fPodofoObj->GetDictionary(), "Encoding", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfEncodingDictionary* getEncodingAsEncodingdictionary() const;
 /** (Required) The first character code defined in the font's Widths array.
 **/
   bool has_FirstChar() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FirstChar", "", NULL));
   }
 
-  long FirstChar() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FirstChar", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long FirstChar() const;
 /** (Required) The last character code defined in the font's Widths array.
 **/
   bool has_LastChar() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastChar", "", NULL));
   }
 
-  long LastChar() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "LastChar", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long LastChar() const;
 /** (Required; indirect reference preferred) An array of (LastChar - FirstChar + 1)
  *  widths, each element being the glyph width for the character whose code is
  *  FirstChar plus the array index. For character codes outside the range FirstChar
@@ -202,13 +142,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Widths", "", NULL));
   }
 
-  SkPdfArray* Widths() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Widths", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Widths() const;
 /** (Optional but strongly recommended; PDF 1.2) A list of the named resources,
  *  such as fonts and images, required by the glyph descriptions in this font (see
  *  Section 3.7.2, "Resource Dictionaries"). If any glyph descriptions refer to
@@ -220,13 +154,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", NULL));
   }
 
-  SkPdfDictionary* Resources() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Resources", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* Resources() const;
 /** (Optional; PDF 1.2) A stream containing a CMap file that maps character
  *  codes to Unicode values (see Section 5.9, "ToUnicode CMaps").
 **/
@@ -234,13 +162,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", NULL));
   }
 
-  SkPdfStream* ToUnicode() const {
-    SkPdfStream* ret;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ToUnicode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* ToUnicode() const;
 };
 
 #endif  // __DEFINED__SkPdfType3FontDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType3FunctionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType3FunctionDictionary_autogen.cpp
new file mode 100644
index 0000000..6449c31
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType3FunctionDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfType3FunctionDictionary_autogen.h"
+
+SkPdfArray* SkPdfType3FunctionDictionary::Functions() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Functions", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfType3FunctionDictionary::Bounds() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bounds", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfType3FunctionDictionary::Encode() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType3FunctionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType3FunctionDictionary_autogen.h
index b09b9fa..38451fb 100644
--- a/experimental/PdfViewer/autogen/SkPdfType3FunctionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType3FunctionDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Functions", "", NULL));
   }
 
-  SkPdfArray* Functions() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Functions", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Functions() const;
 /** (Required) An array of k - 1 numbers that, in combination with Domain, define the
  *  intervals to which each function from the Functions array applies. Bounds elements
  *  must be in order of increasing value, and each value must be within the domain
@@ -549,13 +543,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bounds", "", NULL));
   }
 
-  SkPdfArray* Bounds() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Bounds", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Bounds() const;
 /** (Required) An array of 2 x k numbers that, taken in pairs, map each subset of the do-
  *  main defined by Domain and the Bounds array to the domain of the corresponding
  *  function.
@@ -564,13 +552,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", NULL));
   }
 
-  SkPdfArray* Encode() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Encode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Encode() const;
 };
 
 #endif  // __DEFINED__SkPdfType3FunctionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType3ShadingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType3ShadingDictionary_autogen.cpp
new file mode 100644
index 0000000..042cc8f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType3ShadingDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfType3ShadingDictionary_autogen.h"
+
+SkPdfArray* SkPdfType3ShadingDictionary::Coords() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfType3ShadingDictionary::Domain() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfFunction SkPdfType3ShadingDictionary::Function() const {
+  SkPdfFunction ret;
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
+SkPdfArray* SkPdfType3ShadingDictionary::Extend() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType3ShadingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType3ShadingDictionary_autogen.h
index cff6013..68f4891 100644
--- a/experimental/PdfViewer/autogen/SkPdfType3ShadingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType3ShadingDictionary_autogen.h
@@ -52,13 +52,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", NULL));
   }
 
-  SkPdfArray* Coords() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Coords", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Coords() const;
 /** (Optional) An array of two numbers [ t0 t1 ] specifying the limiting values of a
  *  parametric variable t. The variable is considered to vary linearly between these
  *  two values as the color gradient varies between the starting and ending circles.
@@ -69,13 +63,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", NULL));
   }
 
-  SkPdfArray* Domain() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Domain", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Domain() const;
 /** (Required) A 1-in, n-out function or an array of n 1-in, 1-out functions (where n
  *  is the number of color components in the shading dictionary's color space). The
  *  function(s) are called with values of the parametric variable t in the domain de-
@@ -88,13 +76,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", NULL));
   }
 
-  SkPdfFunction Function() const {
-    SkPdfFunction ret;
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction Function() const;
 /** (Optional) An array of two boolean values specifying whether to extend the
  *  shading beyond the starting and ending circles, respectively. Default value:
  *  [false false].
@@ -103,13 +85,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", NULL));
   }
 
-  SkPdfArray* Extend() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Extend", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Extend() const;
 };
 
 #endif  // __DEFINED__SkPdfType3ShadingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType4ShadingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType4ShadingDictionary_autogen.cpp
new file mode 100644
index 0000000..671856e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType4ShadingDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfType4ShadingDictionary_autogen.h"
+
+long SkPdfType4ShadingDictionary::BitsPerCoordinate() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType4ShadingDictionary::BitsPerComponent() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType4ShadingDictionary::BitsPerFlag() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerFlag", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkRect* SkPdfType4ShadingDictionary::Decode() const {
+  SkRect* ret;
+  if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfFunction SkPdfType4ShadingDictionary::Function() const {
+  SkPdfFunction ret;
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType4ShadingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType4ShadingDictionary_autogen.h
index eeb531d..9deff01 100644
--- a/experimental/PdfViewer/autogen/SkPdfType4ShadingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType4ShadingDictionary_autogen.h
@@ -49,13 +49,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", NULL));
   }
 
-  long BitsPerCoordinate() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long BitsPerCoordinate() const;
 /** (Required) The number of bits used to represent each color component.
  *  Valid values are 1, 2, 4, 8, 12, and 16.
 **/
@@ -63,13 +57,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", NULL));
   }
 
-  long BitsPerComponent() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long BitsPerComponent() const;
 /** (Required) The number of bits used to represent the edge flag for each ver-
  *  tex (see below). Valid values of BitsPerFlag are 2, 4, and 8, but only the
  *  least significant 2 bits in each flag value are used. Valid values for the edge
@@ -79,13 +67,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerFlag", "", NULL));
   }
 
-  long BitsPerFlag() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerFlag", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long BitsPerFlag() const;
 /** (Required) An array of numbers specifying how to map vertex coordinates
  *  and color components into the appropriate ranges of values. The de-
  *  coding method is similar to that used in image dictionaries (see "Decode
@@ -98,13 +80,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", NULL));
   }
 
-  SkRect* Decode() const {
-    SkRect* ret;
-    if (SkRectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkRect* Decode() const;
 /** (Optional) A 1-in, n-out function or an array of n 1-in, 1-out functions
  *  (where n is the number of color components in the shading dictionary's
  *  color space). If this entry is present, the color data for each vertex must be
@@ -122,13 +98,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", NULL));
   }
 
-  SkPdfFunction Function() const {
-    SkPdfFunction ret;
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction Function() const;
 };
 
 #endif  // __DEFINED__SkPdfType4ShadingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType5HalftoneDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType5HalftoneDictionary_autogen.cpp
new file mode 100644
index 0000000..0d999dc
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType5HalftoneDictionary_autogen.cpp
@@ -0,0 +1,53 @@
+#include "SkPdfType5HalftoneDictionary_autogen.h"
+
+std::string SkPdfType5HalftoneDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+double SkPdfType5HalftoneDictionary::HalftoneType() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfType5HalftoneDictionary::HalftoneName() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+/*
+SkPdfDictionary* SkPdfType5HalftoneDictionary::get[any_colorant_name]AsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfType5HalftoneDictionary::get[any_colorant_name]AsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+*/
+SkPdfDictionary* SkPdfType5HalftoneDictionary::getDefaultAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfStream* SkPdfType5HalftoneDictionary::getDefaultAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType5HalftoneDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType5HalftoneDictionary_autogen.h
index d3b3e77..0179af3 100644
--- a/experimental/PdfViewer/autogen/SkPdfType5HalftoneDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType5HalftoneDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) A code identifying the halftone type that this dictionary describes;
  *  must be 5 for this type of halftone.
 **/
@@ -546,26 +540,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", NULL));
   }
 
-  double HalftoneType() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double HalftoneType() const;
 /** (Optional) The name of the halftone dictionary.
 **/
   bool has_HalftoneName() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", NULL));
   }
 
-  std::string HalftoneName() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string HalftoneName() const;
 /** (Required, one per colorant) The halftone corresponding to the colorant or
  *  color component named by the key. The halftone may be of any type other
  *  than 5. Note that the key must be a name object; strings are not permitted, as
@@ -582,26 +564,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* get[any_colorant_name]AsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* get[any_colorant_name]AsDictionary() const;
   bool is[any_colorant_name]AStream() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return false;
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* get[any_colorant_name]AsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "[any_colorant_name]", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* get[any_colorant_name]AsStream() const;
 */
 /** (Required) A halftone to be used for any colorant or color component that
  *  does not have an entry of its own. The value may not be a type 5 halftone. If
@@ -618,26 +588,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getDefaultAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getDefaultAsDictionary() const;
   bool isDefaultAStream() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return false;
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getDefaultAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Default", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getDefaultAsStream() const;
 };
 
 #endif  // __DEFINED__SkPdfType5HalftoneDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType5ShadingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType5ShadingDictionary_autogen.cpp
new file mode 100644
index 0000000..4ec82d1
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType5ShadingDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfType5ShadingDictionary_autogen.h"
+
+long SkPdfType5ShadingDictionary::BitsPerCoordinate() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType5ShadingDictionary::BitsPerComponent() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType5ShadingDictionary::VerticesPerRow() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "VerticesPerRow", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfType5ShadingDictionary::Decode() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfFunction SkPdfType5ShadingDictionary::Function() const {
+  SkPdfFunction ret;
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType5ShadingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType5ShadingDictionary_autogen.h
index bfed8fb..399e713 100644
--- a/experimental/PdfViewer/autogen/SkPdfType5ShadingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType5ShadingDictionary_autogen.h
@@ -49,13 +49,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", NULL));
   }
 
-  long BitsPerCoordinate() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long BitsPerCoordinate() const;
 /** (Required) The number of bits used to represent each color component.
  *  Valid values are 1, 2, 4, 8, 12, and 16.
 **/
@@ -63,13 +57,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", NULL));
   }
 
-  long BitsPerComponent() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long BitsPerComponent() const;
 /** (Required) The number of vertices in each row of the lattice; the value
  *  must be greater than or equal to 2. The number of rows need not be
  *  specified.
@@ -78,13 +66,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "VerticesPerRow", "", NULL));
   }
 
-  long VerticesPerRow() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "VerticesPerRow", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long VerticesPerRow() const;
 /** (Required) An array of numbers specifying how to map vertex coordinates
  *  and color components into the appropriate ranges of values. The de-
  *  coding method is similar to that used in image dictionaries (see "Decode
@@ -97,13 +79,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", NULL));
   }
 
-  SkPdfArray* Decode() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Decode() const;
 /** (Optional) A 1-in, n-out function or an array of n 1-in, 1-out functions
  *  (where n is the number of color components in the shading dictionary's
  *  color space). If this entry is present, the color data for each vertex must be
@@ -121,13 +97,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", NULL));
   }
 
-  SkPdfFunction Function() const {
-    SkPdfFunction ret;
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction Function() const;
 };
 
 #endif  // __DEFINED__SkPdfType5ShadingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType6HalftoneDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType6HalftoneDictionary_autogen.cpp
new file mode 100644
index 0000000..8f9ecd4
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType6HalftoneDictionary_autogen.cpp
@@ -0,0 +1,51 @@
+#include "SkPdfType6HalftoneDictionary_autogen.h"
+
+std::string SkPdfType6HalftoneDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfType6HalftoneDictionary::HalftoneType() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfType6HalftoneDictionary::HalftoneName() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfType6HalftoneDictionary::Width() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType6HalftoneDictionary::Height() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfFunction SkPdfType6HalftoneDictionary::getTransferFunctionAsFunction() const {
+  SkPdfFunction ret = SkPdfFunction();
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
+std::string SkPdfType6HalftoneDictionary::getTransferFunctionAsName() const {
+  std::string ret = "";
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType6HalftoneDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType6HalftoneDictionary_autogen.h
index 74dac95..9c68248 100644
--- a/experimental/PdfViewer/autogen/SkPdfType6HalftoneDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType6HalftoneDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) A code identifying the halftone type that this dictionary
  *  describes; must be 6 for this type of halftone.
 **/
@@ -546,52 +540,28 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", NULL));
   }
 
-  long HalftoneType() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneType", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long HalftoneType() const;
 /** (Optional) The name of the halftone dictionary.
 **/
   bool has_HalftoneName() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", NULL));
   }
 
-  std::string HalftoneName() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HalftoneName", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string HalftoneName() const;
 /** (Required) The width of the threshold array, in device pixels.
 **/
   bool has_Width() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", NULL));
   }
 
-  long Width() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Width", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Width() const;
 /** (Required) The height of the threshold array, in device pixels.
 **/
   bool has_Height() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", NULL));
   }
 
-  long Height() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Height", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Height() const;
 /** (Optional) A transfer function, which overrides the current transfer
  *  function in the graphics state for the same component. This entry is
  *  required if the dictionary is a component of a type 5 halftone (see
@@ -610,26 +580,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Reference;
   }
 
-  SkPdfFunction getTransferFunctionAsFunction() const {
-    SkPdfFunction ret = SkPdfFunction();
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction getTransferFunctionAsFunction() const;
   bool isTransferFunctionAName() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Name;
   }
 
-  std::string getTransferFunctionAsName() const {
-    std::string ret = "";
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TransferFunction", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getTransferFunctionAsName() const;
 };
 
 #endif  // __DEFINED__SkPdfType6HalftoneDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfType6ShadingDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfType6ShadingDictionary_autogen.cpp
new file mode 100644
index 0000000..c7fa09e
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfType6ShadingDictionary_autogen.cpp
@@ -0,0 +1,37 @@
+#include "SkPdfType6ShadingDictionary_autogen.h"
+
+long SkPdfType6ShadingDictionary::BitsPerCoordinate() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType6ShadingDictionary::BitsPerComponent() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfType6ShadingDictionary::BitsPerFlag() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerFlag", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfType6ShadingDictionary::Decode() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfFunction SkPdfType6ShadingDictionary::Function() const {
+  SkPdfFunction ret;
+  if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfFunction();
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfType6ShadingDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfType6ShadingDictionary_autogen.h
index dfb9fd4..59755ac 100644
--- a/experimental/PdfViewer/autogen/SkPdfType6ShadingDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfType6ShadingDictionary_autogen.h
@@ -49,13 +49,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", NULL));
   }
 
-  long BitsPerCoordinate() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerCoordinate", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long BitsPerCoordinate() const;
 /** (Required) The number of bits used to represent each color component.
  *  Valid values are 1, 2, 4, 8, 12, and 16.
 **/
@@ -63,13 +57,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", NULL));
   }
 
-  long BitsPerComponent() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerComponent", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long BitsPerComponent() const;
 /** (Required) The number of bits used to represent the edge flag for each
  *  patch (see below). Valid values of BitsPerFlag are 2, 4, and 8, but only the
  *  least significant 2 bits in each flag value are used. Valid values for the edge
@@ -79,13 +67,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerFlag", "", NULL));
   }
 
-  long BitsPerFlag() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "BitsPerFlag", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long BitsPerFlag() const;
 /** (Required) An array of numbers specifying how to map coordinates and
  *  color components into the appropriate ranges of values. The decoding
  *  method is similar to that used in image dictionaries (see "Decode Arrays"
@@ -98,13 +80,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", NULL));
   }
 
-  SkPdfArray* Decode() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Decode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* Decode() const;
 /** (Optional) A 1-in, n-out function or an array of n 1-in, 1-out functions
  *  (where n is the number of color components in the shading dictionary's
  *  color space). If this entry is present, the color data for each vertex must be
@@ -122,13 +98,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", NULL));
   }
 
-  SkPdfFunction Function() const {
-    SkPdfFunction ret;
-    if (FunctionFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Function", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfFunction();
-  }
-
+  SkPdfFunction Function() const;
 };
 
 #endif  // __DEFINED__SkPdfType6ShadingDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfURIActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfURIActionDictionary_autogen.cpp
new file mode 100644
index 0000000..e2bf8cf
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfURIActionDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfURIActionDictionary_autogen.h"
+
+std::string SkPdfURIActionDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfURIActionDictionary::URI() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URI", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+bool SkPdfURIActionDictionary::IsMap() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IsMap", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfURIActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfURIActionDictionary_autogen.h
index 8b21a61..212969e 100644
--- a/experimental/PdfViewer/autogen/SkPdfURIActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfURIActionDictionary_autogen.h
@@ -532,26 +532,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required) The uniform resource identifier to resolve, encoded in 7-bit ASCII.
 **/
   bool has_URI() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URI", "", NULL));
   }
 
-  std::string URI() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URI", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string URI() const;
 /** (Optional) A flag specifying whether to track the mouse position when the URI is re-
  *  solved (see below). Default value: false.
  *  This entry applies only to actions triggered by the user's clicking an annotation; it is
@@ -562,13 +550,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IsMap", "", NULL));
   }
 
-  bool IsMap() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "IsMap", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool IsMap() const;
 };
 
 #endif  // __DEFINED__SkPdfURIActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfURIDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfURIDictionary_autogen.cpp
new file mode 100644
index 0000000..1c10e0b
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfURIDictionary_autogen.cpp
@@ -0,0 +1,9 @@
+#include "SkPdfURIDictionary_autogen.h"
+
+std::string SkPdfURIDictionary::Base() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Base", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfURIDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfURIDictionary_autogen.h
index a35b94e..be21237 100644
--- a/experimental/PdfViewer/autogen/SkPdfURIDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfURIDictionary_autogen.h
@@ -536,13 +536,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Base", "", NULL));
   }
 
-  std::string Base() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Base", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Base() const;
 };
 
 #endif  // __DEFINED__SkPdfURIDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfURLAliasDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfURLAliasDictionary_autogen.cpp
new file mode 100644
index 0000000..7368499
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfURLAliasDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfURLAliasDictionary_autogen.h"
+
+std::string SkPdfURLAliasDictionary::U() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfURLAliasDictionary::C() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfURLAliasDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfURLAliasDictionary_autogen.h
index 1360788..93ad7f6 100644
--- a/experimental/PdfViewer/autogen/SkPdfURLAliasDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfURLAliasDictionary_autogen.h
@@ -531,13 +531,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", NULL));
   }
 
-  std::string U() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "U", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string U() const;
 /** (Optional) An array of one or more arrays of strings, each representing a chain of URLs
  *  leading to the common destination specified by U.
 **/
@@ -545,13 +539,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
   }
 
-  SkPdfArray* C() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* C() const;
 };
 
 #endif  // __DEFINED__SkPdfURLAliasDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfVariableTextFieldDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfVariableTextFieldDictionary_autogen.cpp
new file mode 100644
index 0000000..e927f3c
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfVariableTextFieldDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfVariableTextFieldDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfVariableTextFieldDictionary::DR() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DR", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfVariableTextFieldDictionary::DA() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfVariableTextFieldDictionary::Q() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfVariableTextFieldDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfVariableTextFieldDictionary_autogen.h
index 5543ca8..29e54a4 100644
--- a/experimental/PdfViewer/autogen/SkPdfVariableTextFieldDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfVariableTextFieldDictionary_autogen.h
@@ -535,13 +535,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DR", "", NULL));
   }
 
-  SkPdfDictionary* DR() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DR", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* DR() const;
 /** (Required; inheritable) The default appearance string, containing a sequence of valid
  *  page-content graphics or text state operators defining such properties as the field's text
  *  size and color.
@@ -550,13 +544,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", NULL));
   }
 
-  std::string DA() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DA", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string DA() const;
 /** (Optional; inheritable) A code specifying the form of quadding (justification) to be
  *  used in displaying the text:
  *      0    Left-justified
@@ -568,13 +556,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", NULL));
   }
 
-  long Q() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Q", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long Q() const;
 };
 
 #endif  // __DEFINED__SkPdfVariableTextFieldDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfViewerPreferencesDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfViewerPreferencesDictionary_autogen.cpp
new file mode 100644
index 0000000..dac44df
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfViewerPreferencesDictionary_autogen.cpp
@@ -0,0 +1,86 @@
+#include "SkPdfViewerPreferencesDictionary_autogen.h"
+
+bool SkPdfViewerPreferencesDictionary::HideToolbar() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideToolbar", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+bool SkPdfViewerPreferencesDictionary::HideMenubar() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideMenubar", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+bool SkPdfViewerPreferencesDictionary::HideWindowUI() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideWindowUI", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+bool SkPdfViewerPreferencesDictionary::FitWindow() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FitWindow", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+bool SkPdfViewerPreferencesDictionary::CenterWindow() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CenterWindow", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+bool SkPdfViewerPreferencesDictionary::DisplayDocTitle() const {
+  bool ret;
+  if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DisplayDocTitle", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return false;
+}
+
+std::string SkPdfViewerPreferencesDictionary::NonFullScreenPageMode() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NonFullScreenPageMode", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfViewerPreferencesDictionary::Direction() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Direction", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfViewerPreferencesDictionary::ViewArea() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewArea", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfViewerPreferencesDictionary::ViewClip() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewClip", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfViewerPreferencesDictionary::PrintArea() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PrintArea", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfViewerPreferencesDictionary::PrintClip() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PrintClip", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfViewerPreferencesDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfViewerPreferencesDictionary_autogen.h
index b604916..0f6a327 100644
--- a/experimental/PdfViewer/autogen/SkPdfViewerPreferencesDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfViewerPreferencesDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideToolbar", "", NULL));
   }
 
-  bool HideToolbar() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideToolbar", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool HideToolbar() const;
 /** (Optional) A flag specifying whether to hide the viewer application's
  *  menu bar when the document is active. Default value: false.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideMenubar", "", NULL));
   }
 
-  bool HideMenubar() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideMenubar", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool HideMenubar() const;
 /** (Optional) A flag specifying whether to hide user interface elements in
  *  the document's window (such as scroll bars and navigation controls),
  *  leaving only the document's contents displayed. Default value: false.
@@ -561,13 +549,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideWindowUI", "", NULL));
   }
 
-  bool HideWindowUI() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "HideWindowUI", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool HideWindowUI() const;
 /** (Optional) A flag specifying whether to resize the document's window to
  *  fit the size of the first displayed page. Default value: false.
 **/
@@ -575,13 +557,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FitWindow", "", NULL));
   }
 
-  bool FitWindow() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "FitWindow", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool FitWindow() const;
 /** (Optional) A flag specifying whether to position the document's window
  *  in the center of the screen. Default value: false.
 **/
@@ -589,13 +565,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CenterWindow", "", NULL));
   }
 
-  bool CenterWindow() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CenterWindow", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool CenterWindow() const;
 /** (Optional; PDF 1.4) A flag specifying whether the window's title bar
  *  should display the document title taken from the Title entry of the docu-
  *  ment information dictionary (see Section 9.2.1, "Document Informa-
@@ -606,13 +576,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DisplayDocTitle", "", NULL));
   }
 
-  bool DisplayDocTitle() const {
-    bool ret;
-    if (BoolFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "DisplayDocTitle", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return false;
-  }
-
+  bool DisplayDocTitle() const;
 /** (Optional) The document's page mode, specifying how to display the
  *  document on exiting full-screen mode:
  *       UseNone            Neither document outline nor thumbnail images
@@ -627,13 +591,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NonFullScreenPageMode", "", NULL));
   }
 
-  std::string NonFullScreenPageMode() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "NonFullScreenPageMode", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string NonFullScreenPageMode() const;
 /** (Optional; PDF 1.3) The predominant reading order for text:
  *       L2R                Left to right
  *       R2L                Right to left (including vertical writing systems
@@ -646,13 +604,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Direction", "", NULL));
   }
 
-  std::string Direction() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Direction", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Direction() const;
 /** (Optional; PDF 1.4) The name of the page boundary representing the
  *  area of a page to be displayed when viewing the document on the screen.
  *  The value is the key designating the relevant page boundary in the page
@@ -668,13 +620,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewArea", "", NULL));
   }
 
-  std::string ViewArea() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewArea", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string ViewArea() const;
 /** (Optional; PDF 1.4) The name of the page boundary to which the con-
  *  tents of a page are to be clipped when viewing the document on the
  *  screen. The value is the key designating the relevant page boundary in
@@ -690,13 +636,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewClip", "", NULL));
   }
 
-  std::string ViewClip() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ViewClip", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string ViewClip() const;
 /** (Optional; PDF 1.4) The name of the page boundary representing the
  *  area of a page to be rendered when printing the document. The value is
  *  the key designating the relevant page boundary in the page object (see
@@ -711,13 +651,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PrintArea", "", NULL));
   }
 
-  std::string PrintArea() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PrintArea", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string PrintArea() const;
 /** (Optional; PDF 1.4) The name of the page boundary to which the con-
  *  tents of a page are to be clipped when printing the document. The value
  *  is the key designating the relevant page boundary in the page object (see
@@ -732,13 +666,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PrintClip", "", NULL));
   }
 
-  std::string PrintClip() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "PrintClip", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string PrintClip() const;
 };
 
 #endif  // __DEFINED__SkPdfViewerPreferencesDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandDictionary_autogen.cpp
new file mode 100644
index 0000000..f09a7b1
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandDictionary_autogen.cpp
@@ -0,0 +1,58 @@
+#include "SkPdfWebCaptureCommandDictionary_autogen.h"
+
+std::string SkPdfWebCaptureCommandDictionary::URL() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URL", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfWebCaptureCommandDictionary::L() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+long SkPdfWebCaptureCommandDictionary::F() const {
+  long ret;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+std::string SkPdfWebCaptureCommandDictionary::getPAsString() const {
+  std::string ret = "";
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfStream* SkPdfWebCaptureCommandDictionary::getPAsStream() const {
+  SkPdfStream* ret = NULL;
+  if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfWebCaptureCommandDictionary::CT() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CT", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfWebCaptureCommandDictionary::H() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfWebCaptureCommandDictionary::S() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandDictionary_autogen.h
index 4627361..acb84c0 100644
--- a/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandDictionary_autogen.h
@@ -531,13 +531,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URL", "", NULL));
   }
 
-  std::string URL() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "URL", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string URL() const;
 /** (Optional) The number of levels of pages retrieved from the initial URL. Default
  *  value: 1.
 **/
@@ -545,13 +539,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", NULL));
   }
 
-  long L() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "L", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long L() const;
 /** (Optional) A set of flags specifying various characteristics of the command (see
  *  Table 9.39). Default value: 0.
 **/
@@ -559,13 +547,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  long F() const {
-    long ret;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long F() const;
 /** (Optional) Data that was posted to the URL.
 **/
   bool has_P() const {
@@ -578,26 +560,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString;
   }
 
-  std::string getPAsString() const {
-    std::string ret = "";
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string getPAsString() const;
   bool isPAStream() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return false;
     return ret->podofo()->HasStream();
   }
 
-  SkPdfStream* getPAsStream() const {
-    SkPdfStream* ret = NULL;
-    if (StreamFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfStream* getPAsStream() const;
 /** (Optional) A content type describing the data posted to the URL. Default value:
  *  application/x-www-form-urlencoded.
 **/
@@ -605,26 +575,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CT", "", NULL));
   }
 
-  std::string CT() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CT", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string CT() const;
 /** (Optional) Additional HTTP request headers sent to the URL.
 **/
   bool has_H() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", NULL));
   }
 
-  std::string H() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string H() const;
 /** (Optional) A command settings dictionary containing settings used in the con-
  *  version process (see "Command Settings" on page 674).
 **/
@@ -632,13 +590,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  SkPdfDictionary* S() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* S() const;
 };
 
 #endif  // __DEFINED__SkPdfWebCaptureCommandDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandSettingsDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandSettingsDictionary_autogen.cpp
new file mode 100644
index 0000000..f0790e6
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandSettingsDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfWebCaptureCommandSettingsDictionary_autogen.h"
+
+SkPdfDictionary* SkPdfWebCaptureCommandSettingsDictionary::G() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfWebCaptureCommandSettingsDictionary::C() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandSettingsDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandSettingsDictionary_autogen.h
index d471d14..ecbff5c 100644
--- a/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandSettingsDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureCommandSettingsDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", NULL));
   }
 
-  SkPdfDictionary* G() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "G", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* G() const;
 /** (Optional) Settings for specific conversion engines. Each key in this dictionary is the
  *  internal name of a conversion engine (see below). The associated value is a dictionary
  *  containing the settings associated with that conversion engine. If the settings for a par-
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
   }
 
-  SkPdfDictionary* C() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* C() const;
 };
 
 #endif  // __DEFINED__SkPdfWebCaptureCommandSettingsDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWebCaptureDictionary_autogen.cpp
new file mode 100644
index 0000000..0892588
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureDictionary_autogen.cpp
@@ -0,0 +1,58 @@
+#include "SkPdfWebCaptureDictionary_autogen.h"
+
+std::string SkPdfWebCaptureDictionary::Type() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfWebCaptureDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfWebCaptureDictionary::ID() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfArray* SkPdfWebCaptureDictionary::O() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfDictionary* SkPdfWebCaptureDictionary::getSIAsDictionary() const {
+  SkPdfDictionary* ret = NULL;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+SkPdfArray* SkPdfWebCaptureDictionary::getSIAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
+std::string SkPdfWebCaptureDictionary::CT() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CT", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDate SkPdfWebCaptureDictionary::TS() const {
+  SkPdfDate ret;
+  if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return SkPdfDate();
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWebCaptureDictionary_autogen.h
index 2460a7a..c87963e 100644
--- a/experimental/PdfViewer/autogen/SkPdfWebCaptureDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", NULL));
   }
 
-  std::string Type() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Type", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Type() const;
 /** (Required) The subtype of content set that this dictionary describes:
  *     SPS     ("Spider page set") A page set
  *     SIS     ("Spider image set") An image set
@@ -547,13 +541,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required) The digital identifier of the content set (see "Digital Identifiers" on page
  *  664). If the content set has been located via the URLS name tree, this allows its related
  *  entry in the IDS name tree to be found.
@@ -562,13 +550,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", NULL));
   }
 
-  std::string ID() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "ID", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string ID() const;
 /** (Required) An array of indirect references to the objects belonging to the content set.
  *  The order of objects in the array is undefined in general, but may be restricted by spe-
  *  cific content set subtypes.
@@ -577,13 +559,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", NULL));
   }
 
-  SkPdfArray* O() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* O() const;
 /** (Required) A source information dictionary (see Section 9.9.4, "Source Information"),
  *  or an array of such dictionaries, describing the sources from which the objects belong-
  *  ing to the content set were created.
@@ -598,26 +574,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Dictionary;
   }
 
-  SkPdfDictionary* getSIAsDictionary() const {
-    SkPdfDictionary* ret = NULL;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* getSIAsDictionary() const;
   bool isSIAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getSIAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "SI", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getSIAsArray() const;
 /** (Optional) The content type, a string characterizing the source from which the objects
  *  belonging to the content set were created. The string should conform to the content
  *  type specification described in Internet RFC 2045, Multipurpose Internet Mail Exten-
@@ -629,26 +593,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CT", "", NULL));
   }
 
-  std::string CT() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "CT", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string CT() const;
 /** (Optional) A time stamp giving the date and time at which the content set was created.
 **/
   bool has_TS() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", NULL));
   }
 
-  SkPdfDate TS() const {
-    SkPdfDate ret;
-    if (DateFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TS", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return SkPdfDate();
-  }
-
+  SkPdfDate TS() const;
 };
 
 #endif  // __DEFINED__SkPdfWebCaptureDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureImageSetDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWebCaptureImageSetDictionary_autogen.cpp
new file mode 100644
index 0000000..db2c429
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureImageSetDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfWebCaptureImageSetDictionary_autogen.h"
+
+std::string SkPdfWebCaptureImageSetDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+long SkPdfWebCaptureImageSetDictionary::getRAsInteger() const {
+  long ret = 0;
+  if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfWebCaptureImageSetDictionary::getRAsArray() const {
+  SkPdfArray* ret = NULL;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureImageSetDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWebCaptureImageSetDictionary_autogen.h
index 287def7..ee23a8e 100644
--- a/experimental/PdfViewer/autogen/SkPdfWebCaptureImageSetDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureImageSetDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Required) The reference counts (see below) for the image XObjects belonging to the
  *  image set. For an image set containing a single XObject, the value is simply the integer
  *  reference count for that XObject. If the image set contains multiple XObjects, the value is
@@ -556,26 +550,14 @@
     return ret->podofo()->GetDataType() == ePdfDataType_Number;
   }
 
-  long getRAsInteger() const {
-    long ret = 0;
-    if (LongFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  long getRAsInteger() const;
   bool isRAArray() const {
     SkPdfObject* ret = NULL;
     if (!ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return false;
     return ret->podofo()->GetDataType() == ePdfDataType_Array;
   }
 
-  SkPdfArray* getRAsArray() const {
-    SkPdfArray* ret = NULL;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "R", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* getRAsArray() const;
 };
 
 #endif  // __DEFINED__SkPdfWebCaptureImageSetDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureInformationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWebCaptureInformationDictionary_autogen.cpp
new file mode 100644
index 0000000..dec583d
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureInformationDictionary_autogen.cpp
@@ -0,0 +1,16 @@
+#include "SkPdfWebCaptureInformationDictionary_autogen.h"
+
+double SkPdfWebCaptureInformationDictionary::V() const {
+  double ret;
+  if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return 0;
+}
+
+SkPdfArray* SkPdfWebCaptureInformationDictionary::C() const {
+  SkPdfArray* ret;
+  if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCaptureInformationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWebCaptureInformationDictionary_autogen.h
index d8593a0..c94f93f 100644
--- a/experimental/PdfViewer/autogen/SkPdfWebCaptureInformationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWebCaptureInformationDictionary_autogen.h
@@ -533,13 +533,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", NULL));
   }
 
-  double V() const {
-    double ret;
-    if (DoubleFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "V", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return 0;
-  }
-
+  double V() const;
 /** (Optional) An array of indirect references to Web Capture command dictionaries (see
  *  "Command Dictionaries" on page 672) describing commands that were used in building
  *  the PDF file. The commands appear in the array in the order in which they were executed
@@ -549,13 +543,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", NULL));
   }
 
-  SkPdfArray* C() const {
-    SkPdfArray* ret;
-    if (ArrayFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "C", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfArray* C() const;
 };
 
 #endif  // __DEFINED__SkPdfWebCaptureInformationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCapturePageSetDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWebCapturePageSetDictionary_autogen.cpp
new file mode 100644
index 0000000..ba6b144
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWebCapturePageSetDictionary_autogen.cpp
@@ -0,0 +1,23 @@
+#include "SkPdfWebCapturePageSetDictionary_autogen.h"
+
+std::string SkPdfWebCapturePageSetDictionary::S() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfWebCapturePageSetDictionary::T() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfWebCapturePageSetDictionary::TID() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TID", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWebCapturePageSetDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWebCapturePageSetDictionary_autogen.h
index 41c46d6..f5fc327 100644
--- a/experimental/PdfViewer/autogen/SkPdfWebCapturePageSetDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWebCapturePageSetDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", NULL));
   }
 
-  std::string S() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "S", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string S() const;
 /** (Optional) The title of the page set, a text string representing it in human-readable
  *  form.
 **/
@@ -546,13 +540,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", NULL));
   }
 
-  std::string T() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "T", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string T() const;
 /** (Optional) A text identifier generated from the text of the page set, as described in
  *  "Digital Identifiers" on page 664.
 **/
@@ -560,13 +548,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TID", "", NULL));
   }
 
-  std::string TID() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "TID", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string TID() const;
 };
 
 #endif  // __DEFINED__SkPdfWebCapturePageSetDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWidgetAnnotationDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWidgetAnnotationDictionary_autogen.cpp
new file mode 100644
index 0000000..db8bbed
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWidgetAnnotationDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfWidgetAnnotationDictionary_autogen.h"
+
+std::string SkPdfWidgetAnnotationDictionary::Subtype() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfWidgetAnnotationDictionary::Contents() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfWidgetAnnotationDictionary::H() const {
+  std::string ret;
+  if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+SkPdfDictionary* SkPdfWidgetAnnotationDictionary::MK() const {
+  SkPdfDictionary* ret;
+  if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MK", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return NULL;
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWidgetAnnotationDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWidgetAnnotationDictionary_autogen.h
index ebe48fc..0a4d360 100644
--- a/experimental/PdfViewer/autogen/SkPdfWidgetAnnotationDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWidgetAnnotationDictionary_autogen.h
@@ -532,13 +532,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", NULL));
   }
 
-  std::string Subtype() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Subtype", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Subtype() const;
 /** (Optional; PDF 1.4) An alternate representation of the annotation's contents in
  *  human-readable form, useful when extracting the document's contents in sup-
  *  port of accessibility to disabled users or for other purposes (see Section 9.8.2,
@@ -548,13 +542,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", NULL));
   }
 
-  std::string Contents() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "Contents", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string Contents() const;
 /** (Optional) The annotation's highlighting mode, the visual effect to be used when
  *  the mouse button is pressed or held down inside its active area:
  *     N    (None) No highlighting.
@@ -572,13 +560,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", NULL));
   }
 
-  std::string H() const {
-    std::string ret;
-    if (NameFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "H", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string H() const;
 /** (Optional) An appearance characteristics dictionary to be used in constructing a
  *  dynamic appearance stream specifying the annotation's visual presentation on
  *  the page; see "Variable Text" on page 533 for further discussion.
@@ -589,13 +571,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MK", "", NULL));
   }
 
-  SkPdfDictionary* MK() const {
-    SkPdfDictionary* ret;
-    if (DictionaryFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "MK", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return NULL;
-  }
-
+  SkPdfDictionary* MK() const;
 };
 
 #endif  // __DEFINED__SkPdfWidgetAnnotationDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfWindowsLaunchActionDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfWindowsLaunchActionDictionary_autogen.cpp
new file mode 100644
index 0000000..838e2be
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfWindowsLaunchActionDictionary_autogen.cpp
@@ -0,0 +1,30 @@
+#include "SkPdfWindowsLaunchActionDictionary_autogen.h"
+
+std::string SkPdfWindowsLaunchActionDictionary::F() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfWindowsLaunchActionDictionary::D() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfWindowsLaunchActionDictionary::O() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
+std::string SkPdfWindowsLaunchActionDictionary::P() const {
+  std::string ret;
+  if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
+  // TODO(edisonn): warn about missing required field, assert for known good pdfs
+  return "";
+}
+
diff --git a/experimental/PdfViewer/autogen/SkPdfWindowsLaunchActionDictionary_autogen.h b/experimental/PdfViewer/autogen/SkPdfWindowsLaunchActionDictionary_autogen.h
index c1bce3e..b3fe9e1 100644
--- a/experimental/PdfViewer/autogen/SkPdfWindowsLaunchActionDictionary_autogen.h
+++ b/experimental/PdfViewer/autogen/SkPdfWindowsLaunchActionDictionary_autogen.h
@@ -535,26 +535,14 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", NULL));
   }
 
-  std::string F() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "F", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string F() const;
 /** (Optional) A string specifying the default directory in standard DOS syntax.
 **/
   bool has_D() const {
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", NULL));
   }
 
-  std::string D() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "D", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string D() const;
 /** (Optional) A string specifying the operation to perform:
  *      open      Open a document.
  *      print     Print a document.
@@ -565,13 +553,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", NULL));
   }
 
-  std::string O() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "O", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string O() const;
 /** (Optional) A parameter string to be passed to the application designated by
  *  the F entry. This entry should be omitted if F designates a document.
 **/
@@ -579,13 +561,7 @@
     return (ObjectFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", NULL));
   }
 
-  std::string P() const {
-    std::string ret;
-    if (StringFromDictionary(fPodofoDoc, fPodofoObj->GetDictionary(), "P", "", &ret)) return ret;
-    // TODO(edisonn): warn about missing required field, assert for known good pdfs
-    return "";
-  }
-
+  std::string P() const;
 };
 
 #endif  // __DEFINED__SkPdfWindowsLaunchActionDictionary
diff --git a/experimental/PdfViewer/autogen/SkPdfXObjectDictionary_autogen.cpp b/experimental/PdfViewer/autogen/SkPdfXObjectDictionary_autogen.cpp
new file mode 100644
index 0000000..ef58c4f
--- /dev/null
+++ b/experimental/PdfViewer/autogen/SkPdfXObjectDictionary_autogen.cpp
@@ -0,0 +1,2 @@
+#include "SkPdfXObjectDictionary_autogen.h"
+
diff --git a/experimental/PdfViewer/autogen/pdfspec_autogen.py b/experimental/PdfViewer/autogen/pdfspec_autogen.py
index 9e1dbd9..f43c848 100644
--- a/experimental/PdfViewer/autogen/pdfspec_autogen.py
+++ b/experimental/PdfViewer/autogen/pdfspec_autogen.py
@@ -5412,168 +5412,168 @@
 
 
 def addDictionaryTypesTo(knowTypes):
-  knowTypes['GoToActionDictionary'] = ['SkPdfGoToActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['SoundObjectDictionary'] = ['SkPdfSoundObjectDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['LaunchActionDictionary'] = ['SkPdfLaunchActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['RemoteGoToActionDictionary'] = ['SkPdfRemoteGoToActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['PageObjectActionsDictionary'] = ['SkPdfPageObjectActionsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['AnnotationActionsDictionary'] = ['SkPdfAnnotationActionsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['DocumentCatalogActionsDictionary'] = ['SkPdfDocumentCatalogActionsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FormFieldActionsDictionary'] = ['SkPdfFormFieldActionsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['JavascriptDictionary'] = ['SkPdfJavascriptDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['EncryptedEmbeddedFileStreamDictionary'] = ['SkPdfEncryptedEmbeddedFileStreamDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['IconFitDictionary'] = ['SkPdfIconFitDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FDFFieldDictionary'] = ['SkPdfFDFFieldDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ThreadActionDictionary'] = ['SkPdfThreadActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['WindowsLaunchActionDictionary'] = ['SkPdfWindowsLaunchActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FileAttachmentAnnotationDictionary'] = ['SkPdfFileAttachmentAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FDFNamedPageReferenceDictionary'] = ['SkPdfFDFNamedPageReferenceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FileTrailerDictionary'] = ['SkPdfFileTrailerDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['EncryptionCommonDictionary'] = ['SkPdfEncryptionCommonDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Jbig2DecodeFilterDictionary'] = ['SkPdfJbig2DecodeFilterDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['DctdecodeFilterDictionary'] = ['SkPdfDctdecodeFilterDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['CatalogDictionary'] = ['SkPdfCatalogDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['PageTreeNodeDictionary'] = ['SkPdfPageTreeNodeDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['StandardSecurityHandlerDictionary'] = ['SkPdfStandardSecurityHandlerDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['PageObjectDictionary'] = ['SkPdfPageObjectDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['NameDictionary'] = ['SkPdfNameDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['VariableTextFieldDictionary'] = ['SkPdfVariableTextFieldDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ObjectReferenceDictionary'] = ['SkPdfObjectReferenceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['TrapNetworkAppearanceStreamDictionary'] = ['SkPdfTrapNetworkAppearanceStreamDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ImageDictionary'] = ['SkPdfImageDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['OpiVersionDictionary'] = ['SkPdfOpiVersionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type1FontDictionary'] = ['SkPdfType1FontDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type3FontDictionary'] = ['SkPdfType3FontDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['EncodingDictionary'] = ['SkPdfEncodingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['CIDSystemInfoDictionary'] = ['SkPdfCIDSystemInfoDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['CIDFontDictionary'] = ['SkPdfCIDFontDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['CMapDictionary'] = ['SkPdfCMapDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type0FontDictionary'] = ['SkPdfType0FontDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FontDescriptorDictionary'] = ['SkPdfFontDescriptorDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ResetFormActionDictionary'] = ['SkPdfResetFormActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FDFPageDictionary'] = ['SkPdfFDFPageDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ChoiceFieldDictionary'] = ['SkPdfChoiceFieldDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['StructureElementAccessDictionary'] = ['SkPdfStructureElementAccessDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['CalgrayColorSpaceDictionary'] = ['SkPdfCalgrayColorSpaceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['WebCaptureCommandDictionary'] = ['SkPdfWebCaptureCommandDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['IccProfileStreamDictionary'] = ['SkPdfIccProfileStreamDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['LabColorSpaceDictionary'] = ['SkPdfLabColorSpaceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['CalrgbColorSpaceDictionary'] = ['SkPdfCalrgbColorSpaceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['HideActionDictionary'] = ['SkPdfHideActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FDFTemplateDictionary'] = ['SkPdfFDFTemplateDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['NamedActionsDictionary'] = ['SkPdfNamedActionsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['InteractiveFormDictionary'] = ['SkPdfInteractiveFormDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['URIActionDictionary'] = ['SkPdfURIActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['URIDictionary'] = ['SkPdfURIDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['SoundActionDictionary'] = ['SkPdfSoundActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['MovieActionDictionary'] = ['SkPdfMovieActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['SourceInformationDictionary'] = ['SkPdfSourceInformationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FDFFileAnnotationDictionary'] = ['SkPdfFDFFileAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['TransitionDictionary'] = ['SkPdfTransitionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['BeadDictionary'] = ['SkPdfBeadDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ThreadDictionary'] = ['SkPdfThreadDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['PageLabelDictionary'] = ['SkPdfPageLabelDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['OutlineItemDictionary'] = ['SkPdfOutlineItemDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['OutlineDictionary'] = ['SkPdfOutlineDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ViewerPreferencesDictionary'] = ['SkPdfViewerPreferencesDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['MarkInformationDictionary'] = ['SkPdfMarkInformationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['URLAliasDictionary'] = ['SkPdfURLAliasDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['WebCaptureDictionary'] = ['SkPdfWebCaptureDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['AttributeObjectDictionary'] = ['SkPdfAttributeObjectDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ArtifactsDictionary'] = ['SkPdfArtifactsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['WebCaptureInformationDictionary'] = ['SkPdfWebCaptureInformationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['TrapNetworkAnnotationDictionary'] = ['SkPdfTrapNetworkAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type1FormDictionary'] = ['SkPdfType1FormDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['GroupAttributesDictionary'] = ['SkPdfGroupAttributesDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ReferenceDictionary'] = ['SkPdfReferenceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['PSXobjectDictionary'] = ['SkPdfPSXobjectDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['BoxStyleDictionary'] = ['SkPdfBoxStyleDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['BoxColorInformationDictionary'] = ['SkPdfBoxColorInformationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['WebCaptureCommandSettingsDictionary'] = ['SkPdfWebCaptureCommandSettingsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['InlineLevelStructureElementsDictionary'] = ['SkPdfInlineLevelStructureElementsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['AppearanceCharacteristicsDictionary'] = ['SkPdfAppearanceCharacteristicsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type3ShadingDictionary'] = ['SkPdfType3ShadingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type4ShadingDictionary'] = ['SkPdfType4ShadingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['TextFieldDictionary'] = ['SkPdfTextFieldDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['RadioButtonFieldDictionary'] = ['SkPdfRadioButtonFieldDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['CheckboxFieldDictionary'] = ['SkPdfCheckboxFieldDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type1PatternDictionary'] = ['SkPdfType1PatternDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type2PatternDictionary'] = ['SkPdfType2PatternDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['DeviceNColorSpaceDictionary'] = ['SkPdfDeviceNColorSpaceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type1ShadingDictionary'] = ['SkPdfType1ShadingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type2ShadingDictionary'] = ['SkPdfType2ShadingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['StandardStructureDictionary'] = ['SkPdfStandardStructureDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ShadingDictionary'] = ['SkPdfShadingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['EmbeddedFileParameterDictionary'] = ['SkPdfEmbeddedFileParameterDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['MacOsFileInformationDictionary'] = ['SkPdfMacOsFileInformationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['WebCaptureImageSetDictionary'] = ['SkPdfWebCaptureImageSetDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['GraphicsStateDictionary'] = ['SkPdfGraphicsStateDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FileSpecificationDictionary'] = ['SkPdfFileSpecificationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['EmbeddedFileStreamDictionary'] = ['SkPdfEmbeddedFileStreamDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['MovieDictionary'] = ['SkPdfMovieDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FieldDictionary'] = ['SkPdfFieldDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['MovieActivationDictionary'] = ['SkPdfMovieActivationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['TableAttributesDictionary'] = ['SkPdfTableAttributesDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ListAttributeDictionary'] = ['SkPdfListAttributeDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['SeparationDictionary'] = ['SkPdfSeparationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['BlockLevelStructureElementsDictionary'] = ['SkPdfBlockLevelStructureElementsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FDFCatalogDictionary'] = ['SkPdfFDFCatalogDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type1HalftoneDictionary'] = ['SkPdfType1HalftoneDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type10HalftoneDictionary'] = ['SkPdfType10HalftoneDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type6HalftoneDictionary'] = ['SkPdfType6HalftoneDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type5HalftoneDictionary'] = ['SkPdfType5HalftoneDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type16HalftoneDictionary'] = ['SkPdfType16HalftoneDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type6ShadingDictionary'] = ['SkPdfType6ShadingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['StreamCommonDictionary'] = ['SkPdfStreamCommonDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FDFDictionary'] = ['SkPdfFDFDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['LzwdecodeAndFlatedecodeFiltersDictionary'] = ['SkPdfLzwdecodeAndFlatedecodeFiltersDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['CcittfaxdecodeFilterDictionary'] = ['SkPdfCcittfaxdecodeFilterDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['MarkedContentReferenceDictionary'] = ['SkPdfMarkedContentReferenceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['SignatureDictionary'] = ['SkPdfSignatureDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['SoundAnnotationDictionary'] = ['SkPdfSoundAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['MovieAnnotationDictionary'] = ['SkPdfMovieAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type3FunctionDictionary'] = ['SkPdfType3FunctionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type2FunctionDictionary'] = ['SkPdfType2FunctionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['RubberStampAnnotationDictionary'] = ['SkPdfRubberStampAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['InkAnnotationDictionary'] = ['SkPdfInkAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['SquareOrCircleAnnotation'] = ['SkPdfSquareOrCircleAnnotation*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['MarkupAnnotationsDictionary'] = ['SkPdfMarkupAnnotationsDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['NameTreeNodeDictionary'] = ['SkPdfNameTreeNodeDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type5ShadingDictionary'] = ['SkPdfType5ShadingDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ResourceDictionary'] = ['SkPdfResourceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['SubmitFormActionDictionary'] = ['SkPdfSubmitFormActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['Type0FunctionDictionary'] = ['SkPdfType0FunctionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FunctionCommonDictionary'] = ['SkPdfFunctionCommonDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['NumberTreeNodeDictionary'] = ['SkPdfNumberTreeNodeDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ActionDictionary'] = ['SkPdfActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['WidgetAnnotationDictionary'] = ['SkPdfWidgetAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['StructureTreeRootDictionary'] = ['SkPdfStructureTreeRootDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['JavascriptActionDictionary'] = ['SkPdfJavascriptActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['AlternateImageDictionary'] = ['SkPdfAlternateImageDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['PDF_XOutputIntentDictionary'] = ['SkPdfPDF_XOutputIntentDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['DocumentInformationDictionary'] = ['SkPdfDocumentInformationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['MetadataStreamDictionary'] = ['SkPdfMetadataStreamDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ImportDataActionDictionary'] = ['SkPdfImportDataActionDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['PagePieceDictionary'] = ['SkPdfPagePieceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ApplicationDataDictionary'] = ['SkPdfApplicationDataDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ComponentsWithMetadataDictionary'] = ['SkPdfComponentsWithMetadataDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['PrinterMarkFormDictionary'] = ['SkPdfPrinterMarkFormDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['StructureElementDictionary'] = ['SkPdfStructureElementDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['PrinterMarkAnnotationDictionary'] = ['SkPdfPrinterMarkAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['SoftMaskImageDictionary'] = ['SkPdfSoftMaskImageDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['TransparencyGroupDictionary'] = ['SkPdfTransparencyGroupDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['SoftMaskDictionary'] = ['SkPdfSoftMaskDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['BorderStyleDictionary'] = ['SkPdfBorderStyleDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['PopUpAnnotationDictionary'] = ['SkPdfPopUpAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FDFTrailerDictionary'] = ['SkPdfFDFTrailerDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['LineAnnotationDictionary'] = ['SkPdfLineAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['FreeTextAnnotationDictionary'] = ['SkPdfFreeTextAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['ALinkAnnotationDictionary'] = ['SkPdfALinkAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['TextAnnotationDictionary'] = ['SkPdfTextAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['WebCapturePageSetDictionary'] = ['SkPdfWebCapturePageSetDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['AppearanceDictionary'] = ['SkPdfAppearanceDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['CIDFontDescriptorDictionary'] = ['SkPdfCIDFontDescriptorDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['EmbeddedFontStreamDictionary'] = ['SkPdfEmbeddedFontStreamDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
-  knowTypes['AnnotationDictionary'] = ['SkPdfAnnotationDictionary*', 'DictionaryFromDictionary2', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['GoToActionDictionary'] = ['SkPdfGoToActionDictionary*', 'GoToActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['SoundObjectDictionary'] = ['SkPdfSoundObjectDictionary*', 'SoundObjectDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['LaunchActionDictionary'] = ['SkPdfLaunchActionDictionary*', 'LaunchActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['RemoteGoToActionDictionary'] = ['SkPdfRemoteGoToActionDictionary*', 'RemoteGoToActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['PageObjectActionsDictionary'] = ['SkPdfPageObjectActionsDictionary*', 'PageObjectActionsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['AnnotationActionsDictionary'] = ['SkPdfAnnotationActionsDictionary*', 'AnnotationActionsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['DocumentCatalogActionsDictionary'] = ['SkPdfDocumentCatalogActionsDictionary*', 'DocumentCatalogActionsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FormFieldActionsDictionary'] = ['SkPdfFormFieldActionsDictionary*', 'FormFieldActionsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['JavascriptDictionary'] = ['SkPdfJavascriptDictionary*', 'JavascriptDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['EncryptedEmbeddedFileStreamDictionary'] = ['SkPdfEncryptedEmbeddedFileStreamDictionary*', 'EncryptedEmbeddedFileStreamDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['IconFitDictionary'] = ['SkPdfIconFitDictionary*', 'IconFitDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FDFFieldDictionary'] = ['SkPdfFDFFieldDictionary*', 'FDFFieldDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ThreadActionDictionary'] = ['SkPdfThreadActionDictionary*', 'ThreadActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['WindowsLaunchActionDictionary'] = ['SkPdfWindowsLaunchActionDictionary*', 'WindowsLaunchActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FileAttachmentAnnotationDictionary'] = ['SkPdfFileAttachmentAnnotationDictionary*', 'FileAttachmentAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FDFNamedPageReferenceDictionary'] = ['SkPdfFDFNamedPageReferenceDictionary*', 'FDFNamedPageReferenceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FileTrailerDictionary'] = ['SkPdfFileTrailerDictionary*', 'FileTrailerDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['EncryptionCommonDictionary'] = ['SkPdfEncryptionCommonDictionary*', 'EncryptionCommonDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Jbig2DecodeFilterDictionary'] = ['SkPdfJbig2DecodeFilterDictionary*', 'Jbig2DecodeFilterDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['DctdecodeFilterDictionary'] = ['SkPdfDctdecodeFilterDictionary*', 'DctdecodeFilterDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['CatalogDictionary'] = ['SkPdfCatalogDictionary*', 'CatalogDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['PageTreeNodeDictionary'] = ['SkPdfPageTreeNodeDictionary*', 'PageTreeNodeDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['StandardSecurityHandlerDictionary'] = ['SkPdfStandardSecurityHandlerDictionary*', 'StandardSecurityHandlerDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['PageObjectDictionary'] = ['SkPdfPageObjectDictionary*', 'PageObjectDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['NameDictionary'] = ['SkPdfNameDictionary*', 'NameDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['VariableTextFieldDictionary'] = ['SkPdfVariableTextFieldDictionary*', 'VariableTextFieldDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ObjectReferenceDictionary'] = ['SkPdfObjectReferenceDictionary*', 'ObjectReferenceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['TrapNetworkAppearanceStreamDictionary'] = ['SkPdfTrapNetworkAppearanceStreamDictionary*', 'TrapNetworkAppearanceStreamDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ImageDictionary'] = ['SkPdfImageDictionary*', 'ImageDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['OpiVersionDictionary'] = ['SkPdfOpiVersionDictionary*', 'OpiVersionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type1FontDictionary'] = ['SkPdfType1FontDictionary*', 'Type1FontDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type3FontDictionary'] = ['SkPdfType3FontDictionary*', 'Type3FontDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['EncodingDictionary'] = ['SkPdfEncodingDictionary*', 'EncodingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['CIDSystemInfoDictionary'] = ['SkPdfCIDSystemInfoDictionary*', 'CIDSystemInfoDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['CIDFontDictionary'] = ['SkPdfCIDFontDictionary*', 'CIDFontDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['CMapDictionary'] = ['SkPdfCMapDictionary*', 'CMapDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type0FontDictionary'] = ['SkPdfType0FontDictionary*', 'Type0FontDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FontDescriptorDictionary'] = ['SkPdfFontDescriptorDictionary*', 'FontDescriptorDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ResetFormActionDictionary'] = ['SkPdfResetFormActionDictionary*', 'ResetFormActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FDFPageDictionary'] = ['SkPdfFDFPageDictionary*', 'FDFPageDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ChoiceFieldDictionary'] = ['SkPdfChoiceFieldDictionary*', 'ChoiceFieldDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['StructureElementAccessDictionary'] = ['SkPdfStructureElementAccessDictionary*', 'StructureElementAccessDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['CalgrayColorSpaceDictionary'] = ['SkPdfCalgrayColorSpaceDictionary*', 'CalgrayColorSpaceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['WebCaptureCommandDictionary'] = ['SkPdfWebCaptureCommandDictionary*', 'WebCaptureCommandDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['IccProfileStreamDictionary'] = ['SkPdfIccProfileStreamDictionary*', 'IccProfileStreamDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['LabColorSpaceDictionary'] = ['SkPdfLabColorSpaceDictionary*', 'LabColorSpaceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['CalrgbColorSpaceDictionary'] = ['SkPdfCalrgbColorSpaceDictionary*', 'CalrgbColorSpaceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['HideActionDictionary'] = ['SkPdfHideActionDictionary*', 'HideActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FDFTemplateDictionary'] = ['SkPdfFDFTemplateDictionary*', 'FDFTemplateDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['NamedActionsDictionary'] = ['SkPdfNamedActionsDictionary*', 'NamedActionsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['InteractiveFormDictionary'] = ['SkPdfInteractiveFormDictionary*', 'InteractiveFormDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['URIActionDictionary'] = ['SkPdfURIActionDictionary*', 'URIActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['URIDictionary'] = ['SkPdfURIDictionary*', 'URIDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['SoundActionDictionary'] = ['SkPdfSoundActionDictionary*', 'SoundActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['MovieActionDictionary'] = ['SkPdfMovieActionDictionary*', 'MovieActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['SourceInformationDictionary'] = ['SkPdfSourceInformationDictionary*', 'SourceInformationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FDFFileAnnotationDictionary'] = ['SkPdfFDFFileAnnotationDictionary*', 'FDFFileAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['TransitionDictionary'] = ['SkPdfTransitionDictionary*', 'TransitionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['BeadDictionary'] = ['SkPdfBeadDictionary*', 'BeadDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ThreadDictionary'] = ['SkPdfThreadDictionary*', 'ThreadDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['PageLabelDictionary'] = ['SkPdfPageLabelDictionary*', 'PageLabelDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['OutlineItemDictionary'] = ['SkPdfOutlineItemDictionary*', 'OutlineItemDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['OutlineDictionary'] = ['SkPdfOutlineDictionary*', 'OutlineDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ViewerPreferencesDictionary'] = ['SkPdfViewerPreferencesDictionary*', 'ViewerPreferencesDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['MarkInformationDictionary'] = ['SkPdfMarkInformationDictionary*', 'MarkInformationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['URLAliasDictionary'] = ['SkPdfURLAliasDictionary*', 'URLAliasDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['WebCaptureDictionary'] = ['SkPdfWebCaptureDictionary*', 'WebCaptureDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['AttributeObjectDictionary'] = ['SkPdfAttributeObjectDictionary*', 'AttributeObjectDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ArtifactsDictionary'] = ['SkPdfArtifactsDictionary*', 'ArtifactsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['WebCaptureInformationDictionary'] = ['SkPdfWebCaptureInformationDictionary*', 'WebCaptureInformationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['TrapNetworkAnnotationDictionary'] = ['SkPdfTrapNetworkAnnotationDictionary*', 'TrapNetworkAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type1FormDictionary'] = ['SkPdfType1FormDictionary*', 'Type1FormDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['GroupAttributesDictionary'] = ['SkPdfGroupAttributesDictionary*', 'GroupAttributesDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ReferenceDictionary'] = ['SkPdfReferenceDictionary*', 'ReferenceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['PSXobjectDictionary'] = ['SkPdfPSXobjectDictionary*', 'PSXobjectDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['BoxStyleDictionary'] = ['SkPdfBoxStyleDictionary*', 'BoxStyleDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['BoxColorInformationDictionary'] = ['SkPdfBoxColorInformationDictionary*', 'BoxColorInformationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['WebCaptureCommandSettingsDictionary'] = ['SkPdfWebCaptureCommandSettingsDictionary*', 'WebCaptureCommandSettingsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['InlineLevelStructureElementsDictionary'] = ['SkPdfInlineLevelStructureElementsDictionary*', 'InlineLevelStructureElementsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['AppearanceCharacteristicsDictionary'] = ['SkPdfAppearanceCharacteristicsDictionary*', 'AppearanceCharacteristicsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type3ShadingDictionary'] = ['SkPdfType3ShadingDictionary*', 'Type3ShadingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type4ShadingDictionary'] = ['SkPdfType4ShadingDictionary*', 'Type4ShadingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['TextFieldDictionary'] = ['SkPdfTextFieldDictionary*', 'TextFieldDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['RadioButtonFieldDictionary'] = ['SkPdfRadioButtonFieldDictionary*', 'RadioButtonFieldDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['CheckboxFieldDictionary'] = ['SkPdfCheckboxFieldDictionary*', 'CheckboxFieldDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type1PatternDictionary'] = ['SkPdfType1PatternDictionary*', 'Type1PatternDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type2PatternDictionary'] = ['SkPdfType2PatternDictionary*', 'Type2PatternDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['DeviceNColorSpaceDictionary'] = ['SkPdfDeviceNColorSpaceDictionary*', 'DeviceNColorSpaceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type1ShadingDictionary'] = ['SkPdfType1ShadingDictionary*', 'Type1ShadingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type2ShadingDictionary'] = ['SkPdfType2ShadingDictionary*', 'Type2ShadingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['StandardStructureDictionary'] = ['SkPdfStandardStructureDictionary*', 'StandardStructureDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ShadingDictionary'] = ['SkPdfShadingDictionary*', 'ShadingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['EmbeddedFileParameterDictionary'] = ['SkPdfEmbeddedFileParameterDictionary*', 'EmbeddedFileParameterDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['MacOsFileInformationDictionary'] = ['SkPdfMacOsFileInformationDictionary*', 'MacOsFileInformationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['WebCaptureImageSetDictionary'] = ['SkPdfWebCaptureImageSetDictionary*', 'WebCaptureImageSetDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['GraphicsStateDictionary'] = ['SkPdfGraphicsStateDictionary*', 'GraphicsStateDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FileSpecificationDictionary'] = ['SkPdfFileSpecificationDictionary*', 'FileSpecificationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['EmbeddedFileStreamDictionary'] = ['SkPdfEmbeddedFileStreamDictionary*', 'EmbeddedFileStreamDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['MovieDictionary'] = ['SkPdfMovieDictionary*', 'MovieDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FieldDictionary'] = ['SkPdfFieldDictionary*', 'FieldDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['MovieActivationDictionary'] = ['SkPdfMovieActivationDictionary*', 'MovieActivationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['TableAttributesDictionary'] = ['SkPdfTableAttributesDictionary*', 'TableAttributesDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ListAttributeDictionary'] = ['SkPdfListAttributeDictionary*', 'ListAttributeDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['SeparationDictionary'] = ['SkPdfSeparationDictionary*', 'SeparationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['BlockLevelStructureElementsDictionary'] = ['SkPdfBlockLevelStructureElementsDictionary*', 'BlockLevelStructureElementsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FDFCatalogDictionary'] = ['SkPdfFDFCatalogDictionary*', 'FDFCatalogDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type1HalftoneDictionary'] = ['SkPdfType1HalftoneDictionary*', 'Type1HalftoneDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type10HalftoneDictionary'] = ['SkPdfType10HalftoneDictionary*', 'Type10HalftoneDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type6HalftoneDictionary'] = ['SkPdfType6HalftoneDictionary*', 'Type6HalftoneDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type5HalftoneDictionary'] = ['SkPdfType5HalftoneDictionary*', 'Type5HalftoneDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type16HalftoneDictionary'] = ['SkPdfType16HalftoneDictionary*', 'Type16HalftoneDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type6ShadingDictionary'] = ['SkPdfType6ShadingDictionary*', 'Type6ShadingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['StreamCommonDictionary'] = ['SkPdfStreamCommonDictionary*', 'StreamCommonDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FDFDictionary'] = ['SkPdfFDFDictionary*', 'FDFDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['LzwdecodeAndFlatedecodeFiltersDictionary'] = ['SkPdfLzwdecodeAndFlatedecodeFiltersDictionary*', 'LzwdecodeAndFlatedecodeFiltersDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['CcittfaxdecodeFilterDictionary'] = ['SkPdfCcittfaxdecodeFilterDictionary*', 'CcittfaxdecodeFilterDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['MarkedContentReferenceDictionary'] = ['SkPdfMarkedContentReferenceDictionary*', 'MarkedContentReferenceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['SignatureDictionary'] = ['SkPdfSignatureDictionary*', 'SignatureDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['SoundAnnotationDictionary'] = ['SkPdfSoundAnnotationDictionary*', 'SoundAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['MovieAnnotationDictionary'] = ['SkPdfMovieAnnotationDictionary*', 'MovieAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type3FunctionDictionary'] = ['SkPdfType3FunctionDictionary*', 'Type3FunctionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type2FunctionDictionary'] = ['SkPdfType2FunctionDictionary*', 'Type2FunctionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['RubberStampAnnotationDictionary'] = ['SkPdfRubberStampAnnotationDictionary*', 'RubberStampAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['InkAnnotationDictionary'] = ['SkPdfInkAnnotationDictionary*', 'InkAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['SquareOrCircleAnnotation'] = ['SkPdfSquareOrCircleAnnotation*', 'SquareOrCircleAnnotationFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['MarkupAnnotationsDictionary'] = ['SkPdfMarkupAnnotationsDictionary*', 'MarkupAnnotationsDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['NameTreeNodeDictionary'] = ['SkPdfNameTreeNodeDictionary*', 'NameTreeNodeDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type5ShadingDictionary'] = ['SkPdfType5ShadingDictionary*', 'Type5ShadingDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ResourceDictionary'] = ['SkPdfResourceDictionary*', 'ResourceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['SubmitFormActionDictionary'] = ['SkPdfSubmitFormActionDictionary*', 'SubmitFormActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['Type0FunctionDictionary'] = ['SkPdfType0FunctionDictionary*', 'Type0FunctionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FunctionCommonDictionary'] = ['SkPdfFunctionCommonDictionary*', 'FunctionCommonDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['NumberTreeNodeDictionary'] = ['SkPdfNumberTreeNodeDictionary*', 'NumberTreeNodeDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ActionDictionary'] = ['SkPdfActionDictionary*', 'ActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['WidgetAnnotationDictionary'] = ['SkPdfWidgetAnnotationDictionary*', 'WidgetAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['StructureTreeRootDictionary'] = ['SkPdfStructureTreeRootDictionary*', 'StructureTreeRootDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['JavascriptActionDictionary'] = ['SkPdfJavascriptActionDictionary*', 'JavascriptActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['AlternateImageDictionary'] = ['SkPdfAlternateImageDictionary*', 'AlternateImageDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['PDF_XOutputIntentDictionary'] = ['SkPdfPDF_XOutputIntentDictionary*', 'PDF_XOutputIntentDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['DocumentInformationDictionary'] = ['SkPdfDocumentInformationDictionary*', 'DocumentInformationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['MetadataStreamDictionary'] = ['SkPdfMetadataStreamDictionary*', 'MetadataStreamDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ImportDataActionDictionary'] = ['SkPdfImportDataActionDictionary*', 'ImportDataActionDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['PagePieceDictionary'] = ['SkPdfPagePieceDictionary*', 'PagePieceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ApplicationDataDictionary'] = ['SkPdfApplicationDataDictionary*', 'ApplicationDataDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ComponentsWithMetadataDictionary'] = ['SkPdfComponentsWithMetadataDictionary*', 'ComponentsWithMetadataDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['PrinterMarkFormDictionary'] = ['SkPdfPrinterMarkFormDictionary*', 'PrinterMarkFormDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['StructureElementDictionary'] = ['SkPdfStructureElementDictionary*', 'StructureElementDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['PrinterMarkAnnotationDictionary'] = ['SkPdfPrinterMarkAnnotationDictionary*', 'PrinterMarkAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['SoftMaskImageDictionary'] = ['SkPdfSoftMaskImageDictionary*', 'SoftMaskImageDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['TransparencyGroupDictionary'] = ['SkPdfTransparencyGroupDictionary*', 'TransparencyGroupDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['SoftMaskDictionary'] = ['SkPdfSoftMaskDictionary*', 'SoftMaskDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['BorderStyleDictionary'] = ['SkPdfBorderStyleDictionary*', 'BorderStyleDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['PopUpAnnotationDictionary'] = ['SkPdfPopUpAnnotationDictionary*', 'PopUpAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FDFTrailerDictionary'] = ['SkPdfFDFTrailerDictionary*', 'FDFTrailerDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['LineAnnotationDictionary'] = ['SkPdfLineAnnotationDictionary*', 'LineAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['FreeTextAnnotationDictionary'] = ['SkPdfFreeTextAnnotationDictionary*', 'FreeTextAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['ALinkAnnotationDictionary'] = ['SkPdfALinkAnnotationDictionary*', 'ALinkAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['TextAnnotationDictionary'] = ['SkPdfTextAnnotationDictionary*', 'TextAnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['WebCapturePageSetDictionary'] = ['SkPdfWebCapturePageSetDictionary*', 'WebCapturePageSetDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['AppearanceDictionary'] = ['SkPdfAppearanceDictionary*', 'AppearanceDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['CIDFontDescriptorDictionary'] = ['SkPdfCIDFontDescriptorDictionary*', 'CIDFontDescriptorDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['EmbeddedFontStreamDictionary'] = ['SkPdfEmbeddedFontStreamDictionary*', 'EmbeddedFontStreamDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
+  knowTypes['AnnotationDictionary'] = ['SkPdfAnnotationDictionary*', 'AnnotationDictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary']
 
 
diff --git a/experimental/PdfViewer/generate_code.py b/experimental/PdfViewer/generate_code.py
index 02736d3..0028cf3 100644
--- a/experimental/PdfViewer/generate_code.py
+++ b/experimental/PdfViewer/generate_code.py
@@ -233,6 +233,7 @@
   
   def write(self):
     global fileHeaders 
+    global fileHeadersCpp 
     global knowTypes
   
     # generate enum
@@ -246,6 +247,7 @@
       cls.fEnumEnd = 'k' + name + '__End_SkPdfObjectType'
 
       fileHeaders.write('#include "SkPdf' + cls.fName + '_autogen.h"\n')
+      fileHeadersCpp.write('#include "SkPdf' + cls.fName + '_autogen.cpp"\n')
             
       if cls.fBase != '':
         self.fClasses[cls.fBase].fEnumSubclasses.append(cls.fEnum)
@@ -286,10 +288,12 @@
       enum = cls.fEnum
       
       fileClass = open('SkPdf' + cls.fName + '_autogen.h', 'w')
+      fileClassCpp = open('SkPdf' + cls.fName + '_autogen.cpp', 'w')
       fileClass.write('#ifndef __DEFINED__SkPdf' + cls.fName + '\n')
       fileClass.write('#define __DEFINED__SkPdf' + cls.fName + '\n')
       fileClass.write('\n')
 
+      fileClassCpp.write('#include "SkPdf' + cls.fName + '_autogen.h"\n\n')
       fileClass.write('#include "SkPdfUtils.h"\n')
       fileClass.write('#include "SkPdfEnums_autogen.h"\n')
       fileClass.write('#include "SkPdfArray_autogen.h"\n')
@@ -363,6 +367,7 @@
           
           if prop.fCppName[0] == '[':
             fileClass.write('/*\n')  # comment code of the atributes that can have any name
+            fileClassCpp.write('/*\n')  # comment code of the atributes that can have any name
           
           # TODO(edisonn): has_foo();  
           fileClass.write('  bool has_' + prop.fCppName + '() const {\n')
@@ -372,16 +377,17 @@
 
           if len(prop.fTypes.split()) == 1:
             t = prop.fTypes.strip()
-            fileClass.write('  ' + knowTypes[t][0] + ' ' + prop.fCppName + '() const {\n')
-            fileClass.write('    ' + knowTypes[t][0] + ' ret;\n')
-            fileClass.write('    if (' + knowTypes[t][1] + '(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret)) return ret;\n')
+            fileClass.write('  ' + knowTypes[t][0] + ' ' + prop.fCppName + '() const;\n')
+            fileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName + '::' + prop.fCppName + '() const {\n')
+            fileClassCpp.write('  ' + knowTypes[t][0] + ' ret;\n')
+            fileClassCpp.write('  if (' + knowTypes[t][1] + '(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret)) return ret;\n')
             if field.fRequired == False and prop.fDefault != '':
-              fileClass.write('    return ' + prop.fDefault.toCpp() + ';\n');
+              fileClassCpp.write('  return ' + prop.fDefault.toCpp() + ';\n');
             else:
-              fileClass.write('    // TODO(edisonn): warn about missing required field, assert for known good pdfs\n')
-              fileClass.write('    return ' + knowTypes[t][2].toCpp() + ';\n');
-            fileClass.write('  }\n') 
-            fileClass.write('\n')
+              fileClassCpp.write('  // TODO(edisonn): warn about missing required field, assert for known good pdfs\n')
+              fileClassCpp.write('  return ' + knowTypes[t][2].toCpp() + ';\n');
+            fileClassCpp.write('}\n') 
+            fileClassCpp.write('\n')
           else:
             for type in prop.fTypes.split():
               t = type.strip()
@@ -392,17 +398,19 @@
               fileClass.write('  }\n')
               fileClass.write('\n')
 
-              fileClass.write('  ' + knowTypes[t][0] + ' get' + prop.fCppName + 'As' + t.title() + '() const {\n')
-              fileClass.write('    ' + knowTypes[t][0] + ' ret = ' + knowTypes[t][2].toCpp() + ';\n')
-              fileClass.write('    if (' + knowTypes[t][1] + '(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret)) return ret;\n')
-              fileClass.write('    // TODO(edisonn): warn about missing required field, assert for known good pdfs\n')
-              fileClass.write('    return ' + knowTypes[t][2].toCpp() + ';\n')
-              fileClass.write('  }\n') 
-              fileClass.write('\n')
+              fileClass.write('  ' + knowTypes[t][0] + ' get' + prop.fCppName + 'As' + t.title() + '() const;\n')
+              fileClassCpp.write('' + knowTypes[t][0] + ' SkPdf' + cls.fName + '::get' + prop.fCppName + 'As' + t.title() + '() const {\n')
+              fileClassCpp.write('  ' + knowTypes[t][0] + ' ret = ' + knowTypes[t][2].toCpp() + ';\n')
+              fileClassCpp.write('  if (' + knowTypes[t][1] + '(fPodofoDoc, fPodofoObj->GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &ret)) return ret;\n')
+              fileClassCpp.write('  // TODO(edisonn): warn about missing required field, assert for known good pdfs\n')
+              fileClassCpp.write('  return ' + knowTypes[t][2].toCpp() + ';\n')
+              fileClassCpp.write('}\n') 
+              fileClassCpp.write('\n')
                
            
           if prop.fCppName[0] == '[':
             fileClass.write('*/\n')  # comment code of the atributes that can have any name
+            fileClassCpp.write('*/\n')  # comment code of the atributes that can have any name
          
 
       fileClass.write('};\n')
@@ -410,6 +418,7 @@
 
       fileClass.write('#endif  // __DEFINED__SkPdf' + cls.fName + '\n')
       fileClass.close()
+      fileClassCpp.close()
     
       
     
@@ -419,25 +428,30 @@
     # generate parser  
     # TODO(edisonn): fast recognition based on must attributes.
     fileMapper = open('SkPdfPodofoMapper_autogen.h', 'w')
+    fileMapperCpp = open('SkPdfPodofoMapper_autogen.cpp', 'w')
     fileMapper.write('#ifndef __DEFINED__SkPdfPodofoMapper\n')
     fileMapper.write('#define __DEFINED__SkPdfPodofoMapper\n')
     fileMapper.write('\n')
 
     fileMapper.write('#include "SkPdfHeaders_autogen.h"\n')
-    fileMapper.write('class PodofoMapper {\n')
-    fileMapper.write('public:\n')
+    fileMapperCpp.write('#include "SkPdfPodofoMapper_autogen.h"\n')
+#    fileMapper.write('class PodofoMapper {\n')
+#    fileMapper.write('public:\n')
     for name in self.fClassesNamesInOrder:
       cls = self.fClasses[name]
       
 
-      fileMapper.write('  static bool map(const SkPdfObject& in, SkPdf' + name + '** out) {\n')
-      fileMapper.write('    return map(*in.doc(), *in.podofo(), out);\n')
-      fileMapper.write('  }\n') 
-      fileMapper.write('\n')
+      fileMapper.write('bool map' + name + '(const SkPdfObject& in, SkPdf' + name + '** out);\n')
 
-      fileMapper.write('  static bool map(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdf' + name + '** out) {\n')
-      fileMapper.write('    if (!is' + name + '(podofoDoc, podofoObj)) return false;\n')
-      fileMapper.write('\n')
+      fileMapperCpp.write('bool map' + name + '(const SkPdfObject& in, SkPdf' + name + '** out) {\n')
+      fileMapperCpp.write('  return map' + name + '(*in.doc(), *in.podofo(), out);\n')
+      fileMapperCpp.write('}\n') 
+      fileMapperCpp.write('\n')
+
+      fileMapper.write('bool map' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdf' + name + '** out);\n')
+      fileMapperCpp.write('bool map' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdf' + name + '** out) {\n')
+      fileMapperCpp.write('  if (!is' + name + '(podofoDoc, podofoObj)) return false;\n')
+      fileMapperCpp.write('\n')
 
       # stream must be last one
       hasStream = False
@@ -445,34 +459,35 @@
         if cls.fName == 'Object' and enumToCls[sub].fName == 'Stream':
           hasStream = True
         else:
-          fileMapper.write('    if (map(podofoDoc, podofoObj, (SkPdf' + enumToCls[sub].fName + '**)out)) return true;\n')
+          fileMapperCpp.write('  if (map' + enumToCls[sub].fName + '(podofoDoc, podofoObj, (SkPdf' + enumToCls[sub].fName + '**)out)) return true;\n')
       
       if hasStream:
-        fileMapper.write('    if (map(podofoDoc, podofoObj, (SkPdfStream**)out)) return true;\n')
+        fileMapperCpp.write('  if (mapStream(podofoDoc, podofoObj, (SkPdfStream**)out)) return true;\n')
       
 
-      fileMapper.write('\n')
+      fileMapperCpp.write('\n')
       
-      fileMapper.write('    *out = new SkPdf' + name + '(&podofoDoc, &podofoObj);\n')
-      fileMapper.write('    return true;\n')        
-      fileMapper.write('  }\n') 
-      fileMapper.write('\n')
+      fileMapperCpp.write('  *out = new SkPdf' + name + '(&podofoDoc, &podofoObj);\n')
+      fileMapperCpp.write('  return true;\n')        
+      fileMapperCpp.write('}\n') 
+      fileMapperCpp.write('\n')
        
     for name in self.fClassesNamesInOrder:
       cls = self.fClasses[name]
       
-      fileMapper.write('  static bool is' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {\n')
+      fileMapper.write('bool is' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj);\n')
+      fileMapperCpp.write('bool is' + name + '(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj) {\n')
       
       if cls.fCheck != '':
-        fileMapper.write('    return ' + cls.fCheck + ';\n')
+        fileMapperCpp.write('  return ' + cls.fCheck + ';\n')
       else:
         cntMust = 0
         for field in cls.fFields:
           prop = field.fProp
           if prop.fHasMust:
             cntMust = cntMust + 1
-            fileMapper.write('    ' + knowTypes[prop.fTypes.strip()][0] + ' ' + prop.fCppName + ';\n')
-            fileMapper.write('    if (!' + knowTypes[prop.fTypes.strip()][1] + '(&podofoDoc, podofoObj.GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &' + prop.fCppName + ')) return false;\n')
+            fileMapperCpp.write('  ' + knowTypes[prop.fTypes.strip()][0] + ' ' + prop.fCppName + ';\n')
+            fileMapperCpp.write('  if (!' + knowTypes[prop.fTypes.strip()][1] + '(&podofoDoc, podofoObj.GetDictionary(), \"' + prop.fName + '\", \"' + prop.fAbr + '\", &' + prop.fCppName + ')) return false;\n')
             
             eval = '';
             # TODO(edisonn): this could get out of hand, and could have poor performance if continued on this path
@@ -486,15 +501,32 @@
                   eval = '(' + prop.fCppName + ' != ' + cnd.toCpp() + ')'
                 else:
                   eval = eval + ' && ' + '(' + prop.fCppName + ' != ' + cnd.toCpp() + ')'
-              fileMapper.write('    if (' + eval + ') return false;\n')
-              fileMapper.write('\n')
+              fileMapperCpp.write('  if (' + eval + ') return false;\n')
+              fileMapperCpp.write('\n')
       
-        fileMapper.write('    return true;\n')
+        fileMapperCpp.write('  return true;\n')
               
-      fileMapper.write('  }\n') 
-      fileMapper.write('\n')    
+      fileMapperCpp.write('}\n') 
+      fileMapperCpp.write('\n')    
     
-    fileMapper.write('};\n') 
+      fileMapper.write('bool ' + name + 'FromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdf' + name + '** data);\n')
+      fileMapperCpp.write('bool ' + name + 'FromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, SkPdf' + name + '** data) {\n')
+      fileMapperCpp.write('  const PdfObject* value = resolveReferenceObject(pdfDoc, dict.GetKey(PdfName(key)), true);\n')
+      fileMapperCpp.write('  if (value == NULL) { return false; }\n')
+      fileMapperCpp.write('  if (data == NULL) { return true; }\n')
+      fileMapperCpp.write('  return map' + name + '(*pdfDoc, *value, (SkPdf' + name + '**)data);\n')
+      fileMapperCpp.write('}\n')
+      fileMapperCpp.write('\n')
+
+      fileMapper.write('bool ' + name + 'FromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdf' + name + '** data);\n')
+      fileMapperCpp.write('bool ' + name + 'FromDictionary(const PdfMemDocument* pdfDoc, const PdfDictionary& dict, const char* key, const char* abr, SkPdf' + name + '** data) {\n')
+      fileMapperCpp.write('  if (' + name + 'FromDictionary(pdfDoc, dict, key, data)) return true;\n')
+      fileMapperCpp.write('  if (abr == NULL || *abr == \'\\0\') return false;\n')
+      fileMapperCpp.write('  return ' + name + 'FromDictionary(pdfDoc, dict, abr, data);\n')
+      fileMapperCpp.write('}\n')
+      fileMapperCpp.write('\n')
+          
+    #fileMapper.write('};\n') 
     fileMapper.write('\n')
     
     fileMapper.write('#endif  // __DEFINED__SkPdfPodofoMapper\n')
@@ -504,15 +536,19 @@
 
 def generateCode():
   global fileHeaders 
+  global fileHeadersCpp 
   global knowTypes
 
   fileHeaders = open('SkPdfHeaders_autogen.h', 'w')
+  fileHeadersCpp = open('SkPdfHeaders_autogen.cpp', 'w')
   fileHeaders.write('#ifndef __DEFINED__SkPdfHeaders\n')
   fileHeaders.write('#define __DEFINED__SkPdfHeaders\n')
   fileHeaders.write('\n')
   
   fileHeaders.write('#include "SkPdfEnums_autogen.h"\n')
 
+  fileHeadersCpp.write('#include "SkPdfHeaders_autogen.h"\n')
+
   manager = PdfClassManager()
   
   manager.addClass('Object')
@@ -581,6 +617,7 @@
   
   fileHeaders.write('#endif  // __DEFINED__SkPdfHeaders\n')
   fileHeaders.close()
+  fileHeadersCpp.close()
   
   return 1
 
diff --git a/experimental/PdfViewer/pdf_viewer_main.cpp b/experimental/PdfViewer/pdf_viewer_main.cpp
index 61997fa..20a6cae 100644
--- a/experimental/PdfViewer/pdf_viewer_main.cpp
+++ b/experimental/PdfViewer/pdf_viewer_main.cpp
@@ -1,10 +1,3 @@
-/*
- * 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 "SkForceLinking.h"
@@ -18,2509 +11,8 @@
 #include "SkTArray.h"
 #include "picture_utils.h"
 
-#include <iostream>
-#include <cstdio>
-#include <stack>
-
-#include "podofo.h"
-using namespace PoDoFo;
-
-
-__SK_FORCE_IMAGE_DECODER_LINKING;
-
-// TODO(edisonn): tool, show what objects were read at least, show the ones not even read
-// keep for each object pos in file
-// plug in for VS? syntax coloring, show selected object ... from the text, or from rendered x,y
-
-// TODO(edisonn): security - validate all the user input, all pdf!
-
-
-#include "SkPdfHeaders_autogen.h"
-#include "SkPdfPodofoMapper_autogen.h"
 #include "SkPdfParser.h"
 
-#include "SkPdfBasics.h"
-#include "SkPdfUtils.h"
-
-#include "SkPdfFont.h"
-
-// TODO(edisonn): fix the mess with the files.
-#include "SkPdfFont.cpp"
-#include "SkPdfBasics.cpp"
-#include "SkPdfUtils.cpp"
-
-bool skpdfmap(const PdfMemDocument& podofoDoc, const PdfObject& podofoObj, SkPdfObject** out) {
-    return PodofoMapper::map(podofoDoc, podofoObj, out);
-}
-
-
-/*
- * TODO(edisonn):
- * - all font types and all ppdf font features
- *      - word spacing
- *      - load font for baidu.pdf
- *      - load font for youtube.pdf
- *      - parser for pdf from the definition already available in pdfspec_autogen.py
- *      - all docs from ~/work
- * - encapsulate podofo in the pdf api so the skpdf does not know anything about podofo ... in progress
- * - load gs/ especially smask and already known prop (skp) ... in progress
- * - wrapper on classes for customizations? e.g.
- * SkPdfPageObjectVanila - has only the basic loaders/getters
- * SkPdfPageObject : public SkPdfPageObjectVanila, extends, and I can add customizations here
- * need to find a nice object model for all this with constructors and factories
- * - deal with inheritable automatically ?
- * - deal with specific type in spec directly, add all dictionary types to known types
-*/
-
-
-// TODO(edisonn): move in trace util.
-#ifdef PDF_TRACE
-static void SkTraceMatrix(const SkMatrix& matrix, const char* sz = "") {
-    printf("SkMatrix %s ", sz);
-    for (int i = 0 ; i < 9 ; i++) {
-        printf("%f ", SkScalarToDouble(matrix.get(i)));
-    }
-    printf("\n");
-}
-
-static void SkTraceRect(const SkRect& rect, const char* sz = "") {
-    printf("SkRect %s ", sz);
-    printf("x = %f ", SkScalarToDouble(rect.x()));
-    printf("y = %f ", SkScalarToDouble(rect.y()));
-    printf("w = %f ", SkScalarToDouble(rect.width()));
-    printf("h = %f ", SkScalarToDouble(rect.height()));
-    printf("\n");
-}
-
-#else
-#define SkTraceMatrix(a,b)
-#define SkTraceRect(a,b)
-#endif
-
-using namespace std;
-using namespace PoDoFo;
-
-// Utilities
-static void setup_bitmap(SkBitmap* bitmap, int width, int height, SkColor color = SK_ColorWHITE) {
-    bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height);
-
-    bitmap->allocPixels();
-    bitmap->eraseColor(color);
-}
-
-// TODO(edisonn): synonyms? DeviceRGB and RGB ...
-int GetColorSpaceComponents(const std::string& colorSpace) {
-    if (colorSpace == "DeviceCMYK") {
-        return 4;
-    } else if (colorSpace == "DeviceGray" ||
-            colorSpace == "CalGray" ||
-            colorSpace == "Indexed") {
-        return 1;
-    } else if (colorSpace == "DeviceRGB" ||
-            colorSpace == "CalRGB" ||
-            colorSpace == "Lab") {
-        return 3;
-    } else {
-        return 0;
-    }
-}
-
-const PdfObject* resolveReferenceObject(const PdfMemDocument* pdfDoc,
-                                  const PdfObject* obj,
-                                  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];
-        }
-    }
-
-    return obj;
-}
-
-static SkMatrix SkMatrixFromPdfMatrix(double array[6]) {
-    SkMatrix matrix;
-    matrix.setAll(SkDoubleToScalar(array[0]),
-                  SkDoubleToScalar(array[2]),
-                  SkDoubleToScalar(array[4]),
-                  SkDoubleToScalar(array[1]),
-                  SkDoubleToScalar(array[3]),
-                  SkDoubleToScalar(array[5]),
-                  SkDoubleToScalar(0),
-                  SkDoubleToScalar(0),
-                  SkDoubleToScalar(1));
-
-    return matrix;
-}
-
-SkMatrix SkMatrixFromPdfArray(SkPdfArray* pdfArray) {
-    double array[6];
-
-    // TODO(edisonn): security issue, ret if size() != 6
-    for (int i = 0; i < 6; i++) {
-        const PdfObject* elem = resolveReferenceObject(pdfArray->doc(), (*pdfArray)[i]->podofo());
-        if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
-            return SkMatrix::I();  // TODO(edisonn): report issue
-        }
-        array[i] = elem->GetReal();
-    }
-
-    return SkMatrixFromPdfMatrix(array);
-}
-
-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,";
-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(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;
-        setup_bitmap(&bitmap, gDumpBitmap->width(), gDumpBitmap->height());
-
-        memcpy(bitmap.getPixels(), gDumpBitmap->getPixels(), gDumpBitmap->getSize());
-
-        SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (bitmap)));
-        SkCanvas canvas(device);
-
-        // draw context stuff here
-        SkPaint blueBorder;
-        blueBorder.setColor(SK_ColorBLUE);
-        blueBorder.setStyle(SkPaint::kStroke_Style);
-        blueBorder.setTextSize(SkDoubleToScalar(20));
-
-        SkString str;
-
-        const SkClipStack* clipStack = gDumpCanvas->getClipStack();
-        if (clipStack) {
-            SkClipStack::Iter iter(*clipStack, SkClipStack::Iter::kBottom_IterStart);
-            const SkClipStack::Element* elem;
-            double y = 0;
-            int total = 0;
-            while (elem = iter.next()) {
-                total++;
-                y += 30;
-
-                switch (elem->getType()) {
-                    case SkClipStack::Element::kRect_Type:
-                        canvas.drawRect(elem->getRect(), blueBorder);
-                        canvas.drawText("Rect Clip", strlen("Rect Clip"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
-                        break;
-                    case SkClipStack::Element::kPath_Type:
-                        canvas.drawPath(elem->getPath(), blueBorder);
-                        canvas.drawText("Path Clip", strlen("Path Clip"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
-                        break;
-                    case SkClipStack::Element::kEmpty_Type:
-                        canvas.drawText("Empty Clip!!!", strlen("Empty Clip!!!"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
-                        break;
-                    default:
-                        canvas.drawText("Unkown Clip!!!", strlen("Unkown Clip!!!"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
-                        break;
-                }
-            }
-
-            y += 30;
-            str.printf("Number of clips in stack: %i", total);
-            canvas.drawText(str.c_str(), str.size(), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder);
-        }
-
-        const SkRegion& clipRegion = gDumpCanvas->getTotalClip();
-        SkPath clipPath;
-        if (clipRegion.getBoundaryPath(&clipPath)) {
-            SkPaint redBorder;
-            redBorder.setColor(SK_ColorRED);
-            redBorder.setStyle(SkPaint::kStroke_Style);
-            canvas.drawPath(clipPath, redBorder);
-        }
-
-        canvas.flush();
-
-        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->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;
-    SkPdfTokenizer* fTokenizer;
-    PdfContext* fPdfContext;
-    SkCanvas* fCanvas;
-
-public:
-    PdfTokenLooper(PdfTokenLooper* parent,
-                   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,
-                  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) {}
-
-    virtual PdfResult consumeToken(PdfToken& token);
-    virtual void loop();
-    PdfResult done();
-};
-
-class PdfCompatibilitySectionLooper : public PdfTokenLooper {
-public:
-    PdfCompatibilitySectionLooper()
-        : PdfTokenLooper(NULL, NULL, 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];
-
-char* gRenderStatsNames[kCount_PdfResult] = {
-    "Success",
-    "Partially implemented",
-    "Not yet implemented",
-    "Ignore Error",
-    "Error",
-    "Unsupported/Unknown"
-};
-
-static SkTypeface* SkTypefaceFromPdfFont(PdfFont* font) {
-    if (font == NULL) {
-        return SkTypeface::CreateFromName("Times New Roman", SkTypeface::kNormal);
-    }
-
-    PdfObject* fontObject = font->GetObject();
-
-    PdfObject* pBaseFont = NULL;
-    // TODO(edisonn): warning, PoDoFo has a bug in PdfFont constructor, does not call InitVars()
-    // for now fixed locally.
-    pBaseFont = fontObject->GetIndirectKey( "BaseFont" );
-    const char* pszBaseFontName = pBaseFont->GetName().GetName().c_str();
-
-#ifdef PDF_TRACE
-    std::string str;
-    fontObject->ToString(str);
-    printf("Base Font Name: %s\n", pszBaseFontName);
-    printf("Font Object Data: %s\n", str.c_str());
-#endif
-
-    SkTypeface* typeface = SkTypefaceFromPdfStandardFont(pszBaseFontName, font->IsBold(), font->IsItalic());
-
-    if (typeface != NULL) {
-        return typeface;
-    }
-
-    char name[1000];
-    // HACK
-    strncpy(name, pszBaseFontName, 1000);
-    char* comma = strstr(name, ",");
-    char* dash = strstr(name, "-");
-    if (comma) *comma = '\0';
-    if (dash) *dash = '\0';
-
-    typeface = SkTypeface::CreateFromName(
-                name,
-                SkTypeface::Style((font->IsBold() ? SkTypeface::kBold : 0) |
-                                  (font->IsItalic() ? SkTypeface::kItalic : 0)));
-
-    if (typeface != NULL) {
-#ifdef PDF_TRACE
-    printf("HACKED FONT found %s\n", name);
-#endif
-        return typeface;
-    }
-
-#ifdef PDF_TRACE
-    printf("FONT_NOT_FOUND %s\n", pszBaseFontName);
-#endif
-
-    // TODO(edisonn): Report Warning, NYI
-    return SkTypeface::CreateFromName(
-                "Times New Roman",
-                SkTypeface::Style((font->IsBold() ? SkTypeface::kBold : 0) |
-                                  (font->IsItalic() ? SkTypeface::kItalic : 0)));
-}
-
-PdfResult DrawText(PdfContext* pdfContext,
-                   const SkPdfObject* str,
-                   SkCanvas* canvas)
-{
-
-    SkPdfFont* skfont = pdfContext->fGraphicsState.fSkFont;
-    if (skfont == NULL) {
-        skfont = SkPdfFont::Default();
-    }
-
-    SkUnencodedText binary(str);
-
-    SkDecodedText decoded;
-
-    if (skfont->encoding() == NULL) {
-        // TODO(edisonn): report warning
-        return kNYI_PdfResult;
-    }
-
-    skfont->encoding()->decodeText(binary, &decoded);
-
-    SkPaint paint;
-    // TODO(edisonn): when should fCurFont->GetFontSize() used? When cur is fCurFontSize == 0?
-    // Or maybe just not call setTextSize at all?
-    if (pdfContext->fGraphicsState.fCurFontSize != 0) {
-        paint.setTextSize(SkDoubleToScalar(pdfContext->fGraphicsState.fCurFontSize));
-    }
-
-//    if (fCurFont && fCurFont->GetFontScale() != 0) {
-//        paint.setTextScaleX(SkFloatToScalar(fCurFont->GetFontScale() / 100.0));
-//    }
-
-    pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
-
-    canvas->save();
-
-#if 1
-    SkMatrix matrix = pdfContext->fGraphicsState.fMatrixTm;
-
-    SkPoint point1;
-    pdfContext->fGraphicsState.fMatrixTm.mapXY(SkIntToScalar(0), SkIntToScalar(0), &point1);
-
-    SkMatrix mirror;
-    mirror.setTranslate(0, -point1.y());
-    // TODO(edisonn): fix rotated text, and skewed too
-    mirror.postScale(SK_Scalar1, -SK_Scalar1);
-    // TODO(edisonn): post rotate, skew
-    mirror.postTranslate(0, point1.y());
-
-    matrix.postConcat(mirror);
-
-    canvas->setMatrix(matrix);
-
-    SkTraceMatrix(matrix, "mirrored");
-#endif
-
-    skfont->drawText(decoded, &paint, pdfContext, canvas, &pdfContext->fGraphicsState.fMatrixTm);
-    canvas->restore();
-
-    return kPartial_PdfResult;
-}
-
-// TODO(edisonn): create header files with declarations!
-PdfResult PdfOp_q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
-PdfResult PdfOp_Q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
-PdfResult PdfOp_Tw(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
-PdfResult PdfOp_Tc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
-
-// TODO(edisonn): deal with synonyms (/BPC == /BitsPerComponent), here or in GetKey?
-// Always pass long form in key, and have a map of long -> short key
-bool LongFromDictionary(const PdfMemDocument* pdfDoc,
-                        const PdfDictionary& dict,
-                        const char* key,
-                        long* data) {
-    const PdfObject* value = resolveReferenceObject(pdfDoc,
-                                              dict.GetKey(PdfName(key)));
-
-    if (value == NULL || !value->IsNumber()) {
-        return false;
-    }
-    if (data == NULL) {
-        return true;
-    }
-
-    *data = value->GetNumber();
-    return true;
-}
-
-bool LongFromDictionary(const PdfMemDocument* pdfDoc,
-                        const PdfDictionary& dict,
-                        const char* key,
-                        const char* abr,
-                        long* data) {
-    if (LongFromDictionary(pdfDoc, dict, key, data)) return true;
-    if (abr == NULL || *abr == '\0') return false;
-    return LongFromDictionary(pdfDoc, dict, abr, data);
-}
-
-bool DoubleFromDictionary(const PdfMemDocument* pdfDoc,
-                          const PdfDictionary& dict,
-                          const char* key,
-                          double* data) {
-    const PdfObject* value = resolveReferenceObject(pdfDoc,
-                                              dict.GetKey(PdfName(key)));
-
-    if (value == NULL || (!value->IsReal() && !value->IsNumber())) {
-        return false;
-    }
-    if (data == NULL) {
-        return true;
-    }
-
-    *data = value->GetReal();
-    return true;
-}
-
-bool DoubleFromDictionary(const PdfMemDocument* pdfDoc,
-                          const PdfDictionary& dict,
-                          const char* key,
-                          const char* abr,
-                          double* data) {
-    if (DoubleFromDictionary(pdfDoc, dict, key, data)) return true;
-    if (abr == NULL || *abr == '\0') return false;
-    return DoubleFromDictionary(pdfDoc, dict, abr, data);
-}
-
-
-bool BoolFromDictionary(const PdfMemDocument* pdfDoc,
-                        const PdfDictionary& dict,
-                        const char* key,
-                        bool* data) {
-    const PdfObject* value = resolveReferenceObject(pdfDoc,
-                                              dict.GetKey(PdfName(key)));
-
-    if (value == NULL || !value->IsBool()) {
-        return false;
-    }
-    if (data == NULL) {
-        return true;
-    }
-
-    *data = value->GetBool();
-    return true;
-}
-
-bool BoolFromDictionary(const PdfMemDocument* pdfDoc,
-                        const PdfDictionary& dict,
-                        const char* key,
-                        const char* abr,
-                        bool* data) {
-    if (BoolFromDictionary(pdfDoc, dict, key, data)) return true;
-    if (abr == NULL || *abr == '\0') return false;
-    return BoolFromDictionary(pdfDoc, dict, abr, data);
-}
-
-bool NameFromDictionary(const PdfMemDocument* pdfDoc,
-                        const PdfDictionary& dict,
-                        const char* key,
-                        std::string* data) {
-    const PdfObject* value = resolveReferenceObject(pdfDoc,
-                                              dict.GetKey(PdfName(key)),
-                                              true);
-    if (value == NULL || !value->IsName()) {
-        return false;
-    }
-    if (data == NULL) {
-        return true;
-    }
-
-    *data = value->GetName().GetName();
-    return true;
-}
-
-bool NameFromDictionary(const PdfMemDocument* pdfDoc,
-                        const PdfDictionary& dict,
-                        const char* key,
-                        const char* abr,
-                        std::string* data) {
-    if (NameFromDictionary(pdfDoc, dict, key, data)) return true;
-    if (abr == NULL || *abr == '\0') return false;
-    return NameFromDictionary(pdfDoc, dict, abr, data);
-}
-
-bool StringFromDictionary(const PdfMemDocument* pdfDoc,
-                          const PdfDictionary& dict,
-                          const char* key,
-                          std::string* data) {
-    const PdfObject* value = resolveReferenceObject(pdfDoc,
-                                              dict.GetKey(PdfName(key)),
-                                              true);
-    if (value == NULL || (!value->IsString() && !value->IsHexString())) {
-        return false;
-    }
-    if (data == NULL) {
-        return true;
-    }
-
-    *data = value->GetString().GetString();
-    return true;
-}
-
-bool StringFromDictionary(const PdfMemDocument* pdfDoc,
-                          const PdfDictionary& dict,
-                          const char* key,
-                          const char* abr,
-                          std::string* data) {
-    if (StringFromDictionary(pdfDoc, dict, key, data)) return true;
-    if (abr == NULL || *abr == '\0') return false;
-    return StringFromDictionary(pdfDoc, dict, abr, data);
-}
-
-bool ArrayFromDictionary(const PdfMemDocument* pdfDoc,
-                              const PdfDictionary& dict,
-                              const char* key,
-                              SkPdfArray** data) {
-    const PdfObject* value = resolveReferenceObject(pdfDoc,
-                                              dict.GetKey(PdfName(key)),
-                                              true);
-    if (value == NULL || !value->IsArray()) {
-        return false;
-    }
-    if (data == NULL) {
-        return true;
-    }
-
-    return PodofoMapper::map(*pdfDoc, *value, (SkPdfObject**)data);
-}
-
-
-bool ArrayFromDictionary(const PdfMemDocument* pdfDoc,
-                        const PdfDictionary& dict,
-                        const char* key,
-                        const char* abr,
-                        SkPdfArray** data) {
-    if (ArrayFromDictionary(pdfDoc, dict, key, data)) return true;
-    if (abr == NULL || *abr == '\0') return false;
-    return ArrayFromDictionary(pdfDoc, dict, abr, data);
-}
-
-
-bool DictionaryFromDictionary(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;
-    }
-    if (data == NULL) {
-        return true;
-    }
-
-    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,
-                              T** data) {
-    const PdfObject* value = resolveReferenceObject(pdfDoc,
-                                              dict.GetKey(PdfName(key)),
-                                              true);
-    if (value == NULL || !value->IsDictionary()) {
-        return false;
-    }
-
-    if (data == NULL) {
-        return true;
-    }
-
-    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;
-    }
-    if (data == NULL) {
-        return true;
-    }
-    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);
-}
-
-bool StreamFromDictionary(const PdfMemDocument* pdfDoc,
-                          const PdfDictionary& dict,
-                          const char* key,
-                          SkPdfStream** data) {
-    const PdfObject* value = resolveReferenceObject(pdfDoc,
-                                              dict.GetKey(PdfName(key)),
-                                              true);
-    if (value == NULL) {
-        return false;
-    }
-    if (data == NULL) {
-        return true;
-    }
-    return PodofoMapper::map(*pdfDoc, *value, data);
-}
-
-bool StreamFromDictionary(const PdfMemDocument* pdfDoc,
-                        const PdfDictionary& dict,
-                        const char* key,
-                        const char* abr,
-                        SkPdfStream** data) {
-    if (StreamFromDictionary(pdfDoc, dict, key, data)) return true;
-    if (abr == NULL || *abr == '\0') return false;
-    return StreamFromDictionary(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);
-    }
-    return grayColortable;
-}
-
-SkBitmap transferImageStreamToBitmap(unsigned char* uncompressedStream, pdf_long uncompressedStreamLength,
-                                     int width, int height, int bytesPerLine,
-                                     int bpc, const std::string& colorSpace,
-                                     bool transparencyMask) {
-    SkBitmap bitmap;
-
-    int components = GetColorSpaceComponents(colorSpace);
-//#define MAX_COMPONENTS 10
-
-    int bitsPerLine = width * components * bpc;
-    // TODO(edisonn): assume start of lines are aligned at 32 bits?
-    // Is there a faster way to load the uncompressed stream into a bitmap?
-
-    // minimal support for now
-    if ((colorSpace == "DeviceRGB" || colorSpace == "RGB") && bpc == 8) {
-        SkColor* uncompressedStreamArgb = (SkColor*)malloc(width * height * sizeof(SkColor));
-
-        for (int h = 0 ; h < height; h++) {
-            long i = width * (height - 1 - h);
-            for (int w = 0 ; w < width; w++) {
-                uncompressedStreamArgb[i] = SkColorSetRGB(uncompressedStream[3 * w],
-                                                          uncompressedStream[3 * w + 1],
-                                                          uncompressedStream[3 * w + 2]);
-                i++;
-            }
-            uncompressedStream += bytesPerLine;
-        }
-
-        bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
-        bitmap.setPixels(uncompressedStreamArgb);
-    }
-    else if ((colorSpace == "DeviceGray" || colorSpace == "Gray") && bpc == 8) {
-        unsigned char* uncompressedStreamA8 = (unsigned char*)malloc(width * height);
-
-        for (int h = 0 ; h < height; h++) {
-            long i = width * (height - 1 - h);
-            for (int w = 0 ; w < width; w++) {
-                uncompressedStreamA8[i] = transparencyMask ? 255 - uncompressedStream[w] :
-                                                             uncompressedStream[w];
-                i++;
-            }
-            uncompressedStream += bytesPerLine;
-        }
-
-        bitmap.setConfig(transparencyMask ? SkBitmap::kA8_Config : SkBitmap::kIndex8_Config,
-                         width, height);
-        bitmap.setPixels(uncompressedStreamA8, transparencyMask ? NULL : getGrayColortable());
-    }
-
-    // TODO(edisonn): Report Warning, NYI, or error
-    return bitmap;
-}
-
-bool transferImageStreamToARGB(unsigned char* uncompressedStream, pdf_long uncompressedStreamLength,
-                               int width, int bytesPerLine,
-                               int bpc, const std::string& colorSpace,
-                               SkColor** uncompressedStreamArgb,
-                               pdf_long* uncompressedStreamLengthInBytesArgb) {
-    int components = GetColorSpaceComponents(colorSpace);
-//#define MAX_COMPONENTS 10
-
-    int bitsPerLine = width * components * bpc;
-    // TODO(edisonn): assume start of lines are aligned at 32 bits?
-    int height = uncompressedStreamLength / bytesPerLine;
-
-    // minimal support for now
-    if ((colorSpace == "DeviceRGB" || colorSpace == "RGB") && bpc == 8) {
-        *uncompressedStreamLengthInBytesArgb = width * height * 4;
-        *uncompressedStreamArgb = (SkColor*)malloc(*uncompressedStreamLengthInBytesArgb);
-
-        for (int h = 0 ; h < height; h++) {
-            long i = width * (height - 1 - h);
-            for (int w = 0 ; w < width; w++) {
-                (*uncompressedStreamArgb)[i] = SkColorSetRGB(uncompressedStream[3 * w],
-                                                             uncompressedStream[3 * w + 1],
-                                                             uncompressedStream[3 * w + 2]);
-                i++;
-            }
-            uncompressedStream += bytesPerLine;
-        }
-        return true;
-    }
-
-    if ((colorSpace == "DeviceGray" || colorSpace == "Gray") && bpc == 8) {
-        *uncompressedStreamLengthInBytesArgb = width * height * 4;
-        *uncompressedStreamArgb = (SkColor*)malloc(*uncompressedStreamLengthInBytesArgb);
-
-        for (int h = 0 ; h < height; h++) {
-            long i = width * (height - 1 - h);
-            for (int w = 0 ; w < width; w++) {
-                (*uncompressedStreamArgb)[i] = SkColorSetRGB(uncompressedStream[w],
-                                                             uncompressedStream[w],
-                                                             uncompressedStream[w]);
-                i++;
-            }
-            uncompressedStream += bytesPerLine;
-        }
-        return true;
-    }
-
-    return false;
-}
-
-// utils
-
-// TODO(edisonn): add cache, or put the bitmap property directly on the PdfObject
-// TODO(edisonn): deal with colorSpaces, we could add them to SkBitmap::Config
-// TODO(edisonn): preserve A1 format that skia knows, + fast convert from 111, 222, 444 to closest
-// skia format, through a table
-
-// this functions returns the image, it does not look at the smask.
-
-SkBitmap getImageFromObject(PdfContext* pdfContext, const SkPdfImageDictionary* image, bool transparencyMask) {
-    if (image == NULL || !image->valid()) {
-        // TODO(edisonn): report warning to be used in testing.
-        return SkBitmap();
-    }
-
-    // TODO (edisonn): Fast Jpeg(DCTDecode) draw, or fast PNG(FlateDecode) draw ...
-//    PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
-//                                              obj.GetDictionary().GetKey(PdfName("Filter")));
-//    if (value && value->IsArray() && value->GetArray().GetSize() == 1) {
-//        value = resolveReferenceObject(pdfContext->fPdfDoc,
-//                                       &value->GetArray()[0]);
-//    }
-//    if (value && value->IsName() && value->GetName().GetName() == "DCTDecode") {
-//        SkStream stream = SkStream::
-//        SkImageDecoder::Factory()
-//    }
-
-    long bpc = image->BitsPerComponent();
-    long width = image->Width();
-    long height = image->Height();
-    std::string colorSpace = "DeviceRGB";
-
-    // TODO(edisonn): color space can be an array too!
-    if (image->isColorSpaceAName()) {
-        colorSpace = image->getColorSpaceAsName();
-    }
-
-/*
-    bool imageMask = image->imageMask();
-
-    if (imageMask) {
-        if (bpc != 0 && bpc != 1) {
-            // TODO(edisonn): report warning to be used in testing.
-            return SkBitmap();
-        }
-        bpc = 1;
-    }
-*/
-
-    const PdfObject* obj = image->podofo();
-
-    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);
-    } catch (PdfError& e) {
-        // TODO(edisonn): report warning to be used in testing.
-        return SkBitmap();
-    }
-
-    int bytesPerLine = uncompressedStreamLength / height;
-#ifdef PDF_TRACE
-    if (uncompressedStreamLength % height != 0) {
-        printf("Warning uncompressedStreamLength % height != 0 !!!\n");
-    }
-#endif
-
-    SkBitmap bitmap = transferImageStreamToBitmap(
-            (unsigned char*)uncompressedStream, uncompressedStreamLength,
-            width, height, bytesPerLine,
-            bpc, colorSpace,
-            transparencyMask);
-
-    free(uncompressedStream);
-
-    return bitmap;
-}
-
-SkBitmap getSmaskFromObject(PdfContext* pdfContext, const SkPdfImageDictionary* obj) {
-    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->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;
-    }
-
-    SkBitmap image = getImageFromObject(pdfContext, skpdfimage, false);
-    SkBitmap sMask = getSmaskFromObject(pdfContext, skpdfimage);
-
-    canvas->save();
-    canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
-    SkRect dst = SkRect::MakeXYWH(SkDoubleToScalar(0.0), SkDoubleToScalar(0.0), SkDoubleToScalar(1.0), SkDoubleToScalar(1.0));
-
-    if (sMask.empty()) {
-        canvas->drawBitmapRect(image, dst, NULL);
-    } else {
-        canvas->saveLayer(&dst, NULL);
-        canvas->drawBitmapRect(image, dst, NULL);
-        SkPaint xfer;
-        pdfContext->fGraphicsState.applyGraphicsState(&xfer, false);
-        xfer.setXfermodeMode(SkXfermode::kSrcOut_Mode); // SkXfermode::kSdtOut_Mode
-        canvas->drawBitmapRect(sMask, dst, &xfer);
-        canvas->restore();
-    }
-
-    canvas->restore();
-
-    return kPartial_PdfResult;
-}
-
-bool SkMatrixFromDictionary(const PdfMemDocument* pdfDoc,
-                            const PdfDictionary& dict,
-                            const char* key,
-                            SkMatrix** matrix) {
-    const PdfObject* value = resolveReferenceObject(pdfDoc,
-                                                    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(pdfDoc, &value->GetArray()[i]);
-        if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
-            return false;
-        }
-        array[i] = elem->GetReal();
-    }
-
-    *matrix = new SkMatrix();
-    **matrix = SkMatrixFromPdfMatrix(array);
-    return true;
-}
-
-bool SkMatrixFromDictionary(const PdfMemDocument* pdfDoc,
-                        const PdfDictionary& dict,
-                        const char* key,
-                        const char* abr,
-                        SkMatrix** data) {
-    if (SkMatrixFromDictionary(pdfDoc, dict, key, data)) return true;
-    if (abr == NULL || *abr == '\0') return false;
-    return SkMatrixFromDictionary(pdfDoc, dict, abr, data);
-
-}
-
-bool SkRectFromDictionary(const PdfMemDocument* pdfDoc,
-                          const PdfDictionary& dict,
-                          const char* key,
-                          SkRect** rect) {
-    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(pdfDoc, &value->GetArray()[i]);
-        if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
-            return false;
-        }
-        array[i] = elem->GetReal();
-    }
-
-    *rect = new SkRect();
-    **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 (skobj->Resources()) {
-        pdfContext->fGraphicsState.fResources = skobj->Resources();
-    }
-
-    SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Current matrix");
-
-    if (skobj->Matrix()) {
-        pdfContext->fGraphicsState.fMatrix.preConcat(*skobj->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);
-
-    if (skobj->BBox()) {
-        canvas->clipRect(*skobj->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.
-
-    PdfResult ret = kPartial_PdfResult;
-    SkPdfTokenizer tokenizer(skobj);
-    PdfMainLooper looper(NULL, &tokenizer, pdfContext, canvas);
-    looper.loop();
-
-    // 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;
-}
-
-PdfResult doType3Char(PdfContext* pdfContext, SkCanvas* canvas, SkPdfObject* skobj, SkRect bBox, SkMatrix matrix, double textSize) {
-    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.fMatrixTm.preConcat(matrix);
-    pdfContext->fGraphicsState.fMatrixTm.preScale(SkDoubleToScalar(textSize), SkDoubleToScalar(textSize));
-
-    pdfContext->fGraphicsState.fMatrix = pdfContext->fGraphicsState.fMatrixTm;
-    pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrix;
-
-    SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Total matrix");
-
-    canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
-
-    SkRect rm = bBox;
-    pdfContext->fGraphicsState.fMatrix.mapRect(&rm);
-
-    SkTraceRect(rm, "bbox mapped");
-
-    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.
-
-    PdfResult ret = kPartial_PdfResult;
-    SkPdfTokenizer tokenizer(skobj);
-    PdfMainLooper looper(NULL, &tokenizer, pdfContext, canvas);
-    looper.loop();
-
-    // 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;
-}
-
-
-// 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 SkPdfObject& obj) {
-    if (CheckRecursiveRendering::IsInRendering(*obj.podofo())) {
-        // Oops, corrupt PDF!
-        return kIgnoreError_PdfResult;
-    }
-
-    CheckRecursiveRendering checkRecursion(*obj.podofo());
-
-    // TODO(edisonn): check type
-    SkPdfXObjectDictionary* skobj = NULL;
-    if (!PodofoMapper::map(obj, &skobj)) return kIgnoreError_PdfResult;
-
-    if (!skobj || !skobj->valid()) return kIgnoreError_PdfResult;
-
-    PdfResult ret = kIgnoreError_PdfResult;
-    switch (skobj->getType())
-    {
-        case kImageDictionary_SkPdfObjectType:
-            ret = doXObject_Image(pdfContext, canvas, skobj->asImageDictionary());
-            break;
-        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->fObjectStack.top()->asNumber()->value();
-        pdfContext->fObjectStack.pop();
-    }
-
-    // a b
-    // c d
-    // e f
-
-    // 0 1
-    // 2 3
-    // 4 5
-
-    // sx ky
-    // kx sy
-    // tx ty
-    SkMatrix matrix = SkMatrixFromPdfMatrix(array);
-
-    pdfContext->fGraphicsState.fMatrix.preConcat(matrix);
-
-#ifdef PDF_TRACE
-    printf("cm ");
-    for (int i = 0 ; i < 6 ; i++) {
-        printf("%f ", array[i]);
-    }
-    printf("\n");
-    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->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->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->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-    double tx = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
-
-    // TODO(edisonn): Create factory methods or constructors so podofo is hidden
-    PdfObject _ty(PdfVariant(-ty));
-    pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc->podofo(), &_ty));
-
-    PdfOp_TL(pdfContext, canvas, looper);
-
-    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->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) {
-    PdfObject zero(PdfVariant(0.0));
-    PdfObject tl(PdfVariant(-(-pdfContext->fGraphicsState.fTextLeading)));
-
-    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->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->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->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->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->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->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->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;
-}
-
-PdfResult PdfOp_h(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fGraphicsState.fPath.close();
-    return kOK_PdfResult;
-}
-
-PdfResult PdfOp_fillAndStroke(PdfContext* pdfContext, SkCanvas* canvas, bool fill, bool stroke, bool close, bool evenOdd) {
-    SkPath path = pdfContext->fGraphicsState.fPath;
-
-    if (close) {
-        path.close();
-    }
-
-    canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
-
-    SkPaint paint;
-
-    SkPoint line[2];
-    if (fill && !stroke && path.isLine(line)) {
-        paint.setStyle(SkPaint::kStroke_Style);
-
-        pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
-        paint.setStrokeWidth(SkDoubleToScalar(0));
-
-        canvas->drawPath(path, paint);
-    } else {
-        if (fill) {
-            paint.setStyle(SkPaint::kFill_Style);
-            if (evenOdd) {
-                path.setFillType(SkPath::kEvenOdd_FillType);
-            }
-
-            pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
-
-            canvas->drawPath(path, paint);
-        }
-
-        if (stroke) {
-            paint.setStyle(SkPaint::kStroke_Style);
-
-            pdfContext->fGraphicsState.applyGraphicsState(&paint, true);
-
-            path.setFillType(SkPath::kWinding_FillType);  // reset it, just in case it messes up the stroke
-            canvas->drawPath(path, paint);
-        }
-    }
-
-    pdfContext->fGraphicsState.fPath.reset();
-    // todo zoom ... other stuff ?
-
-    if (pdfContext->fGraphicsState.fHasClipPathToApply) {
-#ifndef PDF_DEBUG_NO_CLIPING
-        canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kIntersect_Op, true);
-#endif
-    }
-
-    //pdfContext->fGraphicsState.fClipPath.reset();
-    pdfContext->fGraphicsState.fHasClipPathToApply = false;
-
-    return kPartial_PdfResult;
-
-}
-
-PdfResult PdfOp_S(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    return PdfOp_fillAndStroke(pdfContext, canvas, false, true, false, false);
-}
-
-PdfResult PdfOp_s(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    return PdfOp_fillAndStroke(pdfContext, canvas, false, true, true, false);
-}
-
-PdfResult PdfOp_F(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false);
-}
-
-PdfResult PdfOp_f(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false);
-}
-
-PdfResult PdfOp_f_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, true);
-}
-
-PdfResult PdfOp_B(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, false);
-}
-
-PdfResult PdfOp_B_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, true);
-}
-
-PdfResult PdfOp_b(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, false);
-}
-
-PdfResult PdfOp_b_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, true);
-}
-
-PdfResult PdfOp_n(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
-    if (pdfContext->fGraphicsState.fHasClipPathToApply) {
-#ifndef PDF_DEBUG_NO_CLIPING
-        canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kIntersect_Op, true);
-#endif
-    }
-
-    //pdfContext->fGraphicsState.fClipPath.reset();
-    pdfContext->fGraphicsState.fHasClipPathToApply = false;
-
-    pdfContext->fGraphicsState.fPathClosed = true;
-
-    return kOK_PdfResult;
-}
-
-PdfResult PdfOp_BT(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fGraphicsState.fTextBlock   = true;
-    pdfContext->fGraphicsState.fMatrixTm = pdfContext->fGraphicsState.fMatrix;
-    pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrix;
-
-    return kPartial_PdfResult;
-}
-
-PdfResult PdfOp_ET(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    if (!pdfContext->fGraphicsState.fTextBlock) {
-        return kIgnoreError_PdfResult;
-    }
-    // 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 speciﬁed explicitly using Tf before any text is shown.
-PdfResult PdfOp_Tf(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    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 Resources: %s\n", str.c_str());
-    pdfContext->fGraphicsState.fResources->Font()->podofo()->ToString(str);
-    printf("Print Tf Resources/Font: %s\n", str.c_str());
-#endif
-
-    SkPdfFontDictionary* fd = NULL;
-    if (pdfContext->fGraphicsState.fResources->Font()) {
-        SkPdfObject* objFont = pdfContext->fGraphicsState.fResources->Font()->get(fontName.c_str());
-        PodofoMapper::map(*objFont, &fd);
-
-#ifdef PDF_TRACE
-        objFont->podofo()->ToString(str);
-        printf("Print Font loaded: %s\n", str.c_str());
-        fd->podofo()->ToString(str);
-        printf("Print Font loaded and resolved and upgraded: %s\n", str.c_str());
-#endif
-
-    }
-
-    SkPdfFont* skfont = SkPdfFont::fontFromPdfDictionary(fd);
-
-    if (skfont) {
-        pdfContext->fGraphicsState.fSkFont = skfont;
-    }
-
-    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->fObjectStack.top(),
-                             canvas);
-    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;
-    }
-
-    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->fObjectStack.push(aw);
-    PdfOp_Tw(pdfContext, canvas, looper);
-
-    pdfContext->fObjectStack.push(ac);
-    PdfOp_Tc(pdfContext, canvas, looper);
-
-    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;
-    }
-
-    SkPdfArray* array = pdfContext->fObjectStack.top()->asArray();
-    pdfContext->fObjectStack.pop();
-
-    for( int i=0; i<static_cast<int>(array->size()); i++ )
-    {
-        if( (*array)[i]->asString()) {
-            SkPdfObject* obj = (*array)[i];
-            DrawText(pdfContext,
-                     obj,
-                     canvas);
-        } 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->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->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
-        } else {
-            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->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->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->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->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);
-}
-
-PdfResult PdfOp_k(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
-}
-
-PdfResult PdfOp_W(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath;
-    pdfContext->fGraphicsState.fHasClipPathToApply = true;
-
-    return kOK_PdfResult;
-}
-
-PdfResult PdfOp_W_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath;
-
-#ifdef PDF_TRACE
-    if (pdfContext->fGraphicsState.fClipPath.isRect(NULL)) {
-        printf("CLIP IS RECT\n");
-    }
-#endif
-
-    // TODO(edisonn): there seem to be a bug with clipPath of a rect with even odd.
-    pdfContext->fGraphicsState.fClipPath.setFillType(SkPath::kEvenOdd_FillType);
-    pdfContext->fGraphicsState.fHasClipPathToApply = true;
-
-    return kPartial_PdfResult;
-}
-
-PdfResult PdfOp_BX(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    *looper = new PdfCompatibilitySectionLooper();
-    return kOK_PdfResult;
-}
-
-PdfResult PdfOp_EX(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-#ifdef ASSERT_BAD_PDF_OPS
-    SkASSERT(false);  // EX must be consumed by PdfCompatibilitySectionLooper, but let's
-                      // have the assert when testing good pdfs.
-#endif
-    return kIgnoreError_PdfResult;
-}
-
-PdfResult PdfOp_BI(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    *looper = new PdfInlineImageLooper();
-    return kOK_PdfResult;
-}
-
-PdfResult PdfOp_ID(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;
-}
-
-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->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->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->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->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->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->fObjectStack.pop();
-
-    return kNYI_PdfResult;
-}
-
-//ﬂatness i Set the ﬂatness tolerance in the graphics state (see Section 6.5.1, “Flatness
-//Tolerance”). ﬂatness is a number in the range 0 to 100; a value of 0 speci-
-//ﬁes the output device’s default ﬂatness tolerance.
-PdfResult PdfOp_i(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    pdfContext->fObjectStack.pop();
-
-    return kNYI_PdfResult;
-}
-
-//dictName gs (PDF 1.2) Set the speciﬁed 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) {
-    std::string name = pdfContext->fObjectStack.top()->asName()->value();    pdfContext->fObjectStack.pop();
-
-#ifdef PDF_TRACE
-    std::string str;
-#endif
-
-    //Next, get the ExtGState Dictionary from the Resource Dictionary:
-    const SkPdfDictionary* extGStateDictionary = pdfContext->fGraphicsState.fResources->ExtGState();
-
-    if (extGStateDictionary == NULL) {
-#ifdef PDF_TRACE
-        printf("ExtGState is NULL!\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());
-#endif
-
-    SkPdfGraphicsStateDictionary* gs = NULL;
-    PodofoMapper::map(*value, &gs);
-
-    // TODO(edisonn): now load all those properties in graphic state.
-    if (gs == NULL) {
-        return kIgnoreError_PdfResult;
-    }
-
-    if (gs->has_CA()) {
-        pdfContext->fGraphicsState.fStroking.fOpacity = gs->CA();
-    }
-
-    if (gs->has_ca()) {
-        pdfContext->fGraphicsState.fNonStroking.fOpacity = gs->ca();
-    }
-
-    if (gs->has_LW()) {
-        pdfContext->fGraphicsState.fLineWidth = gs->LW();
-    }
-
-
-
-    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->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->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->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->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->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
-
-    return kNYI_PdfResult;
-}
-
-//wx wy d0
-PdfResult PdfOp_d0(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    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->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->fObjectStack.pop();
-
-    return kNYI_PdfResult;
-}
-
-//name Do
-PdfResult PdfOp_Do(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    std::string name = pdfContext->fObjectStack.top()->asName()->value();    pdfContext->fObjectStack.pop();
-
-    SkPdfDictionary* xObject =  pdfContext->fGraphicsState.fResources->XObject();
-
-    if (xObject == NULL) {
-#ifdef PDF_TRACE
-        printf("XObject is NULL!\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());
-#endif
-
-    return doXObject(pdfContext, canvas, *value);
-}
-
-//tag MP Designate a marked-content point. tag is a name object indicating the role or
-//signiﬁcance of the point.
-PdfResult PdfOp_MP(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    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 signiﬁcance 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->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 signiﬁcance of the sequence.
-PdfResult PdfOp_BMC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    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->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() {
-    static bool gInitialized = false;
-    if (gInitialized) {
-        return;
-    }
-
-    gPdfOps["q"] =      PdfOp_q;
-    gPdfOps["Q"] =      PdfOp_Q;
-    gPdfOps["cm"] =     PdfOp_cm;
-
-    gPdfOps["TD"] =     PdfOp_TD;
-    gPdfOps["Td"] =     PdfOp_Td;
-    gPdfOps["Tm"] =     PdfOp_Tm;
-    gPdfOps["T*"] =     PdfOp_T_star;
-
-    gPdfOps["m"] =      PdfOp_m;
-    gPdfOps["l"] =      PdfOp_l;
-    gPdfOps["c"] =      PdfOp_c;
-    gPdfOps["v"] =      PdfOp_v;
-    gPdfOps["y"] =      PdfOp_y;
-    gPdfOps["h"] =      PdfOp_h;
-    gPdfOps["re"] =     PdfOp_re;
-
-    gPdfOps["S"] =      PdfOp_S;
-    gPdfOps["s"] =      PdfOp_s;
-    gPdfOps["f"] =      PdfOp_f;
-    gPdfOps["F"] =      PdfOp_F;
-    gPdfOps["f*"] =     PdfOp_f_star;
-    gPdfOps["B"] =      PdfOp_B;
-    gPdfOps["B*"] =     PdfOp_B_star;
-    gPdfOps["b"] =      PdfOp_b;
-    gPdfOps["b*"] =     PdfOp_b_star;
-    gPdfOps["n"] =      PdfOp_n;
-
-    gPdfOps["BT"] =     PdfOp_BT;
-    gPdfOps["ET"] =     PdfOp_ET;
-
-    gPdfOps["Tj"] =     PdfOp_Tj;
-    gPdfOps["'"] =      PdfOp_quote;
-    gPdfOps["\""] =     PdfOp_doublequote;
-    gPdfOps["TJ"] =     PdfOp_TJ;
-
-    gPdfOps["CS"] =     PdfOp_CS;
-    gPdfOps["cs"] =     PdfOp_cs;
-    gPdfOps["SC"] =     PdfOp_SC;
-    gPdfOps["SCN"] =    PdfOp_SCN;
-    gPdfOps["sc"] =     PdfOp_sc;
-    gPdfOps["scn"] =    PdfOp_scn;
-    gPdfOps["G"] =      PdfOp_G;
-    gPdfOps["g"] =      PdfOp_g;
-    gPdfOps["RG"] =     PdfOp_RG;
-    gPdfOps["rg"] =     PdfOp_rg;
-    gPdfOps["K"] =      PdfOp_K;
-    gPdfOps["k"] =      PdfOp_k;
-
-    gPdfOps["W"] =      PdfOp_W;
-    gPdfOps["W*"] =     PdfOp_W_star;
-
-    gPdfOps["BX"] =     PdfOp_BX;
-    gPdfOps["EX"] =     PdfOp_EX;
-
-    gPdfOps["BI"] =     PdfOp_BI;
-    gPdfOps["ID"] =     PdfOp_ID;
-    gPdfOps["EI"] =     PdfOp_EI;
-
-    gPdfOps["w"] =      PdfOp_w;
-    gPdfOps["J"] =      PdfOp_J;
-    gPdfOps["j"] =      PdfOp_j;
-    gPdfOps["M"] =      PdfOp_M;
-    gPdfOps["d"] =      PdfOp_d;
-    gPdfOps["ri"] =     PdfOp_ri;
-    gPdfOps["i"] =      PdfOp_i;
-    gPdfOps["gs"] =     PdfOp_gs;
-
-    gPdfOps["Tc"] =     PdfOp_Tc;
-    gPdfOps["Tw"] =     PdfOp_Tw;
-    gPdfOps["Tz"] =     PdfOp_Tz;
-    gPdfOps["TL"] =     PdfOp_TL;
-    gPdfOps["Tf"] =     PdfOp_Tf;
-    gPdfOps["Tr"] =     PdfOp_Tr;
-    gPdfOps["Ts"] =     PdfOp_Ts;
-
-    gPdfOps["d0"] =     PdfOp_d0;
-    gPdfOps["d1"] =     PdfOp_d1;
-
-    gPdfOps["sh"] =     PdfOp_sh;
-
-    gPdfOps["Do"] =     PdfOp_Do;
-
-    gPdfOps["MP"] =     PdfOp_MP;
-    gPdfOps["DP"] =     PdfOp_DP;
-    gPdfOps["BMC"] =    PdfOp_BMC;
-    gPdfOps["BDC"] =    PdfOp_BDC;
-    gPdfOps["EMC"] =    PdfOp_EMC;
-
-    gInitialized = true;
-}
-
-void reportPdfRenderStats() {
-    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.fType == kKeyword_TokenType)
-    {
-        // TODO(edisonn): log trace flag (verbose, error, info, warning, ...)
-        PdfOperatorRenderer pdfOperatorRenderer = gPdfOps[token.fKeyword];
-        if (pdfOperatorRenderer) {
-            // caller, main work is done by pdfOperatorRenderer(...)
-            PdfTokenLooper* childLooper = NULL;
-            gRenderStats[pdfOperatorRenderer(fPdfContext, fCanvas, &childLooper)][token.fKeyword]++;
-
-            if (childLooper) {
-                childLooper->setUp(this);
-                childLooper->loop();
-                delete childLooper;
-            }
-        } else {
-            gRenderStats[kUnsupported_PdfResult][token.fKeyword]++;
-        }
-    }
-    else if (token.fType == kObject_TokenType)
-    {
-        fPdfContext->fObjectStack.push( token.fObject );
-    }
-    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.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") == 0) {
-            PdfTokenLooper* looper = new PdfCompatibilitySectionLooper();
-            looper->setUp(this);
-            looper->loop();
-        } else {
-            if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "EI") == 0) {
-                done();
-                return;
-            }
-
-            consumeToken(token);
-        }
-    }
-    // TODO(edisonn): report error/warning, EOF without EI.
-}
-
-PdfResult PdfInlineImageLooper::done() {
-
-    // TODO(edisonn): long to short names
-    // TODO(edisonn): set properties in a map
-    // TODO(edisonn): extract bitmap stream, check if PoDoFo has public utilities to uncompress
-    // the stream.
-
-    SkBitmap bitmap;
-    setup_bitmap(&bitmap, 50, 50, SK_ColorRED);
-
-    // TODO(edisonn): matrix use.
-    // Draw dummy red square, to show the prezence of the inline image.
-    fCanvas->drawBitmap(bitmap,
-                       SkDoubleToScalar(0),
-                       SkDoubleToScalar(0),
-                       NULL);
-    return kNYI_PdfResult;
-}
-
-PdfResult PdfCompatibilitySectionLooper::consumeToken(PdfToken& token) {
-    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.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") == 0) {
-            PdfTokenLooper* looper = new PdfCompatibilitySectionLooper();
-            looper->setUp(this);
-            looper->loop();
-            delete looper;
-        } else {
-            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;
-
-        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.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", 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 * (int)SkScalarToDouble(rect.width()), 3 * (int)SkScalarToDouble(rect.height()));
-#else
-                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);
-
-                PdfContext pdfContext(&doc);
-                pdfContext.fOriginalMatrix = SkMatrix::I();
-                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 = 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
-                SkPoint skiaSpace[4] = {SkPoint::Make(w+z, h+h), SkPoint::Make(w+w, h+h), SkPoint::Make(w+w, h+z), SkPoint::Make(w+z, h+z)};
-#else
-                SkPoint skiaSpace[4] = {SkPoint::Make(z, h), SkPoint::Make(w, h), SkPoint::Make(w, z), SkPoint::Make(z, z)};
-#endif
-                //SkPoint pdfSpace[2] = {SkPoint::Make(z, z), SkPoint::Make(w, h)};
-                //SkPoint skiaSpace[2] = {SkPoint::Make(w, z), SkPoint::Make(z, h)};
-
-                //SkPoint pdfSpace[2] = {SkPoint::Make(z, z), SkPoint::Make(z, h)};
-                //SkPoint skiaSpace[2] = {SkPoint::Make(z, h), SkPoint::Make(z, z)};
-
-                //SkPoint pdfSpace[3] = {SkPoint::Make(z, z), SkPoint::Make(z, h), SkPoint::Make(w, h)};
-                //SkPoint skiaSpace[3] = {SkPoint::Make(z, h), SkPoint::Make(z, z), SkPoint::Make(w, 0)};
-
-                SkAssertResult(pdfContext.fOriginalMatrix.setPolyToPoly(pdfSpace, skiaSpace, 4));
-                SkTraceMatrix(pdfContext.fOriginalMatrix, "Original matrix");
-
-
-                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);
-                looper.loop();
-
-                delete tokenizer;
-
-                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;
-        }
-    }
-    catch( PdfError & e )
-    {
-        std::cout << "ERROR: PDF can't be parsed!" << inputFileName.c_str() << std::endl;
-        return false;
-    }
-
-    return true;
-  }
-  bool write(void*) const { return false; }
-};
-
-
-
 /**
  * Given list of directories and files to use as input, expects to find .pdf
  * files and it will convert them to .png files writing them in the same directory
diff --git a/experimental/PdfViewer/spec2def.py b/experimental/PdfViewer/spec2def.py
index 6bebd87..dc78223 100644
--- a/experimental/PdfViewer/spec2def.py
+++ b/experimental/PdfViewer/spec2def.py
@@ -621,7 +621,7 @@
 
   print 'def addDictionaryTypesTo(knowTypes):'  
   for e in tableToClassName:
-    print('  knowTypes[\'' + tableToClassName[e][0] + '\'] = [\'SkPdf' + tableToClassName[e][0] + '*\', \'DictionaryFromDictionary2\', datatypes.CppNull(), \'ret->podofo()->GetDataType() == ePdfDataType_Dictionary\']')
+    print('  knowTypes[\'' + tableToClassName[e][0] + '\'] = [\'SkPdf' + tableToClassName[e][0] + '*\', \'' + tableToClassName[e][0] + 'FromDictionary\', datatypes.CppNull(), \'ret->podofo()->GetDataType() == ePdfDataType_Dictionary\']')
   print
   print
 
diff --git a/gyp/pdfviewer.gyp b/gyp/pdfviewer.gyp
index b8e605f..967002c 100644
--- a/gyp/pdfviewer.gyp
+++ b/gyp/pdfviewer.gyp
@@ -12,15 +12,19 @@
   ],
   'targets': [
     {
-      'target_name': 'pdfviewer',
-      'type': 'executable',
+      'target_name': 'libpdfviewer',
+      'type': 'static_library',
       'cflags': ['-fexceptions'],
       'cflags_cc': ['-fexceptions'],
       'cflags!': [ '-fno-exceptions' ],
       'cflags_cc!': [ '-fno-exceptions' ],
       'sources': [
-        '../experimental/PdfViewer/pdf_viewer_main.cpp',
-        #'../experimental/PdfViewer/SkPdfFont.cpp',
+        '../experimental/PdfViewer/SkPdfBasics.cpp',
+        '../experimental/PdfViewer/SkPdfFont.cpp',
+        '../experimental/PdfViewer/SkPdfParser.cpp',
+        '../experimental/PdfViewer/SkPdfUtils.cpp',
+        '../experimental/PdfViewer/autogen/SkPdfPodofoMapper_autogen.cpp',
+        '../experimental/PdfViewer/autogen/SkPdfHeaders_autogen.cpp',
       ],
       'include_dirs': [
         '../third_party/externals/podofo/src/base',
@@ -47,21 +51,30 @@
         'BUILDING_PODOFO',
       ],
     },
-  ],
-  'conditions': [
-    ['skia_os == "win"',
-      {
-        'targets': [
-          {
-            'target_name': 'win_lcid',
-            'type': 'executable',
-            'sources': [
-              '../tools/win_lcid.cpp',
-            ],
-          },
-        ],
-      },
-    ],
+    {
+      'target_name': 'pdfviewer',
+      'type': 'executable',
+      'cflags': ['-fexceptions'],
+      'cflags_cc': ['-fexceptions'],
+      'cflags!': [ '-fno-exceptions' ],
+      'cflags_cc!': [ '-fno-exceptions' ],
+      'sources': [
+        '../experimental/PdfViewer/pdf_viewer_main.cpp',
+      ],
+      'include_dirs': [
+        '../third_party/externals/podofo/src/base',
+        '../third_party/externals/podofo/src',
+        '../third_party/externals/podofo',
+        '../tools',
+        '../experimental/PdfViewer',
+        '../experimental/PdfViewer/autogen',
+      ],
+      'dependencies': [
+        'core.gyp:core',
+        'images.gyp:images',
+        'libpdfviewer',
+      ],
+    },
   ],
 }