cc: Added tile bundles

cc/resources/tile_manager_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/resources/tile.h"
 #include "cc/resources/tile_priority.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_picture_pile_impl.h"
 #include "cc/test/fake_tile_manager.h"
@@ skipping 49 matching lines @@
     state.memory_limit_in_bytes =
         max_memory_tiles_ * 4 * tile_size.width() * tile_size.height();
     state.unused_memory_limit_in_bytes = state.memory_limit_in_bytes;
     state.memory_limit_policy = memory_limit_policy_;
     state.num_resources_limit = 100;
     state.tree_priority = tree_priority;
     global_state_ = state;
   }
 
   virtual void TearDown() OVERRIDE {
+    bundles_.clear();
     tile_manager_.reset(NULL);
     picture_pile_ = NULL;
 
     testing::Test::TearDown();
   }
 
   TileVector CreateTilesWithSize(int count,
                                  TilePriority active_priority,
                                  TilePriority pending_priority,
                                  gfx::Size tile_size) {
     TileVector tiles;
     for (int i = 0; i < count; ++i) {
       scoped_refptr<Tile> tile = tile_manager_->CreateTile(picture_pile_.get(),
                                                            tile_size,
                                                            gfx::Rect(),
                                                            gfx::Rect(),
                                                            1.0,
                                                            0,
                                                            0,
                                                            Tile::USE_LCD_TEXT);
-      tile->SetPriority(ACTIVE_TREE, active_priority);
-      tile->SetPriority(PENDING_TREE, pending_priority);
+      scoped_refptr<TileBundle> bundle =
+          tile_manager_->CreateTileBundle(0, 0, 1, 1);
+      bundle->SetPriority(ACTIVE_TREE, active_priority);
+      bundle->SetPriority(PENDING_TREE, pending_priority);
+      bundle->AddTileAt(ACTIVE_TREE, 0, 0, tile);
+      bundle->AddTileAt(PENDING_TREE, 0, 0, tile);
       tiles.push_back(tile);
+      bundles_.push_back(bundle);
     }
     return tiles;
   }
 
   TileVector CreateTiles(int count,
                          TilePriority active_priority,
                          TilePriority pending_priority) {
     return CreateTilesWithSize(count,
                                active_priority,
                                pending_priority,
@@ skipping 32 matching lines @@
  private:
   FakeTileManagerClient tile_manager_client_;
   LayerTreeSettings settings_;
   scoped_ptr<FakeTileManager> tile_manager_;
   scoped_refptr<FakePicturePileImpl> picture_pile_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
   TileMemoryLimitPolicy memory_limit_policy_;
   int max_memory_tiles_;
+  std::vector<scoped_refptr<TileBundle> > bundles_;
 };
 
 TEST_P(TileManagerTest, EnoughMemoryAllowAnything) {
   // A few tiles of each type of priority, with enough memory for all tiles.
 
   Initialize(10, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_now =
       CreateTiles(3, TilePriorityForNowBin(), TilePriority());
   TileVector pending_now =
       CreateTiles(3, TilePriority(), TilePriorityForNowBin());
@@ skipping 366 matching lines @@
 }
 
 // If true, the max tile limit should be applied as bytes; if false,
 // as num_resources_limit.
 INSTANTIATE_TEST_CASE_P(TileManagerTests,
                         TileManagerTest,
                         ::testing::Values(true, false));
 
 }  // namespace
 }  // namespace cc
+