Revert of cc: Remove tile sharing from tilings.

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.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/fake_picture_pile_impl.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/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
@@ skipping 58 matching lines @@
   ~PictureLayerTilingIteratorTest() override {}
 
   void Initialize(const gfx::Size& tile_size,
                   float contents_scale,
                   const gfx::Size& layer_bounds) {
     client_.SetTileSize(tile_size);
     client_.set_tree(PENDING_TREE);
     scoped_refptr<FakePicturePileImpl> pile =
         FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
     tiling_ = TestablePictureLayerTiling::Create(contents_scale, pile, &client_,
-                                                 LayerTreeSettings());
-  }
-
-  void InitializeActive(const gfx::Size& tile_size,
-                        float contents_scale,
-                        const gfx::Size& layer_bounds) {
-    client_.SetTileSize(tile_size);
-    client_.set_tree(ACTIVE_TREE);
-    scoped_refptr<FakePicturePileImpl> pile =
-        FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(layer_bounds);
-    tiling_ = TestablePictureLayerTiling::Create(contents_scale, pile, &client_,
                                                  LayerTreeSettings());
   }
 
   void SetLiveRectAndVerifyTiles(const gfx::Rect& live_tiles_rect) {
     tiling_->SetLiveTilesRect(live_tiles_rect);
 
     std::vector<Tile*> tiles = tiling_->AllTilesForTesting();
     for (std::vector<Tile*>::iterator iter = tiles.begin();
          iter != tiles.end();
          ++iter) {
@@ skipping 83 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PictureLayerTilingIteratorTest);
 };
 
 TEST_F(PictureLayerTilingIteratorTest, ResizeDeletesTiles) {
   // Verifies that a resize with invalidation for newly exposed pixels will
   // deletes tiles that intersect that invalidation.
   gfx::Size tile_size(100, 100);
   gfx::Size original_layer_size(10, 10);
-  InitializeActive(tile_size, 1.f, original_layer_size);
+  Initialize(tile_size, 1.f, original_layer_size);
   SetLiveRectAndVerifyTiles(gfx::Rect(original_layer_size));
 
   // Tiling only has one tile, since its total size is less than one.
   EXPECT_TRUE(tiling_->TileAt(0, 0));
 
   // Stop creating tiles so that any invalidations are left as holes.
   gfx::Size new_layer_size(200, 200);
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateEmptyPileWithDefaultTileSize(new_layer_size);
 
@@ skipping 195 matching lines @@
     for (int j = 0; j < 4; ++j)
       EXPECT_TRUE(tiling_->TileAt(i, j)) << i << "," << j;
   }
 }
 
 TEST_F(PictureLayerTilingIteratorTest, ResizeOverBorderPixelsDeletesTiles) {
   // Verifies that a resize with invalidation for newly exposed pixels will
   // deletes tiles that intersect that invalidation.
   gfx::Size tile_size(100, 100);
   gfx::Size original_layer_size(99, 99);
-  InitializeActive(tile_size, 1.f, original_layer_size);
+  Initialize(tile_size, 1.f, original_layer_size);
   SetLiveRectAndVerifyTiles(gfx::Rect(original_layer_size));
 
   // Tiling only has one tile, since its total size is less than one.
   EXPECT_TRUE(tiling_->TileAt(0, 0));
 
   // Stop creating tiles so that any invalidations are left as holes.
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateEmptyPileWithDefaultTileSize(
           gfx::Size(200, 200));
   tiling_->SetRasterSourceAndResize(pile);
@@ skipping 377 matching lines @@
 
   // No movement in the viewport implies that tiles will either be NOW
   // or EVENTUALLY, with the exception of tiles that are between 0 and 312
   // pixels away from the viewport, which will be in the SOON bin.
   bool have_now = false;
   bool have_eventually = false;
   bool have_soon = false;
   for (int i = 0; i < 47; ++i) {
     for (int j = 0; j < 47; ++j) {
       Tile* tile = tiling->TileAt(i, j);
-      TilePriority priority = tile->priority();
+      TilePriority priority = tile->priority(ACTIVE_TREE);
 
       gfx::Rect tile_rect = tiling->TilingDataForTesting().TileBounds(i, j);
       if (viewport_in_content_space.Intersects(tile_rect)) {
         EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
         EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
         have_now = true;
       } else if (soon_rect_in_content_space.Intersects(tile_rect)) {
         EXPECT_EQ(TilePriority::SOON, priority.priority_bin);
         have_soon = true;
       } else {
@@ skipping 11 matching lines @@
   // Spot check some distances.
   // Tile at 5, 1 should begin at 41x9 in content space (without borders),
   // so the distance to a viewport that ends at 25x25 in content space
   // should be 17 (41 - 25 + 1). In layer space, then that should be
   // 17 / 0.25 = 68 pixels.
 
   // We can verify that the content rect (with borders) is one pixel off
   // 41,9 8x8 on all sides.
   EXPECT_EQ(tiling->TileAt(5, 1)->content_rect().ToString(), "40,8 10x10");
 
-  TilePriority priority = tiling->TileAt(5, 1)->priority();
+  TilePriority priority = tiling->TileAt(5, 1)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(68.f, priority.distance_to_visible);
 
-  priority = tiling->TileAt(2, 5)->priority();
+  priority = tiling->TileAt(2, 5)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(68.f, priority.distance_to_visible);
 
-  priority = tiling->TileAt(3, 4)->priority();
+  priority = tiling->TileAt(3, 4)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(40.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);
 
   // Compute the soon border.
   inset = PictureLayerTiling::CalculateSoonBorderDistance(
@@ skipping 11 matching lines @@
 
   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);
-      TilePriority priority = tile->priority();
+      TilePriority priority = tile->priority(ACTIVE_TREE);
 
       gfx::Rect tile_rect = tiling->TilingDataForTesting().TileBounds(i, j);
       if (viewport_in_content_space.Intersects(tile_rect)) {
         EXPECT_EQ(TilePriority::NOW, priority.priority_bin) << "i: " << i
                                                             << " j: " << j;
         EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible) << "i: " << i
                                                            << " j: " << j;
         have_now = true;
       } else if (skewport.Intersects(tile_rect) ||
                  soon_rect_in_content_space.Intersects(tile_rect)) {
         EXPECT_EQ(TilePriority::SOON, priority.priority_bin) << "i: " << i
                                                              << " j: " << j;
         EXPECT_GT(priority.distance_to_visible, 0.f) << "i: " << i
                                                      << " j: " << j;
         have_soon = true;
       } else {
         EXPECT_EQ(TilePriority::EVENTUALLY, priority.priority_bin)
             << "i: " << i << " j: " << j;
         EXPECT_GT(priority.distance_to_visible, 0.f) << "i: " << i
                                                      << " j: " << j;
         have_eventually = true;
       }
     }
   }
 
   EXPECT_TRUE(have_now);
   EXPECT_TRUE(have_soon);
   EXPECT_TRUE(have_eventually);
 
-  priority = tiling->TileAt(5, 1)->priority();
+  priority = tiling->TileAt(5, 1)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(68.f, priority.distance_to_visible);
 
-  priority = tiling->TileAt(2, 5)->priority();
+  priority = tiling->TileAt(2, 5)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(28.f, priority.distance_to_visible);
 
-  priority = tiling->TileAt(3, 4)->priority();
+  priority = tiling->TileAt(3, 4)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(4.f, priority.distance_to_visible);
 
   // Change the underlying layer scale.
   tiling->ComputeTilePriorityRects(viewport, 2.0f, 3.0, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
-  priority = tiling->TileAt(5, 1)->priority();
+  priority = tiling->TileAt(5, 1)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(136.f, priority.distance_to_visible);
 
-  priority = tiling->TileAt(2, 5)->priority();
+  priority = tiling->TileAt(2, 5)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(56.f, priority.distance_to_visible);
 
-  priority = tiling->TileAt(3, 4)->priority();
+  priority = tiling->TileAt(3, 4)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(8.f, priority.distance_to_visible);
 
   // Test additional scales.
   tiling = TestablePictureLayerTiling::Create(0.2f, pile, &client,
                                               LayerTreeSettings());
   tiling->ComputeTilePriorityRects(viewport, 1.0f, 4.0, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
-  priority = tiling->TileAt(5, 1)->priority();
+  priority = tiling->TileAt(5, 1)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(110.f, priority.distance_to_visible);
 
-  priority = tiling->TileAt(2, 5)->priority();
+  priority = tiling->TileAt(2, 5)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(70.f, priority.distance_to_visible);
 
-  priority = tiling->TileAt(3, 4)->priority();
+  priority = tiling->TileAt(3, 4)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(60.f, priority.distance_to_visible);
 
   tiling->ComputeTilePriorityRects(viewport, 0.5f, 5.0, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
-  priority = tiling->TileAt(5, 1)->priority();
+  priority = tiling->TileAt(5, 1)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(55.f, priority.distance_to_visible);
 
-  priority = tiling->TileAt(2, 5)->priority();
+  priority = tiling->TileAt(2, 5)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(35.f, priority.distance_to_visible);
 
-  priority = tiling->TileAt(3, 4)->priority();
+  priority = tiling->TileAt(3, 4)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(30.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(
       in, target_area, bounds, NULL);
   EXPECT_EQ(in.ToString(), out.ToString());
@@ skipping 347 matching lines @@
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
-  TilePriority priority = tiling->TileAt(0, 0)->priority();
+  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();
+  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();
+  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();
+  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(ComputeTilePriorityRectsTest, OffscreenTiles) {
   // The TilePriority of offscreen tiles (without movement) should have nonzero
   // distance_to_visible and infinite time_to_visible.
   FakePictureLayerTilingClient client;
 
   gfx::Size device_viewport(800, 600);
@@ skipping 23 matching lines @@
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
-  TilePriority priority = tiling->TileAt(0, 0)->priority();
+  TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
-  priority = tiling->TileAt(0, 1)->priority();
+  priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
-  priority = tiling->TileAt(1, 0)->priority();
+  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
-  priority = tiling->TileAt(1, 1)->priority();
+  priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   // Furthermore, in this scenario tiles on the right hand side should have a
   // larger distance to visible.
-  TilePriority left = tiling->TileAt(0, 0)->priority();
-  TilePriority right = tiling->TileAt(1, 0)->priority();
+  TilePriority left = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
+  TilePriority right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
   EXPECT_GT(right.distance_to_visible, left.distance_to_visible);
 
-  left = tiling->TileAt(0, 1)->priority();
-  right = tiling->TileAt(1, 1)->priority();
+  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(ComputeTilePriorityRectsTest, PartiallyOffscreenLayer) {
   // Sanity check that a layer with some tiles visible and others offscreen has
   // correct TilePriorities for each tile.
   FakePictureLayerTilingClient client;
 
   gfx::Size device_viewport(800, 600);
   gfx::Size last_layer_bounds(200, 200);
@@ skipping 22 matching lines @@
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
-  TilePriority priority = tiling->TileAt(0, 0)->priority();
+  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();
+  priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
-  priority = tiling->TileAt(1, 0)->priority();
+  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
-  priority = tiling->TileAt(1, 1)->priority();
+  priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 }
 
 TEST(ComputeTilePriorityRectsTest, PartiallyOffscreenRotatedLayer) {
   // Each tile of a layer may be affected differently by a transform; Check
   // that ComputeTilePriorityRects correctly accounts for the transform between
   // layer space and screen space.
   FakePictureLayerTilingClient client;
 
@@ skipping 27 matching lines @@
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
-  TilePriority priority = tiling->TileAt(0, 0)->priority();
+  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();
+  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();
+  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
-  priority = tiling->TileAt(1, 1)->priority();
+  priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   // Furthermore, in this scenario the bottom-right tile should have the larger
   // distance to visible.
-  TilePriority top_left = tiling->TileAt(0, 0)->priority();
-  TilePriority top_right = tiling->TileAt(1, 0)->priority();
-  TilePriority bottom_right = tiling->TileAt(1, 1)->priority();
+  TilePriority top_left = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
+  TilePriority top_right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
+  TilePriority bottom_right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(top_right.distance_to_visible, top_left.distance_to_visible);
 
   EXPECT_EQ(bottom_right.distance_to_visible, top_right.distance_to_visible);
 }
 
 TEST(ComputeTilePriorityRectsTest, PerspectiveLayer) {
   // Perspective transforms need to take a different code path.
   // This test checks tile priorities of a perspective layer.
   FakePictureLayerTilingClient client;
 
@@ skipping 45 matching lines @@
                                    current_frame_time_in_seconds, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   // All tiles will have a positive distance_to_visible
   // and an infinite time_to_visible.
-  TilePriority priority = tiling->TileAt(0, 0)->priority();
+  TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(priority.distance_to_visible, 0.f);
   EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
-  priority = tiling->TileAt(0, 1)->priority();
+  priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
-  priority = tiling->TileAt(1, 0)->priority();
+  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(priority.distance_to_visible, 0.f);
   EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
-  priority = tiling->TileAt(1, 1)->priority();
+  priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   // 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();
-  TilePriority top_right = tiling->TileAt(1, 0)->priority();
-  TilePriority bottom_left = tiling->TileAt(0, 1)->priority();
-  TilePriority bottom_right = tiling->TileAt(1, 1)->priority();
+  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);
 
   EXPECT_GT(bottom_right.distance_to_visible, top_right.distance_to_visible);
 
   EXPECT_GT(bottom_left.distance_to_visible, top_left.distance_to_visible);
 }
 
 TEST(ComputeTilePriorityRectsTest, PerspectiveLayerClippedByW) {
   // Perspective transforms need to take a different code path.
   // This test checks tile priorities of a perspective layer.
   FakePictureLayerTilingClient client;
@@ skipping 51 matching lines @@
                                    current_frame_time_in_seconds, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
   // Left-side tiles will be clipped by the transform, so we have to assume
   // they are visible just in case.
-  TilePriority priority = tiling->TileAt(0, 0)->priority();
+  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();
+  priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   // Right-side tiles will have a positive distance_to_visible
   // and an infinite time_to_visible.
-  priority = tiling->TileAt(1, 0)->priority();
+  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(priority.distance_to_visible, 0.f);
   EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
-  priority = tiling->TileAt(1, 1)->priority();
+  priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 }
 
 TEST(ComputeTilePriorityRectsTest, BasicMotion) {
   // Test that time_to_visible is computed correctly when
   // there is some motion.
   FakePictureLayerTilingClient client;
 
   gfx::Size device_viewport(800, 600);
@@ skipping 34 matching lines @@
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
-  TilePriority priority = tiling->TileAt(0, 0)->priority();
+  TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
-  priority = tiling->TileAt(0, 1)->priority();
+  priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
   // 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();
+  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
-  priority = tiling->TileAt(1, 1)->priority();
+  priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible, 0.f);
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 }
 
 TEST(ComputeTilePriorityRectsTest, RotationMotion) {
   // Each tile of a layer may be affected differently by a transform; Check
   // that ComputeTilePriorityRects correctly accounts for the transform between
   // layer space and screen space.
 
   FakePictureLayerTilingClient client;
@@ skipping 43 matching lines @@
   tiling->ComputeTilePriorityRects(viewport_in_layer_space,
                                    current_layer_contents_scale,
                                    current_frame_time_in_seconds, Occlusion());
   tiling->UpdateAllTilePrioritiesForTesting();
 
   ASSERT_TRUE(tiling->TileAt(0, 0));
   ASSERT_TRUE(tiling->TileAt(0, 1));
   ASSERT_TRUE(tiling->TileAt(1, 0));
   ASSERT_TRUE(tiling->TileAt(1, 1));
 
-  TilePriority priority = tiling->TileAt(0, 0)->priority();
+  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();
+  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();
+  priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
   EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible);
   EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 }
 
 TEST(PictureLayerTilingTest, RecycledTilesCleared) {
   // This test performs the following:
   // Setup:
   // - Two tilings, one active one recycled with all tiles shared.
   // Procedure:
   // - Viewport moves somewhere far away and active tiling clears tiles.
@@ skipping 30 matching lines @@
 
   // Create all tiles on the second tiling. All tiles should be shared.
   recycle_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f,
                                            1.0f, Occlusion());
 
   // Set the second tiling as recycled.
   active_client.set_twin_tiling(NULL);
   active_client.set_recycled_twin_tiling(recycle_tiling.get());
   recycle_client.set_twin_tiling(NULL);
 
+  // Verify that tiles exist and are shared.
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
-  EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
+  EXPECT_TRUE(recycle_tiling->TileAt(0, 0));
+  EXPECT_EQ(active_tiling->TileAt(0, 0), recycle_tiling->TileAt(0, 0));
 
   // Move the viewport far away from the (0, 0) tile.
   active_tiling->ComputeTilePriorityRects(gfx::Rect(9000, 9000, 100, 100), 1.0f,
                                           2.0, Occlusion());
-  // Ensure the tile was deleted.
+  // Ensure the tile was deleted on both tilings.
   EXPECT_FALSE(active_tiling->TileAt(0, 0));
   EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
 
   // Move the viewport back to (0, 0) tile.
   active_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f, 3.0,
                                           Occlusion());
 
-  // Ensure that we now have a tile here on both active.
+  // Ensure that we now have a tile here on both tilings again.
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
-  EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
+  EXPECT_TRUE(recycle_tiling->TileAt(0, 0));
 }
 
 TEST(PictureLayerTilingTest, RecycledTilesClearedOnReset) {
   FakePictureLayerTilingClient active_client;
   active_client.SetTileSize(gfx::Size(100, 100));
   active_client.set_tree(ACTIVE_TREE);
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
           gfx::Size(100, 100));
@@ skipping 19 matching lines @@
 
   // Create all tiles on the recycle tiling. All tiles should be shared.
   recycle_tiling->ComputeTilePriorityRects(gfx::Rect(0, 0, 100, 100), 1.0f,
                                            1.0f, Occlusion());
 
   // Set the second tiling as recycled.
   active_client.set_twin_tiling(NULL);
   active_client.set_recycled_twin_tiling(recycle_tiling.get());
   recycle_client.set_twin_tiling(NULL);
 
+  // Verify that tiles exist and are shared.
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
-  EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
+  EXPECT_TRUE(recycle_tiling->TileAt(0, 0));
+  EXPECT_EQ(active_tiling->TileAt(0, 0), recycle_tiling->TileAt(0, 0));
 
   // Reset the active tiling. The recycle tiles should be released too.
   active_tiling->Reset();
   EXPECT_FALSE(active_tiling->TileAt(0, 0));
   EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
 }
 
 TEST_F(PictureLayerTilingIteratorTest, ResizeTilesAndUpdateToCurrent) {
   // The tiling has four rows and three columns.
   Initialize(gfx::Size(150, 100), 1.f, gfx::Size(250, 150));
@@ skipping 16 matching lines @@
   tiling_->SetRasterSourceAndResize(pile);
 
   // Tile size in the tiling should be resized to 250x200.
   EXPECT_EQ(250, tiling_->TilingDataForTesting().max_texture_size().width());
   EXPECT_EQ(200, tiling_->TilingDataForTesting().max_texture_size().height());
   EXPECT_EQ(0u, tiling_->AllRefTilesForTesting().size());
 }
 
 }  // namespace
 }  // namespace cc