Simplify SkPdfTokenLooper behavior.

experimental/PdfViewer/src/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 "SkPdfRenderer.h"
 
 #include "SkBitmapDevice.h"
@@ skipping 190 matching lines @@
         NotOwnedString::init(&strings_DeviceCMYK, "DeviceCMYK");
     }
 };
 
 // TODO(edisonn): this will not work in chrome! Find another solution!
 StringsInit gStringsInit;
 
 // TODO(edisonn): Document SkPdfTokenLooper and subclasses.
 class PdfInlineImageLooper : public SkPdfTokenLooper {
 public:
-    PdfInlineImageLooper()
-        : SkPdfTokenLooper(NULL, NULL, NULL, NULL) {}
+    explicit PdfInlineImageLooper(SkPdfTokenLooper* parent)
+        : INHERITED(parent) {}
 
-    virtual SkPdfResult consumeToken(PdfToken& token);
-    virtual void loop();
-    SkPdfResult done();
+    virtual SkPdfResult consumeToken(PdfToken& token) SK_OVERRIDE;
+    virtual void loop() SK_OVERRIDE;
+
+private:
+    typedef SkPdfTokenLooper INHERITED;
 };
 
 class PdfCompatibilitySectionLooper : public SkPdfTokenLooper {
 public:
-    PdfCompatibilitySectionLooper()
-        : SkPdfTokenLooper(NULL, NULL, NULL, NULL) {}
+    explicit PdfCompatibilitySectionLooper(SkPdfTokenLooper* parent)
+        : INHERITED (parent) {}
 
-    virtual SkPdfResult consumeToken(PdfToken& token);
-    virtual void loop();
+    virtual SkPdfResult consumeToken(PdfToken& token) SK_OVERRIDE;
+    virtual void loop() SK_OVERRIDE;
+
+private:
+    typedef SkPdfTokenLooper INHERITED;
 };
 
 // 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);
 }
 
@@ skipping 104 matching lines @@
 //    }
 
     pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
 
     skfont->drawText(decoded, &paint, pdfContext, canvas);
 
     return kOK_SkPdfResult;
 }
 
 // TODO(edisonn): create header files with declarations!
-SkPdfResult PdfOp_q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper);
-SkPdfResult PdfOp_Q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper);
-SkPdfResult PdfOp_Tw(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper);
-SkPdfResult PdfOp_Tc(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper);
+SkPdfResult PdfOp_q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper* parentLooper);
+SkPdfResult PdfOp_Q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper* parentLooper);
+SkPdfResult PdfOp_Tw(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper* parentLooper);
+SkPdfResult PdfOp_Tc(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper* parentLooper);
 
 // TODO(edisonn): perf!!!
 static SkColorTable* getGrayColortable() {
     static SkColorTable* grayColortable = NULL;
     if (grayColortable == NULL) {
         SkPMColor* colors = new SkPMColor[256];
         for (int i = 0 ; i < 256; i++) {
             colors[i] = SkPreMultiplyARGB(255, i, i, i);
         }
         grayColortable = new SkColorTable(colors, 256);
@@ skipping 544 matching lines @@
         canvas->save();
     }
 
     pdfContext->parseStream(stream, canvas);
 
     canvas->restore();
     PdfOp_Q(pdfContext, canvas, NULL);
     return kPartial_SkPdfResult;
 }
 
-SkPdfResult PdfOp_q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+SkPdfResult PdfOp_q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     pdfContext->fStateStack.push(pdfContext->fGraphicsState);
     canvas->save();
     pdfContext->fObjectStack.nest();
     return kOK_SkPdfResult;
 }
 
-SkPdfResult PdfOp_Q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+SkPdfResult PdfOp_Q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     if (pdfContext->fStateStack.count() > 0) {
         pdfContext->fGraphicsState = pdfContext->fStateStack.top();
         pdfContext->fStateStack.pop();
         canvas->restore();
 
         if (pdfContext->fObjectStack.nestingLevel() == 0) {
             SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kStackNestingOverflow_SkPdfIssue,
                         "stack nesting overflow (q/Q)", NULL, pdfContext);
             return kIgnoreError_SkPdfResult;
         } else {
             pdfContext->fObjectStack.unnest();
         }
     } else {
         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kStackOverflow_SkPdfIssue,
                     "stack overflow (q/Q)", NULL, pdfContext);
         return kIgnoreError_SkPdfResult;
     }
 
     return kOK_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_cm(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_cm(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("cm", pdfContext, 6);
     POP_NUMBER(pdfContext, f);
     POP_NUMBER(pdfContext, e);
     POP_NUMBER(pdfContext, d);
     POP_NUMBER(pdfContext, c);
     POP_NUMBER(pdfContext, b);
     POP_NUMBER(pdfContext, a);
     CHECK_PARAMETERS();
     double array[6] = {a, b, c, d, e, f};
 
@@ skipping 20 matching lines @@
     printf("\n");
     SkTraceMatrix(pdfContext->fGraphicsState.fCTM, "cm");
 #endif
 
     return kOK_SkPdfResult;
 }
 
 //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.
-static SkPdfResult PdfOp_TL(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_TL(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("TL", pdfContext, 1);
     POP_NUMBER(pdfContext, ty);
     CHECK_PARAMETERS();
 
     pdfContext->fGraphicsState.fTextLeading = ty;
 
     return kOK_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_Td(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Td(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("Td", pdfContext, 2);
     POP_NUMBER(pdfContext, ty);
     POP_NUMBER(pdfContext, tx);
     CHECK_PARAMETERS();
 
     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_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_TD(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_TD(SkPdfContext* pdfContext, SkCanvas* canvas,
+                            SkPdfTokenLooper* parentLooper) {
     EXPECT_OPERANDS("TD", pdfContext, 2)
     POP_NUMBER(pdfContext, ty);
     POP_NUMBER(pdfContext, tx);
     CHECK_PARAMETERS();
 
     // TODO(edisonn): Create factory methods or constructors so native is hidden
     SkPdfReal* _ty = pdfContext->fPdfDoc->createReal(-ty);
     pdfContext->fObjectStack.push(_ty);
 
-    PdfOp_TL(pdfContext, canvas, looper);
+    PdfOp_TL(pdfContext, canvas, parentLooper);
 
     SkPdfReal* vtx = pdfContext->fPdfDoc->createReal(tx);
     pdfContext->fObjectStack.push(vtx);
 
     SkPdfReal* vty = pdfContext->fPdfDoc->createReal(ty);
     pdfContext->fObjectStack.push(vty);
 
-    SkPdfResult ret = PdfOp_Td(pdfContext, canvas, looper);
+    SkPdfResult ret = PdfOp_Td(pdfContext, canvas, parentLooper);
 
     return ret;
 }
 
-static SkPdfResult PdfOp_Tm(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Tm(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("Tm", pdfContext, 6);
     POP_NUMBER(pdfContext, f);
     POP_NUMBER(pdfContext, e);
     POP_NUMBER(pdfContext, d);
     POP_NUMBER(pdfContext, c);
     POP_NUMBER(pdfContext, b);
     POP_NUMBER(pdfContext, a);
     CHECK_PARAMETERS();
 
     double array[6];
@@ skipping 15 matching lines @@
     pdfContext->fGraphicsState.fMatrixTm = matrix;
     pdfContext->fGraphicsState.fMatrixTlm = matrix;;
 
     return kPartial_SkPdfResult;
 }
 
 //— 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
 static SkPdfResult PdfOp_T_star(SkPdfContext* pdfContext, SkCanvas* canvas,
-                                SkPdfTokenLooper** looper) {
+                                SkPdfTokenLooper* parentLooper) {
     SkPdfReal* zero = pdfContext->fPdfDoc->createReal(0.0);
     SkPdfReal* tl = pdfContext->fPdfDoc->createReal(pdfContext->fGraphicsState.fTextLeading);
 
     pdfContext->fObjectStack.push(zero);
     pdfContext->fObjectStack.push(tl);
 
-    SkPdfResult ret = PdfOp_Td(pdfContext, canvas, looper);
+    SkPdfResult ret = PdfOp_Td(pdfContext, canvas, parentLooper);
 
     return ret;
 }
 
-static SkPdfResult PdfOp_m(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_m(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     if (pdfContext->fGraphicsState.fPathClosed) {
         pdfContext->fGraphicsState.fPath.reset();
         pdfContext->fGraphicsState.fPathClosed = false;
     }
 
     EXPECT_OPERANDS("m", pdfContext, 2);
     POP_NUMBER(pdfContext, y);
     POP_NUMBER(pdfContext, x);
     CHECK_PARAMETERS();
 
     pdfContext->fGraphicsState.fCurPosY = y;
     pdfContext->fGraphicsState.fCurPosX = x;
 
     pdfContext->fGraphicsState.fPath.moveTo(SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosX),
                                             SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosY));
 
     return kOK_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_l(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_l(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     if (pdfContext->fGraphicsState.fPathClosed) {
         pdfContext->fGraphicsState.fPath.reset();
         pdfContext->fGraphicsState.fPathClosed = false;
     }
 
     EXPECT_OPERANDS("l", pdfContext, 2);
     POP_NUMBER(pdfContext, y);
     POP_NUMBER(pdfContext, x);
     CHECK_PARAMETERS();
 
     pdfContext->fGraphicsState.fCurPosY = y;
     pdfContext->fGraphicsState.fCurPosX = x;
 
     pdfContext->fGraphicsState.fPath.lineTo(SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosX),
                                             SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosY));
 
     return kOK_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_c(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_c(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     if (pdfContext->fGraphicsState.fPathClosed) {
         pdfContext->fGraphicsState.fPath.reset();
         pdfContext->fGraphicsState.fPathClosed = false;
     }
 
     EXPECT_OPERANDS("c", pdfContext, 6);
     POP_NUMBER(pdfContext, y3);
     POP_NUMBER(pdfContext, x3);
     POP_NUMBER(pdfContext, y2);
     POP_NUMBER(pdfContext, x2);
     POP_NUMBER(pdfContext, y1);
     POP_NUMBER(pdfContext, x1);
     CHECK_PARAMETERS();
 
     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_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_v(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_v(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     if (pdfContext->fGraphicsState.fPathClosed) {
         pdfContext->fGraphicsState.fPath.reset();
         pdfContext->fGraphicsState.fPathClosed = false;
     }
 
     EXPECT_OPERANDS("v", pdfContext, 4);
     POP_NUMBER(pdfContext, y3);
     POP_NUMBER(pdfContext, x3);
     POP_NUMBER(pdfContext, y2);
     POP_NUMBER(pdfContext, x2);
     CHECK_PARAMETERS();
 
     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_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_y(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_y(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     if (pdfContext->fGraphicsState.fPathClosed) {
         pdfContext->fGraphicsState.fPath.reset();
         pdfContext->fGraphicsState.fPathClosed = false;
     }
 
     EXPECT_OPERANDS("y", pdfContext, 4);
     POP_NUMBER(pdfContext, y3);
     POP_NUMBER(pdfContext, x3);
     POP_NUMBER(pdfContext, y1);
     POP_NUMBER(pdfContext, x1);
     CHECK_PARAMETERS();
 
     double y2 = pdfContext->fGraphicsState.fCurPosY;
     double x2 = 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_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_re(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_re(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     if (pdfContext->fGraphicsState.fPathClosed) {
         pdfContext->fGraphicsState.fPath.reset();
         pdfContext->fGraphicsState.fPathClosed = false;
     }
 
     EXPECT_OPERANDS("re", pdfContext, 4);
     POP_NUMBER(pdfContext, height);
     POP_NUMBER(pdfContext, width);
     POP_NUMBER(pdfContext, y);
     POP_NUMBER(pdfContext, x);
     CHECK_PARAMETERS();
 
     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_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_h(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_h(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     pdfContext->fGraphicsState.fPath.close();
     return kOK_SkPdfResult;
 }
 
 static SkPdfResult PdfOp_fillAndStroke(SkPdfContext* pdfContext, SkCanvas* canvas,
                                        bool fill, bool stroke, bool close, bool evenOdd) {
     SkPath path = pdfContext->fGraphicsState.fPath;
 
     if (close) {
         path.close();
@@ skipping 129 matching lines @@
 #endif
     }
 
     //pdfContext->fGraphicsState.fClipPath.reset();
     pdfContext->fGraphicsState.fHasClipPathToApply = false;
 
     return kOK_SkPdfResult;
 
 }
 
-static SkPdfResult PdfOp_S(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_S(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_fillAndStroke(pdfContext, canvas, false, true, false, false);
 }
 
-static SkPdfResult PdfOp_s(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_s(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_fillAndStroke(pdfContext, canvas, false, true, true, false);
 }
 
-static SkPdfResult PdfOp_F(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_F(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false);
 }
 
-static SkPdfResult PdfOp_f(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_f(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false);
 }
 
 static SkPdfResult PdfOp_f_star(SkPdfContext* pdfContext, SkCanvas* canvas,
-                                SkPdfTokenLooper** looper) {
+                                SkPdfTokenLooper*) {
     return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, true);
 }
 
-static SkPdfResult PdfOp_B(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_B(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, false);
 }
 
 static SkPdfResult PdfOp_B_star(SkPdfContext* pdfContext, SkCanvas* canvas,
-                                SkPdfTokenLooper** looper) {
+                                SkPdfTokenLooper*) {
     return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, true);
 }
 
-static SkPdfResult PdfOp_b(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_b(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, false);
 }
 
 static SkPdfResult PdfOp_b_star(SkPdfContext* pdfContext, SkCanvas* canvas,
-                                SkPdfTokenLooper** looper) {
+                                SkPdfTokenLooper*) {
     return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, true);
 }
 
-static SkPdfResult PdfOp_n(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_n(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     canvas->setMatrix(pdfContext->fGraphicsState.fCTM);
     if (pdfContext->fGraphicsState.fHasClipPathToApply) {
 #ifndef PDF_DEBUG_NO_CLIPING
         canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kIntersect_Op, true);
 #endif
     }
 
     pdfContext->fGraphicsState.fHasClipPathToApply = false;
 
     pdfContext->fGraphicsState.fPathClosed = true;
 
     return kOK_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_BT(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_BT(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     pdfContext->fGraphicsState.fTextBlock   = true;
     SkMatrix matrix = pdfContext->fGraphicsState.fCTM;
     matrix.preScale(SkDoubleToScalar(1), SkDoubleToScalar(-1));
     pdfContext->fGraphicsState.fMatrixTm = matrix;
     pdfContext->fGraphicsState.fMatrixTlm = matrix;
 
     return kPartial_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_ET(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_ET(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     if (!pdfContext->fGraphicsState.fTextBlock) {
         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, "ET without BT", NULL,
                     pdfContext);
 
         return kIgnoreError_SkPdfResult;
     }
 
     pdfContext->fGraphicsState.fTextBlock = false;
 
     // TODO(edisonn): anything else to be done once we are done with draw text? Like restore stack?
@@ skipping 32 matching lines @@
     }
     pdfContext->fGraphicsState.fCurFontSize = fontSize;
     return kOK_SkPdfResult;
 }
 
 //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 SkPdfResult PdfOp_Tf(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Tf(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("Tf", pdfContext, 2);
     POP_NUMBER(pdfContext, fontSize);
     POP_NAME(pdfContext, fontName);
     CHECK_PARAMETERS();
 
     return skpdfGraphicsStateApplyFontCore(pdfContext, fontName, fontSize);
 }
 
-static SkPdfResult PdfOp_Tj(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Tj(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("Tj", pdfContext, 1);
     POP_STRING(pdfContext, str);
     CHECK_PARAMETERS();
 
     if (!pdfContext->fGraphicsState.fTextBlock) {
         // TODO(edisonn): try to recover and draw it any way?
         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, "Tj without BT", NULL,
                     pdfContext);
         return kIgnoreError_SkPdfResult;
     }
 
     SkPdfResult ret = DrawText(pdfContext, str, canvas);
 
     return ret;
 }
 
 static SkPdfResult PdfOp_quote(SkPdfContext* pdfContext, SkCanvas* canvas,
-                               SkPdfTokenLooper** looper) {
+                               SkPdfTokenLooper* parentLooper) {
     if (!pdfContext->fGraphicsState.fTextBlock) {
         // TODO(edisonn): try to recover and draw it any way?
         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue,
                     "' without BT", NULL, pdfContext);
         return kIgnoreError_SkPdfResult;
     }
 
-    PdfOp_T_star(pdfContext, canvas, looper);
+    PdfOp_T_star(pdfContext, canvas, parentLooper);
     // Do not pop, and push, just transfer the param to Tj
-    return PdfOp_Tj(pdfContext, canvas, looper);
+    return PdfOp_Tj(pdfContext, canvas, parentLooper);
 }
 
 static SkPdfResult PdfOp_doublequote(SkPdfContext* pdfContext, SkCanvas* canvas,
-                                     SkPdfTokenLooper** looper) {
+                                     SkPdfTokenLooper* parentLooper) {
     if (!pdfContext->fGraphicsState.fTextBlock) {
         // TODO(edisonn): try to recover and draw it any way?
         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue,
                     "\" without BT", NULL, pdfContext);
         return kIgnoreError_SkPdfResult;
     }
 
     EXPECT_OPERANDS("\"", pdfContext, 3);
     POP_OBJ(pdfContext, str);
     POP_OBJ(pdfContext, ac);
     POP_OBJ(pdfContext, aw);
     CHECK_PARAMETERS();
 
     pdfContext->fObjectStack.push(aw);
-    PdfOp_Tw(pdfContext, canvas, looper);
+    PdfOp_Tw(pdfContext, canvas, parentLooper);
 
     pdfContext->fObjectStack.push(ac);
-    PdfOp_Tc(pdfContext, canvas, looper);
+    PdfOp_Tc(pdfContext, canvas, parentLooper);
 
     pdfContext->fObjectStack.push(str);
-    PdfOp_quote(pdfContext, canvas, looper);
+    PdfOp_quote(pdfContext, canvas, parentLooper);
 
     return kPartial_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_TJ(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_TJ(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("Tf", pdfContext, 1);
     POP_ARRAY(pdfContext, array);
     CHECK_PARAMETERS();
 
     if (!pdfContext->fGraphicsState.fTextBlock) {
         // TODO(edisonn): try to recover and draw it any way?
         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, "TJ without BT", NULL,
                     pdfContext);
         return kIgnoreError_SkPdfResult;
     }
@@ skipping 93 matching lines @@
                     return kPartial_SkPdfResult;
                 }
                 return kNYI_SkPdfResult;
             }
         }
     }
 
     return kPartial_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_CS(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_CS(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
-static SkPdfResult PdfOp_cs(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_cs(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
 }
 
 static SkPdfResult PdfOp_SC_sc(SkPdfContext* pdfContext, SkCanvas* canvas,
                                SkPdfColorOperator* colorOperator) {
     double c[4];
 //    int64_t v[4];
 
     int n = GetColorSpaceComponents(colorOperator->fColorSpace);
 
@@ skipping 22 matching lines @@
     // TODO(edisonn): support also abbreviations /DeviceRGB == /RGB
     if (colorOperator->fColorSpace.equals("DeviceRGB") ||
             colorOperator->fColorSpace.equals("RGB")) {
         colorOperator->setRGBColor(SkColorSetRGB((U8CPU)(255*c[0]),
                                                  (U8CPU)(255*c[1]),
                                                  (U8CPU)(255*c[2])));
     }
     return kPartial_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_SC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_SC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
-static SkPdfResult PdfOp_sc(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_sc(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
 }
 
 static SkPdfResult PdfOp_SCN_scn(SkPdfContext* pdfContext, SkCanvas* canvas,
                                  SkPdfColorOperator* colorOperator) {
     if (pdfContext->fObjectStack.count() > 0 && pdfContext->fObjectStack.top()->isName()) {
         SkPdfNativeObject* name = pdfContext->fObjectStack.top();    pdfContext->fObjectStack.pop();
 
         SkPdfDictionary* patternResources
                 = pdfContext->fGraphicsState.fResources->Pattern(pdfContext->fPdfDoc);
 
         if (patternResources == NULL) {
 #ifdef PDF_TRACE
             printf("ExtGState is NULL!\n");
 #endif
             return kIgnoreError_SkPdfResult;
         }
 
         colorOperator->setPatternColorSpace(
                 pdfContext->fPdfDoc->resolveReference(patternResources->get(name)));
     }
 
     // TODO(edisonn): SCN supports more color spaces than SCN. Read and implement spec.
     PdfOp_SC_sc(pdfContext, canvas, colorOperator);
 
     return kPartial_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_SCN(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_SCN(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
-static SkPdfResult PdfOp_scn(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_scn(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
 }
 
 static SkPdfResult PdfOp_G_g(SkPdfContext* pdfContext, SkCanvas* canvas,
                              SkPdfColorOperator* colorOperator) {
     EXPECT_OPERANDS("G/g", pdfContext, 1);
     POP_NUMBER(pdfContext, gray);
     CHECK_PARAMETERS();
 
     // TODO(edisonn): limit gray in [0, 1]
 
     // TODO(edisonn): HACK - it should be device gray, but not suported right now
     colorOperator->fColorSpace = strings_DeviceRGB;
     colorOperator->setRGBColor(SkColorSetRGB((U8CPU)(255 * gray),
                                              (U8CPU)(255 * gray),
                                              (U8CPU)(255 * gray)));
 
     return kPartial_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_G(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_G(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
-static SkPdfResult PdfOp_g(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_g(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
 }
 
 static SkPdfResult PdfOp_RG_rg(SkPdfContext* pdfContext, SkCanvas* canvas,
                                SkPdfColorOperator* colorOperator) {
     EXPECT_OPERANDS("RG/rg", pdfContext, 3);
     POP_NUMBER(pdfContext, b);
     POP_NUMBER(pdfContext, g);
     POP_NUMBER(pdfContext, r);
     CHECK_PARAMETERS();
 
     colorOperator->fColorSpace = strings_DeviceRGB;
     colorOperator->setRGBColor(SkColorSetRGB((U8CPU)(255*r), (U8CPU)(255*g), (U8CPU)(255*b)));
     return kOK_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_RG(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_RG(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
-static SkPdfResult PdfOp_rg(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_rg(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
 }
 
 static SkPdfResult PdfOp_K_k(SkPdfContext* pdfContext, SkCanvas* canvas,
                              SkPdfColorOperator* colorOperator) {
     // TODO(edisonn): spec has some rules about overprint, implement them.
     EXPECT_OPERANDS("K/k", pdfContext, 4);
     POP_NUMBER(pdfContext, k);
     POP_NUMBER(pdfContext, y);
     POP_NUMBER(pdfContext, m);
     POP_NUMBER(pdfContext, c);
     CHECK_PARAMETERS();
 
     // TODO(edisonn): really silly quick way to remove compiler warning
     if (k + y + m + c == 0) {
         return kNYI_SkPdfResult;
     }
 
     //colorOperator->fColorSpace = strings_DeviceCMYK;
     // TODO(edisonn): Set color.
     return kNYI_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_K(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_K(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
 }
 
-static SkPdfResult PdfOp_k(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_k(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
 }
 
-static SkPdfResult PdfOp_W(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_W(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath;
     pdfContext->fGraphicsState.fHasClipPathToApply = true;
 
     return kOK_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_W_star(SkPdfContext* pdfContext, SkCanvas* canvas,
-                                SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_W_star(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath;
 
     pdfContext->fGraphicsState.fClipPath.setFillType(SkPath::kEvenOdd_FillType);
     pdfContext->fGraphicsState.fHasClipPathToApply = true;
 
     return kOK_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_BX(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
-    *looper = new PdfCompatibilitySectionLooper();
+static SkPdfResult PdfOp_BX(SkPdfContext* pdfContext, SkCanvas* canvas,
+                            SkPdfTokenLooper* parentLooper) {
+    PdfCompatibilitySectionLooper looper(parentLooper);
+    looper.loop();
     return kOK_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_EX(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_EX(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kNullObject_SkPdfIssue,
                 "EX operator should not be called, it is handled in a looper, "
                         "unless the file is corrupted, we should assert",
                 NULL, pdfContext);
 
     return kIgnoreError_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_BI(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
-    *looper = new PdfInlineImageLooper();
+static SkPdfResult PdfOp_BI(SkPdfContext* pdfContext, SkCanvas* canvas,
+                            SkPdfTokenLooper* parentLooper) {
+    PdfInlineImageLooper looper(parentLooper);
+    looper.loop();
     return kOK_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_ID(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_ID(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kNullObject_SkPdfIssue,
                 "ID operator should not be called, it is habdled in a looper, "
                         "unless the file is corrupted, we should assert",
                 NULL, pdfContext);
     return kIgnoreError_SkPdfResult;
 }
 
-static SkPdfResult PdfOp_EI(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_EI(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kNullObject_SkPdfIssue,
                 "EI operator should not be called, it is habdled in a looper, "
                         "unless the file is corrupted, we should assert",
                 NULL, pdfContext);
     return kIgnoreError_SkPdfResult;
 }
 
 static SkPdfResult skpdfGraphicsStateApply_ca(SkPdfContext* pdfContext, double ca) {
     pdfContext->fGraphicsState.fNonStroking.fOpacity = ca;
     return kOK_SkPdfResult;
@@ skipping 144 matching lines @@
                                   SkPdfNativeObject::_kNumber_PdfObjectType, pdfContext);
         return;
     }
 
     skpdfGraphicsStateApplyFontCore(pdfContext, fontAndSize->objAtAIndex(0),
                                     fontAndSize->objAtAIndex(1)->numberValue());
 }
 
 
 //lineWidth w Set the line width in the graphics state (see “Line Width” on page 152).
-static SkPdfResult PdfOp_w(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_w(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("w", pdfContext, 1);
     POP_NUMBER(pdfContext, lw);
     CHECK_PARAMETERS();
 
     return skpdfGraphicsStateApplyLW(pdfContext, lw);
 }
 
 //lineCap J Set the line cap style in the graphics state (see “Line Cap Style” on page 153).
-static SkPdfResult PdfOp_J(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_J(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     // TODO(edisonn): round/ceil to int?
     EXPECT_OPERANDS("J", pdfContext, 1);
     POP_NUMBER(pdfContext, lc);
     CHECK_PARAMETERS();
 
     return skpdfGraphicsStateApplyLC(pdfContext, (int)lc);
 }
 
 //lineJoin j Set the line join style in the graphics state (see “Line Join Style” on page 153).
-static SkPdfResult PdfOp_j(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_j(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     // TODO(edisonn): round/ceil to int?
     EXPECT_OPERANDS("j", pdfContext, 1);
     POP_NUMBER(pdfContext, lj);
     CHECK_PARAMETERS();
 
     return skpdfGraphicsStateApplyLJ(pdfContext, (int)lj);
 }
 
 //miterLimit M Set the miter limit in the graphics state (see “Miter Limit” on page 153).
-static SkPdfResult PdfOp_M(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_M(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("M", pdfContext, 1);
     POP_NUMBER(pdfContext, ml);
     CHECK_PARAMETERS();
     return skpdfGraphicsStateApplyML(pdfContext, ml);
 }
 
 //dashArray dashPhase d Set the line dash pattern in the graphics state (see “Line Dash Pattern” on
 //page 155).
-static SkPdfResult PdfOp_d(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_d(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("d", pdfContext, 2);
     POP_OBJ(pdfContext, phase);
     POP_ARRAY(pdfContext, array);
     CHECK_PARAMETERS();
 
     return skpdfGraphicsStateApplyD(pdfContext, array, phase);
 }
 
 //intent ri (PDF 1.1) Set the color rendering intent in the graphics state (see “Rendering Intents”
 // on page 197).
-static SkPdfResult PdfOp_ri(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_ri(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     pdfContext->fObjectStack.pop();
 
     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "render intent NYI", NULL,
                 pdfContext);
 
     return kNYI_SkPdfResult;
 }
 
 //flatness i Set the flatness tolerance in the graphics state (see Section 6.5.1, “Flatness
 //Tolerance”). flatness is a number in the range 0 to 100; a value of 0 speci-
 //fies the output device’s default flatness tolerance.
-static SkPdfResult PdfOp_i(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_i(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("i", pdfContext, 1);
     POP_NUMBER(pdfContext, flatness);
     CHECK_PARAMETERS();
 
     if (flatness < 0 || flatness > 100) {
         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue,
                     "flatness must be a real in [0, 100] range", flatness_obj, pdfContext);
         return kIgnoreError_SkPdfResult;
     }
 
@@ skipping 136 matching lines @@
 }
 
 static void skpdfGraphicsStateApplyAIS(SkPdfContext* pdfContext, bool alphaSource) {
     pdfContext->fGraphicsState.fAlphaSource = alphaSource;
 }
 
 
 //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 SkPdfResult PdfOp_gs(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_gs(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("gs", pdfContext, 1);
     POP_NAME(pdfContext, name);
     CHECK_PARAMETERS();
 
     SkPdfDictionary* extGStateDictionary
             = pdfContext->fGraphicsState.fResources->ExtGState(pdfContext->fPdfDoc);
 
     if (extGStateDictionary == NULL) {
         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingExtGState_SkPdfIssue, NULL,
                     pdfContext->fGraphicsState.fResources, pdfContext);
@@ skipping 81 matching lines @@
 
     // TODO(edisonn): make sure we loaded all those properties in graphic state.
 
     return kOK_SkPdfResult;
 }
 
 //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.
-SkPdfResult PdfOp_Tc(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+SkPdfResult PdfOp_Tc(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("Tc", pdfContext, 1);
     POP_NUMBER(pdfContext, charSpace);
     CHECK_PARAMETERS();
 
     pdfContext->fGraphicsState.fCharSpace = charSpace;
 
     return kOK_SkPdfResult;
 }
 
 //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.
-SkPdfResult PdfOp_Tw(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+SkPdfResult PdfOp_Tw(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("Tw", pdfContext, 1);
     POP_NUMBER(pdfContext, wordSpace);
     CHECK_PARAMETERS();
 
     pdfContext->fGraphicsState.fWordSpace = wordSpace;
 
     return kOK_SkPdfResult;
 }
 
 //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).
-static SkPdfResult PdfOp_Tz(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Tz(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("Tz", pdfContext, 1);
     POP_NUMBER(pdfContext, scale);
     CHECK_PARAMETERS();
 
     if (scale < 0) {
         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue,
                     "scale must a positive real number", scale_obj, pdfContext);
         return kError_SkPdfResult;
     }
 
     return kNYI_SkPdfResult;
 }
 
 //render Tr Set the text rendering mode, T
 //mode, to render, which is an integer. Initial value: 0.
-static SkPdfResult PdfOp_Tr(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Tr(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("Tr", pdfContext, 1);
     POP_INTEGER(pdfContext, mode);
     CHECK_PARAMETERS();
 
     if (mode < 0) {  // TODO(edisonn): function/enums with supported modes
         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue,
                     "mode must a positive integer or 0", mode_obj, pdfContext);
         return kError_SkPdfResult;
     }
 
     return kNYI_SkPdfResult;
 }
 //rise Ts Set the text rise, Trise, to rise, which is a number expressed in unscaled text space
 //units. Initial value: 0.
-static SkPdfResult PdfOp_Ts(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Ts(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("Ts", pdfContext, 1);
     POP_NUMBER(pdfContext, rise);
     CHECK_PARAMETERS();
 
     if (rise < 0) {
         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue,
                     "rise must a positive real number", rise_obj, pdfContext);
         return kNYI_SkPdfResult;
     }
 
     return kNYI_SkPdfResult;
 }
 
 //wx wy d0
-static SkPdfResult PdfOp_d0(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_d0(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("d0", pdfContext, 2);
     POP_NUMBER(pdfContext, wy);
     POP_NUMBER(pdfContext, wx);
     CHECK_PARAMETERS();
 
     if (wx < 0) {
         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue,
                     "wx must a positive real number", wx_obj, pdfContext);
         return kError_SkPdfResult;
     }
 
     if (wy < 0) {
         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue,
                     "wy must a positive real number", wy_obj, pdfContext);
         return kError_SkPdfResult;
     }
 
     return kNYI_SkPdfResult;
 }
 
 //wx wy llx lly urx ury d1
-static SkPdfResult PdfOp_d1(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_d1(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("d1", pdfContext, 6);
     POP_NUMBER(pdfContext, ury);
     POP_NUMBER(pdfContext, urx);
     POP_NUMBER(pdfContext, lly);
     POP_NUMBER(pdfContext, llx);
     POP_NUMBER(pdfContext, wy);
     POP_NUMBER(pdfContext, wx);
     CHECK_PARAMETERS();
 
     // TODO(edisonn): really silly quick way to remove warning
     if (wx + wy + llx + lly + urx + ury) {
         return kNYI_SkPdfResult;
     }
 
     return kNYI_SkPdfResult;
 }
 
 //name sh
-static SkPdfResult PdfOp_sh(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_sh(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("sh", pdfContext, 1);
     POP_NAME(pdfContext, name);
     CHECK_PARAMETERS();
 
     if (name == NULL) {
         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, name,
                                   SkPdfNativeObject::kName_PdfObjectType, pdfContext);
         return kError_SkPdfResult;
     }
 
     return kNYI_SkPdfResult;
 }
 
 //name Do
-static SkPdfResult PdfOp_Do(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_Do(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("Do", pdfContext, 1);
     POP_NAME(pdfContext, name);
     CHECK_PARAMETERS();
 
     SkPdfDictionary* xObject =  pdfContext->fGraphicsState.fResources->XObject(pdfContext->fPdfDoc);
 
     if (xObject == NULL) {
         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingXObject_SkPdfIssue, NULL,
                     pdfContext->fGraphicsState.fResources, pdfContext);
         return kIgnoreError_SkPdfResult;
     }
 
     SkPdfNativeObject* value = xObject->get(name);
     value = pdfContext->fPdfDoc->resolveReference(value);
 
     return doXObject(pdfContext, canvas, value);
 }
 
 //tag MP Designate a marked-content point. tag is a name object indicating the role or
 //significance of the point.
-static SkPdfResult PdfOp_MP(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_MP(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("MP", pdfContext, 1);
     POP_OBJ(pdfContext, tag);
     CHECK_PARAMETERS();
 
     if (tag == NULL) {
         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag,
                                   SkPdfNativeObject::_kObject_PdfObjectType, pdfContext);
         return kNYI_SkPdfResult;
     }
 
     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "MP NYI", NULL, NULL);
     return kNYI_SkPdfResult;
 }
 
 //tag properties DP Designate a marked-content point with an associated property list. tag is a
 //name object indicating the role or significance of the point; properties is
 //either an inline dictionary containing the property list or a name object
 //associated with it in the Properties subdictionary of the current resource
 //dictionary (see Section 9.5.1, “Property Lists”).
-static SkPdfResult PdfOp_DP(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_DP(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("DP", pdfContext, 2);
     POP_OBJ(pdfContext, properties);
     POP_OBJ(pdfContext, tag);
     CHECK_PARAMETERS();
 
     if (tag == NULL) {
         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag,
                                   SkPdfNativeObject::_kObject_PdfObjectType, pdfContext);
         return kNYI_SkPdfResult;
     }
 
     if (properties == NULL) {
         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, properties,
                                   SkPdfNativeObject::_kObject_PdfObjectType, pdfContext);
         return kNYI_SkPdfResult;
     }
 
     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "DP NYI", NULL, NULL);
     return kNYI_SkPdfResult;
 }
 
 //tag BMC Begin a marked-content sequence terminated by a balancing EMC operator.
 //tag is a name object indicating the role or significance of the sequence.
-static SkPdfResult PdfOp_BMC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_BMC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("BMC", pdfContext, 1);
     POP_OBJ(pdfContext, tag);
     CHECK_PARAMETERS();
 
     if (tag == NULL) {
         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag,
                                   SkPdfNativeObject::_kObject_PdfObjectType, pdfContext);
         return kNYI_SkPdfResult;
     }
 
     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "BMC NYI", NULL, NULL);
     return kNYI_SkPdfResult;
 }
 
 //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”).
-static SkPdfResult PdfOp_BDC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_BDC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     EXPECT_OPERANDS("BDC", pdfContext, 2);
     POP_OBJ(pdfContext, properties);
     POP_OBJ(pdfContext, tag);
     CHECK_PARAMETERS();
 
     if (tag == NULL) {
         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag,
                                   SkPdfNativeObject::_kObject_PdfObjectType, pdfContext);
         return kNYI_SkPdfResult;
     }
 
     if (properties == NULL) {
         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, properties,
                                   SkPdfNativeObject::_kObject_PdfObjectType, pdfContext);
         return kNYI_SkPdfResult;
     }
 
     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "BDC NYI", NULL, NULL);
     return kNYI_SkPdfResult;
 }
 
 //— EMC End a marked-content sequence begun by a BMC or BDC operator.
-static SkPdfResult PdfOp_EMC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper** looper) {
+static SkPdfResult PdfOp_EMC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "EMC NYI", NULL, NULL);
     return kNYI_SkPdfResult;
 }
 
 #include "SkPdfOps.h"
 
 SkTDict<PdfOperatorRenderer> gPdfOps(100);
 
 static void initPdfOperatorRenderes() {
     static bool gInitialized = false;
@@ skipping 101 matching lines @@
 };
 
 InitPdfOps gInitPdfOps;
 
 SkPdfResult PdfInlineImageLooper::consumeToken(PdfToken& token) {
     SkASSERT(false);
     return kIgnoreError_SkPdfResult;
 }
 
 void PdfInlineImageLooper::loop() {
+    // FIXME (scroggo): Does this need to be looper? It does not consumeTokens,
+    // nor does it loop. The one thing it does is provide access to the
+    // protected members of SkPdfTokenLooper.
     doXObject_Image(fPdfContext, fCanvas, fTokenizer->readInlineImage());
 }
 
-SkPdfResult PdfInlineImageLooper::done() {
-    return kNYI_SkPdfResult;
-}
-
 SkPdfResult PdfCompatibilitySectionLooper::consumeToken(PdfToken& token) {
     return fParent->consumeToken(token);
 }
 
 void PdfCompatibilitySectionLooper::loop() {
     PdfOp_q(fPdfContext, fCanvas, NULL);
 
     PdfToken token;
     while (fTokenizer->readToken(&token)) {
         if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") == 0) {
-            SkPdfTokenLooper* looper = new PdfCompatibilitySectionLooper();
-            looper->setUp(this);
-            looper->loop();
-            delete looper;
+            PdfCompatibilitySectionLooper looper(this);
+            looper.loop();
         } else {
-            if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "EX") == 0) break;
+            if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "EX") == 0) {
+                break;
+            }
             fParent->consumeToken(token);
         }
     }
 
     PdfOp_Q(fPdfContext, fCanvas, NULL);
 }
 
 // TODO(edisonn): for debugging - remove or put it in a #ifdef
 SkPdfContext* gPdfContext = NULL;
 
@@ skipping 140 matching lines @@
 
     rect = SkRect::MakeWH(width, height);
 
     setup_bitmap(output, SkScalarCeilToInt(width), SkScalarCeilToInt(height));
 
     SkAutoTUnref<SkBaseDevice> device(SkNEW_ARGS(SkBitmapDevice, (*output)));
     SkCanvas canvas(device);
 
     return renderer->renderPage(page, &canvas, rect);
 }