cc: Stop locking the raster scale factor at 1 after any 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 <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 1154 matching lines @@
   // 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());
 
-  // Now move the ideal scale to 0.5. Our target stays 1.2.
+  // Now move the ideal scale to 0.5.
   SetContentsScaleOnBothLayers(0.5f, 1.f, page_scale, 1.f, 0.f, false);
+  ASSERT_EQ(6u, active_layer_->tilings()->num_tilings());
 
-  // 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.
+  // And begin an animation to 1.2. There are now 3 tilings, 0.5, 1.0 and 1.2.
+  // The the 0.5 is ideal, but the 1.2 is high res. 1.0 sits between them.
+  // high-res tiling is in the middle. There are also ex-low-res tilings paired
+  // with each of the 3 tilings mentioned here, but since we're animating none

[enne (OOO), 2015/11/24 22:05:30]

Maybe offtopic, but do we really need these low res tilings? Especially like the
1.2 one, shouldn't the 1.0 low res tiling be plenty ok (and maybe even the 0.5
one ok for all of them)?

This wasn't a problem really in the past, but now that we change the scale more
often, this seems like it'd be a problem?

[danakj, 2015/11/24 22:06:58]

They get cleaned up by CleanUpTilingsOnActiveLayer when we draw. Notice this
test didn't call that when it changed scale to 0.5 and back.

So I think we should clean up reasonably because we will draw for each scale
change in practice (for each commit).

+  // are marked as LOW_RESOLUTION.
+  SetContentsScaleOnBothLayers(0.5, 1.f, page_scale, 1.2f, 0.f, true);
+  ASSERT_EQ(6u, active_layer_->tilings()->num_tilings());
+  EXPECT_EQ(HIGH_RESOLUTION,
+            active_layer_->tilings()->tiling_at(0)->resolution());
+  EXPECT_EQ(1.2f,  // High-res, though not the ideal scale.
+            active_layer_->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_EQ(1.f,  // Tiling in the middle attack.
+            active_layer_->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_EQ(0.5f,  // Ideal scale, but not considered high-res.
+            active_layer_->tilings()->tiling_at(2)->contents_scale());
+
+  EXPECT_EQ(NON_IDEAL_RESOLUTION,
+            active_layer_->tilings()->tiling_at(1)->resolution());
+  EXPECT_EQ(NON_IDEAL_RESOLUTION,
+            active_layer_->tilings()->tiling_at(2)->resolution());
+  EXPECT_EQ(NON_IDEAL_RESOLUTION,
+            active_layer_->tilings()->tiling_at(3)->resolution());
+  EXPECT_EQ(NON_IDEAL_RESOLUTION,
+            active_layer_->tilings()->tiling_at(4)->resolution());
+  EXPECT_EQ(NON_IDEAL_RESOLUTION,
+            active_layer_->tilings()->tiling_at(5)->resolution());
+
+  EXPECT_EQ(1.2f * low_res_factor,  // Low-res, paired with current high-res.
+            active_layer_->tilings()->tiling_at(3)->contents_scale());

[vmpstr, 2015/11/24 22:14:40]

Out of curiosity, why is the low res pair of the HIGH_RESOLUTION tiling not
marked LOW_RESOLUTION? Are we in an animation here?

[danakj, 2015/11/24 22:16:20]

Right, the true on line 1184 is animation. The comment on 1182 tries to explain
this.

+  EXPECT_EQ(1.f * low_res_factor,  // Ex-low-res, paired with the middle one.
+            active_layer_->tilings()->tiling_at(4)->contents_scale());
+  EXPECT_EQ(0.5f * low_res_factor,  // Ex-low-res, paired with current ideal.
+            active_layer_->tilings()->tiling_at(5)->contents_scale());
+
+  // The high resolution tiling is between target and ideal, so is not removed.
+  // The ex-low-res tilings are all smaller scale, so they are removed.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
 
-  // 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);
+  // Now move the ideal scale to 1.0 on the active layer. The high-res tiling
+  // stays 1.2.
+  SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, page_scale, 1.2f,
+                                    0.f, true);
 
   // All the tilings are between are target and the ideal, so they are not
-  // removed.
+  // Because the pending layer's ideal scale is still 0.5, all tilings fall
+  // in the range [0.5,1.2] and are kept.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
 
-  // 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,
+  // Move the ideal scale on the pending layer to 1.0 as well. Our high-res
+  // stays 1.2 still.
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 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.
+  // Our 0.5 tiling now falls outside the range between our ideal scale and our
+  // high-res 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(2));
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
 
-  // 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());
-
   // 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());
 }
 
 TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
   // Make sure this layer covers multiple tiles, since otherwise low
   // res won't get created because it is too small.
@@ skipping 796 matching lines @@
 
 TEST_F(PictureLayerImplTest,
        HighResAndIdealResTileIsCompleteWhenRasterScaleIsNotIdeal) {
   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);
+
+  // Start with an ideal and raster contents scale of 2.
   SetInitialDeviceScaleFactor(2.f);
-
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   // 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.
-  SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, 0.f,
-                                    false);
+  // Due to the animation, the raster contents scale moves to 1, while the
+  // ideal will still be 2.
   SetupDrawPropertiesAndUpdateTiles(active_layer_, 2.f, 1.f, 1.f, 1.f, 0.f,
-                                    false);
+                                    true);
 
   EXPECT_EQ(1.f, active_layer_->HighResTiling()->contents_scale());
   EXPECT_EQ(1.f, active_layer_->raster_contents_scale());
   EXPECT_EQ(2.f, active_layer_->ideal_contents_scale());
 
   // Both tilings still exist.
+  ASSERT_GE(active_layer_->tilings()->num_tilings(), 2u);
   EXPECT_EQ(2.f, active_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_EQ(1.f, active_layer_->tilings()->tiling_at(1)->contents_scale());
 
   // All high res tiles have resources.
   std::vector<Tile*> high_tiles =
       active_layer_->HighResTiling()->AllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(high_tiles);
 
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
@@ skipping 1250 matching lines @@
   float page_scale = 1.f;
   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.
+  // Changing the source scale without being in an animation should be
+  // immediately honored.
   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.
+  // Further changes to the source scale will continue to be honored.
   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);
 }
 
 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 349 matching lines @@
 
   // 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));
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
 
-  // Now move the ideal scale to 0.5. Our target stays 1.2.
+  // Now move the ideal scale to 0.5.
   SetContentsScaleOnBothLayers(0.5f, device_scale, page_scale, 1.f, 0.f, false);
+  ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
+
+  // And begin an animation to 1.2. There are now 3 tilings, 0.5, 1.0 and 1.2.
+  // The the 0.5 is ideal, but the 1.2 is high res. 1.0 sits between them.
+  // high-res tiling is in the middle.
+  SetContentsScaleOnBothLayers(0.5, device_scale, page_scale, 1.2f, 0.f, true);
+  EXPECT_EQ(HIGH_RESOLUTION,
+            active_layer_->tilings()->tiling_at(0)->resolution());
+  EXPECT_EQ(1.2f,  // High-res, though not the ideal scale.
+            active_layer_->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_EQ(1.f,  // Tiling in the middle attack.
+            active_layer_->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_EQ(0.5f,  // Ideal scale, but not considered high-res.
+            active_layer_->tilings()->tiling_at(2)->contents_scale());
 
   // 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(2u, active_layer_->tilings()->num_tilings());
-
-  // Now move the ideal scale to 1.0. Our target stays 1.2.
-  SetContentsScaleOnBothLayers(1.f, device_scale, 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(2u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
 
-  // Now move the ideal scale to 1.1 on the active layer. Our target stays 1.2.
-  SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.1f, device_scale,
+  // Now move the ideal scale to 1.0 on the active layer. The high-res tiling
+  // stays 1.2.
+  SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, device_scale,
+                                    page_scale, 1.2f, 0.f, true);
+
+  // Because the pending layer's ideal scale is still 0.5, all tilings fall
+  // in the range [0.5,1.2] and are kept.
+  used_tilings.clear();
+  active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
+  ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
+
+  // Move the ideal scale on the pending layer to 1.0 as well. Our high-res
+  // stays 1.2 still.
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, device_scale,
                                     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(2u, active_layer_->tilings()->num_tilings());
-
-  // Move the ideal scale on the pending layer to 1.1 as well. Our target stays
-  // 1.2 still.
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.1f, device_scale,
-                                    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
+  // Our 0.5 tiling now falls outside the range between our ideal scale and our
+  // high-res 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));
+  used_tilings.push_back(active_layer_->tilings()->tiling_at(2));
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
-  ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
 
   // 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(1u, active_layer_->tilings()->num_tilings());
+  ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
 }
 
 TEST_F(NoLowResPictureLayerImplTest, ReleaseResources) {
   gfx::Size layer_bounds(1300, 1900);
   SetupDefaultTrees(layer_bounds);
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
   EXPECT_EQ(1u, active_layer_->tilings()->num_tilings());
 
   // All tilings should be removed when losing output surface.
   active_layer_->ReleaseResources();
@@ skipping 1275 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