Remove SkCanvas matrix ops return value.
The internal SkMatrix ops can no longer fail -> we can remove the bool
return value.
R=bsalomon@google.com, reed@google.com, robertphillips@google.com, scroggo@google.com, fmalita@google.com
Author: fmalita@chromium.org
Review URL: https://codereview.chromium.org/200223008
git-svn-id: http://skia.googlecode.com/svn/trunk@13849 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/include/core/SkCanvas.h b/include/core/SkCanvas.h
index 8e5f3ac..fa433b3 100644
--- a/include/core/SkCanvas.h
+++ b/include/core/SkCanvas.h
@@ -470,35 +470,30 @@
/** Preconcat the current matrix with the specified translation
@param dx The distance to translate in X
@param dy The distance to translate in Y
- returns true if the operation succeeded (e.g. did not overflow)
*/
- bool translate(SkScalar dx, SkScalar dy);
+ void translate(SkScalar dx, SkScalar dy);
/** Preconcat the current matrix with the specified scale.
@param sx The amount to scale in X
@param sy The amount to scale in Y
- returns true if the operation succeeded (e.g. did not overflow)
*/
- bool scale(SkScalar sx, SkScalar sy);
+ void scale(SkScalar sx, SkScalar sy);
/** Preconcat the current matrix with the specified rotation.
@param degrees The amount to rotate, in degrees
- returns true if the operation succeeded (e.g. did not overflow)
*/
- bool rotate(SkScalar degrees);
+ void rotate(SkScalar degrees);
/** Preconcat the current matrix with the specified skew.
@param sx The amount to skew in X
@param sy The amount to skew in Y
- returns true if the operation succeeded (e.g. did not overflow)
*/
- bool skew(SkScalar sx, SkScalar sy);
+ void skew(SkScalar sx, SkScalar sy);
/** Preconcat the current matrix with the specified matrix.
@param matrix The matrix to preconcatenate with the current matrix
- @return true if the operation succeeded (e.g. did not overflow)
*/
- bool concat(const SkMatrix& matrix);
+ void concat(const SkMatrix& matrix);
/** Replace the current matrix with a copy of the specified matrix.
@param matrix The matrix that will be copied into the current matrix.
diff --git a/include/core/SkMatrix.h b/include/core/SkMatrix.h
index d7c163d..8394c38 100644
--- a/include/core/SkMatrix.h
+++ b/include/core/SkMatrix.h
@@ -218,57 +218,57 @@
/** Set the matrix to skew by sx and sy.
*/
void setSkew(SkScalar kx, SkScalar ky);
- /** Set the matrix to the concatenation of the two specified matrices,
- returning true if the the result can be represented. Either of the
- two matrices may also be the target matrix. *this = a * b;
+ /** Set the matrix to the concatenation of the two specified matrices.
+ Either of the two matrices may also be the target matrix.
+ *this = a * b;
*/
- bool setConcat(const SkMatrix& a, const SkMatrix& b);
+ void setConcat(const SkMatrix& a, const SkMatrix& b);
/** Preconcats the matrix with the specified translation.
M' = M * T(dx, dy)
*/
- bool preTranslate(SkScalar dx, SkScalar dy);
+ void preTranslate(SkScalar dx, SkScalar dy);
/** Preconcats the matrix with the specified scale.
M' = M * S(sx, sy, px, py)
*/
- bool preScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py);
+ void preScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py);
/** Preconcats the matrix with the specified scale.
M' = M * S(sx, sy)
*/
- bool preScale(SkScalar sx, SkScalar sy);
+ void preScale(SkScalar sx, SkScalar sy);
/** Preconcats the matrix with the specified rotation.
M' = M * R(degrees, px, py)
*/
- bool preRotate(SkScalar degrees, SkScalar px, SkScalar py);
+ void preRotate(SkScalar degrees, SkScalar px, SkScalar py);
/** Preconcats the matrix with the specified rotation.
M' = M * R(degrees)
*/
- bool preRotate(SkScalar degrees);
+ void preRotate(SkScalar degrees);
/** Preconcats the matrix with the specified skew.
M' = M * K(kx, ky, px, py)
*/
- bool preSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py);
+ void preSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py);
/** Preconcats the matrix with the specified skew.
M' = M * K(kx, ky)
*/
- bool preSkew(SkScalar kx, SkScalar ky);
+ void preSkew(SkScalar kx, SkScalar ky);
/** Preconcats the matrix with the specified matrix.
M' = M * other
*/
- bool preConcat(const SkMatrix& other);
+ void preConcat(const SkMatrix& other);
/** Postconcats the matrix with the specified translation.
M' = T(dx, dy) * M
*/
- bool postTranslate(SkScalar dx, SkScalar dy);
+ void postTranslate(SkScalar dx, SkScalar dy);
/** Postconcats the matrix with the specified scale.
M' = S(sx, sy, px, py) * M
*/
- bool postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py);
+ void postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py);
/** Postconcats the matrix with the specified scale.
M' = S(sx, sy) * M
*/
- bool postScale(SkScalar sx, SkScalar sy);
+ void postScale(SkScalar sx, SkScalar sy);
/** Postconcats the matrix by dividing it by the specified integers.
M' = S(1/divx, 1/divy, 0, 0) * M
*/
@@ -276,23 +276,23 @@
/** Postconcats the matrix with the specified rotation.
M' = R(degrees, px, py) * M
*/
- bool postRotate(SkScalar degrees, SkScalar px, SkScalar py);
+ void postRotate(SkScalar degrees, SkScalar px, SkScalar py);
/** Postconcats the matrix with the specified rotation.
M' = R(degrees) * M
*/
- bool postRotate(SkScalar degrees);
+ void postRotate(SkScalar degrees);
/** Postconcats the matrix with the specified skew.
M' = K(kx, ky, px, py) * M
*/
- bool postSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py);
+ void postSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py);
/** Postconcats the matrix with the specified skew.
M' = K(kx, ky) * M
*/
- bool postSkew(SkScalar kx, SkScalar ky);
+ void postSkew(SkScalar kx, SkScalar ky);
/** Postconcats the matrix with the specified matrix.
M' = other * M
*/
- bool postConcat(const SkMatrix& other);
+ void postConcat(const SkMatrix& other);
enum ScaleToFit {
/**
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 10ca95c..cd2065b 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -1275,65 +1275,60 @@
// Do nothing. Subclasses may do something.
}
-bool SkCanvas::translate(SkScalar dx, SkScalar dy) {
+void SkCanvas::translate(SkScalar dx, SkScalar dy) {
fDeviceCMDirty = true;
fCachedLocalClipBoundsDirty = true;
- bool res = fMCRec->fMatrix->preTranslate(dx, dy);
+ fMCRec->fMatrix->preTranslate(dx, dy);
this->didTranslate(dx, dy);
- return res;
}
void SkCanvas::didScale(SkScalar, SkScalar) {
// Do nothing. Subclasses may do something.
}
-bool SkCanvas::scale(SkScalar sx, SkScalar sy) {
+void SkCanvas::scale(SkScalar sx, SkScalar sy) {
fDeviceCMDirty = true;
fCachedLocalClipBoundsDirty = true;
- bool res = fMCRec->fMatrix->preScale(sx, sy);
+ fMCRec->fMatrix->preScale(sx, sy);
this->didScale(sx, sy);
- return res;
}
void SkCanvas::didRotate(SkScalar) {
// Do nothing. Subclasses may do something.
}
-bool SkCanvas::rotate(SkScalar degrees) {
+void SkCanvas::rotate(SkScalar degrees) {
fDeviceCMDirty = true;
fCachedLocalClipBoundsDirty = true;
- bool res = fMCRec->fMatrix->preRotate(degrees);
+ fMCRec->fMatrix->preRotate(degrees);
this->didRotate(degrees);
- return res;
}
void SkCanvas::didSkew(SkScalar, SkScalar) {
// Do nothing. Subclasses may do something.
}
-bool SkCanvas::skew(SkScalar sx, SkScalar sy) {
+void SkCanvas::skew(SkScalar sx, SkScalar sy) {
fDeviceCMDirty = true;
fCachedLocalClipBoundsDirty = true;
- bool res = fMCRec->fMatrix->preSkew(sx, sy);
+ fMCRec->fMatrix->preSkew(sx, sy);
this->didSkew(sx, sy);
- return res;
}
void SkCanvas::didConcat(const SkMatrix&) {
// Do nothing. Subclasses may do something.
}
-bool SkCanvas::concat(const SkMatrix& matrix) {
+void SkCanvas::concat(const SkMatrix& matrix) {
fDeviceCMDirty = true;
fCachedLocalClipBoundsDirty = true;
- bool res = fMCRec->fMatrix->preConcat(matrix);
+ fMCRec->fMatrix->preConcat(matrix);
this->didConcat(matrix);
- return res;
}
void SkCanvas::didSetMatrix(const SkMatrix&) {
diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp
index 024fa1b..946bf75 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -1056,10 +1056,7 @@
pathPtr->transform(*prePathMatrix, result);
pathPtr = result;
} else {
- if (!tmpMatrix.setConcat(*matrix, *prePathMatrix)) {
- // overflow
- return;
- }
+ tmpMatrix.setConcat(*matrix, *prePathMatrix);
matrix = &tmpMatrix;
}
}
@@ -1279,9 +1276,7 @@
paint.setStyle(SkPaint::kFill_Style);
SkMatrix matrix;
- if (!matrix.setConcat(*fMatrix, prematrix)) {
- return;
- }
+ matrix.setConcat(*fMatrix, prematrix);
if (clipped_out(matrix, *fRC, bitmap.width(), bitmap.height())) {
return;
@@ -2394,7 +2389,8 @@
if (!m.invert(&im)) {
return false;
}
- return fDstToUnit.setConcat(im, this->getTotalInverse());
+ fDstToUnit.setConcat(im, this->getTotalInverse());
+ return true;
}
#include "SkColorPriv.h"
diff --git a/src/core/SkMatrix.cpp b/src/core/SkMatrix.cpp
index a34866f..0929440 100644
--- a/src/core/SkMatrix.cpp
+++ b/src/core/SkMatrix.cpp
@@ -247,35 +247,36 @@
}
}
-bool SkMatrix::preTranslate(SkScalar dx, SkScalar dy) {
+void SkMatrix::preTranslate(SkScalar dx, SkScalar dy) {
+ if (!dx && !dy) {
+ return;
+ }
+
if (this->hasPerspective()) {
SkMatrix m;
m.setTranslate(dx, dy);
- return this->preConcat(m);
- }
-
- if (dx || dy) {
+ this->preConcat(m);
+ } else {
fMat[kMTransX] += sdot(fMat[kMScaleX], dx, fMat[kMSkewX], dy);
fMat[kMTransY] += sdot(fMat[kMSkewY], dx, fMat[kMScaleY], dy);
-
this->setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
}
- return true;
}
-bool SkMatrix::postTranslate(SkScalar dx, SkScalar dy) {
+void SkMatrix::postTranslate(SkScalar dx, SkScalar dy) {
+ if (!dx && !dy) {
+ return;
+ }
+
if (this->hasPerspective()) {
SkMatrix m;
m.setTranslate(dx, dy);
- return this->postConcat(m);
- }
-
- if (dx || dy) {
+ this->postConcat(m);
+ } else {
fMat[kMTransX] += dx;
fMat[kMTransY] += dy;
this->setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
}
- return true;
}
///////////////////////////////////////////////////////////////////////////////
@@ -321,15 +322,19 @@
return true;
}
-bool SkMatrix::preScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
+void SkMatrix::preScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
+ if (1 == sx && 1 == sy) {
+ return;
+ }
+
SkMatrix m;
m.setScale(sx, sy, px, py);
- return this->preConcat(m);
+ this->preConcat(m);
}
-bool SkMatrix::preScale(SkScalar sx, SkScalar sy) {
+void SkMatrix::preScale(SkScalar sx, SkScalar sy) {
if (1 == sx && 1 == sy) {
- return true;
+ return;
}
// the assumption is that these multiplies are very cheap, and that
@@ -346,25 +351,24 @@
fMat[kMPersp1] *= sy;
this->orTypeMask(kScale_Mask);
- return true;
}
-bool SkMatrix::postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
+void SkMatrix::postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
if (1 == sx && 1 == sy) {
- return true;
+ return;
}
SkMatrix m;
m.setScale(sx, sy, px, py);
- return this->postConcat(m);
+ this->postConcat(m);
}
-bool SkMatrix::postScale(SkScalar sx, SkScalar sy) {
+void SkMatrix::postScale(SkScalar sx, SkScalar sy) {
if (1 == sx && 1 == sy) {
- return true;
+ return;
}
SkMatrix m;
m.setScale(sx, sy);
- return this->postConcat(m);
+ this->postConcat(m);
}
// this guy perhaps can go away, if we have a fract/high-precision way to
@@ -436,28 +440,28 @@
this->setSinCos(sinV, cosV);
}
-bool SkMatrix::preRotate(SkScalar degrees, SkScalar px, SkScalar py) {
+void SkMatrix::preRotate(SkScalar degrees, SkScalar px, SkScalar py) {
SkMatrix m;
m.setRotate(degrees, px, py);
- return this->preConcat(m);
+ this->preConcat(m);
}
-bool SkMatrix::preRotate(SkScalar degrees) {
+void SkMatrix::preRotate(SkScalar degrees) {
SkMatrix m;
m.setRotate(degrees);
- return this->preConcat(m);
+ this->preConcat(m);
}
-bool SkMatrix::postRotate(SkScalar degrees, SkScalar px, SkScalar py) {
+void SkMatrix::postRotate(SkScalar degrees, SkScalar px, SkScalar py) {
SkMatrix m;
m.setRotate(degrees, px, py);
- return this->postConcat(m);
+ this->postConcat(m);
}
-bool SkMatrix::postRotate(SkScalar degrees) {
+void SkMatrix::postRotate(SkScalar degrees) {
SkMatrix m;
m.setRotate(degrees);
- return this->postConcat(m);
+ this->postConcat(m);
}
////////////////////////////////////////////////////////////////////////////////////
@@ -492,28 +496,28 @@
this->setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
}
-bool SkMatrix::preSkew(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
+void SkMatrix::preSkew(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
SkMatrix m;
m.setSkew(sx, sy, px, py);
- return this->preConcat(m);
+ this->preConcat(m);
}
-bool SkMatrix::preSkew(SkScalar sx, SkScalar sy) {
+void SkMatrix::preSkew(SkScalar sx, SkScalar sy) {
SkMatrix m;
m.setSkew(sx, sy);
- return this->preConcat(m);
+ this->preConcat(m);
}
-bool SkMatrix::postSkew(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
+void SkMatrix::postSkew(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
SkMatrix m;
m.setSkew(sx, sy, px, py);
- return this->postConcat(m);
+ this->postConcat(m);
}
-bool SkMatrix::postSkew(SkScalar sx, SkScalar sy) {
+void SkMatrix::postSkew(SkScalar sx, SkScalar sy) {
SkMatrix m;
m.setSkew(sx, sy);
- return this->postConcat(m);
+ this->postConcat(m);
}
///////////////////////////////////////////////////////////////////////////////
@@ -588,21 +592,12 @@
///////////////////////////////////////////////////////////////////////////////
-static inline int fixmuladdmul(float a, float b, float c, float d,
- float* result) {
- *result = SkDoubleToFloat((double)a * b + (double)c * d);
- return true;
+static inline float muladdmul(float a, float b, float c, float d) {
+ return SkDoubleToFloat((double)a * b + (double)c * d);
}
-static inline bool rowcol3(const float row[], const float col[],
- float* result) {
- *result = row[0] * col[0] + row[1] * col[3] + row[2] * col[6];
- return true;
-}
-
-static inline int negifaddoverflows(float& result, float a, float b) {
- result = a + b;
- return 0;
+static inline float rowcol3(const float row[], const float col[]) {
+ return row[0] * col[0] + row[1] * col[3] + row[2] * col[6];
}
static void normalize_perspective(SkScalar mat[9]) {
@@ -612,7 +607,7 @@
}
}
-bool SkMatrix::setConcat(const SkMatrix& a, const SkMatrix& b) {
+void SkMatrix::setConcat(const SkMatrix& a, const SkMatrix& b) {
TypeMask aType = a.getPerspectiveTypeMaskOnly();
TypeMask bType = b.getPerspectiveTypeMaskOnly();
@@ -624,73 +619,52 @@
SkMatrix tmp;
if ((aType | bType) & kPerspective_Mask) {
- if (!rowcol3(&a.fMat[0], &b.fMat[0], &tmp.fMat[kMScaleX])) {
- return false;
- }
- if (!rowcol3(&a.fMat[0], &b.fMat[1], &tmp.fMat[kMSkewX])) {
- return false;
- }
- if (!rowcol3(&a.fMat[0], &b.fMat[2], &tmp.fMat[kMTransX])) {
- return false;
- }
-
- if (!rowcol3(&a.fMat[3], &b.fMat[0], &tmp.fMat[kMSkewY])) {
- return false;
- }
- if (!rowcol3(&a.fMat[3], &b.fMat[1], &tmp.fMat[kMScaleY])) {
- return false;
- }
- if (!rowcol3(&a.fMat[3], &b.fMat[2], &tmp.fMat[kMTransY])) {
- return false;
- }
-
- if (!rowcol3(&a.fMat[6], &b.fMat[0], &tmp.fMat[kMPersp0])) {
- return false;
- }
- if (!rowcol3(&a.fMat[6], &b.fMat[1], &tmp.fMat[kMPersp1])) {
- return false;
- }
- if (!rowcol3(&a.fMat[6], &b.fMat[2], &tmp.fMat[kMPersp2])) {
- return false;
- }
+ tmp.fMat[kMScaleX] = rowcol3(&a.fMat[0], &b.fMat[0]);
+ tmp.fMat[kMSkewX] = rowcol3(&a.fMat[0], &b.fMat[1]);
+ tmp.fMat[kMTransX] = rowcol3(&a.fMat[0], &b.fMat[2]);
+ tmp.fMat[kMSkewY] = rowcol3(&a.fMat[3], &b.fMat[0]);
+ tmp.fMat[kMScaleY] = rowcol3(&a.fMat[3], &b.fMat[1]);
+ tmp.fMat[kMTransY] = rowcol3(&a.fMat[3], &b.fMat[2]);
+ tmp.fMat[kMPersp0] = rowcol3(&a.fMat[6], &b.fMat[0]);
+ tmp.fMat[kMPersp1] = rowcol3(&a.fMat[6], &b.fMat[1]);
+ tmp.fMat[kMPersp2] = rowcol3(&a.fMat[6], &b.fMat[2]);
normalize_perspective(tmp.fMat);
tmp.setTypeMask(kUnknown_Mask);
} else { // not perspective
- if (!fixmuladdmul(a.fMat[kMScaleX], b.fMat[kMScaleX],
- a.fMat[kMSkewX], b.fMat[kMSkewY], &tmp.fMat[kMScaleX])) {
- return false;
- }
- if (!fixmuladdmul(a.fMat[kMScaleX], b.fMat[kMSkewX],
- a.fMat[kMSkewX], b.fMat[kMScaleY], &tmp.fMat[kMSkewX])) {
- return false;
- }
- if (!fixmuladdmul(a.fMat[kMScaleX], b.fMat[kMTransX],
- a.fMat[kMSkewX], b.fMat[kMTransY], &tmp.fMat[kMTransX])) {
- return false;
- }
- if (negifaddoverflows(tmp.fMat[kMTransX], tmp.fMat[kMTransX],
- a.fMat[kMTransX]) < 0) {
- return false;
- }
+ tmp.fMat[kMScaleX] = muladdmul(a.fMat[kMScaleX],
+ b.fMat[kMScaleX],
+ a.fMat[kMSkewX],
+ b.fMat[kMSkewY]);
- if (!fixmuladdmul(a.fMat[kMSkewY], b.fMat[kMScaleX],
- a.fMat[kMScaleY], b.fMat[kMSkewY], &tmp.fMat[kMSkewY])) {
- return false;
- }
- if (!fixmuladdmul(a.fMat[kMSkewY], b.fMat[kMSkewX],
- a.fMat[kMScaleY], b.fMat[kMScaleY], &tmp.fMat[kMScaleY])) {
- return false;
- }
- if (!fixmuladdmul(a.fMat[kMSkewY], b.fMat[kMTransX],
- a.fMat[kMScaleY], b.fMat[kMTransY], &tmp.fMat[kMTransY])) {
- return false;
- }
- if (negifaddoverflows(tmp.fMat[kMTransY], tmp.fMat[kMTransY],
- a.fMat[kMTransY]) < 0) {
- return false;
- }
+ tmp.fMat[kMSkewX] = muladdmul(a.fMat[kMScaleX],
+ b.fMat[kMSkewX],
+ a.fMat[kMSkewX],
+ b.fMat[kMScaleY]);
+ tmp.fMat[kMTransX] = muladdmul(a.fMat[kMScaleX],
+ b.fMat[kMTransX],
+ a.fMat[kMSkewX],
+ b.fMat[kMTransY]);
+
+ tmp.fMat[kMTransX] += a.fMat[kMTransX];
+
+ tmp.fMat[kMSkewY] = muladdmul(a.fMat[kMSkewY],
+ b.fMat[kMScaleX],
+ a.fMat[kMScaleY],
+ b.fMat[kMSkewY]);
+
+ tmp.fMat[kMScaleY] = muladdmul(a.fMat[kMSkewY],
+ b.fMat[kMSkewX],
+ a.fMat[kMScaleY],
+ b.fMat[kMScaleY]);
+
+ tmp.fMat[kMTransY] = muladdmul(a.fMat[kMSkewY],
+ b.fMat[kMTransX],
+ a.fMat[kMScaleY],
+ b.fMat[kMTransY]);
+
+ tmp.fMat[kMTransY] += a.fMat[kMTransY];
tmp.fMat[kMPersp0] = tmp.fMat[kMPersp1] = 0;
tmp.fMat[kMPersp2] = 1;
//SkDebugf("Concat mat non-persp type: %d\n", tmp.getType());
@@ -699,19 +673,22 @@
}
*this = tmp;
}
- return true;
}
-bool SkMatrix::preConcat(const SkMatrix& mat) {
+void SkMatrix::preConcat(const SkMatrix& mat) {
// check for identity first, so we don't do a needless copy of ourselves
// to ourselves inside setConcat()
- return mat.isIdentity() || this->setConcat(*this, mat);
+ if(!mat.isIdentity()) {
+ this->setConcat(*this, mat);
+ }
}
-bool SkMatrix::postConcat(const SkMatrix& mat) {
+void SkMatrix::postConcat(const SkMatrix& mat) {
// check for identity first, so we don't do a needless copy of ourselves
// to ourselves inside setConcat()
- return mat.isIdentity() || this->setConcat(mat, *this);
+ if (!mat.isIdentity()) {
+ this->setConcat(mat, *this);
+ }
}
///////////////////////////////////////////////////////////////////////////////
@@ -1468,10 +1445,7 @@
if (!proc(dst, &tempMap, scale)) {
return false;
}
- if (!result.setConcat(tempMap, result)) {
- return false;
- }
- *this = result;
+ this->setConcat(tempMap, result);
return true;
}
diff --git a/src/core/SkMatrixClipStateMgr.h b/src/core/SkMatrixClipStateMgr.h
index c4201f8..b227583 100644
--- a/src/core/SkMatrixClipStateMgr.h
+++ b/src/core/SkMatrixClipStateMgr.h
@@ -62,29 +62,29 @@
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) {
@@ -285,29 +285,29 @@
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) {
diff --git a/src/device/xps/SkXPSDevice.cpp b/src/device/xps/SkXPSDevice.cpp
index 595694c..05ab13a 100644
--- a/src/device/xps/SkXPSDevice.cpp
+++ b/src/device/xps/SkXPSDevice.cpp
@@ -1696,9 +1696,7 @@
}
platonicPath.transform(*prePathMatrix, skeletalPath);
} else {
- if (!matrix.preConcat(*prePathMatrix)) {
- return;
- }
+ matrix.preConcat(*prePathMatrix);
}
}
diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp
index cd448b9..b1fa560 100644
--- a/src/effects/gradients/SkGradientShader.cpp
+++ b/src/effects/gradients/SkGradientShader.cpp
@@ -233,12 +233,7 @@
const SkMatrix& inverse = this->getTotalInverse();
- if (!fDstToIndex.setConcat(fPtsToUnit, inverse)) {
- // need to keep our set/end context calls balanced.
- this->INHERITED::endContext();
- return false;
- }
-
+ fDstToIndex.setConcat(fPtsToUnit, inverse);
fDstToIndexProc = fDstToIndex.getMapXYProc();
fDstToIndexClass = (uint8_t)SkShader::ComputeMatrixClass(fDstToIndex);
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
index 66ddccf..b8e6818 100644
--- a/src/pdf/SkPDFDevice.cpp
+++ b/src/pdf/SkPDFDevice.cpp
@@ -983,10 +983,7 @@
}
origPath.transform(*prePathMatrix, pathPtr);
} else {
- if (!matrix.preConcat(*prePathMatrix)) {
- // TODO(edisonn): report somehow why we failed?
- return;
- }
+ matrix.preConcat(*prePathMatrix);
}
}
diff --git a/tests/CanvasTest.cpp b/tests/CanvasTest.cpp
index 4b6f0fa..50371d1 100644
--- a/tests/CanvasTest.cpp
+++ b/tests/CanvasTest.cpp
@@ -312,14 +312,11 @@
// Basic test steps for most virtual methods in SkCanvas that draw or affect
// the state of the canvas.
-SIMPLE_TEST_STEP_WITH_ASSERT(Translate,
- translate(SkIntToScalar(1), SkIntToScalar(2)));
-SIMPLE_TEST_STEP_WITH_ASSERT(Scale,
- scale(SkIntToScalar(1), SkIntToScalar(2)));
-SIMPLE_TEST_STEP_WITH_ASSERT(Rotate, rotate(SkIntToScalar(1)));
-SIMPLE_TEST_STEP_WITH_ASSERT(Skew,
- skew(SkIntToScalar(1), SkIntToScalar(2)));
-SIMPLE_TEST_STEP_WITH_ASSERT(Concat, concat(kTestMatrix));
+SIMPLE_TEST_STEP(Translate, translate(SkIntToScalar(1), SkIntToScalar(2)));
+SIMPLE_TEST_STEP(Scale, scale(SkIntToScalar(1), SkIntToScalar(2)));
+SIMPLE_TEST_STEP(Rotate, rotate(SkIntToScalar(1)));
+SIMPLE_TEST_STEP(Skew, skew(SkIntToScalar(1), SkIntToScalar(2)));
+SIMPLE_TEST_STEP(Concat, concat(kTestMatrix));
SIMPLE_TEST_STEP(SetMatrix, setMatrix(kTestMatrix));
SIMPLE_TEST_STEP(ClipRect, clipRect(kTestRect));
SIMPLE_TEST_STEP(ClipPath, clipPath(kTestPath));