(upload draf code for backup) pdfviewer: improve memory, son't allocate extra buffers, and put the …

experimental/PdfViewer/SkPdfRenderer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkDevice.h"
 #include "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 "SkTDict.h"
 
 #include "SkPdfBasics.h"
 #include "SkPdfNativeTokenizer.h"
-
-#include <iostream>
 #include <cstdio>
 #include <stack>
 #include <set>
 
 extern "C" PdfContext* gPdfContext;
 extern "C" SkBitmap* gDumpBitmap;
 extern "C" SkCanvas* gDumpCanvas;
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
@@ skipping 37 matching lines @@
  * - 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;
 
+NotOwnedString strings_DeviceRGB;
+NotOwnedString strings_DeviceCMYK;
 
+class StringsInit {
+public:
+    StringsInit() {
+        NotOwnedString::init(&strings_DeviceRGB, "DeviceRGB");
+        NotOwnedString::init(&strings_DeviceCMYK, "DeviceCMYK");
+    }
+};
+
+StringsInit gStringsInit;
 
 // TODO(edisonn): Document PdfTokenLooper and subclasses.
 class PdfTokenLooper {
 protected:
     PdfTokenLooper* fParent;
     SkPdfNativeTokenizer* fTokenizer;
     PdfContext* fPdfContext;
     SkCanvas* fCanvas;
 
 public:
@@ skipping 51 matching lines @@
 
 // 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 ...
-static int GetColorSpaceComponents(const std::string& colorSpace) {
-    if (colorSpace == "DeviceCMYK") {
+static int GetColorSpaceComponents(NotOwnedString& colorSpace) {
+    if (colorSpace.equals("DeviceCMYK")) {
         return 4;
-    } else if (colorSpace == "DeviceGray" ||
-            colorSpace == "CalGray" ||
-            colorSpace == "Indexed") {
+    } else if (colorSpace.equals("DeviceGray") ||
+            colorSpace.equals("CalGray") ||
+            colorSpace.equals("Indexed")) {
         return 1;
-    } else if (colorSpace == "DeviceRGB" ||
-            colorSpace == "CalRGB" ||
-            colorSpace == "Lab") {
+    } else if (colorSpace.equals("DeviceRGB") ||
+            colorSpace.equals("CalRGB") ||
+            colorSpace.equals("Lab")) {
         return 3;
     } else {
         return 0;
     }
 }
 
 SkMatrix SkMatrixFromPdfMatrix(double array[6]) {
     SkMatrix matrix;
     matrix.setAll(SkDoubleToScalar(array[0]),
                   SkDoubleToScalar(array[2]),
@@ skipping 137 matching lines @@
     }
 #endif
 
     return ret;
 }
 
 
 
 typedef PdfResult (*PdfOperatorRenderer)(PdfContext*, SkCanvas*, PdfTokenLooper**);
 
-map<std::string, PdfOperatorRenderer> gPdfOps;
+SkTDict<PdfOperatorRenderer> gPdfOps(100);
 
-map<std::string, int> gRenderStats[kCount_PdfResult];
+
+template <typename T> class SkTDictWithDefaultConstructor : public SkTDict<T> {
+public:
+    SkTDictWithDefaultConstructor() : SkTDict<T>(10) {}
+};
+
+SkTDictWithDefaultConstructor<int> gRenderStats[kCount_PdfResult];
 
 const char* gRenderStatsNames[kCount_PdfResult] = {
     "Success",
     "Partially implemented",
     "Not yet implemented",
     "Ignore Error",
     "Error",
     "Unsupported/Unknown"
 };
 
@@ skipping 79 matching lines @@
     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;
 }
 
-static SkBitmap transferImageStreamToBitmap(unsigned char* uncompressedStream, size_t uncompressedStreamLength,
+static SkBitmap transferImageStreamToBitmap(const unsigned char* uncompressedStream, size_t 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
 
     // TODO(edisonn): assume start of lines are aligned at 32 bits?
     // Is there a faster way to load the uncompressed stream into a bitmap?
@@ skipping 68 matching lines @@
 
     if (imageMask) {
         if (bpc != 0 && bpc != 1) {
             // TODO(edisonn): report warning to be used in testing.
             return SkBitmap();
         }
         bpc = 1;
     }
 */
 
-    unsigned char* uncompressedStream = NULL;
+    const unsigned char* uncompressedStream = NULL;
     size_t uncompressedStreamLength = 0;
 
     SkPdfStream* stream = (SkPdfStream*)image;
 
-    if (!stream || !stream->GetFilteredStreamRef(&uncompressedStream, &uncompressedStreamLength, pdfContext->fPdfDoc->allocator()) ||
+    if (!stream || !stream->GetFilteredStreamRef(&uncompressedStream, &uncompressedStreamLength) ||
             uncompressedStream == NULL || uncompressedStreamLength == 0) {
         // TODO(edisonn): report warning to be used in testing.
         return SkBitmap();
     }
 
     SkPdfStreamCommonDictionary* streamDict = (SkPdfStreamCommonDictionary*)stream;
 
     if (streamDict->has_Filter() && ((streamDict->isFilterAName(NULL) &&
                                           streamDict->getFilterAsName(NULL) == "DCTDecode") ||
                                      (streamDict->isFilterAArray(NULL) &&
@@ skipping 120 matching lines @@
 
     if (skobj->has_BBox()) {
         canvas->clipRect(skobj->BBox(pdfContext->fPdfDoc), 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.
 
     SkPdfStream* stream = (SkPdfStream*)skobj;
 
-    SkPdfNativeTokenizer* tokenizer = pdfContext->fPdfDoc->tokenizerOfStream(stream);
+    SkPdfNativeTokenizer* tokenizer =
+            pdfContext->fPdfDoc->tokenizerOfStream(stream, pdfContext->fTmpPageAllocator);
     if (tokenizer != NULL) {
         PdfMainLooper looper(NULL, tokenizer, pdfContext, canvas);
         looper.loop();
         delete tokenizer;
     }
 
     // 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);
@@ skipping 27 matching lines @@
 
     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.
 
     SkPdfStream* stream = (SkPdfStream*)skobj;
 
-    SkPdfNativeTokenizer* tokenizer = pdfContext->fPdfDoc->tokenizerOfStream(stream);
+    SkPdfNativeTokenizer* tokenizer =
+            pdfContext->fPdfDoc->tokenizerOfStream(stream, pdfContext->fTmpPageAllocator);
     if (tokenizer != NULL) {
         PdfMainLooper looper(NULL, tokenizer, pdfContext, canvas);
         looper.loop();
         delete tokenizer;
     }
 
     // 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);
@@ skipping 428 matching lines @@
     return kPartial_PdfResult;
 }
 
 //font size Tf Set the text font, Tf
 //, to font and the text font size, Tfs, to size. font is the name of a
 //font resource in the Fontsubdictionary of the current resource dictionary; size is
 //a number representing a scale factor. There is no initial value for either font or
 //size; they must be specified explicitly using Tf before any text is shown.
 static PdfResult PdfOp_Tf(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     pdfContext->fGraphicsState.fCurFontSize = pdfContext->fObjectStack.top()->numberValue();     pdfContext->fObjectStack.pop();
-    const char* fontName = pdfContext->fObjectStack.top()->nameValue();                           pdfContext->fObjectStack.pop();
+    SkPdfObject* fontName = pdfContext->fObjectStack.top();                           pdfContext->fObjectStack.pop();
 
 #ifdef PDF_TRACE
-    printf("font name: %s\n", fontName);
+    printf("font name: %s\n", fontName->nameValue2().c_str());
 #endif
 
     if (pdfContext->fGraphicsState.fResources->Font(pdfContext->fPdfDoc)) {
         SkPdfObject* objFont = pdfContext->fGraphicsState.fResources->Font(pdfContext->fPdfDoc)->get(fontName);
         objFont = pdfContext->fPdfDoc->resolveReference(objFont);
         if (kNone_SkPdfObjectType == pdfContext->fPdfDoc->mapper()->mapFontDictionary(objFont)) {
             // TODO(edisonn): try to recover and draw it any way?
             return kIgnoreError_PdfResult;
         }
         SkPdfFontDictionary* fd = (SkPdfFontDictionary*)objFont;
@@ skipping 88 matching lines @@
                           SkDoubleToScalar(0),
                           SkDoubleToScalar(1));
 
             pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
         }
     }
     return kPartial_PdfResult;  // TODO(edisonn): Implement fully DrawText before returing OK.
 }
 
 static PdfResult PdfOp_CS_cs(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
-    colorOperator->fColorSpace = pdfContext->fObjectStack.top()->nameValue();    pdfContext->fObjectStack.pop();
+    colorOperator->fColorSpace = pdfContext->fObjectStack.top()->strRef();    pdfContext->fObjectStack.pop();
     return kOK_PdfResult;
 }
 
 static PdfResult PdfOp_CS(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
 static PdfResult PdfOp_cs(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
 }
 
 static PdfResult PdfOp_SC_sc(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
     double c[4];
 //    int64_t v[4];
 
     int n = GetColorSpaceComponents(colorOperator->fColorSpace);
 
     bool doubles = true;
-    if (strcmp(colorOperator->fColorSpace, "Indexed") == 0) {
+    if (colorOperator->fColorSpace.equals("Indexed")) {
         doubles = false;
     }
 
 #ifdef PDF_TRACE
-    printf("color space = %s, N = %i\n", colorOperator->fColorSpace, n);
+    printf("color space = %s, N = %i\n", colorOperator->fColorSpace.fBuffer, n);
 #endif
 
     for (int i = n - 1; i >= 0 ; i--) {
         if (doubles) {
             c[i] = pdfContext->fObjectStack.top()->numberValue();         pdfContext->fObjectStack.pop();
 //        } else {
 //            v[i] = pdfContext->fObjectStack.top()->intValue();        pdfContext->fObjectStack.pop();
         }
     }
 
     // TODO(edisonn): Now, set that color. Only DeviceRGB supported.
     // TODO(edisonn): do possible field values to enum at parsing time!
     // TODO(edisonn): support also abreviations /DeviceRGB == /RGB
-    if (strcmp(colorOperator->fColorSpace, "DeviceRGB") == 0 || strcmp(colorOperator->fColorSpace, "RGB") == 0) {
+    if (colorOperator->fColorSpace.equals("DeviceRGB") || colorOperator->fColorSpace.equals("RGB")) {
         colorOperator->setRGBColor(SkColorSetRGB(255*c[0], 255*c[1], 255*c[2]));
     }
     return kPartial_PdfResult;
 }
 
 static PdfResult PdfOp_SC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
 static PdfResult PdfOp_sc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
@@ skipping 32 matching lines @@
 
 static PdfResult PdfOp_g(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
 }
 
 static PdfResult PdfOp_RG_rg(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
     double b = pdfContext->fObjectStack.top()->numberValue();     pdfContext->fObjectStack.pop();
     double g = pdfContext->fObjectStack.top()->numberValue();     pdfContext->fObjectStack.pop();
     double r = pdfContext->fObjectStack.top()->numberValue();     pdfContext->fObjectStack.pop();
 
-    colorOperator->fColorSpace = "DeviceRGB";
+    colorOperator->fColorSpace = strings_DeviceRGB;
     colorOperator->setRGBColor(SkColorSetRGB(255*r, 255*g, 255*b));
     return kOK_PdfResult;
 }
 
 static PdfResult PdfOp_RG(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
 static PdfResult PdfOp_rg(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
 }
 
 static PdfResult PdfOp_K_k(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) {
     // TODO(edisonn): spec has some rules about overprint, implement them.
     /*double k = */pdfContext->fObjectStack.top()->numberValue();     pdfContext->fObjectStack.pop();
     /*double y = */pdfContext->fObjectStack.top()->numberValue();     pdfContext->fObjectStack.pop();
     /*double m = */pdfContext->fObjectStack.top()->numberValue();     pdfContext->fObjectStack.pop();
     /*double c = */pdfContext->fObjectStack.top()->numberValue();     pdfContext->fObjectStack.pop();
 
-    colorOperator->fColorSpace = "DeviceCMYK";
+    colorOperator->fColorSpace = strings_DeviceCMYK;
     // TODO(edisonn): Set color.
     return kNYI_PdfResult;
 }
 
 static PdfResult PdfOp_K(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
 static PdfResult PdfOp_k(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
@@ skipping 109 matching lines @@
 //fies the output device’s default flatness tolerance.
 static PdfResult PdfOp_i(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //dictName gs (PDF 1.2) Set the specified parameters in the graphics state. dictName is
 //the name of a graphics state parameter dictionary in the ExtGState subdictionary of the current resource dictionary (see the next section).
 static PdfResult PdfOp_gs(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    const char* name = pdfContext->fObjectStack.top()->nameValue();    pdfContext->fObjectStack.pop();
+    SkPdfObject* name = pdfContext->fObjectStack.top();    pdfContext->fObjectStack.pop();
 
 #ifdef PDF_TRACE
     std::string str;
 #endif
 
     //Next, get the ExtGState Dictionary from the Resource Dictionary:
     SkPdfDictionary* extGStateDictionary = pdfContext->fGraphicsState.fResources->ExtGState(pdfContext->fPdfDoc);
 
     if (extGStateDictionary == NULL) {
 #ifdef PDF_TRACE
@@ skipping 97 matching lines @@
 
 //name sh
 static PdfResult PdfOp_sh(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     pdfContext->fObjectStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //name Do
 static PdfResult PdfOp_Do(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
-    const char* name = pdfContext->fObjectStack.top()->nameValue();    pdfContext->fObjectStack.pop();
+    SkPdfObject* name = pdfContext->fObjectStack.top();    pdfContext->fObjectStack.pop();
 
     SkPdfDictionary* xObject =  pdfContext->fGraphicsState.fResources->XObject(pdfContext->fPdfDoc);
 
     if (xObject == NULL) {
 #ifdef PDF_TRACE
         printf("XObject is NULL!\n");
 #endif
         return kIgnoreError_PdfResult;
     }
 
@@ skipping 50 matching lines @@
 static PdfResult PdfOp_EMC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     return kNYI_PdfResult;
 }
 
 static void initPdfOperatorRenderes() {
     static bool gInitialized = false;
     if (gInitialized) {
         return;
     }
 
-    gPdfOps["q"] =      PdfOp_q;
-    gPdfOps["Q"] =      PdfOp_Q;
-    gPdfOps["cm"] =     PdfOp_cm;
+    gPdfOps.set("q", PdfOp_q);
+    gPdfOps.set("Q", PdfOp_Q);
+    gPdfOps.set("cm", PdfOp_cm);
 
-    gPdfOps["TD"] =     PdfOp_TD;
-    gPdfOps["Td"] =     PdfOp_Td;
-    gPdfOps["Tm"] =     PdfOp_Tm;
-    gPdfOps["T*"] =     PdfOp_T_star;
+    gPdfOps.set("TD", PdfOp_TD);
+    gPdfOps.set("Td", PdfOp_Td);
+    gPdfOps.set("Tm", PdfOp_Tm);
+    gPdfOps.set("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.set("m", PdfOp_m);
+    gPdfOps.set("l", PdfOp_l);
+    gPdfOps.set("c", PdfOp_c);
+    gPdfOps.set("v", PdfOp_v);
+    gPdfOps.set("y", PdfOp_y);
+    gPdfOps.set("h", PdfOp_h);
+    gPdfOps.set("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.set("S", PdfOp_S);
+    gPdfOps.set("s", PdfOp_s);
+    gPdfOps.set("f", PdfOp_f);
+    gPdfOps.set("F", PdfOp_F);
+    gPdfOps.set("f*", PdfOp_f_star);
+    gPdfOps.set("B", PdfOp_B);
+    gPdfOps.set("B*", PdfOp_B_star);
+    gPdfOps.set("b", PdfOp_b);
+    gPdfOps.set("b*", PdfOp_b_star);
+    gPdfOps.set("n", PdfOp_n);
 
-    gPdfOps["BT"] =     PdfOp_BT;
-    gPdfOps["ET"] =     PdfOp_ET;
+    gPdfOps.set("BT", PdfOp_BT);
+    gPdfOps.set("ET", PdfOp_ET);
 
-    gPdfOps["Tj"] =     PdfOp_Tj;
-    gPdfOps["'"] =      PdfOp_quote;
-    gPdfOps["\""] =     PdfOp_doublequote;
-    gPdfOps["TJ"] =     PdfOp_TJ;
+    gPdfOps.set("Tj", PdfOp_Tj);
+    gPdfOps.set("'", PdfOp_quote);
+    gPdfOps.set("\"", PdfOp_doublequote);
+    gPdfOps.set("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.set("CS", PdfOp_CS);
+    gPdfOps.set("cs", PdfOp_cs);
+    gPdfOps.set("SC", PdfOp_SC);
+    gPdfOps.set("SCN", PdfOp_SCN);
+    gPdfOps.set("sc", PdfOp_sc);
+    gPdfOps.set("scn", PdfOp_scn);
+    gPdfOps.set("G", PdfOp_G);
+    gPdfOps.set("g", PdfOp_g);
+    gPdfOps.set("RG", PdfOp_RG);
+    gPdfOps.set("rg", PdfOp_rg);
+    gPdfOps.set("K", PdfOp_K);
+    gPdfOps.set("k", PdfOp_k);
 
-    gPdfOps["W"] =      PdfOp_W;
-    gPdfOps["W*"] =     PdfOp_W_star;
+    gPdfOps.set("W", PdfOp_W);
+    gPdfOps.set("W*", PdfOp_W_star);
 
-    gPdfOps["BX"] =     PdfOp_BX;
-    gPdfOps["EX"] =     PdfOp_EX;
+    gPdfOps.set("BX", PdfOp_BX);
+    gPdfOps.set("EX", PdfOp_EX);
 
-    gPdfOps["BI"] =     PdfOp_BI;
-    gPdfOps["ID"] =     PdfOp_ID;
-    gPdfOps["EI"] =     PdfOp_EI;
+    gPdfOps.set("BI", PdfOp_BI);
+    gPdfOps.set("ID", PdfOp_ID);
+    gPdfOps.set("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.set("w", PdfOp_w);
+    gPdfOps.set("J", PdfOp_J);
+    gPdfOps.set("j", PdfOp_j);
+    gPdfOps.set("M", PdfOp_M);
+    gPdfOps.set("d", PdfOp_d);
+    gPdfOps.set("ri", PdfOp_ri);
+    gPdfOps.set("i", PdfOp_i);
+    gPdfOps.set("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.set("Tc", PdfOp_Tc);
+    gPdfOps.set("Tw", PdfOp_Tw);
+    gPdfOps.set("Tz", PdfOp_Tz);
+    gPdfOps.set("TL", PdfOp_TL);
+    gPdfOps.set("Tf", PdfOp_Tf);
+    gPdfOps.set("Tr", PdfOp_Tr);
+    gPdfOps.set("Ts", PdfOp_Ts);
 
-    gPdfOps["d0"] =     PdfOp_d0;
-    gPdfOps["d1"] =     PdfOp_d1;
+    gPdfOps.set("d0", PdfOp_d0);
+    gPdfOps.set("d1", PdfOp_d1);
 
-    gPdfOps["sh"] =     PdfOp_sh;
+    gPdfOps.set("sh", PdfOp_sh);
 
-    gPdfOps["Do"] =     PdfOp_Do;
+    gPdfOps.set("Do", PdfOp_Do);
 
-    gPdfOps["MP"] =     PdfOp_MP;
-    gPdfOps["DP"] =     PdfOp_DP;
-    gPdfOps["BMC"] =    PdfOp_BMC;
-    gPdfOps["BDC"] =    PdfOp_BDC;
-    gPdfOps["EMC"] =    PdfOp_EMC;
+    gPdfOps.set("MP", PdfOp_MP);
+    gPdfOps.set("DP", PdfOp_DP);
+    gPdfOps.set("BMC", PdfOp_BMC);
+    gPdfOps.set("BDC", PdfOp_BDC);
+    gPdfOps.set("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);
+        SkTDict<int>::Iter iter(gRenderStats[i]);
+        const char* key;
+        int value = 0;
+        while ((key = iter.next(&value)) != NULL) {
+            printf("%s: %s -> count %i\n", gRenderStatsNames[i], key, value);
         }
     }
 }
 
 PdfResult PdfMainLooper::consumeToken(PdfToken& token) {
     char keyword[256];
 
     if (token.fType == kKeyword_TokenType && token.fKeywordLength < 256)
     {
         strncpy(keyword, token.fKeyword, token.fKeywordLength);
         keyword[token.fKeywordLength] = '\0';
         // TODO(edisonn): log trace flag (verbose, error, info, warning, ...)
-        PdfOperatorRenderer pdfOperatorRenderer = gPdfOps[keyword];
-        if (pdfOperatorRenderer) {
+        PdfOperatorRenderer pdfOperatorRenderer = NULL;
+        if (gPdfOps.find(keyword, &pdfOperatorRenderer) && pdfOperatorRenderer) {
             // caller, main work is done by pdfOperatorRenderer(...)
             PdfTokenLooper* childLooper = NULL;
-            gRenderStats[pdfOperatorRenderer(fPdfContext, fCanvas, &childLooper)][keyword]++;
+            PdfResult result = pdfOperatorRenderer(fPdfContext, fCanvas, &childLooper);
+
+            int cnt = 0;
+            gRenderStats[result].find(keyword, &cnt);
+            gRenderStats[result].set(keyword, cnt + 1);
 
             if (childLooper) {
                 childLooper->setUp(this);
                 childLooper->loop();
                 delete childLooper;
             }
         } else {
-            gRenderStats[kUnsupported_PdfResult][keyword]++;
+            int cnt = 0;
+            gRenderStats[kUnsupported_PdfResult].find(keyword, &cnt);
+            gRenderStats[kUnsupported_PdfResult].set(keyword, cnt + 1);
         }
     }
     else if (token.fType == kObject_TokenType)
     {
         fPdfContext->fObjectStack.push( token.fObject );
     }
     else {
         // TODO(edisonn): deine or use assert not reached
         return kIgnoreError_PdfResult;
     }
@@ skipping 74 matching lines @@
 
 bool SkPdfRenderer::renderPage(int page, SkCanvas* canvas, const SkRect& dst) const {
     if (!fPdfDoc) {
         return false;
     }
 
     if (page < 0 || page >= pages()) {
         return false;
     }
 
-    SkPdfNativeTokenizer* tokenizer = fPdfDoc->tokenizerOfPage(page);
+    PdfContext pdfContext(fPdfDoc);
 
-    PdfContext pdfContext(fPdfDoc);
+    SkPdfNativeTokenizer* tokenizer = fPdfDoc->tokenizerOfPage(page, pdfContext.fTmpPageAllocator);
+
     pdfContext.fOriginalMatrix = SkMatrix::I();
     pdfContext.fGraphicsState.fResources = fPdfDoc->pageResources(page);
 
     gPdfContext = &pdfContext;
 
     // TODO(edisonn): get matrix stuff right.
     SkScalar z = SkIntToScalar(0);
     SkScalar w = dst.width();
     SkScalar h = dst.height();
 
@@ skipping 73 matching lines @@
 }
 
 SkRect SkPdfRenderer::MediaBox(int page) const {
     SkASSERT(fPdfDoc);
     return fPdfDoc->MediaBox(page);
 }
 
 size_t SkPdfRenderer::bytesUsed() const {
     return fPdfDoc ? fPdfDoc->bytesUsed() : 0;
 }