cc: Remove fixed raster scale, stop rasterizing with will-change.

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 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 <stddef.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 907 matching lines @@
 
   std::vector<PictureLayerTiling*> used_tilings;
 
   float low_res_factor = host_impl()->settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
   float scale = 1.f;
   float page_scale = 1.f;
 
   SetupDefaultTrees(layer_bounds);
-  EXPECT_EQ(2u, active_layer()->tilings()->num_tilings());
-  EXPECT_EQ(1.f, active_layer()->HighResTiling()->contents_scale());
+  active_layer()->SetHasWillChangeTransformHint(true);
+  EXPECT_FLOAT_EQ(2u, active_layer()->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(1.f,
+                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(1.f * low_res_factor,
+                  active_layer()->tilings()->tiling_at(1)->contents_scale());
 
   // Ensure UpdateTiles won't remove any tilings. Note this is unrelated to
   // |used_tilings| variable, and it's here only to ensure that active_layer()
   // won't remove tilings before the test has a chance to verify behavior.
   active_layer()->MarkAllTilingsUsed();
 
   // We only have ideal tilings, so they aren't removed.
   used_tilings.clear();
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
-  EXPECT_EQ(2u, active_layer()->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(2u, active_layer()->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(1.f,
+                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(1.f * low_res_factor,
+                  active_layer()->tilings()->tiling_at(1)->contents_scale());
 
   host_impl()->PinchGestureBegin();
 
   // Changing the ideal but not creating new tilings.
   scale = 1.5f;
   page_scale = 1.5f;
   SetContentsScaleOnBothLayers(scale, 1.f, page_scale, 1.f, 0.f, false);
-  EXPECT_EQ(2u, active_layer()->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(2u, active_layer()->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(1.f,
+                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(1.f * low_res_factor,
+                  active_layer()->tilings()->tiling_at(1)->contents_scale());
 
   // The tilings are still our target scale, so they aren't removed.
   used_tilings.clear();
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer()->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(1.f,
+                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(1.f * low_res_factor,
+                  active_layer()->tilings()->tiling_at(1)->contents_scale());
 
   host_impl()->PinchGestureEnd();
 
   // Create a 1.2 scale tiling. Now we have 1.0 and 1.2 tilings. Ideal = 1.2.
   scale = 1.2f;
   page_scale = 1.2f;
   SetContentsScaleOnBothLayers(1.2f, 1.f, page_scale, 1.f, 0.f, false);
   ASSERT_EQ(4u, active_layer()->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(1.2f,
+                  active_layer()->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(1.f,
                   active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_FLOAT_EQ(1.2f * low_res_factor,
+                  active_layer()->tilings()->tiling_at(2)->contents_scale());
   EXPECT_FLOAT_EQ(1.f * low_res_factor,
                   active_layer()->tilings()->tiling_at(3)->contents_scale());
 
   // Ensure UpdateTiles won't remove any tilings.
   active_layer()->MarkAllTilingsUsed();
 
   // Mark the non-ideal tilings as used. They won't be removed.
   used_tilings.clear();
   used_tilings.push_back(active_layer()->tilings()->tiling_at(1));
   used_tilings.push_back(active_layer()->tilings()->tiling_at(3));
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(4u, active_layer()->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(1.2f,
+                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(1.f,
+                  active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_FLOAT_EQ(1.2f * low_res_factor,
+                  active_layer()->tilings()->tiling_at(2)->contents_scale());
+  EXPECT_FLOAT_EQ(1.f * low_res_factor,
+                  active_layer()->tilings()->tiling_at(3)->contents_scale());
 
   // Now move the ideal scale to 0.5. Our target stays 1.2.
   SetContentsScaleOnBothLayers(0.5f, 1.f, page_scale, 1.f, 0.f, false);
 
   // The high resolution tiling is between target and ideal, so is not
   // removed.  The low res tiling for the old ideal=1.0 scale is removed.
   used_tilings.clear();
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer()->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(1.2f,
+                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(1.f,
+                  active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_FLOAT_EQ(1.2f * low_res_factor,
+                  active_layer()->tilings()->tiling_at(2)->contents_scale());
 
   // Now move the ideal scale to 1.0. Our target stays 1.2.
   SetContentsScaleOnBothLayers(1.f, 1.f, page_scale, 1.f, 0.f, false);
 
   // All the tilings are between are target and the ideal, so they are not
   // removed.
   used_tilings.clear();
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer()->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(1.2f,
+                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(1.f,
+                  active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_FLOAT_EQ(1.2f * low_res_factor,
+                  active_layer()->tilings()->tiling_at(2)->contents_scale());
 
   // Now move the ideal scale to 1.1 on the active layer. Our target stays 1.2.
   SetupDrawPropertiesAndUpdateTiles(active_layer(), 1.1f, 1.f, page_scale, 1.f,
                                     0.f, false);
 
   // Because the pending layer's ideal scale is still 1.0, our tilings fall
   // in the range [1.0,1.2] and are kept.
   used_tilings.clear();
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer()->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(1.2f,
+                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(1.f,
+                  active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_FLOAT_EQ(1.2f * low_res_factor,
+                  active_layer()->tilings()->tiling_at(2)->contents_scale());
 
   // Move the ideal scale on the pending layer to 1.1 as well. Our target stays
   // 1.2 still.
   SetupDrawPropertiesAndUpdateTiles(pending_layer(), 1.1f, 1.f, page_scale, 1.f,
                                     0.f, false);
 
   // Our 1.0 tiling now falls outside the range between our ideal scale and our
   // target raster scale. But it is in our used tilings set, so nothing is
   // deleted.
   used_tilings.clear();
   used_tilings.push_back(active_layer()->tilings()->tiling_at(1));
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer()->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(1.2f,
+                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(1.f,
+                  active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_FLOAT_EQ(1.2f * low_res_factor,
+                  active_layer()->tilings()->tiling_at(2)->contents_scale());
 
   // If we remove it from our used tilings set, it is outside the range to keep
   // so it is deleted.
   used_tilings.clear();
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer()->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(1.2f,
+                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(1.2 * low_res_factor,
+                  active_layer()->tilings()->tiling_at(1)->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
   // Make sure this layer covers multiple tiles, since otherwise low
   // res won't get created because it is too small.
   gfx::Size tile_size(host_impl()->settings().default_tile_size);
   // Avoid max untiled layer size heuristics via fixed tile size.
   gfx::Size layer_bounds(tile_size.width() + 1, tile_size.height() + 1);
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
@@ skipping 790 matching lines @@
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
   gfx::Size viewport_size(400, 400);
 
   host_impl()->SetViewportSize(viewport_size);
   SetInitialDeviceScaleFactor(2.f);
 
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
+  active_layer()->SetHasWillChangeTransformHint(true);
 
   // One ideal tile exists, this will get used when drawing.
   std::vector<Tile*> ideal_tiles;
   EXPECT_EQ(2.f, active_layer()->HighResTiling()->contents_scale());
   ideal_tiles.push_back(active_layer()->HighResTiling()->TileAt(0, 0));
   host_impl()->tile_manager()->InitializeTilesWithResourcesForTesting(
       ideal_tiles);
 
   // Due to layer scale throttling, the raster contents scale is changed to 1,
   // while the ideal is still 2.
@@ skipping 1270 matching lines @@
   float maximum_animation_scale = 1.f;
   float starting_animation_scale = 0.f;
   bool animating_transform = false;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
 
   // Changing the source scale without being in an animation will cause
-  // the layer to reset its source scale to 1.f.
+  // the layer to change scale.
   contents_scale = 3.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
 
-  // Further changes to the source scale will no longer be reflected in the
-  // contents scale.
   contents_scale = 0.5f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 0.5f);
+
+  // However, if the layer has a will-change property, then the raster scale
+  // will get fixed at the last value.
+  active_layer()->SetHasWillChangeTransformHint(true);
+  pending_layer()->SetHasWillChangeTransformHint(true);
+
+  contents_scale = 3.f;
+
+  SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
+                               maximum_animation_scale,
+                               starting_animation_scale, animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 0.5f);
+
+  // Further changes to the source scale will no longer be reflected in the
+  // contents scale.
+  contents_scale = 1.f;
+
+  SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
+                               maximum_animation_scale,
+                               starting_animation_scale, animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 0.5f);
+
+  // Disabling the will-change hint will once again make the raster scale update
+  // with the ideal scale.
+  active_layer()->SetHasWillChangeTransformHint(false);
+  pending_layer()->SetHasWillChangeTransformHint(false);
+
+  contents_scale = 3.f;
+
+  SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
+                               maximum_animation_scale,
+                               starting_animation_scale, animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
 }
 
 TEST_F(PictureLayerImplTest, LowResReadyToDrawNotEnoughToActivate) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
   // Make sure pending tree has tiles.
   gfx::Rect invalidation(gfx::Point(50, 50), tile_size);
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, invalidation);
 
@@ skipping 230 matching lines @@
   std::vector<PictureLayerTiling*> used_tilings;
   SetupDefaultTrees(layer_bounds);
 
   float low_res_factor = host_impl()->settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
   float device_scale = 1.7f;
   float page_scale = 3.2f;
   float scale = 1.f;
 
+  active_layer()->SetHasWillChangeTransformHint(true);
   ResetTilingsAndRasterScales();
 
   SetContentsScaleOnBothLayers(scale, device_scale, page_scale, 1.f, 0.f,
                                false);
   ASSERT_EQ(1u, active_layer()->tilings()->num_tilings());
 
   // Ensure UpdateTiles won't remove any tilings. Note this is unrelated to
   // |used_tilings| variable, and it's here only to ensure that active_layer()
   // won't remove tilings before the test has a chance to verify behavior.
   active_layer()->MarkAllTilingsUsed();
@@ skipping 1364 matching lines @@
   // New low res tiling.
   EXPECT_TRUE(tilings->tiling_at(2)->may_contain_low_resolution_tiles());
 
   // This tiling will be high res now, it won't contain low res content since it
   // was all destroyed.
   EXPECT_FALSE(tilings->tiling_at(1)->may_contain_low_resolution_tiles());
 }
 
 }  // namespace
 }  // namespace cc