diff --git a/RELEASE_NOTES.txt b/RELEASE_NOTES.txt
index 8bfd999..3bf04f5 100644
--- a/RELEASE_NOTES.txt
+++ b/RELEASE_NOTES.txt
@@ -7,6 +7,8 @@
 Milestone 82
 
 <Insert new notes here- top is most recent.>
+  * Removed SkMaxScalar and SkMinScalar.
+
   * SkColorSetA now warns if the result is unused.
 
   * An SkImageInfo with a null SkColorSpace passed to SkCodec::getPixels() and
diff --git a/bench/PathBench.cpp b/bench/PathBench.cpp
index c92e88d..e78080b 100644
--- a/bench/PathBench.cpp
+++ b/bench/PathBench.cpp
@@ -732,8 +732,8 @@
                                int startAngle)
     {
 
-        SkScalar rx = SkMinScalar(rect.width(), xIn);
-        SkScalar ry = SkMinScalar(rect.height(), yIn);
+        SkScalar rx = std::min(rect.width(), xIn);
+        SkScalar ry = std::min(rect.height(), yIn);
 
         SkRect arcRect;
         arcRect.setLTRB(-rx, -ry, rx, ry);
diff --git a/gm/convexpolyclip.cpp b/gm/convexpolyclip.cpp
index 31dc1d4..7298a95 100644
--- a/gm/convexpolyclip.cpp
+++ b/gm/convexpolyclip.cpp
@@ -39,7 +39,7 @@
 
     SkPoint     pt = { wScalar / 2, hScalar / 2 };
 
-    SkScalar    radius = 3 * SkMaxScalar(wScalar, hScalar);
+    SkScalar    radius = 3 * std::max(wScalar, hScalar);
 
     SkColor colors[] = {SK_ColorDKGRAY,
                         ToolUtils::color_to_565(0xFF222255),
diff --git a/gm/drawbitmaprect.cpp b/gm/drawbitmaprect.cpp
index e4bfac8..ab73b6b 100644
--- a/gm/drawbitmaprect.cpp
+++ b/gm/drawbitmaprect.cpp
@@ -60,7 +60,7 @@
 
     SkPoint     pt = { wScalar / 2, hScalar / 2 };
 
-    SkScalar    radius = 4 * SkMaxScalar(wScalar, hScalar);
+    SkScalar    radius = 4 * std::max(wScalar, hScalar);
 
     SkColor     colors[] = { SK_ColorRED, SK_ColorYELLOW,
                              SK_ColorGREEN, SK_ColorMAGENTA,
diff --git a/gm/drawminibitmaprect.cpp b/gm/drawminibitmaprect.cpp
index 8f9d606..ea044c2 100644
--- a/gm/drawminibitmaprect.cpp
+++ b/gm/drawminibitmaprect.cpp
@@ -36,7 +36,7 @@
 
     const SkPoint     pt = { wScalar / 2, hScalar / 2 };
 
-    const SkScalar    radius = 4 * SkMaxScalar(wScalar, hScalar);
+    const SkScalar    radius = 4 * std::max(wScalar, hScalar);
 
     constexpr SkColor     colors[] = { SK_ColorRED, SK_ColorYELLOW,
                                           SK_ColorGREEN, SK_ColorMAGENTA,
diff --git a/gm/hairlines.cpp b/gm/hairlines.cpp
index ed4f918..74d270f 100644
--- a/gm/hairlines.cpp
+++ b/gm/hairlines.cpp
@@ -207,7 +207,7 @@
                         canvas->drawPath(fPaths[p], paint);
                         canvas->restore();
 
-                        maxH = SkMaxScalar(maxH, bounds.height());
+                        maxH = std::max(maxH, bounds.height());
 
                         SkScalar dx = bounds.width() + SkIntToScalar(kMargin);
                         x += dx;
diff --git a/gm/imagefiltersclipped.cpp b/gm/imagefiltersclipped.cpp
index 6a3101a..df48c00 100644
--- a/gm/imagefiltersclipped.cpp
+++ b/gm/imagefiltersclipped.cpp
@@ -38,7 +38,7 @@
 static sk_sp<SkImage> make_gradient_circle(int width, int height) {
     SkScalar x = SkIntToScalar(width / 2);
     SkScalar y = SkIntToScalar(height / 2);
-    SkScalar radius = SkMinScalar(x, y) * 0.8f;
+    SkScalar radius = std::min(x, y) * 0.8f;
     auto surface(SkSurface::MakeRasterN32Premul(width, height));
     SkCanvas* canvas = surface->getCanvas();
     canvas->clear(0x00000000);
diff --git a/gm/imagefilterscropexpand.cpp b/gm/imagefilterscropexpand.cpp
index 763ab57..18cddb6 100644
--- a/gm/imagefilterscropexpand.cpp
+++ b/gm/imagefilterscropexpand.cpp
@@ -130,7 +130,7 @@
     sk_sp<SkImage> make_gradient_circle(int width, int height) {
         SkScalar x = SkIntToScalar(width / 2);
         SkScalar y = SkIntToScalar(height / 2);
-        SkScalar radius = SkMinScalar(x, y) * 0.8f;
+        SkScalar radius = std::min(x, y) * 0.8f;
         auto surface(SkSurface::MakeRasterN32Premul(width, height));
         SkCanvas* canvas = surface->getCanvas();
         canvas->clear(0x00000000);
diff --git a/gm/imagefiltersscaled.cpp b/gm/imagefiltersscaled.cpp
index 10da56b..df8dc1f 100644
--- a/gm/imagefiltersscaled.cpp
+++ b/gm/imagefiltersscaled.cpp
@@ -37,7 +37,7 @@
 static sk_sp<SkImage> make_gradient_circle(int width, int height) {
     SkScalar x = SkIntToScalar(width / 2);
     SkScalar y = SkIntToScalar(height / 2);
-    SkScalar radius = SkMinScalar(x, y) * 4 / 5;
+    SkScalar radius = std::min(x, y) * 4 / 5;
     sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(width, height));
     SkCanvas* canvas = surface->getCanvas();
     canvas->clear(0x00000000);
diff --git a/gm/imagefilterstransformed.cpp b/gm/imagefilterstransformed.cpp
index 5f36da2..298dde6 100644
--- a/gm/imagefilterstransformed.cpp
+++ b/gm/imagefilterstransformed.cpp
@@ -38,7 +38,7 @@
 static sk_sp<SkImage> make_gradient_circle(int width, int height) {
     SkScalar x = SkIntToScalar(width / 2);
     SkScalar y = SkIntToScalar(height / 2);
-    SkScalar radius = SkMinScalar(x, y) * 0.8f;
+    SkScalar radius = std::min(x, y) * 0.8f;
 
     auto surface(SkSurface::MakeRasterN32Premul(width, height));
     SkCanvas* canvas = surface->getCanvas();
diff --git a/include/core/SkRect.h b/include/core/SkRect.h
index f48ea8b..bee0df5 100644
--- a/include/core/SkRect.h
+++ b/include/core/SkRect.h
@@ -13,6 +13,7 @@
 #include "include/private/SkSafe32.h"
 #include "include/private/SkTFitsIn.h"
 
+#include <algorithm>
 #include <utility>
 
 struct SkRect;
@@ -899,10 +900,10 @@
         @param p1  corner to include
     */
     void set(const SkPoint& p0, const SkPoint& p1) {
-        fLeft =   SkMinScalar(p0.fX, p1.fX);
-        fRight =  SkMaxScalar(p0.fX, p1.fX);
-        fTop =    SkMinScalar(p0.fY, p1.fY);
-        fBottom = SkMaxScalar(p0.fY, p1.fY);
+        fLeft =   std::min(p0.fX, p1.fX);
+        fRight =  std::max(p0.fX, p1.fX);
+        fTop =    std::min(p0.fY, p1.fY);
+        fBottom = std::max(p0.fY, p1.fY);
     }
 
     /** Sets SkRect to (x, y, x + width, y + height).
@@ -1088,10 +1089,10 @@
 private:
     static bool Intersects(SkScalar al, SkScalar at, SkScalar ar, SkScalar ab,
                            SkScalar bl, SkScalar bt, SkScalar br, SkScalar bb) {
-        SkScalar L = SkMaxScalar(al, bl);
-        SkScalar R = SkMinScalar(ar, br);
-        SkScalar T = SkMaxScalar(at, bt);
-        SkScalar B = SkMinScalar(ab, bb);
+        SkScalar L = std::max(al, bl);
+        SkScalar R = std::min(ar, br);
+        SkScalar T = std::max(at, bt);
+        SkScalar B = std::min(ab, bb);
         return L < R && T < B;
     }
 
@@ -1157,10 +1158,10 @@
         @param r  expansion SkRect
     */
     void joinPossiblyEmptyRect(const SkRect& r) {
-        fLeft   = SkMinScalar(fLeft, r.left());
-        fTop    = SkMinScalar(fTop, r.top());
-        fRight  = SkMaxScalar(fRight, r.right());
-        fBottom = SkMaxScalar(fBottom, r.bottom());
+        fLeft   = std::min(fLeft, r.left());
+        fTop    = std::min(fTop, r.top());
+        fRight  = std::max(fRight, r.right());
+        fBottom = std::max(fBottom, r.bottom());
     }
 
     /** Returns true if: fLeft <= x < fRight && fTop <= y < fBottom.
@@ -1301,8 +1302,8 @@
         @return  sorted SkRect
     */
     SkRect makeSorted() const {
-        return MakeLTRB(SkMinScalar(fLeft, fRight), SkMinScalar(fTop, fBottom),
-                        SkMaxScalar(fLeft, fRight), SkMaxScalar(fTop, fBottom));
+        return MakeLTRB(std::min(fLeft, fRight), std::min(fTop, fBottom),
+                        std::max(fLeft, fRight), std::max(fTop, fBottom));
     }
 
     /** Returns pointer to first scalar in SkRect, to treat it as an array with four
diff --git a/include/core/SkScalar.h b/include/core/SkScalar.h
index 64fea69..789b17b 100644
--- a/include/core/SkScalar.h
+++ b/include/core/SkScalar.h
@@ -122,9 +122,6 @@
 #define SkDegreesToRadians(degrees) ((degrees) * (SK_ScalarPI / 180))
 #define SkRadiansToDegrees(radians) ((radians) * (180 / SK_ScalarPI))
 
-static inline SkScalar SkMaxScalar(SkScalar a, SkScalar b) { return a > b ? a : b; }
-static inline SkScalar SkMinScalar(SkScalar a, SkScalar b) { return a < b ? a : b; }
-
 static inline bool SkScalarIsInt(SkScalar x) {
     return x == SkScalarFloorToScalar(x);
 }
diff --git a/modules/skparagraph/src/OneLineShaper.cpp b/modules/skparagraph/src/OneLineShaper.cpp
index 3230d591..22b7c72 100644
--- a/modules/skparagraph/src/OneLineShaper.cpp
+++ b/modules/skparagraph/src/OneLineShaper.cpp
@@ -218,7 +218,7 @@
 
         // Carve out the line text out of the entire run text
         fAdvance.fX += runAdvance.fX;
-        fAdvance.fY = SkMaxScalar(fAdvance.fY, runAdvance.fY);
+        fAdvance.fY = std::max(fAdvance.fY, runAdvance.fY);
     }
 
     advanceX = fAdvance.fX;
diff --git a/modules/skparagraph/src/TextWrapper.cpp b/modules/skparagraph/src/TextWrapper.cpp
index b0cd2ee..c2891a6 100644
--- a/modules/skparagraph/src/TextWrapper.cpp
+++ b/modules/skparagraph/src/TextWrapper.cpp
@@ -255,7 +255,7 @@
                 needEllipsis && !fHardLineBreak);
 
         softLineMaxIntrinsicWidth += widthWithSpaces;
-        fMaxIntrinsicWidth = SkMaxScalar(fMaxIntrinsicWidth, softLineMaxIntrinsicWidth);
+        fMaxIntrinsicWidth = std::max(fMaxIntrinsicWidth, softLineMaxIntrinsicWidth);
         if (fHardLineBreak) {
             softLineMaxIntrinsicWidth = 0;
         }
@@ -265,7 +265,7 @@
             fEndLine.clean();
         }
         fEndLine.startFrom(startLine, pos);
-        parent->fMaxWidthWithTrailingSpaces = SkMaxScalar(parent->fMaxWidthWithTrailingSpaces, widthWithSpaces);
+        parent->fMaxWidthWithTrailingSpaces = std::max(parent->fMaxWidthWithTrailingSpaces, widthWithSpaces);
 
         if (hasEllipsis && unlimitedLines) {
             // There is one case when we need an ellipsis on a separate line
diff --git a/samplecode/Sample.cpp b/samplecode/Sample.cpp
index 887069a..d3821f1 100644
--- a/samplecode/Sample.cpp
+++ b/samplecode/Sample.cpp
@@ -18,8 +18,8 @@
 //////////////////////////////////////////////////////////////////////////////
 
 void Sample::setSize(SkScalar width, SkScalar height) {
-    width = SkMaxScalar(0, width);
-    height = SkMaxScalar(0, height);
+    width = std::max(0.0f, width);
+    height = std::max(0.0f, height);
 
     if (fWidth != width || fHeight != height)
     {
diff --git a/samplecode/SampleDegenerateQuads.cpp b/samplecode/SampleDegenerateQuads.cpp
index 3d48cec..d29c5d5 100644
--- a/samplecode/SampleDegenerateQuads.cpp
+++ b/samplecode/SampleDegenerateQuads.cpp
@@ -220,7 +220,7 @@
                 SkScalar t = SkScalarPin(point.fY - geomDomain.fTop, 0.f, 1.f);
                 SkScalar r = SkScalarPin(geomDomain.fRight - point.fX, 0.f, 1.f);
                 SkScalar b = SkScalarPin(geomDomain.fBottom - point.fY, 0.f, 1.f);
-                coverage = SkMinScalar(coverage, l * t * r * b);
+                coverage = std::min(coverage, l * t * r * b);
             }
             return coverage;
         }
@@ -474,8 +474,8 @@
     void drag(SkPoint* point) {
         SkPoint delta = fCurr - fPrev;
         *point += SkPoint::Make(delta.x() / kViewScale, delta.y() / kViewScale);
-        point->fX = SkMinScalar(fOuterRect.fRight, SkMaxScalar(point->fX, fOuterRect.fLeft));
-        point->fY = SkMinScalar(fOuterRect.fBottom, SkMaxScalar(point->fY, fOuterRect.fTop));
+        point->fX = std::min(fOuterRect.fRight, std::max(point->fX, fOuterRect.fLeft));
+        point->fY = std::min(fOuterRect.fBottom, std::max(point->fY, fOuterRect.fTop));
     }
 };
 
diff --git a/samplecode/SampleImageFilterDAG.cpp b/samplecode/SampleImageFilterDAG.cpp
index 41340b6..915777c 100644
--- a/samplecode/SampleImageFilterDAG.cpp
+++ b/samplecode/SampleImageFilterDAG.cpp
@@ -448,7 +448,7 @@
         y = draw_dag(canvas, nodeSurface, node.fInputNodes[i]);
         canvas->restore();
     }
-    return SkMaxScalar(y, nodeResults->height() + textHeight + kPad);
+    return std::max(y, nodeResults->height() + textHeight + kPad);
 }
 
 static void draw_dag(SkCanvas* canvas, sk_sp<SkImageFilter> filter,
diff --git a/samplecode/SampleStringArt.cpp b/samplecode/SampleStringArt.cpp
index bda466c..2447ccb 100644
--- a/samplecode/SampleStringArt.cpp
+++ b/samplecode/SampleStringArt.cpp
@@ -32,7 +32,7 @@
         SkPath path;
         path.moveTo(center);
 
-        while (length < (SkScalarHalf(SkMinScalar(this->width(), this->height())) - 10.f))
+        while (length < (SkScalarHalf(std::min(this->width(), this->height())) - 10.f))
         {
             SkPoint rp = SkPoint::Make(length*SkScalarCos(step) + center.fX,
                                        length*SkScalarSin(step) + center.fY);
diff --git a/samplecode/SampleThinAA.cpp b/samplecode/SampleThinAA.cpp
index 92aa202..8067827 100644
--- a/samplecode/SampleThinAA.cpp
+++ b/samplecode/SampleThinAA.cpp
@@ -403,8 +403,8 @@
                 case 'u': fAngle = 0.f; return true;
                 case 'y': fAngle = 90.f; return true;
                 case ' ': fAngle = SkScalarMod(fAngle + 15.f, 360.f); return true;
-                case '-': fStrokeWidth = SkMaxScalar(0.1f, fStrokeWidth - 0.05f); return true;
-                case '=': fStrokeWidth = SkMinScalar(1.f, fStrokeWidth + 0.05f); return true;
+                case '-': fStrokeWidth = std::max(0.1f, fStrokeWidth - 0.05f); return true;
+                case '=': fStrokeWidth = std::min(1.f, fStrokeWidth + 0.05f); return true;
             }
             return false;
     }
diff --git a/src/core/SkBlurMF.cpp b/src/core/SkBlurMF.cpp
index e02f823..a5c7acb 100644
--- a/src/core/SkBlurMF.cpp
+++ b/src/core/SkBlurMF.cpp
@@ -104,7 +104,7 @@
 
     SkScalar computeXformedSigma(const SkMatrix& ctm) const {
         SkScalar xformedSigma = this->ignoreXform() ? fSigma : ctm.mapRadius(fSigma);
-        return SkMinScalar(xformedSigma, kMAX_BLUR_SIGMA);
+        return std::min(xformedSigma, kMAX_BLUR_SIGMA);
     }
 
     friend class SkBlurMaskFilter;
diff --git a/src/core/SkContourMeasure.cpp b/src/core/SkContourMeasure.cpp
index c26667a..308cfcc 100644
--- a/src/core/SkContourMeasure.cpp
+++ b/src/core/SkContourMeasure.cpp
@@ -141,7 +141,7 @@
     SkScalar dy = SkScalarHalf(pts[1].fY) -
                         SkScalarHalf(SkScalarHalf(pts[0].fY + pts[2].fY));
 
-    SkScalar dist = SkMaxScalar(SkScalarAbs(dx), SkScalarAbs(dy));
+    SkScalar dist = std::max(SkScalarAbs(dx), SkScalarAbs(dy));
     return dist > tolerance;
 }
 
@@ -150,13 +150,13 @@
     SkPoint midEnds = firstPt + lastPt;
     midEnds *= 0.5f;
     SkVector dxy = midTPt - midEnds;
-    SkScalar dist = SkMaxScalar(SkScalarAbs(dxy.fX), SkScalarAbs(dxy.fY));
+    SkScalar dist = std::max(SkScalarAbs(dxy.fX), SkScalarAbs(dxy.fY));
     return dist > tolerance;
 }
 
 static bool cheap_dist_exceeds_limit(const SkPoint& pt, SkScalar x, SkScalar y,
                                      SkScalar tolerance) {
-    SkScalar dist = SkMaxScalar(SkScalarAbs(x - pt.fX), SkScalarAbs(y - pt.fY));
+    SkScalar dist = std::max(SkScalarAbs(x - pt.fX), SkScalarAbs(y - pt.fY));
     // just made up the 1/2
     return dist > tolerance;
 }
diff --git a/src/core/SkMatrix.cpp b/src/core/SkMatrix.cpp
index 535c6b5..3b50be7 100644
--- a/src/core/SkMatrix.cpp
+++ b/src/core/SkMatrix.cpp
@@ -1456,10 +1456,10 @@
     }
     if (!(typeMask & SkMatrix::kAffine_Mask)) {
         if (kMin_MinMaxOrBoth == MIN_MAX_OR_BOTH) {
-             results[0] = SkMinScalar(SkScalarAbs(m[SkMatrix::kMScaleX]),
+             results[0] = std::min(SkScalarAbs(m[SkMatrix::kMScaleX]),
                                       SkScalarAbs(m[SkMatrix::kMScaleY]));
         } else if (kMax_MinMaxOrBoth == MIN_MAX_OR_BOTH) {
-             results[0] = SkMaxScalar(SkScalarAbs(m[SkMatrix::kMScaleX]),
+             results[0] = std::max(SkScalarAbs(m[SkMatrix::kMScaleX]),
                                       SkScalarAbs(m[SkMatrix::kMScaleY]));
         } else {
             results[0] = SkScalarAbs(m[SkMatrix::kMScaleX]);
@@ -1489,9 +1489,9 @@
     // if upper left 2x2 is orthogonal save some math
     if (bSqd <= SK_ScalarNearlyZero*SK_ScalarNearlyZero) {
         if (kMin_MinMaxOrBoth == MIN_MAX_OR_BOTH) {
-            results[0] = SkMinScalar(a, c);
+            results[0] = std::min(a, c);
         } else if (kMax_MinMaxOrBoth == MIN_MAX_OR_BOTH) {
-            results[0] = SkMaxScalar(a, c);
+            results[0] = std::max(a, c);
         } else {
             results[0] = a;
             results[1] = c;
diff --git a/src/core/SkPath.cpp b/src/core/SkPath.cpp
index c17e056..bc19407 100644
--- a/src/core/SkPath.cpp
+++ b/src/core/SkPath.cpp
@@ -53,10 +53,10 @@
  *  our promise. Hence we have a custom joiner that doesn't look at emptiness
  */
 static void joinNoEmptyChecks(SkRect* dst, const SkRect& src) {
-    dst->fLeft = SkMinScalar(dst->fLeft, src.fLeft);
-    dst->fTop = SkMinScalar(dst->fTop, src.fTop);
-    dst->fRight = SkMaxScalar(dst->fRight, src.fRight);
-    dst->fBottom = SkMaxScalar(dst->fBottom, src.fBottom);
+    dst->fLeft = std::min(dst->fLeft, src.fLeft);
+    dst->fTop = std::min(dst->fTop, src.fTop);
+    dst->fRight = std::max(dst->fRight, src.fRight);
+    dst->fBottom = std::max(dst->fBottom, src.fBottom);
 }
 
 static bool is_degenerate(const SkPath& path) {
@@ -2529,8 +2529,8 @@
     SkScalar min, max;
     min = max = pts[0].fX;
     for (size_t i = 1; i < N; ++i) {
-        min = SkMinScalar(min, pts[i].fX);
-        max = SkMaxScalar(max, pts[i].fX);
+        min = std::min(min, pts[i].fX);
+        max = std::max(max, pts[i].fX);
     }
     *minPtr = min;
     *maxPtr = max;
diff --git a/src/core/SkRRect.cpp b/src/core/SkRRect.cpp
index 0f05193..c429e5c 100644
--- a/src/core/SkRRect.cpp
+++ b/src/core/SkRRect.cpp
@@ -27,7 +27,7 @@
 
     if (fRect.width() < xRad+xRad || fRect.height() < yRad+yRad) {
         // At most one of these two divides will be by zero, and neither numerator is zero.
-        SkScalar scale = SkMinScalar(sk_ieee_float_divide(fRect. width(), xRad + xRad),
+        SkScalar scale = std::min(sk_ieee_float_divide(fRect. width(), xRad + xRad),
                                      sk_ieee_float_divide(fRect.height(), yRad + yRad));
         SkASSERT(scale < SK_Scalar1);
         xRad *= scale;
@@ -64,17 +64,17 @@
         return;
     }
 
-    leftRad = SkMaxScalar(leftRad, 0);
-    topRad = SkMaxScalar(topRad, 0);
-    rightRad = SkMaxScalar(rightRad, 0);
-    bottomRad = SkMaxScalar(bottomRad, 0);
+    leftRad = std::max(leftRad, 0.0f);
+    topRad = std::max(topRad, 0.0f);
+    rightRad = std::max(rightRad, 0.0f);
+    bottomRad = std::max(bottomRad, 0.0f);
 
     SkScalar scale = SK_Scalar1;
     if (leftRad + rightRad > fRect.width()) {
         scale = fRect.width() / (leftRad + rightRad);
     }
     if (topRad + bottomRad > fRect.height()) {
-        scale = SkMinScalar(scale, fRect.height() / (topRad + bottomRad));
+        scale = std::min(scale, fRect.height() / (topRad + bottomRad));
     }
 
     if (scale < SK_Scalar1) {
diff --git a/src/core/SkRecordDraw.cpp b/src/core/SkRecordDraw.cpp
index d3b922b..080a854 100644
--- a/src/core/SkRecordDraw.cpp
+++ b/src/core/SkRecordDraw.cpp
@@ -404,7 +404,7 @@
         dst.setBounds(op.pts, op.count);
 
         // Pad the bounding box a little to make sure hairline points' bounds aren't empty.
-        SkScalar stroke = SkMaxScalar(op.paint.getStrokeWidth(), 0.01f);
+        SkScalar stroke = std::max(op.paint.getStrokeWidth(), 0.01f);
         dst.outset(stroke/2, stroke/2);
 
         return this->adjustAndMap(dst, &op.paint);
diff --git a/src/core/SkRect.cpp b/src/core/SkRect.cpp
index 37f054a..c54e661 100644
--- a/src/core/SkRect.cpp
+++ b/src/core/SkRect.cpp
@@ -100,10 +100,10 @@
 }
 
 #define CHECK_INTERSECT(al, at, ar, ab, bl, bt, br, bb) \
-    SkScalar L = SkMaxScalar(al, bl);                   \
-    SkScalar R = SkMinScalar(ar, br);                   \
-    SkScalar T = SkMaxScalar(at, bt);                   \
-    SkScalar B = SkMinScalar(ab, bb);                   \
+    SkScalar L = std::max(al, bl);                   \
+    SkScalar R = std::min(ar, br);                   \
+    SkScalar T = std::max(at, bt);                   \
+    SkScalar B = std::min(ab, bb);                   \
     do { if (!(L < R && T < B)) return false; } while (0)
     // do the !(opposite) check so we return false if either arg is NaN
 
@@ -127,10 +127,10 @@
     if (this->isEmpty()) {
         *this = r;
     } else {
-        fLeft   = SkMinScalar(fLeft, r.fLeft);
-        fTop    = SkMinScalar(fTop, r.fTop);
-        fRight  = SkMaxScalar(fRight, r.fRight);
-        fBottom = SkMaxScalar(fBottom, r.fBottom);
+        fLeft   = std::min(fLeft, r.fLeft);
+        fTop    = std::min(fTop, r.fTop);
+        fRight  = std::max(fRight, r.fRight);
+        fBottom = std::max(fBottom, r.fBottom);
     }
 }
 
diff --git a/src/core/SkRectPriv.h b/src/core/SkRectPriv.h
index e812f5e..4281cbd 100644
--- a/src/core/SkRectPriv.h
+++ b/src/core/SkRectPriv.h
@@ -41,10 +41,10 @@
     }
 
     static void GrowToInclude(SkRect* r, const SkPoint& pt) {
-        r->fLeft  =  SkMinScalar(pt.fX, r->fLeft);
-        r->fRight =  SkMaxScalar(pt.fX, r->fRight);
-        r->fTop    = SkMinScalar(pt.fY, r->fTop);
-        r->fBottom = SkMaxScalar(pt.fY, r->fBottom);
+        r->fLeft  =  std::min(pt.fX, r->fLeft);
+        r->fRight =  std::max(pt.fX, r->fRight);
+        r->fTop    = std::min(pt.fY, r->fTop);
+        r->fBottom = std::max(pt.fY, r->fBottom);
     }
 
     // Conservative check if r can be expressed in fixed-point.
diff --git a/src/core/SkStrikeSpec.cpp b/src/core/SkStrikeSpec.cpp
index 5b10bae..4716196 100644
--- a/src/core/SkStrikeSpec.cpp
+++ b/src/core/SkStrikeSpec.cpp
@@ -147,7 +147,7 @@
     textMatrix.postConcat(viewMatrix);
 
     // we have a self-imposed maximum, just for memory-usage sanity
-    SkScalar limit = SkMinScalar(SkGraphics::GetFontCachePointSizeLimit(), 1024);
+    SkScalar limit = std::min(SkGraphics::GetFontCachePointSizeLimit(), 1024);
     SkScalar maxSizeSquared = limit * limit;
 
     auto distance = [&textMatrix](int XIndex, int YIndex) {
diff --git a/src/core/SkStroke.cpp b/src/core/SkStroke.cpp
index 1c32900..aac6ee2 100644
--- a/src/core/SkStroke.cpp
+++ b/src/core/SkStroke.cpp
@@ -1571,7 +1571,7 @@
             break;
     }
 
-    if (fWidth < SkMinScalar(rw, rh) && !fDoFill) {
+    if (fWidth < std::min(rw, rh) && !fDoFill) {
         r = rect;
         r.inset(radius, radius);
         dst->addRect(r, reverse_direction(dir));
diff --git a/src/core/SkTextBlob.cpp b/src/core/SkTextBlob.cpp
index 4fe0db7..609f076 100644
--- a/src/core/SkTextBlob.cpp
+++ b/src/core/SkTextBlob.cpp
@@ -322,8 +322,8 @@
         SkScalar maxX = *glyphPos;
         for (unsigned i = 1; i < run.glyphCount(); ++i) {
             SkScalar x = glyphPos[i];
-            minX = SkMinScalar(x, minX);
-            maxX = SkMaxScalar(x, maxX);
+            minX = std::min(x, minX);
+            maxX = std::max(x, maxX);
         }
 
         bounds.setLTRB(minX, 0, maxX, 0);
diff --git a/src/effects/SkDashPathEffect.cpp b/src/effects/SkDashPathEffect.cpp
index 913d851..d392dc2 100644
--- a/src/effects/SkDashPathEffect.cpp
+++ b/src/effects/SkDashPathEffect.cpp
@@ -228,7 +228,7 @@
 
     if (results) {
         results->fFlags = 0;
-        SkScalar clampedInitialDashLength = SkMinScalar(length, fInitialDashLength);
+        SkScalar clampedInitialDashLength = std::min(length, fInitialDashLength);
 
         if (SkPaint::kRound_Cap == rec.getCap()) {
             results->fFlags |= PointData::kCircles_PointFlag;
diff --git a/src/effects/imagefilters/SkBlurImageFilter.cpp b/src/effects/imagefilters/SkBlurImageFilter.cpp
index 572ab13..80f50b7 100644
--- a/src/effects/imagefilters/SkBlurImageFilter.cpp
+++ b/src/effects/imagefilters/SkBlurImageFilter.cpp
@@ -555,8 +555,8 @@
 static SkVector map_sigma(const SkSize& localSigma, const SkMatrix& ctm) {
     SkVector sigma = SkVector::Make(localSigma.width(), localSigma.height());
     ctm.mapVectors(&sigma, 1);
-    sigma.fX = SkMinScalar(SkScalarAbs(sigma.fX), MAX_SIGMA);
-    sigma.fY = SkMinScalar(SkScalarAbs(sigma.fY), MAX_SIGMA);
+    sigma.fX = std::min(SkScalarAbs(sigma.fX), MAX_SIGMA);
+    sigma.fY = std::min(SkScalarAbs(sigma.fY), MAX_SIGMA);
     return sigma;
 }
 
diff --git a/src/effects/imagefilters/SkMagnifierImageFilter.cpp b/src/effects/imagefilters/SkMagnifierImageFilter.cpp
index c06738d..a96879d 100644
--- a/src/effects/imagefilters/SkMagnifierImageFilter.cpp
+++ b/src/effects/imagefilters/SkMagnifierImageFilter.cpp
@@ -197,12 +197,12 @@
 
                 SkScalar dist = SkScalarSqrt(SkScalarSquare(x_dist) +
                                              SkScalarSquare(y_dist));
-                dist = SkMaxScalar(kScalar2 - dist, 0);
-                weight = SkMinScalar(SkScalarSquare(dist), SK_Scalar1);
+                dist = std::max(kScalar2 - dist, 0.0f);
+                weight = std::min(SkScalarSquare(dist), SK_Scalar1);
             } else {
-                SkScalar sqDist = SkMinScalar(SkScalarSquare(x_dist),
+                SkScalar sqDist = std::min(SkScalarSquare(x_dist),
                                               SkScalarSquare(y_dist));
-                weight = SkMinScalar(sqDist, SK_Scalar1);
+                weight = std::min(sqDist, SK_Scalar1);
             }
 
             SkScalar x_interp = weight * (fSrcRect.x() + x * invXZoom) + (1 - weight) * x;
diff --git a/src/gpu/geometry/GrPathUtils.cpp b/src/gpu/geometry/GrPathUtils.cpp
index 4d34d08..f4b8081 100644
--- a/src/gpu/geometry/GrPathUtils.cpp
+++ b/src/gpu/geometry/GrPathUtils.cpp
@@ -28,7 +28,7 @@
             mat.setTranslate((i % 2) ? pathBounds.fLeft : pathBounds.fRight,
                              (i < 2) ? pathBounds.fTop : pathBounds.fBottom);
             mat.postConcat(viewM);
-            stretch = SkMaxScalar(stretch, mat.mapRadius(SK_Scalar1));
+            stretch = std::max(stretch, mat.mapRadius(SK_Scalar1));
         }
     }
     SkScalar srcTol = 0;
@@ -342,7 +342,7 @@
     // scale the max absolute value of coeffs to 10
     SkScalar scale = 0.f;
     for (int i = 0; i < 9; ++i) {
-       scale = SkMaxScalar(scale, SkScalarAbs(klm[i]));
+       scale = std::max(scale, SkScalarAbs(klm[i]));
     }
     SkASSERT(scale > 0.f);
     scale = 10.f / scale;
diff --git a/src/gpu/ops/GrAAConvexTessellator.cpp b/src/gpu/ops/GrAAConvexTessellator.cpp
index 86aa54c..417d700 100644
--- a/src/gpu/ops/GrAAConvexTessellator.cpp
+++ b/src/gpu/ops/GrAAConvexTessellator.cpp
@@ -899,8 +899,8 @@
         cur  = tess.point(fPts[next].fIndex) - tess.point(fPts[i].fIndex);
         SkScalar dot = prev.fX * cur.fY - prev.fY * cur.fX;
 
-        minDot = SkMinScalar(minDot, dot);
-        maxDot = SkMaxScalar(maxDot, dot);
+        minDot = std::min(minDot, dot);
+        maxDot = std::max(maxDot, dot);
 
         prev = cur;
     }
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index 858fa72..b59d996 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -374,7 +374,7 @@
             // We always want to at least stroke out half a pixel on each side in device space
             // so 0.5f / perpScale gives us this min in src space
             SkScalar halfSrcStroke =
-                    SkMaxScalar(args.fSrcStrokeWidth * 0.5f, 0.5f / args.fPerpendicularScale);
+                    std::max(args.fSrcStrokeWidth * 0.5f, 0.5f / args.fPerpendicularScale);
 
             SkScalar strokeAdj;
             if (!hasCap) {
@@ -401,8 +401,8 @@
                     SkPoint startPts[2];
                     startPts[0] = draw.fPtsRot[0];
                     startPts[1].fY = startPts[0].fY;
-                    startPts[1].fX = SkMinScalar(startPts[0].fX + draw.fIntervals[0] - draw.fPhase,
-                                                 draw.fPtsRot[1].fX);
+                    startPts[1].fX = std::min(startPts[0].fX + draw.fIntervals[0] - draw.fPhase,
+                                              draw.fPtsRot[1].fX);
                     startRect.setBounds(startPts, 2);
                     startRect.outset(strokeAdj, halfSrcStroke);
 
diff --git a/src/gpu/ops/GrSmallPathRenderer.cpp b/src/gpu/ops/GrSmallPathRenderer.cpp
index 894cc2c..f0d8191 100644
--- a/src/gpu/ops/GrSmallPathRenderer.cpp
+++ b/src/gpu/ops/GrSmallPathRenderer.cpp
@@ -200,8 +200,8 @@
         return CanDrawPath::kNo;
     }
     SkRect bounds = args.fShape->styledBounds();
-    SkScalar minDim = SkMinScalar(bounds.width(), bounds.height());
-    SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
+    SkScalar minDim = std::min(bounds.width(), bounds.height());
+    SkScalar maxDim = std::max(bounds.width(), bounds.height());
     SkScalar minSize = minDim * SkScalarAbs(scaleFactors[0]);
     SkScalar maxSize = maxDim * SkScalarAbs(scaleFactors[1]);
     if (maxDim > kMaxDim || kMinSize > minSize || maxSize > kMaxSize) {
@@ -402,7 +402,7 @@
                 } else {
                     maxScale = SkScalarAbs(args.fViewMatrix.getMaxScale());
                 }
-                SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
+                SkScalar maxDim = std::max(bounds.width(), bounds.height());
                 // We try to create the DF at a 2^n scaled path resolution (1/2, 1, 2, 4, etc.)
                 // In the majority of cases this will yield a crisper rendering.
                 SkScalar mipScale = 1.0f;
diff --git a/src/gpu/ops/GrStrokeRectOp.cpp b/src/gpu/ops/GrStrokeRectOp.cpp
index 6de35ba..81ce82b 100644
--- a/src/gpu/ops/GrStrokeRectOp.cpp
+++ b/src/gpu/ops/GrStrokeRectOp.cpp
@@ -838,7 +838,7 @@
     // Create either a empty rect or a non-empty rect.
     SkRect rect =
             random->nextBool() ? SkRect::MakeXYWH(10, 10, 50, 40) : SkRect::MakeXYWH(6, 7, 0, 0);
-    SkScalar minDim = SkMinScalar(rect.width(), rect.height());
+    SkScalar minDim = std::min(rect.width(), rect.height());
     SkScalar strokeWidth = random->nextUScalar1() * minDim;
 
     SkStrokeRec rec(SkStrokeRec::kFill_InitStyle);
diff --git a/src/gpu/text/GrTextBlob.cpp b/src/gpu/text/GrTextBlob.cpp
index 8ead191..9154f25 100644
--- a/src/gpu/text/GrTextBlob.cpp
+++ b/src/gpu/text/GrTextBlob.cpp
@@ -351,8 +351,8 @@
 void GrTextBlob::setHasBitmap() { fTextType |= kHasBitmap_TextType; }
 void GrTextBlob::setMinAndMaxScale(SkScalar scaledMin, SkScalar scaledMax) {
     // we init fMaxMinScale and fMinMaxScale in the constructor
-    fMaxMinScale = SkMaxScalar(scaledMin, fMaxMinScale);
-    fMinMaxScale = SkMinScalar(scaledMax, fMinMaxScale);
+    fMaxMinScale = std::max(scaledMin, fMaxMinScale);
+    fMinMaxScale = std::min(scaledMax, fMinMaxScale);
 }
 
 size_t GrTextBlob::GetVertexStride(GrMaskFormat maskFormat, bool hasWCoord) {
diff --git a/src/pdf/SkPDFUtils.cpp b/src/pdf/SkPDFUtils.cpp
index 56689ef..306709c 100644
--- a/src/pdf/SkPDFUtils.cpp
+++ b/src/pdf/SkPDFUtils.cpp
@@ -102,7 +102,7 @@
 
 void SkPDFUtils::AppendRectangle(const SkRect& rect, SkWStream* content) {
     // Skia has 0,0 at top left, pdf at bottom left.  Do the right thing.
-    SkScalar bottom = SkMinScalar(rect.fBottom, rect.fTop);
+    SkScalar bottom = std::min(rect.fBottom, rect.fTop);
 
     SkPDFUtils::AppendScalar(rect.fLeft, content);
     content->writeText(" ");
diff --git a/src/shaders/SkPictureShader.cpp b/src/shaders/SkPictureShader.cpp
index fc99118..8b5f017 100644
--- a/src/shaders/SkPictureShader.cpp
+++ b/src/shaders/SkPictureShader.cpp
@@ -221,7 +221,7 @@
     // Scale down the tile size if larger than maxTextureSize for GPU Path or it should fail on create texture
     if (maxTextureSize) {
         if (scaledSize.width() > maxTextureSize || scaledSize.height() > maxTextureSize) {
-            SkScalar downScale = maxTextureSize / SkMaxScalar(scaledSize.width(), scaledSize.height());
+            SkScalar downScale = maxTextureSize / std::max(scaledSize.width(), scaledSize.height());
             scaledSize.set(SkScalarFloorToScalar(scaledSize.width() * downScale),
                            SkScalarFloorToScalar(scaledSize.height() * downScale));
         }
diff --git a/src/utils/SkPatchUtils.cpp b/src/utils/SkPatchUtils.cpp
index 9387331..30e807b 100644
--- a/src/utils/SkPatchUtils.cpp
+++ b/src/utils/SkPatchUtils.cpp
@@ -182,8 +182,8 @@
     }
 
     // Level of detail per axis, based on the larger side between top and bottom or left and right
-    int lodX = static_cast<int>(SkMaxScalar(topLength, bottomLength) / kPartitionSize);
-    int lodY = static_cast<int>(SkMaxScalar(leftLength, rightLength) / kPartitionSize);
+    int lodX = static_cast<int>(std::max(topLength, bottomLength) / kPartitionSize);
+    int lodY = static_cast<int>(std::max(leftLength, rightLength) / kPartitionSize);
 
     return SkISize::Make(SkMax32(8, lodX), SkMax32(8, lodY));
 }
diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp
index e6469bb..bfadf35 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -89,7 +89,7 @@
 void draw_gradient_circle(SkCanvas* canvas, int width, int height) {
     SkScalar x = SkIntToScalar(width / 2);
     SkScalar y = SkIntToScalar(height / 2);
-    SkScalar radius = SkMinScalar(x, y) * 0.8f;
+    SkScalar radius = std::min(x, y) * 0.8f;
     canvas->clear(0x00000000);
     SkColor colors[2];
     colors[0] = SK_ColorWHITE;
diff --git a/tests/PaintTest.cpp b/tests/PaintTest.cpp
index 51dec6f..ba43b4d 100644
--- a/tests/PaintTest.cpp
+++ b/tests/PaintTest.cpp
@@ -93,7 +93,7 @@
     strokeR = stroke.getBounds();
 
     SkRect maxR = fillR;
-    SkScalar miter = SkMaxScalar(SK_Scalar1, paint.getStrokeMiter());
+    SkScalar miter = std::max(SK_Scalar1, paint.getStrokeMiter());
     SkScalar inset = paint.getStrokeJoin() == SkPaint::kMiter_Join ?
                             paint.getStrokeWidth() * miter :
                             paint.getStrokeWidth();
diff --git a/tests/PathTest.cpp b/tests/PathTest.cpp
index 54526fe..b94c45f 100644
--- a/tests/PathTest.cpp
+++ b/tests/PathTest.cpp
@@ -792,8 +792,8 @@
                            int startAngle)
 {
 
-    SkScalar rx = SkMinScalar(rect.width(), xIn);
-    SkScalar ry = SkMinScalar(rect.height(), yIn);
+    SkScalar rx = std::min(rect.width(), xIn);
+    SkScalar ry = std::min(rect.height(), yIn);
 
     SkRect arcRect;
     arcRect.setLTRB(-rx, -ry, rx, ry);
@@ -1817,7 +1817,7 @@
     static const SkRect kBaseRect = SkRect::MakeWH(SkIntToScalar(100), SkIntToScalar(100));
 
     // A circle that bounds kBaseRect (with a significant amount of slop)
-    SkScalar circleR = SkMaxScalar(kBaseRect.width(), kBaseRect.height());
+    SkScalar circleR = std::max(kBaseRect.width(), kBaseRect.height());
     circleR *= 1.75f / 2;
     static const SkPoint kCircleC = {kBaseRect.centerX(), kBaseRect.centerY()};
 
diff --git a/tools/sk_app/CommandSet.cpp b/tools/sk_app/CommandSet.cpp
index ea0eb13..3cafee5 100644
--- a/tools/sk_app/CommandSet.cpp
+++ b/tools/sk_app/CommandSet.cpp
@@ -126,7 +126,7 @@
     // Measure all key strings:
     SkScalar keyWidth = 0;
     for (Command& cmd : fCommands) {
-        keyWidth = SkMaxScalar(keyWidth,
+        keyWidth = std::max(keyWidth,
                                font.measureText(cmd.fKeyName.c_str(), cmd.fKeyName.size(),
                                                 SkTextEncoding::kUTF8));
     }