stop using SkScalarMul

BUG=skia:

Change-Id: Ie41d8665a1c62ba8eddc93d8cfefaf64ddc52ff8
Reviewed-on: https://skia-review.googlesource.com/8411
Reviewed-by: Ben Wagner <bungeman@google.com>
Commit-Queue: Mike Reed <reed@google.com>

3 files changed, 24 insertions, 30 deletions

diff --git a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
index 9422261c49..898f49be09 100644
--- a/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
+++ b/experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
@@ -79,10 +79,7 @@ inline int checkNoise(int noiseValue, int limitValue, int newValue) {
 }
 
 inline SkScalar smoothCurve(SkScalar t) {
-    static const SkScalar SK_Scalar3 = 3.0f;
-
-    // returns t * t * (3 - 2 * t)
-    return SkScalarMul(SkScalarSquare(t), SK_Scalar3 - 2 * t);
+    return t * t * (3 - 2 * t);
 }
 
 } // end namespace
@@ -244,16 +241,14 @@ private:
         for (int channel = 0; channel < 4; ++channel) {
             for (int i = 0; i < kBlockSize; ++i) {
                 fGradient[channel][i] = SkPoint::Make(
-                    SkScalarMul(SkIntToScalar(fNoise[channel][i][0] - kBlockSize),
-                                gInvBlockSizef),
-                    SkScalarMul(SkIntToScalar(fNoise[channel][i][1] - kBlockSize),
-                                gInvBlockSizef));
+                    (fNoise[channel][i][0] - kBlockSize) * gInvBlockSizef,
+                    (fNoise[channel][i][1] - kBlockSize) * gInvBlockSizef);
                 fGradient[channel][i].normalize();
                 // Put the normalized gradient back into the noise data
-                fNoise[channel][i][0] = SkScalarRoundToInt(SkScalarMul(
-                    fGradient[channel][i].fX + SK_Scalar1, gHalfMax16bits));
-                fNoise[channel][i][1] = SkScalarRoundToInt(SkScalarMul(
-                    fGradient[channel][i].fY + SK_Scalar1, gHalfMax16bits));
+                fNoise[channel][i][0] = SkScalarRoundToInt(
+                                               (fGradient[channel][i].fX + 1) * gHalfMax16bits);
+                fNoise[channel][i][1] = SkScalarRoundToInt(
+                                               (fGradient[channel][i].fY + 1) * gHalfMax16bits);
             }
         }
     }
@@ -451,8 +446,8 @@ SkScalar SkPerlinNoiseShader2::PerlinNoiseShaderContext::calculateTurbulenceValu
         stitchData = fPaintingData->fStitchDataInit;
     }
     SkScalar turbulenceFunctionResult = 0;
-    SkPoint noiseVector(SkPoint::Make(SkScalarMul(point.x(), fPaintingData->fBaseFrequency.fX),
-                                      SkScalarMul(point.y(), fPaintingData->fBaseFrequency.fY)));
+    SkPoint noiseVector(SkPoint::Make(point.x() * fPaintingData->fBaseFrequency.fX,
+                                      point.y() * fPaintingData->fBaseFrequency.fY));
     SkScalar ratio = SK_Scalar1;
     for (int octave = 0; octave < perlinNoiseShader.fNumOctaves; ++octave) {
         SkScalar noise = noise2D(channel, stitchData, noiseVector);
@@ -474,8 +469,7 @@ SkScalar SkPerlinNoiseShader2::PerlinNoiseShaderContext::calculateTurbulenceValu
     // The value of turbulenceFunctionResult comes from ((turbulenceFunctionResult) + 1) / 2
     // by fractalNoise and (turbulenceFunctionResult) by turbulence.
     if (perlinNoiseShader.fType == kFractalNoise_Type) {
-        turbulenceFunctionResult =
-            SkScalarMul(turbulenceFunctionResult, SK_ScalarHalf) + SK_ScalarHalf;
+        turbulenceFunctionResult = SkScalarHalf(turbulenceFunctionResult + 1);
     }
 
     if (channel == 3) { // Scale alpha by paint value
diff --git a/experimental/SkSetPoly3To3.cpp b/experimental/SkSetPoly3To3.cpp
index 750db3074f..f8d8d1d46b 100644
--- a/experimental/SkSetPoly3To3.cpp
+++ b/experimental/SkSetPoly3To3.cpp
@@ -19,15 +19,15 @@ static void computeOuterProduct(SkScalar op[4],
         SkScalar y0 = pts0[i].fY - ave0.fY;
         SkScalar x1 = pts1[i].fX - ave1.fX;
         SkScalar y1 = pts1[i].fY - ave1.fY;
-        op[0] += SkScalarMul(x0, x1);
-        op[1] += SkScalarMul(x0, y1);
-        op[2] += SkScalarMul(y0, x1);
-        op[3] += SkScalarMul(y0, y1);
+        op[0] += x0 * x1;
+        op[1] += x0 * y1;
+        op[2] += y0 * x1;
+        op[3] += y0 * y1;
     }
 }
 
 static SkScalar dot(SkScalar ax, SkScalar ay, SkScalar bx, SkScalar by) {
-    return SkScalarMul(ax, bx) + SkScalarMul(ay, by);
+    return ax * bx + ay * by;
 }
 
 bool SkSetPoly3To3(SkMatrix* matrix, const SkPoint src[3], const SkPoint dst[3]) {
@@ -39,7 +39,7 @@ bool SkSetPoly3To3(SkMatrix* matrix, const SkPoint src[3], const SkPoint dst[3])
     computeOuterProduct(srcOP, src, srcAve, src, srcAve);
     computeOuterProduct(dstOP, src, srcAve, dst, dstAve);
 
-    SkScalar det = SkScalarMul(srcOP[0], srcOP[3]) - SkScalarMul(srcOP[1], srcOP[2]);
+    SkScalar det = srcOP[0] * srcOP[3] - srcOP[1] * srcOP[2];
 
     // need SkScalarNearlyZeroSquared for this (to match Chrome's fix)
     if (SkScalarNearlyZero(det)) {
@@ -51,10 +51,10 @@ bool SkSetPoly3To3(SkMatrix* matrix, const SkPoint src[3], const SkPoint dst[3])
     // now compute invDet * [srcOP]T * [dstOP]
 
     // scale and transpose
-    const SkScalar srcOP0 = SkScalarMul( srcOP[3], invDet);
-    const SkScalar srcOP1 = SkScalarMul(-srcOP[1], invDet);
-    const SkScalar srcOP2 = SkScalarMul(-srcOP[2], invDet);
-    const SkScalar srcOP3 = SkScalarMul( srcOP[0], invDet);
+    const SkScalar srcOP0 =  srcOP[3] * invDet;
+    const SkScalar srcOP1 = -srcOP[1] * invDet;
+    const SkScalar srcOP2 = -srcOP[2] * invDet;
+    const SkScalar srcOP3 =  srcOP[0] * invDet;
 
     matrix->reset();
     matrix->setScaleX(dot(srcOP0, srcOP1, dstOP[0], dstOP[2]));
diff --git a/experimental/SkSetPoly3To3_A.cpp b/experimental/SkSetPoly3To3_A.cpp
index 18777a77b5..bce6314d17 100644
--- a/experimental/SkSetPoly3To3_A.cpp
+++ b/experimental/SkSetPoly3To3_A.cpp
@@ -32,10 +32,10 @@ static void computeOuterProduct(SkScalar op[4],
         SkScalar y0 = pts0[i].fY - ave0.fY;
         SkScalar x1 = pts1[i].fX - ave1.fX;
         SkScalar y1 = pts1[i].fY - ave1.fY;
-        op[0] += SkScalarMul(x0, x1);
-        op[1] += SkScalarMul(x0, y1);
-        op[2] += SkScalarMul(y0, x1);
-        op[3] += SkScalarMul(y0, y1);
+        op[0] += x0 * x1;
+        op[1] += x0 * y1;
+        op[2] += y0 * x1;
+        op[3] += y0 * y1;
     }
 }