Handle large rects better.

ui/gfx/geometry/rect.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/geometry/rect.h"
 
 #include <algorithm>
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 42 matching lines @@
   if (*origin < dst_origin)
     *origin = dst_origin;
   else
     *origin = std::min(dst_origin + dst_size, *origin + *size) - *size;
 }
 
 }  // namespace
 
 namespace gfx {
 
+// This is the per-axis heuristic for picking the cwmost useful origin and
+// width/height to represent the input range.
+static void SaturatedClampRange(int min, int max, int& origin, int& span) {
+  if (max < min) {
+    span = 0;
+    origin = min;
+    return;
+  }
+
+  span = base::SaturatedSubtraction(max, min);
+
+  int span_loss = base::SaturatedSubtraction(max, min + span);
+
+  // If the desired width is within the limits of ints, we can just
+  // use the simple computations to represent the range precisely.
+  if (span_loss == 0) {

[Peter Mayo, 2017/03/17 00:30:48]

This condition neatly summarizes that we have to punt. It leverages the speed
and accuracy of base::SaturatedSubtraction.

+    origin = min;
+    return;
+  }
+
+  // Now we have to approximate. If one of min or max is close enough
+  // to zero we choose to make sure it is represented precisely.
+  // The other side is probably practically "infinite", so we move it.
+  if (base::SaturatedAbsolute(max) < std::numeric_limits<int>::max() / 2) {
+    origin = max - span;
+  } else if (base::SaturatedAbsolute(min) <
+             std::numeric_limits<int>::max() / 2) {
+    origin = min;
+  } else {
+    // both are big, so keep the center.
+    origin = min + span_loss / 2;
+  }
+}
+
+void Rect::SetByBounds(int left, int right, int top, int bottom) {
+  int x, y;
+  int width, height;
+  SaturatedClampRange(left, right, x, width);
+  SaturatedClampRange(top, bottom, y, height);
+  origin_.SetPoint(x, y);
+  size_.SetSize(width, height);
+}
+
 void Rect::Inset(const Insets& insets) {
   Inset(insets.left(), insets.top(), insets.right(), insets.bottom());
 }
 
 void Rect::Inset(int left, int top, int right, int bottom) {
   origin_ += Vector2d(left, top);
   // left+right might overflow/underflow, but width() - (left+right) might
   // overflow as well.
   set_width(base::SaturatedSubtraction(width(),
                                        base::SaturatedAddition(left, right)));
@@ skipping 71 matching lines @@
 }
 
 void Rect::Union(const Rect& rect) {
   if (IsEmpty()) {
     *this = rect;
     return;
   }
   if (rect.IsEmpty())
     return;
 
-  int rx = std::min(x(), rect.x());
-  int ry = std::min(y(), rect.y());
-  int rr = std::max(right(), rect.right());
-  int rb = std::max(bottom(), rect.bottom());
-
-  // Subtracting to get width/height might overflow integers, so clamp them.
-  SetRect(rx, ry, base::SaturatedSubtraction(rr, rx),
-          base::SaturatedSubtraction(rb, ry));
+  SetByBounds(std::min(x(), rect.x()), std::max(right(), rect.right()),
+              std::min(y(), rect.y()), std::max(bottom(), rect.bottom()));
 }
 
 void Rect::Subtract(const Rect& rect) {
   if (!Intersects(rect))
     return;
   if (rect.Contains(*this)) {
     SetRect(0, 0, 0, 0);
     return;
   }
 
@@ skipping 10 matching lines @@
       rr = rect.x();
     }
   } else if (rect.x() <= x() && rect.right() >= right()) {
     // complete intersection in the x-direction
     if (rect.y() <= y()) {
       ry = rect.bottom();
     } else if (rect.bottom() >= bottom()) {
       rb = rect.y();
     }
   }
-  SetRect(rx, ry, rr - rx, rb - ry);
+  SetByBounds(rx, rr, ry, rb);
 }
 
 void Rect::AdjustToFit(const Rect& rect) {
   int new_x = x();
   int new_y = y();
   int new_width = width();
   int new_height = height();
   AdjustAlongAxis(rect.x(), rect.width(), &new_x, &new_width);
   AdjustAlongAxis(rect.y(), rect.height(), &new_y, &new_height);
   SetRect(new_x, new_y, new_width, new_height);
@@ skipping 82 matching lines @@
   return result;
 }
 
 Rect SubtractRects(const Rect& a, const Rect& b) {
   Rect result = a;
   result.Subtract(b);
   return result;
 }
 
 Rect BoundingRect(const Point& p1, const Point& p2) {
-  int rx = std::min(p1.x(), p2.x());
-  int ry = std::min(p1.y(), p2.y());
-  int rr = std::max(p1.x(), p2.x());
-  int rb = std::max(p1.y(), p2.y());
-  return Rect(rx, ry, rr - rx, rb - ry);
+  Rect result;
+  result.SetByBounds(std::min(p1.x(), p2.x()), std::max(p1.x(), p2.x()),
+                     std::min(p1.y(), p2.y()), std::max(p1.y(), p2.y()));
+  return result;
 }
 
 }  // namespace gfx