Collapse matrix & clip stack in PictureRecord

https://codereview.chromium.org/137093004/



git-svn-id: http://skia.googlecode.com/svn/trunk@13402 2bbb7eff-a529-9590-31e7-b0007b416f81

gyp/core.gypi

@@ -110,6 +110,8 @@
         '<(skia_src_path)/core/SkMaskGamma.h',
         '<(skia_src_path)/core/SkMath.cpp',
         '<(skia_src_path)/core/SkMatrix.cpp',
+        '<(skia_src_path)/core/SkMatrixClipStateMgr.cpp',
+        '<(skia_src_path)/core/SkMatrixClipStateMgr.h',
         '<(skia_src_path)/core/SkMessageBus.h',
         '<(skia_src_path)/core/SkMetaData.cpp',
         '<(skia_src_path)/core/SkMipMap.cpp',

src/core/SkMatrixClipStateMgr.cpp

@@ -0,0 +1,257 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkMatrixClipStateMgr.h"
+#include "SkPictureRecord.h"
+
+bool SkMatrixClipStateMgr::MatrixClipState::ClipInfo::clipPath(SkPictureRecord* picRecord, 
+                                                               const SkPath& path, 
+                                                               SkRegion::Op op, 
+                                                               bool doAA, 
+                                                               const SkMatrix& matrix) {
+    int pathID = picRecord->addPathToHeap(path);
+
+    ClipOp& newClip = fClips.push_back();
+    newClip.fClipType = kPath_ClipType;
+    newClip.fGeom.fPathID = pathID;
+    newClip.fOp = op;
+    newClip.fDoAA = doAA;
+    newClip.fMatrix = matrix;
+    newClip.fOffset = kInvalidJumpOffset;
+    return false;
+}
+
+bool SkMatrixClipStateMgr::MatrixClipState::ClipInfo::clipRegion(SkPictureRecord* picRecord, 
+                                                                 const SkRegion& region, 
+                                                                 SkRegion::Op op, 
+                                                                 const SkMatrix& matrix) {
+    // TODO: add a region dictionary so we don't have to copy the region in here                                                                    
+    ClipOp& newClip = fClips.push_back();
+    newClip.fClipType = kRegion_ClipType;
+    newClip.fGeom.fRegion = SkNEW(SkRegion(region));
+    newClip.fOp = op;
+    newClip.fDoAA = true;      // not necessary but sanity preserving
+    newClip.fMatrix = matrix;
+    newClip.fOffset = kInvalidJumpOffset;
+    return false;
+}
+
+void SkMatrixClipStateMgr::WriteDeltaMat(SkPictureRecord* picRecord,
+                                         const SkMatrix& current, 
+                                         const SkMatrix& desired) {
+    SkMatrix delta;
+    current.invert(&delta);
+    delta.preConcat(desired);
+    picRecord->recordConcat(delta);
+}
+
+// Note: this only writes out the clips for the current save state. To get the
+// entire clip stack requires iterating of the entire matrix/clip stack.
+void SkMatrixClipStateMgr::MatrixClipState::ClipInfo::writeClip(SkMatrix* curMat, 
+                                                                SkPictureRecord* picRecord, 
+                                                                bool* overrideFirstOp) {
+    for (int i = 0; i < fClips.count(); ++i) {
+        ClipOp& curClip = fClips[i];
+
+        SkRegion::Op op = curClip.fOp;
+        if (*overrideFirstOp) {
+            op = SkRegion::kReplace_Op;
+            *overrideFirstOp = false;
+        }
+
+        // TODO: re-add an internal matrix dictionary to not write out
+        // redundant matrices.
+        // TODO: right now we're writing out the delta matrix from the prior
+        // matrix state. This is a side-effect of writing out the entire
+        // clip stack and should be resolved when that is fixed.
+        SkMatrixClipStateMgr::WriteDeltaMat(picRecord, *curMat, curClip.fMatrix);
+        *curMat = curClip.fMatrix;
+            
+        switch (curClip.fClipType) {
+        case kRect_ClipType:
+            curClip.fOffset = picRecord->recordClipRect(curClip.fGeom.fRRect.rect(), 
+                                                        op, curClip.fDoAA);
+            break;
+        case kRRect_ClipType:
+            curClip.fOffset = picRecord->recordClipRRect(curClip.fGeom.fRRect, op, 
+                                                         curClip.fDoAA);
+            break;
+        case kPath_ClipType:
+            curClip.fOffset = picRecord->recordClipPath(curClip.fGeom.fPathID, op, 
+                                                        curClip.fDoAA);
+            break;
+        case kRegion_ClipType:
+            curClip.fOffset = picRecord->recordClipRegion(*curClip.fGeom.fRegion, op);
+            break;
+        default:
+            SkASSERT(0);
+        }
+    }
+}
+
+// Fill in the skip offsets for all the clips written in the current block
+void SkMatrixClipStateMgr::MatrixClipState::ClipInfo::fillInSkips(SkWriter32* writer, 
+                                                                  int32_t restoreOffset) {
+    for (int i = 0; i < fClips.count(); ++i) {
+        ClipOp& curClip = fClips[i];
+
+        if (-1 == curClip.fOffset) {
+            continue;
+        }
+        SkDEBUGCODE(uint32_t peek = writer->read32At(curClip.fOffset);)
+        SkASSERT(-1 == peek);
+        writer->write32At(curClip.fOffset, restoreOffset);
+        SkDEBUGCODE(curClip.fOffset = -1;)
+    }
+}
+
+SkMatrixClipStateMgr::SkMatrixClipStateMgr()
+    : fPicRecord(NULL)
+    , fCurOpenStateID(kIdentityWideOpenStateID)
+    , fMatrixClipStack(sizeof(MatrixClipState), 
+                       fMatrixClipStackStorage, 
+                       sizeof(fMatrixClipStackStorage)) {
+    fCurMCState = (MatrixClipState*)fMatrixClipStack.push_back();
+    new (fCurMCState) MatrixClipState(NULL, 0);    // balanced in restore()
+}
+
+
+int SkMatrixClipStateMgr::save(SkCanvas::SaveFlags flags) {
+    SkDEBUGCODE(this->validate();)
+
+    MatrixClipState* newTop = (MatrixClipState*)fMatrixClipStack.push_back();
+    new (newTop) MatrixClipState(fCurMCState, flags); // balanced in restore()
+    fCurMCState = newTop;
+
+    SkDEBUGCODE(this->validate();)
+
+    return fMatrixClipStack.count();
+}
+
+int SkMatrixClipStateMgr::saveLayer(const SkRect* bounds, const SkPaint* paint, 
+                                    SkCanvas::SaveFlags flags) {
+    int result = this->save(flags);
+    ++fCurMCState->fLayerID;
+    fCurMCState->fIsSaveLayer = true;
+
+    fCurMCState->fSaveLayerBracketed = this->call(kOther_CallType);
+    fCurMCState->fSaveLayerBaseStateID = fCurOpenStateID;
+    fPicRecord->recordSaveLayer(bounds, paint, 
+                                (SkCanvas::SaveFlags)(flags| SkCanvas::kMatrixClip_SaveFlag));
+    return result;
+}
+
+void SkMatrixClipStateMgr::restore() {
+    SkDEBUGCODE(this->validate();)
+
+    if (fCurMCState->fIsSaveLayer) {
+        if (fCurMCState->fSaveLayerBaseStateID != fCurOpenStateID) {
+            fPicRecord->recordRestore(); // Close the open block
+        }
+        // The saveLayer's don't carry any matrix or clip state in the
+        // new scheme so make sure the saveLayer's recordRestore doesn't
+        // try to finalize them (i.e., fill in their skip offsets).
+        fPicRecord->recordRestore(false); // close of saveLayer
+
+        // Close the Save that brackets the saveLayer. TODO: this doesn't handle
+        // the skip offsets correctly
+        if (fCurMCState->fSaveLayerBracketed) {
+            fPicRecord->recordRestore(false);
+        }
+
+        // MC states can be allowed to fuse across saveLayer/restore boundaries
+        fCurOpenStateID = kIdentityWideOpenStateID;
+    }
+
+    fCurMCState->~MatrixClipState();       // balanced in save()
+    fMatrixClipStack.pop_back();
+    fCurMCState = (MatrixClipState*)fMatrixClipStack.back();
+
+    SkDEBUGCODE(this->validate();)
+}
+
+// kIdentityWideOpenStateID (0) is reserved for the identity/wide-open clip state
+int32_t SkMatrixClipStateMgr::NewMCStateID() {
+    // TODO: guard against wrap around
+    // TODO: make uint32_t
+    static int32_t gMCStateID = kIdentityWideOpenStateID;
+    ++gMCStateID;
+    return gMCStateID;
+}
+
+bool SkMatrixClipStateMgr::call(CallType callType) {
+    SkDEBUGCODE(this->validate();)
+
+    if (kMatrix_CallType == callType || kClip_CallType == callType) {
+        fCurMCState->fMCStateID = NewMCStateID();
+        SkDEBUGCODE(this->validate();)
+        return false;
+    }
+
+    SkASSERT(kOther_CallType == callType);
+
+    if (fCurMCState->fMCStateID == fCurOpenStateID) {
+        // Required MC state is already active one - nothing to do
+        SkDEBUGCODE(this->validate();)
+        return false;
+    }
+
+    if (kIdentityWideOpenStateID != fCurOpenStateID) {
+        fPicRecord->recordRestore();    // Close the open block
+    }
+    
+    // Install the required MC state as the active one
+    fCurOpenStateID = fCurMCState->fMCStateID;
+
+    fPicRecord->recordSave(SkCanvas::kMatrixClip_SaveFlag);
+
+    // write out clips
+    SkDeque::F2BIter iter(fMatrixClipStack);
+    bool firstClip = true;
+
+    SkMatrix curMat = SkMatrix::I();
+    for (const MatrixClipState* state = (const MatrixClipState*) iter.next();
+         state != NULL;
+         state = (const MatrixClipState*) iter.next()) {
+         state->fClipInfo->writeClip(&curMat, fPicRecord, &firstClip);
+    }
+
+    // write out matrix
+    if (!fCurMCState->fMatrixInfo->fMatrix.isIdentity()) {
+        // TODO: writing out the delta matrix here is an artifact of the writing 
+        // out of the entire clip stack (with its matrices). Ultimately we will 
+        // write out the CTM here when the clip state is collapsed to a single path.
+        WriteDeltaMat(fPicRecord, curMat, fCurMCState->fMatrixInfo->fMatrix);
+    }
+
+    SkDEBUGCODE(this->validate();)
+
+    return true;
+}
+
+void SkMatrixClipStateMgr::finish() {
+    if (kIdentityWideOpenStateID != fCurOpenStateID) {
+        fPicRecord->recordRestore();    // Close the open block
+        fCurOpenStateID = kIdentityWideOpenStateID;
+    }
+}
+
+#ifdef SK_DEBUG
+void SkMatrixClipStateMgr::validate() {
+    if (fCurOpenStateID == fCurMCState->fMCStateID) {
+        // The current state is the active one so all its skip offsets should
+        // still be -1
+        SkDeque::F2BIter iter(fMatrixClipStack);
+
+        for (const MatrixClipState* state = (const MatrixClipState*) iter.next();
+             state != NULL;
+             state = (const MatrixClipState*) iter.next()) {
+            state->fClipInfo->checkOffsetNotEqual(-1);
+        }
+    }
+}
+#endif

src/core/SkMatrixClipStateMgr.h

@@ -0,0 +1,343 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkMatrixClipStateMgr_DEFINED
+#define SkMatrixClipStateMgr_DEFINED
+
+#include "SkCanvas.h"
+#include "SkMatrix.h"
+#include "SkRegion.h"
+#include "SkRRect.h"
+#include "SkTypes.h"
+#include "SkTArray.h"
+
+class SkPictureRecord;
+class SkWriter32;
+
+// The SkMatrixClipStateMgr collapses the matrix/clip state of an SkPicture into
+// a series of save/restore blocks of consistent matrix clip state, e.g.:
+//
+//   save
+//     clip(s)
+//     concat
+//     ... draw ops ...
+//   restore
+//
+// SaveLayers simply add another level, e.g.:
+//
+//   save
+//     clip(s)
+//     concat
+//     ... draw ops ...
+//     saveLayer
+//       save
+//         clip(s)
+//         concat
+//         ... draw ops ...
+//       restore
+//     restore
+//   restore
+//
+// As a side effect of this process all saves and saveLayers will become
+// kMatrixClip_SaveFlag style saves/saveLayers.
+
+// The SkMatrixClipStateMgr works by intercepting all the save*, restore, clip*,
+// and matrix calls sent to SkCanvas in order to track the current matrix/clip
+// state. All the other canvas calls get funnelled into a generic "call" entry 
+// point that signals that a state block is required.
+class SkMatrixClipStateMgr {
+public:
+    static const int32_t kIdentityWideOpenStateID = 0;
+
+    class MatrixClipState {
+    public:
+        class MatrixInfo {
+        public:
+            SkMatrix fMatrix;
+            // TODO: add an internal dictionary and an ID here
+        };
+
+        class ClipInfo : public SkNoncopyable {
+        public:
+            ClipInfo() {}
+
+            bool clipRect(const SkRect& rect, 
+                          SkRegion::Op op, 
+                          bool doAA, 
+                          const SkMatrix& matrix) {
+                ClipOp& newClip = fClips.push_back();
+                newClip.fClipType = kRect_ClipType;
+                newClip.fGeom.fRRect.setRect(rect);   // storing the clipRect in the RRect
+                newClip.fOp = op;
+                newClip.fDoAA = doAA;
+                newClip.fMatrix = matrix;
+                newClip.fOffset = kInvalidJumpOffset;
+                return false;
+            }
+
+            bool clipRRect(const SkRRect& rrect, 
+                           SkRegion::Op op, 
+                           bool doAA, 
+                           const SkMatrix& matrix) {
+                ClipOp& newClip = fClips.push_back();
+                newClip.fClipType = kRRect_ClipType;
+                newClip.fGeom.fRRect = rrect;
+                newClip.fOp = op;
+                newClip.fDoAA = doAA;
+                newClip.fMatrix = matrix;
+                newClip.fOffset = kInvalidJumpOffset;
+                return false;
+            }
+
+            bool clipPath(SkPictureRecord* picRecord, 
+                          const SkPath& path, 
+                          SkRegion::Op op, 
+                          bool doAA, 
+                          const SkMatrix& matrix);
+            bool clipRegion(SkPictureRecord* picRecord, 
+                            const SkRegion& region, 
+                            SkRegion::Op op, 
+                            const SkMatrix& matrix);
+            void writeClip(SkMatrix* curMat, 
+                           SkPictureRecord* picRecord,
+                           bool* overrideFirstOp);
+            void fillInSkips(SkWriter32* writer, int32_t restoreOffset);
+
+#ifdef SK_DEBUG
+            void checkOffsetNotEqual(int32_t offset) {
+                for (int i = 0; i < fClips.count(); ++i) {
+                    ClipOp& curClip = fClips[i];
+                    SkASSERT(offset != curClip.fOffset);
+                }
+            }
+#endif
+        private:
+            enum ClipType {
+                kRect_ClipType,
+                kRRect_ClipType,
+                kPath_ClipType,
+                kRegion_ClipType
+            };
+
+            static const int kInvalidJumpOffset = -1;
+
+            class ClipOp {
+            public:
+                ClipOp() {}
+                ~ClipOp() {
+                    if (kRegion_ClipType == fClipType) {
+                        SkDELETE(fGeom.fRegion);
+                    }
+                }
+
+                ClipType     fClipType;
+
+                union {
+                    SkRRect         fRRect;        // also stores clipRect
+                    int             fPathID;
+                    // TODO: add internal dictionary of regions
+                    // This parameter forces us to have a dtor and thus use
+                    // SkTArray rather then SkTDArray!
+                    const SkRegion* fRegion;
+                } fGeom;
+
+                bool         fDoAA;
+                SkRegion::Op fOp;
+
+                // The CTM in effect when this clip call was issued
+                // TODO: add an internal dictionary and replace with ID
+                SkMatrix     fMatrix;
+
+                // The offset of this clipOp's "jump-to-offset" location in the skp.
+                // -1 means the offset hasn't been written.
+                int32_t      fOffset;
+            };
+
+            SkTArray<ClipOp> fClips;
+
+            typedef SkNoncopyable INHERITED;
+        };
+
+        MatrixClipState(MatrixClipState* prev, int flags) 
+#ifdef SK_DEBUG
+            : fPrev(prev)
+#endif
+        {
+            if (NULL == prev) {
+                fLayerID = 0;
+
+                fMatrixInfoStorage.fMatrix.reset();
+                fMatrixInfo = &fMatrixInfoStorage;
+                fClipInfo = &fClipInfoStorage;  // ctor handles init of fClipInfoStorage
+
+                // The identity/wide-open-clip state is current by default
+                fMCStateID = kIdentityWideOpenStateID;
+            } 
+            else {
+                fLayerID = prev->fLayerID;
+
+                if (flags & SkCanvas::kMatrix_SaveFlag) {
+                    fMatrixInfoStorage = *prev->fMatrixInfo;
+                    fMatrixInfo = &fMatrixInfoStorage;
+                } else {
+                    fMatrixInfo = prev->fMatrixInfo;
+                }
+
+                if (flags & SkCanvas::kClip_SaveFlag) {
+                    // We don't copy the ClipOps of the previous clip states
+                    fClipInfo = &fClipInfoStorage;
+                } else {
+                    fClipInfo = prev->fClipInfo;
+                }
+
+                // Initially a new save/saveLayer represents the same MC state
+                // as its predecessor.
+                fMCStateID = prev->fMCStateID;
+            }
+
+            fIsSaveLayer = false;
+        }
+
+        MatrixInfo*  fMatrixInfo;
+        MatrixInfo   fMatrixInfoStorage;
+
+        ClipInfo*    fClipInfo;
+        ClipInfo     fClipInfoStorage;
+
+        // Tracks the current depth of saveLayers to support the isDrawingToLayer call
+        int          fLayerID;
+        // Does this MC state represent a saveLayer call?
+        bool         fIsSaveLayer;
+
+        // The next two fields are only valid when fIsSaveLayer is set.
+        int32_t      fSaveLayerBaseStateID;
+        bool         fSaveLayerBracketed;
+
+#ifdef SK_DEBUG
+        MatrixClipState* fPrev; // debugging aid
+#endif
+
+        int32_t     fMCStateID;
+    };
+
+    enum CallType {
+        kMatrix_CallType,
+        kClip_CallType,
+        kOther_CallType
+    };
+
+    SkMatrixClipStateMgr();
+
+    void init(SkPictureRecord* picRecord) {
+        // Note: we're not taking a ref here. It is expected that the SkMatrixClipStateMgr
+        // is owned by the SkPictureRecord object
+        fPicRecord = picRecord; 
+    }
+
+    // TODO: need to override canvas' getSaveCount. Right now we pass the
+    // save* and restore calls on to the base SkCanvas in SkPictureRecord but
+    // this duplicates effort.
+    int getSaveCount() const { return fMatrixClipStack.count(); }
+
+    int save(SkCanvas::SaveFlags flags);
+
+    int saveLayer(const SkRect* bounds, const SkPaint* paint, SkCanvas::SaveFlags flags);
+
+    bool isDrawingToLayer() const {
+        return fCurMCState->fLayerID > 0;
+    }
+
+    void restore();
+
+    bool translate(SkScalar dx, SkScalar dy) {
+        this->call(kMatrix_CallType);
+        return fCurMCState->fMatrixInfo->fMatrix.preTranslate(dx, dy);
+    }
+
+    bool scale(SkScalar sx, SkScalar sy) {
+        this->call(kMatrix_CallType);
+        return fCurMCState->fMatrixInfo->fMatrix.preScale(sx, sy);
+    }
+
+    bool rotate(SkScalar degrees) {
+        this->call(kMatrix_CallType);
+        return fCurMCState->fMatrixInfo->fMatrix.preRotate(degrees);
+    }
+
+    bool skew(SkScalar sx, SkScalar sy) {
+        this->call(kMatrix_CallType);
+        return fCurMCState->fMatrixInfo->fMatrix.preSkew(sx, sy);
+    }
+
+    bool concat(const SkMatrix& matrix) {
+        this->call(kMatrix_CallType);
+        return fCurMCState->fMatrixInfo->fMatrix.preConcat(matrix);
+    }
+
+    void setMatrix(const SkMatrix& matrix) {
+        this->call(kMatrix_CallType);
+        fCurMCState->fMatrixInfo->fMatrix = matrix;
+    }
+
+    bool clipRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
+        this->call(SkMatrixClipStateMgr::kClip_CallType);
+        return fCurMCState->fClipInfo->clipRect(rect, op, doAA,
+                                                fCurMCState->fMatrixInfo->fMatrix);
+    }
+
+    bool clipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
+        this->call(SkMatrixClipStateMgr::kClip_CallType);
+        return fCurMCState->fClipInfo->clipRRect(rrect, op, doAA,
+                                                 fCurMCState->fMatrixInfo->fMatrix);
+    }
+
+    bool clipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
+        this->call(SkMatrixClipStateMgr::kClip_CallType);
+        return fCurMCState->fClipInfo->clipPath(fPicRecord, path, op, doAA,
+                                                fCurMCState->fMatrixInfo->fMatrix);
+    }
+
+    bool clipRegion(const SkRegion& region, SkRegion::Op op) {
+        this->call(SkMatrixClipStateMgr::kClip_CallType);
+        return fCurMCState->fClipInfo->clipRegion(fPicRecord, region, op,
+                                                  fCurMCState->fMatrixInfo->fMatrix);
+    }
+
+    bool call(CallType callType);
+
+    void fillInSkips(SkWriter32* writer, int32_t restoreOffset) {
+        // Since we write out the entire clip stack at each block start we
+        // need to update the skips for the entire stack each time too.
+        SkDeque::F2BIter iter(fMatrixClipStack);
+
+        for (const MatrixClipState* state = (const MatrixClipState*) iter.next();
+             state != NULL;
+             state = (const MatrixClipState*) iter.next()) {
+            state->fClipInfo->fillInSkips(writer, restoreOffset);
+        }
+    }
+
+    void finish();
+
+protected:
+    SkPictureRecord* fPicRecord;
+
+    uint32_t         fMatrixClipStackStorage[43]; // sized to fit 2 clip states
+    SkDeque          fMatrixClipStack;
+    MatrixClipState* fCurMCState;
+
+    // The MCStateID of the state currently in effect in the byte stream. 0 if none.
+    int32_t          fCurOpenStateID;
+
+    SkDEBUGCODE(void validate();)
+
+    static void WriteDeltaMat(SkPictureRecord* picRecord,
+                              const SkMatrix& current, 
+                              const SkMatrix& desired);
+    static int32_t   NewMCStateID();
+};
+
+#endif

src/core/SkPictureRecord.cpp

@@ -43,9 +43,15 @@ SkPictureRecord::SkPictureRecord(uint32_t flags, SkBaseDevice* device)
     fBitmapHeap = SkNEW(SkBitmapHeap);
     fFlattenableHeap.setBitmapStorage(fBitmapHeap);
     fPathHeap = NULL;   // lazy allocate
+#ifndef SK_COLLAPSE_MATRIX_CLIP_STATE
     fFirstSavedLayerIndex = kNoSavedLayerIndex;
+#endif
 
     fInitialSaveCount = kNoInitialSave;
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.init(this);
+#endif
 }
 
 SkPictureRecord::~SkPictureRecord() {
@@ -139,10 +145,15 @@ SkBaseDevice* SkPictureRecord::setDevice(SkBaseDevice* device) {
 }
 
 int SkPictureRecord::save(SaveFlags flags) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.save(flags);
+#else
     // record the offset to us, making it non-positive to distinguish a save
     // from a clip entry.
     fRestoreOffsetStack.push(-(int32_t)fWriter.bytesWritten());
     this->recordSave(flags);
+#endif
     return this->INHERITED::save(flags);
 }
 
@@ -157,6 +168,11 @@ void SkPictureRecord::recordSave(SaveFlags flags) {
 
 int SkPictureRecord::saveLayer(const SkRect* bounds, const SkPaint* paint,
                                SaveFlags flags) {
+
+    int count;
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    count = fMCMgr.saveLayer(bounds, paint, flags);
+#else
     // record the offset to us, making it non-positive to distinguish a save
     // from a clip entry.
     fRestoreOffsetStack.push(-(int32_t)fWriter.bytesWritten());
@@ -164,6 +180,7 @@ int SkPictureRecord::saveLayer(const SkRect* bounds, const SkPaint* paint,
     if (kNoSavedLayerIndex == fFirstSavedLayerIndex) {
         fFirstSavedLayerIndex = fRestoreOffsetStack.count();
     }
+#endif
 
     /*  Don't actually call INHERITED::saveLayer, because that will try to allocate
         an offscreen device (potentially very big) which we don't actually need
@@ -171,13 +188,13 @@ int SkPictureRecord::saveLayer(const SkRect* bounds, const SkPaint* paint,
         clip starts out the size of the picture, which is often much larger
         than the size of the actual device we'll use during playback).
      */
-    int count = this->INHERITED::save(flags);
+    count = this->INHERITED::save(flags);
     this->clipRectBounds(bounds, flags, NULL);
     return count;
 }
 
 void SkPictureRecord::recordSaveLayer(const SkRect* bounds, const SkPaint* paint,
-                                    SaveFlags flags) {
+                                      SaveFlags flags) {
     // op + bool for 'bounds'
     uint32_t size = 2 * kUInt32Size;
     if (NULL != bounds) {
@@ -198,7 +215,11 @@ void SkPictureRecord::recordSaveLayer(const SkRect* bounds, const SkPaint* paint
 }
 
 bool SkPictureRecord::isDrawingToLayer() const {
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    return fMCMgr.isDrawingToLayer();
+#else
     return fFirstSavedLayerIndex != kNoSavedLayerIndex;
+#endif
 }
 
 /*
@@ -577,6 +598,14 @@ void SkPictureRecord::restore() {
     SkASSERT(fRestoreOffsetStack.count() > 1);
 #endif
 
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    if (fMCMgr.getSaveCount() == 1) {
+        return;
+    }
+
+    // TODO: don't write the restore to the op stream for normal saves
+    fMCMgr.restore();
+#else
     // check for underflow
     if (fRestoreOffsetStack.count() == 0) {
         return;
@@ -609,59 +638,86 @@ void SkPictureRecord::restore() {
     }
 
     fRestoreOffsetStack.pop();
+#endif
 
     return this->INHERITED::restore();
 }
 
-void SkPictureRecord::recordRestore() {
+void SkPictureRecord::recordRestore(bool fillInSkips) {
     uint32_t initialOffset, size;
-    this->fillRestoreOffsetPlaceholdersForCurrentStackLevel((uint32_t)fWriter.bytesWritten());
+    if (fillInSkips) {
+        this->fillRestoreOffsetPlaceholdersForCurrentStackLevel((uint32_t)fWriter.bytesWritten());
+    }
     size = 1 * kUInt32Size; // RESTORE consists solely of 1 op code
     initialOffset = this->addDraw(RESTORE, &size);
     this->validate(initialOffset, size);
 }
 
 bool SkPictureRecord::translate(SkScalar dx, SkScalar dy) {
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.translate(dx, dy);
+#else
     // op + dx + dy
     uint32_t size = 1 * kUInt32Size + 2 * sizeof(SkScalar);
     size_t initialOffset = this->addDraw(TRANSLATE, &size);
     this->addScalar(dx);
     this->addScalar(dy);
     this->validate(initialOffset, size);
+#endif
     return this->INHERITED::translate(dx, dy);
 }
 
 bool SkPictureRecord::scale(SkScalar sx, SkScalar sy) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.scale(sx, sy);
+#else
     // op + sx + sy
     uint32_t size = 1 * kUInt32Size + 2 * sizeof(SkScalar);
     size_t initialOffset = this->addDraw(SCALE, &size);
     this->addScalar(sx);
     this->addScalar(sy);
     this->validate(initialOffset, size);
+#endif
     return this->INHERITED::scale(sx, sy);
 }
 
 bool SkPictureRecord::rotate(SkScalar degrees) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.rotate(degrees);
+#else
     // op + degrees
     uint32_t size = 1 * kUInt32Size + sizeof(SkScalar);
     size_t initialOffset = this->addDraw(ROTATE, &size);
     this->addScalar(degrees);
     this->validate(initialOffset, size);
+#endif
     return this->INHERITED::rotate(degrees);
 }
 
 bool SkPictureRecord::skew(SkScalar sx, SkScalar sy) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.skew(sx, sy);
+#else
     // op + sx + sy
     uint32_t size = 1 * kUInt32Size + 2 * sizeof(SkScalar);
     size_t initialOffset = this->addDraw(SKEW, &size);
     this->addScalar(sx);
     this->addScalar(sy);
     this->validate(initialOffset, size);
+#endif
     return this->INHERITED::skew(sx, sy);
 }
 
 bool SkPictureRecord::concat(const SkMatrix& matrix) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.concat(matrix);
+#else
     this->recordConcat(matrix);
+#endif
     return this->INHERITED::concat(matrix);
 }
 
@@ -675,12 +731,17 @@ void SkPictureRecord::recordConcat(const SkMatrix& matrix) {
 }
 
 void SkPictureRecord::setMatrix(const SkMatrix& matrix) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.setMatrix(matrix);
+#else
     this->validate(fWriter.bytesWritten(), 0);
     // op + matrix
     uint32_t size = kUInt32Size + matrix.writeToMemory(NULL);
     size_t initialOffset = this->addDraw(SET_MATRIX, &size);
     this->addMatrix(matrix);
     this->validate(initialOffset, size);
+#endif
     this->INHERITED::setMatrix(matrix);
 }
 
@@ -700,6 +761,11 @@ static bool regionOpExpands(SkRegion::Op op) {
     }
 }
 
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+void SkPictureRecord::fillRestoreOffsetPlaceholdersForCurrentStackLevel(uint32_t restoreOffset) {
+    fMCMgr.fillInSkips(&fWriter, restoreOffset);
+}
+#else
 void SkPictureRecord::fillRestoreOffsetPlaceholdersForCurrentStackLevel(uint32_t restoreOffset) {
     int32_t offset = fRestoreOffsetStack.top();
     while (offset > 0) {
@@ -715,6 +781,7 @@ void SkPictureRecord::fillRestoreOffsetPlaceholdersForCurrentStackLevel(uint32_t
     SkASSERT(SAVE == drawOp || SAVE_LAYER == drawOp);
 #endif
 }
+#endif
 
 void SkPictureRecord::beginRecording() {
     // we have to call this *after* our constructor, to ensure that it gets
@@ -726,8 +793,18 @@ void SkPictureRecord::beginRecording() {
 void SkPictureRecord::endRecording() {
     SkASSERT(kNoInitialSave != fInitialSaveCount);
     this->restoreToCount(fInitialSaveCount);
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.finish();
+#endif
 }
 
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+int SkPictureRecord::recordRestoreOffsetPlaceholder(SkRegion::Op op) {
+    size_t offset = fWriter.bytesWritten();
+    this->addInt(-1);
+    return offset;
+}
+#else
 int SkPictureRecord::recordRestoreOffsetPlaceholder(SkRegion::Op op) {
     if (fRestoreOffsetStack.isEmpty()) {
         return -1;
@@ -757,22 +834,30 @@ int SkPictureRecord::recordRestoreOffsetPlaceholder(SkRegion::Op op) {
     fRestoreOffsetStack.top() = offset;
     return offset;
 }
+#endif
 
 bool SkPictureRecord::clipRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.clipRect(rect, op, doAA);
+#else
     this->recordClipRect(rect, op, doAA);
+#endif
     return this->INHERITED::clipRect(rect, op, doAA);
 }
 
 int SkPictureRecord::recordClipRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
-
     // id + rect + clip params
     uint32_t size = 1 * kUInt32Size + sizeof(rect) + 1 * kUInt32Size;
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    size += kUInt32Size;    // + restore offset
+#else
     // recordRestoreOffsetPlaceholder doesn't always write an offset
     if (!fRestoreOffsetStack.isEmpty()) {
         // + restore offset
         size += kUInt32Size;
     }
-
+#endif
     size_t initialOffset = this->addDraw(CLIP_RECT, &size);
     this->addRect(rect);
     this->addInt(ClipParams_pack(op, doAA));
@@ -787,7 +872,11 @@ bool SkPictureRecord::clipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA
         return this->SkPictureRecord::clipRect(rrect.getBounds(), op, doAA);
     }
 
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.clipRRect(rrect, op, doAA);
+#else
     this->recordClipRRect(rrect, op, doAA);
+#endif
     if (fRecordFlags & SkPicture::kUsePathBoundsForClip_RecordingFlag) {
         return this->updateClipConservativelyUsingBounds(rrect.getBounds(), op, false);
     } else {
@@ -796,19 +885,21 @@ bool SkPictureRecord::clipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA
 }
 
 int SkPictureRecord::recordClipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
-
     // op + rrect + clip params
     uint32_t size = 1 * kUInt32Size + SkRRect::kSizeInMemory + 1 * kUInt32Size;
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    size += kUInt32Size;    // + restore offset
+#else
     // recordRestoreOffsetPlaceholder doesn't always write an offset
     if (!fRestoreOffsetStack.isEmpty()) {
         // + restore offset
         size += kUInt32Size;
     }
+#endif
     size_t initialOffset = this->addDraw(CLIP_RRECT, &size);
     this->addRRect(rrect);
     this->addInt(ClipParams_pack(op, doAA));
     int offset = recordRestoreOffsetPlaceholder(op);
-
     this->validate(initialOffset, size);
     return offset;
 }
@@ -820,8 +911,12 @@ bool SkPictureRecord::clipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
         return this->clipRect(r, op, doAA);
     }
 
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.clipPath(path, op, doAA);
+#else
     int pathID = this->addPathToHeap(path);
     this->recordClipPath(pathID, op, doAA);
+#endif
 
     if (fRecordFlags & SkPicture::kUsePathBoundsForClip_RecordingFlag) {
         return this->updateClipConservativelyUsingBounds(path.getBounds(), op,
@@ -832,36 +927,47 @@ bool SkPictureRecord::clipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
 }
 
 int SkPictureRecord::recordClipPath(int pathID, SkRegion::Op op, bool doAA) {
-
     // op + path index + clip params
     uint32_t size = 3 * kUInt32Size;
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    size += kUInt32Size;    // + restore offset
+#else
     // recordRestoreOffsetPlaceholder doesn't always write an offset
     if (!fRestoreOffsetStack.isEmpty()) {
         // + restore offset
         size += kUInt32Size;
     }
+#endif
     size_t initialOffset = this->addDraw(CLIP_PATH, &size);
     this->addInt(pathID);
     this->addInt(ClipParams_pack(op, doAA));
     int offset = recordRestoreOffsetPlaceholder(op);
-
     this->validate(initialOffset, size);
     return offset;
 }
 
 bool SkPictureRecord::clipRegion(const SkRegion& region, SkRegion::Op op) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.clipRegion(region, op);
+#else
     this->recordClipRegion(region, op);
+#endif
     return this->INHERITED::clipRegion(region, op);
 }
 
 int SkPictureRecord::recordClipRegion(const SkRegion& region, SkRegion::Op op) {
     // op + clip params + region
     uint32_t size = 2 * kUInt32Size + region.writeToMemory(NULL);
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    size += kUInt32Size;    // + restore offset
+#else
     // recordRestoreOffsetPlaceholder doesn't always write an offset
     if (!fRestoreOffsetStack.isEmpty()) {
         // + restore offset
         size += kUInt32Size;
     }
+#endif
     size_t initialOffset = this->addDraw(CLIP_REGION, &size);
     this->addRegion(region);
     this->addInt(ClipParams_pack(op, false));
@@ -872,6 +978,11 @@ int SkPictureRecord::recordClipRegion(const SkRegion& region, SkRegion::Op op) {
 }
 
 void SkPictureRecord::clear(SkColor color) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     // op + color
     uint32_t size = 2 * kUInt32Size;
     size_t initialOffset = this->addDraw(DRAW_CLEAR, &size);
@@ -880,6 +991,11 @@ void SkPictureRecord::clear(SkColor color) {
 }
 
 void SkPictureRecord::drawPaint(const SkPaint& paint) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     // op + paint index
     uint32_t size = 2 * kUInt32Size;
     size_t initialOffset = this->addDraw(DRAW_PAINT, &size);
@@ -890,6 +1006,11 @@ void SkPictureRecord::drawPaint(const SkPaint& paint) {
 
 void SkPictureRecord::drawPoints(PointMode mode, size_t count, const SkPoint pts[],
                                  const SkPaint& paint) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     // op + paint index + mode + count + point data
     uint32_t size = 4 * kUInt32Size + count * sizeof(SkPoint);
     size_t initialOffset = this->addDraw(DRAW_POINTS, &size);
@@ -902,6 +1023,11 @@ void SkPictureRecord::drawPoints(PointMode mode, size_t count, const SkPoint pts
 }
 
 void SkPictureRecord::drawOval(const SkRect& oval, const SkPaint& paint) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     // op + paint index + rect
     uint32_t size = 2 * kUInt32Size + sizeof(oval);
     size_t initialOffset = this->addDraw(DRAW_OVAL, &size);
@@ -912,6 +1038,11 @@ void SkPictureRecord::drawOval(const SkRect& oval, const SkPaint& paint) {
 }
 
 void SkPictureRecord::drawRect(const SkRect& rect, const SkPaint& paint) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     // op + paint index + rect
     uint32_t size = 2 * kUInt32Size + sizeof(rect);
     size_t initialOffset = this->addDraw(DRAW_RECT, &size);
@@ -922,6 +1053,11 @@ void SkPictureRecord::drawRect(const SkRect& rect, const SkPaint& paint) {
 }
 
 void SkPictureRecord::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     if (rrect.isRect()) {
         this->SkPictureRecord::drawRect(rrect.getBounds(), paint);
     } else if (rrect.isOval()) {
@@ -939,6 +1075,11 @@ void SkPictureRecord::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
 }
 
 void SkPictureRecord::drawPath(const SkPath& path, const SkPaint& paint) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     // op + paint index + path index
     uint32_t size = 3 * kUInt32Size;
     size_t initialOffset = this->addDraw(DRAW_PATH, &size);
@@ -953,6 +1094,11 @@ void SkPictureRecord::drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar
     if (bitmap.drawsNothing()) {
         return;
     }
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     // op + paint index + bitmap index + left + top
     uint32_t size = 3 * kUInt32Size + 2 * sizeof(SkScalar);
     size_t initialOffset = this->addDraw(DRAW_BITMAP, &size);
@@ -970,6 +1116,10 @@ void SkPictureRecord::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect*
     if (bitmap.drawsNothing()) {
         return;
     }
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
     // id + paint index + bitmap index + bool for 'src' + flags
     uint32_t size = 5 * kUInt32Size;
     if (NULL != src) {
@@ -993,6 +1143,11 @@ void SkPictureRecord::drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m
     if (bitmap.drawsNothing()) {
         return;
     }
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     // id + paint index + bitmap index + matrix
     uint32_t size = 3 * kUInt32Size + matrix.writeToMemory(NULL);
     size_t initialOffset = this->addDraw(DRAW_BITMAP_MATRIX, &size);
@@ -1008,6 +1163,11 @@ void SkPictureRecord::drawBitmapNine(const SkBitmap& bitmap, const SkIRect& cent
     if (bitmap.drawsNothing()) {
         return;
     }
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     // op + paint index + bitmap id + center + dst rect
     uint32_t size = 3 * kUInt32Size + sizeof(center) + sizeof(dst);
     size_t initialOffset = this->addDraw(DRAW_BITMAP_NINE, &size);
@@ -1024,6 +1184,11 @@ void SkPictureRecord::drawSprite(const SkBitmap& bitmap, int left, int top,
     if (bitmap.drawsNothing()) {
         return;
     }
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     // op + paint index + bitmap index + left + top
     uint32_t size = 5 * kUInt32Size;
     size_t initialOffset = this->addDraw(DRAW_SPRITE, &size);
@@ -1056,6 +1221,11 @@ void SkPictureRecord::addFontMetricsTopBottom(const SkPaint& paint, const SkFlat
 
 void SkPictureRecord::drawText(const void* text, size_t byteLength, SkScalar x,
                       SkScalar y, const SkPaint& paint) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     bool fast = !paint.isVerticalText() && paint.canComputeFastBounds();
 
     // op + paint index + length + 'length' worth of chars + x + y
@@ -1080,6 +1250,11 @@ void SkPictureRecord::drawText(const void* text, size_t byteLength, SkScalar x,
 
 void SkPictureRecord::drawPosText(const void* text, size_t byteLength,
                          const SkPoint pos[], const SkPaint& paint) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     size_t points = paint.countText(text, byteLength);
     if (0 == points)
         return;
@@ -1166,6 +1341,10 @@ void SkPictureRecord::drawPosTextH(const void* text, size_t byteLength,
                           const SkScalar xpos[], SkScalar constY,
                           const SkPaint& paint) {
 
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     const SkFlatData* flatPaintData = this->getFlatPaintData(paint);
     this->drawPosTextHImpl(text, byteLength, xpos, constY, paint, flatPaintData);
 }
@@ -1212,6 +1391,11 @@ void SkPictureRecord::drawPosTextHImpl(const void* text, size_t byteLength,
 void SkPictureRecord::drawTextOnPath(const void* text, size_t byteLength,
                             const SkPath& path, const SkMatrix* matrix,
                             const SkPaint& paint) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     // op + paint index + length + 'length' worth of data + path index + matrix
     const SkMatrix& m = matrix ? *matrix : SkMatrix::I();
     uint32_t size = 3 * kUInt32Size + SkAlign4(byteLength) + kUInt32Size + m.writeToMemory(NULL);
@@ -1225,6 +1409,11 @@ void SkPictureRecord::drawTextOnPath(const void* text, size_t byteLength,
 }
 
 void SkPictureRecord::drawPicture(SkPicture& picture) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     // op + picture index
     uint32_t size = 2 * kUInt32Size;
     size_t initialOffset = this->addDraw(DRAW_PICTURE, &size);
@@ -1237,6 +1426,11 @@ void SkPictureRecord::drawVertices(VertexMode vmode, int vertexCount,
                           const SkColor colors[], SkXfermode* xfer,
                           const uint16_t indices[], int indexCount,
                           const SkPaint& paint) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     uint32_t flags = 0;
     if (texs) {
         flags |= DRAW_VERTICES_HAS_TEXS;
@@ -1296,6 +1490,11 @@ void SkPictureRecord::drawVertices(VertexMode vmode, int vertexCount,
 }
 
 void SkPictureRecord::drawData(const void* data, size_t length) {
+
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+
     // op + length + 'length' worth of data
     uint32_t size = 2 * kUInt32Size + SkAlign4(length);
     size_t initialOffset = this->addDraw(DRAW_DATA, &size);

src/core/SkPictureRecord.h

@@ -10,6 +10,9 @@
 
 #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"
@@ -111,11 +114,13 @@ private:
     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'
@@ -250,7 +255,7 @@ protected:
     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.
@@ -261,6 +266,9 @@ protected:
     SkBitmapHeap* fBitmapHeap;
 
 private:
+    friend class MatrixClipState; // for access to *Impl methods
+    friend class SkMatrixClipStateMgr; // for access to *Impl methods
+
     SkChunkFlatController fFlattenableHeap;
 
     SkPaintDictionary fPaints;
@@ -277,6 +285,10 @@ private:
     friend class SkPicturePlayback;
     friend class SkPictureTester; // for unit testing
 
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    SkMatrixClipStateMgr fMCMgr;
+#endif
+
     typedef SkCanvas INHERITED;
 };
 

tests/MatrixClipCollapseTest.cpp

@@ -52,7 +52,10 @@
 //        system is ready for prime time
 //   bench the recording times with/without matrix/clip collapsing
 
-#ifdef COLLAPSE_MATRIX_CLIP_STATE
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+
+// Enable/disable debugging helper code
+//#define TEST_COLLAPSE_MATRIX_CLIP_STATE 1
 
 // Extract the command ops from the input SkPicture
 static void gets_ops(SkPicture& input, SkTDArray<DrawType>* ops) {
@@ -623,7 +626,7 @@ static void emit_struct3(SkCanvas* canvas,
 
 //////////////////////////////////////////////////////////////////////////////
 
-#ifdef COLLAPSE_MATRIX_CLIP_STATE
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
 static void print(const SkTDArray<DrawType>& expected, const SkTDArray<DrawType>& actual) {
     SkDebugf("\n\nexpected %d --- actual %d\n", expected.count(), actual.count());
     int max = SkMax32(expected.count(), actual.count());
@@ -658,7 +661,7 @@ static void test_collapse(skiatest::Reporter* reporter) {
                 for (int l = 0; l < kMatTypeCount; ++l) {
                     for (int m = 0; m < kClipTypeCount; ++m) {
                         for (int n = 0; n < kDrawOpTypeCount; ++n) {
-#ifdef COLLAPSE_MATRIX_CLIP_STATE
+#ifdef TEST_COLLAPSE_MATRIX_CLIP_STATE
                             static int testID = -1;
                             ++testID;
                             if (testID < -1) {
@@ -686,7 +689,7 @@ static void test_collapse(skiatest::Reporter* reporter) {
                             REPORTER_ASSERT(reporter, expected.count() == actual.count());
 
                             if (expected.count() != actual.count()) {
-#ifdef COLLAPSE_MATRIX_CLIP_STATE
+#ifdef TEST_COLLAPSE_MATRIX_CLIP_STATE
                                 print(expected, actual);
 #endif
                                 continue;
@@ -694,7 +697,7 @@ static void test_collapse(skiatest::Reporter* reporter) {
 
                             for (int i = 0; i < expected.count(); ++i) {
                                 REPORTER_ASSERT(reporter, expected[i] == actual[i]);
-#ifdef COLLAPSE_MATRIX_CLIP_STATE
+#ifdef TEST_COLLAPSE_MATRIX_CLIP_STATE
                                 if (expected[i] != actual[i]) {
                                     print(expected, actual);
                                 }