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 139 matching lines @@
   }
   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));
+  int rdx = base::SaturatedSubtraction(rr, rx);
+  int rdy = base::SaturatedSubtraction(rb, ry);
+
+  // clamping may move one side, choose to move the bigger by recomputing it.
+  // The computation of right is implicit, so this happens vacuosly.
+  //  If Right is small, move left to width away.
+  //  If Left is big(negative), move them both to keep the center.
+  if (rdx >= std::numeric_limits<int>::max() / 2) {

[Peter Mayo, 2017/03/14 18:35:59]

Maybe just on equality.

+    if (base::SaturatedAbsolute(rr) < rdx / 2)
+      rx = rr - rdx;
+    else if (base::SaturatedAbsolute(rx) > rdx / 2)
+      rx = rx + rdx / 4;
+  }
+
+  // Same computation, other axis.
+  if (rdy >= std::numeric_limits<int>::max() / 2) {
+    if (base::SaturatedAbsolute(rb) < rdy / 2)
+      ry = rb - rdy;
+    else if (base::SaturatedAbsolute(ry) > rdy / 2)
+      ry = ry + rdy / 4;
+  }
+
+  SetRect(rx, ry, rdx, rdy);
 }
 
 void Rect::Subtract(const Rect& rect) {
   if (!Intersects(rect))
     return;
   if (rect.Contains(*this)) {
     SetRect(0, 0, 0, 0);
     return;
   }
 
@@ skipping 121 matching lines @@
 
 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);
 }
 
 }  // namespace gfx