Makes tile-creation lazy

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 <utility>
 
 #include "cc/layers/picture_layer.h"
 #include "cc/test/fake_content_layer_client.h"
@@ skipping 14 matching lines @@
   static scoped_ptr<TestablePictureLayerImpl> Create(
       LayerTreeImpl* tree_impl,
       int id,
       scoped_refptr<PicturePileImpl> pile) {
     return make_scoped_ptr(new TestablePictureLayerImpl(tree_impl, id, pile));
   }
 
   PictureLayerTilingSet& tilings() { return *tilings_; }
   Region& invalidation() { return invalidation_; }
 
-  virtual gfx::Size CalculateTileSize(
-      gfx::Size current_tile_size,
-      gfx::Size content_bounds) OVERRIDE {
-    if (current_tile_size.IsEmpty())
-      return gfx::Size(100, 100);
-    return current_tile_size;
-  }
-
   using PictureLayerImpl::AddTiling;
   using PictureLayerImpl::CleanUpTilingsOnActiveLayer;
 
  private:
   TestablePictureLayerImpl(
       LayerTreeImpl* tree_impl,
       int id,
       scoped_refptr<PicturePileImpl> pile)
       : PictureLayerImpl(tree_impl, id) {
     pile_ = pile;
@@ skipping 109 matching lines @@
 
     SetupPendingTree(pending_pile);
     pending_layer_ = static_cast<TestablePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
   }
 
   void AddDefaultTilingsWithInvalidation(const Region& invalidation) {
     active_layer_->AddTiling(2.3f);
     active_layer_->AddTiling(1.0f);
     active_layer_->AddTiling(0.5f);
+    for (size_t i = 0; i < active_layer_->tilings().num_tilings(); ++i)
+      active_layer_->tilings().tiling_at(i)->CreateAllTilesForTesting();
     pending_layer_->invalidation() = invalidation;
     pending_layer_->SyncFromActiveLayer();
+    for (size_t i = 0; i < pending_layer_->tilings().num_tilings(); ++i)
+      pending_layer_->tilings().tiling_at(i)->CreateAllTilesForTesting();
   }
 
   void SetupPendingTree(
       scoped_refptr<PicturePileImpl> pile) {
     host_impl_.CreatePendingTree();
     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
     // Clear recycled tree.
     pending_tree->DetachLayerTree();
 
     scoped_ptr<TestablePictureLayerImpl> pending_layer =
@@ skipping 40 matching lines @@
 
     SetupTrees(pending_pile, active_pile);
 
     host_impl_.active_tree()->SetPageScaleFactorAndLimits(1.f, 1.f, 1.f);
     float result_scale_x, result_scale_y;
     gfx::Size result_bounds;
     active_layer_->CalculateContentsScale(
         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();
       gfx::Rect rect(tile_center.x(), tile_center.y(), 1, 1);
       active_pile->add_draw_rect(rect);
       rects.push_back(SkRect::MakeXYWH(rect.x(), rect.y(), 1, 1));
@@ skipping 150 matching lines @@
         gfx::Rect(active_layer_bounds),
         tiling->contents_scale()));
     for (PictureLayerTiling::CoverageIterator
              iter(tiling,
                   tiling->contents_scale(),
                   tiling->ContentRect());
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
+      std::vector<Tile*> active_tiles =
+          active_layer_->tilings().tiling_at(i)->AllTilesForTesting();
+      std::vector<Tile*> pending_tiles = tiling->AllTilesForTesting();
       if (iter.geometry_rect().right() >= active_content_bounds.width() ||
-          iter.geometry_rect().bottom() >= active_content_bounds.height()) {
+          iter.geometry_rect().bottom() >= active_content_bounds.height() ||
+          active_tiles[0]->content_rect().size() !=
+              pending_tiles[0]->content_rect().size()) {
         EXPECT_EQ(pending_pile, iter->picture_pile());
       } else {
         EXPECT_EQ(active_pile, iter->picture_pile());
       }
     }
   }
 }
 
 TEST_F(PictureLayerImplTest, AddTilesFromNewRecording) {
   gfx::Size tile_size(400, 400);
@@ skipping 306 matching lines @@
   EXPECT_EQ(0u, pending_layer_->tilings().num_tilings());
 
   // This should create new tilings.
   pending_layer_->CalculateContentsScale(
       1.3f, false, &result_scale_x, &result_scale_y, &result_bounds);
   EXPECT_EQ(2u, pending_layer_->tilings().num_tilings());
 }
 
 }  // namespace
 }  // namespace cc