Stabilize empty rect handling in EnclosingRect.

ui/gfx/geometry/size_unittest.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 "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/size_f.h"
 
 namespace gfx {
@@ skipping 135 matching lines @@
 
   test = Size(10, 20);
   test.Enlarge(int_max, int_max);
   EXPECT_EQ(test, max_size);
 
   test = Size(-10, -20);
   test.Enlarge(int_min, int_min);
   EXPECT_EQ(test, min_size);
 }
 
+float SizeFPrivateMatch() {
+  return SizeF::kTrivial;
+};
+
+static float myTrivial = SizeFPrivateMatch() / 2.f;

[danakj, 2017/03/28 18:00:20]

these names are all (old) blink style not chromium style

"my" is not descriptive, maybe smaller_than_trivial?

[Peter Mayo, 2017/03/28 20:11:21]

Done.

+static float boundaryTrivial = SizeFPrivateMatch();
+static float nearlyTrivial = SizeFPrivateMatch() * 1.5f;
+
+// This checks that we set IsEmpty appropriately.
+TEST(SizeTest, TrivialDimensionTests) {
+  // First, using the constructor.
+  EXPECT_TRUE(SizeF(myTrivial, 1.f).IsEmpty());
+  EXPECT_TRUE(SizeF(.01f, myTrivial).IsEmpty());
+  EXPECT_TRUE(SizeF(0.f, 0.f).IsEmpty());
+  EXPECT_FALSE(SizeF(.01f, .01f).IsEmpty());
+
+  // Then use the setter.
+  SizeF test(2.f, 1.f);
+  EXPECT_FALSE(test.IsEmpty());
+
+  test.SetSize(myTrivial, 1.f);
+  EXPECT_TRUE(test.IsEmpty());
+
+  test.SetSize(.01f, myTrivial);
+  EXPECT_TRUE(test.IsEmpty());
+
+  test.SetSize(0.f, 0.f);
+  EXPECT_TRUE(test.IsEmpty());
+
+  test.SetSize(.01f, .01f);
+  EXPECT_FALSE(test.IsEmpty());
+
+  // Now just one dimension at a time.
+  test.set_width(myTrivial);
+  EXPECT_TRUE(test.IsEmpty());
+
+  test.set_width(4e13f);
+  test.set_height(myTrivial);
+  EXPECT_TRUE(test.IsEmpty());
+
+  test.set_width(myTrivial);
+  test.set_height(4e13f);
+  EXPECT_TRUE(test.IsEmpty());
+
+  test.set_width(2.f);
+  EXPECT_FALSE(test.IsEmpty());
+}
+
+// These are the ramifications of the decision to keep the recorded size
+// at zero for trivial sizes.
+TEST(SizeTest, ClampsToZero) {
+  SizeF test(myTrivial, 1.f);
+
+  EXPECT_FLOAT_EQ(0.f, test.width());
+  EXPECT_FLOAT_EQ(1.f, test.height());
+
+  test.SetSize(.01f, myTrivial);
+
+  EXPECT_FLOAT_EQ(.01f, test.width());
+  EXPECT_FLOAT_EQ(0.f, test.height());
+
+  test.SetSize(nearlyTrivial, nearlyTrivial);

[Peter Mayo, 2017/03/28 20:11:21]

Added an expectation here that validates nearly_trivial isn't clamped, to make
sure we're testing what we expect - that scaling it to trivial clamps.

+  test.Scale(0.5f);
+
+  EXPECT_FLOAT_EQ(0.f, test.width());
+  EXPECT_FLOAT_EQ(0.f, test.height());
+
+  test.SetSize(0.f, 0.f);
+  test.Enlarge(myTrivial, myTrivial);
+  test.Enlarge(myTrivial, myTrivial);
+  test.Enlarge(myTrivial, myTrivial);
+
+  EXPECT_EQ(SizeF(0.f, 0.f), test);
+}
+
+// These make sure the constructor and setter have the same effect on the
+// boundary case. This claims to know the boundary, but not which way it goes.
+TEST(SizeTest, ConsistentClamping) {
+  SizeF resized;
+
+  resized.SetSize(boundaryTrivial, 0.f);
+  EXPECT_EQ(SizeF(boundaryTrivial, 0.f), resized);
+
+  resized.SetSize(0.f, boundaryTrivial);
+  EXPECT_EQ(SizeF(0.f, boundaryTrivial), resized);
+}
+
+// Let's make sure we don't unexpectedly grow the struct by adding constants.
+// Also, if some platform packs floats inefficiently, it would be worth noting.
+TEST(SizeTest, StaysSmall) {
+  EXPECT_EQ(2 * sizeof(float), sizeof(SizeF));
+}
+
 }  // namespace gfx