Simplify storage of MC State stack

src/core/SkMatrixClipStateMgr.cpp

 /*
  * 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"
 
@@ skipping 10 matching lines @@
     newClip->fOp = op;
     newClip->fDoAA = doAA;
     newClip->fMatrixID = matrixID;
     return false;
 }
 
 bool SkMatrixClipStateMgr::MatrixClipState::ClipInfo::clipRegion(SkPictureRecord* picRecord,
                                                                  int regionID,
                                                                  SkRegion::Op op,
                                                                  int matrixID) {
-    // TODO: add a region dictionary so we don't have to copy the region in here
     ClipOp* newClip = fClips.append();
     newClip->fClipType = kRegion_ClipType;
     newClip->fGeom.fRegionID = regionID;
     newClip->fOp = op;
     newClip->fDoAA = true;      // not necessary but sanity preserving
     newClip->fMatrixID = matrixID;
     return false;
 }
 
 void SkMatrixClipStateMgr::writeDeltaMat(int currentMatID, int desiredMatID) {
@@ skipping 117 matching lines @@
     ++fCurMCState->fLayerID;
     fCurMCState->fIsSaveLayer = true;
 
 #ifdef SK_DEBUG
     if (saved) {
         fCurMCState->fExpectedDepth++; // 1 for nesting save
     }
     fCurMCState->fExpectedDepth++;   // 1 for saveLayer
 #endif
 
-    fCurMCState->fSaveLayerBaseStateID = fCurOpenStateID;
+    *fStateIDStack.append() = fCurOpenStateID;
     fCurMCState->fSavedSkipOffsets = fSkipOffsets;
 
     // TODO: recycle these rather then new & deleting them on every saveLayer/
     // restore
     fSkipOffsets = SkNEW(SkTDArray<int>);
 
     fPicRecord->recordSaveLayer(bounds, paint,
                                 (SkCanvas::SaveFlags)(flags| SkCanvas::kMatrixClip_SaveFlag));
 #ifdef SK_DEBUG
     fActualDepth++;
@@ skipping 18 matching lines @@
 
         // 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
 #ifdef SK_DEBUG
         SkASSERT(fActualDepth > 0);
         fActualDepth--;
 #endif
 
-        fCurOpenStateID = fCurMCState->fSaveLayerBaseStateID;
+        SkASSERT(fStateIDStack.count() >= 1);
+        fCurOpenStateID = fStateIDStack[fStateIDStack.count()-1];
+        fStateIDStack.pop();
 
         SkASSERT(0 == fSkipOffsets->count());
         SkASSERT(NULL != fCurMCState->fSavedSkipOffsets);
 
         SkDELETE(fSkipOffsets);
         fSkipOffsets = fCurMCState->fSavedSkipOffsets;
     }
 
     bool prevHadOpen = fCurMCState->fHasOpen;
     bool prevWasSaveLayer = fCurMCState->fIsSaveLayer;
@@ skipping 17 matching lines @@
 
 // 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::isCurrentlyOpen(int32_t stateID) {
-    if (fCurMCState->fIsSaveLayer)
-        return false;
-
-    SkDeque::Iter iter(fMatrixClipStack, SkDeque::Iter::kBack_IterStart);
-
-    for (const MatrixClipState* state = (const MatrixClipState*) iter.prev();
-         state != NULL;
-         state = (const MatrixClipState*) iter.prev()) {
-        if (state->fIsSaveLayer) {
-            if (state->fSaveLayerBaseStateID == stateID) {
-                return true;
-            }
-        }
-    }
-
-    return false;
+bool SkMatrixClipStateMgr::isNestingMCState(int stateID) {
+    return fStateIDStack.count() > 0 && fStateIDStack[fStateIDStack.count()-1] == fCurOpenStateID;
 }
 
 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 &&
-        !this->isCurrentlyOpen(fCurOpenStateID)) {
+        !this->isNestingMCState(fCurOpenStateID)) {
         // Don't write a restore if the open state is one in which a saveLayer
         // is nested. The save after the saveLayer's restore will close it.
         fPicRecord->recordRestore();    // Close the open block
         fCurMCState->fHasOpen = false;
 #ifdef SK_DEBUG
         SkASSERT(fActualDepth > 0);
         fActualDepth--;
 #endif
     }
 
@@ skipping 96 matching lines @@
         SkASSERT(fActualDepth > 0);
         fActualDepth--;
 #endif
         fCurOpenStateID = kIdentityWideOpenStateID;
         SkASSERT(!fCurMCState->fHasOpen);
     }
 }
 
 #ifdef SK_DEBUG
 void SkMatrixClipStateMgr::validate() {
-    if (fCurOpenStateID == fCurMCState->fMCStateID &&
-            (!fCurMCState->fIsSaveLayer ||
-             fCurOpenStateID != fCurMCState->fSaveLayerBaseStateID)) {
+    if (fCurOpenStateID == fCurMCState->fMCStateID && !this->isNestingMCState(fCurOpenStateID)) {
         // The current state is the active one so it should have a skip
         // offset for each clip
         SkDeque::Iter iter(fMatrixClipStack, SkDeque::Iter::kBack_IterStart);
         int clipCount = 0;
         for (const MatrixClipState* state = (const MatrixClipState*) iter.prev();
              state != NULL;
              state = (const MatrixClipState*) iter.prev()) {
             if (NULL == state->fPrev || state->fPrev->fClipInfo != state->fClipInfo) {
                 clipCount += state->fClipInfo->numClips();
             }
@@ skipping 14 matching lines @@
 }
 
 int SkMatrixClipStateMgr::addMatToDict(const SkMatrix& mat) {
     if (mat.isIdentity()) {
         return kIdentityMatID;
     }
 
     *fMatrixDict.append() = mat;
     return fMatrixDict.count()-1;
 }