0

Replace repeated min/max calls with n-arg min/max calls.

Cleanup only, no functional change.

Bug: 1000055
TBR: sadrul,kinuko,thestig, mthiesse, zmo, msarda, csharrison, jochen
Change-Id: Idc3d434d6cd5a5d9125c5e00047cbc6219616769
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1790724
Commit-Queue: Peter Kasting <pkasting@chromium.org>
Reviewed-by: Charlie Harrison <csharrison@chromium.org>
Reviewed-by: Lei Zhang <thestig@chromium.org>
Reviewed-by: Michael Thiessen <mthiesse@chromium.org>
Reviewed-by: danakj <danakj@chromium.org>
Reviewed-by: Peter Kasting <pkasting@chromium.org>
Cr-Commit-Position: refs/heads/master@{#696103}
This commit is contained in:
Peter Kasting
2019-09-12 18:18:27 +00:00
committed by Commit Bot
parent fda5fc8bca
commit 14eab5ccd1
18 changed files with 52 additions and 73 deletions

@@ -162,8 +162,7 @@ static inline bool IsNearlyTheSame(float f, float g) {
// for the base of the scale too. // for the base of the scale too.
static const float epsilon_scale = 0.00001f; static const float epsilon_scale = 0.00001f;
return std::abs(f - g) < return std::abs(f - g) <
epsilon_scale * epsilon_scale * std::max({std::abs(f), std::abs(g), epsilon_scale});
std::max(std::max(std::abs(f), std::abs(g)), epsilon_scale);
} }
static inline bool IsNearlyTheSame(const gfx::PointF& lhs, static inline bool IsNearlyTheSame(const gfx::PointF& lhs,

@@ -1277,12 +1277,12 @@ void PictureLayerImpl::CleanUpTilingsOnActiveLayer(
PictureLayerImpl* twin = GetPendingOrActiveTwinLayer(); PictureLayerImpl* twin = GetPendingOrActiveTwinLayer();
if (twin && twin->CanHaveTilings()) { if (twin && twin->CanHaveTilings()) {
min_acceptable_high_res_scale = std::min( min_acceptable_high_res_scale =
min_acceptable_high_res_scale, std::min({min_acceptable_high_res_scale, twin->raster_contents_scale_,
std::min(twin->raster_contents_scale_, twin->ideal_contents_scale_)); twin->ideal_contents_scale_});
max_acceptable_high_res_scale = std::max( max_acceptable_high_res_scale =
max_acceptable_high_res_scale, std::max({max_acceptable_high_res_scale, twin->raster_contents_scale_,
std::max(twin->raster_contents_scale_, twin->ideal_contents_scale_)); twin->ideal_contents_scale_});
} }
PictureLayerTilingSet* twin_set = twin ? twin->tilings_.get() : nullptr; PictureLayerTilingSet* twin_set = twin ? twin->tilings_.get() : nullptr;

@@ -1393,8 +1393,8 @@ void PushDrawDRRectOps(PaintOpBuffer* buffer) {
} }
void PushDrawImageOps(PaintOpBuffer* buffer) { void PushDrawImageOps(PaintOpBuffer* buffer) {
size_t len = std::min(std::min(test_images.size(), test_flags.size()), size_t len =
test_floats.size() - 1); std::min({test_images.size(), test_flags.size(), test_floats.size() - 1});
for (size_t i = 0; i < len; ++i) { for (size_t i = 0; i < len; ++i) {
buffer->push<DrawImageOp>(test_images[i], test_floats[i], buffer->push<DrawImageOp>(test_images[i], test_floats[i],
test_floats[i + 1], &test_flags[i]); test_floats[i + 1], &test_flags[i]);
@@ -1408,8 +1408,8 @@ void PushDrawImageOps(PaintOpBuffer* buffer) {
} }
void PushDrawImageRectOps(PaintOpBuffer* buffer) { void PushDrawImageRectOps(PaintOpBuffer* buffer) {
size_t len = std::min(std::min(test_images.size(), test_flags.size()), size_t len =
test_rects.size() - 1); std::min({test_images.size(), test_flags.size(), test_rects.size() - 1});
for (size_t i = 0; i < len; ++i) { for (size_t i = 0; i < len; ++i) {
PaintCanvas::SrcRectConstraint constraint = PaintCanvas::SrcRectConstraint constraint =
i % 2 ? PaintCanvas::kStrict_SrcRectConstraint i % 2 ? PaintCanvas::kStrict_SrcRectConstraint
@@ -1529,8 +1529,8 @@ void PushDrawTextBlobOps(PaintOpBuffer* buffer) {
return builder.make(); return builder.make();
}(), }(),
}; };
size_t len = std::min(std::min(test_paint_blobs.size(), test_flags.size()), size_t len = std::min(
test_floats.size() - 1); {test_paint_blobs.size(), test_flags.size(), test_floats.size() - 1});
for (size_t i = 0; i < len; ++i) { for (size_t i = 0; i < len; ++i) {
buffer->push<DrawTextBlobOp>(test_paint_blobs[i], test_floats[i], buffer->push<DrawTextBlobOp>(test_paint_blobs[i], test_floats[i],
test_floats[i + 1], test_flags[i]); test_floats[i + 1], test_flags[i]);

@@ -626,12 +626,11 @@ void PictureLayerTiling::SetTilePriorityRects(
// since skewport.Contains(visible_rect) is always true. // since skewport.Contains(visible_rect) is always true.
max_skewport_extent_in_screen_space_ = max_skewport_extent_in_screen_space_ =
current_content_to_screen_scale_ * current_content_to_screen_scale_ *
std::max(std::max(current_visible_rect_.x() - current_skewport_rect_.x(), std::max(
current_skewport_rect_.right() - {current_visible_rect_.x() - current_skewport_rect_.x(),
current_visible_rect_.right()), current_skewport_rect_.right() - current_visible_rect_.right(),
std::max(current_visible_rect_.y() - current_skewport_rect_.y(), current_visible_rect_.y() - current_skewport_rect_.y(),
current_skewport_rect_.bottom() - current_skewport_rect_.bottom() - current_visible_rect_.bottom()});
current_visible_rect_.bottom()));
} }
void PictureLayerTiling::SetLiveTilesRect( void PictureLayerTiling::SetLiveTilesRect(

@@ -370,7 +370,7 @@ gfx::Image GetAvatarIconForTitleBar(const gfx::Image& image,
if (!is_gaia_image && image.Height() <= kAvatarIconSize) if (!is_gaia_image && image.Height() <= kAvatarIconSize)
return image; return image;
int size = std::min(kAvatarIconSize, std::min(dst_width, dst_height)); int size = std::min({kAvatarIconSize, dst_width, dst_height});
gfx::Size dst_size(dst_width, dst_height); gfx::Size dst_size(dst_width, dst_height);
// Source for a sized icon drawn at the bottom center of the canvas, // Source for a sized icon drawn at the bottom center of the canvas,

@@ -407,13 +407,12 @@ void StackedTabStripLayout::LayoutUsingCurrentAfter(int index) {
void StackedTabStripLayout::LayoutUsingCurrentBefore(int index) { void StackedTabStripLayout::LayoutUsingCurrentBefore(int index) {
for (int i = index - 1; i >= pinned_tab_count_; --i) { for (int i = index - 1; i >= pinned_tab_count_; --i) {
int x = std::max(ideal_x(i), ideal_x(i + 1) - tab_offset());
int max_x = x_ + width_for_count(i - pinned_tab_count_); int max_x = x_ + width_for_count(i - pinned_tab_count_);
if (i > pinned_tab_count_) if (i > pinned_tab_count_)
max_x -= overlap_; max_x -= overlap_;
max_x = std::min(max_x, ideal_x(i + 1) - stacked_padding_); SetIdealBoundsAt(i,
SetIdealBoundsAt( std::min({x, ideal_x(i + 1) - stacked_padding_, max_x}));
i, std::min(max_x,
std::max(ideal_x(i), ideal_x(i + 1) - tab_offset())));
} }
} }

@@ -26,8 +26,7 @@ struct CornerRadii {
} }
float MaxRadius() const { float MaxRadius() const {
return std::max(upper_left, return std::max({upper_left, upper_right, lower_left, lower_right});
std::max(upper_right, std::max(lower_left, lower_right)));
} }
}; };

@@ -17,7 +17,7 @@ double ConvertFontSizeChromeToAndroid(int default_size,
// fixed font size we will want to take into account the adjustment. // fixed font size we will want to take into account the adjustment.
default_fixed_size += 3; default_fixed_size += 3;
int max_chrome_size = int max_chrome_size =
std::max(std::max(default_fixed_size, default_size), minimum_size); std::max({default_fixed_size, default_size, minimum_size});
double android_scale = kAndroidFontScaleSmall; double android_scale = kAndroidFontScaleSmall;
if (max_chrome_size >= kChromeFontSizeVeryLarge) { if (max_chrome_size >= kChromeFontSizeVeryLarge) {

@@ -10,14 +10,6 @@
namespace webrtc_logging { namespace webrtc_logging {
namespace {
inline uint32_t Min3(uint32_t a, uint32_t b, uint32_t c) {
return std::min(a, std::min(b, c));
}
} // namespace
PartialCircularBuffer::PartialCircularBuffer(void* buffer, uint32_t buffer_size) PartialCircularBuffer::PartialCircularBuffer(void* buffer, uint32_t buffer_size)
: buffer_data_(reinterpret_cast<BufferData*>(buffer)), : buffer_data_(reinterpret_cast<BufferData*>(buffer)),
memory_buffer_size_(buffer_size), memory_buffer_size_(buffer_size),
@@ -74,7 +66,7 @@ uint32_t PartialCircularBuffer::Read(void* buffer, uint32_t buffer_size) {
if (position_ < buffer_data_->wrap_position) { if (position_ < buffer_data_->wrap_position) {
uint32_t to_wrap_pos = buffer_data_->wrap_position - position_; uint32_t to_wrap_pos = buffer_data_->wrap_position - position_;
uint32_t to_eow = buffer_data_->total_written - total_read_; uint32_t to_eow = buffer_data_->total_written - total_read_;
uint32_t to_read = Min3(buffer_size, to_wrap_pos, to_eow); uint32_t to_read = std::min({buffer_size, to_wrap_pos, to_eow});
memcpy(buffer_uint8, buffer_data_->data + position_, to_read); memcpy(buffer_uint8, buffer_data_->data + position_, to_read);
position_ += to_read; position_ += to_read;
total_read_ += to_read; total_read_ += to_read;
@@ -103,7 +95,7 @@ uint32_t PartialCircularBuffer::Read(void* buffer, uint32_t buffer_size) {
uint32_t remaining_buffer_size = buffer_size - read; uint32_t remaining_buffer_size = buffer_size - read;
uint32_t to_eof = data_size_ - position_; uint32_t to_eof = data_size_ - position_;
uint32_t to_eow = buffer_data_->total_written - total_read_; uint32_t to_eow = buffer_data_->total_written - total_read_;
uint32_t to_read = Min3(remaining_buffer_size, to_eof, to_eow); uint32_t to_read = std::min({remaining_buffer_size, to_eof, to_eow});
memcpy(buffer_uint8 + read, buffer_data_->data + position_, to_read); memcpy(buffer_uint8 + read, buffer_data_->data + position_, to_read);
position_ += to_read; position_ += to_read;
total_read_ += to_read; total_read_ += to_read;
@@ -128,7 +120,7 @@ uint32_t PartialCircularBuffer::Read(void* buffer, uint32_t buffer_size) {
uint32_t remaining_buffer_size = buffer_size - read; uint32_t remaining_buffer_size = buffer_size - read;
uint32_t to_eob = buffer_data_->end_position - position_; uint32_t to_eob = buffer_data_->end_position - position_;
uint32_t to_eow = buffer_data_->total_written - total_read_; uint32_t to_eow = buffer_data_->total_written - total_read_;
uint32_t to_read = Min3(remaining_buffer_size, to_eob, to_eow); uint32_t to_read = std::min({remaining_buffer_size, to_eob, to_eow});
memcpy(buffer_uint8 + read, buffer_data_->data + position_, to_read); memcpy(buffer_uint8 + read, buffer_data_->data + position_, to_read);
position_ += to_read; position_ += to_read;
total_read_ += to_read; total_read_ += to_read;

@@ -1139,7 +1139,7 @@ void RenderAccessibilityImpl::RecordImageMetrics(AXContentTreeUpdate* update) {
continue; continue;
// We log the min size in a histogram with a max of 10000, so set a ceiling // We log the min size in a histogram with a max of 10000, so set a ceiling
// of 10000 on min_size. // of 10000 on min_size.
int min_size = std::min(std::min(width, height), 10000); int min_size = std::min({width, height, 10000});
int max_size = std::max(width, height); int max_size = std::max(width, height);
// The ratio is always the smaller divided by the larger so as not to go // The ratio is always the smaller divided by the larger so as not to go
// over 100%. // over 100%.

@@ -2589,11 +2589,9 @@ GLsizei TextureManager::ComputeMipMapCount(GLenum target,
case GL_TEXTURE_RECTANGLE_ARB: case GL_TEXTURE_RECTANGLE_ARB:
return 1; return 1;
case GL_TEXTURE_3D: case GL_TEXTURE_3D:
return 1 + return 1 + base::bits::Log2Floor(std::max({width, height, depth}));
base::bits::Log2Floor(std::max(std::max(width, height), depth));
default: default:
return 1 + return 1 + base::bits::Log2Floor(std::max(width, height));
base::bits::Log2Floor(std::max(width, height));
} }
} }

@@ -3288,11 +3288,10 @@ void PDFiumEngine::DrawPageShadow(const pp::Rect& page_rc,
// Page drop shadow parameters. // Page drop shadow parameters.
constexpr double factor = 0.5; constexpr double factor = 0.5;
uint32_t depth = uint32_t depth = std::max({page_rect.x() - shadow_rect.x(),
std::max(std::max(page_rect.x() - shadow_rect.x(), page_rect.y() - shadow_rect.y(),
page_rect.y() - shadow_rect.y()), shadow_rect.right() - page_rect.right(),
std::max(shadow_rect.right() - page_rect.right(), shadow_rect.bottom() - page_rect.bottom()});
shadow_rect.bottom() - page_rect.bottom()));
depth = static_cast<uint32_t>(depth * 1.5) + 1; depth = static_cast<uint32_t>(depth * 1.5) + 1;
// We need to check depth only to verify our copy of shadow matrix is correct. // We need to check depth only to verify our copy of shadow matrix is correct.

@@ -155,15 +155,13 @@ void PageSetup::CalculateSizesWithinRect(const gfx::Rect& bounds,
effective_margins_.footer = std::max( effective_margins_.footer = std::max(
requested_margins_.footer, physical_size_.height() - bounds.bottom()); requested_margins_.footer, physical_size_.height() - bounds.bottom());
effective_margins_.left = std::max(requested_margins_.left, bounds.x()); effective_margins_.left = std::max(requested_margins_.left, bounds.x());
effective_margins_.top = effective_margins_.top = std::max({requested_margins_.top, bounds.y(),
std::max(std::max(requested_margins_.top, bounds.y()), effective_margins_.header + text_height});
effective_margins_.header + text_height);
effective_margins_.right = std::max(requested_margins_.right, effective_margins_.right = std::max(requested_margins_.right,
physical_size_.width() - bounds.right()); physical_size_.width() - bounds.right());
effective_margins_.bottom = effective_margins_.bottom = std::max(
std::max(std::max(requested_margins_.bottom, {requested_margins_.bottom, physical_size_.height() - bounds.bottom(),
physical_size_.height() - bounds.bottom()), effective_margins_.footer + text_height});
effective_margins_.footer + text_height);
// Calculate the overlay area. If the margins are excessive, the overlay_area // Calculate the overlay area. If the margins are excessive, the overlay_area
// size will be (0, 0). // size will be (0, 0).

@@ -644,8 +644,7 @@ int BlobReader::ComputeBytesToRead() const {
uint64_t max_int_value = std::numeric_limits<int>::max(); uint64_t max_int_value = std::numeric_limits<int>::max();
// Here we make sure we don't overflow 'max int'. // Here we make sure we don't overflow 'max int'.
uint64_t min = std::min( uint64_t min = std::min(
std::min(std::min(item_remaining, buf_remaining), remaining_bytes_), {item_remaining, buf_remaining, remaining_bytes_, max_int_value});
max_int_value);
return static_cast<int>(min); return static_cast<int>(min);
} }

@@ -151,8 +151,8 @@ void CubicBezier::InitRange(double p1y, double p2y) {
if (0 < t2 && t2 < 1) if (0 < t2 && t2 < 1)
sol2 = SampleCurveY(t2); sol2 = SampleCurveY(t2);
range_min_ = std::min(std::min(range_min_, sol1), sol2); range_min_ = std::min({range_min_, sol1, sol2});
range_max_ = std::max(std::max(range_max_, sol1), sol2); range_max_ = std::max({range_max_, sol1, sol2});
} }
void CubicBezier::InitSpline() { void CubicBezier::InitSpline() {

@@ -63,10 +63,10 @@ class GEOMETRY_EXPORT QuadF {
// the quad may lie on the right/bottom edge of the resulting rectangle, // the quad may lie on the right/bottom edge of the resulting rectangle,
// rather than being strictly inside it. // rather than being strictly inside it.
RectF BoundingBox() const { RectF BoundingBox() const {
float rl = std::min(std::min(p1_.x(), p2_.x()), std::min(p3_.x(), p4_.x())); float rl = std::min({p1_.x(), p2_.x(), p3_.x(), p4_.x()});
float rr = std::max(std::max(p1_.x(), p2_.x()), std::max(p3_.x(), p4_.x())); float rr = std::max({p1_.x(), p2_.x(), p3_.x(), p4_.x()});
float rt = std::min(std::min(p1_.y(), p2_.y()), std::min(p3_.y(), p4_.y())); float rt = std::min({p1_.y(), p2_.y(), p3_.y(), p4_.y()});
float rb = std::max(std::max(p1_.y(), p2_.y()), std::max(p3_.y(), p4_.y())); float rb = std::max({p1_.y(), p2_.y(), p3_.y(), p4_.y()});
return RectF(rl, rt, rr - rl, rb - rt); return RectF(rl, rt, rr - rl, rb - rt);
} }

@@ -150,12 +150,10 @@ void NineImagePainter::Paint(Canvas* canvas,
i7h = std::min(i7h, height_in_pixels - i1h); i7h = std::min(i7h, height_in_pixels - i1h);
i8h = std::min(i8h, height_in_pixels - i2h); i8h = std::min(i8h, height_in_pixels - i2h);
int i4x = std::min(std::min(i0w, i3w), i6w); int i4x = std::min({i0w, i3w, i6w});
int i4y = std::min(std::min(i0h, i1h), i2h); int i4y = std::min({i0h, i1h, i2h});
int i4w = int i4w = std::max(width_in_pixels - i4x - std::min({i2w, i5w, i8w}), 0);
std::max(width_in_pixels - i4x - std::min(std::min(i2w, i5w), i8w), 0); int i4h = std::max(height_in_pixels - i4y - std::min({i6h, i7h, i8h}), 0);
int i4h =
std::max(height_in_pixels - i4y - std::min(std::min(i6h, i7h), i8h), 0);
cc::PaintFlags flags; cc::PaintFlags flags;
flags.setAlpha(alpha); flags.setAlpha(alpha);

@@ -287,9 +287,8 @@ bool DoResolveRelativePath(const char* base_url,
// Canonical URLs always have a path, so we can use that offset. Reserve // Canonical URLs always have a path, so we can use that offset. Reserve
// enough room for the base URL, the new path, and some extra bytes for // enough room for the base URL, the new path, and some extra bytes for
// possible escaped characters. // possible escaped characters.
output->ReserveSizeIfNeeded( output->ReserveSizeIfNeeded(base_parsed.path.begin +
base_parsed.path.begin + std::max({path.end(), query.end(), ref.end()}));
std::max(path.end(), std::max(query.end(), ref.end())));
output->Append(base_url, base_parsed.path.begin); output->Append(base_url, base_parsed.path.begin);
if (path.len > 0) { if (path.len > 0) {