cc: Remove tile sharing from tilings.

cc/layers/picture_layer_impl_unittest.cc

Index: cc/layers/picture_layer_impl_unittest.cc
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 4db0f5b5f028aa3715b9293cd987af50ca052288..5c2fa65305348545b10aeb8e8174ef83f17e229d 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -286,15 +286,19 @@ class PictureLayerImplTest : public testing::Test {
   }
 
   void ResetTilingsAndRasterScales() {
-    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 (pending_layer_) {
+      pending_layer_->ReleaseResources();
+      EXPECT_FALSE(pending_layer_->tilings());
+      pending_layer_->RecreateResources();
+      EXPECT_EQ(0u, pending_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) {
@@ -404,7 +408,7 @@ TEST_F(PictureLayerImplTest, CloneNoInvalidation) {
   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) {
@@ -682,9 +686,16 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
              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));
+      }
     }
   }
 
@@ -702,12 +713,8 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
          ++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());
     }
   }
 }
@@ -1525,17 +1532,15 @@ TEST_F(PictureLayerImplTest, ReleaseResources) {
   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();
@@ -1580,16 +1585,16 @@ TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
       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();
@@ -1602,18 +1607,18 @@ TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
   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());
 }
@@ -1802,10 +1807,12 @@ TEST_F(NoLowResPictureLayerImplTest,
       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;
@@ -2071,9 +2078,13 @@ TEST_F(PictureLayerImplTest, HighResRequiredWhenMissingHighResFlagOn) {
 
   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) {

[enne (OOO), 2015/04/13 22:36:02]

AllHighResRequiredEvenIfAirquotesSharedAirquotes

[vmpstr, 2015/04/13 23:52:13]

Done.

@@ -2086,13 +2097,15 @@ TEST_F(PictureLayerImplTest, AllHighResRequiredEvenIfShared) {
       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) {
@@ -2105,18 +2118,22 @@ TEST_F(PictureLayerImplTest, DisallowRequiredForActivation) {
       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) {
+TEST_F(PictureLayerImplTest, EverythingRequiredIfActiveMissingTiles) {

[enne (OOO), 2015/04/13 22:36:02]

O_o?

This was an optimization to make it possible to instantly activate if the active
tree was entirely checkerboarded.

This is testing that we do extra work in this case.

[vmpstr, 2015/04/13 23:52:12]

I've changed this back. I'm not sure it's worth it though, since it triggers in
the case that:

- We don't "require high res to draw"
- The raster sources of this and twin are the same size
- The visible rect of this and twin are the same

So in other words, in situations where have the same viewport and active one has
a hole in the viewport's recording, then the tile would not be required for
activation. Do you know if this is a frequent situation? It costs us a couple of
extra function calls and a rect comparison per rfa tile in other situations.

[vmpstr, 2015/04/13 23:53:48]

I guess in a fast scroll it can happen after a fling, nevermind.

   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
@@ -2143,7 +2160,7 @@ TEST_F(PictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
   pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
   pending_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();
 
-  AssertNoTilesRequired(pending_layer_->HighResTiling());
+  AssertAllTilesRequired(pending_layer_->HighResTiling());
   AssertNoTilesRequired(pending_layer_->LowResTiling());
 }
 
@@ -2187,9 +2204,16 @@ TEST_F(PictureLayerImplTest, HighResRequiredWhenActiveHasDifferentBounds) {
   // 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) {
@@ -2259,14 +2283,15 @@ TEST_F(PictureLayerImplTest, ShareTilesOnNextFrame) {
   // pending_tiling->CreateAllTilesForTesting();
 
   // Tile 0,0 should be shared, but tile 1,1 should not be.

[enne (OOO), 2015/04/13 22:36:02]

Can you change this comment (and other comments [and test titles]) to not
reference sharing?

[vmpstr, 2015/04/13 23:52:12]

Done.

-  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));
+  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.
@@ -2275,14 +2300,15 @@ TEST_F(PictureLayerImplTest, ShareTilesOnNextFrame) {
   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));
+  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) {
@@ -2302,19 +2328,10 @@ TEST_F(PictureLayerImplTest, ShareTilesWithNoInvalidation) {
   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) {
@@ -2348,19 +2365,10 @@ TEST_F(PictureLayerImplTest, ShareInvalidActiveTreeTiles) {
   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) {
@@ -2384,19 +2392,11 @@ TEST_F(PictureLayerImplTest, RecreateInvalidPendingTreeTiles) {
   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) {
@@ -3277,12 +3277,14 @@ TEST_F(PictureLayerImplTest, LowResReadyToDrawNotEnoughToActivate) {
 
   // 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());
 }
@@ -3300,6 +3302,7 @@ TEST_F(PictureLayerImplTest, HighResReadyToDrawEnoughToActivate) {
 
   // 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());
@@ -3478,18 +3481,21 @@ TEST_F(NoLowResPictureLayerImplTest, AllHighResRequiredEvenIfShared) {
       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) {
+TEST_F(NoLowResPictureLayerImplTest, EverythingRequiredIfActiveMissingTiles) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
@@ -3518,9 +3524,9 @@ TEST_F(NoLowResPictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
   if (host_impl_.settings().create_low_res_tiling)
     pending_layer_->LowResTiling()->UpdateAllTilePrioritiesForTesting();
 
-  AssertNoTilesRequired(pending_layer_->HighResTiling());
+  AssertAllTilesRequired(pending_layer_->HighResTiling());
   if (host_impl_.settings().create_low_res_tiling)
-    AssertNoTilesRequired(pending_layer_->LowResTiling());
+    AssertAllTilesRequired(pending_layer_->LowResTiling());
 }
 
 TEST_F(NoLowResPictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
@@ -3872,11 +3878,10 @@ class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest {
   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));
@@ -3884,8 +3889,6 @@ class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest {
       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
@@ -3903,54 +3906,15 @@ class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest {
 
           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;
   }
 };
 
@@ -4375,7 +4339,7 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
   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);
@@ -4399,7 +4363,7 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
   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.
@@ -4423,11 +4387,9 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
 
   // 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) {
@@ -4435,31 +4397,24 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
     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.
@@ -4467,9 +4422,7 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
     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(),
@@ -4480,22 +4433,12 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
 
       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;
@@ -4504,32 +4447,39 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
     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);
 }
 
@@ -4758,6 +4708,13 @@ TEST_F(PictureLayerImplTest, ChangeInViewportAllowsTilingUpdates) {
     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);
 
@@ -4787,8 +4744,8 @@ TEST_F(PictureLayerImplTest, CloneMissingRecordings) {
   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
@@ -4816,6 +4773,9 @@ TEST_F(PictureLayerImplTest, CloneMissingRecordings) {
   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());
@@ -4823,9 +4783,9 @@ TEST_F(PictureLayerImplTest, CloneMissingRecordings) {
   // Activate the tree. The tiles are created and shared on 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 {