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

cc/base/math_util.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 <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 102 matching lines @@
   (*num_vertices_in_clipped_quad)++;
 }
 
 static inline void AddVertexToClippedQuad3d(const gfx::Point3F& new_vertex,
                                             gfx::Point3F clipped_quad[8],
                                             int* num_vertices_in_clipped_quad) {
   clipped_quad[*num_vertices_in_clipped_quad] = new_vertex;
   (*num_vertices_in_clipped_quad)++;
 }
 
+float MathUtil::RoundToFixedPrecision(float value, int precision) {
+  DCHECK_GE(precision, 0);
+
+  // The value of std::numeric_limits<float>::digits10 is the number of base-10
+  // digits that can be represented by the type float without change.
+  int max_digits10 = std::numeric_limits<float>::digits10;
+
+  float integral_part;
+  float fractional_part = std::modf(value, &integral_part);
+
+  // Return if |value| can not be represented by float without change.
+  int digits10_in_integral_part =
+      integral_part > 0 ? static_cast<int>(std::log10(integral_part)) + 1 : 1;
+  if (digits10_in_integral_part > max_digits10)
+    return value;
+
+  // Get maximum possible precision.
+  int possible_precision =
+      std::min((max_digits10 - digits10_in_integral_part), precision);
+  DCHECK(possible_precision < max_digits10);
+
+  float factor = std::pow(10, possible_precision);
+  fractional_part = std::round(fractional_part * factor) / factor;
+  return integral_part + fractional_part;
+}
+
 gfx::Rect MathUtil::MapEnclosingClippedRect(const gfx::Transform& transform,
                                             const gfx::Rect& src_rect) {
   if (transform.IsIdentityOrIntegerTranslation()) {
     gfx::Vector2d offset(static_cast<int>(transform.matrix().getFloat(0, 3)),
                          static_cast<int>(transform.matrix().getFloat(1, 3)));
     return src_rect + offset;
   }
   gfx::RectF mapped_rect = MapClippedRect(transform, gfx::RectF(src_rect));
 
   // gfx::ToEnclosingRect crashes if called on a RectF with any NaN coordinate.
@@ skipping 756 matching lines @@
                         transform.matrix().getFloat(2, 0));
 }
 
 gfx::Vector3dF MathUtil::GetYAxis(const gfx::Transform& transform) {
   return gfx::Vector3dF(transform.matrix().getFloat(0, 1),
                         transform.matrix().getFloat(1, 1),
                         transform.matrix().getFloat(2, 1));
 }
 
 }  // namespace cc