diff --git a/src/core/SkMatrix.cpp b/src/core/SkMatrix.cpp
index f32f485771..33af64a41f 100644
--- a/src/core/SkMatrix.cpp
+++ b/src/core/SkMatrix.cpp
@@ -10,7 +10,20 @@
 #include "SkOnce.h"
 #include "SkString.h"
 
-#define kMatrix22Elem   SK_Scalar1
+// In a few places, we performed the following
+//      a * b + c * d + e
+// as
+//      a * b + (c * d + e)
+//
+// sdot and scross are indended to capture these compound operations into a
+// function, with an eye toward considering upscaling the intermediates to
+// doubles for more precision (as we do in concat and invert).
+//
+// However, these few lines that performed the last add before the "dot", cause
+// tiny image differences, so we guard that change until we see the impact on
+// chrome's layouttests.
+//
+#define SK_LEGACY_MATRIX_MATH_ORDER
 
 static inline float SkDoubleToFloat(double x) {
     return static_cast<float>(x);
@@ -22,11 +35,10 @@ static inline float SkDoubleToFloat(double x) {
 */
 
 void SkMatrix::reset() {
-    fMat[kMScaleX] = fMat[kMScaleY] = SK_Scalar1;
+    fMat[kMScaleX] = fMat[kMScaleY] = fMat[kMPersp2] = 1;
     fMat[kMSkewX]  = fMat[kMSkewY] =
     fMat[kMTransX] = fMat[kMTransY] =
     fMat[kMPersp0] = fMat[kMPersp1] = 0;
-    fMat[kMPersp2] = kMatrix22Elem;
 
     this->setTypeMask(kIdentity_Mask | kRectStaysRect_Mask);
 }
@@ -46,8 +58,7 @@ uint8_t SkMatrix::computePerspectiveTypeMask() const {
     // Benchmarking suggests that replacing this set of SkScalarAs2sCompliment
     // is a win, but replacing those below is not. We don't yet understand
     // that result.
-    if (fMat[kMPersp0] != 0 || fMat[kMPersp1] != 0 ||
-        fMat[kMPersp2] != kMatrix22Elem) {
+    if (fMat[kMPersp0] != 0 || fMat[kMPersp1] != 0 || fMat[kMPersp2] != 1) {
         // If this is a perspective transform, we return true for all other
         // transform flags - this does not disable any optimizations, respects
         // the rule that the type mask must be conservative, and speeds up
@@ -61,8 +72,7 @@ uint8_t SkMatrix::computePerspectiveTypeMask() const {
 uint8_t SkMatrix::computeTypeMask() const {
     unsigned mask = 0;
 
-    if (fMat[kMPersp0] != 0 || fMat[kMPersp1] != 0 ||
-        fMat[kMPersp2] != kMatrix22Elem) {
+    if (fMat[kMPersp0] != 0 || fMat[kMPersp1] != 0 || fMat[kMPersp2] != 1) {
         // Once it is determined that that this is a perspective transform,
         // all other flags are moot as far as optimizations are concerned.
         return SkToU8(kORableMasks);
@@ -209,15 +219,27 @@ bool SkMatrix::preservesRightAngles(SkScalar tol) const {
 
 ///////////////////////////////////////////////////////////////////////////////
 
+static inline SkScalar sdot(SkScalar a, SkScalar b, SkScalar c, SkScalar d) {
+    return a * b + c * d;
+}
+
+static inline SkScalar sdot(SkScalar a, SkScalar b, SkScalar c, SkScalar d,
+                             SkScalar e, SkScalar f) {
+    return a * b + c * d + e * f;
+}
+
+static inline SkScalar scross(SkScalar a, SkScalar b, SkScalar c, SkScalar d) {
+    return a * b - c * d;
+}
+
 void SkMatrix::setTranslate(SkScalar dx, SkScalar dy) {
     if (dx || dy) {
         fMat[kMTransX] = dx;
         fMat[kMTransY] = dy;
 
-        fMat[kMScaleX] = fMat[kMScaleY] = SK_Scalar1;
+        fMat[kMScaleX] = fMat[kMScaleY] = fMat[kMPersp2] = 1;
         fMat[kMSkewX]  = fMat[kMSkewY] =
         fMat[kMPersp0] = fMat[kMPersp1] = 0;
-        fMat[kMPersp2] = kMatrix22Elem;
 
         this->setTypeMask(kTranslate_Mask | kRectStaysRect_Mask);
     } else {
@@ -233,10 +255,8 @@ bool SkMatrix::preTranslate(SkScalar dx, SkScalar dy) {
     }
 
     if (dx || dy) {
-        fMat[kMTransX] += SkScalarMul(fMat[kMScaleX], dx) +
-                          SkScalarMul(fMat[kMSkewX], dy);
-        fMat[kMTransY] += SkScalarMul(fMat[kMSkewY], dx) +
-                          SkScalarMul(fMat[kMScaleY], dy);
+        fMat[kMTransX] += sdot(fMat[kMScaleX], dx, fMat[kMSkewX], dy);
+        fMat[kMTransY] += sdot(fMat[kMSkewY], dx, fMat[kMScaleY], dy);
 
         this->setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
     }
@@ -261,14 +281,14 @@ bool SkMatrix::postTranslate(SkScalar dx, SkScalar dy) {
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkMatrix::setScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
-    if (SK_Scalar1 == sx && SK_Scalar1 == sy) {
+    if (1 == sx && 1 == sy) {
         this->reset();
     } else {
         fMat[kMScaleX] = sx;
         fMat[kMScaleY] = sy;
-        fMat[kMTransX] = px - SkScalarMul(sx, px);
-        fMat[kMTransY] = py - SkScalarMul(sy, py);
-        fMat[kMPersp2] = kMatrix22Elem;
+        fMat[kMTransX] = px - sx * px;
+        fMat[kMTransY] = py - sy * py;
+        fMat[kMPersp2] = 1;
 
         fMat[kMSkewX]  = fMat[kMSkewY] =
         fMat[kMPersp0] = fMat[kMPersp1] = 0;
@@ -278,12 +298,12 @@ void SkMatrix::setScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
 }
 
 void SkMatrix::setScale(SkScalar sx, SkScalar sy) {
-    if (SK_Scalar1 == sx && SK_Scalar1 == sy) {
+    if (1 == sx && 1 == sy) {
         this->reset();
     } else {
         fMat[kMScaleX] = sx;
         fMat[kMScaleY] = sy;
-        fMat[kMPersp2] = kMatrix22Elem;
+        fMat[kMPersp2] = 1;
 
         fMat[kMTransX] = fMat[kMTransY] =
         fMat[kMSkewX]  = fMat[kMSkewY] =
@@ -297,7 +317,7 @@ bool SkMatrix::setIDiv(int divx, int divy) {
     if (!divx || !divy) {
         return false;
     }
-    this->setScale(SK_Scalar1 / divx, SK_Scalar1 / divy);
+    this->setScale(SkScalarInvert(divx), SkScalarInvert(divy));
     return true;
 }
 
@@ -308,7 +328,7 @@ bool SkMatrix::preScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
 }
 
 bool SkMatrix::preScale(SkScalar sx, SkScalar sy) {
-    if (SK_Scalar1 == sx && SK_Scalar1 == sy) {
+    if (1 == sx && 1 == sy) {
         return true;
     }
 
@@ -317,20 +337,20 @@ bool SkMatrix::preScale(SkScalar sx, SkScalar sy) {
     // Also, the fixed-point case checks for overflow, but the float doesn't,
     // so we can get away with these blind multiplies.
 
-    fMat[kMScaleX] = SkScalarMul(fMat[kMScaleX], sx);
-    fMat[kMSkewY] = SkScalarMul(fMat[kMSkewY],   sx);
-    fMat[kMPersp0] = SkScalarMul(fMat[kMPersp0], sx);
+    fMat[kMScaleX] *= sx;
+    fMat[kMSkewY]  *= sx;
+    fMat[kMPersp0] *= sx;
 
-    fMat[kMSkewX] = SkScalarMul(fMat[kMSkewX],   sy);
-    fMat[kMScaleY] = SkScalarMul(fMat[kMScaleY], sy);
-    fMat[kMPersp1] = SkScalarMul(fMat[kMPersp1], sy);
+    fMat[kMSkewX]  *= sy;
+    fMat[kMScaleY] *= sy;
+    fMat[kMPersp1] *= sy;
 
     this->orTypeMask(kScale_Mask);
     return true;
 }
 
 bool SkMatrix::postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
-    if (SK_Scalar1 == sx && SK_Scalar1 == sy) {
+    if (1 == sx && 1 == sy) {
         return true;
     }
     SkMatrix    m;
@@ -339,7 +359,7 @@ bool SkMatrix::postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
 }
 
 bool SkMatrix::postScale(SkScalar sx, SkScalar sy) {
-    if (SK_Scalar1 == sx && SK_Scalar1 == sy) {
+    if (1 == sx && 1 == sy) {
         return true;
     }
     SkMatrix    m;
@@ -373,18 +393,18 @@ bool SkMatrix::postIDiv(int divx, int divy) {
 
 void SkMatrix::setSinCos(SkScalar sinV, SkScalar cosV,
                          SkScalar px, SkScalar py) {
-    const SkScalar oneMinusCosV = SK_Scalar1 - cosV;
+    const SkScalar oneMinusCosV = 1 - cosV;
 
     fMat[kMScaleX]  = cosV;
     fMat[kMSkewX]   = -sinV;
-    fMat[kMTransX]  = SkScalarMul(sinV, py) + SkScalarMul(oneMinusCosV, px);
+    fMat[kMTransX]  = sdot(sinV, py, oneMinusCosV, px);
 
     fMat[kMSkewY]   = sinV;
     fMat[kMScaleY]  = cosV;
-    fMat[kMTransY]  = SkScalarMul(-sinV, px) + SkScalarMul(oneMinusCosV, py);
+    fMat[kMTransY]  = sdot(-sinV, px, oneMinusCosV, py);
 
     fMat[kMPersp0] = fMat[kMPersp1] = 0;
-    fMat[kMPersp2] = kMatrix22Elem;
+    fMat[kMPersp2] = 1;
 
     this->setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
 }
@@ -399,7 +419,7 @@ void SkMatrix::setSinCos(SkScalar sinV, SkScalar cosV) {
     fMat[kMTransY]  = 0;
 
     fMat[kMPersp0] = fMat[kMPersp1] = 0;
-    fMat[kMPersp2] = kMatrix22Elem;
+    fMat[kMPersp2] = 1;
 
     this->setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
 }
@@ -443,31 +463,31 @@ bool SkMatrix::postRotate(SkScalar degrees) {
 ////////////////////////////////////////////////////////////////////////////////////
 
 void SkMatrix::setSkew(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
-    fMat[kMScaleX]  = SK_Scalar1;
+    fMat[kMScaleX]  = 1;
     fMat[kMSkewX]   = sx;
-    fMat[kMTransX]  = SkScalarMul(-sx, py);
+    fMat[kMTransX]  = -sx * py;
 
     fMat[kMSkewY]   = sy;
-    fMat[kMScaleY]  = SK_Scalar1;
-    fMat[kMTransY]  = SkScalarMul(-sy, px);
+    fMat[kMScaleY]  = 1;
+    fMat[kMTransY]  = -sy * px;
 
     fMat[kMPersp0] = fMat[kMPersp1] = 0;
-    fMat[kMPersp2] = kMatrix22Elem;
+    fMat[kMPersp2] = 1;
 
     this->setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
 }
 
 void SkMatrix::setSkew(SkScalar sx, SkScalar sy) {
-    fMat[kMScaleX]  = SK_Scalar1;
+    fMat[kMScaleX]  = 1;
     fMat[kMSkewX]   = sx;
     fMat[kMTransX]  = 0;
 
     fMat[kMSkewY]   = sy;
-    fMat[kMScaleY]  = SK_Scalar1;
+    fMat[kMScaleY]  = 1;
     fMat[kMTransY]  = 0;
 
     fMat[kMPersp0] = fMat[kMPersp1] = 0;
-    fMat[kMPersp2] = kMatrix22Elem;
+    fMat[kMPersp2] = 1;
 
     this->setTypeMask(kUnknown_Mask | kOnlyPerspectiveValid_Mask);
 }
@@ -510,8 +530,8 @@ bool SkMatrix::setRectToRect(const SkRect& src, const SkRect& dst,
         sk_bzero(fMat, 8 * sizeof(SkScalar));
         this->setTypeMask(kScale_Mask | kRectStaysRect_Mask);
     } else {
-        SkScalar    tx, sx = SkScalarDiv(dst.width(), src.width());
-        SkScalar    ty, sy = SkScalarDiv(dst.height(), src.height());
+        SkScalar    tx, sx = dst.width() / src.width();
+        SkScalar    ty, sy = dst.height() / src.height();
         bool        xLarger = false;
 
         if (align != kFill_ScaleToFit) {
@@ -523,15 +543,15 @@ bool SkMatrix::setRectToRect(const SkRect& src, const SkRect& dst,
             }
         }
 
-        tx = dst.fLeft - SkScalarMul(src.fLeft, sx);
-        ty = dst.fTop - SkScalarMul(src.fTop, sy);
+        tx = dst.fLeft - src.fLeft * sx;
+        ty = dst.fTop - src.fTop * sy;
         if (align == kCenter_ScaleToFit || align == kEnd_ScaleToFit) {
             SkScalar diff;
 
             if (xLarger) {
-                diff = dst.width() - SkScalarMul(src.width(), sy);
+                diff = dst.width() - src.width() * sy;
             } else {
-                diff = dst.height() - SkScalarMul(src.height(), sy);
+                diff = dst.height() - src.height() * sy;
             }
 
             if (align == kCenter_ScaleToFit) {
@@ -553,7 +573,7 @@ bool SkMatrix::setRectToRect(const SkRect& src, const SkRect& dst,
         fMat[kMPersp0] = fMat[kMPersp1] = 0;
 
         unsigned mask = kRectStaysRect_Mask;
-        if (sx != SK_Scalar1 || sy != SK_Scalar1) {
+        if (sx != 1 || sy != 1) {
             mask |= kScale_Mask;
         }
         if (tx || ty) {
@@ -562,7 +582,7 @@ bool SkMatrix::setRectToRect(const SkRect& src, const SkRect& dst,
         this->setTypeMask(mask);
     }
     // shared cleanup
-    fMat[kMPersp2] = kMatrix22Elem;
+    fMat[kMPersp2] = 1;
     return true;
 }
 
@@ -586,7 +606,7 @@ static inline int negifaddoverflows(float& result, float a, float b) {
 }
 
 static void normalize_perspective(SkScalar mat[9]) {
-    if (SkScalarAbs(mat[SkMatrix::kMPersp2]) > kMatrix22Elem) {
+    if (SkScalarAbs(mat[SkMatrix::kMPersp2]) > 1) {
         for (int i = 0; i < 9; i++)
             mat[i] = SkScalarHalf(mat[i]);
     }
@@ -672,7 +692,7 @@ bool SkMatrix::setConcat(const SkMatrix& a, const SkMatrix& b) {
             }
 
             tmp.fMat[kMPersp0] = tmp.fMat[kMPersp1] = 0;
-            tmp.fMat[kMPersp2] = kMatrix22Elem;
+            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);
@@ -702,19 +722,38 @@ bool SkMatrix::postConcat(const SkMatrix& mat) {
     the intermediate math, even though we know that is more expensive.
  */
 
-typedef double SkDetScalar;
-#define SkPerspMul(a, b)            SkScalarMul(a, b)
-#define SkScalarMulShift(a, b, s)   SkDoubleToFloat((a) * (b))
-static double sk_inv_determinant(const float mat[9], int isPerspective,
-                                int* /* (only used in Fixed case) */) {
+static inline SkScalar scross_dscale(SkScalar a, SkScalar b,
+                                     SkScalar c, SkScalar d, double scale) {
+    return SkDoubleToScalar(scross(a, b, c, d) * scale);
+}
+
+static inline double dcross(double a, double b, double c, double d) {
+    return a * b - c * d;
+}
+
+static inline SkScalar dcross_dscale(double a, double b,
+                                     double c, double d, double scale) {
+    return SkDoubleToScalar(dcross(a, b, c, d) * scale);
+}
+
+static double sk_inv_determinant(const float mat[9], int isPerspective) {
     double det;
 
     if (isPerspective) {
-        det =   mat[SkMatrix::kMScaleX] * ((double)mat[SkMatrix::kMScaleY] * mat[SkMatrix::kMPersp2] - (double)mat[SkMatrix::kMTransY] * mat[SkMatrix::kMPersp1]) +
-                mat[SkMatrix::kMSkewX] * ((double)mat[SkMatrix::kMTransY] * mat[SkMatrix::kMPersp0] - (double)mat[SkMatrix::kMSkewY] * mat[SkMatrix::kMPersp2]) +
-                mat[SkMatrix::kMTransX] * ((double)mat[SkMatrix::kMSkewY] * mat[SkMatrix::kMPersp1] - (double)mat[SkMatrix::kMScaleY] * mat[SkMatrix::kMPersp0]);
+        det = mat[SkMatrix::kMScaleX] *
+              dcross(mat[SkMatrix::kMScaleY], mat[SkMatrix::kMPersp2],
+                     mat[SkMatrix::kMTransY], mat[SkMatrix::kMPersp1])
+              +
+              mat[SkMatrix::kMSkewX]  *
+              dcross(mat[SkMatrix::kMTransY], mat[SkMatrix::kMPersp0],
+                     mat[SkMatrix::kMSkewY],  mat[SkMatrix::kMPersp2])
+              +
+              mat[SkMatrix::kMTransX] *
+              dcross(mat[SkMatrix::kMSkewY],  mat[SkMatrix::kMPersp1],
+                     mat[SkMatrix::kMScaleY], mat[SkMatrix::kMPersp0]);
     } else {
-        det =   (double)mat[SkMatrix::kMScaleX] * mat[SkMatrix::kMScaleY] - (double)mat[SkMatrix::kMSkewX] * mat[SkMatrix::kMSkewY];
+        det = dcross(mat[SkMatrix::kMScaleX], mat[SkMatrix::kMScaleY],
+                     mat[SkMatrix::kMSkewX], mat[SkMatrix::kMSkewY]);
     }
 
     // Since the determinant is on the order of the cube of the matrix members,
@@ -725,19 +764,12 @@ static double sk_inv_determinant(const float mat[9], int isPerspective,
     }
     return 1.0 / det;
 }
-// we declar a,b,c,d to all be doubles, because we want to perform
-// double-precision muls and subtract, even though the original values are
-// from the matrix, which are floats.
-static float inline mul_diff_scale(double a, double b, double c, double d,
-                                   double scale) {
-    return SkDoubleToFloat((a * b - c * d) * scale);
-}
 
 void SkMatrix::SetAffineIdentity(SkScalar affine[6]) {
-    affine[kAScaleX] = SK_Scalar1;
+    affine[kAScaleX] = 1;
     affine[kASkewY] = 0;
     affine[kASkewX] = 0;
-    affine[kAScaleY] = SK_Scalar1;
+    affine[kAScaleY] = 1;
     affine[kATransX] = 0;
     affine[kATransY] = 0;
 }
@@ -782,9 +814,9 @@ bool SkMatrix::invertNonIdentity(SkMatrix* inv) const {
 
                 inv->fMat[kMScaleX] = invX;
                 inv->fMat[kMScaleY] = invY;
-                inv->fMat[kMPersp2] = kMatrix22Elem;
-                inv->fMat[kMTransX] = -SkScalarMul(fMat[kMTransX], invX);
-                inv->fMat[kMTransY] = -SkScalarMul(fMat[kMTransY], invY);
+                inv->fMat[kMPersp2] = 1;
+                inv->fMat[kMTransX] = -fMat[kMTransX] * invX;
+                inv->fMat[kMTransY] = -fMat[kMTransY] * invY;
 
                 inv->setTypeMask(mask | kRectStaysRect_Mask);
             } else {
@@ -799,9 +831,8 @@ bool SkMatrix::invertNonIdentity(SkMatrix* inv) const {
         return invertible;
     }
 
-    int         isPersp = mask & kPerspective_Mask;
-    int         shift;
-    SkDetScalar scale = sk_inv_determinant(fMat, isPersp, &shift);
+    int    isPersp = mask & kPerspective_Mask;
+    double scale = sk_inv_determinant(fMat, isPersp);
 
     if (scale == 0) { // underflow
         return false;
@@ -814,33 +845,29 @@ bool SkMatrix::invertNonIdentity(SkMatrix* inv) const {
         }
 
         if (isPersp) {
-            shift = 61 - shift;
-            inv->fMat[kMScaleX] = SkScalarMulShift(SkPerspMul(fMat[kMScaleY], fMat[kMPersp2]) - SkPerspMul(fMat[kMTransY], fMat[kMPersp1]), scale, shift);
-            inv->fMat[kMSkewX]  = SkScalarMulShift(SkPerspMul(fMat[kMTransX], fMat[kMPersp1]) - SkPerspMul(fMat[kMSkewX],  fMat[kMPersp2]), scale, shift);
-            inv->fMat[kMTransX] = SkScalarMulShift(SkScalarMul(fMat[kMSkewX], fMat[kMTransY]) - SkScalarMul(fMat[kMTransX], fMat[kMScaleY]), scale, shift);
+            inv->fMat[kMScaleX] = scross_dscale(fMat[kMScaleY], fMat[kMPersp2], fMat[kMTransY], fMat[kMPersp1], scale);
+            inv->fMat[kMSkewX]  = scross_dscale(fMat[kMTransX], fMat[kMPersp1], fMat[kMSkewX],  fMat[kMPersp2], scale);
+            inv->fMat[kMTransX] = scross_dscale(fMat[kMSkewX],  fMat[kMTransY], fMat[kMTransX], fMat[kMScaleY], scale);
 
-            inv->fMat[kMSkewY]  = SkScalarMulShift(SkPerspMul(fMat[kMTransY], fMat[kMPersp0]) - SkPerspMul(fMat[kMSkewY],   fMat[kMPersp2]), scale, shift);
-            inv->fMat[kMScaleY] = SkScalarMulShift(SkPerspMul(fMat[kMScaleX], fMat[kMPersp2]) - SkPerspMul(fMat[kMTransX],  fMat[kMPersp0]), scale, shift);
-            inv->fMat[kMTransY] = SkScalarMulShift(SkScalarMul(fMat[kMTransX], fMat[kMSkewY]) - SkScalarMul(fMat[kMScaleX], fMat[kMTransY]), scale, shift);
+            inv->fMat[kMSkewY]  = scross_dscale(fMat[kMTransY], fMat[kMPersp0], fMat[kMSkewY],  fMat[kMPersp2], scale);
+            inv->fMat[kMScaleY] = scross_dscale(fMat[kMScaleX], fMat[kMPersp2], fMat[kMTransX], fMat[kMPersp0], scale);
+            inv->fMat[kMTransY] = scross_dscale(fMat[kMTransX], fMat[kMSkewY],  fMat[kMScaleX], fMat[kMTransY], scale);
 
-            inv->fMat[kMPersp0] = SkScalarMulShift(SkScalarMul(fMat[kMSkewY], fMat[kMPersp1]) - SkScalarMul(fMat[kMScaleY], fMat[kMPersp0]), scale, shift);
-            inv->fMat[kMPersp1] = SkScalarMulShift(SkScalarMul(fMat[kMSkewX], fMat[kMPersp0]) - SkScalarMul(fMat[kMScaleX], fMat[kMPersp1]), scale, shift);
-            inv->fMat[kMPersp2] = SkScalarMulShift(SkScalarMul(fMat[kMScaleX], fMat[kMScaleY]) - SkScalarMul(fMat[kMSkewX], fMat[kMSkewY]), scale, shift);
+            inv->fMat[kMPersp0] = scross_dscale(fMat[kMSkewY],  fMat[kMPersp1], fMat[kMScaleY], fMat[kMPersp0], scale);
+            inv->fMat[kMPersp1] = scross_dscale(fMat[kMSkewX],  fMat[kMPersp0], fMat[kMScaleX], fMat[kMPersp1], scale);
+            inv->fMat[kMPersp2] = scross_dscale(fMat[kMScaleX], fMat[kMScaleY], fMat[kMSkewX],  fMat[kMSkewY],  scale);
         } else {   // not perspective
-            inv->fMat[kMScaleX] = SkDoubleToFloat(fMat[kMScaleY] * scale);
-            inv->fMat[kMSkewX] = SkDoubleToFloat(-fMat[kMSkewX] * scale);
-            inv->fMat[kMTransX] = mul_diff_scale(fMat[kMSkewX], fMat[kMTransY],
-                                     fMat[kMScaleY], fMat[kMTransX], scale);
+            inv->fMat[kMScaleX] = SkDoubleToScalar(fMat[kMScaleY] * scale);
+            inv->fMat[kMSkewX]  = SkDoubleToScalar(-fMat[kMSkewX] * scale);
+            inv->fMat[kMTransX] = dcross_dscale(fMat[kMSkewX], fMat[kMTransY], fMat[kMScaleY], fMat[kMTransX], scale);
 
-            inv->fMat[kMSkewY] = SkDoubleToFloat(-fMat[kMSkewY] * scale);
-            inv->fMat[kMScaleY] = SkDoubleToFloat(fMat[kMScaleX] * scale);
-            inv->fMat[kMTransY] = mul_diff_scale(fMat[kMSkewY], fMat[kMTransX],
-                                        fMat[kMScaleX], fMat[kMTransY], scale);
+            inv->fMat[kMSkewY]  = SkDoubleToScalar(-fMat[kMSkewY] * scale);
+            inv->fMat[kMScaleY] = SkDoubleToScalar(fMat[kMScaleX] * scale);
+            inv->fMat[kMTransY] = dcross_dscale(fMat[kMSkewY], fMat[kMTransX], fMat[kMScaleX], fMat[kMTransY], scale);
 
             inv->fMat[kMPersp0] = 0;
             inv->fMat[kMPersp1] = 0;
-            inv->fMat[kMPersp2] = kMatrix22Elem;
-
+            inv->fMat[kMPersp2] = 1;
         }
 
         inv->setTypeMask(fTypeMask);
@@ -886,8 +913,8 @@ void SkMatrix::Scale_pts(const SkMatrix& m, SkPoint dst[],
         SkScalar mx = m.fMat[kMScaleX];
         SkScalar my = m.fMat[kMScaleY];
         do {
-            dst->fY = SkScalarMul(src->fY, my);
-            dst->fX = SkScalarMul(src->fX, mx);
+            dst->fY = src->fY * my;
+            dst->fX = src->fX * mx;
             src += 1;
             dst += 1;
         } while (--count);
@@ -904,8 +931,8 @@ void SkMatrix::ScaleTrans_pts(const SkMatrix& m, SkPoint dst[],
         SkScalar tx = m.fMat[kMTransX];
         SkScalar ty = m.fMat[kMTransY];
         do {
-            dst->fY = SkScalarMulAdd(src->fY, my, ty);
-            dst->fX = SkScalarMulAdd(src->fX, mx, tx);
+            dst->fY = src->fY * my + ty;
+            dst->fX = src->fX * mx + tx;
             src += 1;
             dst += 1;
         } while (--count);
@@ -925,8 +952,8 @@ void SkMatrix::Rot_pts(const SkMatrix& m, SkPoint dst[],
             SkScalar sy = src->fY;
             SkScalar sx = src->fX;
             src += 1;
-            dst->fY = SkScalarMul(sx, ky) + SkScalarMul(sy, my);
-            dst->fX = SkScalarMul(sx, mx) + SkScalarMul(sy, kx);
+            dst->fY = sdot(sx, ky, sy, my);
+            dst->fX = sdot(sx, mx, sy, kx);
             dst += 1;
         } while (--count);
     }
@@ -947,8 +974,13 @@ void SkMatrix::RotTrans_pts(const SkMatrix& m, SkPoint dst[],
             SkScalar sy = src->fY;
             SkScalar sx = src->fX;
             src += 1;
-            dst->fY = SkScalarMul(sx, ky) + SkScalarMulAdd(sy, my, ty);
-            dst->fX = SkScalarMul(sx, mx) + SkScalarMulAdd(sy, kx, tx);
+#ifdef SK_LEGACY_MATRIX_MATH_ORDER
+            dst->fY = sx * ky + (sy * my + ty);
+            dst->fX = sx * mx + (sy * kx + tx);
+#else
+            dst->fY = sdot(sx, ky, sy, my) + ty;
+            dst->fX = sdot(sx, mx, sy, kx) + tx;
+#endif
             dst += 1;
         } while (--count);
     }
@@ -964,18 +996,19 @@ void SkMatrix::Persp_pts(const SkMatrix& m, SkPoint dst[],
             SkScalar sx = src->fX;
             src += 1;
 
-            SkScalar x = SkScalarMul(sx, m.fMat[kMScaleX]) +
-                         SkScalarMul(sy, m.fMat[kMSkewX]) + m.fMat[kMTransX];
-            SkScalar y = SkScalarMul(sx, m.fMat[kMSkewY]) +
-                         SkScalarMul(sy, m.fMat[kMScaleY]) + m.fMat[kMTransY];
-            SkScalar z = SkScalarMul(sx, m.fMat[kMPersp0]) +
-                        SkScalarMulAdd(sy, m.fMat[kMPersp1], m.fMat[kMPersp2]);
+            SkScalar x = sdot(sx, m.fMat[kMScaleX], sy, m.fMat[kMSkewX])  + m.fMat[kMTransX];
+            SkScalar y = sdot(sx, m.fMat[kMSkewY],  sy, m.fMat[kMScaleY]) + m.fMat[kMTransY];
+#ifdef SK_LEGACY_MATRIX_MATH_ORDER
+            SkScalar z = sx * m.fMat[kMPersp0] + (sy * m.fMat[kMPersp1] + m.fMat[kMPersp2]);
+#else
+            SkScalar z = sdot(sx, m.fMat[kMPersp0], sy, m.fMat[kMPersp1]) + m.fMat[kMPersp2];
+#endif
             if (z) {
                 z = SkScalarFastInvert(z);
             }
 
-            dst->fY = SkScalarMul(y, z);
-            dst->fX = SkScalarMul(x, z);
+            dst->fY = y * z;
+            dst->fX = x * z;
             dst += 1;
         } while (--count);
     }
@@ -1019,15 +1052,9 @@ void SkMatrix::mapHomogeneousPoints(SkScalar dst[], const SkScalar src[], int co
             SkScalar sw = src[2];
             src += 3;
 
-            SkScalar x = SkScalarMul(sx, fMat[kMScaleX]) +
-                         SkScalarMul(sy, fMat[kMSkewX]) +
-                         SkScalarMul(sw, fMat[kMTransX]);
-            SkScalar y = SkScalarMul(sx, fMat[kMSkewY]) +
-                         SkScalarMul(sy, fMat[kMScaleY]) +
-                         SkScalarMul(sw, fMat[kMTransY]);
-            SkScalar w = SkScalarMul(sx, fMat[kMPersp0]) +
-                         SkScalarMul(sy, fMat[kMPersp1]) +
-                         SkScalarMul(sw, fMat[kMPersp2]);
+            SkScalar x = sdot(sx, fMat[kMScaleX], sy, fMat[kMSkewX],  sw, fMat[kMTransX]);
+            SkScalar y = sdot(sx, fMat[kMSkewY],  sy, fMat[kMScaleY], sw, fMat[kMTransY]);
+            SkScalar w = sdot(sx, fMat[kMPersp0], sy, fMat[kMPersp1], sw, fMat[kMPersp2]);
 
             dst[0] = x;
             dst[1] = y;
@@ -1098,27 +1125,27 @@ void SkMatrix::Persp_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
                         SkPoint* pt) {
     SkASSERT(m.hasPerspective());
 
-    SkScalar x = SkScalarMul(sx, m.fMat[kMScaleX]) +
-                 SkScalarMul(sy, m.fMat[kMSkewX]) + m.fMat[kMTransX];
-    SkScalar y = SkScalarMul(sx, m.fMat[kMSkewY]) +
-                 SkScalarMul(sy, m.fMat[kMScaleY]) + m.fMat[kMTransY];
-    SkScalar z = SkScalarMul(sx, m.fMat[kMPersp0]) +
-                 SkScalarMul(sy, m.fMat[kMPersp1]) + m.fMat[kMPersp2];
+    SkScalar x = sdot(sx, m.fMat[kMScaleX], sy, m.fMat[kMSkewX])  + m.fMat[kMTransX];
+    SkScalar y = sdot(sx, m.fMat[kMSkewY],  sy, m.fMat[kMScaleY]) + m.fMat[kMTransY];
+    SkScalar z = sdot(sx, m.fMat[kMPersp0], sy, m.fMat[kMPersp1]) + m.fMat[kMPersp2];
     if (z) {
         z = SkScalarFastInvert(z);
     }
-    pt->fX = SkScalarMul(x, z);
-    pt->fY = SkScalarMul(y, z);
+    pt->fX = x * z;
+    pt->fY = y * z;
 }
 
 void SkMatrix::RotTrans_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
                            SkPoint* pt) {
     SkASSERT((m.getType() & (kAffine_Mask | kPerspective_Mask)) == kAffine_Mask);
 
-    pt->fX = SkScalarMul(sx, m.fMat[kMScaleX]) +
-             SkScalarMulAdd(sy, m.fMat[kMSkewX], m.fMat[kMTransX]);
-    pt->fY = SkScalarMul(sx, m.fMat[kMSkewY]) +
-             SkScalarMulAdd(sy, m.fMat[kMScaleY], m.fMat[kMTransY]);
+#ifdef SK_LEGACY_MATRIX_MATH_ORDER
+    pt->fX = sx * m.fMat[kMScaleX] + (sy * m.fMat[kMSkewX]  +  m.fMat[kMTransX]);
+    pt->fY = sx * m.fMat[kMSkewY]  + (sy * m.fMat[kMScaleY] + m.fMat[kMTransY]);
+#else
+    pt->fX = sdot(sx, m.fMat[kMScaleX], sy, m.fMat[kMSkewX])  + m.fMat[kMTransX];
+    pt->fY = sdot(sx, m.fMat[kMSkewY],  sy, m.fMat[kMScaleY]) + m.fMat[kMTransY];
+#endif
 }
 
 void SkMatrix::Rot_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
@@ -1127,10 +1154,13 @@ void SkMatrix::Rot_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
     SkASSERT(0 == m.fMat[kMTransX]);
     SkASSERT(0 == m.fMat[kMTransY]);
 
-    pt->fX = SkScalarMul(sx, m.fMat[kMScaleX]) +
-             SkScalarMulAdd(sy, m.fMat[kMSkewX], m.fMat[kMTransX]);
-    pt->fY = SkScalarMul(sx, m.fMat[kMSkewY]) +
-             SkScalarMulAdd(sy, m.fMat[kMScaleY], m.fMat[kMTransY]);
+#ifdef SK_LEGACY_MATRIX_MATH_ORDER
+    pt->fX = sx * m.fMat[kMScaleX] + (sy * m.fMat[kMSkewX]  + m.fMat[kMTransX]);
+    pt->fY = sx * m.fMat[kMSkewY]  + (sy * m.fMat[kMScaleY] + m.fMat[kMTransY]);
+#else
+    pt->fX = sdot(sx, m.fMat[kMScaleX], sy, m.fMat[kMSkewX])  + m.fMat[kMTransX];
+    pt->fY = sdot(sx, m.fMat[kMSkewY],  sy, m.fMat[kMScaleY]) + m.fMat[kMTransY];
+#endif
 }
 
 void SkMatrix::ScaleTrans_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
@@ -1138,8 +1168,8 @@ void SkMatrix::ScaleTrans_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
     SkASSERT((m.getType() & (kScale_Mask | kAffine_Mask | kPerspective_Mask))
              == kScale_Mask);
 
-    pt->fX = SkScalarMulAdd(sx, m.fMat[kMScaleX], m.fMat[kMTransX]);
-    pt->fY = SkScalarMulAdd(sy, m.fMat[kMScaleY], m.fMat[kMTransY]);
+    pt->fX = sx * m.fMat[kMScaleX] + m.fMat[kMTransX];
+    pt->fY = sy * m.fMat[kMScaleY] + m.fMat[kMTransY];
 }
 
 void SkMatrix::Scale_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
@@ -1149,8 +1179,8 @@ void SkMatrix::Scale_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
     SkASSERT(0 == m.fMat[kMTransX]);
     SkASSERT(0 == m.fMat[kMTransY]);
 
-    pt->fX = SkScalarMul(sx, m.fMat[kMScaleX]);
-    pt->fY = SkScalarMul(sy, m.fMat[kMScaleY]);
+    pt->fX = sx * m.fMat[kMScaleX];
+    pt->fY = sy * m.fMat[kMScaleY];
 }
 
 void SkMatrix::Trans_xy(const SkMatrix& m, SkScalar sx, SkScalar sy,
@@ -1190,7 +1220,7 @@ bool SkMatrix::fixedStepInX(SkScalar y, SkFixed* stepX, SkFixed* stepY) const {
     if (PerspNearlyZero(fMat[kMPersp0])) {
         if (stepX || stepY) {
             if (PerspNearlyZero(fMat[kMPersp1]) &&
-                    PerspNearlyZero(fMat[kMPersp2] - kMatrix22Elem)) {
+                    PerspNearlyZero(fMat[kMPersp2] - 1)) {
                 if (stepX) {
                     *stepX = SkScalarToFixed(fMat[kMScaleX]);
                 }
@@ -1200,10 +1230,10 @@ bool SkMatrix::fixedStepInX(SkScalar y, SkFixed* stepX, SkFixed* stepY) const {
             } else {
                 SkScalar z = y * fMat[kMPersp1] + fMat[kMPersp2];
                 if (stepX) {
-                    *stepX = SkScalarToFixed(SkScalarDiv(fMat[kMScaleX], z));
+                    *stepX = SkScalarToFixed(fMat[kMScaleX] / z);
                 }
                 if (stepY) {
-                    *stepY = SkScalarToFixed(SkScalarDiv(fMat[kMSkewY], z));
+                    *stepY = SkScalarToFixed(fMat[kMSkewY] / z);
                 }
             }
         }
@@ -1291,8 +1321,7 @@ static inline bool poly_to_point(SkPoint* pt, const SkPoint poly[], int count) {
                 pt2.fX = poly[0].fY - poly[3].fY;
                 pt2.fY = poly[3].fX - poly[0].fX;
             CALC_X:
-                x = SkScalarDiv(SkScalarMul(pt1.fX, pt2.fX) +
-                                SkScalarMul(pt1.fY, pt2.fY), y);
+                x = sdot(pt1.fX, pt2.fX, pt1.fY, pt2.fY) / y;
                 break;
         }
     }
@@ -1354,13 +1383,13 @@ bool SkMatrix::Poly4Proc(const SkPoint srcPt[], SkMatrix* dst,
         if (checkForZero(denom)) {
             return false;
         }
-        a1 = SkScalarDiv(SkScalarMulDiv(x0 - x1, y2, x2) - y0 + y1, denom);
+        a1 = (SkScalarMulDiv(x0 - x1, y2, x2) - y0 + y1) / denom;
     } else {
         float denom = x1 - SkScalarMulDiv(y1, x2, y2);
         if (checkForZero(denom)) {
             return false;
         }
-        a1 = SkScalarDiv(x0 - x1 - SkScalarMulDiv(y0 - y1, x2, y2), denom);
+        a1 = (x0 - x1 - SkScalarMulDiv(y0 - y1, x2, y2)) / denom;
     }
 
     /* check if abs(x1) > abs(y1) */
@@ -1369,27 +1398,25 @@ bool SkMatrix::Poly4Proc(const SkPoint srcPt[], SkMatrix* dst,
         if (checkForZero(denom)) {
             return false;
         }
-        a2 = SkScalarDiv(y0 - y2 - SkScalarMulDiv(x0 - x2, y1, x1), denom);
+        a2 = (y0 - y2 - SkScalarMulDiv(x0 - x2, y1, x1)) / denom;
     } else {
         float denom = SkScalarMulDiv(y2, x1, y1) - x2;
         if (checkForZero(denom)) {
             return false;
         }
-        a2 = SkScalarDiv(SkScalarMulDiv(y0 - y2, x1, y1) - x0 + x2, denom);
+        a2 = (SkScalarMulDiv(y0 - y2, x1, y1) - x0 + x2) / denom;
     }
 
-    float invScale = 1 / scale.fX;
-    dst->fMat[kMScaleX] = SkScalarMul(SkScalarMul(a2, srcPt[3].fX) +
-                                      srcPt[3].fX - srcPt[0].fX, invScale);
-    dst->fMat[kMSkewY] = SkScalarMul(SkScalarMul(a2, srcPt[3].fY) +
-                                     srcPt[3].fY - srcPt[0].fY, invScale);
-    dst->fMat[kMPersp0] = SkScalarMul(a2, invScale);
-    invScale = 1 / scale.fY;
-    dst->fMat[kMSkewX] = SkScalarMul(SkScalarMul(a1, srcPt[1].fX) +
-                                     srcPt[1].fX - srcPt[0].fX, invScale);
-    dst->fMat[kMScaleY] = SkScalarMul(SkScalarMul(a1, srcPt[1].fY) +
-                                      srcPt[1].fY - srcPt[0].fY, invScale);
-    dst->fMat[kMPersp1] = SkScalarMul(a1, invScale);
+    float invScale = SkScalarInvert(scale.fX);
+    dst->fMat[kMScaleX] = (a2 * srcPt[3].fX + srcPt[3].fX - srcPt[0].fX) * invScale;
+    dst->fMat[kMSkewY]  = (a2 * srcPt[3].fY + srcPt[3].fY - srcPt[0].fY) * invScale;
+    dst->fMat[kMPersp0] = a2 * invScale;
+
+    invScale = SkScalarInvert(scale.fY);
+    dst->fMat[kMSkewX]  = (a1 * srcPt[1].fX + srcPt[1].fX - srcPt[0].fX) * invScale;
+    dst->fMat[kMScaleY] = (a1 * srcPt[1].fY + srcPt[1].fY - srcPt[0].fY) * invScale;
+    dst->fMat[kMPersp1] = a1 * invScale;
+
     dst->fMat[kMTransX] = srcPt[0].fX;
     dst->fMat[kMTransY] = srcPt[0].fY;
     dst->fMat[kMPersp2] = 1;
@@ -1458,10 +1485,10 @@ enum MinOrMax {
 template <MinOrMax MIN_OR_MAX> SkScalar get_stretch_factor(SkMatrix::TypeMask typeMask,
                                                            const SkScalar m[9]) {
     if (typeMask & SkMatrix::kPerspective_Mask) {
-        return -SK_Scalar1;
+        return -1;
     }
     if (SkMatrix::kIdentity_Mask == typeMask) {
-        return SK_Scalar1;
+        return 1;
     }
     if (!(typeMask & SkMatrix::kAffine_Mask)) {
         if (kMin_MinOrMax == MIN_OR_MAX) {
@@ -1475,19 +1502,19 @@ template <MinOrMax MIN_OR_MAX> SkScalar get_stretch_factor(SkMatrix::TypeMask ty
     // ignore the translation part of the matrix, just look at 2x2 portion.
     // compute singular values, take largest or smallest abs value.
     // [a b; b c] = A^T*A
-    SkScalar a = SkScalarMul(m[SkMatrix::kMScaleX], m[SkMatrix::kMScaleX]) +
-                 SkScalarMul(m[SkMatrix::kMSkewY],  m[SkMatrix::kMSkewY]);
-    SkScalar b = SkScalarMul(m[SkMatrix::kMScaleX], m[SkMatrix::kMSkewX]) +
-                 SkScalarMul(m[SkMatrix::kMScaleY], m[SkMatrix::kMSkewY]);
-    SkScalar c = SkScalarMul(m[SkMatrix::kMSkewX],  m[SkMatrix::kMSkewX]) +
-                 SkScalarMul(m[SkMatrix::kMScaleY], m[SkMatrix::kMScaleY]);
+    SkScalar a = sdot(m[SkMatrix::kMScaleX], m[SkMatrix::kMScaleX],
+                      m[SkMatrix::kMSkewY],  m[SkMatrix::kMSkewY]);
+    SkScalar b = sdot(m[SkMatrix::kMScaleX], m[SkMatrix::kMSkewX],
+                      m[SkMatrix::kMScaleY], m[SkMatrix::kMSkewY]);
+    SkScalar c = sdot(m[SkMatrix::kMSkewX],  m[SkMatrix::kMSkewX],
+                      m[SkMatrix::kMScaleY], m[SkMatrix::kMScaleY]);
     // eigenvalues of A^T*A are the squared singular values of A.
     // characteristic equation is det((A^T*A) - l*I) = 0
     // l^2 - (a + c)l + (ac-b^2)
     // solve using quadratic equation (divisor is non-zero since l^2 has 1 coeff
     // and roots are guaranteed to be pos and real).
     SkScalar chosenRoot;
-    SkScalar bSqd = SkScalarMul(b,b);
+    SkScalar bSqd = b * b;
     // if upper left 2x2 is orthogonal save some math
     if (bSqd <= SK_ScalarNearlyZero*SK_ScalarNearlyZero) {
         if (kMin_MinOrMax == MIN_OR_MAX) {
@@ -1498,7 +1525,7 @@ template <MinOrMax MIN_OR_MAX> SkScalar get_stretch_factor(SkMatrix::TypeMask ty
     } else {
         SkScalar aminusc = a - c;
         SkScalar apluscdiv2 = SkScalarHalf(a + c);
-        SkScalar x = SkScalarHalf(SkScalarSqrt(SkScalarMul(aminusc, aminusc) + 4 * bSqd));
+        SkScalar x = SkScalarHalf(SkScalarSqrt(aminusc * aminusc + 4 * bSqd));
         if (kMin_MinOrMax == MIN_OR_MAX) {
             chosenRoot = apluscdiv2 - x;
         } else {
@@ -1661,7 +1688,7 @@ bool SkDecomposeUpper2x2(const SkMatrix& matrix,
     double Sa, Sb, Sd;
     // if M is already symmetric (i.e., M = I*S)
     if (SkScalarNearlyEqual(B, C)) {
-        cosQ = SK_Scalar1;
+        cosQ = 1;
         sinQ = 0;
 
         Sa = A;
@@ -1670,7 +1697,7 @@ bool SkDecomposeUpper2x2(const SkMatrix& matrix,
     } else {
         cosQ = A + D;
         sinQ = C - B;
-        SkScalar reciplen = SK_Scalar1/SkScalarSqrt(cosQ*cosQ + sinQ*sinQ);
+        SkScalar reciplen = SkScalarInvert(SkScalarSqrt(cosQ*cosQ + sinQ*sinQ));
         cosQ *= reciplen;
         sinQ *= reciplen;
 
@@ -1686,7 +1713,7 @@ bool SkDecomposeUpper2x2(const SkMatrix& matrix,
     // From this, should be able to reconstruct S as U*W*U^T
     if (SkScalarNearlyZero(SkDoubleToScalar(Sb))) {
         // already diagonalized
-        cos1 = SK_Scalar1;
+        cos1 = 1;
         sin1 = 0;
         w1 = Sa;
         w2 = Sd;
@@ -1705,7 +1732,7 @@ bool SkDecomposeUpper2x2(const SkMatrix& matrix,
         }
 
         cos1 = SkDoubleToScalar(Sb); sin1 = SkDoubleToScalar(w1 - Sa);
-        SkScalar reciplen = SK_Scalar1/SkScalarSqrt(cos1*cos1 + sin1*sin1);
+        SkScalar reciplen = SkScalarInvert(SkScalarSqrt(cos1*cos1 + sin1*sin1));
         cos1 *= reciplen;
         sin1 *= reciplen;