Collapse matrix & clip stack in PictureRecord

src/core/SkPictureRecord.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPictureRecord_DEFINED
 #define SkPictureRecord_DEFINED
 
 #include "SkCanvas.h"
 #include "SkFlattenable.h"
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+#include "SkMatrixClipStateMgr.h"
+#endif
 #include "SkPathHeap.h"
 #include "SkPicture.h"
 #include "SkPictureFlat.h"
 #include "SkTemplates.h"
 #include "SkWriter32.h"
 
 class SkPictureStateTree;
 class SkBBoxHierarchy;
 
 // These macros help with packing and unpacking a single byte value and
@@ skipping 81 matching lines @@
     }
 
     void beginRecording();
     void endRecording();
 
 private:
     void handleOptimization(int opt);
     int recordRestoreOffsetPlaceholder(SkRegion::Op);
     void fillRestoreOffsetPlaceholdersForCurrentStackLevel(uint32_t restoreOffset);
 
+#ifndef SK_COLLAPSE_MATRIX_CLIP_STATE
     SkTDArray<int32_t> fRestoreOffsetStack;
     int fFirstSavedLayerIndex;
     enum {
         kNoSavedLayerIndex = -1
     };
+#endif
 
     /*
      * Write the 'drawType' operation and chunk size to the skp. 'size'
      * can potentially be increased if the chunk size needs its own storage
      * location (i.e., it overflows 24 bits).
      * Returns the start offset of the chunk. This is the location at which
      * the opcode & size are stored.
      * TODO: since we are handing the size into here we could call reserve
      * and then return a pointer to the memory storage. This could decrease
      * allocation overhead but could lead to more wasted space (the tail
@@ skipping 114 matching lines @@
     // These entry points allow the writing of matrices, clips, saves &
     // restores to be deferred (e.g., if the MC state is being collapsed and
     // only written out as needed).
     void recordConcat(const SkMatrix& matrix);
     int recordClipRect(const SkRect& rect, SkRegion::Op op, bool doAA);
     int recordClipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA);
     int recordClipPath(int pathID, SkRegion::Op op, bool doAA);
     int recordClipRegion(const SkRegion& region, SkRegion::Op op);
     void recordSave(SaveFlags flags);
     void recordSaveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags);
-    void recordRestore();
+    void recordRestore(bool fillInSkips = true);
 
     // These are set to NULL in our constructor, but may be changed by
     // subclasses, in which case they will be SkSafeUnref'd in our destructor.
     SkBBoxHierarchy* fBoundingHierarchy;
     SkPictureStateTree* fStateTree;
 
     // Allocated in the constructor and managed by this class.
     SkBitmapHeap* fBitmapHeap;
 
 private:
+    friend class MatrixClipState; // for access to *Impl methods
+    friend class SkMatrixClipStateMgr; // for access to *Impl methods
+
     SkChunkFlatController fFlattenableHeap;
 
     SkPaintDictionary fPaints;
 
     SkPathHeap* fPathHeap;  // reference counted
     SkWriter32 fWriter;
 
     // we ref each item in these arrays
     SkTDArray<SkPicture*> fPictureRefs;
 
     uint32_t fRecordFlags;
     int fInitialSaveCount;
 
     friend class SkPicturePlayback;
     friend class SkPictureTester; // for unit testing
 
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    SkMatrixClipStateMgr fMCMgr;
+#endif
+
     typedef SkCanvas INHERITED;
 };
 
 #endif