Handle large rects better.

ui/gfx/geometry/rect_unittest.cc

 // Copyright (c) 2013 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 <limits>
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "build/build_config.h"
@@ skipping 407 matching lines @@
   EXPECT_FALSE(r.SharesEdgeWith(just_above_no_edge));
   EXPECT_FALSE(r.SharesEdgeWith(just_below_no_edge));
   EXPECT_FALSE(r.SharesEdgeWith(just_left_no_edge));
   EXPECT_FALSE(r.SharesEdgeWith(just_right_no_edge));
 }
 
 // Similar to EXPECT_FLOAT_EQ, but lets NaN equal NaN
 #define EXPECT_FLOAT_AND_NAN_EQ(a, b) \
   { if (a == a || b == b) { EXPECT_FLOAT_EQ(a, b); } }
 
+static const int dont_care = -451329;
+#define MAYBE_EXPECT_INT_EQ(a, b) \
+  {                               \
+    if (a != dont_care) {         \
+      EXPECT_EQ(a, b);            \
+    }                             \
+  }
+
 TEST(RectTest, ScaleRect) {
   static const struct Test {
     int x1;  // source
     int y1;
     int w1;
     int h1;
     float scale;
     float x2;  // target
     float y2;
     float w2;
@@ skipping 37 matching lines @@
   static const float max_float = std::numeric_limits<float>::max();
   static const struct Test {
     float x1; // source
     float y1;
     float w1;
     float h1;
     int x2; // target
     int y2;
     int w2;
     int h2;
-  } tests[] = {{0.0f, 0.0f, 0.0f, 0.0f, 0, 0, 0, 0},
-               {-1.5f, -1.5f, 3.0f, 3.0f, -1, -1, 2, 2},
-               {-1.5f, -1.5f, 3.5f, 3.5f, -1, -1, 3, 3},
-               {max_float, max_float, 2.0f, 2.0f, max_int, max_int, 0, 0},
-               {0.0f, 0.0f, max_float, max_float, 0, 0, max_int, max_int},
-               {20000.5f, 20000.5f, 0.5f, 0.5f, 20001, 20001, 0, 0},
-               {static_cast<float>(min_int),
-                static_cast<float>(min_int),
-                max_int * 2.f,
-                max_int * 2.f,
-                min_int,
-                min_int,
-                max_int,
-                max_int},
-               {static_cast<float>(max_int),
-                static_cast<float>(max_int),
-                static_cast<float>(max_int),
-                static_cast<float>(max_int),
-                max_int,
-                max_int,
-                0,
-                0}};
+  } tests[] = {
+      {0.0f, 0.0f, 0.0f, 0.0f, 0, 0, 0, 0},
+      {-1.5f, -1.5f, 3.0f, 3.0f, -1, -1, 2, 2},
+      {-1.5f, -1.5f, 3.5f, 3.5f, -1, -1, 3, 3},
+      {max_float, max_float, 2.0f, 2.0f, max_int, max_int, 0, 0},
+      {0.0f, 0.0f, max_float, max_float, 0, 0, max_int, max_int},
+      {20000.5f, 20000.5f, 0.5f, 0.5f, 20001, 20001, 0, 0},
+      {static_cast<float>(min_int), static_cast<float>(min_int), max_int * 2.f,
+       max_int * 2.f, dont_care, dont_care, max_int, max_int},
+      {static_cast<float>(max_int), static_cast<float>(max_int),
+       static_cast<float>(max_int), static_cast<float>(max_int), max_int,
+       max_int, 0, 0}};
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     RectF r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
     Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
 
     Rect enclosed = ToEnclosedRect(r1);
-    EXPECT_FLOAT_AND_NAN_EQ(r2.x(), enclosed.x());
-    EXPECT_FLOAT_AND_NAN_EQ(r2.y(), enclosed.y());
-    EXPECT_FLOAT_AND_NAN_EQ(r2.width(), enclosed.width());
-    EXPECT_FLOAT_AND_NAN_EQ(r2.height(), enclosed.height());
+    MAYBE_EXPECT_INT_EQ(r2.x(), enclosed.x());
+    MAYBE_EXPECT_INT_EQ(r2.y(), enclosed.y());
+    MAYBE_EXPECT_INT_EQ(r2.width(), enclosed.width());
+    MAYBE_EXPECT_INT_EQ(r2.height(), enclosed.height());
   }
 }
 
 TEST(RectTest, ToEnclosingRect) {
   static const int max_int = std::numeric_limits<int>::max();
   static const int min_int = std::numeric_limits<int>::min();
   static const float max_float = std::numeric_limits<float>::max();
   static const struct Test {
     float x1; // source
     float y1;
     float w1;
     float h1;
     int x2; // target
     int y2;
     int w2;
     int h2;
   } tests[] = {
       {0.0f, 0.0f, 0.0f, 0.0f, 0, 0, 0, 0},
       {5.5f, 5.5f, 0.0f, 0.0f, 5, 5, 0, 0},
-      {3.5f, 2.5f, 0.01f, -0.0f, 3, 2, 0, 0},
+      {3.5f, 2.5f, 0.01f, -0.0f, 3, 2, 1, 0},
+      {3.5f, 2.5f, 0.f, 0.001f, 3, 2, 0, 1},
       {-1.5f, -1.5f, 3.0f, 3.0f, -2, -2, 4, 4},
       {-1.5f, -1.5f, 3.5f, 3.5f, -2, -2, 4, 4},
       {max_float, max_float, 2.0f, 2.0f, max_int, max_int, 0, 0},
       {0.0f, 0.0f, max_float, max_float, 0, 0, max_int, max_int},
       {20000.5f, 20000.5f, 0.5f, 0.5f, 20000, 20000, 1, 1},
       {static_cast<float>(min_int), static_cast<float>(min_int), max_int * 2.f,
-       max_int * 2.f, min_int, min_int, max_int, max_int},
+       max_int * 2.f, dont_care, dont_care, max_int, max_int},
       {static_cast<float>(max_int), static_cast<float>(max_int),
        static_cast<float>(max_int), static_cast<float>(max_int), max_int,
        max_int, 0, 0},
       {-0.5f, -0.5f, 22777712.f, 1.f, -1, -1, 22777713, 2}};
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     RectF r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
     Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
 
     Rect enclosed = ToEnclosingRect(r1);
-    EXPECT_EQ(r2.x(), enclosed.x());
-    EXPECT_EQ(r2.y(), enclosed.y());
-    EXPECT_EQ(r2.width(), enclosed.width());
-    EXPECT_EQ(r2.height(), enclosed.height());
+    MAYBE_EXPECT_INT_EQ(r2.x(), enclosed.x());
+    MAYBE_EXPECT_INT_EQ(r2.y(), enclosed.y());
+    MAYBE_EXPECT_INT_EQ(r2.width(), enclosed.width());
+    MAYBE_EXPECT_INT_EQ(r2.height(), enclosed.height());
   }
 }
 
 TEST(RectTest, ToNearestRect) {
   Rect rect;
   EXPECT_EQ(rect, ToNearestRect(RectF(rect)));
 
   rect = Rect(-1, -1, 3, 3);
   EXPECT_EQ(rect, ToNearestRect(RectF(rect)));
 
@@ skipping 472 matching lines @@
     Rect positive_origin(100, 100, 500, 500);
 
     // Ideally, this should be (100, 100, limit + 400, limit + 400).
     // However, width overflows and would be clamped to limit, but right
     // overflows too and so will be clamped to limit - 100.
     Rect expected(100, 100, limit - 100, limit - 100);
     EXPECT_EQ(UnionRects(clamped, positive_origin), expected);
   }
 
   // Unioning a left=minint rect with a right=maxint rect.
-  // Width is always clamped before adjusting position, so this
-  // should taking the min left/top and then finding the max width.
+  // We can't represent both ends of the spectrum in the same rect.
+  // Make sure we keep the most useful area.
   {
+    int part_limit = min_limit / 3;
     Rect left_minint(min_limit, min_limit, 1, 1);
     Rect right_maxint(limit - 1, limit - 1, limit, limit);
-    Rect expected(min_limit, min_limit, limit, limit);
-    EXPECT_EQ(UnionRects(left_minint, right_maxint), expected);
+    Rect expected(part_limit, part_limit, 2 * part_limit, 2 * part_limit);
+    EXPECT_TRUE(UnionRects(left_minint, right_maxint).Contains(expected));
   }
 }
 
 TEST(RectTest, ScaleToEnclosingRectSafe) {
   const int max_int = std::numeric_limits<int>::max();
   const int min_int = std::numeric_limits<int>::min();
 
   Rect xy_underflow(-100000, -123456, 10, 20);
   EXPECT_EQ(ScaleToEnclosingRectSafe(xy_underflow, 100000, 100000),
             Rect(min_int, min_int, 1000000, 2000000));
@@ skipping 24 matching lines @@
 
   Rect min_rect(min_int, min_int, max_int, max_int);
   // Min rect can't be scaled up any further in any dimension.
   EXPECT_EQ(ScaleToEnclosingRectSafe(min_rect, 2, 3.5), min_rect);
   EXPECT_EQ(ScaleToEnclosingRectSafe(min_rect, max_int, max_int), min_rect);
   // Min rect scaled by min is an empty rect at (max, max)
   EXPECT_EQ(ScaleToEnclosingRectSafe(min_rect, min_int, min_int), max_rect);
 }
 
 }  // namespace gfx