Refactor SkPicturePlayback for SkPictureReplacementPlayback

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 32 matching lines @@
 
     SkPictureStateTree();
     ~SkPictureStateTree();
 
     /**
      * Creates and returns a struct representing a draw at the given offset.
      */
     Draw* appendDraw(size_t offset);
 
     /**
-     * Given a list of draws, and a canvas, returns an iterator that produces the correct sequence
-     * of offsets into the command buffer to carry out those calls with correct matrix/clip state.
-     * This handles saves/restores, and does all necessary matrix setup.
+     * Given a list of draws, and a canvas, initialize an iterator that produces the correct 
+     * sequence of offsets into the command buffer to carry out those calls with correct 
+     * matrix/clip state. This handles saves/restores, and does all necessary matrix setup.
      */
-    Iterator getIterator(const SkTDArray<void*>& draws, SkCanvas* canvas);
+    void initIterator(SkPictureStateTree::Iterator* iter, 
+                      const SkTDArray<void*>& draws, 
+                      SkCanvas* canvas);
 
     void appendSave();
     void appendSaveLayer(size_t offset);
     void appendRestore();
     void appendTransform(const SkMatrix& trans);
     void appendClip(size_t offset);
 
     /**
      * Call this immediately after an appendRestore call that is associated
      * 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 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();
         static const uint32_t kDrawComplete = SK_MaxU32;
-        Iterator() : fPlaybackMatrix(), fValid(false) { }
+        Iterator() : fValid(false) { }
         bool isValid() const { return fValid; }
 
     private:
-        Iterator(const SkTDArray<void*>& draws, SkCanvas* canvas, Node* root);
+        void init(const SkTDArray<void*>& draws, SkCanvas* canvas, Node* root);
 
         void setCurrentMatrix(const SkMatrix*);
 
         // The draws this iterator is associated with
         const SkTDArray<void*>* fDraws;
 
         // canvas this is playing into (so we can insert saves/restores as necessary)
         SkCanvas* fCanvas;
 
         // current state node
         Node* fCurrentNode;
 
         // List of nodes whose state we need to apply to reach TargetNode
         SkTDArray<Node*> fNodes;
 
         // The matrix of the canvas we're playing back into
-        const SkMatrix fPlaybackMatrix;
+        SkMatrix fPlaybackMatrix;
 
         // Cache of current matrix, so we can avoid redundantly setting it
         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)
@@ skipping 33 matching lines @@
         };
     };
 
     Node fRoot;
     SkMatrix fRootMatrix;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif