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

cc/layers/picture_layer_impl.cc

Index: cc/layers/picture_layer_impl.cc
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index f8aa213a92596eef4bcf8a843933d4c1d6f10da2..747d4d7c9ae14222607420a4f4dfacf5682e267f 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -48,6 +48,12 @@ const int kMinHeightForGpuRasteredTile = 256;
 // of using the same tile size.
 const int kTileRoundUp = 64;
 
+// The precision value for rounding floating points values of scale factors.
+// With this scale factors will be having 3 digits fractional part, which will
+// make almost equal (having smaller difference by some magnitude of floating
+// point epsilon) scale factors to be considered as same.
+const int kScalePrecision = 4;
+
 }  // namespace
 
 namespace cc {
@@ -942,7 +948,10 @@ void PictureLayerImpl::RecalculateRasterScales() {
   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 scale to avoid creating extra tilings for scales
+  // which are almost equal.
+  raster_contents_scale_ =
+      MathUtil::RoundToFixedPrecision(ideal_contents_scale_, kScalePrecision);

[vmpstr, 2015/10/19 18:58:38]

My understanding is that with this, something like 1.004 would become 1.0,
right? (or maybe 1.0004 becomes 1.0). In either case, wouldn't this cause
blurriness? Since 1.0 is actually not the ideal scale, but 1.004 is. I'm not
saying the blurriness would be excessive, but it's probably also not too small
(.004 is 1 pixel in every 250, right?)

Can you fake a pinch scale of 1.004 before and after your patch and have two
screenshots to compare? Something with a lot of text probably would show any
artifacts. I don't know if that's easy to do though...

[prashant.n, 2015/10/20 18:45:24]

We set scale precision as 4. This will give 4 digits in fractional part, IMO,
which is sufficient for distinguishing two scales. e.g. 1.1234. The ideal scale
gets used further as raster contents scale. So there would not occur blurriness.
However I'll check contents with two different scales.

[vmpstr, 2015/10/20 18:55:23]

Yeah you're probably right, but I'd still like to see concrete examples (or at
least some verification). Mostly because it's hard to reason about small float
difference when they affect large layers.

 
   // If we're not animating, or leaving an animation, and the
   // ideal_source_scale_ changes, then things are unpredictable, and we fix