Make the canvas draw looper internal layer not part of SkCanvas save count

src/core/SkCanvas.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
 #include "SkBitmapDevice.h"
@@ skipping 180 matching lines @@
     DeviceCM*       fLayer;
     /*  If there are any layers in the stack, this points to the top-most
         one that is at or below this level in the stack (so we know what
         bitmap/device to draw into from this level. This value is NOT
         reference counted, since the real owner is either our fLayer field,
         or a previous one in a lower level.)
     */
     DeviceCM*       fTopLayer;
     SkRasterClip    fRasterClip;
     SkMatrix        fMatrix;
-    int             fDeferredSaveCount;
+    int             fSaveCount;  // The count of SkCanvas::save() calls when this rec was created.
 
-    MCRec(bool conservativeRasterClip) : fRasterClip(conservativeRasterClip) {
+    MCRec(bool conservativeRasterClip, int saveCount)
+            : fRasterClip(conservativeRasterClip)
+            , fSaveCount(saveCount) {
         fFilter     = NULL;
         fLayer      = NULL;
         fTopLayer   = NULL;
         fMatrix.reset();
-        fDeferredSaveCount = 0;
 
         // don't bother initializing fNext
         inc_rec();
     }
-    MCRec(const MCRec& prev) : fRasterClip(prev.fRasterClip), fMatrix(prev.fMatrix) {
+    MCRec(const MCRec& prev, int saveCount)
+            : fRasterClip(prev.fRasterClip), fMatrix(prev.fMatrix)
+            , fSaveCount(saveCount) {
         fFilter = SkSafeRef(prev.fFilter);
         fLayer = NULL;
         fTopLayer = prev.fTopLayer;
-        fDeferredSaveCount = 0;
 
         // don't bother initializing fNext
         inc_rec();
     }
     ~MCRec() {
         SkSafeUnref(fFilter);
         SkDELETE(fLayer);
         dec_rec();
     }
 };
@@ skipping 201 matching lines @@
     fConservativeRasterClip = SkToBool(flags & kConservativeRasterClip_InitFlag);
     fCachedLocalClipBounds.setEmpty();
     fCachedLocalClipBoundsDirty = true;
     fAllowSoftClip = true;
     fAllowSimplifyClip = false;
     fDeviceCMDirty = true;
     fSaveCount = 1;
     fMetaData = NULL;
 
     fMCRec = (MCRec*)fMCStack.push_back();
-    new (fMCRec) MCRec(fConservativeRasterClip);
+    new (fMCRec) MCRec(fConservativeRasterClip, fSaveCount);
 
     fMCRec->fLayer = SkNEW_ARGS(DeviceCM, (NULL, NULL, NULL, fConservativeRasterClip));
     fMCRec->fTopLayer = fMCRec->fLayer;
 
     fSurfaceBase = NULL;
 
     fClipStack.reset(SkNEW(SkClipStack));
 
     if (device) {
         device->initForRootLayer(fProps.pixelGeometry());
@@ skipping 88 matching lines @@
 {
     inc_canvas();
 
     SkAutoTUnref<SkBaseDevice> device(SkNEW_ARGS(SkBitmapDevice, (bitmap)));
     this->init(device, kDefault_InitFlags);
 }
 
 SkCanvas::~SkCanvas() {
     // free up the contents of our deque
     this->restoreToCount(1);    // restore everything but the last
-
     this->internalRestore();    // restore the last, since we're going away
 
     SkDELETE(fMetaData);
 
     dec_canvas();
 }
 
 SkDrawFilter* SkCanvas::getDrawFilter() const {
     return fMCRec->fFilter;
 }
@@ skipping 186 matching lines @@
                 layer->updateMC(totalMatrix, clip, *fClipStack, &clip);
             } while ((layer = layer->fNext) != NULL);
         }
         fDeviceCMDirty = false;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkCanvas::checkForDeferredSave() {
-    if (fMCRec->fDeferredSaveCount > 0) {
-        fMCRec->fDeferredSaveCount -= 1;
+    if (fMCRec->fSaveCount < fSaveCount) {
         this->doSave();
     }
 }
 
 int SkCanvas::getSaveCount() const {
-#ifdef SK_DEBUG
-    int count = 0;
-    SkDeque::Iter iter(fMCStack, SkDeque::Iter::kFront_IterStart);
-    for (;;) {
-        const MCRec* rec = (const MCRec*)iter.next();
-        if (!rec) {
-            break;
-        }
-        count += 1 + rec->fDeferredSaveCount;
-    }
-    SkASSERT(count == fSaveCount);
-#endif
     return fSaveCount;
 }
 
 int SkCanvas::save() {
     fSaveCount += 1;
-    fMCRec->fDeferredSaveCount += 1;
     return this->getSaveCount() - 1;  // return our prev value
 }
 
 void SkCanvas::doSave() {
     this->willSave();
     this->internalSave();
 }
 
 void SkCanvas::restore() {
-    if (fMCRec->fDeferredSaveCount > 0) {
-        SkASSERT(fSaveCount > 1);
-        fSaveCount -= 1;
-        fMCRec->fDeferredSaveCount -= 1;
-    } else {
-        // check for underflow
+    int deferredSaveCount = fSaveCount - fMCRec->fSaveCount;
+    SkASSERT(deferredSaveCount >= 0);
+    if (deferredSaveCount == 0) {
+        // Check if the client tried to restore() too many times.
         if (fMCStack.count() > 1) {
             this->willRestore();
-            SkASSERT(fSaveCount > 1);
+            this->internalRestore();
             fSaveCount -= 1;
-            this->internalRestore();
             this->didRestore();
         }
+    } else {
+        // The topmost save was deferred.
+        fSaveCount -= 1;
     }
+
+    // Note: we can not detect the case where errorneous SkCanvas::restore()
+    // is called within the SkDrawLooper callback.
 }
 
 void SkCanvas::restoreToCount(int count) {
     // sanity check
     if (count < 1) {
         count = 1;
     }
 
     int n = this->getSaveCount() - count;
     for (int i = 0; i < n; ++i) {
         this->restore();
     }
 }
 
 void SkCanvas::internalSave() {
     MCRec* newTop = (MCRec*)fMCStack.push_back();
-    new (newTop) MCRec(*fMCRec);    // balanced in restore()
+    new (newTop) MCRec(*fMCRec, fSaveCount);    // balanced in restore()
     fMCRec = newTop;
-
     fClipStack->save();
 }
 
 static bool bounds_affects_clip(SkCanvas::SaveFlags flags) {
 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
     return (flags & SkCanvas::kClipToLayer_SaveFlag) != 0;
 #else
     return true;
 #endif
 }
@@ skipping 40 matching lines @@
         *intersection = ir;
     }
     return true;
 }
 
 int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint) {
     if (gIgnoreSaveLayerBounds) {
         bounds = NULL;
     }
     SaveLayerStrategy strategy = this->willSaveLayer(bounds, paint, kARGB_ClipLayer_SaveFlag);
-    fSaveCount += 1;
+    fSaveCount++;
     this->internalSaveLayer(bounds, paint, kARGB_ClipLayer_SaveFlag, strategy);
     return this->getSaveCount() - 1;
 }
 
 int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags) {
     if (gIgnoreSaveLayerBounds) {
         bounds = NULL;
     }
     SaveLayerStrategy strategy = this->willSaveLayer(bounds, paint, flags);
-    fSaveCount += 1;
+    fSaveCount++;
     this->internalSaveLayer(bounds, paint, flags, strategy);
     return this->getSaveCount() - 1;
 }
 
 void SkCanvas::internalSaveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags,
                                  SaveLayerStrategy strategy) {
 #ifndef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
     flags |= kClipToLayer_SaveFlag;
 #endif
 
@@ skipping 67 matching lines @@
         return this->saveLayer(bounds, NULL, flags);
     } else {
         SkPaint tmpPaint;
         tmpPaint.setAlpha(alpha);
         return this->saveLayer(bounds, &tmpPaint, flags);
     }
 }
 
 void SkCanvas::internalRestore() {
     SkASSERT(fMCStack.count() != 0);
+    SkASSERT(fMCRec->fSaveCount == fSaveCount);
 
     fDeviceCMDirty = true;
     fCachedLocalClipBoundsDirty = true;
 
     fClipStack->restore();
 
     // reserve our layer (if any)
     DeviceCM* layer = fMCRec->fLayer;   // may be null
     // now detach it from fMCRec so we can pop(). Gets freed after its drawn
     fMCRec->fLayer = NULL;
@@ skipping 10 matching lines @@
     if (layer) {
         if (layer->fNext) {
             const SkIPoint& origin = layer->fDevice->getOrigin();
             this->internalDrawDevice(layer->fDevice, origin.x(), origin.y(),
                                      layer->fPaint);
             // reset this, since internalDrawDevice will have set it to true
             fDeviceCMDirty = true;
         }
         SkDELETE(layer);
     }
+    SkASSERT(fMCStack.count() == 0 || fMCRec->fSaveCount <= fSaveCount);
 }
 
 SkSurface* SkCanvas::newSurface(const SkImageInfo& info, const SkSurfaceProps* props) {
     if (NULL == props) {
         props = &fProps;
     }
     return this->onNewSurface(info, *props);
 }
 
 SkSurface* SkCanvas::onNewSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
@@ skipping 1500 matching lines @@
     }
 
     if (matrix) {
         canvas->concat(*matrix);
     }
 }
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }