First pass at pre-rendering saveLayers for GPU

src/core/SkPictureStateTree.h

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPictureStateTree_DEFINED
 #define SkPictureStateTree_DEFINED
@@ skipping 56 matching lines @@
      * a save or saveLayer that was removed from the command stream
      * due to a command pattern optimization in SkPicture.
      */
     void saveCollapsed();
 
     /**
      * Playback helper
      */
     class Iterator {
     public:
-        /** Returns the next offset into the picture stream, or kDrawComplete if complete. */
+        /** Returns the next op offset needed to create the drawing state
+            required by the queued up draw operation or the offset of the queued 
+            up draw operation itself. In the latter case, the next draw operation
+            will move into the queued up slot.
+            It retuns kDrawComplete when done. 
+            TODO: this might be better named nextOp
+        */
         uint32_t nextDraw();
+        /** Peek at the currently queued up draw op's offset. Note that this can
+            be different then what 'nextDraw' would return b.c. it is
+            the offset of the next _draw_ op while 'nextDraw' can return
+            the offsets to saveLayer and clip ops while it is creating the proper 
+            drawing context for the queued up draw op.
+        */
+        uint32_t peekDraw();
+        /** Stop trying to create the drawing context for the currently queued 
+            up _draw_ operation and queue up the next one. This call returns
+            the offset of the skipped _draw_ operation. Obviously (since the
+            correct drawing context has not been established), the skipped
+            _draw_ operation should not be issued. Returns kDrawComplete if
+            the end of the draw operations is reached.
+         */
+        uint32_t skipDraw();
         static const uint32_t kDrawComplete = SK_MaxU32;
         Iterator() : fPlaybackMatrix(), fValid(false) { }
         bool isValid() const { return fValid; }
 
     private:
         Iterator(const SkTDArray<void*>& draws, SkCanvas* canvas, Node* root);
 
         void setCurrentMatrix(const SkMatrix*);
 
         // The draws this iterator is associated with
@@ skipping 15 matching lines @@
         const SkMatrix* fCurrentMatrix;
 
         // current position in the array of draws
         int fPlaybackIndex;
         // Whether or not we need to do a save next iteration
         bool fSave;
 
         // Whether or not this is a valid iterator (the default public constructor sets this false)
         bool fValid;
 
+        uint32_t finish();
+
         friend class SkPictureStateTree;
     };
 
 private:
 
     void appendNode(size_t offset);
 
     SkChunkAlloc fAlloc;
     // Needed by saveCollapsed() because nodes do not currently store
     // references to their children.  If they did, we could just retrieve the
@@ skipping 19 matching lines @@
         };
     };
 
     Node fRoot;
     SkMatrix fRootMatrix;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif