cc: Remove tile sharing from tilings.

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 270 matching lines @@
 
     SetupDrawPropertiesAndUpdateTiles(active_layer_,
                                       contents_scale,
                                       device_scale_factor,
                                       page_scale_factor,
                                       maximum_animation_contents_scale,
                                       animating_transform);
   }
 
   void ResetTilingsAndRasterScales() {
-    pending_layer_->ReleaseResources();
-    EXPECT_FALSE(pending_layer_->tilings());
-    pending_layer_->RecreateResources();
-    EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
+    if (pending_layer_) {
+      pending_layer_->ReleaseResources();
+      EXPECT_FALSE(pending_layer_->tilings());
+      pending_layer_->RecreateResources();
+      EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
+    }
 
-    active_layer_->ReleaseResources();
-    EXPECT_FALSE(active_layer_->tilings());
-    active_layer_->RecreateResources();
-    EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
+    if (active_layer_) {
+      active_layer_->ReleaseResources();
+      EXPECT_FALSE(active_layer_->tilings());
+      active_layer_->RecreateResources();
+      EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
+    }
   }
 
   void AssertAllTilesRequired(PictureLayerTiling* tiling) {
     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
     for (size_t i = 0; i < tiles.size(); ++i)
       EXPECT_TRUE(tiles[i]->required_for_activation()) << "i: " << i;
     EXPECT_GT(tiles.size(), 0u);
   }
 
   void AssertNoTilesRequired(PictureLayerTiling* tiling) {
@@ skipping 89 matching lines @@
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTreesWithInvalidation(pending_pile, active_pile, Region());
 
   EXPECT_EQ(pending_layer_->tilings()->num_tilings(),
             active_layer_->tilings()->num_tilings());
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i)
-    VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), pending_pile.get());
+    EXPECT_TRUE(tilings->tiling_at(i)->AllTilesForTesting().empty());
 }
 
 TEST_F(PictureLayerImplTest, ExternalViewportRectForPrioritizingTiles) {
   base::TimeTicks time_ticks;
   time_ticks += base::TimeDelta::FromMilliseconds(1);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
 
@@ skipping 230 matching lines @@
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> lost_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupPendingTreeWithFixedTileSize(lost_pile, gfx::Size(50, 50), Region());
   ActivateTree();
-  // Add a non-shared tiling on the active tree.
+  // Add a unique tiling on the active tree.
   PictureLayerTiling* tiling = active_layer_->AddTiling(3.f);
   tiling->CreateAllTilesForTesting();
 
   // Ensure UpdateTiles won't remove any tilings.
   active_layer_->MarkAllTilingsUsed();
 
   // Then setup a new pending tree and activate it.
   SetupTreesWithFixedTileSize(pending_pile, active_pile, gfx::Size(50, 50),
                               layer_invalidation);
 
   EXPECT_EQ(2u, pending_layer_->num_tilings());
   EXPECT_EQ(3u, active_layer_->num_tilings());
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
     gfx::Rect content_invalidation = gfx::ScaleToEnclosingRect(
         layer_invalidation,
         tiling->contents_scale());
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
              gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
-      EXPECT_TRUE(*iter);
-      EXPECT_FALSE(iter.geometry_rect().IsEmpty());
-      EXPECT_EQ(pending_pile.get(), iter->raster_source());
+      // We don't always have a tile, but when we do it's because it was
+      // invalidated and it has the latest raster source.
+      if (*iter) {
+        EXPECT_FALSE(iter.geometry_rect().IsEmpty());
+        EXPECT_EQ(pending_pile.get(), iter->raster_source());
+        EXPECT_TRUE(iter.geometry_rect().Intersects(content_invalidation));
+      } else {
+        // We don't create tiles in non-invalidated regions.
+        EXPECT_FALSE(iter.geometry_rect().Intersects(content_invalidation));
+      }
     }
   }
 
   tilings = active_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
     gfx::Rect content_invalidation =
         gfx::ScaleToEnclosingRect(layer_invalidation, tiling->contents_scale());
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
              gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
-      if (iter.geometry_rect().Intersects(content_invalidation))
-        EXPECT_EQ(active_pile.get(), iter->raster_source());
-      else if (!active_layer_->GetPendingOrActiveTwinTiling(tiling))
-        EXPECT_EQ(active_pile.get(), iter->raster_source());
-      else
-        EXPECT_EQ(pending_pile.get(), iter->raster_source());
+      // Pile will be updated upon activation.
+      EXPECT_EQ(active_pile.get(), iter->raster_source());
     }
   }
 }
 
 TEST_F(PictureLayerImplTest, CloneFullInvalidation) {
   gfx::Size tile_size(90, 80);
   gfx::Size layer_bounds(300, 500);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
@@ skipping 797 matching lines @@
   // This should create new tilings.
   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
                                     1.f,  // ideal contents scale
                                     1.f,  // device scale
                                     1.f,  // page scale
                                     1.f,  // maximum animation scale
                                     false);
   EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
 }
 
-TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) {
+TEST_F(PictureLayerImplTest, ClampTilesToMaxTileSize) {
   // The default max tile size is larger than 400x400.
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(5000, 5000);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupPendingTree(pending_pile);
   EXPECT_GE(pending_layer_->tilings()->num_tilings(), 1u);
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // The default value.
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
             host_impl_.settings().default_tile_size.ToString());
 
   Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
@@ skipping 24 matching lines @@
   // The default max tile size is larger than 400x400.
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(500, 500);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
-  EXPECT_GE(pending_layer_->tilings()->num_tilings(), 1u);
+  EXPECT_GE(active_layer_->tilings()->num_tilings(), 1u);
 
-  pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
+  active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // The default value. The layer is smaller than this.
   EXPECT_EQ(gfx::Size(512, 512).ToString(),
             host_impl_.settings().max_untiled_layer_size.ToString());
 
   // There should be a single tile since the layer is small.
-  PictureLayerTiling* high_res_tiling = pending_layer_->tilings()->tiling_at(0);
+  PictureLayerTiling* high_res_tiling = active_layer_->tilings()->tiling_at(0);
   EXPECT_EQ(1u, high_res_tiling->AllTilesForTesting().size());
 
   ResetTilingsAndRasterScales();
 
   // Change the max texture size on the output surface context.
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   context->set_max_texture_size(140);
   host_impl_.DidLoseOutputSurface();
   host_impl_.InitializeRenderer(
       FakeOutputSurface::Create3d(context.Pass()).Pass());
 
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
-  ASSERT_LE(1u, pending_layer_->tilings()->num_tilings());
+  SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
+  ASSERT_LE(1u, active_layer_->tilings()->num_tilings());
 
-  pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
+  active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // There should be more than one tile since the max texture size won't cover
   // the layer.
-  high_res_tiling = pending_layer_->tilings()->tiling_at(0);
+  high_res_tiling = active_layer_->tilings()->tiling_at(0);
   EXPECT_LT(1u, high_res_tiling->AllTilesForTesting().size());
 
   // Verify the tiles are not larger than the context's max texture size.
-  Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
+  Tile* tile = active_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_GE(140, tile->content_rect().width());
   EXPECT_GE(140, tile->content_rect().height());
 }
 
 TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) {
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
@@ skipping 103 matching lines @@
   pending_layer_->UpdateTiles(resourceless_software_draw);
 
   int num_visible = 0;
   int num_offscreen = 0;
 
   scoped_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
   for (; !queue->IsEmpty(); queue->Pop()) {
     const Tile* tile = queue->Top();
     DCHECK(tile);
-    if (tile->priority(PENDING_TREE).distance_to_visible == 0.f) {
+    if (tile->priority().distance_to_visible == 0.f) {
       EXPECT_TRUE(tile->required_for_activation());
       num_visible++;
     } else {
       EXPECT_FALSE(tile->required_for_activation());
       num_offscreen++;
     }
   }
 
   EXPECT_GT(num_visible, 0);
   EXPECT_GT(num_offscreen, 0);
@@ skipping 44 matching lines @@
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
   pending_layer_->UpdateTiles(resourceless_software_draw);
 
   // Intersect the two rects. Any tile outside should not be required for
   // activation.
   gfx::Rect viewport_for_tile_priority =
       pending_layer_->viewport_rect_for_tile_priority_in_content_space();
   viewport_for_tile_priority.Intersect(pending_layer_->visible_content_rect());
 
+  EXPECT_TRUE(pending_layer_->HighResTiling()->AllTilesForTesting().empty());
+
   int num_inside = 0;
   int num_outside = 0;
-  for (PictureLayerTiling::CoverageIterator iter(
-           pending_layer_->HighResTiling(), 1.f, gfx::Rect(layer_bounds));
+  for (PictureLayerTiling::CoverageIterator iter(active_layer_->HighResTiling(),
+                                                 1.f, gfx::Rect(layer_bounds));
        iter; ++iter) {
     if (!*iter)
       continue;
     Tile* tile = *iter;
     if (viewport_for_tile_priority.Intersects(iter.geometry_rect())) {
       num_inside++;
       // Mark everything in viewport for tile priority as ready to draw.
       TileDrawInfo& draw_info = tile->draw_info();
       draw_info.SetSolidColorForTesting(SK_ColorRED);
     } else {
@@ skipping 208 matching lines @@
   EXPECT_EQ(gfx::SizeF(49.5f, 49.5f),
             TileDrawQuad::MaterialCast(render_pass->quad_list.ElementAt(1))
                 ->tex_coord_rect.size());
 
   // Neither the high res nor the ideal tiles were considered as incomplete.
   EXPECT_EQ(0u, data.num_missing_tiles);
   EXPECT_EQ(0u, data.num_incomplete_tiles);
   EXPECT_FALSE(active_layer_->only_used_low_res_last_append_quads());
 }
 
-TEST_F(PictureLayerImplTest, HighResRequiredWhenUnsharedActiveAllReady) {
+TEST_F(PictureLayerImplTest, HighResRequiredWhenActiveAllReady) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
-  // No tiles shared.
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size,
                                      gfx::Rect(layer_bounds));
 
   active_layer_->SetAllTilesReady();
 
-  // No shared tiles and all active tiles ready, so pending can only
-  // activate with all high res tiles.
+  // All active tiles ready, so pending can only activate with all high res
+  // tiles.
   pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
   pending_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();
 
   AssertAllTilesRequired(pending_layer_->HighResTiling());
   AssertNoTilesRequired(pending_layer_->LowResTiling());
 }
 
 TEST_F(PictureLayerImplTest, HighResRequiredWhenMissingHighResFlagOn) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
-  // All tiles shared (no invalidation).
+  // No invalidation.
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   // Verify active tree not ready.
   Tile* some_active_tile =
       active_layer_->HighResTiling()->AllTilesForTesting()[0];
   EXPECT_FALSE(some_active_tile->IsReadyToDraw());
 
-  // When high res are required, even if the active tree is not ready,
-  // the high res tiles must be ready.
+  // When high res are required, all tiles in active high res tiling should be
+  // required for activation.
   host_impl_.SetRequiresHighResToDraw();
 
   pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
   pending_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();
+  active_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
+  active_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();
 
-  AssertAllTilesRequired(pending_layer_->HighResTiling());
-  AssertNoTilesRequired(pending_layer_->LowResTiling());
+  EXPECT_TRUE(pending_layer_->HighResTiling()->AllTilesForTesting().empty());
+  EXPECT_TRUE(pending_layer_->LowResTiling()->AllTilesForTesting().empty());
+  AssertAllTilesRequired(active_layer_->HighResTiling());
+  AssertNoTilesRequired(active_layer_->LowResTiling());
 }
 
-TEST_F(PictureLayerImplTest, AllHighResRequiredEvenIfShared) {
+TEST_F(PictureLayerImplTest, AllHighResRequiredEvenIfNotChanged) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   Tile* some_active_tile =
       active_layer_->HighResTiling()->AllTilesForTesting()[0];
   EXPECT_FALSE(some_active_tile->IsReadyToDraw());
 
-  // All tiles shared (no invalidation), so even though the active tree's
-  // tiles aren't ready, the high res tiles are required for activation.
-  pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
-  pending_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();
+  // Since there are no invalidations, pending tree should have no tiles.
+  EXPECT_TRUE(pending_layer_->HighResTiling()->AllTilesForTesting().empty());
+  EXPECT_TRUE(pending_layer_->LowResTiling()->AllTilesForTesting().empty());
 
-  AssertAllTilesRequired(pending_layer_->HighResTiling());
-  AssertNoTilesRequired(pending_layer_->LowResTiling());
+  active_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
+  active_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();
+
+  AssertAllTilesRequired(active_layer_->HighResTiling());
+  AssertNoTilesRequired(active_layer_->LowResTiling());
 }
 
 TEST_F(PictureLayerImplTest, DisallowRequiredForActivation) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   Tile* some_active_tile =
       active_layer_->HighResTiling()->AllTilesForTesting()[0];
   EXPECT_FALSE(some_active_tile->IsReadyToDraw());
 
+  EXPECT_TRUE(pending_layer_->HighResTiling()->AllTilesForTesting().empty());
+  EXPECT_TRUE(pending_layer_->LowResTiling()->AllTilesForTesting().empty());
+  active_layer_->HighResTiling()->set_can_require_tiles_for_activation(false);
+  active_layer_->LowResTiling()->set_can_require_tiles_for_activation(false);
   pending_layer_->HighResTiling()->set_can_require_tiles_for_activation(false);
   pending_layer_->LowResTiling()->set_can_require_tiles_for_activation(false);
 
   // If we disallow required for activation, no tiles can be required.
-  pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
-  pending_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();
+  active_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
+  active_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();
 
-  AssertNoTilesRequired(pending_layer_->HighResTiling());
-  AssertNoTilesRequired(pending_layer_->LowResTiling());
+  AssertNoTilesRequired(active_layer_->HighResTiling());
+  AssertNoTilesRequired(active_layer_->LowResTiling());
 }
 
 TEST_F(PictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   // This pile will create tilings, but has no recordings so will not create any
   // tiles.  This is attempting to simulate scrolling past the end of recorded
@@ skipping 53 matching lines @@
       FakePicturePileImpl::CreateFilledPile(tile_size, pending_layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, active_layer_bounds);
 
   SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
 
   // Since the active layer has different bounds, the pending layer needs all
   // high res tiles in order to activate.
   pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
   pending_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();
+  active_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
+  active_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();
 
   AssertAllTilesRequired(pending_layer_->HighResTiling());
-  AssertNoTilesRequired(pending_layer_->LowResTiling());
+  AssertAllTilesRequired(active_layer_->HighResTiling());
+  AssertNoTilesRequired(active_layer_->LowResTiling());
+  // Since the test doesn't invalidate the resized region, we expect that the
+  // same low res tile would exist (which means we don't create a new one of the
+  // pending tree).
+  EXPECT_TRUE(pending_layer_->LowResTiling()->AllTilesForTesting().empty());
 }
 
 TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   host_impl_.CreatePendingTree();
   LayerTreeImpl* pending_tree = host_impl_.pending_tree();
@@ skipping 48 matching lines @@
   // Activate and make a pending tree with an invalidated raster tile 1,1.
   ActivateTree();
 
   SetupPendingTreeWithInvalidation(pending_pile, second_invalidate);
 
   PictureLayerTiling* pending_tiling = pending_layer_->tilings()->tiling_at(0);
   PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(0);
 
   // pending_tiling->CreateAllTilesForTesting();
 
-  // Tile 0,0 should be shared, but tile 1,1 should not be.
-  EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
-  EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
-  EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
+  // Tile 0,0 not exist on pending, but tile 1,1 should.
+  EXPECT_TRUE(active_tiling->TileAt(0, 0));
+  EXPECT_TRUE(active_tiling->TileAt(1, 0));
+  EXPECT_TRUE(active_tiling->TileAt(0, 1));
+  EXPECT_FALSE(pending_tiling->TileAt(0, 0));
+  EXPECT_FALSE(pending_tiling->TileAt(1, 0));
+  EXPECT_FALSE(pending_tiling->TileAt(0, 1));
   EXPECT_NE(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
-  EXPECT_TRUE(pending_tiling->TileAt(0, 0)->is_shared());
-  EXPECT_TRUE(pending_tiling->TileAt(1, 0)->is_shared());
-  EXPECT_TRUE(pending_tiling->TileAt(0, 1)->is_shared());
-  EXPECT_FALSE(pending_tiling->TileAt(1, 1)->is_shared());
+  EXPECT_TRUE(active_tiling->TileAt(1, 1));
+  EXPECT_TRUE(pending_tiling->TileAt(1, 1));
 
-  // Drop the tiles on the active tree and recreate them. The same tiles
-  // should be shared or not.
+  // Drop the tiles on the active tree and recreate them.
   active_tiling->ComputeTilePriorityRects(gfx::Rect(), 1.f, 1.0, Occlusion());
   EXPECT_TRUE(active_tiling->AllTilesForTesting().empty());
   active_tiling->CreateAllTilesForTesting();
 
-  // Tile 0,0 should be shared, but tile 1,1 should not be.
-  EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
-  EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
-  EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
+  // Tile 0,0 not exist on pending, but tile 1,1 should.
+  EXPECT_TRUE(active_tiling->TileAt(0, 0));
+  EXPECT_TRUE(active_tiling->TileAt(1, 0));
+  EXPECT_TRUE(active_tiling->TileAt(0, 1));
+  EXPECT_FALSE(pending_tiling->TileAt(0, 0));
+  EXPECT_FALSE(pending_tiling->TileAt(1, 0));
+  EXPECT_FALSE(pending_tiling->TileAt(0, 1));
   EXPECT_NE(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
-  EXPECT_TRUE(pending_tiling->TileAt(0, 0)->is_shared());
-  EXPECT_TRUE(pending_tiling->TileAt(1, 0)->is_shared());
-  EXPECT_TRUE(pending_tiling->TileAt(0, 1)->is_shared());
-  EXPECT_FALSE(pending_tiling->TileAt(1, 1)->is_shared());
+  EXPECT_TRUE(active_tiling->TileAt(1, 1));
+  EXPECT_TRUE(pending_tiling->TileAt(1, 1));
 }
 
-TEST_F(PictureLayerImplTest, ShareTilesWithNoInvalidation) {
+TEST_F(PictureLayerImplTest, PendingHasNoTilesWithNoInvalidation) {
   SetupDefaultTrees(gfx::Size(1500, 1500));
 
   EXPECT_GE(active_layer_->num_tilings(), 1u);
   EXPECT_GE(pending_layer_->num_tilings(), 1u);
 
-  // No invalidation, so all tiles are shared.
+  // No invalidation.
   PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(0);
   PictureLayerTiling* pending_tiling = pending_layer_->tilings()->tiling_at(0);
   ASSERT_TRUE(active_tiling);
   ASSERT_TRUE(pending_tiling);
 
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
   EXPECT_TRUE(active_tiling->TileAt(1, 0));
   EXPECT_TRUE(active_tiling->TileAt(0, 1));
   EXPECT_TRUE(active_tiling->TileAt(1, 1));
 
-  EXPECT_TRUE(pending_tiling->TileAt(0, 0));
-  EXPECT_TRUE(pending_tiling->TileAt(1, 0));
-  EXPECT_TRUE(pending_tiling->TileAt(0, 1));
-  EXPECT_TRUE(pending_tiling->TileAt(1, 1));
-
-  EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
-  EXPECT_TRUE(active_tiling->TileAt(0, 0)->is_shared());
-  EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
-  EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
-  EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
-  EXPECT_TRUE(active_tiling->TileAt(0, 1)->is_shared());
-  EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
-  EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
+  EXPECT_FALSE(pending_tiling->TileAt(0, 0));
+  EXPECT_FALSE(pending_tiling->TileAt(1, 0));
+  EXPECT_FALSE(pending_tiling->TileAt(0, 1));
+  EXPECT_FALSE(pending_tiling->TileAt(1, 1));
 }
 
 TEST_F(PictureLayerImplTest, ShareInvalidActiveTreeTiles) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1500, 1500);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   SetupTreesWithInvalidation(pending_pile, active_pile, gfx::Rect(1, 1));
   // Activate the invalidation.
   ActivateTree();
   // Make another pending tree without any invalidation in it.
   scoped_refptr<FakePicturePileImpl> pending_pile2 =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   SetupPendingTree(pending_pile2);
 
   EXPECT_GE(active_layer_->num_tilings(), 1u);
   EXPECT_GE(pending_layer_->num_tilings(), 1u);
 
-  // The active tree invalidation was handled by the active tiles, so they
-  // can be shared with the pending tree.
+  // The active tree invalidation was handled by the active tiles.
   PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(0);
   PictureLayerTiling* pending_tiling = pending_layer_->tilings()->tiling_at(0);
   ASSERT_TRUE(active_tiling);
   ASSERT_TRUE(pending_tiling);
 
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
   EXPECT_TRUE(active_tiling->TileAt(1, 0));
   EXPECT_TRUE(active_tiling->TileAt(0, 1));
   EXPECT_TRUE(active_tiling->TileAt(1, 1));
 
-  EXPECT_TRUE(pending_tiling->TileAt(0, 0));
-  EXPECT_TRUE(pending_tiling->TileAt(1, 0));
-  EXPECT_TRUE(pending_tiling->TileAt(0, 1));
-  EXPECT_TRUE(pending_tiling->TileAt(1, 1));
-
-  EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
-  EXPECT_TRUE(active_tiling->TileAt(0, 0)->is_shared());
-  EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
-  EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
-  EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
-  EXPECT_TRUE(active_tiling->TileAt(0, 1)->is_shared());
-  EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
-  EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
+  EXPECT_FALSE(pending_tiling->TileAt(0, 0));
+  EXPECT_FALSE(pending_tiling->TileAt(1, 0));
+  EXPECT_FALSE(pending_tiling->TileAt(0, 1));
+  EXPECT_FALSE(pending_tiling->TileAt(1, 1));
 }
 
 TEST_F(PictureLayerImplTest, RecreateInvalidPendingTreeTiles) {
   // Set some invalidation on the pending tree. We should replace raster tiles
   // that touch this.
   SetupDefaultTreesWithInvalidation(gfx::Size(1500, 1500), gfx::Rect(1, 1));
 
   EXPECT_GE(active_layer_->num_tilings(), 1u);
   EXPECT_GE(pending_layer_->num_tilings(), 1u);
 
-  // The pending tree invalidation means tiles can not be shared with the
-  // active tree.
+  // The pending tree invalidation creates tiles on the pending tree.
   PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(0);
   PictureLayerTiling* pending_tiling = pending_layer_->tilings()->tiling_at(0);
   ASSERT_TRUE(active_tiling);
   ASSERT_TRUE(pending_tiling);
 
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
   EXPECT_TRUE(active_tiling->TileAt(1, 0));
   EXPECT_TRUE(active_tiling->TileAt(0, 1));
   EXPECT_TRUE(active_tiling->TileAt(1, 1));
 
   EXPECT_TRUE(pending_tiling->TileAt(0, 0));
-  EXPECT_TRUE(pending_tiling->TileAt(1, 0));
-  EXPECT_TRUE(pending_tiling->TileAt(0, 1));
-  EXPECT_TRUE(pending_tiling->TileAt(1, 1));
+  EXPECT_FALSE(pending_tiling->TileAt(1, 0));
+  EXPECT_FALSE(pending_tiling->TileAt(0, 1));
+  EXPECT_FALSE(pending_tiling->TileAt(1, 1));
 
   EXPECT_NE(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
-  EXPECT_FALSE(active_tiling->TileAt(0, 0)->is_shared());
-  EXPECT_FALSE(pending_tiling->TileAt(0, 0)->is_shared());
-  EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
-  EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
-  EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
-  EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
-  EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
-  EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
 }
 
 TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
   base::TimeTicks time_ticks;
   time_ticks += base::TimeDelta::FromMilliseconds(1);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(10, 10);
@@ skipping 422 matching lines @@
   std::set<Tile*> unique_tiles;
   bool reached_prepaint = false;
   int non_ideal_tile_count = 0u;
   int low_res_tile_count = 0u;
   int high_res_tile_count = 0u;
   int high_res_now_tiles = 0u;
   scoped_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
   while (!queue->IsEmpty()) {
     Tile* tile = queue->Top();
-    TilePriority priority = tile->priority(PENDING_TREE);
+    TilePriority priority = tile->priority();
 
     EXPECT_TRUE(tile);
 
     // Non-high res tiles only get visible tiles. Also, prepaint should only
     // come at the end of the iteration.
     if (priority.resolution != HIGH_RESOLUTION) {
       EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
     } else if (reached_prepaint) {
       EXPECT_NE(TilePriority::NOW, priority.priority_bin);
     } else {
@@ skipping 53 matching lines @@
       gfx::Rect(1100, 1100, 500, 500);
   bool resourceless_software_draw = false;
   pending_layer_->UpdateTiles(resourceless_software_draw);
 
   unique_tiles.clear();
   high_res_tile_count = 0u;
   queue.reset(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
   while (!queue->IsEmpty()) {
     Tile* tile = queue->Top();
-    TilePriority priority = tile->priority(PENDING_TREE);
+    TilePriority priority = tile->priority();
 
     EXPECT_TRUE(tile);
 
     // Non-high res tiles only get visible tiles.
     EXPECT_EQ(HIGH_RESOLUTION, priority.resolution);
     EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
     high_res_tile_count += priority.resolution == HIGH_RESOLUTION;
 
     unique_tiles.insert(tile);
@@ skipping 21 matching lines @@
     draw_info.SetSolidColorForTesting(SK_ColorRED);
   }
 
   non_ideal_tile_count = 0;
   low_res_tile_count = 0;
   high_res_tile_count = 0;
   queue.reset(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), true));
   while (!queue->IsEmpty()) {
     Tile* tile = queue->Top();
-    TilePriority priority = tile->priority(PENDING_TREE);
+    TilePriority priority = tile->priority();
 
     EXPECT_TRUE(tile);
 
     non_ideal_tile_count += priority.resolution == NON_IDEAL_RESOLUTION;
     low_res_tile_count += priority.resolution == LOW_RESOLUTION;
     high_res_tile_count += priority.resolution == HIGH_RESOLUTION;
     queue->Pop();
   }
 
   EXPECT_EQ(0, non_ideal_tile_count);
@@ skipping 125 matching lines @@
   size_t distance_increasing = 0;
   queue.reset(new TilingSetEvictionQueue(
       pending_layer_->picture_layer_tiling_set(), false));
   while (!queue->IsEmpty()) {
     Tile* tile = queue->Top();
     if (!last_tile)
       last_tile = tile;
 
     EXPECT_TRUE(tile);
 
-    TilePriority priority = tile->priority(PENDING_TREE);
+    TilePriority priority = tile->priority();
 
     if (priority.priority_bin == TilePriority::NOW) {
       reached_visible = true;
       last_tile = tile;
       break;
     }
 
     EXPECT_FALSE(tile->required_for_activation());
 
     while (std::abs(tile->contents_scale() - expected_scales[scale_index]) >
            std::numeric_limits<float>::epsilon()) {
       ++scale_index;
       ASSERT_LT(scale_index, arraysize(expected_scales));
     }
 
     EXPECT_FLOAT_EQ(tile->contents_scale(), expected_scales[scale_index]);
     unique_tiles.insert(tile);
 
     if (tile->required_for_activation() ==
             last_tile->required_for_activation() &&
         std::abs(tile->contents_scale() - last_tile->contents_scale()) <
             std::numeric_limits<float>::epsilon()) {
       if (priority.distance_to_visible <=
-          last_tile->priority(PENDING_TREE).distance_to_visible)
+          last_tile->priority().distance_to_visible)
         ++distance_decreasing;
       else
         ++distance_increasing;
     }
 
     last_tile = tile;
     queue->Pop();
   }
 
   // 4 high res tiles are inside the viewport, the rest are evicted.
   EXPECT_TRUE(reached_visible);
   EXPECT_EQ(12u, unique_tiles.size());
   EXPECT_EQ(1u, distance_increasing);
   EXPECT_EQ(11u, distance_decreasing);
 
   scale_index = 0;
   bool reached_required = false;
   while (!queue->IsEmpty()) {
     Tile* tile = queue->Top();
     EXPECT_TRUE(tile);
 
-    TilePriority priority = tile->priority(PENDING_TREE);
+    TilePriority priority = tile->priority();
     EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
     if (reached_required) {
       EXPECT_TRUE(tile->required_for_activation());
     } else if (tile->required_for_activation()) {
       reached_required = true;
       scale_index = 0;
     }
 
     while (std::abs(tile->contents_scale() - expected_scales[scale_index]) >
@@ skipping 100 matching lines @@
                                page_scale,
                                maximum_animation_scale,
                                animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
 }
 
 TEST_F(PictureLayerImplTest, LowResReadyToDrawNotEnoughToActivate) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
-  // Make sure some tiles are not shared.
+  // Make sure pending tree has tiles.
   gfx::Rect invalidation(gfx::Point(50, 50), tile_size);
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, invalidation);
 
   // All pending layer tiles required are not ready.
   EXPECT_FALSE(host_impl_.tile_manager()->IsReadyToActivate());
 
   // Initialize all low-res tiles.
   pending_layer_->SetAllTilesReadyInTiling(pending_layer_->LowResTiling());
+  pending_layer_->SetAllTilesReadyInTiling(active_layer_->LowResTiling());
 
   // Low-res tiles should not be enough.
   EXPECT_FALSE(host_impl_.tile_manager()->IsReadyToActivate());
 
   // Initialize remaining tiles.
   pending_layer_->SetAllTilesReady();
+  active_layer_->SetAllTilesReady();
 
   EXPECT_TRUE(host_impl_.tile_manager()->IsReadyToActivate());
 }
 
 TEST_F(PictureLayerImplTest, HighResReadyToDrawEnoughToActivate) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
-  // Make sure some tiles are not shared.
+  // Make sure pending tree has tiles.
   gfx::Rect invalidation(gfx::Point(50, 50), tile_size);
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, invalidation);
 
   // All pending layer tiles required are not ready.
   EXPECT_FALSE(host_impl_.tile_manager()->IsReadyToActivate());
 
   // Initialize all high-res tiles.
   pending_layer_->SetAllTilesReadyInTiling(pending_layer_->HighResTiling());
+  active_layer_->SetAllTilesReadyInTiling(active_layer_->HighResTiling());
 
   // High-res tiles should be enough, since they cover everything visible.
   EXPECT_TRUE(host_impl_.tile_manager()->IsReadyToActivate());
 }
 
 TEST_F(PictureLayerImplTest,
-       SharedActiveHighResReadyAndPendingLowResReadyNotEnoughToActivate) {
+       ActiveHighResReadyAndPendingLowResReadyNotEnoughToActivate) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
-  // Make sure some tiles are not shared.
+  // Make sure pending tree has tiles.
   gfx::Rect invalidation(gfx::Point(50, 50), tile_size);
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, invalidation);
 
   // Initialize all high-res tiles in the active layer.
   active_layer_->SetAllTilesReadyInTiling(active_layer_->HighResTiling());
   // And all the low-res tiles in the pending layer.
   pending_layer_->SetAllTilesReadyInTiling(pending_layer_->LowResTiling());
 
-  // The unshared high-res tiles are not ready, so we cannot activate.
+  // The pending high-res tiles are not ready, so we cannot activate.
   EXPECT_FALSE(host_impl_.tile_manager()->IsReadyToActivate());
 
-  // When the unshared pending high-res tiles are ready, we can activate.
+  // When the pending high-res tiles are ready, we can activate.
   pending_layer_->SetAllTilesReadyInTiling(pending_layer_->HighResTiling());
   EXPECT_TRUE(host_impl_.tile_manager()->IsReadyToActivate());
 }
 
-TEST_F(PictureLayerImplTest, SharedActiveHighResReadyNotEnoughToActivate) {
+TEST_F(PictureLayerImplTest, ActiveHighResReadyNotEnoughToActivate) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
-  // Make sure some tiles are not shared.
+  // Make sure pending tree has tiles.
   gfx::Rect invalidation(gfx::Point(50, 50), tile_size);
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, invalidation);
 
   // Initialize all high-res tiles in the active layer.
   active_layer_->SetAllTilesReadyInTiling(active_layer_->HighResTiling());
 
-  // The unshared high-res tiles are not ready, so we cannot activate.
+  // The pending high-res tiles are not ready, so we cannot activate.
   EXPECT_FALSE(host_impl_.tile_manager()->IsReadyToActivate());
 
-  // When the unshared pending high-res tiles are ready, we can activate.
+  // When the pending pending high-res tiles are ready, we can activate.
   pending_layer_->SetAllTilesReadyInTiling(pending_layer_->HighResTiling());
   EXPECT_TRUE(host_impl_.tile_manager()->IsReadyToActivate());
 }
 
 TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
@@ skipping 106 matching lines @@
                                     7.26f,  // ideal contents scale
                                     2.2f,   // device scale
                                     3.3f,   // page scale
                                     1.f,    // maximum animation scale
                                     false);
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 }
 
-TEST_F(NoLowResPictureLayerImplTest, AllHighResRequiredEvenIfShared) {
+TEST_F(NoLowResPictureLayerImplTest, AllHighResRequiredEvenIfNotChanged) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   Tile* some_active_tile =
       active_layer_->HighResTiling()->AllTilesForTesting()[0];
   EXPECT_FALSE(some_active_tile->IsReadyToDraw());
 
-  // All tiles shared (no invalidation), so even though the active tree's
-  // tiles aren't ready, there is nothing required.
-  pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
+  // Since there is no invalidaiton, pending tree should have no tiles.
+  EXPECT_TRUE(pending_layer_->HighResTiling()->AllTilesForTesting().empty());
   if (host_impl_.settings().create_low_res_tiling)
-    pending_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();
+    EXPECT_TRUE(pending_layer_->LowResTiling()->AllTilesForTesting().empty());
 
-  AssertAllTilesRequired(pending_layer_->HighResTiling());
+  active_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
   if (host_impl_.settings().create_low_res_tiling)
-    AssertNoTilesRequired(pending_layer_->LowResTiling());
+    active_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();
+
+  AssertAllTilesRequired(active_layer_->HighResTiling());
+  if (host_impl_.settings().create_low_res_tiling)
+    AssertNoTilesRequired(active_layer_->LowResTiling());
 }
 
 TEST_F(NoLowResPictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   // This pile will create tilings, but has no recordings so will not create any
   // tiles.  This is attempting to simulate scrolling past the end of recorded
@@ skipping 365 matching lines @@
 };
 
 class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest {
  public:
   OcclusionTrackingPictureLayerImplTest()
       : PictureLayerImplTest(OcclusionTrackingSettings()) {}
 
   void VerifyEvictionConsidersOcclusion(FakePictureLayerImpl* layer,
                                         FakePictureLayerImpl* twin_layer,
                                         WhichTree tree,
-                                        size_t expected_occluded_tile_count) {
-    WhichTree twin_tree = tree == ACTIVE_TREE ? PENDING_TREE : ACTIVE_TREE;
+                                        size_t expected_occluded_tile_count,
+                                        int source_line) {
     size_t occluded_tile_count = 0u;
     Tile* last_tile = nullptr;
-    std::set<Tile*> shared_tiles;
 
     scoped_ptr<TilingSetEvictionQueue> queue(new TilingSetEvictionQueue(
         layer->picture_layer_tiling_set(), layer && twin_layer));
     while (!queue->IsEmpty()) {
       Tile* tile = queue->Top();
       if (!last_tile)
         last_tile = tile;
-      if (tile->is_shared())
-        EXPECT_TRUE(shared_tiles.insert(tile).second);
 
       // The only way we will encounter an occluded tile after an unoccluded
       // tile is if the priorty bin decreased, the tile is required for
       // activation, or the scale changed.
-      bool tile_is_occluded = tile->is_occluded(tree);
+      bool tile_is_occluded = tile->is_occluded();
       if (tile_is_occluded) {
         occluded_tile_count++;
 
-        bool last_tile_is_occluded = last_tile->is_occluded(tree);
+        bool last_tile_is_occluded = last_tile->is_occluded();
         if (!last_tile_is_occluded) {
           TilePriority::PriorityBin tile_priority_bin =
-              tile->priority(tree).priority_bin;
+              tile->priority().priority_bin;
           TilePriority::PriorityBin last_tile_priority_bin =
-              last_tile->priority(tree).priority_bin;
+              last_tile->priority().priority_bin;
 
           EXPECT_TRUE(tile_priority_bin < last_tile_priority_bin ||
                       tile->required_for_activation() ||
-                      tile->contents_scale() != last_tile->contents_scale());
+                      tile->contents_scale() != last_tile->contents_scale())
+              << "line: " << source_line;
         }
       }
       last_tile = tile;
       queue->Pop();
     }
-    // Count also shared tiles which are occluded in the tree but which were
-    // not returned by the tiling set eviction queue. Those shared tiles
-    // shall be returned by the twin tiling set eviction queue.
-    queue.reset(new TilingSetEvictionQueue(
-        twin_layer->picture_layer_tiling_set(), layer && twin_layer));
-    while (!queue->IsEmpty()) {
-      Tile* tile = queue->Top();
-      if (tile->is_shared()) {
-        EXPECT_TRUE(shared_tiles.insert(tile).second);
-        if (tile->is_occluded(tree))
-          ++occluded_tile_count;
-        // Check the reasons why the shared tile was not returned by
-        // the first tiling set eviction queue.
-        const TilePriority& combined_priority = tile->combined_priority();
-        const TilePriority& priority = tile->priority(tree);
-        const TilePriority& twin_priority = tile->priority(twin_tree);
-        // Check if the shared tile was not returned by the first tiling
-        // set eviction queue because it was out of order for the first
-        // tiling set eviction queue but not for the twin tiling set
-        // eviction queue.
-        if (priority.priority_bin != twin_priority.priority_bin) {
-          EXPECT_LT(combined_priority.priority_bin, priority.priority_bin);
-          EXPECT_EQ(combined_priority.priority_bin, twin_priority.priority_bin);
-        } else if (tile->is_occluded(tree) != tile->is_occluded(twin_tree)) {
-          EXPECT_TRUE(tile->is_occluded(tree));
-          EXPECT_FALSE(tile->is_occluded(twin_tree));
-          EXPECT_FALSE(tile->is_occluded_combined());
-        } else if (priority.distance_to_visible !=
-                   twin_priority.distance_to_visible) {
-          EXPECT_LT(combined_priority.distance_to_visible,
-                    priority.distance_to_visible);
-          EXPECT_EQ(combined_priority.distance_to_visible,
-                    twin_priority.distance_to_visible);
-        } else {
-          // Shared tiles having the same active and pending priorities
-          // should be returned only by a pending tree eviction queue.
-          EXPECT_EQ(ACTIVE_TREE, tree);
-        }
-      }
-      queue->Pop();
-    }
-    EXPECT_EQ(expected_occluded_tile_count, occluded_tile_count);
+    EXPECT_EQ(expected_occluded_tile_count, occluded_tile_count)
+        << "line: " << source_line;
   }
 };
 
 TEST_F(OcclusionTrackingPictureLayerImplTest,
        OccludedTilesSkippedDuringRasterization) {
   base::TimeTicks time_ticks;
   time_ticks += base::TimeDelta::FromMilliseconds(1);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
 
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
   gfx::Size viewport_size(500, 500);
   gfx::Point occluding_layer_position(310, 0);
 
   host_impl_.SetViewportSize(viewport_size);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
 
   // No occlusion.
   int unoccluded_tile_count = 0;
   scoped_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
   while (!queue->IsEmpty()) {
     Tile* tile = queue->Top();
 
     // Occluded tiles should not be iterated over.
-    EXPECT_FALSE(tile->is_occluded(PENDING_TREE));
+    EXPECT_FALSE(tile->is_occluded());
 
     // Some tiles may not be visible (i.e. outside the viewport). The rest are
     // visible and at least partially unoccluded, verified by the above expect.
     bool tile_is_visible =
         tile->content_rect().Intersects(pending_layer_->visible_content_rect());
     if (tile_is_visible)
       unoccluded_tile_count++;
     queue->Pop();
   }
   EXPECT_EQ(unoccluded_tile_count, 25);
@@ skipping 12 matching lines @@
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
   bool update_lcd_text = false;
   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   unoccluded_tile_count = 0;
   queue.reset(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
   while (!queue->IsEmpty()) {
     Tile* tile = queue->Top();
 
-    EXPECT_FALSE(tile->is_occluded(PENDING_TREE));
+    EXPECT_FALSE(tile->is_occluded());
 
     bool tile_is_visible =
         tile->content_rect().Intersects(pending_layer_->visible_content_rect());
     if (tile_is_visible)
       unoccluded_tile_count++;
     queue->Pop();
   }
   EXPECT_EQ(20, unoccluded_tile_count);
 
   // Full occlusion.
   layer1->SetPosition(gfx::Point(0, 0));
 
   time_ticks += base::TimeDelta::FromMilliseconds(200);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   unoccluded_tile_count = 0;
   queue.reset(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
   while (!queue->IsEmpty()) {
     Tile* tile = queue->Top();
 
-    EXPECT_FALSE(tile->is_occluded(PENDING_TREE));
+    EXPECT_FALSE(tile->is_occluded());
 
     bool tile_is_visible =
         tile->content_rect().Intersects(pending_layer_->visible_content_rect());
     if (tile_is_visible)
       unoccluded_tile_count++;
     queue->Pop();
   }
   EXPECT_EQ(unoccluded_tile_count, 0);
 }
 
@@ skipping 12 matching lines @@
   host_impl_.SetViewportSize(viewport_size);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
 
   // No occlusion.
   int occluded_tile_count = 0;
   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
+    tiling->UpdateAllTilePrioritiesForTesting();
 
     occluded_tile_count = 0;
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              pending_layer_->contents_scale_x(),
              gfx::Rect(layer_bounds));
          iter;
          ++iter) {
       if (!*iter)
         continue;
       const Tile* tile = *iter;
 
       // Fully occluded tiles are not required for activation.
-      if (tile->is_occluded(PENDING_TREE)) {
+      if (tile->is_occluded()) {
         EXPECT_FALSE(tile->required_for_activation());
         occluded_tile_count++;
       }
     }
     EXPECT_EQ(occluded_tile_count, 0);
   }
 
   // Partial occlusion.
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
   LayerImpl* layer1 = pending_layer_->children()[0];
@@ skipping 17 matching lines @@
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              pending_layer_->contents_scale_x(),
              gfx::Rect(layer_bounds));
          iter;
          ++iter) {
       if (!*iter)
         continue;
       const Tile* tile = *iter;
 
-      if (tile->is_occluded(PENDING_TREE)) {
+      if (tile->is_occluded()) {
         EXPECT_FALSE(tile->required_for_activation());
         occluded_tile_count++;
       }
     }
     switch (i) {
       case 0:
         EXPECT_EQ(occluded_tile_count, 5);
         break;
       case 1:
         EXPECT_EQ(occluded_tile_count, 2);
@@ skipping 19 matching lines @@
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              pending_layer_->contents_scale_x(),
              gfx::Rect(layer_bounds));
          iter;
          ++iter) {
       if (!*iter)
         continue;
       const Tile* tile = *iter;
 
-      if (tile->is_occluded(PENDING_TREE)) {
+      if (tile->is_occluded()) {
         EXPECT_FALSE(tile->required_for_activation());
         occluded_tile_count++;
       }
     }
     switch (i) {
       case 0:
         EXPECT_EQ(25, occluded_tile_count);
         break;
       case 1:
         EXPECT_EQ(4, occluded_tile_count);
@@ skipping 49 matching lines @@
   EXPECT_EQ(5u, pending_layer_->num_tilings());
 
   int occluded_tile_count = 0;
   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
     tiling->UpdateAllTilePrioritiesForTesting();
     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 
     occluded_tile_count = 0;
     for (size_t j = 0; j < tiles.size(); ++j) {
-      if (tiles[j]->is_occluded(PENDING_TREE)) {
+      if (tiles[j]->is_occluded()) {
         gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
             tiles[j]->content_rect(), 1.0f / tiles[j]->contents_scale());
         EXPECT_GE(scaled_content_rect.x(), occluding_layer_position.x());
         occluded_tile_count++;
       }
     }
 
     switch (i) {
       case 0:
         EXPECT_EQ(occluded_tile_count, 30);
@@ skipping 33 matching lines @@
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 2));
   LayerImpl* layer1 = pending_layer_->children()[0];
   layer1->SetBounds(layer_bounds);
   layer1->SetContentBounds(layer_bounds);
   layer1->SetDrawsContent(true);
   layer1->SetContentsOpaque(true);
   layer1->SetPosition(occluding_layer_position);
 
   ActivateTree();
 
+  for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
+    tiling->UpdateAllTilePrioritiesForTesting();
+
+    for (
+        PictureLayerTiling::CoverageIterator iter(
+            tiling, active_layer_->contents_scale_x(), gfx::Rect(layer_bounds));
+        iter; ++iter) {
+      if (!*iter)
+        continue;
+      const Tile* tile = *iter;
+
+      gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
+          tile->content_rect(), 1.0f / tile->contents_scale());
+      // Tiles are occluded on the active tree iff they lie beneath the
+      // occluding layer.
+      EXPECT_EQ(tile->is_occluded(),
+                scaled_content_rect.x() >= occluding_layer_position.x());
+    }
+  }
+
   // Partially invalidate the pending layer.
   SetupPendingTreeWithInvalidation(pending_pile, invalidation_rect);
 
-  for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
-    PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
+  for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
     tiling->UpdateAllTilePrioritiesForTesting();
 
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
-             pending_layer_->contents_scale_x(),
-             gfx::Rect(layer_bounds));
-         iter;
-         ++iter) {
-      if (!*iter)
-        continue;
-      const Tile* tile = *iter;
-
-      // All tiles are unoccluded on the pending tree.
-      EXPECT_FALSE(tile->is_occluded(PENDING_TREE));
-
-      Tile* twin_tile = pending_layer_->GetPendingOrActiveTwinTiling(tiling)
-                            ->TileAt(iter.i(), iter.j());
-      gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
-          tile->content_rect(), 1.0f / tile->contents_scale());
-
-      if (scaled_content_rect.Intersects(invalidation_rect)) {
-        // Tiles inside the invalidation rect are only on the pending tree.
-        EXPECT_NE(tile, twin_tile);
-
-        // Unshared tiles should be unoccluded on the active tree by default.
-        EXPECT_FALSE(tile->is_occluded(ACTIVE_TREE));
-      } else {
-        // Tiles outside the invalidation rect are shared between both trees.
-        EXPECT_EQ(tile, twin_tile);
-        // Shared tiles are occluded on the active tree iff they lie beneath the
-        // occluding layer.
-        EXPECT_EQ(tile->is_occluded(ACTIVE_TREE),
-                  scaled_content_rect.x() >= occluding_layer_position.x());
-      }
-    }
-  }
-
-  for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
-    PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
-
-    for (PictureLayerTiling::CoverageIterator iter(
-             tiling,
              active_layer_->contents_scale_x(),
              gfx::Rect(layer_bounds));
          iter;
          ++iter) {
       if (!*iter)
         continue;
       const Tile* tile = *iter;
 
+      // All tiles are unoccluded, because the pending tree has no occlusion.
+      EXPECT_FALSE(tile->is_occluded());
+      EXPECT_FALSE(tile->is_occluded());
+
       Tile* twin_tile = active_layer_->GetPendingOrActiveTwinTiling(tiling)
                             ->TileAt(iter.i(), iter.j());
       gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
           tile->content_rect(), 1.0f / tile->contents_scale());
 
-      // Since we've already checked the shared tiles, only consider tiles in
-      // the invalidation rect.
       if (scaled_content_rect.Intersects(invalidation_rect)) {
-        // Tiles inside the invalidation rect are only on the active tree.
+        // Tiles inside the invalidation rect exist on both trees.
+        EXPECT_TRUE(tile);
+        EXPECT_TRUE(twin_tile);
         EXPECT_NE(tile, twin_tile);
-
-        // Unshared tiles should be unoccluded on the pending tree by default.
-        EXPECT_FALSE(tile->is_occluded(PENDING_TREE));
-
-        // Unshared tiles are occluded on the active tree iff they lie beneath
-        // the occluding layer.
-        EXPECT_EQ(tile->is_occluded(ACTIVE_TREE),
-                  scaled_content_rect.x() >= occluding_layer_position.x());
+      } else {
+        // Tiles outside the invalidation rect only exist on the active tree.
+        EXPECT_TRUE(tile);
+        EXPECT_FALSE(twin_tile);
       }
     }
   }
 }
 
 TEST_F(OcclusionTrackingPictureLayerImplTest,
        OccludedTilesConsideredDuringEviction) {
   base::TimeTicks time_ticks;
   time_ticks += base::TimeDelta::FromMilliseconds(1);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
 
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
   gfx::Size viewport_size(1000, 1000);
   gfx::Point pending_occluding_layer_position(310, 0);
   gfx::Point active_occluding_layer_position(0, 310);
-  gfx::Rect invalidation_rect(230, 230, 102, 102);
+  gfx::Rect invalidation_rect(230, 230, 152, 152);
 
   host_impl_.SetViewportSize(viewport_size);
   host_impl_.SetDeviceScaleFactor(2.f);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupPendingTreeWithFixedTileSize(active_pile, tile_size, Region());
 
   // Partially occlude the active layer.
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 2));
   LayerImpl* active_occluding_layer = pending_layer_->children()[0];
   active_occluding_layer->SetBounds(layer_bounds);
   active_occluding_layer->SetContentBounds(layer_bounds);
   active_occluding_layer->SetDrawsContent(true);
   active_occluding_layer->SetContentsOpaque(true);
   active_occluding_layer->SetPosition(active_occluding_layer_position);
 
   ActivateTree();
 
   // Partially invalidate the pending layer. Tiles inside the invalidation rect
-  // are not shared between trees.
+  // are created.
   SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, invalidation_rect);
 
   // Partially occlude the pending layer in a different way.
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 3));
   LayerImpl* pending_occluding_layer = pending_layer_->children()[0];
   pending_occluding_layer->SetBounds(layer_bounds);
   pending_occluding_layer->SetContentBounds(layer_bounds);
   pending_occluding_layer->SetDrawsContent(true);
   pending_occluding_layer->SetContentsOpaque(true);
   pending_occluding_layer->SetPosition(pending_occluding_layer_position);
 
   EXPECT_EQ(2u, pending_layer_->num_tilings());
   EXPECT_EQ(2u, active_layer_->num_tilings());
 
   time_ticks += base::TimeDelta::FromMilliseconds(1);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
   // UpdateDrawProperties with the occluding layer.
   bool update_lcd_text = false;
   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   // The expected number of occluded tiles on each of the 2 tilings for each of
   // the 3 tree priorities.
-  size_t expected_occluded_tile_count_on_both[] = {9u, 1u};
-  size_t expected_occluded_tile_count_on_active[] = {30u, 3u};
-  size_t expected_occluded_tile_count_on_pending[] = {30u, 3u};
-
-  size_t total_expected_occluded_tile_count_on_trees[] = {33u, 33u};
+  size_t expected_occluded_tile_count_on_pending[] = {4u, 0u};
+  size_t expected_occluded_tile_count_on_active[] = {12u, 1u};
+  size_t total_expected_occluded_tile_count_on_trees[] = {13u, 4u};
 
   // Verify number of occluded tiles on the pending layer for each tiling.
   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
     tiling->UpdateAllTilePrioritiesForTesting();
 
     size_t occluded_tile_count_on_pending = 0u;
-    size_t occluded_tile_count_on_active = 0u;
-    size_t occluded_tile_count_on_both = 0u;
     for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f,
                                                    gfx::Rect(layer_bounds));
          iter; ++iter) {
       Tile* tile = *iter;
 
+      if (invalidation_rect.Intersects(iter.geometry_rect()))
+        EXPECT_TRUE(tile);
+      else
+        EXPECT_FALSE(tile);
+
       if (!tile)
         continue;
-      if (tile->is_occluded(PENDING_TREE))
+      if (tile->is_occluded())
         occluded_tile_count_on_pending++;
-      if (tile->is_occluded(ACTIVE_TREE))
-        occluded_tile_count_on_active++;
-      if (tile->is_occluded(PENDING_TREE) && tile->is_occluded(ACTIVE_TREE))
-        occluded_tile_count_on_both++;
     }
     EXPECT_EQ(expected_occluded_tile_count_on_pending[i],
               occluded_tile_count_on_pending)
         << tiling->contents_scale();
-    EXPECT_EQ(expected_occluded_tile_count_on_active[i],
-              occluded_tile_count_on_active)
-        << tiling->contents_scale();
-    EXPECT_EQ(expected_occluded_tile_count_on_both[i],
-              occluded_tile_count_on_both)
-        << tiling->contents_scale();
   }
 
   // Verify number of occluded tiles on the active layer for each tiling.
   for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
     tiling->UpdateAllTilePrioritiesForTesting();
 
-    size_t occluded_tile_count_on_pending = 0u;
     size_t occluded_tile_count_on_active = 0u;
-    size_t occluded_tile_count_on_both = 0u;
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              pending_layer_->contents_scale_x(),
              gfx::Rect(layer_bounds));
          iter;
          ++iter) {
       Tile* tile = *iter;
 
       if (!tile)
         continue;
-      if (tile->is_occluded(PENDING_TREE))
-        occluded_tile_count_on_pending++;
-      if (tile->is_occluded(ACTIVE_TREE))
+      if (tile->is_occluded())
         occluded_tile_count_on_active++;
-      if (tile->is_occluded(PENDING_TREE) && tile->is_occluded(ACTIVE_TREE))
-        occluded_tile_count_on_both++;
     }
-    EXPECT_EQ(expected_occluded_tile_count_on_pending[i],
-              occluded_tile_count_on_pending)
-        << i;
     EXPECT_EQ(expected_occluded_tile_count_on_active[i],
               occluded_tile_count_on_active)
         << i;
-    EXPECT_EQ(expected_occluded_tile_count_on_both[i],
-              occluded_tile_count_on_both)
-        << i;
   }
 
   std::vector<Tile*> all_tiles;
   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
     all_tiles.insert(all_tiles.end(), tiles.begin(), tiles.end());
   }
+  for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
+    std::vector<Tile*> tiles = tiling->AllTilesForTesting();
+    all_tiles.insert(all_tiles.end(), tiles.begin(), tiles.end());
+  }
 
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
 
   VerifyEvictionConsidersOcclusion(
       pending_layer_, active_layer_, PENDING_TREE,
-      total_expected_occluded_tile_count_on_trees[PENDING_TREE]);
+      total_expected_occluded_tile_count_on_trees[PENDING_TREE], __LINE__);
   VerifyEvictionConsidersOcclusion(
       active_layer_, pending_layer_, ACTIVE_TREE,
-      total_expected_occluded_tile_count_on_trees[ACTIVE_TREE]);
+      total_expected_occluded_tile_count_on_trees[ACTIVE_TREE], __LINE__);
 
   // Repeat the tests without valid active tree priorities.
   active_layer_->set_has_valid_tile_priorities(false);
   VerifyEvictionConsidersOcclusion(
       pending_layer_, active_layer_, PENDING_TREE,
-      total_expected_occluded_tile_count_on_trees[PENDING_TREE]);
+      total_expected_occluded_tile_count_on_trees[PENDING_TREE], __LINE__);
   VerifyEvictionConsidersOcclusion(
-      active_layer_, pending_layer_, ACTIVE_TREE, 0u);
+      active_layer_, pending_layer_, ACTIVE_TREE,
+      total_expected_occluded_tile_count_on_trees[ACTIVE_TREE], __LINE__);
   active_layer_->set_has_valid_tile_priorities(true);
 
   // Repeat the tests without valid pending tree priorities.
   pending_layer_->set_has_valid_tile_priorities(false);
   VerifyEvictionConsidersOcclusion(
       active_layer_, pending_layer_, ACTIVE_TREE,
-      total_expected_occluded_tile_count_on_trees[ACTIVE_TREE]);
+      total_expected_occluded_tile_count_on_trees[ACTIVE_TREE], __LINE__);
   VerifyEvictionConsidersOcclusion(
-      pending_layer_, active_layer_, PENDING_TREE, 0u);
+      pending_layer_, active_layer_, PENDING_TREE,
+      total_expected_occluded_tile_count_on_trees[PENDING_TREE], __LINE__);
   pending_layer_->set_has_valid_tile_priorities(true);
 }
 
 TEST_F(PictureLayerImplTest, PendingOrActiveTwinLayer) {
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   SetupPendingTree(pile);
@@ skipping 208 matching lines @@
   std::vector<Tile*> tiles;
   for (PictureLayerTiling::CoverageIterator iter(
            pending_layer_->HighResTiling(),
            1.f,
            pending_layer_->HighResTiling()->GetCurrentVisibleRectForTesting());
        iter;
        ++iter) {
     if (*iter)
       tiles.push_back(*iter);
   }
+  for (PictureLayerTiling::CoverageIterator iter(
+           active_layer_->HighResTiling(), 1.f,
+           active_layer_->HighResTiling()->GetCurrentVisibleRectForTesting());
+       iter; ++iter) {
+    if (*iter)
+      tiles.push_back(*iter);
+  }
 
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
 
   // Ensure we can activate.
   EXPECT_TRUE(host_impl_.tile_manager()->IsReadyToActivate());
 }
 
 TEST_F(PictureLayerImplTest, CloneMissingRecordings) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
 
   scoped_refptr<FakePicturePileImpl> filled_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   scoped_ptr<FakePicturePile> partial_recording =
       FakePicturePile::CreateEmptyPile(tile_size, layer_bounds);
   for (int i = 1; i < partial_recording->tiling().num_tiles_x(); ++i) {
     for (int j = 1; j < partial_recording->tiling().num_tiles_y(); ++j)
       partial_recording->AddRecordingAt(i, j);
   }
   scoped_refptr<FakePicturePileImpl> partial_pile =
       FakePicturePileImpl::CreateFromPile(partial_recording.get(), nullptr);
 
   SetupPendingTreeWithFixedTileSize(filled_pile, tile_size, Region());
   ActivateTree();
 
   PictureLayerTiling* pending_tiling = old_pending_layer_->HighResTiling();
   PictureLayerTiling* active_tiling = active_layer_->HighResTiling();
 
-  // We should have all tiles in both tile sets.
-  EXPECT_EQ(5u * 5u, pending_tiling->AllTilesForTesting().size());
+  // We should have all tiles on active, and none on pending.
+  EXPECT_EQ(0u, pending_tiling->AllTilesForTesting().size());
   EXPECT_EQ(5u * 5u, active_tiling->AllTilesForTesting().size());
 
   // Now put a partially-recorded pile on the pending tree (and invalidate
   // everything, since the main thread PicturePile will invalidate dropped
   // recordings). This will cause us to be missing some tiles.
   SetupPendingTreeWithFixedTileSize(partial_pile, tile_size,
                                     Region(gfx::Rect(layer_bounds)));
   EXPECT_EQ(3u * 3u, pending_tiling->AllTilesForTesting().size());
   EXPECT_FALSE(pending_tiling->TileAt(0, 0));
   EXPECT_FALSE(pending_tiling->TileAt(1, 1));
   EXPECT_TRUE(pending_tiling->TileAt(2, 2));
 
   // Active is not affected yet.
   EXPECT_EQ(5u * 5u, active_tiling->AllTilesForTesting().size());
 
   // Activate the tree. The same tiles go missing on the active tree.
   ActivateTree();
   EXPECT_EQ(3u * 3u, active_tiling->AllTilesForTesting().size());
   EXPECT_FALSE(active_tiling->TileAt(0, 0));
   EXPECT_FALSE(active_tiling->TileAt(1, 1));
   EXPECT_TRUE(active_tiling->TileAt(2, 2));
 
   // Now put a full recording on the pending tree again. We'll get all our tiles
   // back.
   SetupPendingTreeWithFixedTileSize(filled_pile, tile_size,
                                     Region(gfx::Rect(layer_bounds)));
   EXPECT_EQ(5u * 5u, pending_tiling->AllTilesForTesting().size());
+  Tile* tile00 = pending_tiling->TileAt(0, 0);
+  Tile* tile11 = pending_tiling->TileAt(1, 1);
+  Tile* tile22 = pending_tiling->TileAt(2, 2);
 
   // Active is not affected yet.
   EXPECT_EQ(3u * 3u, active_tiling->AllTilesForTesting().size());
 
-  // Activate the tree. The tiles are created and shared on the active tree.
+  // Activate the tree. The tiles are moved to the active tree.
   ActivateTree();
   EXPECT_EQ(5u * 5u, active_tiling->AllTilesForTesting().size());
-  EXPECT_TRUE(active_tiling->TileAt(0, 0)->is_shared());
-  EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
-  EXPECT_TRUE(active_tiling->TileAt(2, 2)->is_shared());
+  EXPECT_EQ(tile00, active_tiling->TileAt(0, 0));
+  EXPECT_EQ(tile11, active_tiling->TileAt(1, 1));
+  EXPECT_EQ(tile22, active_tiling->TileAt(2, 2));
 }
 
 class TileSizeSettings : public ImplSidePaintingSettings {
  public:
   TileSizeSettings() {
     default_tile_size = gfx::Size(100, 100);
     max_untiled_layer_size = gfx::Size(200, 200);
   }
 };
 
@@ skipping 52 matching lines @@
   result = layer->CalculateTileSize(gfx::Size(447, 400));
   EXPECT_EQ(result.width(), 448);
   EXPECT_EQ(result.height(), 448);
   result = layer->CalculateTileSize(gfx::Size(500, 499));
   EXPECT_EQ(result.width(), 512);
   EXPECT_EQ(result.height(), 500 + 2);
 }
 
 }  // namespace
 }  // namespace cc