Revert of specialize setConcat for scale+translate

src/core/SkMatrix.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrix.h"
 #include "SkFloatBits.h"
 #include "SkString.h"
@@ skipping 262 matching lines @@
         this->setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkMatrix::setScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
     if (1 == sx && 1 == sy) {
         this->reset();
     } else {
-        this->setScaleTranslate(sx, sy, px - sx * px, py - sy * py);
+        fMat[kMScaleX] = sx;
+        fMat[kMScaleY] = sy;
+        fMat[kMTransX] = px - sx * px;
+        fMat[kMTransY] = py - sy * py;
+        fMat[kMPersp2] = 1;
+
+        fMat[kMSkewX]  = fMat[kMSkewY] =
+        fMat[kMPersp0] = fMat[kMPersp1] = 0;
+
+        this->setTypeMask(kScale_Mask | kTranslate_Mask | kRectStaysRect_Mask);
     }
 }
 
 void SkMatrix::setScale(SkScalar sx, SkScalar sy) {
     if (1 == sx && 1 == sy) {
         this->reset();
     } else {
         fMat[kMScaleX] = sx;
         fMat[kMScaleY] = sy;
         fMat[kMPersp2] = 1;
@@ skipping 80 matching lines @@
     fMat[kMScaleY] *= invY;
     fMat[kMSkewY]  *= invY;
     fMat[kMTransY] *= invY;
 
     this->setTypeMask(kUnknown_Mask);
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////
 
-void SkMatrix::setSinCos(SkScalar sinV, SkScalar cosV, SkScalar px, SkScalar py) {
+void SkMatrix::setSinCos(SkScalar sinV, SkScalar cosV,
+                         SkScalar px, SkScalar py) {
     const SkScalar oneMinusCosV = 1 - cosV;
 
     fMat[kMScaleX]  = cosV;
     fMat[kMSkewX]   = -sinV;
     fMat[kMTransX]  = sdot(sinV, py, oneMinusCosV, px);
 
     fMat[kMSkewY]   = sinV;
     fMat[kMScaleY]  = cosV;
     fMat[kMTransY]  = sdot(-sinV, px, oneMinusCosV, py);
 
@@ skipping 105 matching lines @@
 }
 
 void SkMatrix::postSkew(SkScalar sx, SkScalar sy) {
     SkMatrix    m;
     m.setSkew(sx, sy);
     this->postConcat(m);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-bool SkMatrix::setRectToRect(const SkRect& src, const SkRect& dst, ScaleToFit align) {
+bool SkMatrix::setRectToRect(const SkRect& src, const SkRect& dst,
+                             ScaleToFit align)
+{
     if (src.isEmpty()) {
         this->reset();
         return false;
     }
 
     if (dst.isEmpty()) {
         sk_bzero(fMat, 8 * sizeof(SkScalar));
-        fMat[kMPersp2] = 1;
         this->setTypeMask(kScale_Mask | kRectStaysRect_Mask);
     } else {
         SkScalar    tx, sx = dst.width() / src.width();
         SkScalar    ty, sy = dst.height() / src.height();
         bool        xLarger = false;
 
         if (align != kFill_ScaleToFit) {
             if (sx > sy) {
                 xLarger = true;
                 sx = sy;
@@ skipping 17 matching lines @@
                 diff = SkScalarHalf(diff);
             }
 
             if (xLarger) {
                 tx += diff;
             } else {
                 ty += diff;
             }
         }
 
-        this->setScaleTranslate(sx, sy, tx, ty);
+        fMat[kMScaleX] = sx;
+        fMat[kMScaleY] = sy;
+        fMat[kMTransX] = tx;
+        fMat[kMTransY] = ty;
+        fMat[kMSkewX]  = fMat[kMSkewY] =
+        fMat[kMPersp0] = fMat[kMPersp1] = 0;
+
+        unsigned mask = kRectStaysRect_Mask;
+        if (sx != 1 || sy != 1) {
+            mask |= kScale_Mask;
+        }
+        if (tx || ty) {
+            mask |= kTranslate_Mask;
+        }
+        this->setTypeMask(mask);
     }
+    // shared cleanup
+    fMat[kMPersp2] = 1;
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static inline float muladdmul(float a, float b, float c, float d) {
     return SkDoubleToFloat((double)a * b + (double)c * d);
 }
 
 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]) {
     if (SkScalarAbs(mat[SkMatrix::kMPersp2]) > 1) {
         for (int i = 0; i < 9; i++)
             mat[i] = SkScalarHalf(mat[i]);
     }
 }
 
-static bool only_scale_and_translate(unsigned mask) {
-    return 0 == (mask & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask));
-}
-
 void SkMatrix::setConcat(const SkMatrix& a, const SkMatrix& b) {
-    TypeMask aType = a.getType();
-    TypeMask bType = b.getType();
+    TypeMask aType = a.getPerspectiveTypeMaskOnly();
+    TypeMask bType = b.getPerspectiveTypeMaskOnly();
 
     if (a.isTriviallyIdentity()) {
         *this = b;
     } else if (b.isTriviallyIdentity()) {
         *this = a;
-    } else if (only_scale_and_translate(aType | bType)) {
-        this->setScaleTranslate(a.fMat[kMScaleX] * b.fMat[kMScaleX],
-                                a.fMat[kMScaleY] * b.fMat[kMScaleY],
-                                a.fMat[kMScaleX] * b.fMat[kMTransX] + a.fMat[kMTransX],
-                                a.fMat[kMScaleY] * b.fMat[kMTransY] + a.fMat[kMTransY]);
     } else {
         SkMatrix tmp;
 
         if ((aType | bType) & kPerspective_Mask) {
             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 {
+        } else {    // not perspective
             tmp.fMat[kMScaleX] = muladdmul(a.fMat[kMScaleX],
                                            b.fMat[kMScaleX],
                                            a.fMat[kMSkewX],
                                            b.fMat[kMSkewY]);
 
             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]) + a.fMat[kMTransX];
+                                           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]) + a.fMat[kMTransY];
+                                           b.fMat[kMTransY]);
 
-            tmp.fMat[kMPersp0] = 0;
-            tmp.fMat[kMPersp1] = 0;
+            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());
             //SkASSERT(!(tmp.getType() & kPerspective_Mask));
             tmp.setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
         }
         *this = tmp;
     }
 }
 
 void SkMatrix::preConcat(const SkMatrix& mat) {
@@ skipping 1100 matching lines @@
         rotation1->fX = cos1;
         rotation1->fY = sin1;
     }
     if (rotation2) {
         rotation2->fX = cos2;
         rotation2->fY = sin2;
     }
 
     return true;
 }