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;
+
+bool VerifyFixedPrecisionValue(float value) {
+  const base::CheckedNumeric<float> checked_factor = pow(10, kScalePrecision);
+  if (!checked_factor.IsValid())
+    return false;
+
+  base::CheckedNumeric<float> checked_value = value;
+  checked_value *= checked_factor.ValueOrDie();
+  if (!checked_value.IsValid())
+    return false;
+
+  checked_value = floor(checked_value.ValueOrDie());
+  checked_value /= checked_factor.ValueOrDie();
+  return checked_value.IsValid();
+}
+
+float GetFixedPrecisionValue(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);
+  DCHECK(VerifyFixedPrecisionValue(value));
+
+  const float factor = pow(10, kScalePrecision);

[enne (OOO), 2015/08/27 18:08:34]

It is weird to do math with base 10.  Surely there's some more standard way to
do this.

+  value *= factor;
+  value = floor(value);
+  value /= factor;
+  return value;
+}
+
 }  // 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_;
 
-  raster_device_scale_ = ideal_device_scale_;
-  raster_page_scale_ = ideal_page_scale_;
-  raster_source_scale_ = ideal_source_scale_;
-  raster_contents_scale_ = ideal_contents_scale_;
+  // Get fixed precision values to avoid creating extra tilings for scales
+  // which are almost equal.
+  raster_device_scale_ = GetFixedPrecisionValue(ideal_device_scale_);
+  raster_page_scale_ = GetFixedPrecisionValue(ideal_page_scale_);
+  raster_source_scale_ = GetFixedPrecisionValue(ideal_source_scale_);
+  raster_contents_scale_ = GetFixedPrecisionValue(ideal_contents_scale_);

[enne (OOO), 2015/08/27 18:08:34]

Do we really need fixed precision for all of these? I think contents is really
the only important one.

 
   // 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