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"
 #include "cc/resources/picture_layer_tiling_set.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_picture_layer_tiling_client.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
 namespace {
 
-static gfx::Rect ViewportInLayerSpace(
-    const gfx::Transform& transform,
-    const gfx::Size& device_viewport) {
-
+static gfx::Rect ViewportInLayerSpace(const gfx::Transform& transform,
+                                      const gfx::Size& device_viewport) {
   gfx::Transform inverse;
   if (!transform.GetInverse(&inverse))
     return gfx::Rect();
 
   gfx::RectF viewport_in_layer_space = MathUtil::ProjectClippedRect(
       inverse, gfx::RectF(gfx::Point(0, 0), device_viewport));
   return ToEnclosingRect(viewport_in_layer_space);
 }
 
 static void UpdateAllTilePriorities(PictureLayerTilingSet* set,
                                     WhichTree tree,
                                     const gfx::Rect& visible_layer_rect,
                                     float layer_contents_scale,
                                     double current_frame_time_in_seconds) {
   for (size_t i = 0; i < set->num_tilings(); ++i) {
     set->tiling_at(i)->UpdateTilePriorities(tree,
                                             visible_layer_rect,
                                             layer_contents_scale,
                                             current_frame_time_in_seconds,
                                             NULL,
                                             NULL,
                                             gfx::Transform());
   }
 }
 
+static void CreateAllTiles(PictureLayerTilingSet* set) {
+  for (size_t i = 0; i < set->num_tilings(); ++i)
+    set->tiling_at(i)->CreateAllTilesForTesting();
+}
+
 class TestablePictureLayerTiling : public PictureLayerTiling {
  public:
   using PictureLayerTiling::SetLiveTilesRect;
   using PictureLayerTiling::TileAt;
 
   static scoped_ptr<TestablePictureLayerTiling> Create(
       float contents_scale,
       const gfx::Size& layer_bounds,
       PictureLayerTilingClient* client) {
-    return make_scoped_ptr(new TestablePictureLayerTiling(
-        contents_scale,
-        layer_bounds,
-        client));
+    return make_scoped_ptr(
+        new TestablePictureLayerTiling(contents_scale, layer_bounds, client));
   }
 
   using PictureLayerTiling::ComputeSkewport;
 
  protected:
   TestablePictureLayerTiling(float contents_scale,
                              const gfx::Size& layer_bounds,
                              PictureLayerTilingClient* client)
-      : PictureLayerTiling(contents_scale, layer_bounds, client) { }
+      : PictureLayerTiling(contents_scale, layer_bounds, client) {}
 };
 
 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);
-    tiling_ = TestablePictureLayerTiling::Create(contents_scale,
-                                                 layer_bounds,
-                                                 &client_);
+    tiling_ = TestablePictureLayerTiling::Create(
+        contents_scale, layer_bounds, &client_);
   }
 
   void SetLiveRectAndVerifyTiles(const gfx::Rect& live_tiles_rect) {
+    tiling_->CreateAllTilesForTesting();
     tiling_->SetLiveTilesRect(live_tiles_rect);
 
     std::vector<Tile*> tiles = tiling_->AllTilesForTesting();
-    for (std::vector<Tile*>::iterator iter = tiles.begin();
-         iter != tiles.end();
+    for (std::vector<Tile*>::iterator iter = tiles.begin(); iter != tiles.end();
          ++iter) {
       EXPECT_TRUE(live_tiles_rect.Intersects((*iter)->content_rect()));
     }
   }
 
-  void VerifyTilesExactlyCoverRect(
-      float rect_scale,
-      const gfx::Rect& request_rect,
-      const gfx::Rect& expect_rect) {
+  void VerifyTilesExactlyCoverRect(float rect_scale,
+                                   const gfx::Rect& request_rect,
+                                   const gfx::Rect& expect_rect) {
     EXPECT_TRUE(request_rect.Contains(expect_rect));
 
     // Iterators are not valid if this ratio is too large (i.e. the
     // tiling is too high-res for a low-res destination rect.)  This is an
     // artifact of snapping geometry to integer coordinates and then mapping
     // back to floating point texture coordinates.
     float dest_to_contents_scale = tiling_->contents_scale() / rect_scale;
     ASSERT_LE(dest_to_contents_scale, 2.0);
 
     Region remaining = expect_rect;
-    for (PictureLayerTiling::CoverageIterator
-             iter(tiling_.get(), rect_scale, request_rect);
+    for (PictureLayerTiling::CoverageIterator iter(
+             tiling_.get(), rect_scale, request_rect);
          iter;
          ++iter) {
       // Geometry cannot overlap previous geometry at all
       gfx::Rect geometry = iter.geometry_rect();
       EXPECT_TRUE(expect_rect.Contains(geometry));
       EXPECT_TRUE(remaining.Contains(geometry));
       remaining.Subtract(geometry);
 
       // Sanity check that texture coords are within the texture rect.
       gfx::RectF texture_rect = iter.texture_rect();
       EXPECT_GE(texture_rect.x(), 0);
       EXPECT_GE(texture_rect.y(), 0);
       EXPECT_LE(texture_rect.right(), client_.TileSize().width());
       EXPECT_LE(texture_rect.bottom(), client_.TileSize().height());
 
       EXPECT_EQ(iter.texture_size(), client_.TileSize());
     }
 
     // The entire rect must be filled by geometry from the tiling.
     EXPECT_TRUE(remaining.IsEmpty());
   }
 
   void VerifyTilesExactlyCoverRect(float rect_scale, const gfx::Rect& rect) {
     VerifyTilesExactlyCoverRect(rect_scale, rect, rect);
   }
 
   void VerifyTiles(
       float rect_scale,
       const gfx::Rect& rect,
-      base::Callback<void(Tile* tile,
-                          const gfx::Rect& geometry_rect)> callback) {
-    VerifyTiles(tiling_.get(),
-                rect_scale,
-                rect,
-                callback);
+      base::Callback<void(Tile* tile, const gfx::Rect& geometry_rect)>
+          callback) {
+    VerifyTiles(tiling_.get(), rect_scale, rect, callback);
   }
 
   void VerifyTiles(
       PictureLayerTiling* tiling,
       float rect_scale,
       const gfx::Rect& rect,
-      base::Callback<void(Tile* tile,
-                          const gfx::Rect& geometry_rect)> callback) {
+      base::Callback<void(Tile* tile, const gfx::Rect& geometry_rect)>
+          callback) {
     Region remaining = rect;
     for (PictureLayerTiling::CoverageIterator iter(tiling, rect_scale, rect);
          iter;
          ++iter) {
       remaining.Subtract(iter.geometry_rect());
       callback.Run(*iter, iter.geometry_rect());
     }
     EXPECT_TRUE(remaining.IsEmpty());
   }
 
@@ skipping 303 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->CreateInterestRectTilesForTesting();
 
   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 17 (40 - 25 + 1). In layer space, then that should be
+  // 17 / 0.25 = 64 pixels.
 
-  // We can verify that the content rect (with borders) is one pixel off
-  // 41,9 8x8 on all sides.
+  // We can verify that the content rect is what we expect it to be.
   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->CreateAllTilesForTesting();
 
   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->CreateAllTilesForTesting();
 
   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 90 matching lines @@
   EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y());
   EXPECT_EQ(out.bottom() - in.bottom(), out.right() - in.right());
   EXPECT_LE(out.width() * out.height(), target_area);
   EXPECT_GT(out.width() * out.height(),
             target_area - out.width() - out.height() * 2);
   EXPECT_TRUE(bounds.Contains(out));
 }
 
 TEST(PictureLayerTilingTest, ExpandRectBoundedRight) {
   gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(-1000, -1000, 1000+120, 10000);
+  gfx::Rect bounds(-1000, -1000, 1000 + 120, 10000);
   int64 target_area = 200 * 200;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
       in, target_area, bounds, NULL);
   EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y());
   EXPECT_EQ(out.bottom() - in.bottom(), in.x() - out.x());
   EXPECT_LE(out.width() * out.height(), target_area);
   EXPECT_GT(out.width() * out.height(),
             target_area - out.width() - out.height() * 2);
   EXPECT_TRUE(bounds.Contains(out));
 }
@@ skipping 21 matching lines @@
   EXPECT_EQ(out.right() - in.right(), in.x() - out.x());
   EXPECT_EQ(out.right() - in.right(), in.y() - out.y());
   EXPECT_LE(out.width() * out.height(), target_area);
   EXPECT_GT(out.width() * out.height(),
             target_area - out.width() * 2 - out.height());
   EXPECT_TRUE(bounds.Contains(out));
 }
 
 TEST(PictureLayerTilingTest, ExpandRectSquishedHorizontally) {
   gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(0, -4000, 100+40+20, 100000);
+  gfx::Rect bounds(0, -4000, 100 + 40 + 20, 100000);
   int64 target_area = 400 * 400;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
       in, target_area, bounds, NULL);
   EXPECT_EQ(20, out.right() - in.right());
   EXPECT_EQ(40, in.x() - out.x());
   EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y());
   EXPECT_LE(out.width() * out.height(), target_area);
-  EXPECT_GT(out.width() * out.height(),
-            target_area - out.width() * 2);
+  EXPECT_GT(out.width() * out.height(), target_area - out.width() * 2);
   EXPECT_TRUE(bounds.Contains(out));
 }
 
 TEST(PictureLayerTilingTest, ExpandRectSquishedVertically) {
   gfx::Rect in(40, 50, 100, 200);
-  gfx::Rect bounds(-4000, 0, 100000, 200+50+30);
+  gfx::Rect bounds(-4000, 0, 100000, 200 + 50 + 30);
   int64 target_area = 400 * 400;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
       in, target_area, bounds, NULL);
   EXPECT_EQ(30, out.bottom() - in.bottom());
   EXPECT_EQ(50, in.y() - out.y());
   EXPECT_EQ(out.right() - in.right(), in.x() - out.x());
   EXPECT_LE(out.width() * out.height(), target_area);
-  EXPECT_GT(out.width() * out.height(),
-            target_area - out.height() * 2);
+  EXPECT_GT(out.width() * out.height(), target_area - out.height() * 2);
   EXPECT_TRUE(bounds.Contains(out));
 }
 
 TEST(PictureLayerTilingTest, ExpandRectOutOfBoundsFarAway) {
   gfx::Rect in(400, 500, 100, 200);
   gfx::Rect bounds(0, 0, 10, 10);
   int64 target_area = 400 * 400;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
       in, target_area, bounds, NULL);
   EXPECT_TRUE(out.IsEmpty());
@@ skipping 45 matching lines @@
 
   client.SetTileSize(gfx::Size(30, 30));
 
   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();
-
-  // Sanity check.
-  EXPECT_EQ(841u, all_tiles.size());
-
   // The explanation of each iteration is as follows:
   // 1. First iteration tests that we can get all of the tiles correctly.
   // 2. Second iteration ensures that we can get all of the tiles again (first
   //    iteration didn't change any tiles), as well set all tiles to be ready to
   //    draw.
   // 3. Third iteration ensures that no tiles are returned, since they were all
   //    marked as ready to draw.
   for (int i = 0; i < 3; ++i) {
     PictureLayerTiling::TilingRasterTileIterator it(tiling.get(), ACTIVE_TREE);
 
@@ skipping 62 matching lines @@
 
     EXPECT_GT(eventually_bin_order_correct_count,
               eventually_bin_order_incorrect_count);
 
     // We should have now and eventually tiles, as well as soon tiles from
     // the border region.
     EXPECT_TRUE(have_tiles[TilePriority::NOW]);
     EXPECT_TRUE(have_tiles[TilePriority::SOON]);
     EXPECT_TRUE(have_tiles[TilePriority::EVENTUALLY]);
 
+    std::vector<Tile*> all_tiles = tiling->AllTilesForTesting();
+
+    // Sanity check.
+    EXPECT_EQ(841u, all_tiles.size());
     EXPECT_EQ(unique_tiles.size(), all_tiles.size());
   }
 }
 
 TEST(PictureLayerTilingTest, TilingRasterTileIteratorMovingViewport) {
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(50, 0, 100, 100);
   gfx::Rect moved_viewport(50, 0, 100, 500);
@@ skipping 48 matching lines @@
   }
 
   EXPECT_GT(eventually_bin_order_correct_count,
             eventually_bin_order_incorrect_count);
 
   EXPECT_TRUE(have_tiles[TilePriority::NOW]);
   EXPECT_TRUE(have_tiles[TilePriority::SOON]);
   EXPECT_TRUE(have_tiles[TilePriority::EVENTUALLY]);
 }
 
-static void TileExists(bool exists, Tile* tile,
+static void TileExists(bool exists,
+                       Tile* tile,
                        const gfx::Rect& geometry_rect) {
   EXPECT_EQ(exists, tile != NULL) << geometry_rect.ToString();
 }
 
 TEST(PictureLayerTilingTest, TilingEvictionTileIteratorStaticViewport) {
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<FakeOutputSurface> output_surface = FakeOutputSurface::Create3d();
   CHECK(output_surface->BindToClient(&output_surface_client));
   TestSharedBitmapManager shared_bitmap_manager;
   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));
 
   tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
   tiling->UpdateTilePriorities(
       ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
+  tiling->CreateAllTilesForTesting();
 
   PictureLayerTiling::TilingRasterTileIterator empty_iterator;
   EXPECT_FALSE(empty_iterator);
 
   std::vector<Tile*> all_tiles = tiling->AllTilesForTesting();
 
   PictureLayerTiling::TilingEvictionTileIterator it(tiling.get(),
                                                     SMOOTHNESS_TAKES_PRIORITY);
 
   // Tiles don't have resources to evict.
@@ skipping 37 matching lines @@
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
   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
+  tiling_->CreateAllTilesForTesting();
   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);
 
   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
+  tiling_->CreateAllTilesForTesting();
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
 
   // If the visible content rect is empty, it should still have live tiles.
   tiling_->UpdateTilePriorities(ACTIVE_TREE,
                                 giant_rect,         // visible content rect
                                 1.f,                // current contents scale
                                 2.0,                // current frame time
                                 NULL,               // occlusion tracker
                                 NULL,               // render target
                                 gfx::Transform());  // draw transform
+  tiling_->CreateAllTilesForTesting();
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
 }
 
 TEST_F(PictureLayerTilingIteratorTest, TilesExistOutsideViewport) {
   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)));
 
   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
+  tiling_->CreateInterestRectTilesForTesting();
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
 }
 
 static void TilesIntersectingRectExist(const gfx::Rect& rect,
                                        bool intersect_exists,
                                        Tile* tile,
                                        const gfx::Rect& geometry_rect) {
   bool intersects = rect.Intersects(geometry_rect);
   bool expected_exists = intersect_exists ? intersects : !intersects;
   EXPECT_EQ(expected_exists, tile != NULL)
@@ skipping 11 matching lines @@
   gfx::Rect visible_rect(8000, 8000, 50, 50);
 
   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
+  tiling_->CreateInterestRectTilesForTesting();
   VerifyTiles(1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&TilesIntersectingRectExist, visible_rect, true));
 }
 
-static void CountExistingTiles(int *count,
+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);
@@ skipping 29 matching lines @@
   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));
 
   UpdateAllTilePriorities(&active_set,
-                          PENDING_TREE,
+                          ACTIVE_TREE,
                           gfx::Rect(layer_bounds),  // visible content rect
                           1.f,                      // current contents scale
                           1.0);                     // current frame time
+  CreateAllTiles(&active_set);
 
   // The active tiling has tiles now.
   VerifyTiles(active_set.tiling_at(0),
               1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&TileExists, true));
 
   // Add the same tilings to the pending set.
   PictureLayerTilingSet pending_set(&client_, layer_bounds);
   Region invalidation;
   pending_set.SyncTilings(active_set, layer_bounds, invalidation, 0.f);
 
   // The pending tiling starts with no tiles.
   VerifyTiles(pending_set.tiling_at(0),
               1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&TileExists, false));
 
   // UpdateTilePriorities on the pending tiling at the same frame time. The
   // pending tiling should get tiles.
   UpdateAllTilePriorities(&pending_set,
                           PENDING_TREE,
                           gfx::Rect(layer_bounds),  // visible content rect
                           1.f,                      // current contents scale
                           1.0);                     // current frame time
+  CreateAllTiles(&pending_set);
 
   VerifyTiles(pending_set.tiling_at(0),
               1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&TileExists, true));
 }
 
 TEST(UpdateTilePrioritiesTest, VisibleTiles) {
   // The TilePriority of visible tiles should have zero distance_to_visible
   // and time_to_visible.
 
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   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);
+  gfx::Rect viewport_in_layer_space =
+      ViewportInLayerSpace(current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   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
                                gfx::Transform());  // draw transform
+  tiling->CreateInterestRectTilesForTesting();
 
   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);
 
   priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
   EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
   EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
 
   priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
   EXPECT_FLOAT_EQ(TilePriority::NOW, priority.priority_bin);
 }
 
 TEST(UpdateTilePrioritiesTest, OffscreenTiles) {
-  // The TilePriority of offscreen tiles (without movement) should have nonzero
-  // distance_to_visible and infinite time_to_visible.
-
+  // The TilePriority of offscreen tiles (without movement) should have
+  // nonzero distance_to_visible and infinite time_to_visible.
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   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);
+  gfx::Rect viewport_in_layer_space =
+      ViewportInLayerSpace(current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   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
                                gfx::Transform());  // draw transform
+  tiling->CreateInterestRectTilesForTesting();
 
   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 16 matching lines @@
   EXPECT_GT(right.distance_to_visible, left.distance_to_visible);
 
   left = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
   right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(right.distance_to_visible, left.distance_to_visible);
 }
 
 TEST(UpdateTilePrioritiesTest, PartiallyOffscreenLayer) {
   // Sanity check that a layer with some tiles visible and others offscreen has
   // correct TilePriorities for each tile.
-
   FakePictureLayerTilingClient client;
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   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);
+  gfx::Rect viewport_in_layer_space =
+      ViewportInLayerSpace(current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   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
                                gfx::Transform());  // draw transform
+  tiling->CreateInterestRectTilesForTesting();
 
   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 25 matching lines @@
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   double current_frame_time_in_seconds = 1.0;
 
   // 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);
+  gfx::Rect viewport_in_layer_space =
+      ViewportInLayerSpace(current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   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
                                gfx::Transform());  // draw transform
+  tiling->CreateInterestRectTilesForTesting();
 
   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 49 matching lines @@
   current_screen_transform.Translate(-100.0, -100.0);
   last_screen_transform = current_screen_transform;
 
   // Sanity check that this transform wouldn't cause w<0 clipping.
   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);
+  gfx::Rect viewport_in_layer_space =
+      ViewportInLayerSpace(current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   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
                                gfx::Transform());  // draw transform
+  tiling->CreateInterestRectTilesForTesting();
 
   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 59 matching lines @@
   MathUtil::MapQuad(current_screen_transform,
                     gfx::QuadF(gfx::RectF(0, 0, 100, 200)),
                     &clipped);
   ASSERT_TRUE(clipped);
 
   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);
+  gfx::Rect viewport_in_layer_space =
+      ViewportInLayerSpace(current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   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
                                gfx::Transform());  // draw transform
+  tiling->CreateInterestRectTilesForTesting();
 
   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 29 matching lines @@
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
   double last_frame_time_in_seconds = 1.0;
   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);
+  gfx::Rect viewport_in_layer_space =
+      ViewportInLayerSpace(current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   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
                                NULL,               // render target
                                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->CreateInterestRectTilesForTesting();
 
   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 36 matching lines @@
   //  - the top-left tile becomes visible on rotation
   //  - the top-right tile will have an infinite time_to_visible
   //    because it is rotating away from viewport.
   //  - bottom-left layer will have a positive non-zero time_to_visible
   //    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);
+  gfx::Rect viewport_in_layer_space =
+      ViewportInLayerSpace(current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
   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
                                NULL,               // render target
                                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->CreateInterestRectTilesForTesting();
 
   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);
 }
 
 }  // namespace
 }  // namespace cc