cc: Start using raster/eviction iterators.

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 467 matching lines @@
   // 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));
 
   tiling->UpdateTilePriorities(
       ACTIVE_TREE, viewport, 1.f, 1.0, NULL, NULL, gfx::Transform());
+  tiling->UpdateAllTilePrioritiesForTesting();
 
   gfx::Rect soon_rect = viewport;
   soon_rect.Inset(-312.f, -312.f, -312.f, -312.f);
   gfx::Rect soon_rect_in_content_space =
       gfx::ToEnclosedRect(gfx::ScaleRect(soon_rect, 0.25f));
 
   // Sanity checks.
   for (int i = 0; i < 47; ++i) {
     for (int j = 0; j < 47; ++j) {
       EXPECT_TRUE(tiling->TileAt(i, j)) << "i: " << i << " j: " << j;
@@ skipping 28 matching lines @@
         have_eventually = true;
       }
     }
   }
 
   EXPECT_TRUE(have_now);
   EXPECT_TRUE(have_soon);
   EXPECT_TRUE(have_eventually);
 
   // Spot check some distances.
-  // Tile at 5, 1 should begin at 41x9 in content space (without borders),
+  // Tile at 5, 1 should begin at 40x8 in content space (with borders),
   // so the distance to a viewport that ends at 25x25 in content space
-  // should be 17 (41 - 25 + 1). In layer space, then that should be
-  // 17 / 0.25 = 68 pixels.
+  // should be 16 (40 - 25 + 1). In layer space, then that should be
+  // 16 / 0.25 = 64 pixels.
 
   // We can verify that the content rect (with borders) is one pixel off
   // 41,9 8x8 on all sides.
   EXPECT_EQ(tiling->TileAt(5, 1)->content_rect().ToString(), "40,8 10x10");
 
   TilePriority priority = tiling->TileAt(5, 1)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(68.f, priority.distance_to_visible);
+  EXPECT_FLOAT_EQ(64.f, priority.distance_to_visible);
 
   priority = tiling->TileAt(2, 5)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(68.f, priority.distance_to_visible);
+  EXPECT_FLOAT_EQ(64.f, priority.distance_to_visible);
 
   priority = tiling->TileAt(3, 4)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(40.f, priority.distance_to_visible);
+  EXPECT_FLOAT_EQ(32.f, priority.distance_to_visible);
 
   // Move the viewport down 40 pixels.
   viewport = gfx::Rect(0, 40, 100, 100);
   viewport_in_content_space =
       gfx::ToEnclosedRect(gfx::ScaleRect(viewport, 0.25f));
   gfx::Rect skewport = tiling->ComputeSkewport(2.0, viewport_in_content_space);
 
   soon_rect = viewport;
   soon_rect.Inset(-312.f, -312.f, -312.f, -312.f);
   soon_rect_in_content_space =
       gfx::ToEnclosedRect(gfx::ScaleRect(soon_rect, 0.25f));
 
   EXPECT_EQ(0, skewport.x());
   EXPECT_EQ(10, skewport.y());
   EXPECT_EQ(25, skewport.width());
   EXPECT_EQ(35, skewport.height());
 
   tiling->UpdateTilePriorities(
       ACTIVE_TREE, viewport, 1.f, 2.0, NULL, NULL, gfx::Transform());
+  tiling->UpdateAllTilePrioritiesForTesting();
 
   have_now = false;
   have_eventually = false;
   have_soon = false;
 
   // Viewport moved, so we expect to find some NOW tiles, some SOON tiles and
   // some EVENTUALLY tiles.
   for (int i = 0; i < 47; ++i) {
     for (int j = 0; j < 47; ++j) {
       Tile* tile = tiling->TileAt(i, j);
@@ skipping 20 matching lines @@
         have_eventually = true;
       }
     }
   }
 
   EXPECT_TRUE(have_now);
   EXPECT_TRUE(have_soon);
   EXPECT_TRUE(have_eventually);
 
   priority = tiling->TileAt(5, 1)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(68.f, priority.distance_to_visible);
+  EXPECT_FLOAT_EQ(64.f, priority.distance_to_visible);
 
   priority = tiling->TileAt(2, 5)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(28.f, priority.distance_to_visible);
+  EXPECT_FLOAT_EQ(24.f, priority.distance_to_visible);
 
   priority = tiling->TileAt(3, 4)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
 
   // Change the underlying layer scale.
   tiling->UpdateTilePriorities(
       ACTIVE_TREE, viewport, 2.0f, 3.0, NULL, NULL, gfx::Transform());
+  tiling->UpdateAllTilePrioritiesForTesting();
 
   priority = tiling->TileAt(5, 1)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(34.f, priority.distance_to_visible);
+  EXPECT_FLOAT_EQ(32.f, priority.distance_to_visible);
 
   priority = tiling->TileAt(2, 5)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(14.f, priority.distance_to_visible);
+  EXPECT_FLOAT_EQ(12.f, priority.distance_to_visible);
 
   priority = tiling->TileAt(3, 4)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
 }
 
 TEST(PictureLayerTilingTest, ExpandRectEqual) {
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(-1000, -1000, 10000, 10000);
   int64 target_area = 100 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
@@ skipping 701 matching lines @@
                                               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
                                gfx::Transform());  // draw transform
+  tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
   EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
 
@@ skipping 37 matching lines @@
                                               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
                                gfx::Transform());  // draw transform
+  tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
@@ skipping 47 matching lines @@
                                               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
                                gfx::Transform());  // draw transform
+  tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
   EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
 
@@ skipping 41 matching lines @@
                                               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
                                gfx::Transform());  // draw transform
+  tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
   EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
@@ skipping 65 matching lines @@
                                               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
                                gfx::Transform());  // draw transform
+  tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   // All tiles will have a positive distance_to_visible
   // and an infinite time_to_visible.
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(priority.distance_to_visible, 0.f);
@@ skipping 75 matching lines @@
                                               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
                                gfx::Transform());  // draw transform
+  tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   // Left-side tiles will be clipped by the transform, so we have to assume
   // they are visible just in case.
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
@@ skipping 55 matching lines @@
                                gfx::Transform());  // draw transform
 
   // current frame
   tiling->UpdateTilePriorities(ACTIVE_TREE,
                                viewport_in_layer_space,
                                current_layer_contents_scale,
                                current_frame_time_in_seconds,
                                NULL,               // occlusion tracker
                                NULL,               // render target
                                gfx::Transform());  // draw transform
+  tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
@@ skipping 62 matching lines @@
                                gfx::Transform());  // draw transform
 
   // current frame
   tiling->UpdateTilePriorities(ACTIVE_TREE,
                                viewport_in_layer_space,
                                current_layer_contents_scale,
                                current_frame_time_in_seconds,
                                NULL,               // occlusion tracker
                                NULL,               // render target
                                gfx::Transform());  // draw transform
+  tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
   EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
   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);
 }
 
-TEST(PictureLayerTilingTest, ResetClearsPriorities) {
-  FakePictureLayerTilingClient client;
-  scoped_ptr<TestablePictureLayerTiling> tiling;
-
-  client.SetTileSize(gfx::Size(100, 100));
-  client.set_tree(ACTIVE_TREE);
-  tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
-                                              gfx::Size(100, 100),
-                                              &client);
-  tiling->UpdateTilePriorities(ACTIVE_TREE,
-                               gfx::Rect(0, 0, 100, 100),
-                               1.0f,
-                               1.0f,
-                               NULL,               // occlusion tracker
-                               NULL,               // render target
-                               gfx::Transform());  // draw transform
-
-  std::vector<scoped_refptr<Tile> > tiles = tiling->AllRefTilesForTesting();
-  ASSERT_GT(tiles.size(), 0u);
-  for (std::vector<scoped_refptr<Tile> >::const_iterator it = tiles.begin();
-       it != tiles.end();
-       ++it) {
-    EXPECT_NE(TilePriority(), (*it)->priority(ACTIVE_TREE));
-  }
-
-  tiling->Reset();
-  for (std::vector<scoped_refptr<Tile> >::const_iterator it = tiles.begin();
-       it != tiles.end();
-       ++it) {
-    EXPECT_EQ(TilePriority(), (*it)->priority(ACTIVE_TREE));
-  }
-  tiles.clear();
-}
-
 }  // namespace
 }  // namespace cc