cc: Don't add new tilings while syncing a tiling.

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 122 matching lines @@
     scoped_ptr<FakePictureLayerImpl> pending_layer =
         FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
     pending_layer->SetDrawsContent(true);
     pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
     pending_layer_->DoPostCommitInitializationIfNeeded();
   }
 
-  void SetupDrawPropertiesAndManageTilings(
-      FakePictureLayerImpl* layer,
-      float ideal_contents_scale,
-      float device_scale_factor,
-      float page_scale_factor,
-      float maximum_animation_contents_scale,
-      bool animating_transform_to_screen) {
+  void SetupDrawPropertiesAndUpdateTiles(FakePictureLayerImpl* layer,
+                                         float ideal_contents_scale,
+                                         float device_scale_factor,
+                                         float page_scale_factor,
+                                         float maximum_animation_contents_scale,
+                                         bool animating_transform_to_screen) {
     layer->draw_properties().ideal_contents_scale = ideal_contents_scale;
     layer->draw_properties().device_scale_factor = device_scale_factor;
     layer->draw_properties().page_scale_factor = page_scale_factor;
     layer->draw_properties().maximum_animation_contents_scale =
         maximum_animation_contents_scale;
     layer->draw_properties().screen_space_transform_is_animating =
         animating_transform_to_screen;
-    layer->ScaleAndManageTilings(animating_transform_to_screen,
-                                 maximum_animation_contents_scale);
+    layer->UpdateTiles();
   }
   static void VerifyAllTilesExistAndHavePile(
       const PictureLayerTiling* tiling,
       PicturePileImpl* pile) {
     for (PictureLayerTiling::CoverageIterator iter(
              tiling, tiling->contents_scale(), tiling->TilingRect());
          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_contents_scale,
                                     bool animating_transform) {
-    SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                        contents_scale,
-                                        device_scale_factor,
-                                        page_scale_factor,
-                                        maximum_animation_contents_scale,
-                                        animating_transform);
+    SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                      contents_scale,
+                                      device_scale_factor,
+                                      page_scale_factor,
+                                      maximum_animation_contents_scale,
+                                      animating_transform);
 
-    SetupDrawPropertiesAndManageTilings(active_layer_,
-                                        contents_scale,
-                                        device_scale_factor,
-                                        page_scale_factor,
-                                        maximum_animation_contents_scale,
-                                        animating_transform);
+    SetupDrawPropertiesAndUpdateTiles(active_layer_,
+                                      contents_scale,
+                                      device_scale_factor,
+                                      page_scale_factor,
+                                      maximum_animation_contents_scale,
+                                      animating_transform);
   }
 
   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 16 matching lines @@
         settings.default_tile_size.width() * 7 / 2,
         settings.default_tile_size.height() * 7 / 2);
 
     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);
 
-    SetupDrawPropertiesAndManageTilings(
-        active_layer_, 1.f, 1.f, 1.f, 1.f, false);
+    SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
     // 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 74 matching lines @@
 
   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);
 
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
-  SetupDrawPropertiesAndManageTilings(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
+  SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
-  // UpdateTilePriorities with valid viewport. Should update tile viewport.
+  // UpdateTiles with valid viewport. Should update tile viewport.
   bool valid_for_tile_management = true;
   gfx::Rect viewport = gfx::Rect(layer_bounds);
   gfx::Transform transform;
   host_impl_.SetExternalDrawConstraints(
       transform, viewport, viewport, valid_for_tile_management);
   active_layer_->draw_properties().visible_content_rect = viewport;
   active_layer_->draw_properties().screen_space_transform = transform;
-  active_layer_->UpdateTilePriorities();
+  active_layer_->UpdateTiles();
 
   gfx::Rect visible_rect_for_tile_priority =
       active_layer_->visible_rect_for_tile_priority();
   EXPECT_FALSE(visible_rect_for_tile_priority.IsEmpty());
   gfx::Size viewport_size_for_tile_priority =
       active_layer_->viewport_size_for_tile_priority();
   EXPECT_FALSE(viewport_size_for_tile_priority.IsEmpty());
   gfx::Transform screen_space_transform_for_tile_priority =
       active_layer_->screen_space_transform_for_tile_priority();
 
   // Expand viewport and set it as invalid for prioritizing tiles.
   // Should not update tile viewport.
   time_ticks += base::TimeDelta::FromMilliseconds(200);
   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
   valid_for_tile_management = false;
   viewport = gfx::ScaleToEnclosingRect(viewport, 2);
   transform.Translate(1.f, 1.f);
   active_layer_->draw_properties().visible_content_rect = viewport;
   active_layer_->draw_properties().screen_space_transform = transform;
   host_impl_.SetExternalDrawConstraints(
       transform, viewport, viewport, valid_for_tile_management);
-  active_layer_->UpdateTilePriorities();
+  active_layer_->UpdateTiles();
 
   EXPECT_RECT_EQ(visible_rect_for_tile_priority,
                  active_layer_->visible_rect_for_tile_priority());
   EXPECT_SIZE_EQ(viewport_size_for_tile_priority,
                  active_layer_->viewport_size_for_tile_priority());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       screen_space_transform_for_tile_priority,
       active_layer_->screen_space_transform_for_tile_priority());
 
   // Keep expanded viewport but mark it valid. Should update tile viewport.
   time_ticks += base::TimeDelta::FromMilliseconds(200);
   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
   valid_for_tile_management = true;
   host_impl_.SetExternalDrawConstraints(
       transform, viewport, viewport, valid_for_tile_management);
-  active_layer_->UpdateTilePriorities();
+  active_layer_->UpdateTiles();
 
   EXPECT_FALSE(visible_rect_for_tile_priority ==
                active_layer_->visible_rect_for_tile_priority());
   EXPECT_FALSE(viewport_size_for_tile_priority ==
                active_layer_->viewport_size_for_tile_priority());
   EXPECT_FALSE(screen_space_transform_for_tile_priority ==
                active_layer_->screen_space_transform_for_tile_priority());
 }
 
 TEST_F(PictureLayerImplTest, InvalidViewportAfterReleaseResources) {
@@ skipping 16 matching lines @@
   bool valid_for_tile_management = false;
   gfx::Rect viewport = gfx::Rect(layer_bounds);
   host_impl_.SetExternalDrawConstraints(
       gfx::Transform(), viewport, viewport, valid_for_tile_management);
   ResetTilingsAndRasterScales();
   host_impl_.pending_tree()->UpdateDrawProperties();
   host_impl_.active_tree()->UpdateDrawProperties();
   EXPECT_TRUE(active_layer_->HighResTiling());
 
   size_t num_tilings = active_layer_->num_tilings();
-  active_layer_->UpdateTilePriorities();
+  active_layer_->UpdateTiles();
   pending_layer_->AddTiling(0.5f);
   EXPECT_EQ(num_tilings + 1, active_layer_->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   gfx::Rect layer_invalidation(150, 200, 30, 180);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
@@ skipping 153 matching lines @@
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
 
-  SetupDrawPropertiesAndManageTilings(
-      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
   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);
 
   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);
 
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      6.f,  // ideal contents scale
-                                      3.f,  // device scale
-                                      2.f,  // page scale
-                                      1.f,  // maximum animation scale
-                                      false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    6.f,  // ideal contents scale
+                                    3.f,  // device scale
+                                    2.f,  // page scale
+                                    1.f,  // maximum animation scale
+                                    false);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(6.f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(6.f * low_res_factor,
                   pending_layer_->tilings()->tiling_at(1)->contents_scale());
 
   // If we change the page scale factor, then we should get new tilings.
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      6.6f,  // ideal contents scale
-                                      3.f,   // device scale
-                                      2.2f,  // page scale
-                                      1.f,   // maximum animation scale
-                                      false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    6.6f,  // ideal contents scale
+                                    3.f,   // device scale
+                                    2.2f,  // page scale
+                                    1.f,   // maximum animation scale
+                                    false);
   ASSERT_EQ(4u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(6.6f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(6.6f * low_res_factor,
                   pending_layer_->tilings()->tiling_at(2)->contents_scale());
 
   // If we change the device scale factor, then we should get new tilings.
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      7.26f,  // ideal contents scale
-                                      3.3f,   // device scale
-                                      2.2f,   // page scale
-                                      1.f,    // maximum animation scale
-                                      false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    7.26f,  // ideal contents scale
+                                    3.3f,   // device scale
+                                    2.2f,   // page scale
+                                    1.f,    // maximum animation scale
+                                    false);
   ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(7.26f * 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.
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      7.26f,  // ideal contents scale
-                                      2.2f,   // device scale
-                                      3.3f,   // page scale
-                                      1.f,    // maximum animation scale
-                                      false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    7.26f,  // ideal contents scale
+                                    2.2f,   // device scale
+                                    3.3f,   // page scale
+                                    1.f,    // maximum animation scale
+                                    false);
   ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(7.26f * low_res_factor,
                   pending_layer_->tilings()->tiling_at(3)->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) {
   // This test makes sure that if a layer can have tilings, then a commit makes
   // it not able to have tilings (empty size), and then a future commit that
   // makes it valid again should be able to create tilings.
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> empty_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
   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;
 
   SetupPendingTree(valid_pile);
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      high_res_scale,
-                                      device_scale,
-                                      page_scale,
-                                      maximum_animation_scale,
-                                      false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    high_res_scale,
+                                    device_scale,
+                                    page_scale,
+                                    maximum_animation_scale,
+                                    false);
   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);
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      high_res_scale,
-                                      device_scale,
-                                      page_scale,
-                                      maximum_animation_scale,
-                                      false);
+  EXPECT_FALSE(pending_layer_->CanHaveTilings());
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    high_res_scale,
+                                    device_scale,
+                                    page_scale,
+                                    maximum_animation_scale,
+                                    false);
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
   ASSERT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   ActivateTree();
-  SetupDrawPropertiesAndManageTilings(active_layer_,
-                                      high_res_scale,
-                                      device_scale,
-                                      page_scale,
-                                      maximum_animation_scale,
-                                      false);
+  EXPECT_FALSE(active_layer_->CanHaveTilings());
+  SetupDrawPropertiesAndUpdateTiles(active_layer_,
+                                    high_res_scale,
+                                    device_scale,
+                                    page_scale,
+                                    maximum_animation_scale,
+                                    false);
   ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
 
   SetupPendingTree(valid_pile);
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      high_res_scale,
-                                      device_scale,
-                                      page_scale,
-                                      maximum_animation_scale,
-                                      false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    high_res_scale,
+                                    device_scale,
+                                    page_scale,
+                                    maximum_animation_scale,
+                                    false);
   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);
@@ skipping 186 matching lines @@
   // Now move the ideal scale to 1.0. Our target stays 1.2.
   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.
-  SetupDrawPropertiesAndManageTilings(
+  SetupDrawPropertiesAndUpdateTiles(
       active_layer_, 1.1f, device_scale, page_scale, 1.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());
 
   // Move the ideal scale on the pending layer to 1.1 as well. Our target stays
   // 1.2 still.
-  SetupDrawPropertiesAndManageTilings(
+  SetupDrawPropertiesAndUpdateTiles(
       pending_layer_, 1.1f, device_scale, page_scale, 1.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());
 
@@ skipping 137 matching lines @@
   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);
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      1.3f,  // ideal contents scale
-                                      2.7f,  // device scale
-                                      3.2f,  // page scale
-                                      1.f,   // maximum animation scale
-                                      false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    1.3f,  // ideal contents scale
+                                    2.7f,  // device scale
+                                    3.2f,  // page scale
+                                    1.f,   // maximum animation scale
+                                    false);
   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.
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      1.3f,  // ideal contents scale
-                                      2.7f,  // device scale
-                                      3.2f,  // page scale
-                                      1.f,   // maximum animation scale
-                                      false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    1.3f,  // ideal contents scale
+                                    2.7f,  // device scale
+                                    3.2f,  // page scale
+                                    1.f,   // maximum animation scale
+                                    false);
   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);
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
-  SetupDrawPropertiesAndManageTilings(
-      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   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>());
 
-  SetupDrawPropertiesAndManageTilings(
-      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   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);
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
-  SetupDrawPropertiesAndManageTilings(
-      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   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>());
 
-  SetupDrawPropertiesAndManageTilings(
-      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   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 374 matching lines @@
   host_impl_.SetUseGpuRasterization(false);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, HighResCreatedWhenBoundsShrink) {
   SetupDefaultTrees(gfx::Size(10, 10));
   host_impl_.active_tree()->UpdateDrawProperties();
   EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties());
 
-  SetupDrawPropertiesAndManageTilings(
+  SetupDrawPropertiesAndUpdateTiles(
       active_layer_, 0.5f, 0.5f, 0.5f, 0.5f, false);
   active_layer_->tilings()->RemoveAllTilings();
   PictureLayerTiling* tiling = active_layer_->tilings()->AddTiling(0.5f);
   active_layer_->tilings()->AddTiling(1.5f);
   active_layer_->tilings()->AddTiling(0.25f);
   tiling->set_resolution(HIGH_RESOLUTION);
 
   // Sanity checks.
   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
   ASSERT_EQ(tiling, active_layer_->tilings()->TilingAtScale(0.5f));
@@ skipping 27 matching lines @@
 }
 
 TEST_F(PictureLayerImplTest, NoLowResTilingWithGpuRasterization) {
   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);
 
   SetupDefaultTrees(layer_bounds);
   EXPECT_FALSE(host_impl_.use_gpu_rasterization());
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
-  SetupDrawPropertiesAndManageTilings(
-      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   // Should have a low-res and a high-res tiling.
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
 
   ResetTilingsAndRasterScales();
 
   host_impl_.SetUseGpuRasterization(true);
   EXPECT_TRUE(host_impl_.use_gpu_rasterization());
-  SetupDrawPropertiesAndManageTilings(
-      pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
   // Should only have the high-res tiling.
   ASSERT_EQ(1u, 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, 1.f, false);
   pending_layer_->PushPropertiesTo(active_layer_);
@@ skipping 81 matching lines @@
         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
     SetupTrees(pending_pile, active_pile);
   }
 };
 
 // This test is really a LayerTreeHostImpl test, in that it makes sure
 // that trees need update draw properties after deferred initialization.
 // However, this is also a regression test for PictureLayerImpl in that
 // not having this update will cause a crash.
-TEST_F(DeferredInitPictureLayerImplTest,
-       PreventUpdateTilePrioritiesDuringLostContext) {
+TEST_F(DeferredInitPictureLayerImplTest, PreventUpdateTilesDuringLostContext) {
   host_impl_.pending_tree()->UpdateDrawProperties();
   host_impl_.active_tree()->UpdateDrawProperties();
   EXPECT_FALSE(host_impl_.pending_tree()->needs_update_draw_properties());
   EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties());
 
   FakeOutputSurface* fake_output_surface =
       static_cast<FakeOutputSurface*>(host_impl_.output_surface());
   ASSERT_TRUE(fake_output_surface->InitializeAndSetContext3d(
       TestContextProvider::Create()));
 
@@ skipping 509 matching lines @@
       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, pending_layer_->tilings()->num_tilings());
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      6.f,  // ideal contents scale
-                                      3.f,  // device scale
-                                      2.f,  // page scale
-                                      1.f,  // maximum animation scale
-                                      false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    6.f,  // ideal contents scale
+                                    3.f,  // device scale
+                                    2.f,  // page scale
+                                    1.f,  // maximum animation scale
+                                    false);
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(6.f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 
   // If we change the page scale factor, then we should get new tilings.
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      6.6f,  // ideal contents scale
-                                      3.f,   // device scale
-                                      2.2f,  // page scale
-                                      1.f,   // maximum animation scale
-                                      false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    6.6f,  // ideal contents scale
+                                    3.f,   // device scale
+                                    2.2f,  // page scale
+                                    1.f,   // maximum animation scale
+                                    false);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(6.6f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 
   // If we change the device scale factor, then we should get new tilings.
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      7.26f,  // ideal contents scale
-                                      3.3f,   // device scale
-                                      2.2f,   // page scale
-                                      1.f,    // maximum animation scale
-                                      false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    7.26f,  // ideal contents scale
+                                    3.3f,   // device scale
+                                    2.2f,   // page scale
+                                    1.f,    // maximum animation scale
+                                    false);
   ASSERT_EQ(3u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   pending_layer_->tilings()->tiling_at(0)->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.
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      7.26f,  // ideal contents scale
-                                      2.2f,   // device scale
-                                      3.3f,   // page scale
-                                      1.f,    // maximum animation scale
-                                      false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    7.26f,  // ideal contents scale
+                                    2.2f,   // device scale
+                                    3.3f,   // page scale
+                                    1.f,    // maximum animation scale
+                                    false);
   ASSERT_EQ(3u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 }
 
 TEST_F(NoLowResPictureLayerImplTest, MarkRequiredNullTiles) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
@@ skipping 74 matching lines @@
 
   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);
 
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
-  SetupDrawPropertiesAndManageTilings(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
+  SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
-  // UpdateTilePriorities with valid viewport. Should update tile viewport.
+  // UpdateTiles with valid viewport. Should update tile viewport.
   bool valid_for_tile_management = true;
   gfx::Rect viewport = gfx::Rect(layer_bounds);
   gfx::Transform transform;
   host_impl_.SetExternalDrawConstraints(
       transform, viewport, viewport, valid_for_tile_management);
   active_layer_->draw_properties().visible_content_rect = viewport;
   active_layer_->draw_properties().screen_space_transform = transform;
-  active_layer_->UpdateTilePriorities();
+  active_layer_->UpdateTiles();
 
   gfx::Rect visible_rect_for_tile_priority =
       active_layer_->visible_rect_for_tile_priority();
   EXPECT_FALSE(visible_rect_for_tile_priority.IsEmpty());
   gfx::Size viewport_size_for_tile_priority =
       active_layer_->viewport_size_for_tile_priority();
   EXPECT_FALSE(viewport_size_for_tile_priority.IsEmpty());
   gfx::Transform screen_space_transform_for_tile_priority =
       active_layer_->screen_space_transform_for_tile_priority();
 
   // Expand viewport and set it as invalid for prioritizing tiles.
   // Should not update tile viewport.
   time_ticks += base::TimeDelta::FromMilliseconds(200);
   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
   valid_for_tile_management = false;
   viewport = gfx::ScaleToEnclosingRect(viewport, 2);
   transform.Translate(1.f, 1.f);
   active_layer_->draw_properties().visible_content_rect = viewport;
   active_layer_->draw_properties().screen_space_transform = transform;
   host_impl_.SetExternalDrawConstraints(
       transform, viewport, viewport, valid_for_tile_management);
-  active_layer_->UpdateTilePriorities();
+  active_layer_->UpdateTiles();
 
   EXPECT_RECT_EQ(visible_rect_for_tile_priority,
                  active_layer_->visible_rect_for_tile_priority());
   EXPECT_SIZE_EQ(viewport_size_for_tile_priority,
                  active_layer_->viewport_size_for_tile_priority());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       screen_space_transform_for_tile_priority,
       active_layer_->screen_space_transform_for_tile_priority());
 
   // Keep expanded viewport but mark it valid. Should update tile viewport.
   time_ticks += base::TimeDelta::FromMilliseconds(200);
   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
   valid_for_tile_management = true;
   host_impl_.SetExternalDrawConstraints(
       transform, viewport, viewport, valid_for_tile_management);
-  active_layer_->UpdateTilePriorities();
+  active_layer_->UpdateTiles();
 
   EXPECT_FALSE(visible_rect_for_tile_priority ==
                active_layer_->visible_rect_for_tile_priority());
   EXPECT_FALSE(viewport_size_for_tile_priority ==
                active_layer_->viewport_size_for_tile_priority());
   EXPECT_FALSE(screen_space_transform_for_tile_priority ==
                active_layer_->screen_space_transform_for_tile_priority());
 }
 
 TEST_F(NoLowResPictureLayerImplTest, InvalidViewportAfterReleaseResources) {
@@ skipping 16 matching lines @@
   bool valid_for_tile_management = false;
   gfx::Rect viewport = gfx::Rect(layer_bounds);
   host_impl_.SetExternalDrawConstraints(
       gfx::Transform(), viewport, viewport, valid_for_tile_management);
   ResetTilingsAndRasterScales();
   host_impl_.pending_tree()->UpdateDrawProperties();
   host_impl_.active_tree()->UpdateDrawProperties();
   EXPECT_TRUE(active_layer_->HighResTiling());
 
   size_t num_tilings = active_layer_->num_tilings();
-  active_layer_->UpdateTilePriorities();
+  active_layer_->UpdateTiles();
   pending_layer_->AddTiling(0.5f);
   EXPECT_EQ(num_tilings + 1, active_layer_->num_tilings());
 }
 
 TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
@@ skipping 61 matching lines @@
   // Now move the ideal scale to 1.0. Our target stays 1.2.
   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(2u, active_layer_->tilings()->num_tilings());
 
   // Now move the ideal scale to 1.1 on the active layer. Our target stays 1.2.
-  SetupDrawPropertiesAndManageTilings(
+  SetupDrawPropertiesAndUpdateTiles(
       active_layer_, 1.1f, device_scale, page_scale, 1.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.
-  SetupDrawPropertiesAndManageTilings(
+  SetupDrawPropertiesAndUpdateTiles(
       pending_layer_, 1.1f, device_scale, page_scale, 1.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(2u, active_layer_->tilings()->num_tilings());
 
@@ skipping 21 matching lines @@
   float active_contents_scale = 2.f;
   float device_scale_factor = 1.f;
   float page_scale_factor = 1.f;
   float maximum_animation_contents_scale = 1.f;
   bool animating_transform = false;
 
   EXPECT_TRUE(host_impl_.settings().create_low_res_tiling);
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      pending_contents_scale,
-                                      device_scale_factor,
-                                      page_scale_factor,
-                                      maximum_animation_contents_scale,
-                                      animating_transform);
-  SetupDrawPropertiesAndManageTilings(active_layer_,
-                                      active_contents_scale,
-                                      device_scale_factor,
-                                      page_scale_factor,
-                                      maximum_animation_contents_scale,
-                                      animating_transform);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    pending_contents_scale,
+                                    device_scale_factor,
+                                    page_scale_factor,
+                                    maximum_animation_contents_scale,
+                                    animating_transform);
+  SetupDrawPropertiesAndUpdateTiles(active_layer_,
+                                    active_contents_scale,
+                                    device_scale_factor,
+                                    page_scale_factor,
+                                    maximum_animation_contents_scale,
+                                    animating_transform);
 
   ASSERT_EQ(4u, pending_layer_->tilings()->num_tilings());
   ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
 
   EXPECT_EQ(active_contents_scale,
             pending_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_EQ(pending_contents_scale,
             pending_layer_->tilings()->tiling_at(1)->contents_scale());
   EXPECT_EQ(active_contents_scale * low_res_factor,
             pending_layer_->tilings()->tiling_at(2)->contents_scale());
@@ skipping 30 matching lines @@
   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);
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      1.3f,  // ideal contents scale
-                                      2.7f,  // device scale
-                                      3.2f,  // page scale
-                                      1.f,   // maximum animation scale
-                                      false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    1.3f,  // ideal contents scale
+                                    2.7f,  // device scale
+                                    3.2f,  // page scale
+                                    1.f,   // maximum animation scale
+                                    false);
   EXPECT_EQ(1u, 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.
-  SetupDrawPropertiesAndManageTilings(pending_layer_,
-                                      1.3f,  // ideal contents scale
-                                      2.7f,  // device scale
-                                      3.2f,  // page scale
-                                      1.f,   // maximum animation scale
-                                      false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
+                                    1.3f,  // ideal contents scale
+                                    2.7f,  // device scale
+                                    3.2f,  // page scale
+                                    1.f,   // maximum animation scale
+                                    false);
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, SharedQuadStateContainsMaxTilingScale) {
   MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   MockQuadCuller quad_culler(render_pass.get(), &occlusion_tracker);
 
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1000, 2000);
 
   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);
 
-  SetupDrawPropertiesAndManageTilings(
-      pending_layer_, 2.5f, 1.f, 1.f, 1.f, false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 2.5f, 1.f, 1.f, 1.f, false);
   host_impl_.pending_tree()->UpdateDrawProperties();
 
   active_layer_->draw_properties().visible_content_rect =
       gfx::Rect(layer_bounds);
   host_impl_.active_tree()->UpdateDrawProperties();
 
   float max_contents_scale = active_layer_->MaximumTilingContentsScale();
   gfx::Transform scaled_draw_transform = active_layer_->draw_transform();
   scaled_draw_transform.Scale(SK_MScalar1 / max_contents_scale,
                               SK_MScalar1 / max_contents_scale);
@@ skipping 59 matching lines @@
 
   host_impl_.pending_tree()->SetRootLayer(root.Pass());
 
   EXPECT_FALSE(pending_mask_content->tilings());
   host_impl_.pending_tree()->UpdateDrawProperties();
   EXPECT_NE(0u, pending_mask_content->num_tilings());
 }
 
 }  // namespace
 }  // namespace cc