Rasterize at maximum scale for scale animations on CPU-rasterized layers

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 136 matching lines @@
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_EQ(pile, iter->picture_pile());
     }
   }
 
   void SetContentsScaleOnBothLayers(float contents_scale,
                                     float device_scale_factor,
                                     float page_scale_factor,
+                                    float maximum_animation_scale_factor,
                                     bool animating_transform) {
     float result_scale_x, result_scale_y;
     gfx::Size result_bounds;
-    pending_layer_->CalculateContentsScale(
-        contents_scale,
-        device_scale_factor,
-        page_scale_factor,
-        animating_transform,
-        &result_scale_x,
-        &result_scale_y,
-        &result_bounds);
-    active_layer_->CalculateContentsScale(
-        contents_scale,
-        device_scale_factor,
-        page_scale_factor,
-        animating_transform,
-        &result_scale_x,
-        &result_scale_y,
-        &result_bounds);
+    pending_layer_->CalculateContentsScale(contents_scale,
+                                           device_scale_factor,
+                                           page_scale_factor,
+                                           maximum_animation_scale_factor,
+                                           animating_transform,
+                                           &result_scale_x,
+                                           &result_scale_y,
+                                           &result_bounds);
+    active_layer_->CalculateContentsScale(contents_scale,
+                                          device_scale_factor,
+                                          page_scale_factor,
+                                          maximum_animation_scale_factor,
+                                          animating_transform,
+                                          &result_scale_x,
+                                          &result_scale_y,
+                                          &result_bounds);
   }
 
   void ResetTilingsAndRasterScales() {
     pending_layer_->ReleaseResources();
     active_layer_->ReleaseResources();
   }
 
   void AssertAllTilesRequired(PictureLayerTiling* tiling) {
     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
     for (size_t i = 0; i < tiles.size(); ++i)
@@ skipping 18 matching lines @@
 
     scoped_refptr<FakePicturePileImpl> pending_pile =
         FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
     scoped_refptr<FakePicturePileImpl> active_pile =
         FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
 
     SetupTrees(pending_pile, active_pile);
 
     float result_scale_x, result_scale_y;
     gfx::Size result_bounds;
-    active_layer_->CalculateContentsScale(
-        1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
+    active_layer_->CalculateContentsScale(1.f,
+                                          1.f,
+                                          1.f,
+                                          1.f,
+                                          false,
+                                          &result_scale_x,
+                                          &result_scale_y,
+                                          &result_bounds);
 
     // Add 1x1 rects at the centers of each tile, then re-record pile contents
     active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
     std::vector<Tile*> tiles =
         active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
     EXPECT_EQ(16u, tiles.size());
     std::vector<SkRect> rects;
     std::vector<Tile*>::const_iterator tile_iter;
     for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
       gfx::Point tile_center = (*tile_iter)->content_rect().CenterPoint();
@@ skipping 80 matching lines @@
   host_impl_.tile_manager()->GetPairedPictureLayers(&paired_layers);
   EXPECT_EQ(0u, paired_layers.size());
 
   // Update tile priorities will force the layer to register itself.
   float dummy_contents_scale_x;
   float dummy_contents_scale_y;
   gfx::Size dummy_content_bounds;
   active_layer_->CalculateContentsScale(1.f,
                                         1.f,
                                         1.f,
+                                        1.f,
                                         false,
                                         &dummy_contents_scale_x,
                                         &dummy_contents_scale_y,
                                         &dummy_content_bounds);
   active_layer_->UpdateTilePriorities();
   host_impl_.pending_tree()->UpdateDrawProperties();
   pending_layer_->CalculateContentsScale(1.f,
                                          1.f,
                                          1.f,
+                                         1.f,
                                          false,
                                          &dummy_contents_scale_x,
                                          &dummy_contents_scale_y,
                                          &dummy_content_bounds);
   pending_layer_->UpdateTilePriorities();
 
   host_impl_.tile_manager()->GetPairedPictureLayers(&paired_layers);
   EXPECT_EQ(1u, paired_layers.size());
   EXPECT_EQ(active_layer_, paired_layers[0].active_layer);
   EXPECT_EQ(pending_layer_, paired_layers[0].pending_layer);
 
   // Destroy and recreate tile manager.
   host_impl_.DidLoseOutputSurface();
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   host_impl_.InitializeRenderer(
       FakeOutputSurface::Create3d(context.Pass()).PassAs<OutputSurface>());
 
   host_impl_.tile_manager()->GetPairedPictureLayers(&paired_layers);
   EXPECT_EQ(0u, paired_layers.size());
 
   active_layer_->CalculateContentsScale(1.f,
                                         1.f,
                                         1.f,
+                                        1.f,
                                         false,
                                         &dummy_contents_scale_x,
                                         &dummy_contents_scale_y,
                                         &dummy_content_bounds);
   active_layer_->UpdateTilePriorities();
   host_impl_.pending_tree()->UpdateDrawProperties();
   pending_layer_->CalculateContentsScale(1.f,
                                          1.f,
                                          1.f,
+                                         1.f,
                                          false,
                                          &dummy_contents_scale_x,
                                          &dummy_contents_scale_y,
                                          &dummy_content_bounds);
   pending_layer_->UpdateTilePriorities();
 
   host_impl_.tile_manager()->GetPairedPictureLayers(&paired_layers);
   EXPECT_EQ(1u, paired_layers.size());
   EXPECT_EQ(active_layer_, paired_layers[0].active_layer);
   EXPECT_EQ(pending_layer_, paired_layers[0].pending_layer);
@@ skipping 14 matching lines @@
   SetupTrees(pending_pile, active_pile);
 
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
   float dummy_contents_scale_x;
   float dummy_contents_scale_y;
   gfx::Size dummy_content_bounds;
   active_layer_->CalculateContentsScale(1.f,
                                         1.f,
                                         1.f,
+                                        1.f,
                                         false,
                                         &dummy_contents_scale_x,
                                         &dummy_contents_scale_y,
                                         &dummy_content_bounds);
 
   EXPECT_TRUE(host_impl_.manage_tiles_needed());
   active_layer_->UpdateTilePriorities();
   host_impl_.ManageTiles();
   EXPECT_FALSE(host_impl_.manage_tiles_needed());
 
@@ skipping 192 matching lines @@
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupTrees(pending_pile, active_pile);
 
-  pending_layer_->CalculateContentsScale(
-      1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
+  pending_layer_->CalculateContentsScale(1.f,
+                                         1.f,
+                                         1.f,
+                                         1.f,
+                                         false,
+                                         &result_scale_x,
+                                         &result_scale_y,
+                                         &result_bounds);
 
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
   pending_layer_->CalculateContentsScale(1.3f,  // ideal contents scale
                                          1.7f,  // device scale
-                                         3.2f,  // page cale
+                                         3.2f,  // page scale
+                                         1.f,   // maximum animation scale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.3f,
       pending_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.3f * low_res_factor,
       pending_layer_->tilings()->tiling_at(1)->contents_scale());
 
   // If we change the layer's CSS scale factor, then we should not get new
   // tilings.
   pending_layer_->CalculateContentsScale(1.8f,  // ideal contents scale
                                          1.7f,  // device scale
-                                         3.2f,  // page cale
+                                         3.2f,  // page scale
+                                         1.f,   // maximum animation scale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.3f,
       pending_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.3f * low_res_factor,
       pending_layer_->tilings()->tiling_at(1)->contents_scale());
 
   // If we change the page scale factor, then we should get new tilings.
   pending_layer_->CalculateContentsScale(1.8f,  // ideal contents scale
                                          1.7f,  // device scale
-                                         2.2f,  // page cale
+                                         2.2f,  // page scale
+                                         1.f,   // maximum animation scale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   ASSERT_EQ(4u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.8f,
       pending_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.8f * low_res_factor,
       pending_layer_->tilings()->tiling_at(2)->contents_scale());
 
   // If we change the device scale factor, then we should get new tilings.
   pending_layer_->CalculateContentsScale(1.9f,  // ideal contents scale
                                          1.4f,  // device scale
-                                         2.2f,  // page cale
+                                         2.2f,  // page scale
+                                         1.f,   // maximum animation scale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.9f,
       pending_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.9f * low_res_factor,
       pending_layer_->tilings()->tiling_at(3)->contents_scale());
 
   // If we change the device scale factor, but end up at the same total scale
   // factor somehow, then we don't get new tilings.
   pending_layer_->CalculateContentsScale(1.9f,  // ideal contents scale
                                          2.2f,  // device scale
-                                         1.4f,  // page cale
+                                         1.4f,  // page scale
+                                         1.f,   // maximum animation scale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.9f,
       pending_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.9f * low_res_factor,
@@ skipping 12 matching lines @@
   scoped_refptr<FakePicturePileImpl> valid_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
   float high_res_scale = 1.3f;
   float low_res_scale = high_res_scale * low_res_factor;
   float device_scale = 1.7f;
   float page_scale = 3.2f;
+  float maximum_animation_scale = 1.f;
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupPendingTree(valid_pile);
   pending_layer_->CalculateContentsScale(high_res_scale,
                                          device_scale,
                                          page_scale,
+                                         maximum_animation_scale,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(high_res_scale,
                   pending_layer_->HighResTiling()->contents_scale());
   EXPECT_FLOAT_EQ(low_res_scale,
                   pending_layer_->LowResTiling()->contents_scale());
 
   ActivateTree();
   SetupPendingTree(empty_pile);
   pending_layer_->CalculateContentsScale(high_res_scale,
                                          device_scale,
                                          page_scale,
+                                         maximum_animation_scale,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
   ASSERT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   ActivateTree();
   active_layer_->CalculateContentsScale(high_res_scale,
                                         device_scale,
                                         page_scale,
+                                        maximum_animation_scale,
                                         false,
                                         &result_scale_x,
                                         &result_scale_y,
                                         &result_bounds);
   ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
 
   SetupPendingTree(valid_pile);
   pending_layer_->CalculateContentsScale(high_res_scale,
                                          device_scale,
                                          page_scale,
+                                         maximum_animation_scale,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(high_res_scale,
                   pending_layer_->HighResTiling()->contents_scale());
   EXPECT_FLOAT_EQ(low_res_scale,
                   pending_layer_->LowResTiling()->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, ZoomOutCrash) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   // Set up the high and low res tilings before pinch zoom.
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
-  SetContentsScaleOnBothLayers(32.0f, 1.0f, 32.0f, false);
+  SetContentsScaleOnBothLayers(32.0f, 1.0f, 32.0f, 1.0f, false);
   host_impl_.PinchGestureBegin();
-  SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, false);
-  SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, false);
+  SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, 1.0f, false);
+  SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, 1.0f, false);
   EXPECT_EQ(active_layer_->tilings()->NumHighResTilings(), 1);
 }
 
 TEST_F(PictureLayerImplTest, PinchGestureTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   // Set up the high and low res tilings before pinch zoom.
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
-  SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, false);
+  SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, 1.0f, false);
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.0f,
       active_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.0f * low_res_factor,
       active_layer_->tilings()->tiling_at(1)->contents_scale());
 
   // Start a pinch gesture.
   host_impl_.PinchGestureBegin();
 
   // Zoom out by a small amount. We should create a tiling at half
   // the scale (1/kMaxScaleRatioDuringPinch).
-  SetContentsScaleOnBothLayers(0.90f, 1.0f, 0.9f, false);
+  SetContentsScaleOnBothLayers(0.90f, 1.0f, 0.9f, 1.0f, false);
   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.0f,
       active_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       0.5f,
       active_layer_->tilings()->tiling_at(1)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.0f * low_res_factor,
       active_layer_->tilings()->tiling_at(2)->contents_scale());
 
   // Zoom out further, close to our low-res scale factor. We should
   // use that tiling as high-res, and not create a new tiling.
-  SetContentsScaleOnBothLayers(low_res_factor, 1.0f, low_res_factor, false);
+  SetContentsScaleOnBothLayers(
+      low_res_factor, 1.0f, low_res_factor, 1.0f, false);
   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
 
   // Zoom in a lot now. Since we increase by increments of
   // kMaxScaleRatioDuringPinch, this will first use 0.5, then 1.0
   // and then finally create a new tiling at 2.0.
-  SetContentsScaleOnBothLayers(2.1f, 1.0f, 2.1f, false);
+  SetContentsScaleOnBothLayers(2.1f, 1.0f, 2.1f, 1.f, false);
   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
-  SetContentsScaleOnBothLayers(2.1f, 1.0f, 2.1f, false);
+  SetContentsScaleOnBothLayers(2.1f, 1.0f, 2.1f, 1.f, false);
   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
-  SetContentsScaleOnBothLayers(2.1f, 1.0f, 2.1f, false);
+  SetContentsScaleOnBothLayers(2.1f, 1.0f, 2.1f, 1.f, false);
   EXPECT_EQ(4u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       2.0f,
       active_layer_->tilings()->tiling_at(0)->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, CleanUpTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
   std::vector<PictureLayerTiling*> used_tilings;
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   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;
 
-  SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, false);
+  SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, 1.f, false);
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
 
   // We only have ideal tilings, so they aren't removed.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
 
   // Changing the ideal but not creating new tilings.
-  SetContentsScaleOnBothLayers(1.5f, device_scale, page_scale, false);
+  SetContentsScaleOnBothLayers(1.5f, device_scale, page_scale, 1.f, false);
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
 
   // 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());
 
   // Create a 1.2 scale tiling. Now we have 1.0 and 1.2 tilings. Ideal = 1.2.
   page_scale = 1.2f;
-  SetContentsScaleOnBothLayers(1.2f, device_scale, page_scale, false);
+  SetContentsScaleOnBothLayers(1.2f, device_scale, page_scale, 1.f, false);
   ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.f,
       active_layer_->tilings()->tiling_at(1)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.f * low_res_factor,
       active_layer_->tilings()->tiling_at(3)->contents_scale());
 
   // 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.
-  SetContentsScaleOnBothLayers(0.5f, device_scale, page_scale, false);
+  SetContentsScaleOnBothLayers(0.5f, device_scale, page_scale, 1.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());
 
   // Now move the ideal scale to 1.0. Our target stays 1.2.
-  SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, false);
+  SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, 1.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());
 
   // Now move the ideal scale to 1.1 on the active layer. Our target stays 1.2.
   active_layer_->CalculateContentsScale(1.1f,
                                         device_scale,
                                         page_scale,
+                                        1.f,
                                         false,
                                         &result_scale_x,
                                         &result_scale_y,
                                         &result_bounds);
 
   // 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());
 
   // Move the ideal scale on the pending layer to 1.1 as well. Our target stays
   // 1.2 still.
   pending_layer_->CalculateContentsScale(1.1f,
                                          device_scale,
                                          page_scale,
+                                         1.f,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
 
   // 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));
@@ skipping 19 matching lines @@
   gfx::Size tile_size(host_impl_.settings().default_tile_size);
   SetupDefaultTrees(gfx::Size(tile_size.width() + 1, tile_size.height() + 1));
   // Avoid max untiled layer size heuristics via fixed tile size.
   pending_layer_->set_fixed_tile_size(tile_size);
   active_layer_->set_fixed_tile_size(tile_size);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   float contents_scale = 1.f;
   float device_scale = 1.f;
   float page_scale = 1.f;
+  float maximum_animation_scale = 1.f;
   bool animating_transform = true;
 
   // Animating, so don't create low res even if there isn't one already.
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
   EXPECT_BOTH_EQ(num_tilings(), 1u);
 
   // Stop animating, low res gets created.
   animating_transform = false;
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
   EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), low_res_factor);
   EXPECT_BOTH_EQ(num_tilings(), 2u);
 
   // Page scale animation, new high res, but not new low res because animating.
   contents_scale = 2.f;
   page_scale = 2.f;
   animating_transform = true;
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
   EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), low_res_factor);
   EXPECT_BOTH_EQ(num_tilings(), 3u);
 
   // Stop animating, new low res gets created for final page scale.
   animating_transform = false;
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
   EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), 2.f * low_res_factor);
   EXPECT_BOTH_EQ(num_tilings(), 4u);
 }
 
 TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) {
   gfx::Size tile_size(host_impl_.settings().default_tile_size);
   SetupDefaultTrees(tile_size);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   float device_scale = 1.f;
   float page_scale = 1.f;
+  float maximum_animation_scale = 1.f;
   bool animating_transform = false;
 
   // Contents exactly fit on one tile at scale 1, no low res.
   float contents_scale = 1.f;
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
   EXPECT_BOTH_EQ(num_tilings(), 1u);
 
   ResetTilingsAndRasterScales();
 
   // Contents that are smaller than one tile, no low res.
   contents_scale = 0.123f;
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
   EXPECT_BOTH_EQ(num_tilings(), 1u);
 
   ResetTilingsAndRasterScales();
 
   // Any content bounds that would create more than one tile will
   // generate a low res tiling.
   contents_scale = 2.5f;
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
   EXPECT_BOTH_EQ(LowResTiling()->contents_scale(),
                  contents_scale * low_res_factor);
   EXPECT_BOTH_EQ(num_tilings(), 2u);
 
   ResetTilingsAndRasterScales();
 
   // Mask layers dont create low res since they always fit on one tile.
   pending_layer_->SetIsMask(true);
   active_layer_->SetIsMask(true);
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
   EXPECT_BOTH_EQ(num_tilings(), 1u);
 }
 
 TEST_F(PictureLayerImplTest, ReleaseResources) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->CalculateContentsScale(1.3f,  // ideal contents scale
                                          2.7f,  // device scale
-                                         3.2f,  // page cale
+                                         3.2f,  // page scale
+                                         1.f,   // maximum animation scale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
 
   // All tilings should be removed when losing output surface.
   active_layer_->ReleaseResources();
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
   pending_layer_->ReleaseResources();
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   // This should create new tilings.
   pending_layer_->CalculateContentsScale(1.3f,  // ideal contents scale
                                          2.7f,  // device scale
-                                         3.2f,  // page cale
+                                         3.2f,  // page scale
+                                         1.f,   // maximum animation scale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) {
   // The default max tile size is larger than 400x400.
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(5000, 5000);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
-  pending_layer_->CalculateContentsScale(
-      1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
+  pending_layer_->CalculateContentsScale(1.f,
+                                         1.f,
+                                         1.f,
+                                         1.f,
+                                         false,
+                                         &result_scale_x,
+                                         &result_scale_y,
+                                         &result_bounds);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // The default value.
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
             host_impl_.settings().default_tile_size.ToString());
 
   Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
             tile->content_rect().size().ToString());
 
   pending_layer_->ReleaseResources();
 
   // Change the max texture size on the output surface context.
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   context->set_max_texture_size(140);
   host_impl_.DidLoseOutputSurface();
   host_impl_.InitializeRenderer(FakeOutputSurface::Create3d(
       context.Pass()).PassAs<OutputSurface>());
 
-  pending_layer_->CalculateContentsScale(
-      1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
+  pending_layer_->CalculateContentsScale(1.f,
+                                         1.f,
+                                         1.f,
+                                         1.f,
+                                         false,
+                                         &result_scale_x,
+                                         &result_scale_y,
+                                         &result_bounds);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // Verify the tiles are not larger than the context's max texture size.
   tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_GE(140, tile->content_rect().width());
   EXPECT_GE(140, tile->content_rect().height());
 }
 
 TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
   // The default max tile size is larger than 400x400.
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(500, 500);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
-  pending_layer_->CalculateContentsScale(
-      1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
+  pending_layer_->CalculateContentsScale(1.f,
+                                         1.f,
+                                         1.f,
+                                         1.f,
+                                         false,
+                                         &result_scale_x,
+                                         &result_scale_y,
+                                         &result_bounds);
   ASSERT_LE(1u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // The default value. The layer is smaller than this.
   EXPECT_EQ(gfx::Size(512, 512).ToString(),
             host_impl_.settings().max_untiled_layer_size.ToString());
 
   // There should be a single tile since the layer is small.
   PictureLayerTiling* high_res_tiling = pending_layer_->tilings()->tiling_at(0);
   EXPECT_EQ(1u, high_res_tiling->AllTilesForTesting().size());
 
   pending_layer_->ReleaseResources();
 
   // Change the max texture size on the output surface context.
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   context->set_max_texture_size(140);
   host_impl_.DidLoseOutputSurface();
   host_impl_.InitializeRenderer(FakeOutputSurface::Create3d(
       context.Pass()).PassAs<OutputSurface>());
 
-  pending_layer_->CalculateContentsScale(
-      1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
+  pending_layer_->CalculateContentsScale(1.f,
+                                         1.f,
+                                         1.f,
+                                         1.f,
+                                         false,
+                                         &result_scale_x,
+                                         &result_scale_y,
+                                         &result_bounds);
   ASSERT_LE(1u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // There should be more than one tile since the max texture size won't cover
   // the layer.
   high_res_tiling = pending_layer_->tilings()->tiling_at(0);
   EXPECT_LT(1u, high_res_tiling->AllTilesForTesting().size());
 
   // Verify the tiles are not larger than the context's max texture size.
@@ skipping 282 matching lines @@
 TEST_F(PictureLayerImplTest, TilingWithoutGpuRasterization) {
   gfx::Size default_tile_size(host_impl_.settings().default_tile_size);
   gfx::Size layer_bounds(default_tile_size.width() * 4,
                          default_tile_size.height() * 4);
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupDefaultTrees(layer_bounds);
   EXPECT_FALSE(pending_layer_->ShouldUseGpuRasterization());
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
-  pending_layer_->CalculateContentsScale(
-      1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
+  pending_layer_->CalculateContentsScale(1.f,
+                                         1.f,
+                                         1.f,
+                                         1.f,
+                                         false,
+                                         &result_scale_x,
+                                         &result_scale_y,
+                                         &result_bounds);
   // Should have a low-res and a high-res tiling.
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, NoTilingIfDoesNotDrawContent) {
   // Set up layers with tilings.
   SetupDefaultTrees(gfx::Size(10, 10));
-  SetContentsScaleOnBothLayers(1.f, 1.f, 1.f, false);
+  SetContentsScaleOnBothLayers(1.f, 1.f, 1.f, 1.f, false);
   pending_layer_->PushPropertiesTo(active_layer_);
   EXPECT_TRUE(pending_layer_->DrawsContent());
   EXPECT_TRUE(pending_layer_->CanHaveTilings());
   EXPECT_GE(pending_layer_->num_tilings(), 0u);
   EXPECT_GE(active_layer_->num_tilings(), 0u);
 
   // Set content to false, which should make CanHaveTilings return false.
   pending_layer_->SetDrawsContent(false);
   EXPECT_FALSE(pending_layer_->DrawsContent());
   EXPECT_FALSE(pending_layer_->CanHaveTilings());
 
   // No tilings should be pushed to active layer.
   pending_layer_->PushPropertiesTo(active_layer_);
   EXPECT_EQ(0u, active_layer_->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, FirstTilingDuringPinch) {
   SetupDefaultTrees(gfx::Size(10, 10));
   host_impl_.PinchGestureBegin();
   float high_res_scale = 2.3f;
-  SetContentsScaleOnBothLayers(high_res_scale, 1.f, 1.f, false);
+  SetContentsScaleOnBothLayers(high_res_scale, 1.f, 1.f, 1.f, false);
 
   ASSERT_GE(pending_layer_->num_tilings(), 0u);
   EXPECT_FLOAT_EQ(high_res_scale,
                   pending_layer_->HighResTiling()->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, FirstTilingTooSmall) {
   SetupDefaultTrees(gfx::Size(10, 10));
   host_impl_.PinchGestureBegin();
   float high_res_scale = 0.0001f;
   EXPECT_GT(pending_layer_->MinimumContentsScale(), high_res_scale);
 
-  SetContentsScaleOnBothLayers(high_res_scale, 1.f, 1.f, false);
+  SetContentsScaleOnBothLayers(high_res_scale, 1.f, 1.f, 1.f, false);
 
   ASSERT_GE(pending_layer_->num_tilings(), 0u);
   EXPECT_FLOAT_EQ(pending_layer_->MinimumContentsScale(),
                   pending_layer_->HighResTiling()->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, PinchingTooSmall) {
   SetupDefaultTrees(gfx::Size(10, 10));
 
   float contents_scale = 0.15f;
-  SetContentsScaleOnBothLayers(contents_scale, 1.f, 1.f, false);
+  SetContentsScaleOnBothLayers(contents_scale, 1.f, 1.f, 1.f, false);
 
   ASSERT_GE(pending_layer_->num_tilings(), 0u);
   EXPECT_FLOAT_EQ(contents_scale,
                   pending_layer_->HighResTiling()->contents_scale());
 
   host_impl_.PinchGestureBegin();
 
   float page_scale = 0.0001f;
   EXPECT_LT(page_scale * contents_scale,
             pending_layer_->MinimumContentsScale());
 
-
-  SetContentsScaleOnBothLayers(contents_scale, 1.f, page_scale, false);
+  SetContentsScaleOnBothLayers(contents_scale, 1.f, page_scale, 1.f, false);
   ASSERT_GE(pending_layer_->num_tilings(), 0u);
   EXPECT_FLOAT_EQ(pending_layer_->MinimumContentsScale(),
                   pending_layer_->HighResTiling()->contents_scale());
 }
 
 class DeferredInitPictureLayerImplTest : public PictureLayerImplTest {
  public:
   virtual void InitializeRenderer() OVERRIDE {
     host_impl_.InitializeRenderer(FakeOutputSurface::CreateDeferredGL(
         scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice))
@@ skipping 47 matching lines @@
 TEST_F(HybridRasterizationPictureLayerImplTest, Tiling) {
   gfx::Size default_tile_size(host_impl_.settings().default_tile_size);
   gfx::Size layer_bounds(default_tile_size.width() * 4,
                          default_tile_size.height() * 4);
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupDefaultTrees(layer_bounds);
   EXPECT_FALSE(pending_layer_->ShouldUseGpuRasterization());
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
-  pending_layer_->CalculateContentsScale(
-      1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
+  pending_layer_->CalculateContentsScale(1.f,
+                                         1.f,
+                                         1.f,
+                                         1.f,
+                                         false,
+                                         &result_scale_x,
+                                         &result_scale_y,
+                                         &result_bounds);
   // Should have a low-res and a high-res tiling.
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->SetHasGpuRasterizationHint(true);
   EXPECT_TRUE(pending_layer_->ShouldUseGpuRasterization());
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
-  pending_layer_->CalculateContentsScale(
-      1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
+  pending_layer_->CalculateContentsScale(1.f,
+                                         1.f,
+                                         1.f,
+                                         1.f,
+                                         false,
+                                         &result_scale_x,
+                                         &result_scale_y,
+                                         &result_bounds);
   // Should only have the high-res tiling.
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
 }
 
 TEST_F(HybridRasterizationPictureLayerImplTest,
        HighResTilingDuringAnimationForCpuRasterization) {
   gfx::Size tile_size(host_impl_.settings().default_tile_size);
   SetupDefaultTrees(tile_size);
   pending_layer_->SetHasGpuRasterizationHint(false);
   active_layer_->SetHasGpuRasterizationHint(false);
 
   float contents_scale = 1.f;
   float device_scale = 1.f;

[enne (OOO), 2014/04/08 19:18:47]

Can you use a non-1 device and page scale in this test?

   float page_scale = 1.f;
+  float maximum_animation_scale = 1.f;
   bool animating_transform = false;
 
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
 
-  // Changing contents scale shouldn't affect tiling resolution during the
-  // animation, since we're CPU-rasterizing.
+  // Since we're CPU-rasterizing, starting an animation should cause tiling
+  // resolution to get set to the maximum animation scale factor.
   animating_transform = true;
+  maximum_animation_scale = 3.f;
   contents_scale = 2.f;
 
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
+
+  // Further changes to scale during the animation should not cause a new
+  // high-res tiling to get created.
+  contents_scale = 4.f;
+  maximum_animation_scale = 5.f;
+
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
 
   // Once we stop animating, a new high-res tiling should be created.
   animating_transform = false;
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
+
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 4.f);
+
+  // When animating with an unknown maximum animation scale factor, a new
+  // high-res tiling should be created at the animation's initial scale.
+  animating_transform = true;
+  contents_scale = 2.f;
+  maximum_animation_scale = 0.f;
+
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
+
+  // Further changes to scale during the animation should not cause a new
+  // high-res tiling to get created.
+  contents_scale = 3.f;
+
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
+
+  // Once we stop animating, a new high-res tiling should be created.
+  animating_transform = false;
+  contents_scale = 4.f;
+
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 4.f);
 }
 
 TEST_F(HybridRasterizationPictureLayerImplTest,
        HighResTilingDuringAnimationForGpuRasterization) {
   gfx::Size tile_size(host_impl_.settings().default_tile_size);
   SetupDefaultTrees(tile_size);
   pending_layer_->SetHasGpuRasterizationHint(true);
   active_layer_->SetHasGpuRasterizationHint(true);
 
   float contents_scale = 1.f;
   float device_scale = 1.f;
   float page_scale = 1.f;
+  float maximum_animation_scale = 1.f;
   bool animating_transform = false;
 
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
 
   // Changing contents scale during an animation should cause tiling resolution
-  // to change, since we're GPU-rasterizing.
+  // to change, since we're GPU-rasterizing. The maximum animation scale should
+  // not have any effect.
   animating_transform = true;
   contents_scale = 2.f;
+  maximum_animation_scale = 4.f;
 
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
 
   // Since we're re-rasterizing during the animation, scales smaller than 1
   // should be respected.
   contents_scale = 0.5f;
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 0.5f);
 
   // Tiling resolution should also update once we stop animating.
   contents_scale = 4.f;
   animating_transform = false;
-  SetContentsScaleOnBothLayers(
-      contents_scale, device_scale, page_scale, animating_transform);
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 4.f);
 }
 
 class GpuRasterizationPictureLayerImplTest : public PictureLayerImplTest {
  public:
   GpuRasterizationPictureLayerImplTest()
       : PictureLayerImplTest(GpuRasterizationSettings()) {}
 };
 
 TEST_F(GpuRasterizationPictureLayerImplTest, Tiling) {
   gfx::Size default_tile_size(host_impl_.settings().default_tile_size);
   gfx::Size layer_bounds(default_tile_size.width() * 4,
                          default_tile_size.height() * 4);
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupDefaultTrees(layer_bounds);
   pending_layer_->SetHasGpuRasterizationHint(true);
   EXPECT_TRUE(pending_layer_->ShouldUseGpuRasterization());
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
-  pending_layer_->CalculateContentsScale(
-      1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
+  pending_layer_->CalculateContentsScale(1.f,
+                                         1.f,
+                                         1.f,
+                                         1.f,
+                                         false,
+                                         &result_scale_x,
+                                         &result_scale_y,
+                                         &result_bounds);
   // Should only have the high-res tiling.
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->SetHasGpuRasterizationHint(false);
   EXPECT_TRUE(pending_layer_->ShouldUseGpuRasterization());
   // Should still have the high-res tiling.
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
-  pending_layer_->CalculateContentsScale(
-      1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
+  pending_layer_->CalculateContentsScale(1.f,
+                                         1.f,
+                                         1.f,
+                                         1.f,
+                                         false,
+                                         &result_scale_x,
+                                         &result_scale_y,
+                                         &result_bounds);
   // Should still only have the high-res tiling.
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, LayerRasterTileIterator) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
@@ skipping 224 matching lines @@
     EXPECT_FLOAT_EQ(tile->contents_scale(), expected_scales[scale_index]);
     unique_tiles.insert(tile);
   }
 
   EXPECT_TRUE(reached_required);
   EXPECT_EQ(all_tiles_set.size(), unique_tiles.size());
 }
 
 }  // namespace
 }  // namespace cc