cc: Do not cleanup tiles with raster tasks.

cc/resources/picture_layer_tiling_unittest.cc

 // Copyright 2012 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/picture_layer_tiling.h"
 
 #include <limits>
 #include <set>
 
 #include "cc/base/math_util.h"
@@ skipping 65 matching lines @@
 
 class PictureLayerTilingIteratorTest : public testing::Test {
  public:
   PictureLayerTilingIteratorTest() {}
   virtual ~PictureLayerTilingIteratorTest() {}
 
   void Initialize(const gfx::Size& tile_size,
                   float contents_scale,
                   const gfx::Size& layer_bounds) {
     client_.SetTileSize(tile_size);
+    client_.set_tree(PENDING_TREE);
     tiling_ = TestablePictureLayerTiling::Create(contents_scale,
                                                  layer_bounds,
                                                  &client_);
   }
 
   void SetLiveRectAndVerifyTiles(const gfx::Rect& live_tiles_rect) {
     tiling_->SetLiveTilesRect(live_tiles_rect);
 
     std::vector<Tile*> tiles = tiling_->AllTilesForTesting();
     for (std::vector<Tile*>::iterator iter = tiles.begin();
@@ skipping 235 matching lines @@
 
   // Partially covering content, but too large
   VerifyTilesCoverNonContainedRect(1.0f, gfx::Rect(-1000, 100, 2000, 100));
   VerifyTilesCoverNonContainedRect(1.5f, gfx::Rect(-1000, 100, 2000, 100));
   VerifyTilesCoverNonContainedRect(0.5f, gfx::Rect(-1000, 100, 2000, 100));
 }
 
 TEST(PictureLayerTilingTest, SkewportLimits) {
   FakePictureLayerTilingClient client;
   client.set_skewport_extrapolation_limit_in_content_pixels(75);
+  client.set_tree(ACTIVE_TREE);
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(100, 100));
   tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
 
   tiling->UpdateTilePriorities(
       ACTIVE_TREE, viewport, 1.f, 1.0, NULL, NULL, gfx::Transform());
@@ skipping 52 matching lines @@
 }
 
 TEST(PictureLayerTilingTest, ComputeSkewport) {
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
 
   tiling->UpdateTilePriorities(
       ACTIVE_TREE, viewport, 1.f, 1.0, NULL, NULL, gfx::Transform());
 
   // Move viewport down 50 pixels in 0.5 seconds.
   gfx::Rect down_skewport =
       tiling->ComputeSkewport(1.5, gfx::Rect(0, 50, 100, 100));
 
   EXPECT_EQ(0, down_skewport.x());
@@ skipping 39 matching lines @@
 }
 
 TEST(PictureLayerTilingTest, ViewportDistanceWithScale) {
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(1500, 1500);
 
   client.SetTileSize(gfx::Size(10, 10));
+  client.set_tree(ACTIVE_TREE);
 
   // Tiling at 0.25 scale: this should create 47x47 tiles of size 10x10.
   // The reason is that each tile has a one pixel border, so tile at (1, 2)
   // for instance begins at (8, 16) pixels. So tile at (46, 46) will begin at
   // (368, 368) and extend to the end of 1500 * 0.25 = 375 edge of the
   // tiling.
   tiling = TestablePictureLayerTiling::Create(0.25f, layer_bounds, &client);
   gfx::Rect viewport_in_content_space =
       gfx::ToEnclosedRect(gfx::ScaleRect(viewport, 0.25f));
 
@@ skipping 367 matching lines @@
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(50, 50, 100, 100);
   gfx::Size layer_bounds(800, 800);
 
   gfx::Rect soon_rect = viewport;
   soon_rect.Inset(-312.f, -312.f, -312.f, -312.f);
 
   client.SetTileSize(gfx::Size(30, 30));
+  client.set_tree(ACTIVE_TREE);
 
   tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
   tiling->UpdateTilePriorities(
       ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
 
   PictureLayerTiling::TilingRasterTileIterator empty_iterator;
   EXPECT_FALSE(empty_iterator);
 
   std::vector<Tile*> all_tiles = tiling->AllTilesForTesting();
 
@@ skipping 88 matching lines @@
 
 TEST(PictureLayerTilingTest, TilingRasterTileIteratorMovingViewport) {
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(50, 0, 100, 100);
   gfx::Rect moved_viewport(50, 0, 100, 500);
   gfx::Size layer_bounds(1000, 1000);
 
   client.SetTileSize(gfx::Size(30, 30));
+  client.set_tree(ACTIVE_TREE);
 
   tiling = TestablePictureLayerTiling::Create(1.f, layer_bounds, &client);
   tiling->UpdateTilePriorities(
       ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
   tiling->UpdateTilePriorities(
       ACTIVE_TREE, moved_viewport, 1.0f, 2.0, NULL, NULL, gfx::Transform());
 
   gfx::Rect soon_rect = moved_viewport;
   soon_rect.Inset(-312.f, -312.f, -312.f, -312.f);
 
@@ skipping 55 matching lines @@
   scoped_ptr<ResourceProvider> resource_provider = ResourceProvider::Create(
       output_surface.get(), &shared_bitmap_manager, 0, false, 1, false);
 
   FakePictureLayerTilingClient client(resource_provider.get());
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(50, 50, 100, 100);
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(30, 30));
+  client.set_tree(ACTIVE_TREE);
 
   tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
   tiling->UpdateTilePriorities(
       ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
 
   PictureLayerTiling::TilingRasterTileIterator empty_iterator;
   EXPECT_FALSE(empty_iterator);
 
   std::vector<Tile*> all_tiles = tiling->AllTilesForTesting();
 
@@ skipping 33 matching lines @@
   EXPECT_GT(all_tiles_set.size(), 0u);
   EXPECT_EQ(all_tiles_set, eviction_tiles);
 }
 
 TEST_F(PictureLayerTilingIteratorTest, TilesExist) {
   gfx::Size layer_bounds(1099, 801);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
+  client_.set_tree(ACTIVE_TREE);
   tiling_->UpdateTilePriorities(
       ACTIVE_TREE,
       gfx::Rect(layer_bounds),  // visible content rect
       1.f,                      // current contents scale
       1.0,                      // current frame time
       NULL,                     // occlusion tracker
       NULL,                     // render target
       gfx::Transform());        // draw transform
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
 
   // Make the viewport rect empty. All tiles are killed and become zombies.
   tiling_->UpdateTilePriorities(ACTIVE_TREE,
                                 gfx::Rect(),        // visible content rect
                                 1.f,                // current contents scale
                                 2.0,                // current frame time
                                 NULL,               // occlusion tracker
                                 NULL,               // render target
                                 gfx::Transform());  // draw transform
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 }
 
 TEST_F(PictureLayerTilingIteratorTest, TilesExistGiantViewport) {
   gfx::Size layer_bounds(1099, 801);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
   gfx::Rect giant_rect(-10000000, -10000000, 1000000000, 1000000000);
 
+  client_.set_tree(ACTIVE_TREE);
   tiling_->UpdateTilePriorities(
       ACTIVE_TREE,
       gfx::Rect(layer_bounds),  // visible content rect
       1.f,                      // current contents scale
       1.0,                      // current frame time
       NULL,                     // occlusion tracker
       NULL,                     // render target
       gfx::Transform());        // draw transform
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
 
@@ skipping 12 matching lines @@
   gfx::Size layer_bounds(1099, 801);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
   // This rect does not intersect with the layer, as the layer is outside the
   // viewport.
   gfx::Rect viewport_rect(1100, 0, 1000, 1000);
   EXPECT_FALSE(viewport_rect.Intersects(gfx::Rect(layer_bounds)));
 
+  client_.set_tree(ACTIVE_TREE);
   tiling_->UpdateTilePriorities(ACTIVE_TREE,
                                 viewport_rect,      // visible content rect
                                 1.f,                // current contents scale
                                 1.0,                // current frame time
                                 NULL,               // occlusion tracker
                                 NULL,               // render target
                                 gfx::Transform());  // draw transform
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
 }
 
@@ skipping 10 matching lines @@
 
 TEST_F(PictureLayerTilingIteratorTest,
        TilesExistLargeViewportAndLayerWithSmallVisibleArea) {
   gfx::Size layer_bounds(10000, 10000);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
   gfx::Rect visible_rect(8000, 8000, 50, 50);
 
+  client_.set_tree(ACTIVE_TREE);
   set_max_tiles_for_interest_area(1);
   tiling_->UpdateTilePriorities(ACTIVE_TREE,
                                 visible_rect,       // visible content rect
                                 1.f,                // current contents scale
                                 1.0,                // current frame time
                                 NULL,               // occlusion tracker
                                 NULL,               // render target
                                 gfx::Transform());  // draw transform
   VerifyTiles(1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&TilesIntersectingRectExist, visible_rect, true));
 }
 
 static void CountExistingTiles(int *count,
                                Tile* tile,
                                const gfx::Rect& geometry_rect) {
   if (tile != NULL)
     ++(*count);
 }
 
 TEST_F(PictureLayerTilingIteratorTest,
        TilesExistLargeViewportAndLayerWithLargeVisibleArea) {
   gfx::Size layer_bounds(10000, 10000);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
+  client_.set_tree(ACTIVE_TREE);
   set_max_tiles_for_interest_area(1);
   tiling_->UpdateTilePriorities(
       ACTIVE_TREE,
       gfx::Rect(layer_bounds),  // visible content rect
       1.f,                      // current contents scale
       1.0,                      // current frame time
       NULL,                     // occlusion tracker
       NULL,                     // render target
       gfx::Transform());        // draw transform
 
   int num_tiles = 0;
   VerifyTiles(1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&CountExistingTiles, &num_tiles));
   // If we're making a rect the size of one tile, it can only overlap up to 4
   // tiles depending on its position.
   EXPECT_LE(num_tiles, 4);
   VerifyTiles(1.f, gfx::Rect(), base::Bind(&TileExists, false));
 }
 
 TEST_F(PictureLayerTilingIteratorTest, AddTilingsToMatchScale) {
   gfx::Size layer_bounds(1099, 801);
   gfx::Size tile_size(100, 100);
 
   client_.SetTileSize(tile_size);
+  client_.set_tree(PENDING_TREE);
 
   PictureLayerTilingSet active_set(&client_, layer_bounds);
 
   active_set.AddTiling(1.f);
 
   VerifyTiles(active_set.tiling_at(0),
               1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&TileExists, false));
 
@@ skipping 45 matching lines @@
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
   float current_layer_contents_scale = 1.f;
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
   tiling->UpdateTilePriorities(ACTIVE_TREE,
                                viewport_in_layer_space,
                                current_layer_contents_scale,
                                current_frame_time_in_seconds,
                                NULL,               // occlusion tracker
                                NULL,               // render target
@@ skipping 36 matching lines @@
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
 
   current_screen_transform.Translate(850, 0);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
   tiling->UpdateTilePriorities(ACTIVE_TREE,
                                viewport_in_layer_space,
                                current_layer_contents_scale,
                                current_frame_time_in_seconds,
                                NULL,               // occlusion tracker
                                NULL,               // render target
@@ skipping 46 matching lines @@
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
 
   current_screen_transform.Translate(705, 505);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
   tiling->UpdateTilePriorities(ACTIVE_TREE,
                                viewport_in_layer_space,
                                current_layer_contents_scale,
                                current_frame_time_in_seconds,
                                NULL,               // occlusion tracker
                                NULL,               // render target
@@ skipping 40 matching lines @@
   // A diagonally rotated layer that is partially off the bottom of the screen.
   // In this configuration, only the top-left tile would be visible.
   current_screen_transform.Translate(600, 750);
   current_screen_transform.RotateAboutZAxis(45);
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
   tiling->UpdateTilePriorities(ACTIVE_TREE,
                                viewport_in_layer_space,
                                current_layer_contents_scale,
                                current_frame_time_in_seconds,
                                NULL,               // occlusion tracker
                                NULL,               // render target
@@ skipping 64 matching lines @@
   bool clipped;
   MathUtil::MapQuad(current_screen_transform,
                     gfx::QuadF(gfx::RectF(0, 0, 200, 200)),
                     &clipped);
   ASSERT_FALSE(clipped);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
   tiling->UpdateTilePriorities(ACTIVE_TREE,
                                viewport_in_layer_space,
                                current_layer_contents_scale,
                                current_frame_time_in_seconds,
                                NULL,               // occlusion tracker
                                NULL,               // render target
@@ skipping 74 matching lines @@
 
   MathUtil::MapQuad(current_screen_transform,
                     gfx::QuadF(gfx::RectF(100, 0, 100, 200)),
                     &clipped);
   ASSERT_FALSE(clipped);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
   tiling->UpdateTilePriorities(ACTIVE_TREE,
                                viewport_in_layer_space,
                                current_layer_contents_scale,
                                current_frame_time_in_seconds,
                                NULL,               // occlusion tracker
                                NULL,               // render target
@@ skipping 44 matching lines @@
   double current_frame_time_in_seconds = 2.0;
 
   // Offscreen layer is coming closer to viewport at 1000 pixels per second.
   current_screen_transform.Translate(1800, 0);
   last_screen_transform.Translate(2800, 0);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
   // previous ("last") frame
   tiling->UpdateTilePriorities(ACTIVE_TREE,
                                viewport_in_layer_space,
                                last_layer_contents_scale,
                                last_frame_time_in_seconds,
                                NULL,               // occlusion tracker
@@ skipping 61 matching lines @@
   //    because it is rotating toward the viewport.
   current_screen_transform.Translate(400, 550);
   current_screen_transform.RotateAboutZAxis(45);
 
   last_screen_transform.Translate(400, 550);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
   // previous ("last") frame
   tiling->UpdateTilePriorities(ACTIVE_TREE,
                                viewport_in_layer_space,
                                last_layer_contents_scale,
                                last_frame_time_in_seconds,
                                NULL,               // occlusion tracker
@@ skipping 22 matching lines @@
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
   EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
   EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 }
 
 }  // namespace
 }  // namespace cc