Remove SkCanvas matrix ops return value.

src/core/SkMatrixClipStateMgr.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkMatrixClipStateMgr_DEFINED
 #define SkMatrixClipStateMgr_DEFINED
 
 #include "SkCanvas.h"
@@ skipping 44 matching lines @@
 
     class MatrixClipState : public SkNoncopyable {
     public:
         class MatrixInfo {
         public:
             void reset() {
                 fMatrixID = kIdentityMatID;
                 fMatrix.reset();
             }
 
-            bool preTranslate(SkScalar dx, SkScalar dy) {
+            void preTranslate(SkScalar dx, SkScalar dy) {
                 fMatrixID = -1;
-                return fMatrix.preTranslate(dx, dy);
+                fMatrix.preTranslate(dx, dy);
             }
 
-            bool preScale(SkScalar sx, SkScalar sy) {
+            void preScale(SkScalar sx, SkScalar sy) {
                 fMatrixID = -1;
-                return fMatrix.preScale(sx, sy);
+                fMatrix.preScale(sx, sy);
             }
 
-            bool preRotate(SkScalar degrees) {
+            void preRotate(SkScalar degrees) {
                 fMatrixID = -1;
-                return fMatrix.preRotate(degrees);
+                fMatrix.preRotate(degrees);
             }
 
-            bool preSkew(SkScalar sx, SkScalar sy) {
+            void preSkew(SkScalar sx, SkScalar sy) {
                 fMatrixID = -1;
-                return fMatrix.preSkew(sx, sy);
+                fMatrix.preSkew(sx, sy);
             }
 
-            bool preConcat(const SkMatrix& matrix) {
+            void preConcat(const SkMatrix& matrix) {
                 fMatrixID = -1;
-                return fMatrix.preConcat(matrix);
+                fMatrix.preConcat(matrix);
             }
 
             void setMatrix(const SkMatrix& matrix) {
                 fMatrixID = -1;
                 fMatrix = matrix;
             }
 
             int getID(SkMatrixClipStateMgr* mgr) {
                 if (fMatrixID >= 0) {
                     return fMatrixID;
@@ skipping 180 matching lines @@
     int save(SkCanvas::SaveFlags flags);
 
     int saveLayer(const SkRect* bounds, const SkPaint* paint, SkCanvas::SaveFlags flags);
 
     bool isDrawingToLayer() const {
         return fCurMCState->fLayerID > 0;
     }
 
     void restore();
 
-    bool translate(SkScalar dx, SkScalar dy) {
+    void translate(SkScalar dx, SkScalar dy) {
         this->call(kMatrix_CallType);
-        return fCurMCState->fMatrixInfo->preTranslate(dx, dy);
+        fCurMCState->fMatrixInfo->preTranslate(dx, dy);
     }
 
-    bool scale(SkScalar sx, SkScalar sy) {
+    void scale(SkScalar sx, SkScalar sy) {
         this->call(kMatrix_CallType);
-        return fCurMCState->fMatrixInfo->preScale(sx, sy);
+        fCurMCState->fMatrixInfo->preScale(sx, sy);
     }
 
-    bool rotate(SkScalar degrees) {
+    void rotate(SkScalar degrees) {
         this->call(kMatrix_CallType);
-        return fCurMCState->fMatrixInfo->preRotate(degrees);
+        fCurMCState->fMatrixInfo->preRotate(degrees);
     }
 
-    bool skew(SkScalar sx, SkScalar sy) {
+    void skew(SkScalar sx, SkScalar sy) {
         this->call(kMatrix_CallType);
-        return fCurMCState->fMatrixInfo->preSkew(sx, sy);
+        fCurMCState->fMatrixInfo->preSkew(sx, sy);
     }
 
-    bool concat(const SkMatrix& matrix) {
+    void concat(const SkMatrix& matrix) {
         this->call(kMatrix_CallType);
-        return fCurMCState->fMatrixInfo->preConcat(matrix);
+        fCurMCState->fMatrixInfo->preConcat(matrix);
     }
 
     void setMatrix(const SkMatrix& matrix) {
         this->call(kMatrix_CallType);
         fCurMCState->fMatrixInfo->setMatrix(matrix);
     }
 
     bool clipRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
         this->call(SkMatrixClipStateMgr::kClip_CallType);
         return fCurMCState->fClipInfo->clipRect(rect, op, doAA,
@@ skipping 84 matching lines @@
 #ifdef SK_DEBUG
     int fActualDepth;
 #endif
 
     // save layers are nested within a specific MC state. This stack tracks
     // the nesting MC state's ID as save layers are pushed and popped.
     SkTDArray<int> fStateIDStack;
 };
 
 #endif