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 275 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),

[vmpstr, 2014/07/02 23:51:29]

I think it makes sense for us to use bordered rects as the distance metric,
since we already use the bordered rects to determine bins. This effectively
makes most tiles distance to visible be smaller than it was before, without
touching 0, so the overall order of tiles is unaffected.

   // 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
@@ skipping 11 matching lines @@
   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_->CreateAllTilesForTesting();
   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