De-virtualize SkCanvas matrix ops.

src/utils/debugger/SkDebugCanvas.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkColorPriv.h"
@@ skipping 391 matching lines @@
 }
 
 void SkDebugCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
     this->addDrawCommand(new SkClipRRectCommand(rrect, op, kSoft_ClipEdgeStyle == edgeStyle));
 }
 
 void SkDebugCanvas::onClipRegion(const SkRegion& region, SkRegion::Op op) {
     this->addDrawCommand(new SkClipRegionCommand(region, op));
 }
 
-bool SkDebugCanvas::concat(const SkMatrix& matrix) {
+void SkDebugCanvas::didConcat(const SkMatrix& matrix) {
     addDrawCommand(new SkConcatCommand(matrix));
-    return true;
+    this->INHERITED::didConcat(matrix);
 }
 
 void SkDebugCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar left,
                                SkScalar top, const SkPaint* paint = NULL) {
     addDrawCommand(new SkDrawBitmapCommand(bitmap, left, top, paint));
 }
 
 void SkDebugCanvas::drawBitmapRectToRect(const SkBitmap& bitmap,
                                          const SkRect* src, const SkRect& dst,
                                          const SkPaint* paint,
@@ skipping 103 matching lines @@
 
 void SkDebugCanvas::onPopCull() {
     this->addDrawCommand(new SkPopCullCommand());
 }
 
 void SkDebugCanvas::willRestore() {
     this->addDrawCommand(new SkRestoreCommand());
     this->INHERITED::willRestore();
 }
 
-bool SkDebugCanvas::rotate(SkScalar degrees) {
+void SkDebugCanvas::didRotate(SkScalar degrees) {
     addDrawCommand(new SkRotateCommand(degrees));
-    return true;
+    this->INHERITED::didRotate(degrees);
 }
 
 void SkDebugCanvas::willSave(SaveFlags flags) {
     this->addDrawCommand(new SkSaveCommand(flags));
     this->INHERITED::willSave(flags);
 }
 
 SkCanvas::SaveLayerStrategy SkDebugCanvas::willSaveLayer(const SkRect* bounds, const SkPaint* paint,
                                                          SaveFlags flags) {
     this->addDrawCommand(new SkSaveLayerCommand(bounds, paint, flags));
     this->INHERITED::willSaveLayer(bounds, paint, flags);
     // No need for a full layer.
     return kNoLayer_SaveLayerStrategy;
 }
 
-bool SkDebugCanvas::scale(SkScalar sx, SkScalar sy) {
+void SkDebugCanvas::didScale(SkScalar sx, SkScalar sy) {
     addDrawCommand(new SkScaleCommand(sx, sy));
-    return true;
+    this->INHERITED::didScale(sx, sy);
 }
 
-void SkDebugCanvas::setMatrix(const SkMatrix& matrix) {
+void SkDebugCanvas::didSetMatrix(const SkMatrix& matrix) {
     addDrawCommand(new SkSetMatrixCommand(matrix));
+    this->INHERITED::didSetMatrix(matrix);
 }
 
-bool SkDebugCanvas::skew(SkScalar sx, SkScalar sy) {
+void SkDebugCanvas::didSkew(SkScalar sx, SkScalar sy) {
     addDrawCommand(new SkSkewCommand(sx, sy));
-    return true;
+    this->INHERITED::didSkew(sx, sy);
 }
 
-bool SkDebugCanvas::translate(SkScalar dx, SkScalar dy) {
+void SkDebugCanvas::didTranslate(SkScalar dx, SkScalar dy) {
     addDrawCommand(new SkTranslateCommand(dx, dy));
-    return true;
+    this->INHERITED::didTranslate(dx, dy);
 }
 
 void SkDebugCanvas::toggleCommand(int index, bool toggle) {
     SkASSERT(index < fCommandVector.count());
     fCommandVector[index]->setVisible(toggle);
 }