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

cc/layers/picture_layer_impl.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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 31 matching lines @@
 
 // Even for really wide viewports, at some point GPU raster should use
 // less than 4 tiles to fill the viewport. This is set to 256 as a
 // sane minimum for now, but we might want to tune this for low-end.
 const int kMinHeightForGpuRasteredTile = 256;
 
 // When making odd-sized tiles, round them up to increase the chances
 // of using the same tile size.
 const int kTileRoundUp = 64;
 
+// The precision value for rounding floating points values (of scale factors),
+// to given decimal places so that scale factors which are almost equal (differ
+// by some threshold magnitude of floating point epsilon) are considered as
+// same.
+const int kScalePrecision = 4;
+
+float RoundToFixedPrecision(float value) {
+  // 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);

[prashant.n, 2015/09/01 16:55:25]

I tried checking standard way for doing this. Definitely there should be based
on logarithmic function. But I still did not get it. I'll try to work on it.

Meanwhile enne@/danakj, if you know this rounding can you pls. suggest here.

+  fractional *= factor;
+  fractional = std::round(fractional);
+  fractional /= factor;
+  return integral + fractional;
+}
+
 }  // namespace
 
 namespace cc {
 
 PictureLayerImpl::PictureLayerImpl(
     LayerTreeImpl* tree_impl,
     int id,
     bool is_mask,
     scoped_refptr<SyncedScrollOffset> scroll_offset)
     : LayerImpl(tree_impl, id, scroll_offset),
@@ skipping 833 matching lines @@
     return true;
 
   return false;
 }
 
 void PictureLayerImpl::RecalculateRasterScales() {
   float old_raster_contents_scale = raster_contents_scale_;
   float old_raster_page_scale = raster_page_scale_;
   float old_raster_source_scale = raster_source_scale_;
 
+  // Get fixed precision values to avoid creating extra tilings for scales
+  // which are almost equal.
   raster_device_scale_ = ideal_device_scale_;
   raster_page_scale_ = ideal_page_scale_;
   raster_source_scale_ = ideal_source_scale_;
-  raster_contents_scale_ = ideal_contents_scale_;
+  raster_contents_scale_ = RoundToFixedPrecision(ideal_contents_scale_);

[prashant.n, 2015/09/01 16:55:25]

I thought of rounding all raster scales, so that all are in sync. When checked
by applying only for contents scale I did not see any issue.

 
   // If we're not animating, or leaving an animation, and the
   // ideal_source_scale_ changes, then things are unpredictable, and we fix
   // the raster_source_scale_ in place.
   if (old_raster_source_scale &&
       !draw_properties().screen_space_transform_is_animating &&
       !was_screen_space_transform_animating_ &&
       old_raster_source_scale != ideal_source_scale_)
     raster_source_scale_is_fixed_ = true;
 
@@ skipping 307 matching lines @@
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() && IsDrawnRenderSurfaceLayerListMember();
 }
 
 }  // namespace cc