Remove SkTMin and SkTMax
Use std::min and std::max everywhere.
SkTPin still exists. We can't use std::clamp yet, and even when
we can, it has undefined behavior with NaN. SkTPin is written
to ensure that we return a value in the [lo, hi] range.
Change-Id: I506852a36e024ae405358d5078a872e2c77fa71e
Docs-Preview: https://skia.org/?cl=269357
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/269357
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Reed <reed@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
diff --git a/src/core/SkAnalyticEdge.cpp b/src/core/SkAnalyticEdge.cpp
index 2062512..a15b7f8 100644
--- a/src/core/SkAnalyticEdge.cpp
+++ b/src/core/SkAnalyticEdge.cpp
@@ -383,10 +383,10 @@
SkFDot6 diffY = SkFixedToFDot6(newy - fSnappedY);
slope = diffY ? quick_div(SkFixedToFDot6(newx - fSnappedX), diffY)
: SK_MaxS32;
- newSnappedY = SkTMin<SkFixed>(fQEdge.fQLastY, SkFixedRoundToFixed(newy));
+ newSnappedY = std::min<SkFixed>(fQEdge.fQLastY, SkFixedRoundToFixed(newy));
newSnappedX = newx - SkFixedMul(slope, newy - newSnappedY);
} else {
- newSnappedY = SkTMin(fQEdge.fQLastY, SnapY(newy));
+ newSnappedY = std::min(fQEdge.fQLastY, SnapY(newy));
newSnappedX = newx;
SkFDot6 diffY = SkFixedToFDot6(newSnappedY - fSnappedY);
slope = diffY ? quick_div(SkFixedToFDot6(newx - fSnappedX), diffY)
diff --git a/src/core/SkBlurMF.cpp b/src/core/SkBlurMF.cpp
index a5c7acb..bd7acca 100644
--- a/src/core/SkBlurMF.cpp
+++ b/src/core/SkBlurMF.cpp
@@ -185,10 +185,10 @@
const SkVector& devRadiiLR = devRRect.radii(SkRRect::kLowerRight_Corner);
const SkVector& devRadiiLL = devRRect.radii(SkRRect::kLowerLeft_Corner);
- const int devLeft = SkScalarCeilToInt(SkTMax<SkScalar>(devRadiiUL.fX, devRadiiLL.fX));
- const int devTop = SkScalarCeilToInt(SkTMax<SkScalar>(devRadiiUL.fY, devRadiiUR.fY));
- const int devRight = SkScalarCeilToInt(SkTMax<SkScalar>(devRadiiUR.fX, devRadiiLR.fX));
- const int devBot = SkScalarCeilToInt(SkTMax<SkScalar>(devRadiiLL.fY, devRadiiLR.fY));
+ const int devLeft = SkScalarCeilToInt(std::max<SkScalar>(devRadiiUL.fX, devRadiiLL.fX));
+ const int devTop = SkScalarCeilToInt(std::max<SkScalar>(devRadiiUL.fY, devRadiiUR.fY));
+ const int devRight = SkScalarCeilToInt(std::max<SkScalar>(devRadiiUR.fX, devRadiiLR.fX));
+ const int devBot = SkScalarCeilToInt(std::max<SkScalar>(devRadiiLL.fY, devRadiiLR.fY));
// This is a conservative check for nine-patchability
if (devOrig.fLeft + devLeft + devBlurRadius >= devOrig.fRight - devRight - devBlurRadius ||
@@ -201,10 +201,10 @@
const SkVector& srcRadiiLR = srcRRect.radii(SkRRect::kLowerRight_Corner);
const SkVector& srcRadiiLL = srcRRect.radii(SkRRect::kLowerLeft_Corner);
- const SkScalar srcLeft = SkTMax<SkScalar>(srcRadiiUL.fX, srcRadiiLL.fX);
- const SkScalar srcTop = SkTMax<SkScalar>(srcRadiiUL.fY, srcRadiiUR.fY);
- const SkScalar srcRight = SkTMax<SkScalar>(srcRadiiUR.fX, srcRadiiLR.fX);
- const SkScalar srcBot = SkTMax<SkScalar>(srcRadiiLL.fY, srcRadiiLR.fY);
+ const SkScalar srcLeft = std::max<SkScalar>(srcRadiiUL.fX, srcRadiiLL.fX);
+ const SkScalar srcTop = std::max<SkScalar>(srcRadiiUL.fY, srcRadiiUR.fY);
+ const SkScalar srcRight = std::max<SkScalar>(srcRadiiUR.fX, srcRadiiLR.fX);
+ const SkScalar srcBot = std::max<SkScalar>(srcRadiiLL.fY, srcRadiiLR.fY);
int newRRWidth = 2*devBlurRadius + devLeft + devRight + 1;
int newRRHeight = 2*devBlurRadius + devTop + devBot + 1;
@@ -491,8 +491,8 @@
const SkVector& LR = rrect.radii(SkRRect::kLowerRight_Corner);
const SkVector& LL = rrect.radii(SkRRect::kLowerLeft_Corner);
- const SkScalar leftUnstretched = SkTMax(UL.fX, LL.fX) + SkIntToScalar(2 * margin.fX);
- const SkScalar rightUnstretched = SkTMax(UR.fX, LR.fX) + SkIntToScalar(2 * margin.fX);
+ const SkScalar leftUnstretched = std::max(UL.fX, LL.fX) + SkIntToScalar(2 * margin.fX);
+ const SkScalar rightUnstretched = std::max(UR.fX, LR.fX) + SkIntToScalar(2 * margin.fX);
// Extra space in the middle to ensure an unchanging piece for stretching. Use 3 to cover
// any fractional space on either side plus 1 for the part to stretch.
@@ -504,8 +504,8 @@
return kUnimplemented_FilterReturn;
}
- const SkScalar topUnstretched = SkTMax(UL.fY, UR.fY) + SkIntToScalar(2 * margin.fY);
- const SkScalar bottomUnstretched = SkTMax(LL.fY, LR.fY) + SkIntToScalar(2 * margin.fY);
+ const SkScalar topUnstretched = std::max(UL.fY, UR.fY) + SkIntToScalar(2 * margin.fY);
+ const SkScalar bottomUnstretched = std::max(LL.fY, LR.fY) + SkIntToScalar(2 * margin.fY);
const SkScalar totalSmallHeight = topUnstretched + bottomUnstretched + stretchSize;
if (totalSmallHeight >= rrect.rect().height()) {
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 17bf974..b7a73c2 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -537,7 +537,7 @@
{
inc_canvas();
this->init(sk_make_sp<SkNoPixelsDevice>(
- SkIRect::MakeWH(SkTMax(width, 0), SkTMax(height, 0)), fProps));
+ SkIRect::MakeWH(std::max(width, 0), std::max(height, 0)), fProps));
}
SkCanvas::SkCanvas(const SkIRect& bounds)
diff --git a/src/core/SkCompressedDataUtils.cpp b/src/core/SkCompressedDataUtils.cpp
index 3f7dc58..5583c61 100644
--- a/src/core/SkCompressedDataUtils.cpp
+++ b/src/core/SkCompressedDataUtils.cpp
@@ -268,7 +268,7 @@
static_assert(sizeof(ETC1Block) == sizeof(BC1Block));
totalSize += numBlocks * sizeof(ETC1Block);
- dimensions = {SkTMax(1, dimensions.width()/2), SkTMax(1, dimensions.height()/2)};
+ dimensions = {std::max(1, dimensions.width()/2), std::max(1, dimensions.height()/2)};
}
break;
}
diff --git a/src/core/SkCubicMap.cpp b/src/core/SkCubicMap.cpp
index f5285e0..e6bf714 100644
--- a/src/core/SkCubicMap.cpp
+++ b/src/core/SkCubicMap.cpp
@@ -80,8 +80,8 @@
SkCubicMap::SkCubicMap(SkPoint p1, SkPoint p2) {
// Clamp X values only (we allow Ys outside [0..1]).
- p1.fX = SkTMin(SkTMax(p1.fX, 0.0f), 1.0f);
- p2.fX = SkTMin(SkTMax(p2.fX, 0.0f), 1.0f);
+ p1.fX = std::min(std::max(p1.fX, 0.0f), 1.0f);
+ p2.fX = std::min(std::max(p2.fX, 0.0f), 1.0f);
Sk2s s1 = Sk2s::Load(&p1) * 3;
Sk2s s2 = Sk2s::Load(&p2) * 3;
diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp
index 6bd36c6..609e40c 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -807,7 +807,7 @@
SkScalar sx = SkPoint::Length(matrix[SkMatrix::kMScaleX], matrix[SkMatrix::kMSkewY]);
SkScalar sy = SkPoint::Length(matrix[SkMatrix::kMSkewX], matrix[SkMatrix::kMScaleY]);
if (SkScalarsAreFinite(sx, sy)) {
- SkScalar scale = SkTMax(sx, sy);
+ SkScalar scale = std::max(sx, sy);
if (scale > 0) {
return scale;
}
diff --git a/src/core/SkDrawShadowInfo.cpp b/src/core/SkDrawShadowInfo.cpp
index 8912046..c8a4fe3 100644
--- a/src/core/SkDrawShadowInfo.cpp
+++ b/src/core/SkDrawShadowInfo.cpp
@@ -121,11 +121,11 @@
occluderZ = rec.fZPlaneParams.fZ;
} else {
occluderZ = compute_z(ambientBounds.fLeft, ambientBounds.fTop, rec.fZPlaneParams);
- occluderZ = SkTMax(occluderZ, compute_z(ambientBounds.fRight, ambientBounds.fTop,
+ occluderZ = std::max(occluderZ, compute_z(ambientBounds.fRight, ambientBounds.fTop,
rec.fZPlaneParams));
- occluderZ = SkTMax(occluderZ, compute_z(ambientBounds.fLeft, ambientBounds.fBottom,
+ occluderZ = std::max(occluderZ, compute_z(ambientBounds.fLeft, ambientBounds.fBottom,
rec.fZPlaneParams));
- occluderZ = SkTMax(occluderZ, compute_z(ambientBounds.fRight, ambientBounds.fBottom,
+ occluderZ = std::max(occluderZ, compute_z(ambientBounds.fRight, ambientBounds.fBottom,
rec.fZPlaneParams));
}
SkScalar ambientBlur;
diff --git a/src/core/SkDrawShadowInfo.h b/src/core/SkDrawShadowInfo.h
index c89c8f2..c1e7707 100644
--- a/src/core/SkDrawShadowInfo.h
+++ b/src/core/SkDrawShadowInfo.h
@@ -42,11 +42,11 @@
}
inline SkScalar AmbientBlurRadius(SkScalar height) {
- return SkTMin(height*kAmbientHeightFactor*kAmbientGeomFactor, kMaxAmbientRadius);
+ return std::min(height*kAmbientHeightFactor*kAmbientGeomFactor, kMaxAmbientRadius);
}
inline SkScalar AmbientRecipAlpha(SkScalar height) {
- return 1.0f + SkTMax(height*kAmbientHeightFactor, 0.0f);
+ return 1.0f + std::max(height*kAmbientHeightFactor, 0.0f);
}
inline SkScalar SpotBlurRadius(SkScalar occluderZ, SkScalar lightZ, SkScalar lightRadius) {
diff --git a/src/core/SkFont.cpp b/src/core/SkFont.cpp
index e2e3ef9..b0de674 100644
--- a/src/core/SkFont.cpp
+++ b/src/core/SkFont.cpp
@@ -27,7 +27,7 @@
#define kDefault_Hinting SkPaintDefaults_Hinting
static inline SkScalar valid_size(SkScalar size) {
- return SkTMax<SkScalar>(0, size);
+ return std::max<SkScalar>(0, size);
}
SkFont::SkFont(sk_sp<SkTypeface> face, SkScalar size, SkScalar scaleX, SkScalar skewX)
diff --git a/src/core/SkGlyph.cpp b/src/core/SkGlyph.cpp
index b0c7523..4765faf 100644
--- a/src/core/SkGlyph.cpp
+++ b/src/core/SkGlyph.cpp
@@ -201,8 +201,8 @@
SkScalar left = SK_ScalarMax,
right = SK_ScalarMin;
auto expandGap = [&left, &right](SkScalar v) {
- left = SkTMin(left, v);
- right = SkTMax(right, v);
+ left = std::min(left, v);
+ right = std::max(right, v);
};
// Handle all the different verbs for the path.
@@ -257,9 +257,9 @@
break;
}
case SkPath::kQuad_Verb: {
- SkScalar quadTop = SkTMin(SkTMin(pts[0].fY, pts[1].fY), pts[2].fY);
+ SkScalar quadTop = std::min(std::min(pts[0].fY, pts[1].fY), pts[2].fY);
if (bottomOffset < quadTop) { break; }
- SkScalar quadBottom = SkTMax(SkTMax(pts[0].fY, pts[1].fY), pts[2].fY);
+ SkScalar quadBottom = std::max(std::max(pts[0].fY, pts[1].fY), pts[2].fY);
if (topOffset > quadBottom) { break; }
addQuad(topOffset);
addQuad(bottomOffset);
@@ -272,10 +272,10 @@
}
case SkPath::kCubic_Verb: {
SkScalar quadTop =
- SkTMin(SkTMin(SkTMin(pts[0].fY, pts[1].fY), pts[2].fY), pts[3].fY);
+ std::min(std::min(std::min(pts[0].fY, pts[1].fY), pts[2].fY), pts[3].fY);
if (bottomOffset < quadTop) { break; }
SkScalar quadBottom =
- SkTMax(SkTMax(SkTMax(pts[0].fY, pts[1].fY), pts[2].fY), pts[3].fY);
+ std::max(std::max(std::max(pts[0].fY, pts[1].fY), pts[2].fY), pts[3].fY);
if (topOffset > quadBottom) { break; }
addCubic(topOffset);
addCubic(bottomOffset);
diff --git a/src/core/SkGlyphBuffer.h b/src/core/SkGlyphBuffer.h
index be97703..fe4da38 100644
--- a/src/core/SkGlyphBuffer.h
+++ b/src/core/SkGlyphBuffer.h
@@ -45,7 +45,7 @@
}
void reject(size_t index, int rejectedMaxDimension) {
- fRejectedMaxDimension = SkTMax(fRejectedMaxDimension, rejectedMaxDimension);
+ fRejectedMaxDimension = std::max(fRejectedMaxDimension, rejectedMaxDimension);
this->reject(index);
}
diff --git a/src/core/SkMathPriv.h b/src/core/SkMathPriv.h
index d0ce3b2..23b51bd 100644
--- a/src/core/SkMathPriv.h
+++ b/src/core/SkMathPriv.h
@@ -121,10 +121,6 @@
return (prod + (prod >> 8)) >> 8;
}
-static inline float SkPinToUnitFloat(float x) {
- return SkTMin(SkTMax(x, 0.0f), 1.0f);
-}
-
/**
* Swap byte order of a 4-byte value, e.g. 0xaarrggbb -> 0xbbggrraa.
*/
diff --git a/src/core/SkMipMap.cpp b/src/core/SkMipMap.cpp
index 748b7ea..21cf377 100644
--- a/src/core/SkMipMap.cpp
+++ b/src/core/SkMipMap.cpp
@@ -614,8 +614,8 @@
proc = proc_2_2;
}
}
- width = SkTMax(1, width >> 1);
- height = SkTMax(1, height >> 1);
+ width = std::max(1, width >> 1);
+ height = std::max(1, height >> 1);
rowBytes = SkToU32(SkColorTypeMinRowBytes(ct, width));
// We make the Info w/o any colorspace, since that storage is not under our control, and
@@ -654,7 +654,7 @@
// (or original_width) where i is the mipmap level.
// Continue scaling down until both axes are size 1.
- const int largestAxis = SkTMax(baseWidth, baseHeight);
+ const int largestAxis = std::max(baseWidth, baseHeight);
if (largestAxis < 2) {
// SkMipMap::Build requires a minimum size of 2.
return 0;
@@ -695,8 +695,8 @@
// For example, it contains levels 1-x instead of 0-x.
// This is because the image used to create SkMipMap is the base level.
// So subtract 1 from the mip level to get the index stored by SkMipMap.
- int width = SkTMax(1, baseWidth >> (level + 1));
- int height = SkTMax(1, baseHeight >> (level + 1));
+ int width = std::max(1, baseWidth >> (level + 1));
+ int height = std::max(1, baseHeight >> (level + 1));
return SkISize::Make(width, height);
}
@@ -712,7 +712,7 @@
#ifndef SK_SUPPORT_LEGACY_ANISOTROPIC_MIPMAP_SCALE
// Use the smallest scale to match the GPU impl.
- const SkScalar scale = SkTMin(scaleSize.width(), scaleSize.height());
+ const SkScalar scale = std::min(scaleSize.width(), scaleSize.height());
#else
// Ideally we'd pick the smaller scale, to match Ganesh. But ignoring one of the
// scales can produce some atrocious results, so for now we use the geometric mean.
diff --git a/src/core/SkNormalMapSource.cpp b/src/core/SkNormalMapSource.cpp
index cc08e26..79359a4 100644
--- a/src/core/SkNormalMapSource.cpp
+++ b/src/core/SkNormalMapSource.cpp
@@ -180,7 +180,7 @@
SkPMColor tmpNormalColors[BUFFER_MAX];
do {
- int n = SkTMin(count, BUFFER_MAX);
+ int n = std::min(count, BUFFER_MAX);
fMapContext->shadeSpan(x, y, tmpNormalColors, n);
diff --git a/src/core/SkPath.cpp b/src/core/SkPath.cpp
index 4074d6a..5afe53a 100644
--- a/src/core/SkPath.cpp
+++ b/src/core/SkPath.cpp
@@ -1189,7 +1189,7 @@
SkVector delta = unitPts[1] - unitPts[0];
SkScalar d = delta.fX * delta.fX + delta.fY * delta.fY;
- SkScalar scaleFactorSquared = SkTMax(1 / d - 0.25f, 0.f);
+ SkScalar scaleFactorSquared = std::max(1 / d - 0.25f, 0.f);
SkScalar scaleFactor = SkScalarSqrt(scaleFactorSquared);
if ((arcSweep == SkPathDirection::kCCW) != SkToBool(arcLarge)) { // flipped from the original implementation
@@ -2088,9 +2088,9 @@
if (!SkScalarIsFinite(cross)) {
return kUnknown_DirChange;
}
- SkScalar smallest = SkTMin(fCurrPt.fX, SkTMin(fCurrPt.fY, SkTMin(fLastPt.fX, fLastPt.fY)));
- SkScalar largest = SkTMax(fCurrPt.fX, SkTMax(fCurrPt.fY, SkTMax(fLastPt.fX, fLastPt.fY)));
- largest = SkTMax(largest, -smallest);
+ SkScalar smallest = std::min(fCurrPt.fX, std::min(fCurrPt.fY, std::min(fLastPt.fX, fLastPt.fY)));
+ SkScalar largest = std::max(fCurrPt.fX, std::max(fCurrPt.fY, std::max(fLastPt.fX, fLastPt.fY)));
+ largest = std::max(largest, -smallest);
if (almost_equal(largest, largest + cross)) {
constexpr SkScalar nearlyZeroSqd = SK_ScalarNearlyZero * SK_ScalarNearlyZero;
diff --git a/src/core/SkRRect.cpp b/src/core/SkRRect.cpp
index c429e5c..3527cd1 100644
--- a/src/core/SkRRect.cpp
+++ b/src/core/SkRRect.cpp
@@ -115,7 +115,7 @@
// miss the fact that a scale is required.
static double compute_min_scale(double rad1, double rad2, double limit, double curMin) {
if ((rad1 + rad2) > limit) {
- return SkTMin(curMin, limit / (rad1 + rad2));
+ return std::min(curMin, limit / (rad1 + rad2));
}
return curMin;
}
diff --git a/src/core/SkRWBuffer.cpp b/src/core/SkRWBuffer.cpp
index 462532f..626611f 100644
--- a/src/core/SkRWBuffer.cpp
+++ b/src/core/SkRWBuffer.cpp
@@ -11,6 +11,7 @@
#include "include/private/SkMalloc.h"
#include "include/private/SkTo.h"
+#include <algorithm>
#include <atomic>
#include <new>
@@ -40,7 +41,7 @@
//
size_t append(const void* src, size_t length) {
this->validate();
- size_t amount = SkTMin(this->avail(), length);
+ size_t amount = std::min(this->avail(), length);
memcpy(this->availData(), src, amount);
fUsed += amount;
this->validate();
@@ -59,7 +60,7 @@
private:
static size_t LengthToCapacity(size_t length) {
const size_t minSize = kMinAllocSize - sizeof(SkBufferBlock);
- return SkTMax(length, minSize);
+ return std::max(length, minSize);
}
};
@@ -71,7 +72,7 @@
static size_t LengthToCapacity(size_t length) {
const size_t minSize = kMinAllocSize - sizeof(SkBufferHead);
- return SkTMax(length, minSize);
+ return std::max(length, minSize);
}
static SkBufferHead* Alloc(size_t length) {
@@ -171,7 +172,7 @@
if (!fBlock) {
return 0;
}
- return SkTMin(fBlock->fCapacity, fRemaining);
+ return std::min(fBlock->fCapacity, fRemaining);
}
bool SkROBuffer::Iter::next() {
@@ -290,7 +291,7 @@
for (;;) {
size_t size = fIter.size();
SkASSERT(fLocalOffset <= size);
- size_t avail = SkTMin(size - fLocalOffset, request - bytesRead);
+ size_t avail = std::min(size - fLocalOffset, request - bytesRead);
if (dst) {
memcpy(dst, (const char*)fIter.data() + fLocalOffset, avail);
dst = (char*)dst + avail;
diff --git a/src/core/SkRecordDraw.cpp b/src/core/SkRecordDraw.cpp
index 080a854..e97729c 100644
--- a/src/core/SkRecordDraw.cpp
+++ b/src/core/SkRecordDraw.cpp
@@ -61,7 +61,7 @@
const SkMatrix& initialCTM) {
SkAutoCanvasRestore saveRestore(canvas, true /*save now, restore at exit*/);
- stop = SkTMin(stop, record.count());
+ stop = std::min(stop, record.count());
SkRecords::Draw draw(canvas, drawablePicts, nullptr, drawableCount, &initialCTM);
for (int i = start; i < stop; i++) {
record.visit(i, draw);
diff --git a/src/core/SkRect.cpp b/src/core/SkRect.cpp
index b3cabbe..c1e81a3 100644
--- a/src/core/SkRect.cpp
+++ b/src/core/SkRect.cpp
@@ -85,8 +85,8 @@
bool all_finite = (accum * 0 == 0).allTrue();
if (all_finite) {
- this->setLTRB(SkTMin(min[0], min[2]), SkTMin(min[1], min[3]),
- SkTMax(max[0], max[2]), SkTMax(max[1], max[3]));
+ this->setLTRB(std::min(min[0], min[2]), std::min(min[1], min[3]),
+ std::max(max[0], max[2]), std::max(max[1], max[3]));
} else {
this->setEmpty();
}
diff --git a/src/core/SkResourceCache.cpp b/src/core/SkResourceCache.cpp
index 61197f8..ff39bd6 100644
--- a/src/core/SkResourceCache.cpp
+++ b/src/core/SkResourceCache.cpp
@@ -434,7 +434,7 @@
if (0 == limit) {
limit = fTotalByteLimit;
} else {
- limit = SkTMin(limit, fTotalByteLimit);
+ limit = std::min(limit, fTotalByteLimit);
}
}
return limit;
diff --git a/src/core/SkScan_AAAPath.cpp b/src/core/SkScan_AAAPath.cpp
index 90a89ce..2df03b9 100644
--- a/src/core/SkScan_AAAPath.cpp
+++ b/src/core/SkScan_AAAPath.cpp
@@ -95,7 +95,7 @@
}
static void safely_add_alpha(SkAlpha* alpha, SkAlpha delta) {
- *alpha = SkTMin(0xFF, *alpha + delta);
+ *alpha = std::min(0xFF, *alpha + delta);
}
class AdditiveBlitter : public SkBlitter {
@@ -415,7 +415,7 @@
antialias -= x;
x = 0;
}
- len = SkTMin(len, fWidth - x);
+ len = std::min(len, fWidth - x);
SkASSERT(check(x, len));
if (x < fOffsetX) {
@@ -485,7 +485,7 @@
antialias -= x;
x = 0;
}
- len = SkTMin(len, fWidth - x);
+ len = std::min(len, fWidth - x);
SkASSERT(check(x, len));
if (x < fOffsetX) {
@@ -589,7 +589,7 @@
if (l2 > r2) {
std::swap(l2, r2);
}
- return (SkTMax(l1, l2) + SkTMin(r1, r2)) / 2;
+ return (std::max(l1, l2) + std::min(r1, r2)) / 2;
}
// Here we always send in l < SK_Fixed1, and the first alpha we want to compute is alphas[0]
@@ -1107,7 +1107,7 @@
SkAnalyticEdge* riteE = (SkAnalyticEdge*)leftE->fNext;
SkAnalyticEdge* currE = (SkAnalyticEdge*)riteE->fNext;
- SkFixed y = SkTMax(leftE->fUpperY, riteE->fUpperY);
+ SkFixed y = std::max(leftE->fUpperY, riteE->fUpperY);
for (;;) {
// We have to check fLowerY first because some edges might be alone (e.g., there's only
@@ -1155,9 +1155,9 @@
}
local_bot_fixed = std::min(local_bot_fixed, SkIntToFixed(stop_y));
- SkFixed left = SkTMax(leftBound, leftE->fX);
+ SkFixed left = std::max(leftBound, leftE->fX);
SkFixed dLeft = leftE->fDX;
- SkFixed rite = SkTMin(riteBound, riteE->fX);
+ SkFixed rite = std::min(riteBound, riteE->fX);
SkFixed dRite = riteE->fDX;
if (0 == (dLeft | dRite)) {
int fullLeft = SkFixedCeilToInt(left);
@@ -1326,8 +1326,8 @@
// Smooth jumping to integer y may make the last nextLeft/nextRite out of bound.
// Take them back into the bound here.
// Note that we substract kSnapHalf later so we have to add them to leftBound/riteBound
- SkFixed nextLeft = SkTMax(left + SkFixedMul(dLeft, dY), leftBound + kSnapHalf);
- SkFixed nextRite = SkTMin(rite + SkFixedMul(dRite, dY), riteBound + kSnapHalf);
+ SkFixed nextLeft = std::max(left + SkFixedMul(dLeft, dY), leftBound + kSnapHalf);
+ SkFixed nextRite = std::min(rite + SkFixedMul(dRite, dY), riteBound + kSnapHalf);
SkASSERT((left & kSnapMask) >= leftBound && (rite & kSnapMask) <= riteBound &&
(nextLeft & kSnapMask) >= leftBound && (nextRite & kSnapMask) <= riteBound);
blit_trapezoid_row(blitter,
@@ -1472,10 +1472,10 @@
blit_trapezoid_row(
blitter,
y,
- SkTMax(leftE->fSavedX, leftClip),
- SkTMin(riteE->fSavedX, rightClip),
- SkTMax(lowerLeft, leftClip),
- SkTMin(lowerRite, rightClip),
+ std::max(leftE->fSavedX, leftClip),
+ std::min(riteE->fSavedX, rightClip),
+ std::max(lowerLeft, leftClip),
+ std::min(lowerRite, rightClip),
leftE->fSavedDY,
riteE->fSavedDY,
fullAlpha,
@@ -1557,7 +1557,7 @@
bool skipIntersect) {
prevHead->fX = prevHead->fUpperX = leftClip;
nextTail->fX = nextTail->fUpperX = rightClip;
- SkFixed y = SkTMax(prevHead->fNext->fUpperY, SkIntToFixed(start_y));
+ SkFixed y = std::max(prevHead->fNext->fUpperY, SkIntToFixed(start_y));
SkFixed nextNextY = SK_MaxS32;
{
@@ -1596,7 +1596,7 @@
int w = 0;
bool in_interval = isInverse;
SkFixed prevX = prevHead->fX;
- SkFixed nextY = SkTMin(nextNextY, SkFixedCeilToFixed(y + 1));
+ SkFixed nextY = std::min(nextNextY, SkFixedCeilToFixed(y + 1));
bool isIntegralNextY = (nextY & (SK_Fixed1 - 1)) == 0;
SkAnalyticEdge* currE = prevHead->fNext;
SkAnalyticEdge* leftE = prevHead;
@@ -1699,9 +1699,9 @@
} else {
SkFixed rite = currE->fX;
currE->goY(nextY, yShift);
- SkFixed nextLeft = SkTMax(leftClip, leftE->fX);
- rite = SkTMin(rightClip, rite);
- SkFixed nextRite = SkTMin(rightClip, currE->fX);
+ SkFixed nextLeft = std::max(leftClip, leftE->fX);
+ rite = std::min(rightClip, rite);
+ SkFixed nextRite = std::min(rightClip, currE->fX);
blit_trapezoid_row(
blitter,
y >> 16,
@@ -1718,11 +1718,11 @@
(edges_too_close(prevRite, left, leftE->fX) ||
edges_too_close(currE, currE->fNext, nextY))),
true);
- prevRite = SkFixedCeilToInt(SkTMax(rite, currE->fX));
+ prevRite = SkFixedCeilToInt(std::max(rite, currE->fX));
}
} else {
if (isLeft) {
- left = SkTMax(currE->fX, leftClip);
+ left = std::max(currE->fX, leftClip);
leftDY = currE->fDY;
leftE = currE;
leftEnds = leftE->fLowerY == nextY;
@@ -1810,7 +1810,7 @@
y >> 16,
left,
rightClip,
- SkTMax(leftClip, leftE->fX),
+ std::max(leftClip, leftE->fX),
rightClip,
leftDY,
0,
@@ -1915,8 +1915,8 @@
// Otherwise, the edge drift may access an invalid address inside the mask.
SkIRect ir;
path.getBounds().roundOut(&ir);
- leftBound = SkTMax(leftBound, SkIntToFixed(ir.fLeft));
- rightBound = SkTMin(rightBound, SkIntToFixed(ir.fRight));
+ leftBound = std::max(leftBound, SkIntToFixed(ir.fLeft));
+ rightBound = std::min(rightBound, SkIntToFixed(ir.fRight));
}
if (!path.isInverseFillType() && path.isConvex() && count >= 2) {
diff --git a/src/core/SkScan_AntiPath.cpp b/src/core/SkScan_AntiPath.cpp
index 9b21e4b..2c1128a 100644
--- a/src/core/SkScan_AntiPath.cpp
+++ b/src/core/SkScan_AntiPath.cpp
@@ -658,7 +658,7 @@
// every pixel row/column is significantly greater than zero. Hence
// Aanlytic AA is not likely to produce visible quality improvements,
// and Analytic AA might be slower than supersampling.
- return path.countPoints() < SkTMax(bounds.width(), bounds.height()) / 2 - 10;
+ return path.countPoints() < std::max(bounds.width(), bounds.height()) / 2 - 10;
#else
if (path.countPoints() >= path.getBounds().height()) {
// SAA is faster than AAA in this case even if there are no
diff --git a/src/core/SkScan_Hairline.cpp b/src/core/SkScan_Hairline.cpp
index f9365ce..589bd1c 100644
--- a/src/core/SkScan_Hairline.cpp
+++ b/src/core/SkScan_Hairline.cpp
@@ -310,7 +310,7 @@
static inline SkScalar max_component(const Sk2s& value) {
SkScalar components[2];
value.store(components);
- return SkTMax(components[0], components[1]);
+ return std::max(components[0], components[1]);
}
static inline int compute_cubic_segs(const SkPoint pts[4]) {
diff --git a/src/core/SkStream.cpp b/src/core/SkStream.cpp
index 755414e..bb53e2c 100644
--- a/src/core/SkStream.cpp
+++ b/src/core/SkStream.cpp
@@ -155,8 +155,8 @@
size_t offset, size_t originalOffset)
: fFILE(std::move(file))
, fSize(size)
- , fOffset(SkTMin(offset, fSize))
- , fOriginalOffset(SkTMin(originalOffset, fSize))
+ , fOffset(std::min(offset, fSize))
+ , fOriginalOffset(std::min(originalOffset, fSize))
{ }
SkFILEStream::SkFILEStream(std::shared_ptr<FILE> file, size_t size, size_t offset)
@@ -221,7 +221,7 @@
}
bool SkFILEStream::seek(size_t position) {
- fOffset = SkTMin(SkSafeMath::Add(position, fOriginalOffset), fSize);
+ fOffset = std::min(SkSafeMath::Add(position, fOriginalOffset), fSize);
return true;
}
@@ -237,7 +237,7 @@
} else if (!SkTFitsIn<size_t>(offset)) {
fOffset = fSize;
} else {
- fOffset = SkTMin(SkSafeMath::Add(fOffset, (size_t) offset), fSize);
+ fOffset = std::min(SkSafeMath::Add(fOffset, (size_t) offset), fSize);
}
SkASSERT(fOffset >= fOriginalOffset && fOffset <= fSize);
@@ -524,7 +524,7 @@
if (fTail) {
if (fTail->avail() > 0) {
- size = SkTMin(fTail->avail(), count);
+ size = std::min(fTail->avail(), count);
buffer = fTail->append(buffer, size);
SkASSERT(count >= size);
count -= size;
@@ -536,7 +536,7 @@
fBytesWrittenBeforeTail += fTail->written();
}
- size = SkTMax<size_t>(count, SkDynamicMemoryWStream_MinBlockSize - sizeof(Block));
+ size = std::max<size_t>(count, SkDynamicMemoryWStream_MinBlockSize - sizeof(Block));
size = SkAlign4(size); // ensure we're always a multiple of 4 (see padToAlign4())
Block* block = (Block*)sk_malloc_throw(sizeof(Block) + size);
@@ -752,7 +752,7 @@
size_t bytesLeftToRead = count;
while (fCurrent != nullptr) {
size_t bytesLeftInCurrent = fCurrent->written() - fCurrentOffset;
- size_t bytesFromCurrent = SkTMin(bytesLeftToRead, bytesLeftInCurrent);
+ size_t bytesFromCurrent = std::min(bytesLeftToRead, bytesLeftInCurrent);
if (buffer) {
memcpy(buffer, fCurrent->start() + fCurrentOffset, bytesFromCurrent);
buffer = SkTAddOffset<void>(buffer, bytesFromCurrent);
@@ -777,7 +777,7 @@
size_t peek(void* buff, size_t bytesToPeek) const override {
SkASSERT(buff != nullptr);
- bytesToPeek = SkTMin(bytesToPeek, fSize - fOffset);
+ bytesToPeek = std::min(bytesToPeek, fSize - fOffset);
size_t bytesLeftToPeek = bytesToPeek;
char* buffer = static_cast<char*>(buff);
@@ -785,7 +785,7 @@
size_t currentOffset = fCurrentOffset;
while (bytesLeftToPeek) {
SkASSERT(current);
- size_t bytesFromCurrent = SkTMin(current->written() - currentOffset, bytesLeftToPeek);
+ size_t bytesFromCurrent = std::min(current->written() - currentOffset, bytesLeftToPeek);
memcpy(buffer, current->start() + currentOffset, bytesFromCurrent);
bytesLeftToPeek -= bytesFromCurrent;
buffer += bytesFromCurrent;
diff --git a/src/core/SkStrikeCache.cpp b/src/core/SkStrikeCache.cpp
index f92a98d..f90caa2 100644
--- a/src/core/SkStrikeCache.cpp
+++ b/src/core/SkStrikeCache.cpp
@@ -390,10 +390,10 @@
if (fTotalMemoryUsed > fCacheSizeLimit) {
bytesNeeded = fTotalMemoryUsed - fCacheSizeLimit;
}
- bytesNeeded = SkTMax(bytesNeeded, minBytesNeeded);
+ bytesNeeded = std::max(bytesNeeded, minBytesNeeded);
if (bytesNeeded) {
// no small purges!
- bytesNeeded = SkTMax(bytesNeeded, fTotalMemoryUsed >> 2);
+ bytesNeeded = std::max(bytesNeeded, fTotalMemoryUsed >> 2);
}
int countNeeded = 0;
diff --git a/src/core/SkStroke.cpp b/src/core/SkStroke.cpp
index aac6ee2..ec25e75 100644
--- a/src/core/SkStroke.cpp
+++ b/src/core/SkStroke.cpp
@@ -543,7 +543,7 @@
for (int index = 0; index < 3; ++index) {
for (int inner = index + 1; inner < 4; ++inner) {
SkVector testDiff = cubic[inner] - cubic[index];
- SkScalar testMax = SkTMax(SkScalarAbs(testDiff.fX), SkScalarAbs(testDiff.fY));
+ SkScalar testMax = std::max(SkScalarAbs(testDiff.fX), SkScalarAbs(testDiff.fY));
if (ptMax < testMax) {
outer1 = index;
outer2 = inner;
@@ -580,7 +580,7 @@
for (int index = 0; index < 2; ++index) {
for (int inner = index + 1; inner < 3; ++inner) {
SkVector testDiff = quad[inner] - quad[index];
- SkScalar testMax = SkTMax(SkScalarAbs(testDiff.fX), SkScalarAbs(testDiff.fY));
+ SkScalar testMax = std::max(SkScalarAbs(testDiff.fX), SkScalarAbs(testDiff.fY));
if (ptMax < testMax) {
outer1 = index;
outer2 = inner;
@@ -897,9 +897,9 @@
// are small, a straight line is good enough
SkScalar dist1 = pt_to_line(start, end, quadPts->fTangentEnd);
SkScalar dist2 = pt_to_line(end, start, quadPts->fTangentStart);
- if (SkTMax(dist1, dist2) <= fInvResScaleSquared) {
+ if (std::max(dist1, dist2) <= fInvResScaleSquared) {
return STROKER_RESULT(kDegenerate_ResultType, depth, quadPts,
- "SkTMax(dist1=%g, dist2=%g) <= fInvResScaleSquared", dist1, dist2);
+ "std::max(dist1=%g, dist2=%g) <= fInvResScaleSquared", dist1, dist2);
}
return STROKER_RESULT(kSplit_ResultType, depth, quadPts,
"(numerA=%g >= 0) == (numerB=%g >= 0)", numerA, numerB);
@@ -949,19 +949,19 @@
// Return true if the point is close to the bounds of the quad. This is used as a quick reject.
bool SkPathStroker::ptInQuadBounds(const SkPoint quad[3], const SkPoint& pt) const {
- SkScalar xMin = SkTMin(SkTMin(quad[0].fX, quad[1].fX), quad[2].fX);
+ SkScalar xMin = std::min(std::min(quad[0].fX, quad[1].fX), quad[2].fX);
if (pt.fX + fInvResScale < xMin) {
return false;
}
- SkScalar xMax = SkTMax(SkTMax(quad[0].fX, quad[1].fX), quad[2].fX);
+ SkScalar xMax = std::max(std::max(quad[0].fX, quad[1].fX), quad[2].fX);
if (pt.fX - fInvResScale > xMax) {
return false;
}
- SkScalar yMin = SkTMin(SkTMin(quad[0].fY, quad[1].fY), quad[2].fY);
+ SkScalar yMin = std::min(std::min(quad[0].fY, quad[1].fY), quad[2].fY);
if (pt.fY + fInvResScale < yMin) {
return false;
}
- SkScalar yMax = SkTMax(SkTMax(quad[0].fY, quad[1].fY), quad[2].fY);
+ SkScalar yMax = std::max(std::max(quad[0].fY, quad[1].fY), quad[2].fY);
if (pt.fY - fInvResScale > yMax) {
return false;
}
@@ -1143,7 +1143,7 @@
return false; // just abort if projected quad isn't representable
}
#if QUAD_STROKE_APPROX_EXTENDED_DEBUGGING
- SkDEBUGCODE(gMaxRecursion[fFoundTangents] = SkTMax(gMaxRecursion[fFoundTangents],
+ SkDEBUGCODE(gMaxRecursion[fFoundTangents] = std::max(gMaxRecursion[fFoundTangents],
fRecursionDepth + 1));
#endif
if (++fRecursionDepth > kRecursiveLimits[fFoundTangents]) {
@@ -1183,7 +1183,7 @@
return true;
}
#if QUAD_STROKE_APPROX_EXTENDED_DEBUGGING
- SkDEBUGCODE(gMaxRecursion[kConic_RecursiveLimit] = SkTMax(gMaxRecursion[kConic_RecursiveLimit],
+ SkDEBUGCODE(gMaxRecursion[kConic_RecursiveLimit] = std::max(gMaxRecursion[kConic_RecursiveLimit],
fRecursionDepth + 1));
#endif
if (++fRecursionDepth > kRecursiveLimits[kConic_RecursiveLimit]) {
@@ -1215,7 +1215,7 @@
return true;
}
#if QUAD_STROKE_APPROX_EXTENDED_DEBUGGING
- SkDEBUGCODE(gMaxRecursion[kQuad_RecursiveLimit] = SkTMax(gMaxRecursion[kQuad_RecursiveLimit],
+ SkDEBUGCODE(gMaxRecursion[kQuad_RecursiveLimit] = std::max(gMaxRecursion[kQuad_RecursiveLimit],
fRecursionDepth + 1));
#endif
if (++fRecursionDepth > kRecursiveLimits[kQuad_RecursiveLimit]) {
diff --git a/src/core/SkStrokeRec.cpp b/src/core/SkStrokeRec.cpp
index a668dab..bc42941 100644
--- a/src/core/SkStrokeRec.cpp
+++ b/src/core/SkStrokeRec.cpp
@@ -160,10 +160,10 @@
// since we're stroked, outset the rect by the radius (and join type, caps)
SkScalar multiplier = SK_Scalar1;
if (SkPaint::kMiter_Join == join) {
- multiplier = SkTMax(multiplier, miterLimit);
+ multiplier = std::max(multiplier, miterLimit);
}
if (SkPaint::kSquare_Cap == cap) {
- multiplier = SkTMax(multiplier, SK_ScalarSqrt2);
+ multiplier = std::max(multiplier, SK_ScalarSqrt2);
}
return strokeWidth/2 * multiplier;
}
diff --git a/src/core/SkTLList.h b/src/core/SkTLList.h
index 496ee9e..6d51329 100644
--- a/src/core/SkTLList.h
+++ b/src/core/SkTLList.h
@@ -151,7 +151,7 @@
this->validate();
}
- int count() const { return SkTMax(fCount ,0); }
+ int count() const { return std::max(fCount ,0); }
bool isEmpty() const { this->validate(); return 0 == fCount || -1 == fCount; }
bool operator== (const SkTLList& list) const {
diff --git a/src/core/SkWriter32.cpp b/src/core/SkWriter32.cpp
index cab2812..589382b 100644
--- a/src/core/SkWriter32.cpp
+++ b/src/core/SkWriter32.cpp
@@ -75,7 +75,7 @@
void SkWriter32::growToAtLeast(size_t size) {
const bool wasExternal = (fExternal != nullptr) && (fData == fExternal);
- fCapacity = 4096 + SkTMax(size, fCapacity + (fCapacity / 2));
+ fCapacity = 4096 + std::max(size, fCapacity + (fCapacity / 2));
fInternal.realloc(fCapacity);
fData = fInternal.get();
diff --git a/src/core/SkZip.h b/src/core/SkZip.h
index 5561566..d13ecaf 100644
--- a/src/core/SkZip.h
+++ b/src/core/SkZip.h
@@ -191,8 +191,8 @@
size_t maxSize = 0;
for (size_t s : {Span<Ts>::Size(std::forward<Ts>(ts))...}) {
if (s != SIZE_MAX) {
- minSize = SkTMin(minSize, s);
- maxSize = SkTMax(maxSize, s);
+ minSize = std::min(minSize, s);
+ maxSize = std::max(maxSize, s);
}
}
SkASSERT(minSize == maxSize);