De-virtualize SkCanvas save/restore.
This moves the state management logic into non-virtual SkCanvas methods,
and turns the virtuals into protected notifiers.
R=robertphillips@google.com, reed@google.com
Review URL: https://codereview.chromium.org/194713008
git-svn-id: http://skia.googlecode.com/svn/trunk@13747 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/src/core/SkBBoxHierarchyRecord.cpp b/src/core/SkBBoxHierarchyRecord.cpp
index 5d310be..e7a30f6 100644
--- a/src/core/SkBBoxHierarchyRecord.cpp
+++ b/src/core/SkBBoxHierarchyRecord.cpp
@@ -26,20 +26,20 @@
fBoundingHierarchy->insert(draw, r, true);
}
-int SkBBoxHierarchyRecord::save(SaveFlags flags) {
+void SkBBoxHierarchyRecord::onSave(SaveFlags flags) {
fStateTree->appendSave();
- return INHERITED::save(flags);
+ this->INHERITED::onSave(flags);
}
-int SkBBoxHierarchyRecord::saveLayer(const SkRect* bounds, const SkPaint* paint,
- SaveFlags flags) {
+bool SkBBoxHierarchyRecord::onSaveLayer(const SkRect* bounds, const SkPaint* paint,
+ SaveFlags flags) {
fStateTree->appendSaveLayer(this->writeStream().bytesWritten());
- return INHERITED::saveLayer(bounds, paint, flags);
+ return this->INHERITED::onSaveLayer(bounds, paint, flags);
}
-void SkBBoxHierarchyRecord::restore() {
+void SkBBoxHierarchyRecord::onRestore() {
fStateTree->appendRestore();
- INHERITED::restore();
+ this->INHERITED::onRestore();
}
bool SkBBoxHierarchyRecord::translate(SkScalar dx, SkScalar dy) {
diff --git a/src/core/SkBBoxHierarchyRecord.h b/src/core/SkBBoxHierarchyRecord.h
index 80f59c3..80c809c 100644
--- a/src/core/SkBBoxHierarchyRecord.h
+++ b/src/core/SkBBoxHierarchyRecord.h
@@ -23,11 +23,6 @@
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;
@@ -39,6 +34,10 @@
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 0888a01..bd75f7d 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -348,7 +348,7 @@
SkPaint tmp;
tmp.setImageFilter(fOrigPaint.getImageFilter());
(void)canvas->internalSaveLayer(bounds, &tmp,
- SkCanvas::kARGB_ClipLayer_SaveFlag, true);
+ SkCanvas::kARGB_ClipLayer_SaveFlag, true, false);
// we'll clear the imageFilter for the actual draws in next(), so
// it will only be applied during the restore().
fDoClearImageFilter = true;
@@ -806,7 +806,12 @@
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);
}
@@ -863,9 +868,16 @@
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) {
- return this->internalSaveLayer(bounds, paint, flags, false);
+ // 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);
}
static SkBaseDevice* createCompatibleDevice(SkCanvas* canvas,
@@ -875,7 +887,7 @@
}
int SkCanvas::internalSaveLayer(const SkRect* bounds, const SkPaint* paint,
- SaveFlags flags, bool justForImageFilter) {
+ SaveFlags flags, bool justForImageFilter, bool skipLayer) {
#ifndef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
flags = (SaveFlags)(flags | kClipToLayer_SaveFlag);
#endif
@@ -891,6 +903,11 @@
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()) {
@@ -943,9 +960,14 @@
}
}
+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 08b69b8..497ce8e 100644
--- a/src/core/SkPictureRecord.cpp
+++ b/src/core/SkPictureRecord.cpp
@@ -146,7 +146,7 @@
return gPaintOffsets[op] * sizeof(uint32_t) + overflow;
}
-int SkPictureRecord::save(SaveFlags flags) {
+void SkPictureRecord::onSave(SaveFlags flags) {
#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
fMCMgr.save(flags);
@@ -156,7 +156,8 @@
fRestoreOffsetStack.push(-(int32_t)fWriter.bytesWritten());
this->recordSave(flags);
#endif
- return this->INHERITED::save(flags);
+
+ this->INHERITED::onSave(flags);
}
void SkPictureRecord::recordSave(SaveFlags flags) {
@@ -168,12 +169,11 @@
this->validate(initialOffset, size);
}
-int SkPictureRecord::saveLayer(const SkRect* bounds, const SkPaint* paint,
- SaveFlags flags) {
+bool SkPictureRecord::onSaveLayer(const SkRect* bounds, const SkPaint* paint,
+ SaveFlags flags) {
- int count;
#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
- count = fMCMgr.saveLayer(bounds, paint, flags);
+ fMCMgr.saveLayer(bounds, paint, flags);
#else
// record the offset to us, making it non-positive to distinguish a save
// from a clip entry.
@@ -184,15 +184,13 @@
}
#endif
- /* Don't actually call INHERITED::saveLayer, because that will try to allocate
- an offscreen device (potentially very big) which we don't actually need
+ this->INHERITED::onSaveLayer(bounds, paint, flags);
+ /* No need for a (potentially very big) layer 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).
*/
- count = this->INHERITED::save(flags);
- this->clipRectBounds(bounds, flags, NULL);
- return count;
+ return false;
}
void SkPictureRecord::recordSaveLayer(const SkRect* bounds, const SkPaint* paint,
@@ -605,7 +603,7 @@
}
}
-void SkPictureRecord::restore() {
+void SkPictureRecord::onRestore() {
// FIXME: SkDeferredCanvas needs to be refactored to respect
// save/restore balancing so that the following test can be
// turned on permanently.
@@ -653,7 +651,7 @@
fRestoreOffsetStack.pop();
#endif
- return this->INHERITED::restore();
+ this->INHERITED::onRestore();
}
void SkPictureRecord::recordRestore(bool fillInSkips) {
diff --git a/src/core/SkPictureRecord.h b/src/core/SkPictureRecord.h
index e91c1c5..ccb1d08 100644
--- a/src/core/SkPictureRecord.h
+++ b/src/core/SkPictureRecord.h
@@ -37,9 +37,6 @@
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;
@@ -227,6 +224,11 @@
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;
diff --git a/src/pipe/SkGPipeWrite.cpp b/src/pipe/SkGPipeWrite.cpp
index 43209f6..146f49c 100644
--- a/src/pipe/SkGPipeWrite.cpp
+++ b/src/pipe/SkGPipeWrite.cpp
@@ -229,10 +229,6 @@
}
// overrides from SkCanvas
- virtual int save(SaveFlags) SK_OVERRIDE;
- virtual int saveLayer(const SkRect* bounds, const SkPaint*,
- SaveFlags) SK_OVERRIDE;
- virtual void restore() SK_OVERRIDE;
virtual bool isDrawingToLayer() const SK_OVERRIDE;
virtual bool translate(SkScalar dx, SkScalar dy) SK_OVERRIDE;
virtual bool scale(SkScalar sx, SkScalar sy) SK_OVERRIDE;
@@ -287,6 +283,10 @@
bool shuttleBitmap(const SkBitmap&, int32_t slot);
protected:
+ 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 onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) SK_OVERRIDE;
@@ -514,16 +514,17 @@
#define NOTIFY_SETUP(canvas) \
AutoPipeNotify apn(canvas)
-int SkGPipeCanvas::save(SaveFlags flags) {
+void SkGPipeCanvas::onSave(SaveFlags flags) {
NOTIFY_SETUP(this);
if (this->needOpBytes()) {
this->writeOp(kSave_DrawOp, 0, flags);
}
- return this->INHERITED::save(flags);
+
+ this->INHERITED::onSave(flags);
}
-int SkGPipeCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
- SaveFlags saveFlags) {
+bool SkGPipeCanvas::onSaveLayer(const SkRect* bounds, const SkPaint* paint,
+ SaveFlags saveFlags) {
NOTIFY_SETUP(this);
size_t size = 0;
unsigned opFlags = 0;
@@ -547,21 +548,23 @@
if (kNoSaveLayer == fFirstSaveLayerStackLevel){
fFirstSaveLayerStackLevel = this->getSaveCount();
}
- // we just pass on the save, so we don't create a layer
- return this->INHERITED::save(saveFlags);
+
+ this->INHERITED::onSaveLayer(bounds, paint, saveFlags);
+ // we don't create a layer
+ return false;
}
-void SkGPipeCanvas::restore() {
+void SkGPipeCanvas::onRestore() {
NOTIFY_SETUP(this);
if (this->needOpBytes()) {
this->writeOp(kRestore_DrawOp);
}
- this->INHERITED::restore();
-
- if (this->getSaveCount() == fFirstSaveLayerStackLevel){
+ if (this->getSaveCount() - 1 == fFirstSaveLayerStackLevel){
fFirstSaveLayerStackLevel = kNoSaveLayer;
}
+
+ this->INHERITED::onRestore();
}
bool SkGPipeCanvas::isDrawingToLayer() const {
diff --git a/src/utils/SkDeferredCanvas.cpp b/src/utils/SkDeferredCanvas.cpp
index efe7501..8b617b3 100644
--- a/src/utils/SkDeferredCanvas.cpp
+++ b/src/utils/SkDeferredCanvas.cpp
@@ -739,28 +739,25 @@
SkIntToScalar(canvasSize.fWidth), SkIntToScalar(canvasSize.fHeight)));
}
-int SkDeferredCanvas::save(SaveFlags flags) {
+void SkDeferredCanvas::onSave(SaveFlags flags) {
this->drawingCanvas()->save(flags);
- int val = this->INHERITED::save(flags);
this->recordedDrawCommand();
-
- return val;
+ this->INHERITED::onSave(flags);
}
-int SkDeferredCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
- SaveFlags flags) {
+bool SkDeferredCanvas::onSaveLayer(const SkRect* bounds, const SkPaint* paint,
+ SaveFlags flags) {
this->drawingCanvas()->saveLayer(bounds, paint, flags);
- int count = this->INHERITED::save(flags);
- this->clipRectBounds(bounds, flags, NULL);
this->recordedDrawCommand();
-
- return count;
+ this->INHERITED::onSaveLayer(bounds, paint, flags);
+ // No need for a full layer.
+ return false;
}
-void SkDeferredCanvas::restore() {
+void SkDeferredCanvas::onRestore() {
this->drawingCanvas()->restore();
- this->INHERITED::restore();
this->recordedDrawCommand();
+ this->INHERITED::onRestore();
}
bool SkDeferredCanvas::isDrawingToLayer() const {
diff --git a/src/utils/SkDumpCanvas.cpp b/src/utils/SkDumpCanvas.cpp
index 4805d62..ccc5124 100644
--- a/src/utils/SkDumpCanvas.cpp
+++ b/src/utils/SkDumpCanvas.cpp
@@ -192,13 +192,13 @@
///////////////////////////////////////////////////////////////////////////////
-int SkDumpCanvas::save(SaveFlags flags) {
+void SkDumpCanvas::onSave(SaveFlags flags) {
this->dump(kSave_Verb, NULL, "save(0x%X)", flags);
- return this->INHERITED::save(flags);
+ this->INHERITED::onSave(flags);
}
-int SkDumpCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
- SaveFlags flags) {
+bool SkDumpCanvas::onSaveLayer(const SkRect* bounds, const SkPaint* paint,
+ SaveFlags flags) {
SkString str;
str.printf("saveLayer(0x%X)", flags);
if (bounds) {
@@ -214,12 +214,12 @@
}
}
this->dump(kSave_Verb, paint, str.c_str());
- return this->INHERITED::saveLayer(bounds, paint, flags);
+ return this->INHERITED::onSaveLayer(bounds, paint, flags);
}
-void SkDumpCanvas::restore() {
- this->INHERITED::restore();
+void SkDumpCanvas::onRestore() {
this->dump(kRestore_Verb, NULL, "restore");
+ this->INHERITED::onRestore();
}
bool SkDumpCanvas::translate(SkScalar dx, SkScalar dy) {
diff --git a/src/utils/SkLuaCanvas.cpp b/src/utils/SkLuaCanvas.cpp
index 0f13073..2679fd2 100644
--- a/src/utils/SkLuaCanvas.cpp
+++ b/src/utils/SkLuaCanvas.cpp
@@ -81,13 +81,13 @@
SkLuaCanvas::~SkLuaCanvas() {}
-int SkLuaCanvas::save(SaveFlags flags) {
+void SkLuaCanvas::onSave(SaveFlags flags) {
AUTO_LUA("save");
- return this->INHERITED::save(flags);
+ this->INHERITED::onSave(flags);
}
-int SkLuaCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
- SaveFlags flags) {
+bool SkLuaCanvas::onSaveLayer(const SkRect* bounds, const SkPaint* paint,
+ SaveFlags flags) {
AUTO_LUA("saveLayer");
if (bounds) {
lua.pushRect(*bounds, "bounds");
@@ -95,12 +95,15 @@
if (paint) {
lua.pushPaint(*paint, "paint");
}
- return this->INHERITED::save(flags);
+
+ this->INHERITED::onSaveLayer(bounds, paint, flags);
+ // No need for a layer.
+ return false;
}
-void SkLuaCanvas::restore() {
+void SkLuaCanvas::onRestore() {
AUTO_LUA("restore");
- this->INHERITED::restore();
+ this->INHERITED::onRestore();
}
bool SkLuaCanvas::translate(SkScalar dx, SkScalar dy) {
diff --git a/src/utils/SkNWayCanvas.cpp b/src/utils/SkNWayCanvas.cpp
index a9543f9..6fbec96 100644
--- a/src/utils/SkNWayCanvas.cpp
+++ b/src/utils/SkNWayCanvas.cpp
@@ -57,29 +57,33 @@
SkCanvas* fCanvas;
};
-int SkNWayCanvas::save(SaveFlags flags) {
+void SkNWayCanvas::onSave(SaveFlags flags) {
Iter iter(fList);
while (iter.next()) {
iter->save(flags);
}
- return this->INHERITED::save(flags);
+
+ this->INHERITED::onSave(flags);
}
-int SkNWayCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
- SaveFlags flags) {
+bool SkNWayCanvas::onSaveLayer(const SkRect* bounds, const SkPaint* paint,
+ SaveFlags flags) {
Iter iter(fList);
while (iter.next()) {
iter->saveLayer(bounds, paint, flags);
}
- return this->INHERITED::saveLayer(bounds, paint, flags);
+
+ this->INHERITED::onSaveLayer(bounds, paint, flags);
+ // No need for a layer.
+ return false;
}
-void SkNWayCanvas::restore() {
+void SkNWayCanvas::onRestore() {
Iter iter(fList);
while (iter.next()) {
iter->restore();
}
- this->INHERITED::restore();
+ this->INHERITED::onRestore();
}
bool SkNWayCanvas::translate(SkScalar dx, SkScalar dy) {
diff --git a/src/utils/SkNoSaveLayerCanvas.h b/src/utils/SkNoSaveLayerCanvas.h
index 60fad87..037fcec 100644
--- a/src/utils/SkNoSaveLayerCanvas.h
+++ b/src/utils/SkNoSaveLayerCanvas.h
@@ -18,21 +18,13 @@
public:
SkNoSaveLayerCanvas(SkBaseDevice* device) : INHERITED(device) {}
- // turn saveLayer() into save() for speed, should not affect correctness.
- virtual int saveLayer(const SkRect* bounds,
- const SkPaint* paint,
- SaveFlags flags) SK_OVERRIDE {
-
- // Like SkPictureRecord, we don't want to create layers, but we do need
- // to respect the save and (possibly) its rect-clip.
- int count = this->INHERITED::save(flags);
- if (NULL != bounds) {
- this->INHERITED::clipRectBounds(bounds, flags, NULL);
- }
- return count;
+protected:
+ virtual bool onSaveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags)
+ SK_OVERRIDE {
+ this->INHERITED::onSaveLayer(bounds, paint, flags);
+ return false;
}
-protected:
// disable aa for speed
virtual void onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle) SK_OVERRIDE {
this->INHERITED::onClipRect(rect, op, kHard_ClipEdgeStyle);
diff --git a/src/utils/SkProxyCanvas.cpp b/src/utils/SkProxyCanvas.cpp
index 0a9d7a8..f61a31d 100644
--- a/src/utils/SkProxyCanvas.cpp
+++ b/src/utils/SkProxyCanvas.cpp
@@ -21,17 +21,22 @@
///////////////////////////////// Overrides ///////////
-int SkProxyCanvas::save(SaveFlags flags) {
- return fProxy->save(flags);
+void SkProxyCanvas::onSave(SaveFlags flags) {
+ fProxy->save(flags);
+ this->INHERITED::onSave(flags);
}
-int SkProxyCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
- SaveFlags flags) {
- return fProxy->saveLayer(bounds, paint, flags);
+bool SkProxyCanvas::onSaveLayer(const SkRect* bounds, const SkPaint* paint,
+ SaveFlags flags) {
+ fProxy->saveLayer(bounds, paint, flags);
+ this->INHERITED::onSaveLayer(bounds, paint, flags);
+ // No need for a layer.
+ return false;
}
-void SkProxyCanvas::restore() {
+void SkProxyCanvas::onRestore() {
fProxy->restore();
+ this->INHERITED::onRestore();
}
bool SkProxyCanvas::translate(SkScalar dx, SkScalar dy) {
diff --git a/src/utils/debugger/SkDebugCanvas.cpp b/src/utils/debugger/SkDebugCanvas.cpp
index 08e6d94..67ecc65 100644
--- a/src/utils/debugger/SkDebugCanvas.cpp
+++ b/src/utils/debugger/SkDebugCanvas.cpp
@@ -530,8 +530,9 @@
this->addDrawCommand(new SkPopCullCommand());
}
-void SkDebugCanvas::restore() {
- addDrawCommand(new SkRestoreCommand());
+void SkDebugCanvas::onRestore() {
+ this->addDrawCommand(new SkRestoreCommand());
+ this->INHERITED::onRestore();
}
bool SkDebugCanvas::rotate(SkScalar degrees) {
@@ -539,15 +540,17 @@
return true;
}
-int SkDebugCanvas::save(SaveFlags flags) {
- addDrawCommand(new SkSaveCommand(flags));
- return true;
+void SkDebugCanvas::onSave(SaveFlags flags) {
+ this->addDrawCommand(new SkSaveCommand(flags));
+ this->INHERITED::onSave(flags);
}
-int SkDebugCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
- SaveFlags flags) {
- addDrawCommand(new SkSaveLayerCommand(bounds, paint, flags));
- return true;
+bool SkDebugCanvas::onSaveLayer(const SkRect* bounds, const SkPaint* paint,
+ SaveFlags flags) {
+ this->addDrawCommand(new SkSaveLayerCommand(bounds, paint, flags));
+ this->INHERITED::onSaveLayer(bounds, paint, flags);
+ // No need for a full layer.
+ return false;
}
bool SkDebugCanvas::scale(SkScalar sx, SkScalar sy) {
diff --git a/src/utils/debugger/SkDebugCanvas.h b/src/utils/debugger/SkDebugCanvas.h
index 0bbb640..24824c9 100644
--- a/src/utils/debugger/SkDebugCanvas.h
+++ b/src/utils/debugger/SkDebugCanvas.h
@@ -206,14 +206,8 @@
const uint16_t indices[], int indexCount,
const SkPaint&) SK_OVERRIDE;
- virtual void restore() SK_OVERRIDE;
-
virtual bool rotate(SkScalar degrees) SK_OVERRIDE;
- virtual int save(SaveFlags) SK_OVERRIDE;
-
- virtual int saveLayer(const SkRect* bounds, const SkPaint*, SaveFlags) SK_OVERRIDE;
-
virtual bool scale(SkScalar sx, SkScalar sy) SK_OVERRIDE;
virtual void setMatrix(const SkMatrix& matrix) SK_OVERRIDE;
@@ -248,6 +242,10 @@
}
protected:
+ 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& cullRect) SK_OVERRIDE;
virtual void onPopCull() SK_OVERRIDE;