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

cc/base/math_util.h

 // 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.
 
 #ifndef CC_BASE_MATH_UTIL_H_
 #define CC_BASE_MATH_UTIL_H_
 
 #include <algorithm>
 #include <cmath>
 #include <vector>
@@ skipping 79 matching lines @@
   static float Deg2Rad(float deg) { return deg * kPiFloat / 180.0f; }
   static float Rad2Deg(float rad) { return rad * 180.0f / kPiFloat; }
 
   static float Round(float f) {
     return (f > 0.f) ? std::floor(f + 0.5f) : std::ceil(f - 0.5f);
   }
   static double Round(double d) {
     return (d > 0.0) ? std::floor(d + 0.5) : std::ceil(d - 0.5);
   }
 
+  // Rounds the given |value| to fixed precision. This makes almost equal
+  // floats (which differ by some threshold magnitude of floating point epsilon)
+  // to be considered as same.
+  // The |precision| should be >= 0, otherwise crashes in debug builds.
+  // The max number of digits that can be represented without change by float
+  // is 6. The maximum possible digits in the fraction part is computed by
+  // considering digits in integral part and digits required for |precision|.
+  // e.g. If intergral part has 4 digits and precision in fractional part
+  // requested is 5, then max allowed precision for fraction part is 2.
+  // Examples:
+  // RoundToFixedPrecision(7.33907556533813, 4) returns 7.339000225067138671875.
+  // RoundToFixedPrecision(7.33907508850098, 4) returns 7.339000225067138671875.
+  static float RoundToFixedPrecision(float value, int precision);
+
   // Returns true if rounded up value does not overflow, false otherwise.
   template <typename T>
   static bool VerifyRoundup(T n, T mul) {
     return mul && (n <= (std::numeric_limits<T>::max() -
                          (std::numeric_limits<T>::max() % mul)));
   }
 
   // Rounds up a given |n| to be a multiple of |mul|, but may overflow.
   // Examples:
   //    - RoundUp(123, 50) returns 150.
@@ skipping 206 matching lines @@
   template <typename T>
   static T RoundDownInternal(T n, T mul) {
     return (n > 0) ? (n / mul) * mul : (n == 0) ? 0
                                                 : ((n - mul + 1) / mul) * mul;
   }
 };
 
 }  // namespace cc
 
 #endif  // CC_BASE_MATH_UTIL_H_