pdfviewer: code cleanup - remove STL usage

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 "SkPdfGraphicsState.h"
 #include "SkPdfNativeTokenizer.h"
-#include <cstdio>
-#include <stack>
-#include <set>
 
 extern "C" SkPdfContext* gPdfContext;
 extern "C" SkBitmap* gDumpBitmap;
 extern "C" SkCanvas* gDumpCanvas;
 
 __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!
 
 // TODO(edisonn): put drawtext in #ifdefs, so comparations will ignore minor changes in text positioning and font
 // this way, we look more at other features and layout in diffs
 
 // TODO(edisonn): move trace dump in the get functions, and mapper ones too so it ghappens automatically
 /*
 #ifdef PDF_TRACE
-    std::string str;
+    SkString str;
     pdfContext->fGraphicsState.fResources->native()->ToString(str);
     printf("Print Tf Resources: %s\n", str.c_str());
 #endif
  */
 
 #include "SkPdfHeaders_autogen.h"
 #include "SkPdfMapper_autogen.h"
 #include "SkPdfRenderer.h"
 
 #include "SkPdfUtils.h"
@@ skipping 11 matching lines @@
  * - encapsulate native in the pdf api so the skpdf does not know anything about native ... 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;
-
 NotOwnedString strings_DeviceRGB;
 NotOwnedString strings_DeviceCMYK;
 
 class StringsInit {
 public:
     StringsInit() {
         NotOwnedString::init(&strings_DeviceRGB, "DeviceRGB");
         NotOwnedString::init(&strings_DeviceCMYK, "DeviceCMYK");
     }
 };
@@ skipping 318 matching lines @@
         for (int i = 0 ; i < 256; i++) {
             colors[i] = SkPreMultiplyARGB(255, i, i, i);
         }
         grayColortable = new SkColorTable(colors, 256);
     }
     return grayColortable;
 }
 
 static SkBitmap* transferImageStreamToBitmap(const unsigned char* uncompressedStream, size_t uncompressedStreamLength,
                                      int width, int height, int bytesPerLine,
-                                     int bpc, const std::string& colorSpace,
+                                     int bpc, const SkString& colorSpace,
                                      bool transparencyMask) {
     SkBitmap* bitmap = new SkBitmap();
 
     //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?
 
     // minimal support for now
-    if ((colorSpace == "DeviceRGB" || colorSpace == "RGB") && bpc == 8) {
+    if ((colorSpace.equals("DeviceRGB") || colorSpace.equals("RGB")) && bpc == 8) {
         SkColor* uncompressedStreamArgb = (SkColor*)malloc(width * height * sizeof(SkColor));
 
         for (int h = 0 ; h < height; h++) {
             long i = width * (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) {
+    else if ((colorSpace.equals("DeviceGray") || colorSpace.equals("Gray")) && bpc == 8) {
         unsigned char* uncompressedStreamA8 = (unsigned char*)malloc(width * height);
 
         for (int h = 0 ; h < height; h++) {
             long i = width * (h);
             for (int w = 0 ; w < width; w++) {
                 uncompressedStreamA8[i] = transparencyMask ? 255 - uncompressedStream[w] :
                                                              uncompressedStream[w];
                 i++;
             }
             uncompressedStream += bytesPerLine;
@@ skipping 19 matching lines @@
 
 static SkBitmap* getImageFromObjectCore(SkPdfContext* pdfContext, SkPdfImageDictionary* image, bool transparencyMask) {
     if (image == NULL || !image->hasStream()) {
         // TODO(edisonn): report warning to be used in testing.
         return NULL;
     }
 
     int bpc = (int)image->BitsPerComponent(pdfContext->fPdfDoc);
     int width = (int)image->Width(pdfContext->fPdfDoc);
     int height = (int)image->Height(pdfContext->fPdfDoc);
-    std::string colorSpace = "DeviceRGB";
+    SkString colorSpace("DeviceRGB");
 
     bool indexed = false;
     SkPMColor colors[256];
     int cnt = 0;
 
     // TODO(edisonn): color space can be an array too!
     if (image->isColorSpaceAName(pdfContext->fPdfDoc)) {
         colorSpace = image->getColorSpaceAsName(pdfContext->fPdfDoc);
     } else if (image->isColorSpaceAArray(pdfContext->fPdfDoc)) {
         SkPdfArray* array = image->getColorSpaceAsArray(pdfContext->fPdfDoc);
@@ skipping 40 matching lines @@
 
     if (!stream || !stream->GetFilteredStreamRef(&uncompressedStream, &uncompressedStreamLength) ||
             uncompressedStream == NULL || uncompressedStreamLength == 0) {
         // TODO(edisonn): report warning to be used in testing.
         return NULL;
     }
 
     SkPdfStreamCommonDictionary* streamDict = (SkPdfStreamCommonDictionary*)stream;
 
     if (streamDict->has_Filter() && ((streamDict->isFilterAName(NULL) &&
-                                          streamDict->getFilterAsName(NULL) == "DCTDecode") ||
+                                          streamDict->getFilterAsName(NULL).equals("DCTDecode")) ||
                                      (streamDict->isFilterAArray(NULL) &&
                                           streamDict->getFilterAsArray(NULL)->size() > 0 &&
                                           streamDict->getFilterAsArray(NULL)->objAtAIndex(0)->isName() &&
-                                          streamDict->getFilterAsArray(NULL)->objAtAIndex(0)->nameValue2() == "DCTDecode"))) {
+                                          streamDict->getFilterAsArray(NULL)->objAtAIndex(0)->nameValue2().equals("DCTDecode")))) {
         SkBitmap* bitmap = new SkBitmap();
         SkImageDecoder::DecodeMemory(uncompressedStream, uncompressedStreamLength, bitmap);
         return bitmap;
     }
 
 
 
     // TODO (edisonn): Fast Jpeg(DCTDecode) draw, or fast PNG(FlateDecode) draw ...
 //    PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
 //                                              obj.GetDictionary().GetKey(PdfName("Filter")));
@@ skipping 309 matching lines @@
         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.
     PdfOp_Q(pdfContext, canvas, NULL);
 
     return kPartial_SkPdfResult;
 }
 
-
-// TODO(edisonn): make sure the pointer is unique
-std::set<const SkPdfNativeObject*> gInRendering;
-
 class CheckRecursiveRendering {
-    const SkPdfNativeObject* fUniqueData;
+    SkPdfNativeObject* fObj;
 public:
-    CheckRecursiveRendering(const SkPdfNativeObject* obj) : fUniqueData(obj) {
-        gInRendering.insert(obj);
+    CheckRecursiveRendering(SkPdfNativeObject* obj) : fObj(obj) {
+        SkASSERT(!obj->inRendering());
+        obj->startRendering();
     }
 
     ~CheckRecursiveRendering() {
-        //SkASSERT(fObj.fInRendering);
-        gInRendering.erase(fUniqueData);
+        SkASSERT(fObj->inRendering());
+        fObj->doneRendering();
     }
 
     static bool IsInRendering(const SkPdfNativeObject* obj) {
-        return gInRendering.find(obj) != gInRendering.end();
+        return obj->inRendering();
     }
 };
 
-static SkPdfResult doXObject(SkPdfContext* pdfContext, SkCanvas* canvas, const SkPdfNativeObject* obj) {
+static SkPdfResult doXObject(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfNativeObject* obj) {
     if (CheckRecursiveRendering::IsInRendering(obj)) {
         // Oops, corrupt PDF!
         return kIgnoreError_SkPdfResult;
     }
 
     CheckRecursiveRendering checkRecursion(obj);
 
     switch (pdfContext->fPdfDoc->mapper()->mapXObjectDictionary(obj))
     {
         case kImageDictionary_SkPdfNativeObjectType:
@@ skipping 950 matching lines @@
             cnt++;
         } else {
             // TODO(edisonn): report error/warning
             return kNYI_SkPdfResult;
         }
     }
     pdfContext->fGraphicsState.fDashArrayLength = cnt;
     pdfContext->fGraphicsState.fDashPhase = phase->scalarValue();
     if (pdfContext->fGraphicsState.fDashPhase == 0) {
         // other rules, changes?
-        pdfContext->fGraphicsState.fDashPhase = total;
+        pdfContext->fGraphicsState.fDashPhase = SkDoubleToScalar(total);
     }
 
     return kOK_SkPdfResult;
 }
 
 static SkPdfResult skpdfGraphicsStateApplyD(SkPdfContext* pdfContext, SkPdfArray* dash) {
     // TODO(edisonn): verify input
     if (!dash || dash->isArray() || dash->size() != 2 || !dash->objAtAIndex(0)->isArray() || !dash->objAtAIndex(1)->isNumber()) {
         // TODO(edisonn): report error/warning
         return kIgnoreError_SkPdfResult;
@@ skipping 11 matching lines @@
 
 
 //lineWidth w Set the line width in the graphics state (see “Line Width” on page 152).
 static SkPdfResult PdfOp_w(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     double lw = pdfContext->fObjectStack.top()->numberValue();    pdfContext->fObjectStack.pop();
     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, PdfTokenLooper** looper) {
-    int64_t lc = pdfContext->fObjectStack.top()->numberValue();    pdfContext->fObjectStack.pop();
+    // TODO(edisonn): round/ceil to int?
+    int lc = (int)pdfContext->fObjectStack.top()->numberValue();    pdfContext->fObjectStack.pop();
     return skpdfGraphicsStateApplyLC(pdfContext, 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, PdfTokenLooper** looper) {
-    double lj = pdfContext->fObjectStack.top()->numberValue();    pdfContext->fObjectStack.pop();
+    // TODO(edisonn): round/ceil to int?
+    int lj = (int)pdfContext->fObjectStack.top()->numberValue();    pdfContext->fObjectStack.pop();
     return skpdfGraphicsStateApplyLJ(pdfContext, 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, PdfTokenLooper** looper) {
     double ml = pdfContext->fObjectStack.top()->numberValue();    pdfContext->fObjectStack.pop();
     return skpdfGraphicsStateApplyML(pdfContext, ml);
 }
 
 //dashArray dashPhase d Set the line dash pattern in the graphics state (see “Line Dash Pattern” on
@@ skipping 57 matching lines @@
 
 static SkXfermode::Mode xferModeFromBlendMode(const char* blendMode, size_t len) {
     SkXfermode::Mode mode = (SkXfermode::Mode)(SkXfermode::kLastMode + 1);
     if (gPdfBlendModes.find(blendMode, len, &mode)) {
         return mode;
     }
 
     return (SkXfermode::Mode)(SkXfermode::kLastMode + 1);
 }
 
-static void skpdfGraphicsStateApplyBM_name(SkPdfContext* pdfContext, const std::string& blendMode) {
-    SkXfermode::Mode mode = xferModeFromBlendMode(blendMode.c_str(), blendMode.length());
+static void skpdfGraphicsStateApplyBM_name(SkPdfContext* pdfContext, const SkString& blendMode) {
+    SkXfermode::Mode mode = xferModeFromBlendMode(blendMode.c_str(), blendMode.size());
     if (mode <= SkXfermode::kLastMode) {
         pdfContext->fGraphicsState.fBlendModesLength = 1;
         pdfContext->fGraphicsState.fBlendModes[0] = mode;
     } else {
         // TODO(edisonn): report unknown blend mode
     }
 }
 
 static void skpdfGraphicsStateApplyBM_array(SkPdfContext* pdfContext, SkPdfArray* blendModes) {
     if (!blendModes || blendModes->isArray() || blendModes->size() == 0 || blendModes->size() > 256) {
@@ skipping 26 matching lines @@
     if (pdfContext->fPdfDoc->mapper()->mapSoftMaskDictionary(sMask)) {
         pdfContext->fGraphicsState.fSoftMaskDictionary = (SkPdfSoftMaskDictionary*)sMask;
     } else if (pdfContext->fPdfDoc->mapper()->mapSoftMaskImageDictionary(sMask)) {
         SkPdfSoftMaskImageDictionary* smid = (SkPdfSoftMaskImageDictionary*)sMask;
         pdfContext->fGraphicsState.fSMask = getImageFromObject(pdfContext, smid, true);
     } else {
         // TODO (edisonn): report error/warning
     }
 }
 
-static void skpdfGraphicsStateApplySMask_name(SkPdfContext* pdfContext, const std::string& sMask) {
-    if (sMask == "None") {
+static void skpdfGraphicsStateApplySMask_name(SkPdfContext* pdfContext, const SkString& sMask) {
+    if (sMask.equals("None")) {
         pdfContext->fGraphicsState.fSoftMaskDictionary = NULL;
         pdfContext->fGraphicsState.fSMask = NULL;
         return;
     }
 
     //Next, get the ExtGState Dictionary from the Resource Dictionary:
     SkPdfDictionary* extGStateDictionary = pdfContext->fGraphicsState.fResources->ExtGState(pdfContext->fPdfDoc);
 
     if (extGStateDictionary == NULL) {
 #ifdef PDF_TRACE
@@ skipping 19 matching lines @@
     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, PdfTokenLooper** looper) {
     SkPdfNativeObject* name = pdfContext->fObjectStack.top();    pdfContext->fObjectStack.pop();
 
 #ifdef PDF_TRACE
-    std::string str;
+    SkString 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
         printf("ExtGState is NULL!\n");
 #endif
         return kIgnoreError_SkPdfResult;
@@ skipping 311 matching lines @@
 class InitPdfOps {
 public:
     InitPdfOps() {
         initPdfOperatorRenderes();
     }
 };
 
 InitPdfOps gInitPdfOps;
 
 void reportPdfRenderStats() {
-    std::map<std::string, int>::iterator iter;
-
     for (int i = 0 ; i < kCount_SkPdfResult; i++) {
         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);
         }
     }
 }
 
@@ skipping 226 matching lines @@
 
     rect = SkRect::MakeWH(width, height);
 
     setup_bitmap(output, (int)SkScalarToDouble(width), (int)SkScalarToDouble(height));
 
     SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (*output)));
     SkCanvas canvas(device);
 
     return renderer.renderPage(page, &canvas, rect);
 }