pdfviewer: code cleanup - remove STL usage

experimental/PdfViewer/SkPdfGraphicsState.h

 #ifndef __DEFINED__SkPdfBasics
 #define __DEFINED__SkPdfBasics
 
 #include "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkPdfConfig.h"
 #include "SkPdfUtils.h"
 
-#include <stack>
+//#include "SkTDStack.h"
 
 class SkPdfFont;
 class SkPdfDoc;
 class SkPdfNativeObject;
 class SkPdfResourceDictionary;
 class SkPdfSoftMaskDictionary;
 
 class SkPdfNativeDoc;
 class SkPdfAllocator;
 
+// TODO(edisonn): move this class in iclude/core?
+// Ref objects can't be dealt unless we use a specific class initialization
+// The difference between SkTDStackNew and SkTDStack is that SkTDStackNew uses new/delete
+// to be a manage c++ stuff (like initializations)
+#include "SkTypes.h"
+template <typename T> class SkTDStackNew : SkNoncopyable {
+public:
+    SkTDStackNew() : fCount(0), fTotalCount(0) {
+        fInitialRec.fNext = NULL;
+        fRec = &fInitialRec;
+
+    //  fCount = kSlotCount;
+    }
+
+    ~SkTDStackNew() {
+        Rec* rec = fRec;
+        while (rec != &fInitialRec) {
+            Rec* next = rec->fNext;
+            delete rec;
+            rec = next;
+        }
+    }
+
+    int count() const { return fTotalCount; }
+    int depth() const { return fTotalCount; }
+    bool empty() const { return fTotalCount == 0; }
+
+    T* push() {
+        SkASSERT(fCount <= kSlotCount);
+        if (fCount == kSlotCount) {
+            Rec* rec = new Rec();
+            rec->fNext = fRec;
+            fRec = rec;
+            fCount = 0;
+        }
+        ++fTotalCount;
+        return &fRec->fSlots[fCount++];
+    }
+
+    void push(const T& elem) { *this->push() = elem; }
+
+    const T& index(int idx) const {
+        SkASSERT(fRec && fCount > idx);
+        return fRec->fSlots[fCount - idx - 1];
+    }
+
+    T& index(int idx) {
+        SkASSERT(fRec && fCount > idx);
+        return fRec->fSlots[fCount - idx - 1];
+    }
+
+    const T& top() const {
+        SkASSERT(fRec && fCount > 0);
+        return fRec->fSlots[fCount - 1];
+    }
+
+    T& top() {
+        SkASSERT(fRec && fCount > 0);
+        return fRec->fSlots[fCount - 1];
+    }
+
+    void pop(T* elem) {
+        if (elem) {
+            *elem = fRec->fSlots[fCount - 1];
+        }
+        this->pop();
+    }
+
+    void pop() {
+        SkASSERT(fCount > 0 && fRec);
+        --fTotalCount;
+        if (--fCount == 0) {
+            if (fRec != &fInitialRec) {
+                Rec* rec = fRec->fNext;
+                delete fRec;
+                fCount = kSlotCount;
+                fRec = rec;
+            } else {
+                SkASSERT(fTotalCount == 0);
+            }
+        }
+    }
+
+private:
+    enum {
+        kSlotCount  = 64
+    };
+
+    struct Rec;
+    friend struct Rec;
+
+    struct Rec {
+        Rec* fNext;
+        T    fSlots[kSlotCount];
+    };
+    Rec     fInitialRec;
+    Rec*    fRec;
+    int     fCount, fTotalCount;
+};
+
 // TODO(edisonn): better class design.
 class SkPdfColorOperator {
 
     /*
     color space   name or array     The current color space in which color values are to be interpreted
                                     (see Section 4.5, “Color Spaces”). There are two separate color space
                                     parameters: one for stroking and one for all other painting opera-
                                     tions. Initial value: DeviceGray.
      */
 
@@ skipping 51 matching lines @@
     // TODO(edisonn): deprecate and remove these!
     double              fCurPosX;
     double              fCurPosY;
 
     double              fCurFontSize;
     bool                fTextBlock;
     SkPdfFont*          fSkFont;
     SkPath              fPath;
     bool                fPathClosed;
 
-
-
     double              fTextLeading;
     double              fWordSpace;
     double              fCharSpace;
 
     SkPdfResourceDictionary* fResources;
 
 
     // TODO(edisonn): move most of these in canvas/paint?
     // we could have some in canvas (matrixes?),
     // some in 2 paints (stroking paint and non stroking paint)
@@ skipping 251 matching lines @@
     }
 
     // TODO(edisonn): make two functons instead, stroking and non stoking, avoid branching
     void applyGraphicsState(SkPaint* paint, bool stroking);
 };
 
 // TODO(edisonn): better class design.
 // TODO(edisonn): rename to SkPdfContext
 class SkPdfContext {
 public:
-    std::stack<SkPdfNativeObject*>  fObjectStack;
-    std::stack<SkPdfGraphicsState>  fStateStack;
+    SkTDStackNew<SkPdfNativeObject*>  fObjectStack;
+    SkTDStackNew<SkPdfGraphicsState>  fStateStack;
     SkPdfGraphicsState              fGraphicsState;
     SkPdfNativeDoc*                 fPdfDoc;
     // TODO(edisonn): the allocator, could be freed after the page is done drawing.
     SkPdfAllocator*                 fTmpPageAllocator;
     SkMatrix                        fOriginalMatrix;
 
     SkPdfContext(SkPdfNativeDoc* doc);
     ~SkPdfContext();
 };
 
 #endif  // __DEFINED__SkPdfBasics