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 < 2; ++bundle_y) {
+    for (int bundle_x = 0; bundle_x < 2; ++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 < 2; ++tile_y) {

[enne (OOO), 2013/12/03 02:28:37]

Is it possible to not make this depend on the magic bundle constants?

[vmpstr, 2013/12/03 18:44:43]

I changed this to be kTileBundle{Width,Height} which is already defined here.
It's hard not to rely on some particular constant, since I'm testing
tiling->BundleAt()->TileAt() vs tiling->TileAt() here, which means I have to
figure out what the BundleAt and TileAt indexes are independently.

I could expose BundleAt index_offset stuff, but I would prefer not to, since
it's then testing more of consistency instead of correctness (ie, it's
consistent that if bundle offset is this, then it has tiles with those
offsets... but whether those tiles actually belong in there is not known). I
don't know if I'm making any sense :P

+        for (int tile_x = 0; tile_x < 2; ++tile_x) {
+          int global_tile_x = bundle_x * 2 + tile_x;
+          int global_tile_y = bundle_y * 2 + 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));
+  bool success = true;
+  for (int y = -20; (y <= 102) && success; ++y) {
+    for (int x = 0; (x <= 103) && success; ++x) {
+      for (int size = 1; (size <= 201) && success; 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()));
+        }
+
+        EXPECT_EQ(tile_positions.size(), iteration_count) << rect.ToString();
+        if (tile_positions.size() != iteration_count)
+          success = false;

[enne (OOO), 2013/12/03 02:28:37]

Why do you need this success variable with EXPECT_EQ on the previous line?

[vmpstr, 2013/12/03 18:44:43]

Oh this is just so it doesn't spam a lot of lines if _everything_ breaks. I can
remove this if that's better?

[enne (OOO), 2013/12/03 20:49:01]

You could make them ASSERT instead of EXPECT and it'll abort?

[vmpstr, 2013/12/03 22:01:36]

Done.

+
+        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()));
+        }
+
+        EXPECT_EQ(bundle_positions.size(), iteration_count) << rect.ToString();
+        EXPECT_EQ(predicted_bundle_positions.size(), iteration_count)
+            << rect.ToString();
+        if ((bundle_positions.size() != iteration_count) ||
+            (predicted_bundle_positions.size() != iteration_count))
+          success = false;
+
+        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) {
+          EXPECT_EQ(*actual_iterator, *predicted_iterator) << rect.ToString();
+          if (*actual_iterator != *predicted_iterator)
+            success = false;
+
+          ++predicted_iterator;
+        }
+      }
+    }
+  }
+  EXPECT_TRUE(success);
+}
+
+
 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