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)->AllTilesForTesting();
     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)->AllTilesForTesting();
   }
 
   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 211 matching lines @@
         tiling->contents_scale()));
     for (PictureLayerTiling::Iterator
              iter(tiling,
                   tiling->contents_scale(),
                   tiling->ContentRect());
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       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() ||
+          tiling->tile_bounds() !=
+              active_layer_->tilings().tiling_at(i)->tile_bounds()) {
         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 271 matching lines @@
   used_tilings.push_back(active_layer_->tilings().tiling_at(1));
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer_->tilings().num_tilings());
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer_->tilings().num_tilings());
 }
 
 }  // namespace
 }  // namespace cc