Revert "De-virtualize SkCanvas save/restore."

(To allow a roll fix into the tree).

This reverts commit edf702204be42c945254191f9f9cd6585b3d189b.

R=halcanary@google.com

Review URL: https://codereview.chromium.org/194923008

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

5 files changed, 31 insertions, 52 deletions

diff --git a/src/core/SkBBoxHierarchyRecord.cpp b/src/core/SkBBoxHierarchyRecord.cpp
index e7a30f61f1..5d310be7bc 100644
--- a/src/core/SkBBoxHierarchyRecord.cpp
+++ b/src/core/SkBBoxHierarchyRecord.cpp
@@ -26,20 +26,20 @@ void SkBBoxHierarchyRecord::handleBBox(const SkRect& bounds) {
     fBoundingHierarchy->insert(draw, r, true);
 }
 
-void SkBBoxHierarchyRecord::onSave(SaveFlags flags) {
+int SkBBoxHierarchyRecord::save(SaveFlags flags) {
     fStateTree->appendSave();
-    this->INHERITED::onSave(flags);
+    return INHERITED::save(flags);
 }
 
-bool SkBBoxHierarchyRecord::onSaveLayer(const SkRect* bounds, const SkPaint* paint,
-                                        SaveFlags flags) {
+int SkBBoxHierarchyRecord::saveLayer(const SkRect* bounds, const SkPaint* paint,
+                                     SaveFlags flags) {
     fStateTree->appendSaveLayer(this->writeStream().bytesWritten());
-    return this->INHERITED::onSaveLayer(bounds, paint, flags);
+    return INHERITED::saveLayer(bounds, paint, flags);
 }
 
-void SkBBoxHierarchyRecord::onRestore() {
+void SkBBoxHierarchyRecord::restore() {
     fStateTree->appendRestore();
-    this->INHERITED::onRestore();
+    INHERITED::restore();
 }
 
 bool SkBBoxHierarchyRecord::translate(SkScalar dx, SkScalar dy) {
diff --git a/src/core/SkBBoxHierarchyRecord.h b/src/core/SkBBoxHierarchyRecord.h
index 80c809cfbd..80f59c3907 100644
--- a/src/core/SkBBoxHierarchyRecord.h
+++ b/src/core/SkBBoxHierarchyRecord.h
@@ -23,6 +23,11 @@ public:
 
     virtual void handleBBox(const SkRect& bounds) SK_OVERRIDE;
 
+    virtual int save(SaveFlags flags = kMatrixClip_SaveFlag) SK_OVERRIDE;
+    virtual int saveLayer(const SkRect* bounds, const SkPaint* paint,
+                          SaveFlags flags = kARGB_ClipLayer_SaveFlag) SK_OVERRIDE;
+    virtual void restore() SK_OVERRIDE;
+
     virtual bool translate(SkScalar dx, SkScalar dy) SK_OVERRIDE;
     virtual bool scale(SkScalar sx, SkScalar sy) SK_OVERRIDE;
     virtual bool rotate(SkScalar degrees) SK_OVERRIDE;
@@ -34,10 +39,6 @@ public:
     virtual bool shouldRewind(void* data) SK_OVERRIDE;
 
 protected:
-    virtual void onSave(SaveFlags) SK_OVERRIDE;
-    virtual bool onSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE;
-    virtual void onRestore() SK_OVERRIDE;
-
     virtual void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
     virtual void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
     virtual void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index bd75f7dbde..0888a01fa4 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -348,7 +348,7 @@ public:
             SkPaint tmp;
             tmp.setImageFilter(fOrigPaint.getImageFilter());
             (void)canvas->internalSaveLayer(bounds, &tmp,
-                                    SkCanvas::kARGB_ClipLayer_SaveFlag, true, false);
+                                    SkCanvas::kARGB_ClipLayer_SaveFlag, true);
             // we'll clear the imageFilter for the actual draws in next(), so
             // it will only be applied during the restore().
             fDoClearImageFilter = true;
@@ -806,12 +806,7 @@ int SkCanvas::internalSave(SaveFlags flags) {
     return saveCount;
 }
 
-void SkCanvas::onSave(SaveFlags) {
-    // Do nothing. Subclasses may do something.
-}
-
 int SkCanvas::save(SaveFlags flags) {
-    this->onSave(flags);
     // call shared impl
     return this->internalSave(flags);
 }
@@ -868,16 +863,9 @@ bool SkCanvas::clipRectBounds(const SkRect* bounds, SaveFlags flags,
     return true;
 }
 
-bool SkCanvas::onSaveLayer(const SkRect*, const SkPaint*, SaveFlags) {
-    // Do nothing. Subclasses may do something.
-    return true;
-}
-
 int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
                         SaveFlags flags) {
-    // Overriding classes may return false to signal that we don't need to create a layer.
-    bool skipLayer = !this->onSaveLayer(bounds, paint, flags);
-    return this->internalSaveLayer(bounds, paint, flags, false, skipLayer);
+    return this->internalSaveLayer(bounds, paint, flags, false);
 }
 
 static SkBaseDevice* createCompatibleDevice(SkCanvas* canvas,
@@ -887,7 +875,7 @@ static SkBaseDevice* createCompatibleDevice(SkCanvas* canvas,
 }
 
 int SkCanvas::internalSaveLayer(const SkRect* bounds, const SkPaint* paint,
-                                SaveFlags flags, bool justForImageFilter, bool skipLayer) {
+                                SaveFlags flags, bool justForImageFilter) {
 #ifndef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
     flags = (SaveFlags)(flags | kClipToLayer_SaveFlag);
 #endif
@@ -903,11 +891,6 @@ int SkCanvas::internalSaveLayer(const SkRect* bounds, const SkPaint* paint,
         return count;
     }
 
-    // FIXME: do onSaveLayer() overriders returning false really care about the clipRectBounds()
-    // call above?
-    if (skipLayer)
-        return count;
-
     // Kill the imagefilter if our device doesn't allow it
     SkLazyPaint lazyP;
     if (paint && paint->getImageFilter()) {
@@ -960,14 +943,9 @@ int SkCanvas::saveLayerAlpha(const SkRect* bounds, U8CPU alpha,
     }
 }
 
-void SkCanvas::onRestore() {
-    // Do nothing. Subclasses may do something.
-}
-
 void SkCanvas::restore() {
     // check for underflow
     if (fMCStack.count() > 1) {
-        this->onRestore();
         this->internalRestore();
     }
 }
diff --git a/src/core/SkPictureRecord.cpp b/src/core/SkPictureRecord.cpp
index 497ce8ec54..08b69b8527 100644
--- a/src/core/SkPictureRecord.cpp
+++ b/src/core/SkPictureRecord.cpp
@@ -146,7 +146,7 @@ static inline uint32_t getPaintOffset(DrawType op, uint32_t opSize) {
     return gPaintOffsets[op] * sizeof(uint32_t) + overflow;
 }
 
-void SkPictureRecord::onSave(SaveFlags flags) {
+int SkPictureRecord::save(SaveFlags flags) {
 
 #ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
     fMCMgr.save(flags);
@@ -156,8 +156,7 @@ void SkPictureRecord::onSave(SaveFlags flags) {
     fRestoreOffsetStack.push(-(int32_t)fWriter.bytesWritten());
     this->recordSave(flags);
 #endif
-
-    this->INHERITED::onSave(flags);
+    return this->INHERITED::save(flags);
 }
 
 void SkPictureRecord::recordSave(SaveFlags flags) {
@@ -169,11 +168,12 @@ void SkPictureRecord::recordSave(SaveFlags flags) {
     this->validate(initialOffset, size);
 }
 
-bool SkPictureRecord::onSaveLayer(const SkRect* bounds, const SkPaint* paint,
-                                  SaveFlags flags) {
+int SkPictureRecord::saveLayer(const SkRect* bounds, const SkPaint* paint,
+                               SaveFlags flags) {
 
+    int count;
 #ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
-    fMCMgr.saveLayer(bounds, paint, flags);
+    count = fMCMgr.saveLayer(bounds, paint, flags);
 #else
     // record the offset to us, making it non-positive to distinguish a save
     // from a clip entry.
@@ -184,13 +184,15 @@ bool SkPictureRecord::onSaveLayer(const SkRect* bounds, const SkPaint* paint,
     }
 #endif
 
-    this->INHERITED::onSaveLayer(bounds, paint, flags);
-    /*  No need for a (potentially very big) layer which we don't actually need
+    /*  Don't actually call INHERITED::saveLayer, because that will try to allocate
+        an offscreen device (potentially very big) which we don't actually need
         at this time (and may not be able to afford since during record our
         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).
      */
-    return false;
+    count = this->INHERITED::save(flags);
+    this->clipRectBounds(bounds, flags, NULL);
+    return count;
 }
 
 void SkPictureRecord::recordSaveLayer(const SkRect* bounds, const SkPaint* paint,
@@ -603,7 +605,7 @@ static void apply_optimization_to_bbh(PictureRecordOptType opt, SkPictureStateTr
     }
 }
 
-void SkPictureRecord::onRestore() {
+void SkPictureRecord::restore() {
     // FIXME: SkDeferredCanvas needs to be refactored to respect
     // save/restore balancing so that the following test can be
     // turned on permanently.
@@ -651,7 +653,7 @@ void SkPictureRecord::onRestore() {
     fRestoreOffsetStack.pop();
 #endif
 
-    this->INHERITED::onRestore();
+    return this->INHERITED::restore();
 }
 
 void SkPictureRecord::recordRestore(bool fillInSkips) {
diff --git a/src/core/SkPictureRecord.h b/src/core/SkPictureRecord.h
index ccb1d08163..e91c1c5c12 100644
--- a/src/core/SkPictureRecord.h
+++ b/src/core/SkPictureRecord.h
@@ -37,6 +37,9 @@ public:
     SkPictureRecord(const SkISize& dimensions, uint32_t recordFlags);
     virtual ~SkPictureRecord();
 
+    virtual int save(SaveFlags) SK_OVERRIDE;
+    virtual int saveLayer(const SkRect* bounds, const SkPaint*, SaveFlags) SK_OVERRIDE;
+    virtual void restore() SK_OVERRIDE;
     virtual bool translate(SkScalar dx, SkScalar dy) SK_OVERRIDE;
     virtual bool scale(SkScalar sx, SkScalar sy) SK_OVERRIDE;
     virtual bool rotate(SkScalar degrees) SK_OVERRIDE;
@@ -224,11 +227,6 @@ protected:
     const void* onPeekPixels(SkImageInfo*, size_t*) SK_OVERRIDE {
         return NULL;
     }
-
-    virtual void onSave(SaveFlags) SK_OVERRIDE;
-    virtual bool onSaveLayer(const SkRect*, const SkPaint*, SaveFlags) SK_OVERRIDE;
-    virtual void onRestore() SK_OVERRIDE;
-
     virtual void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) SK_OVERRIDE;
     virtual void onPushCull(const SkRect&) SK_OVERRIDE;
     virtual void onPopCull() SK_OVERRIDE;