cc: Do not create separate tilings for almost equal scale factors.

cc/base/math_util_unittest.cc

 // Copyright 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 "cc/base/math_util.h"
 
 #include <cmath>
 
 #include "cc/test/geometry_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 366 matching lines @@
   }
 }
 
 TEST(MathUtilTest, RoundDownUnderflow) {
   // Rounding down -123 by 50 is -150, which underflows int8_t, but fits in
   // int16_t.
   EXPECT_FALSE(MathUtil::VerifyRoundDown<int8_t>(-123, 50));
   EXPECT_TRUE(MathUtil::VerifyRoundDown<int16_t>(-123, 50));
 }
 
+TEST(MathUtilTest, AlmostEqualFloats) {
+  // Two almost equal floats.
+  float value1 = 7.33907556533813f;
+  float value2 = 7.33907508850098f;
+
+  EXPECT_TRUE(value1 != value2);
+
+  int max_precision = std::numeric_limits<float>::digits10 - 1;
+
+  // Check with all possible precisions, the almost equal floats (differing
+  // by small magnitude of epsilon) are same.
+  for (int i = 0; i <= max_precision; ++i) {
+    float value1_rounded_to_same_precision =
+        MathUtil::RoundToFixedPrecision(value1, i);
+    float value2_rounded_to_same_precision =
+        MathUtil::RoundToFixedPrecision(value2, i);
+    EXPECT_TRUE(value1_rounded_to_same_precision ==
+                value2_rounded_to_same_precision);
+  }
+
+  // Check the same float with different precisions. Different values should
+  // be returned.
+  for (int i = 0; i <= max_precision; ++i) {
+    for (int j = i + 1; j <= max_precision; ++j) {
+      float value1_rounded_to_precision_i =
+          MathUtil::RoundToFixedPrecision(value1, i);
+      float value1_rounded_to_precision_j =
+          MathUtil::RoundToFixedPrecision(value1, j);
+      EXPECT_FALSE(value1_rounded_to_precision_i ==
+                   value1_rounded_to_precision_j);
+    }
+  }
+
+  // Different floats created by differing some magnitude of epsilon.
+  float value3 = value1 + (10 * std::numeric_limits<float>::epsilon());
+  EXPECT_TRUE(value1 != value3);
+  EXPECT_TRUE(MathUtil::RoundToFixedPrecision(value1, 2) ==
+              MathUtil::RoundToFixedPrecision(value3, 2));
+
+  // Check different floats.
+  float value4 = 7.3f;
+  float value5 = 7.4f;
+  // Rounded to precision 0, should be equal.
+  EXPECT_TRUE(MathUtil::RoundToFixedPrecision(value4, 0) ==
+              MathUtil::RoundToFixedPrecision(value5, 0));
+  // Rounded to precision 1, should not be equal.
+  EXPECT_FALSE(MathUtil::RoundToFixedPrecision(value4, 1) ==
+               MathUtil::RoundToFixedPrecision(value5, 1));
+}
+
 }  // namespace
 }  // namespace cc