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) {
+  const int kScalePrecision = 4;

[vmpstr, 2015/10/16 17:58:17]

Can you just write const float kFactor = 1e4 instead? And remove the dcheck?

Or better yet, take the precision as a parameter to this function.
MathUtil::RoundToFixedPrecision(foo) is not clear at all that it will round to 4
decimal places. (and why 4, btw?)

[prashant.n, 2015/10/17 01:28:13]

I'll add precision as a parameter, I was thinking to add this earlier, but then
thought of 3 digits fractional part is sufficient so let it be fixed value here.
4 is for having 3 digits fractional part, e.g. 3.336f for scale factor.

+  // Limiting precision 1 <= kScalePrecision <= 8, as floating point precision
+  // of >= 12 gives different values, 8 on a safer side.
+  DCHECK(kScalePrecision >= 1 && kScalePrecision <= 8);
+
+  const float factor = pow(10, kScalePrecision);
+  float integral;
+  float fractional = std::modf(value, &integral);
+  fractional *= factor;

[vmpstr, 2015/10/16 17:58:17]

nit: I'd just write these three things in one line

fractional = std::round(factor * fractional) / factor;

+  fractional = std::round(fractional);
+  fractional /= factor;
+  return integral + fractional;
+}
+
 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