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>

26 files changed, 86 insertions, 98 deletions

diff --git a/bench/ColorFilterBench.cpp b/bench/ColorFilterBench.cpp
index 40ec64456b..54a04d2771 100644
--- a/bench/ColorFilterBench.cpp
+++ b/bench/ColorFilterBench.cpp
@@ -16,7 +16,7 @@
 #define FILTER_HEIGHT_LARGE SkIntToScalar(256)
 
 static sk_sp<SkImageFilter> make_brightness(float amount, sk_sp<SkImageFilter> input) {
-    SkScalar amount255 = SkScalarMul(amount, SkIntToScalar(255));
+    SkScalar amount255 = amount * 255;
     SkScalar matrix[20] = { 1, 0, 0, 0, amount255,
                             0, 1, 0, 0, amount255,
                             0, 0, 1, 0, amount255,
diff --git a/bench/FSRectBench.cpp b/bench/FSRectBench.cpp
index 2d5abc21cd..ba68ea1dfa 100644
--- a/bench/FSRectBench.cpp
+++ b/bench/FSRectBench.cpp
@@ -28,10 +28,10 @@ protected:
             static const SkScalar kMaxOffset = 100 * SK_Scalar1;
             static const SkScalar kOffsetRange = kMaxOffset - kMinOffset;
             for (int i = 0; i < N; ++i) {
-                fRects[i].fLeft = -kMinOffset - SkScalarMul(rand.nextUScalar1(), kOffsetRange);
-                fRects[i].fTop = -kMinOffset - SkScalarMul(rand.nextUScalar1(), kOffsetRange);
-                fRects[i].fRight = W + kMinOffset + SkScalarMul(rand.nextUScalar1(), kOffsetRange);
-                fRects[i].fBottom = H + kMinOffset + SkScalarMul(rand.nextUScalar1(), kOffsetRange);
+                fRects[i].fLeft = -kMinOffset - rand.nextUScalar1() * kOffsetRange;
+                fRects[i].fTop = -kMinOffset - rand.nextUScalar1() * kOffsetRange;
+                fRects[i].fRight = W + kMinOffset + rand.nextUScalar1() * kOffsetRange;
+                fRects[i].fBottom = H + kMinOffset + rand.nextUScalar1() * kOffsetRange;
                 fColors[i] = rand.nextU() | 0xFF000000;
             }
             fInit = true;
diff --git a/bench/ImageFilterCollapse.cpp b/bench/ImageFilterCollapse.cpp
index d85d1de330..ce27f06dd0 100644
--- a/bench/ImageFilterCollapse.cpp
+++ b/bench/ImageFilterCollapse.cpp
@@ -98,7 +98,7 @@ private:
 };
 
 static sk_sp<SkColorFilter> make_brightness(float amount) {
-    SkScalar amount255 = SkScalarMul(amount, SkIntToScalar(255));
+    SkScalar amount255 = amount * 255;
     SkScalar matrix[20] = { 1, 0, 0, 0, amount255,
                             0, 1, 0, 0, amount255,
                             0, 0, 1, 0, amount255,
diff --git a/bench/LightingBench.cpp b/bench/LightingBench.cpp
index bbe0af343c..a924f4a9ce 100644
--- a/bench/LightingBench.cpp
+++ b/bench/LightingBench.cpp
@@ -37,11 +37,10 @@ protected:
     static SkPoint3 GetDistantDirection() {
         static SkScalar azimuthRad = SkDegreesToRadians(SkIntToScalar(225));
         static SkScalar elevationRad = SkDegreesToRadians(SkIntToScalar(5));
-        static SkPoint3 distantDirection = SkPoint3::Make(SkScalarMul(SkScalarCos(azimuthRad),
-                                                                      SkScalarCos(elevationRad)),
-                                                          SkScalarMul(SkScalarSin(azimuthRad),
-                                                                      SkScalarCos(elevationRad)),
-                                                          SkScalarSin(elevationRad));
+        static SkPoint3 distantDirection = SkPoint3::Make(
+                                              SkScalarCos(azimuthRad) * SkScalarCos(elevationRad),
+                                              SkScalarSin(azimuthRad) * SkScalarCos(elevationRad),
+                                              SkScalarSin(elevationRad));
         return distantDirection;
     }
 
diff --git a/bench/PathBench.cpp b/bench/PathBench.cpp
index 10cffc20c2..3a1410a32d 100644
--- a/bench/PathBench.cpp
+++ b/bench/PathBench.cpp
@@ -272,10 +272,8 @@ public:
         SkRandom rand (12);
         int i;
         for (i = 0; i < 100; i++) {
-            path->quadTo(SkScalarMul(rand.nextUScalar1(), SkIntToScalar(640)),
-                         SkScalarMul(rand.nextUScalar1(), SkIntToScalar(480)),
-                         SkScalarMul(rand.nextUScalar1(), SkIntToScalar(640)),
-                         SkScalarMul(rand.nextUScalar1(), SkIntToScalar(480)));
+            path->quadTo(rand.nextUScalar1() * 640, rand.nextUScalar1() * 480,
+                         rand.nextUScalar1() * 640, rand.nextUScalar1() * 480);
         }
         path->close();
     }
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;
     }
 }
 
diff --git a/gm/beziereffects.cpp b/gm/beziereffects.cpp
index cc28538dd0..661e7709d3 100644
--- a/gm/beziereffects.cpp
+++ b/gm/beziereffects.cpp
@@ -145,8 +145,8 @@ protected:
                 if (!gp) {
                     continue;
                 }
-                SkScalar x = SkScalarMul(col, w);
-                SkScalar y = SkScalarMul(row, h);
+                SkScalar x = col * w;
+                SkScalar y = row * h;
                 SkPoint controlPts[] = {
                     {x + baseControlPts[0].fX, y + baseControlPts[0].fY},
                     {x + baseControlPts[1].fX, y + baseControlPts[1].fY},
@@ -281,8 +281,8 @@ protected:
                     continue;
                 }
 
-                SkScalar x = SkScalarMul(col, w);
-                SkScalar y = SkScalarMul(row, h);
+                SkScalar x = col * w;
+                SkScalar y = row * h;
                 SkPoint controlPts[] = {
                     {x + baseControlPts[0].fX, y + baseControlPts[0].fY},
                     {x + baseControlPts[1].fX, y + baseControlPts[1].fY},
@@ -498,8 +498,8 @@ protected:
                     continue;
                 }
 
-                SkScalar x = SkScalarMul(col, w);
-                SkScalar y = SkScalarMul(row, h);
+                SkScalar x = col * w;
+                SkScalar y = row * h;
                 SkPoint controlPts[] = {
                     {x + baseControlPts[0].fX, y + baseControlPts[0].fY},
                     {x + baseControlPts[1].fX, y + baseControlPts[1].fY},
diff --git a/gm/colorfilterimagefilter.cpp b/gm/colorfilterimagefilter.cpp
index 6e07ed3cc1..912eda12c4 100644
--- a/gm/colorfilterimagefilter.cpp
+++ b/gm/colorfilterimagefilter.cpp
@@ -19,7 +19,7 @@
 #define MARGIN          SkIntToScalar(10)
 
 static sk_sp<SkColorFilter> cf_make_brightness(float brightness) {
-    SkScalar amount255 = SkScalarMul(brightness, SkIntToScalar(255));
+    SkScalar amount255 = brightness * 255;
     SkScalar matrix[20] = {
         1, 0, 0, 0, amount255,
         0, 1, 0, 0, amount255,
diff --git a/gm/imagefiltersscaled.cpp b/gm/imagefiltersscaled.cpp
index 756b7c624c..39d58f3724 100644
--- a/gm/imagefiltersscaled.cpp
+++ b/gm/imagefiltersscaled.cpp
@@ -28,7 +28,7 @@
 static sk_sp<SkImage> make_gradient_circle(int width, int height) {
     SkScalar x = SkIntToScalar(width / 2);
     SkScalar y = SkIntToScalar(height / 2);
-    SkScalar radius = SkScalarMul(SkMinScalar(x, y), SkIntToScalar(4) / SkIntToScalar(5));
+    SkScalar radius = SkMinScalar(x, y) * 4 / 5;
     sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(width, height));
     SkCanvas* canvas = surface->getCanvas();
     canvas->clear(0x00000000);
diff --git a/gm/lighting.cpp b/gm/lighting.cpp
index cd4132e1b5..97c6f52fef 100644
--- a/gm/lighting.cpp
+++ b/gm/lighting.cpp
@@ -73,10 +73,8 @@ protected:
                                                 SkIntToScalar(10));
         SkScalar elevationRad = SkDegreesToRadians(SkIntToScalar(5));
 
-        SkPoint3 distantDirection = SkPoint3::Make(SkScalarMul(cosAzimuth,
-                                                               SkScalarCos(elevationRad)),
-                                                   SkScalarMul(sinAzimuth,
-                                                               SkScalarCos(elevationRad)),
+        SkPoint3 distantDirection = SkPoint3::Make(cosAzimuth * SkScalarCos(elevationRad),
+                                                   sinAzimuth * SkScalarCos(elevationRad),
                                                    SkScalarSin(elevationRad));
         SkScalar cutoffAngle = SkIntToScalar(15);
         SkScalar kd = SkIntToScalar(2);
diff --git a/gm/pathfill.cpp b/gm/pathfill.cpp
index 2562e7c9a5..de762a9548 100644
--- a/gm/pathfill.cpp
+++ b/gm/pathfill.cpp
@@ -119,7 +119,7 @@ static SkScalar make_star(SkPath* path, int n) {
     for (int i = 1; i < n; i++) {
         rad += drad;
         SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
-        path->lineTo(c + SkScalarMul(cosV, r), c + SkScalarMul(sinV, r));
+        path->lineTo(c + cosV * r, c + sinV * r);
     }
     path->close();
     return r * 2 * 6 / 5;
diff --git a/gm/smallpaths.cpp b/gm/smallpaths.cpp
index ddbb60dcfd..b6a3b33cdc 100644
--- a/gm/smallpaths.cpp
+++ b/gm/smallpaths.cpp
@@ -49,7 +49,7 @@ static SkScalar make_star(SkPath* path, int n) {
     for (int i = 1; i < n; i++) {
         rad += drad;
         SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
-        path->lineTo(c + SkScalarMul(cosV, r), c + SkScalarMul(sinV, r));
+        path->lineTo(c + cosV * r, c + sinV * r);
     }
     path->close();
     return r * 2 * 6 / 5;
diff --git a/gm/strokefill.cpp b/gm/strokefill.cpp
index 98e9bbb868..3e81107e2a 100644
--- a/gm/strokefill.cpp
+++ b/gm/strokefill.cpp
@@ -241,7 +241,7 @@ static void path_bold(SkCanvas* canvas, const SkPath& path, const SkPaint& paint
         SkScalar fakeBoldScale = SkScalarInterpFunc(p.getTextSize(),
                 kStdFakeBoldInterpKeys, kStdFakeBoldInterpValues,
                 kStdFakeBoldInterpLength);
-        SkScalar extra = SkScalarMul(p.getTextSize(), fakeBoldScale);
+        SkScalar extra = p.getTextSize() * fakeBoldScale;
         p.setStrokeWidth(extra);
         canvas->save();
         canvas->translate(0, 120);
diff --git a/gn/android_framework_defines.gni b/gn/android_framework_defines.gni
index b693d2808d..17a566bde5 100644
--- a/gn/android_framework_defines.gni
+++ b/gn/android_framework_defines.gni
@@ -16,4 +16,5 @@ android_framework_defines = [
   "SK_SUPPORT_LEGACY_SHADER_ISABITMAP",
   "SK_SUPPORT_LEGACY_EMBOSSMASKFILTER",
   "SK_SUPPORT_EXOTIC_CLIPOPS",
+  "SK_SUPPORT_LEGACY_SCALARMUL",
 ]
diff --git a/include/core/SkScalar.h b/include/core/SkScalar.h
index c4bfce8779..0dd968c7c3 100644
--- a/include/core/SkScalar.h
+++ b/include/core/SkScalar.h
@@ -134,9 +134,6 @@ SkScalar SkScalarSinCos(SkScalar radians, SkScalar* cosValue);
 
 static inline SkScalar SkScalarSquare(SkScalar x) { return x * x; }
 
-#define SkScalarMul(a, b)       ((SkScalar)(a) * (b))
-#define SkScalarMulAdd(a, b, c) ((SkScalar)(a) * (b) + (c))
-#define SkScalarMulDiv(a, b, c) ((SkScalar)(a) * (b) / (c))
 #define SkScalarInvert(x)       (SK_Scalar1 / (x))
 #define SkScalarFastInvert(x)   (SK_Scalar1 / (x))
 #define SkScalarAve(a, b)       (((a) + (b)) * SK_ScalarHalf)
@@ -218,4 +215,10 @@ static inline bool SkScalarsEqual(const SkScalar a[], const SkScalar b[], int n)
     return true;
 }
 
+#ifdef SK_SUPPORT_LEGACY_SCALARMUL
+    #define SkScalarMul(a, b)       ((SkScalar)(a) * (b))
+    #define SkScalarMulAdd(a, b, c) ((SkScalar)(a) * (b) + (c))
+    #define SkScalarMulDiv(a, b, c) ((SkScalar)(a) * (b) / (c))
+#endif
+
 #endif
diff --git a/public.bzl b/public.bzl
index 4f063ffac3..430dbc84e0 100644
--- a/public.bzl
+++ b/public.bzl
@@ -599,6 +599,7 @@ DEFINES_ALL = [
     "SK_NO_ANALYTIC_AA",
     "SK_SUPPORT_LEGACY_BITMAP_SETPIXELREF",
     "SK_SUPPORT_LEGACY_CLIPOP_EXOTIC_NAMES",
+    "SK_SUPPORT_LEGACY_SCALARMUL",
 ]
 
 ################################################################################
diff --git a/samplecode/SampleApp.cpp b/samplecode/SampleApp.cpp
index 81a8fe8fed..8b5e074173 100644
--- a/samplecode/SampleApp.cpp
+++ b/samplecode/SampleApp.cpp
@@ -1305,30 +1305,30 @@ void SampleWindow::showZoomer(SkCanvas* canvas) {
     string.appendf("(%i, %i)", fMouseX, fMouseY);
     SkScalar left = dest.fLeft + SkIntToScalar(3);
     SkScalar i = SK_Scalar1;
-    drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+    drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
     // Alpha
     i += SK_Scalar1;
     string.reset();
     string.appendf("A: %X", SkColorGetA(color));
-    drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+    drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
     // Red
     i += SK_Scalar1;
     string.reset();
     string.appendf("R: %X", SkColorGetR(color));
     paint.setColor(SK_ColorRED);
-    drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+    drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
     // Green
     i += SK_Scalar1;
     string.reset();
     string.appendf("G: %X", SkColorGetG(color));
     paint.setColor(0xFF008800);
-    drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+    drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
     // Blue
     i += SK_Scalar1;
     string.reset();
     string.appendf("B: %X", SkColorGetB(color));
     paint.setColor(SK_ColorBLUE);
-    drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
+    drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
     canvas->restoreToCount(count);
 }
 
diff --git a/samplecode/SampleClip.cpp b/samplecode/SampleClip.cpp
index 75367cc122..41192fbbc4 100644
--- a/samplecode/SampleClip.cpp
+++ b/samplecode/SampleClip.cpp
@@ -57,7 +57,7 @@ static void show_fill(SkCanvas* canvas, bool doAA) {
 
 static SkScalar randRange(SkRandom& rand, SkScalar min, SkScalar max) {
     SkASSERT(min <= max);
-    return min + SkScalarMul(rand.nextUScalar1(), max - min);
+    return min + rand.nextUScalar1() * (max - min);
 }
 
 static void show_stroke(SkCanvas* canvas, bool doAA, SkScalar strokeWidth, int n) {
diff --git a/samplecode/SamplePatch.cpp b/samplecode/SamplePatch.cpp
index b105090db2..54de942fc8 100644
--- a/samplecode/SamplePatch.cpp
+++ b/samplecode/SamplePatch.cpp
@@ -87,24 +87,18 @@ static void eval_sheet(const SkPoint edge[], int nu, int nv, int iu, int iv,
     SkScalar u = SkIntToScalar(iu) / nu;
     SkScalar v = SkIntToScalar(iv) / nv;
 
-    SkScalar uv = SkScalarMul(u, v);
-    SkScalar Uv = SkScalarMul(SK_Scalar1 - u, v);
-    SkScalar uV = SkScalarMul(u, SK_Scalar1 - v);
-    SkScalar UV = SkScalarMul(SK_Scalar1 - u, SK_Scalar1 - v);
-
-    SkScalar x0 = SkScalarMul(UV, edge[TL].fX) + SkScalarMul(uV, edge[TR].fX) +
-                  SkScalarMul(Uv, edge[BL].fX) + SkScalarMul(uv, edge[BR].fX);
-    SkScalar y0 = SkScalarMul(UV, edge[TL].fY) + SkScalarMul(uV, edge[TR].fY) +
-                  SkScalarMul(Uv, edge[BL].fY) + SkScalarMul(uv, edge[BR].fY);
-
-    SkScalar x =    SkScalarMul(SK_Scalar1 - v, edge[TL+iu].fX) +
-                    SkScalarMul(u, edge[TR+iv].fX) +
-                    SkScalarMul(v, edge[BR+nu-iu].fX) +
-                    SkScalarMul(SK_Scalar1 - u, edge[BL+nv-iv].fX) - x0;
-    SkScalar y =    SkScalarMul(SK_Scalar1 - v, edge[TL+iu].fY) +
-                    SkScalarMul(u, edge[TR+iv].fY) +
-                    SkScalarMul(v, edge[BR+nu-iu].fY) +
-                    SkScalarMul(SK_Scalar1 - u, edge[BL+nv-iv].fY) - y0;
+    SkScalar uv = u * v;
+    SkScalar Uv = (1 - u) * v;
+    SkScalar uV = u * (1 - v);
+    SkScalar UV = (1 - u) * (1 - v);
+
+    SkScalar x0 = UV * edge[TL].fX + uV * edge[TR].fX + Uv * edge[BL].fX + uv * edge[BR].fX;
+    SkScalar y0 = UV * edge[TL].fY + uV * edge[TR].fY + Uv * edge[BL].fY + uv * edge[BR].fY;
+
+    SkScalar x = (1 - v) * edge[TL+iu].fX + u * edge[TR+iv].fX +
+                 v * edge[BR+nu-iu].fX + (1 - u) * edge[BL+nv-iv].fX - x0;
+    SkScalar y = (1 - v) * edge[TL+iu].fY + u * edge[TR+iv].fY +
+                 v * edge[BR+nu-iu].fY + (1 - u) * edge[BL+nv-iv].fY - y0;
     pt->set(x, y);
 }
 
diff --git a/samplecode/SamplePathFill.cpp b/samplecode/SamplePathFill.cpp
index 2f0dc6ff25..fbc4c2e749 100644
--- a/samplecode/SamplePathFill.cpp
+++ b/samplecode/SamplePathFill.cpp
@@ -82,7 +82,7 @@ static SkScalar make_star(SkPath* path, int n) {
     for (int i = 1; i < n; i++) {
         rad += drad;
         SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
-        path->lineTo(c + SkScalarMul(cosV, r), c + SkScalarMul(sinV, r));
+        path->lineTo(c + cosV * r, c + sinV * r);
     }
     path->close();
     return r * 2 * 6 / 5;
diff --git a/tests/ClipStackTest.cpp b/tests/ClipStackTest.cpp
index 8448f4cbe5..744ef18d17 100644
--- a/tests/ClipStackTest.cpp
+++ b/tests/ClipStackTest.cpp
@@ -979,8 +979,8 @@ static void test_reduced_clip_stack(skiatest::Reporter* reporter) {
             bool doSave = r.nextBool();
 
             SkSize size = SkSize::Make(
-                SkScalarMul(kBounds.width(), r.nextRangeScalar(kMinElemSizeFrac, kMaxElemSizeFrac)),
-                SkScalarMul(kBounds.height(), r.nextRangeScalar(kMinElemSizeFrac, kMaxElemSizeFrac)));
+                kBounds.width()  * r.nextRangeScalar(kMinElemSizeFrac, kMaxElemSizeFrac),
+                kBounds.height() * r.nextRangeScalar(kMinElemSizeFrac, kMaxElemSizeFrac));
 
             SkPoint xy = {r.nextRangeScalar(kBounds.fLeft, kBounds.fRight - size.fWidth),
                           r.nextRangeScalar(kBounds.fTop, kBounds.fBottom - size.fHeight)};
diff --git a/tests/PaintTest.cpp b/tests/PaintTest.cpp
index 55a82a73e4..7ddcd0d78f 100644
--- a/tests/PaintTest.cpp
+++ b/tests/PaintTest.cpp
@@ -192,7 +192,7 @@ DEF_TEST(Paint_regression_cubic, reporter) {
     SkRect maxR = fillR;
     SkScalar miter = SkMaxScalar(SK_Scalar1, paint.getStrokeMiter());
     SkScalar inset = paint.getStrokeJoin() == SkPaint::kMiter_Join ?
-                            SkScalarMul(paint.getStrokeWidth(), miter) :
+                            paint.getStrokeWidth() * miter :
                             paint.getStrokeWidth();
     maxR.inset(-inset, -inset);
 
diff --git a/tests/PathTest.cpp b/tests/PathTest.cpp
index 694dab57ee..d45f02eaf5 100644
--- a/tests/PathTest.cpp
+++ b/tests/PathTest.cpp
@@ -1739,7 +1739,7 @@ static void test_conservativelyContains(skiatest::Reporter* reporter) {
 
     // A circle that bounds kBaseRect (with a significant amount of slop)
     SkScalar circleR = SkMaxScalar(kBaseRect.width(), kBaseRect.height());
-    circleR = SkScalarMul(circleR, 1.75f) / 2;
+    circleR *= 1.75f / 2;
     static const SkPoint kCircleC = {kBaseRect.centerX(), kBaseRect.centerY()};
 
     // round-rect radii
diff --git a/tests/RoundRectTest.cpp b/tests/RoundRectTest.cpp
index 37f5318d30..ce9744571b 100644
--- a/tests/RoundRectTest.cpp
+++ b/tests/RoundRectTest.cpp
@@ -660,18 +660,18 @@ static void test_transform_helper(skiatest::Reporter* reporter, const SkRRect& o
     // Radii are scaled.
     for (int i = 0; i < 4; ++i) {
         REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.radii((SkRRect::Corner) i).fX,
-                                    SkScalarMul(orig.radii((SkRRect::Corner) i).fX, xScale)));
+                                    orig.radii((SkRRect::Corner) i).fX * xScale));
         REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.radii((SkRRect::Corner) i).fY,
-                                    SkScalarMul(orig.radii((SkRRect::Corner) i).fY, yScale)));
+                                    orig.radii((SkRRect::Corner) i).fY * yScale));
     }
     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.rect().width(),
-                                                  SkScalarMul(orig.rect().width(), xScale)));
+                                                  orig.rect().width() * xScale));
     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.rect().height(),
-                                                  SkScalarMul(orig.rect().height(), yScale)));
+                                                  orig.rect().height() * yScale));
     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.rect().left(),
-                                                  SkScalarMul(orig.rect().left(), xScale)));
+                                                  orig.rect().left() * xScale));
     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.rect().top(),
-                                                  SkScalarMul(orig.rect().top(), yScale)));
+                                                  orig.rect().top() * yScale));
 }
 
 static void test_round_rect_transform(skiatest::Reporter* reporter) {