SaveFlags be-gone

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 92 matching lines @@
                        fMatrixClipStackStorage,
                        sizeof(fMatrixClipStackStorage))
     , fCurOpenStateID(kIdentityWideOpenStateID) {
 
     fSkipOffsets = SkNEW(SkTDArray<int>);
 
     // The first slot in the matrix dictionary is reserved for the identity matrix
     fMatrixDict.append()->reset();
 
     fCurMCState = (MatrixClipState*)fMatrixClipStack.push_back();
-    new (fCurMCState) MatrixClipState(NULL, 0);    // balanced in restore()
+    new (fCurMCState) MatrixClipState(NULL);    // balanced in restore()
 
 #ifdef SK_DEBUG
     fActualDepth = 0;
 #endif
 }
 
 SkMatrixClipStateMgr::~SkMatrixClipStateMgr() {
     for (int i = 0; i < fRegionDict.count(); ++i) {
         SkDELETE(fRegionDict[i]);
     }
 
     SkDELETE(fSkipOffsets);
 }
 
 
-int SkMatrixClipStateMgr::MCStackPush(SkCanvas::SaveFlags flags) {
+int SkMatrixClipStateMgr::MCStackPush() {
     MatrixClipState* newTop = (MatrixClipState*)fMatrixClipStack.push_back();
-    new (newTop) MatrixClipState(fCurMCState, flags); // balanced in restore()
+    new (newTop) MatrixClipState(fCurMCState); // balanced in restore()
     fCurMCState = newTop;
 
     SkDEBUGCODE(this->validate();)
 
     return fMatrixClipStack.count();
 }
 
-int SkMatrixClipStateMgr::save(SkCanvas::SaveFlags flags) {
+int SkMatrixClipStateMgr::save() {
     SkDEBUGCODE(this->validate();)
 
-    return this->MCStackPush(flags);
+    return this->MCStackPush();
 }
 
 int SkMatrixClipStateMgr::saveLayer(const SkRect* bounds, const SkPaint* paint,
                                     SkCanvas::SaveFlags flags) {
 #ifdef SK_DEBUG
     if (fCurMCState->fIsSaveLayer) {
         SkASSERT(0 == fSkipOffsets->count());
     }
 #endif
 
     // Since the saveLayer call draws something we need to potentially dump
     // out the MC state
     SkDEBUGCODE(bool saved =) this->call(kOther_CallType);
 
-    int result = this->MCStackPush(flags);
+    int result = this->MCStackPush();
     ++fCurMCState->fLayerID;
     fCurMCState->fIsSaveLayer = true;
 
 #ifdef SK_DEBUG
     if (saved) {
         fCurMCState->fExpectedDepth++; // 1 for nesting save
     }
     fCurMCState->fExpectedDepth++;   // 1 for saveLayer
 #endif
 
     *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, flags | SkCanvas::kMatrixClip_SaveFlag);
+    fPicRecord->recordSaveLayer(bounds, paint, flags);
 #ifdef SK_DEBUG
     fActualDepth++;
 #endif
     return result;
 }
 
 void SkMatrixClipStateMgr::restore() {
     SkDEBUGCODE(this->validate();)
 
     if (fCurMCState->fIsSaveLayer) {
@@ skipping 96 matching lines @@
     if (kIdentityWideOpenStateID == fCurOpenStateID) {
         SkASSERT(0 == fActualDepth);
         SkASSERT(!fCurMCState->fHasOpen);
         SkASSERT(0 == fSkipOffsets->count());
         return false;
     }
 
     SkASSERT(!fCurMCState->fHasOpen);
     SkASSERT(0 == fSkipOffsets->count());
     fCurMCState->fHasOpen = true;
-    fPicRecord->recordSave(SkCanvas::kMatrixClip_SaveFlag);
+    fPicRecord->recordSave();
 #ifdef SK_DEBUG
     fActualDepth++;
     SkASSERT(fActualDepth == fCurMCState->fExpectedDepth);
 #endif
 
     // write out clips
     SkDeque::Iter iter(fMatrixClipStack, SkDeque::Iter::kBack_IterStart);
     const MatrixClipState* state;
     // Loop back across the MC states until the last saveLayer. The MC
     // state in front of the saveLayer has already been written out.
@@ skipping 107 matching lines @@
 }
 
 int SkMatrixClipStateMgr::addMatToDict(const SkMatrix& mat) {
     if (mat.isIdentity()) {
         return kIdentityMatID;
     }
 
     *fMatrixDict.append() = mat;
     return fMatrixDict.count()-1;
 }