pdfviewer: when q start, and an operator is called, it should not be able to see operands before q.…

experimental/PdfViewer/SkPdfGraphicsState.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPdfGraphicsState_DEFINED
 #define SkPdfGraphicsState_DEFINED
 
 #include "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkPdfConfig.h"
 #include "SkPdfUtils.h"
 
 //#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?
+// TODO(edisonn): move this class in include/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)
+
+// Adobe limits it to 28, so 256 should be more than enough
+#define MAX_NESTING 256
+
 #include "SkTypes.h"
 template <typename T> class SkTDStackNew : SkNoncopyable {
 public:
-    SkTDStackNew() : fCount(0), fTotalCount(0) {
+    SkTDStackNew() : fCount(0), fTotalCount(0), fLocalCount(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; }
+    int count() const { return fLocalCount; }
+    int depth() const { return fLocalCount; }
+    bool empty() const { return fLocalCount == 0; }
+
+    bool nests() {
+        return fNestingLevel;
+    }
+
+    void nest() {
+        // We are are past max nesting levels, we will still continue to work, but we might fail
+        // to properly ignore errors. Ideally it should only mean poor rendering in exceptional
+        // cases
+        if (fNestingLevel >= 0 && fNestingLevel < MAX_NESTING) {
+            fNestings[fNestingLevel] = fLocalCount;
+            fLocalCount = 0;
+        }
+        fNestingLevel++;
+    }
+
+    void unnest() {
+        SkASSERT(fNestingLevel > 0);
+        fNestingLevel--;
+        if (fNestingLevel >= 0 && fNestingLevel < MAX_NESTING) {
+            // TODO(edisonn): warn if fLocal > 0
+            while (fLocalCount > 0) {
+                pop();
+            }
+            fLocalCount = fNestings[fNestingLevel];
+        }
+    }
 
     T* push() {
         SkASSERT(fCount <= kSlotCount);
         if (fCount == kSlotCount) {
             Rec* rec = new Rec();
             rec->fNext = fRec;
             fRec = rec;
             fCount = 0;
         }
         ++fTotalCount;
+        ++fLocalCount;
         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];
     }
 
@@ skipping 14 matching lines @@
 
     void pop(T* elem) {
         if (elem) {
             *elem = fRec->fSlots[fCount - 1];
         }
         this->pop();
     }
 
     void pop() {
         SkASSERT(fCount > 0 && fRec);
+        --fLocalCount;
         --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;
+    int     fCount, fTotalCount, fLocalCount;
+    int     fNestings[MAX_NESTING];
+    int     fNestingLevel;
 };
 
 // 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 337 matching lines @@
     SkPdfNativeDoc*                 fPdfDoc;
     // TODO(edisonn): the allocator, could be freed after the page is done drawing.
     SkPdfAllocator*                 fTmpPageAllocator;
     SkMatrix                        fOriginalMatrix;
 
     SkPdfContext(SkPdfNativeDoc* doc);
     ~SkPdfContext();
 };
 
 #endif  // SkPdfGraphicsState_DEFINED