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 268 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 168 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 851 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);
       if (tile_is_occluded) {
         occluded_tile_count++;
 
         bool last_tile_is_occluded = last_tile->is_occluded(tree);
         if (!last_tile_is_occluded) {
           TilePriority::PriorityBin tile_priority_bin =
               tile->priority(tree).priority_bin;
           TilePriority::PriorityBin last_tile_priority_bin =
               last_tile->priority(tree).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));
 
@@ skipping 314 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(ACTIVE_TREE),
+                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(ACTIVE_TREE));
+      EXPECT_FALSE(tile->is_occluded(PENDING_TREE));
+
       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))
         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))
         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