cc: Added tile bundles

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_picture_layer_tiling_client.h"
+#include "cc/test/fake_tile_manager.h"
+#include "cc/test/fake_tile_manager_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
 namespace {
 
+const int kTileBundleWidth = 2;
+const int kTileBundleHeight = 2;
+std::pair<int, int> ComputeTileBundleIndex(int i, int j) {
+  return std::make_pair(i / kTileBundleWidth, j / kTileBundleHeight);
+}
+
 static gfx::Rect ViewportInLayerSpace(
     const gfx::Transform& transform,
     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);
 }
 
 class TestablePictureLayerTiling : public PictureLayerTiling {
  public:
   using PictureLayerTiling::SetLiveTilesRect;
   using PictureLayerTiling::TileAt;
+  using PictureLayerTiling::TileBundleAt;
 
   static scoped_ptr<TestablePictureLayerTiling> Create(
       float contents_scale,
       gfx::Size layer_bounds,
       PictureLayerTilingClient* client) {
     return make_scoped_ptr(new TestablePictureLayerTiling(
         contents_scale,
         layer_bounds,
         client));
   }
 
+  TilingData tiling_data() const { return tiling_data_; }
+  TilingData bundle_tiling_data() const { return bundle_tiling_data_; }
+
  protected:
   TestablePictureLayerTiling(float contents_scale,
                              gfx::Size layer_bounds,
                              PictureLayerTilingClient* client)
       : PictureLayerTiling(contents_scale, layer_bounds, client) { }
 };
 
 class PictureLayerTilingIteratorTest : public testing::Test {
  public:
-  PictureLayerTilingIteratorTest() {}
+  PictureLayerTilingIteratorTest()
+      : tile_manager_(&tile_manager_client_), client_(&tile_manager_) {}
+
   virtual ~PictureLayerTilingIteratorTest() {}
 
   void Initialize(gfx::Size tile_size,
                   float contents_scale,
                   gfx::Size layer_bounds) {
     client_.SetTileSize(tile_size);
     tiling_ = TestablePictureLayerTiling::Create(contents_scale,
                                                  layer_bounds,
                                                  &client_);
   }
 
   void SetLiveRectAndVerifyTiles(gfx::Rect live_tiles_rect) {
+    tiling_->SetTreeForTesting(ACTIVE_TREE);
     tiling_->SetLiveTilesRect(live_tiles_rect);
 
     std::vector<Tile*> tiles = tiling_->AllTilesForTesting();
     for (std::vector<Tile*>::iterator iter = tiles.begin();
          iter != tiles.end();
          ++iter) {
       EXPECT_TRUE(live_tiles_rect.Intersects((*iter)->content_rect()));
     }
   }
 
@@ skipping 66 matching lines @@
 
   void VerifyTilesCoverNonContainedRect(float rect_scale, gfx::Rect dest_rect) {
     float dest_to_contents_scale = tiling_->contents_scale() / rect_scale;
     gfx::Rect clamped_rect = gfx::ScaleToEnclosingRect(
         tiling_->ContentRect(), 1.f / dest_to_contents_scale);
     clamped_rect.Intersect(dest_rect);
     VerifyTilesExactlyCoverRect(rect_scale, dest_rect, clamped_rect);
   }
 
  protected:
+  FakeTileManagerClient tile_manager_client_;
+  FakeTileManager tile_manager_;
   FakePictureLayerTilingClient client_;
   scoped_ptr<TestablePictureLayerTiling> tiling_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PictureLayerTilingIteratorTest);
 };
 
 TEST_F(PictureLayerTilingIteratorTest, LiveTilesExactlyCoverLiveTileRect) {
   Initialize(gfx::Size(100, 100), 1, gfx::Size(1099, 801));
   SetLiveRectAndVerifyTiles(gfx::Rect(100, 100));
@@ skipping 88 matching lines @@
   VerifyTilesCoverNonContainedRect(1.0f, gfx::Rect(-1000, -1000, 2000, 2000));
   VerifyTilesCoverNonContainedRect(1.5f, gfx::Rect(-1000, -1000, 2000, 2000));
   VerifyTilesCoverNonContainedRect(0.5f, gfx::Rect(-1000, -1000, 2000, 2000));
 
   // Partially covering content, but too large
   VerifyTilesCoverNonContainedRect(1.0f, gfx::Rect(-1000, 100, 2000, 100));
   VerifyTilesCoverNonContainedRect(1.5f, gfx::Rect(-1000, 100, 2000, 100));
   VerifyTilesCoverNonContainedRect(0.5f, gfx::Rect(-1000, 100, 2000, 100));
 }
 
+TEST(PictureLayerTilingTest, BundleAtContainsTileAt) {
+  FakeTileManagerClient tile_manager_client;
+  FakeTileManager tile_manager(&tile_manager_client);
+  FakePictureLayerTilingClient client(&tile_manager);
+
+  gfx::Size current_layer_bounds(400, 400);
+  client.SetTileSize(gfx::Size(100, 100));
+  scoped_ptr<TestablePictureLayerTiling> tiling =
+      TestablePictureLayerTiling::Create(1.0f, current_layer_bounds, &client);
+
+  tiling->CreateTilesForTesting(ACTIVE_TREE);
+  for (int bundle_y = 0;
+       bundle_y < (current_layer_bounds.height() / (kTileBundleHeight * 100));
+       ++bundle_y) {
+    for (int bundle_x = 0;
+         bundle_x < (current_layer_bounds.width() / (kTileBundleWidth * 100));
+         ++bundle_x) {
+      EXPECT_TRUE(tiling->TileBundleAt(bundle_x, bundle_y))
+          << "bundle_x " << bundle_x << " bundle_y " << bundle_y;
+
+      TileBundle* bundle = tiling->TileBundleAt(bundle_x, bundle_y);
+      for (int tile_y = 0; tile_y < kTileBundleWidth; ++tile_y) {
+        for (int tile_x = 0; tile_x < kTileBundleHeight; ++tile_x) {
+          int global_tile_x = bundle_x * kTileBundleWidth + tile_x;
+          int global_tile_y = bundle_y * kTileBundleHeight + tile_y;
+
+          EXPECT_TRUE(tiling->TileAt(ACTIVE_TREE, global_tile_x, global_tile_y))
+              << "x " << global_tile_x << " y " << global_tile_y;
+          EXPECT_EQ(tiling->TileAt(ACTIVE_TREE, global_tile_x, global_tile_y),
+                    bundle->TileAt(ACTIVE_TREE, global_tile_x, global_tile_y))
+              << "x " << global_tile_x << " y " << global_tile_y;
+        }
+      }
+    }
+  }
+}
+
+TEST(PictureLayerTilingTest, DidBecomeActiveSwapsTiles) {
+  FakeTileManagerClient tile_manager_client;
+  FakeTileManager tile_manager(&tile_manager_client);
+  FakePictureLayerTilingClient client(&tile_manager);
+
+  gfx::Size current_layer_bounds(400, 400);
+  client.SetTileSize(gfx::Size(100, 100));
+  scoped_ptr<TestablePictureLayerTiling> tiling =
+      TestablePictureLayerTiling::Create(1.0f, current_layer_bounds, &client);
+
+  tiling->CreateTilesForTesting(ACTIVE_TREE);
+  std::vector<Tile*> old_active_tiles = tiling->TilesForTesting(ACTIVE_TREE);
+  tiling->DidBecomeActive();
+  std::vector<Tile*> pending_tiles = tiling->TilesForTesting(PENDING_TREE);
+  EXPECT_EQ(old_active_tiles.size(), pending_tiles.size());
+  std::vector<Tile*>::const_iterator old_it = old_active_tiles.begin();
+  for (std::vector<Tile*>::const_iterator it = pending_tiles.begin();
+       it != pending_tiles.end();
+       ++it) {
+    EXPECT_EQ(*it, *old_it);
+    ++old_it;
+  }
+}
+
 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(
       in, target_area, bounds, NULL);
   EXPECT_EQ(in.ToString(), out.ToString());
 }
 
 TEST(PictureLayerTilingTest, ExpandRectSmaller) {
@@ skipping 451 matching lines @@
       gfx::Transform(),  // current screen transform
       1.0,  // current frame time
       10000);  // max tiles in tile manager
 
   VerifyTiles(pending_set.tiling_at(0),
               1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&TileExists, true));
 }
 
+TEST_F(PictureLayerTilingIteratorTest, BundlesAndTilesAlign) {
+  Initialize(gfx::Size(100, 100), 1, gfx::Size(850, 850));
+  for (int y = -20; y <= 102; ++y) {
+    for (int x = 0; x <= 103; ++x) {
+      for (int size = 1; size <= 201; size += 50) {
+        gfx::Rect rect(x, y, size, size);
+
+        TilingData tiling_data = tiling_->tiling_data();
+
+        std::set<std::pair<int, int> > tile_positions;
+        std::set<std::pair<int, int> > predicted_bundle_positions;
+        size_t iteration_count = 0;
+        for (TilingData::Iterator iter(&tiling_data, rect); iter; ++iter) {
+          ++iteration_count;
+          tile_positions.insert(std::make_pair(iter.index_x(), iter.index_y()));
+          predicted_bundle_positions.insert(
+              ComputeTileBundleIndex(iter.index_x(), iter.index_y()));
+        }
+
+        ASSERT_EQ(tile_positions.size(), iteration_count) << rect.ToString();
+
+        TilingData bundle_tiling_data = tiling_->bundle_tiling_data();
+        std::set<std::pair<int, int> > bundle_positions;
+        iteration_count = 0;
+        for (TilingData::Iterator iter(&bundle_tiling_data, rect);
+             iter;
+             ++iter) {
+          ++iteration_count;
+          bundle_positions.insert(
+              std::make_pair(iter.index_x(), iter.index_y()));
+        }
+
+        ASSERT_EQ(bundle_positions.size(), iteration_count) << rect.ToString();
+        ASSERT_EQ(predicted_bundle_positions.size(), iteration_count)
+            << rect.ToString();
+
+        std::set<std::pair<int, int> >::const_iterator predicted_iterator =
+            predicted_bundle_positions.begin();
+        for (std::set<std::pair<int, int> >::const_iterator actual_iterator =
+                 bundle_positions.begin();
+             actual_iterator != bundle_positions.end();
+             ++actual_iterator) {
+          ASSERT_EQ(*actual_iterator, *predicted_iterator) << rect.ToString();
+          ++predicted_iterator;
+        }
+      }
+    }
+  }
+}
+
+
 TEST(UpdateTilePrioritiesTest, VisibleTiles) {
   // The TilePriority of visible tiles should have zero distance_to_visible
   // and time_to_visible.
 
-  FakePictureLayerTilingClient client;
+  FakeTileManagerClient tile_manager_client;
+  FakeTileManager tile_manager(&tile_manager_client);
+  FakePictureLayerTilingClient client(&tile_manager);
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Rect visible_layer_rect(0, 0, 200, 200);
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
   float last_layer_contents_scale = 1.f;
   float current_layer_contents_scale = 1.f;
   gfx::Transform last_screen_transform;
   gfx::Transform current_screen_transform;
@@ skipping 15 matching lines @@
       visible_layer_rect,
       last_layer_bounds,
       current_layer_bounds,
       last_layer_contents_scale,
       current_layer_contents_scale,
       last_screen_transform,
       current_screen_transform,
       current_frame_time_in_seconds,
       max_tiles_for_interest_area);
 
-  ASSERT_TRUE(tiling->TileAt(0, 0));
-  ASSERT_TRUE(tiling->TileAt(0, 1));
-  ASSERT_TRUE(tiling->TileAt(1, 0));
-  ASSERT_TRUE(tiling->TileAt(1, 1));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 0, 0));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 0, 1));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 1, 0));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 1, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 0));
 
-  TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
-  EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
-
-  priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
-  EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
-
-  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
-  EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
-  EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
-
-  priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
+  TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
   EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
 }
 
 TEST(UpdateTilePrioritiesTest, OffscreenTiles) {
   // The TilePriority of offscreen tiles (without movement) should have nonzero
   // distance_to_visible and infinite time_to_visible.
 
-  FakePictureLayerTilingClient client;
+  FakeTileManagerClient tile_manager_client;
+  FakeTileManager tile_manager(&tile_manager_client);
+  FakePictureLayerTilingClient client(&tile_manager);
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Rect visible_layer_rect(0, 0, 0, 0);  // offscreen; nothing is visible.
-  gfx::Size last_layer_bounds(200, 200);
-  gfx::Size current_layer_bounds(200, 200);
+  gfx::Size last_layer_bounds(400, 400);
+  gfx::Size current_layer_bounds(400, 400);
   float last_layer_contents_scale = 1.f;
   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;
   size_t max_tiles_for_interest_area = 10000;
 
   current_screen_transform.Translate(850, 0);
   last_screen_transform = current_screen_transform;
 
@@ skipping 12 matching lines @@
       visible_layer_rect,
       last_layer_bounds,
       current_layer_bounds,
       last_layer_contents_scale,
       current_layer_contents_scale,
       last_screen_transform,
       current_screen_transform,
       current_frame_time_in_seconds,
       max_tiles_for_interest_area);
 
-  ASSERT_TRUE(tiling->TileAt(0, 0));
-  ASSERT_TRUE(tiling->TileAt(0, 1));
-  ASSERT_TRUE(tiling->TileAt(1, 0));
-  ASSERT_TRUE(tiling->TileAt(1, 1));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 0, 0));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 0, 1));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 1, 0));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 1, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 0));
 
-  TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
+  TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 2, 2));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 2, 3));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 3, 2));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 3, 3));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(1, 0));
+  ASSERT_TRUE(tiling->TileBundleAt(1, 1));
 
-  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
-
-  priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
-  EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
-                  priority.time_to_visible_in_seconds);
-
-  // Furthermore, in this scenario tiles on the right hand side should have a
+  // Furthermore, in this scenario bundles on the right hand side should have a
   // larger distance to visible.
-  TilePriority left = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
-  TilePriority right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
+  TilePriority left = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
+  TilePriority right = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(right.distance_to_visible_in_pixels,
             left.distance_to_visible_in_pixels);
 
-  left = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
-  right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
+  left = tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
+  right = tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(right.distance_to_visible_in_pixels,
             left.distance_to_visible_in_pixels);
 }
 
 TEST(UpdateTilePrioritiesTest, PartiallyOffscreenLayer) {
   // Sanity check that a layer with some tiles visible and others offscreen has
   // correct TilePriorities for each tile.
 
-  FakePictureLayerTilingClient client;
+  FakeTileManagerClient tile_manager_client;
+  FakeTileManager tile_manager(&tile_manager_client);
+  FakePictureLayerTilingClient client(&tile_manager);
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Rect visible_layer_rect(0, 0, 100, 100);  // only top quarter.
-  gfx::Size last_layer_bounds(200, 200);
-  gfx::Size current_layer_bounds(200, 200);
+  gfx::Size last_layer_bounds(400, 400);
+  gfx::Size current_layer_bounds(400, 400);
   float last_layer_contents_scale = 1.f;
   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;
   size_t max_tiles_for_interest_area = 10000;
 
   current_screen_transform.Translate(705, 505);
   last_screen_transform = current_screen_transform;
 
@@ skipping 12 matching lines @@
       visible_layer_rect,
       last_layer_bounds,
       current_layer_bounds,
       last_layer_contents_scale,
       current_layer_contents_scale,
       last_screen_transform,
       current_screen_transform,
       current_frame_time_in_seconds,
       max_tiles_for_interest_area);
 
-  ASSERT_TRUE(tiling->TileAt(0, 0));
-  ASSERT_TRUE(tiling->TileAt(0, 1));
-  ASSERT_TRUE(tiling->TileAt(1, 0));
-  ASSERT_TRUE(tiling->TileAt(1, 1));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 0, 0));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 0, 1));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 1, 0));
+  ASSERT_TRUE(tiling->TileAt(ACTIVE_TREE, 1, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 0));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(1, 0));
+  ASSERT_TRUE(tiling->TileBundleAt(1, 1));
 
-  TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
+  TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
   EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 }
 
 TEST(UpdateTilePrioritiesTest, PartiallyOffscreenRotatedLayer) {
   // Each tile of a layer may be affected differently by a transform; Check
   // that UpdateTilePriorities correctly accounts for the transform between
   // layer space and screen space.
 
-  FakePictureLayerTilingClient client;
+  FakeTileManagerClient tile_manager_client;
+  FakeTileManager tile_manager(&tile_manager_client);
+  FakePictureLayerTilingClient client(&tile_manager);
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Rect visible_layer_rect(0, 0, 100, 100);  // only top-left quarter.
-  gfx::Size last_layer_bounds(200, 200);
-  gfx::Size current_layer_bounds(200, 200);
+  gfx::Size last_layer_bounds(400, 400);
+  gfx::Size current_layer_bounds(400, 400);
   float last_layer_contents_scale = 1.f;
   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;
   size_t max_tiles_for_interest_area = 10000;
 
   // 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(400, 550);
@@ skipping 15 matching lines @@
       visible_layer_rect,
       last_layer_bounds,
       current_layer_bounds,
       last_layer_contents_scale,
       current_layer_contents_scale,
       last_screen_transform,
       current_screen_transform,
       current_frame_time_in_seconds,
       max_tiles_for_interest_area);
 
-  ASSERT_TRUE(tiling->TileAt(0, 0));
-  ASSERT_TRUE(tiling->TileAt(0, 1));
-  ASSERT_TRUE(tiling->TileAt(1, 0));
-  ASSERT_TRUE(tiling->TileAt(1, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 0));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(1, 0));
+  ASSERT_TRUE(tiling->TileBundleAt(1, 1));
 
-  TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
+  TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
   EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 
   // Furthermore, in this scenario the bottom-right tile should have the larger
   // distance to visible.
-  TilePriority top_left = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
-  TilePriority top_right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
-  TilePriority bottom_left = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
-  TilePriority bottom_right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
+  TilePriority top_left = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
+  TilePriority top_right = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
+  TilePriority bottom_left =
+      tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
+  TilePriority bottom_right =
+      tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(top_right.distance_to_visible_in_pixels,
             top_left.distance_to_visible_in_pixels);
   EXPECT_GT(bottom_left.distance_to_visible_in_pixels,
             top_left.distance_to_visible_in_pixels);
 
   EXPECT_GT(bottom_right.distance_to_visible_in_pixels,
             bottom_left.distance_to_visible_in_pixels);
   EXPECT_GT(bottom_right.distance_to_visible_in_pixels,
             top_right.distance_to_visible_in_pixels);
 }
 
 TEST(UpdateTilePrioritiesTest, PerspectiveLayer) {
   // Perspective transforms need to take a different code path.
   // This test checks tile priorities of a perspective layer.
 
-  FakePictureLayerTilingClient client;
+  FakeTileManagerClient tile_manager_client;
+  FakeTileManager tile_manager(&tile_manager_client);
+  FakePictureLayerTilingClient client(&tile_manager);
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Rect visible_layer_rect(0, 0, 0, 0);  // offscreen.
-  gfx::Size last_layer_bounds(200, 200);
-  gfx::Size current_layer_bounds(200, 200);
+  gfx::Size last_layer_bounds(400, 400);
+  gfx::Size current_layer_bounds(400, 400);
   float last_layer_contents_scale = 1.f;
   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;
   size_t max_tiles_for_interest_area = 10000;
 
   // A 3d perspective layer rotated about its Y axis, translated to almost
   // fully offscreen. The left side will appear closer (i.e. larger in 2d) than
   // the right side, so the top-left tile will technically be closer than the
@@ skipping 30 matching lines @@
       visible_layer_rect,
       last_layer_bounds,
       current_layer_bounds,
       last_layer_contents_scale,
       current_layer_contents_scale,
       last_screen_transform,
       current_screen_transform,
       current_frame_time_in_seconds,
       max_tiles_for_interest_area);
 
-  ASSERT_TRUE(tiling->TileAt(0, 0));
-  ASSERT_TRUE(tiling->TileAt(0, 1));
-  ASSERT_TRUE(tiling->TileAt(1, 0));
-  ASSERT_TRUE(tiling->TileAt(1, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 0));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(1, 0));
+  ASSERT_TRUE(tiling->TileBundleAt(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);
+  TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 
   // Furthermore, in this scenario the top-left distance_to_visible
   // will be smallest, followed by top-right. The bottom layers
   // will of course be further than the top layers.
-  TilePriority top_left = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
-  TilePriority top_right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
-  TilePriority bottom_left = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
-  TilePriority bottom_right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
+  TilePriority top_left = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
+  TilePriority top_right = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
+  TilePriority bottom_left =
+      tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
+  TilePriority bottom_right =
+      tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(top_right.distance_to_visible_in_pixels,
             top_left.distance_to_visible_in_pixels);
 
   EXPECT_GT(bottom_right.distance_to_visible_in_pixels,
             top_right.distance_to_visible_in_pixels);
 
   EXPECT_GT(bottom_left.distance_to_visible_in_pixels,
             top_left.distance_to_visible_in_pixels);
 }
 
 TEST(UpdateTilePrioritiesTest, PerspectiveLayerClippedByW) {
   // Perspective transforms need to take a different code path.
   // This test checks tile priorities of a perspective layer.
 
-  FakePictureLayerTilingClient client;
+  FakeTileManagerClient tile_manager_client;
+  FakeTileManager tile_manager(&tile_manager_client);
+  FakePictureLayerTilingClient client(&tile_manager);
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Rect visible_layer_rect(0, 0, 0, 0);  // offscreen.
-  gfx::Size last_layer_bounds(200, 200);
-  gfx::Size current_layer_bounds(200, 200);
+  gfx::Size last_layer_bounds(400, 400);
+  gfx::Size current_layer_bounds(400, 400);
   float last_layer_contents_scale = 1.f;
   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;
   size_t max_tiles_for_interest_area = 10000;
 
   // A 3d perspective layer rotated about its Y axis, translated to almost
   // fully offscreen. The left side will appear closer (i.e. larger in 2d) than
   // the right side, so the top-left tile will technically be closer than the
   // top-right.
 
   // Translate layer to offscreen
   current_screen_transform.Translate(400.0, 970.0);
   // Apply perspective and rotation about the center of the layer
-  current_screen_transform.Translate(100.0, 100.0);
+  current_screen_transform.Translate(200.0, 200.0);
   current_screen_transform.ApplyPerspectiveDepth(10.0);
   current_screen_transform.RotateAboutYAxis(10.0);
-  current_screen_transform.Translate(-100.0, -100.0);
+  current_screen_transform.Translate(-200.0, -200.0);
   last_screen_transform = current_screen_transform;
 
   // Sanity check that this transform does cause w<0 clipping for the left side
   // of the layer, but not the right side.
   bool clipped;
   MathUtil::MapQuad(current_screen_transform,
-                    gfx::QuadF(gfx::RectF(0, 0, 100, 200)),
+                    gfx::QuadF(gfx::RectF(0, 0, 200, 400)),
                     &clipped);
   ASSERT_TRUE(clipped);
 
   MathUtil::MapQuad(current_screen_transform,
-                    gfx::QuadF(gfx::RectF(100, 0, 100, 200)),
+                    gfx::QuadF(gfx::RectF(200, 0, 200, 400)),
                     &clipped);
   ASSERT_FALSE(clipped);
 
   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,
       device_viewport,
       viewport_in_layer_space,
       visible_layer_rect,
       last_layer_bounds,
       current_layer_bounds,
       last_layer_contents_scale,
       current_layer_contents_scale,
       last_screen_transform,
       current_screen_transform,
       current_frame_time_in_seconds,
       max_tiles_for_interest_area);
 
-  ASSERT_TRUE(tiling->TileAt(0, 0));
-  ASSERT_TRUE(tiling->TileAt(0, 1));
-  ASSERT_TRUE(tiling->TileAt(1, 0));
-  ASSERT_TRUE(tiling->TileAt(1, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 0));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(1, 0));
+  ASSERT_TRUE(tiling->TileBundleAt(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);
+  TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
   EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
   EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
 
   // Right-side tiles will have a positive distance_to_visible
   // and an infinite time_to_visible.
-  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 }
 
 TEST(UpdateTilePrioritiesTest, BasicMotion) {
   // Test that time_to_visible is computed correctly when
   // there is some motion.
 
-  FakePictureLayerTilingClient client;
+  FakeTileManagerClient tile_manager_client;
+  FakeTileManager tile_manager(&tile_manager_client);
+  FakePictureLayerTilingClient client(&tile_manager);
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Rect visible_layer_rect(0, 0, 0, 0);
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
   float last_layer_contents_scale = 1.f;
   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;
   size_t max_tiles_for_interest_area = 10000;
 
   // Offscreen layer is coming closer to viewport at 1000 pixels per second.
   current_screen_transform.Translate(1800, 0);
   last_screen_transform.Translate(2800, 0);
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
-  client.SetTileSize(gfx::Size(100, 100));
+  client.SetTileSize(gfx::Size(50, 50));
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
   // previous ("last") frame
   tiling->UpdateTilePriorities(
       ACTIVE_TREE,
       device_viewport,
       viewport_in_layer_space,
       visible_layer_rect,
@@ skipping 14 matching lines @@
       visible_layer_rect,
       last_layer_bounds,
       current_layer_bounds,
       last_layer_contents_scale,
       current_layer_contents_scale,
       last_screen_transform,
       current_screen_transform,
       current_frame_time_in_seconds,
       max_tiles_for_interest_area);
 
-  ASSERT_TRUE(tiling->TileAt(0, 0));
-  ASSERT_TRUE(tiling->TileAt(0, 1));
-  ASSERT_TRUE(tiling->TileAt(1, 0));
-  ASSERT_TRUE(tiling->TileAt(1, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 0));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(1, 0));
+  ASSERT_TRUE(tiling->TileBundleAt(1, 1));
 
-  TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
+  TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(1.f,
                   priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(1.f,
                   priority.time_to_visible_in_seconds);
 
-  // time_to_visible for the right hand side layers needs an extra 0.099
-  // seconds because this tile is 99 pixels further away.
-  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
+  // time_to_visible for the right hand side layers needs an extra 0.097
+  // seconds because this bundle is
+  // |(50 - 2 * border_texels) * 2 + border_texels| = 97 pixels further away.
+  priority = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(1.099f,
+  EXPECT_FLOAT_EQ(1.097f,
                   priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(1, 1)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
-  EXPECT_FLOAT_EQ(1.099f,
+  EXPECT_FLOAT_EQ(1.097f,
                   priority.time_to_visible_in_seconds);
 }
 
 TEST(UpdateTilePrioritiesTest, RotationMotion) {
   // Each tile of a layer may be affected differently by a transform; Check
   // that UpdateTilePriorities correctly accounts for the transform between
   // layer space and screen space.
 
-  FakePictureLayerTilingClient client;
+  FakeTileManagerClient tile_manager_client;
+  FakeTileManager tile_manager(&tile_manager_client);
+  FakePictureLayerTilingClient client(&tile_manager);
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Size device_viewport(800, 600);
   gfx::Rect visible_layer_rect(0, 0, 0, 0);  // offscren.
   gfx::Size last_layer_bounds(200, 200);
   gfx::Size current_layer_bounds(200, 200);
   float last_layer_contents_scale = 1.f;
   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;
   size_t max_tiles_for_interest_area = 10000;
 
   // Rotation motion is set up specifically so that:
   //  - rotation occurs about the center of the layer
   //  - 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);
 
-  client.SetTileSize(gfx::Size(100, 100));
+  client.SetTileSize(gfx::Size(50, 50));
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
 
   // previous ("last") frame
   tiling->UpdateTilePriorities(
       ACTIVE_TREE,
       device_viewport,
       viewport_in_layer_space,
       visible_layer_rect,
@@ skipping 14 matching lines @@
       visible_layer_rect,
       last_layer_bounds,
       current_layer_bounds,
       last_layer_contents_scale,
       current_layer_contents_scale,
       last_screen_transform,
       current_screen_transform,
       current_frame_time_in_seconds,
       max_tiles_for_interest_area);
 
-  ASSERT_TRUE(tiling->TileAt(0, 0));
-  ASSERT_TRUE(tiling->TileAt(0, 1));
-  ASSERT_TRUE(tiling->TileAt(1, 0));
-  ASSERT_TRUE(tiling->TileAt(1, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 0));
+  ASSERT_TRUE(tiling->TileBundleAt(0, 1));
+  ASSERT_TRUE(tiling->TileBundleAt(1, 0));
+  ASSERT_TRUE(tiling->TileBundleAt(1, 1));
 
-  TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
+  TilePriority priority = tiling->TileBundleAt(0, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels);
   EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds);
 
-  priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(0, 1)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_GT(priority.time_to_visible_in_seconds, 0.f);
 
-  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
+  priority = tiling->TileBundleAt(1, 0)->GetPriority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 }
 
 }  // namespace
 }  // namespace cc