De-virtualize SkCanvas save/restore.

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"
@@ skipping 329 matching lines @@
         fCanvas = canvas;
         fFilter = canvas->getDrawFilter();
         fPaint = NULL;
         fSaveCount = canvas->getSaveCount();
         fDoClearImageFilter = false;
         fDone = false;
 
         if (!skipLayerForImageFilter && fOrigPaint.getImageFilter()) {
             SkPaint tmp;
             tmp.setImageFilter(fOrigPaint.getImageFilter());
-            (void)canvas->internalSaveLayer(bounds, &tmp,
-                                    SkCanvas::kARGB_ClipLayer_SaveFlag, true);
+            (void)canvas->internalSaveLayer(bounds, &tmp, SkCanvas::kARGB_ClipLayer_SaveFlag,
+                                            true, SkCanvas::kFullLayer_SaveLayerStrategy);
             // we'll clear the imageFilter for the actual draws in next(), so
             // it will only be applied during the restore().
             fDoClearImageFilter = true;
         }
 
         if (SkDrawLooper* looper = paint.getLooper()) {
             void* buffer = fLooperContextAllocator.reserveT<SkDrawLooper::Context>(
                     looper->contextSize());
             fLooperContext = looper->createContext(canvas, buffer);
             fIsSimple = false;
@@ skipping 441 matching lines @@
 
     fMCRec = newTop;
 
     if (SkCanvas::kClip_SaveFlag & flags) {
         fClipStack.save();
     }
 
     return saveCount;
 }
 
+void SkCanvas::willSave(SaveFlags) {
+    // Do nothing. Subclasses may do something.
+}
+
 int SkCanvas::save(SaveFlags flags) {
+    this->willSave(flags);
     // call shared impl
     return this->internalSave(flags);
 }
 
 static bool bounds_affects_clip(SkCanvas::SaveFlags flags) {
 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
     return (flags & SkCanvas::kClipToLayer_SaveFlag) != 0;
 #else
     return true;
 #endif
@@ skipping 36 matching lines @@
             return false;
         }
     }
 
     if (intersection) {
         *intersection = ir;
     }
     return true;
 }
 
+SkCanvas::SaveLayerStrategy SkCanvas::willSaveLayer(const SkRect*, const SkPaint*, SaveFlags) {
+
+    // Do nothing. Subclasses may do something.
+    return kFullLayer_SaveLayerStrategy;
+}
+
 int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
                         SaveFlags flags) {
-    return this->internalSaveLayer(bounds, paint, flags, false);
+    // Overriding classes may return false to signal that we don't need to create a layer.
+    SaveLayerStrategy strategy = this->willSaveLayer(bounds, paint, flags);
+    return this->internalSaveLayer(bounds, paint, flags, false, strategy);
 }
 
 static SkBaseDevice* createCompatibleDevice(SkCanvas* canvas,
                                             const SkImageInfo& info) {
     SkBaseDevice* device = canvas->getDevice();
     return device ? device->createCompatibleDevice(info) : NULL;
 }
 
-int SkCanvas::internalSaveLayer(const SkRect* bounds, const SkPaint* paint,
-                                SaveFlags flags, bool justForImageFilter) {
+int SkCanvas::internalSaveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags,
+                                bool justForImageFilter, SaveLayerStrategy strategy) {
 #ifndef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
     flags = (SaveFlags)(flags | kClipToLayer_SaveFlag);
 #endif
 
     // do this before we create the layer. We don't call the public save() since
     // that would invoke a possibly overridden virtual
     int count = this->internalSave(flags);
 
     fDeviceCMDirty = true;
 
     SkIRect ir;
     if (!this->clipRectBounds(bounds, flags, &ir, paint ? paint->getImageFilter() : NULL)) {
         return count;
     }
 
+    // FIXME: do willSaveLayer() overriders returning kNoLayer_SaveLayerStrategy really care about
+    // the clipRectBounds() call above?
+    if (kNoLayer_SaveLayerStrategy == strategy) {
+        return count;
+    }
+
     // Kill the imagefilter if our device doesn't allow it
     SkLazyPaint lazyP;
     if (paint && paint->getImageFilter()) {
         if (!this->getTopDevice()->allowImageFilter(paint->getImageFilter())) {
             if (justForImageFilter) {
                 // early exit if the layer was just for the imageFilter
                 return count;
             }
             SkPaint* p = lazyP.set(*paint);
             p->setImageFilter(NULL);
@@ skipping 32 matching lines @@
                              SaveFlags flags) {
     if (0xFF == alpha) {
         return this->saveLayer(bounds, NULL, flags);
     } else {
         SkPaint tmpPaint;
         tmpPaint.setAlpha(alpha);
         return this->saveLayer(bounds, &tmpPaint, flags);
     }
 }
 
+void SkCanvas::willRestore() {
+    // Do nothing. Subclasses may do something.
+}
+
 void SkCanvas::restore() {
     // check for underflow
     if (fMCStack.count() > 1) {
+        this->willRestore();
         this->internalRestore();
     }
 }
 
 void SkCanvas::internalRestore() {
     SkASSERT(fMCStack.count() != 0);
 
     fDeviceCMDirty = true;
     fCachedLocalClipBoundsDirty = true;
 
@@ skipping 1514 matching lines @@
     if (!bitmap.allocPixels(info)) {
         return NULL;
     }
 
     // should this functionality be moved into allocPixels()?
     if (!bitmap.info().isOpaque()) {
         bitmap.eraseColor(0);
     }
     return SkNEW_ARGS(SkCanvas, (bitmap));
 }