Revert two cc patches due to crashes on canary.

This is a revert of two cc patches:
1) cc: Always use invalidation on the pending tree when deciding to share
  https://crrev.com/82e46120237bc023559ac7ebddb29e21b6530170
2) cc: Always keep the PictureLayerImpl::twin_layer_ pointer valid
  https://crrev.com/11f13546fd3ee3d53921c23861bf970bd2bb6428

These are being reverted together because (1) depends on (2). Landing
through the CQ to prevent too much chaos muppet.

Reason for revert:
I suspect these patches are causing canary crashers (see http://crbug.com/427215)

TBR=enne@chromium.org,vmpstr@chromium.org,danakj@chromium.org
BUG=407418,387116,427215

Review URL: https://codereview.chromium.org/680793002

Cr-Commit-Position: refs/heads/master@{#301299}

17 files changed, 113 insertions, 264 deletions

diff --git a/cc/debug/rasterize_and_record_benchmark_impl.cc b/cc/debug/rasterize_and_record_benchmark_impl.cc
index 0310b10..612dad8 100644
--- a/cc/debug/rasterize_and_record_benchmark_impl.cc
+++ b/cc/debug/rasterize_and_record_benchmark_impl.cc
@@ -106,12 +106,12 @@ class FixedInvalidationPictureLayerTilingClient
   }
 
   // This is the only function that returns something different from the base
-  // client. Avoids sharing tiles in this area.
-  const Region* GetPendingInvalidation() override { return &invalidation_; }
+  // client.
+  const Region* GetInvalidation() override { return &invalidation_; }
 
-  const PictureLayerTiling* GetPendingOrActiveTwinTiling(
+  const PictureLayerTiling* GetTwinTiling(
       const PictureLayerTiling* tiling) const override {
-    return base_client_->GetPendingOrActiveTwinTiling(tiling);
+    return base_client_->GetTwinTiling(tiling);
   }
 
   PictureLayerTiling* GetRecycledTwinTiling(
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 6556afa..e51821f 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -90,8 +90,6 @@ PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* tree_impl, int id)
 }
 
 PictureLayerImpl::~PictureLayerImpl() {
-  if (twin_layer_)
-    twin_layer_->twin_layer_ = nullptr;
   layer_tree_impl()->UnregisterPictureLayerImpl(this);
 }
 
@@ -112,15 +110,10 @@ void PictureLayerImpl::PushPropertiesTo(LayerImpl* base_layer) {
 
   LayerImpl::PushPropertiesTo(base_layer);
 
-  // Twin relationships should never change once established.
-  DCHECK_IMPLIES(twin_layer_, twin_layer_ == layer_impl);
-  DCHECK_IMPLIES(twin_layer_, layer_impl->twin_layer_ == this);
-  // The twin relationship does not need to exist before the first
-  // PushPropertiesTo from pending to active layer since before that the active
-  // layer can not have a pile or tilings, it has only been created and inserted
-  // into the tree at that point.
-  twin_layer_ = layer_impl;
-  layer_impl->twin_layer_ = this;
+  // When the pending tree pushes to the active tree, the pending twin
+  // becomes recycled.
+  layer_impl->twin_layer_ = nullptr;
+  twin_layer_ = nullptr;
 
   layer_impl->pile_ = pile_;
 
@@ -568,16 +561,10 @@ gfx::Rect PictureLayerImpl::GetViewportForTilePriorityInContentSpace() const {
   return visible_rect_in_content_space;
 }
 
-PictureLayerImpl* PictureLayerImpl::GetPendingOrActiveTwinLayer() const {
-  if (!twin_layer_ || !twin_layer_->IsOnActiveOrPendingTree())
-    return nullptr;
-  return twin_layer_;
-}
-
-PictureLayerImpl* PictureLayerImpl::GetRecycledTwinLayer() const {
-  if (!twin_layer_ || twin_layer_->IsOnActiveOrPendingTree())
-    return nullptr;
-  return twin_layer_;
+PictureLayerImpl* PictureLayerImpl::GetRecycledTwinLayer() {
+  // TODO(vmpstr): Maintain recycled twin as a member. crbug.com/407418
+  return static_cast<PictureLayerImpl*>(
+      layer_tree_impl()->FindRecycleTreeLayerById(id()));
 }
 
 void PictureLayerImpl::NotifyTileStateChanged(const Tile* tile) {
@@ -645,21 +632,15 @@ PicturePileImpl* PictureLayerImpl::GetPile() {
   return pile_.get();
 }
 
-const Region* PictureLayerImpl::GetPendingInvalidation() {
-  if (layer_tree_impl()->IsPendingTree())
-    return &invalidation_;
-  DCHECK(layer_tree_impl()->IsActiveTree());
-  if (PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer())
-    return &twin_layer->invalidation_;
-  return nullptr;
+const Region* PictureLayerImpl::GetInvalidation() {
+  return &invalidation_;
 }
 
-const PictureLayerTiling* PictureLayerImpl::GetPendingOrActiveTwinTiling(
+const PictureLayerTiling* PictureLayerImpl::GetTwinTiling(
     const PictureLayerTiling* tiling) const {
-  PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer();
-  if (!twin_layer)
+  if (!twin_layer_)
     return nullptr;
-  return twin_layer->tilings_->TilingAtScale(tiling->contents_scale());
+  return twin_layer_->tilings_->TilingAtScale(tiling->contents_scale());
 }
 
 PictureLayerTiling* PictureLayerImpl::GetRecycledTwinTiling(
@@ -864,12 +845,16 @@ void PictureLayerImpl::DoPostCommitInitialization() {
   if (!tilings_)
     tilings_ = make_scoped_ptr(new PictureLayerTilingSet(this));
 
-  PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer();
-  if (twin_layer) {
+  DCHECK(!twin_layer_);
+  twin_layer_ = static_cast<PictureLayerImpl*>(
+      layer_tree_impl()->FindActiveTreeLayerById(id()));
+  if (twin_layer_) {
+    DCHECK(!twin_layer_->twin_layer_);
+    twin_layer_->twin_layer_ = this;
     // If the twin has never been pushed to, do not sync from it.
     // This can happen if this function is called during activation.
-    if (!twin_layer->needs_post_commit_initialization_)
-      SyncFromActiveLayer(twin_layer);
+    if (!twin_layer_->needs_post_commit_initialization_)
+      SyncFromActiveLayer(twin_layer_);
   }
 
   needs_post_commit_initialization_ = false;
@@ -883,8 +868,8 @@ PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
 
   DCHECK(pile_->HasRecordings());
 
-  if (PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer())
-    twin_layer->SyncTiling(tiling);
+  if (twin_layer_)
+    twin_layer_->SyncTiling(tiling);
 
   return tiling;
 }
@@ -1128,7 +1113,7 @@ void PictureLayerImpl::CleanUpTilingsOnActiveLayer(
       raster_contents_scale_, ideal_contents_scale_);
   float twin_low_res_scale = 0.f;
 
-  PictureLayerImpl* twin = GetPendingOrActiveTwinLayer();
+  PictureLayerImpl* twin = twin_layer_;
   if (twin && twin->CanHaveTilings()) {
     min_acceptable_high_res_scale = std::min(
         min_acceptable_high_res_scale,
@@ -1175,8 +1160,7 @@ void PictureLayerImpl::CleanUpTilingsOnActiveLayer(
   PictureLayerImpl* recycled_twin = GetRecycledTwinLayer();
   // Remove tilings on this tree and the twin tree.
   for (size_t i = 0; i < to_remove.size(); ++i) {
-    const PictureLayerTiling* twin_tiling =
-        GetPendingOrActiveTwinTiling(to_remove[i]);
+    const PictureLayerTiling* twin_tiling = GetTwinTiling(to_remove[i]);
     // Only remove tilings from the twin layer if they have
     // NON_IDEAL_RESOLUTION.
     if (twin_tiling && twin_tiling->resolution() == NON_IDEAL_RESOLUTION)
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index 9350dc8..1ac106a 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -121,8 +121,8 @@ class CC_EXPORT PictureLayerImpl
                                  const gfx::Rect& content_rect) override;
   PicturePileImpl* GetPile() override;
   gfx::Size CalculateTileSize(const gfx::Size& content_bounds) const override;
-  const Region* GetPendingInvalidation() override;
-  const PictureLayerTiling* GetPendingOrActiveTwinTiling(
+  const Region* GetInvalidation() override;
+  const PictureLayerTiling* GetTwinTiling(
       const PictureLayerTiling* tiling) const override;
   PictureLayerTiling* GetRecycledTwinTiling(
       const PictureLayerTiling* tiling) override;
@@ -144,7 +144,7 @@ class CC_EXPORT PictureLayerImpl
   void RunMicroBenchmark(MicroBenchmarkImpl* benchmark) override;
 
   // Functions used by tile manager.
-  PictureLayerImpl* GetPendingOrActiveTwinLayer() const;
+  PictureLayerImpl* GetTwinLayer() { return twin_layer_; }
   bool IsOnActiveOrPendingTree() const;
   // Virtual for testing.
   virtual bool HasValidTilePriorities() const;
@@ -168,7 +168,7 @@ class CC_EXPORT PictureLayerImpl
   float SnappedContentsScale(float new_contents_scale);
   void ResetRasterScale();
   gfx::Rect GetViewportForTilePriorityInContentSpace() const;
-  PictureLayerImpl* GetRecycledTwinLayer() const;
+  PictureLayerImpl* GetRecycledTwinLayer();
 
   void DoPostCommitInitializationIfNeeded() {
     if (needs_post_commit_initialization_)
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 2b1d0dc..3920779 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -138,23 +138,12 @@ class PictureLayerImplTest : public testing::Test {
     host_impl_.CreatePendingTree();
     host_impl_.pending_tree()->SetPageScaleFactorAndLimits(1.f, 0.25f, 100.f);
     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
+    // Clear recycled tree.
+    pending_tree->DetachLayerTree();
 
-    // Steal from the recycled tree.
-    scoped_ptr<LayerImpl> old_pending_root = pending_tree->DetachLayerTree();
-    DCHECK_IMPLIES(old_pending_root, old_pending_root->id() == id_);
-
-    scoped_ptr<FakePictureLayerImpl> pending_layer;
-    if (old_pending_root) {
-      pending_layer.reset(
-          static_cast<FakePictureLayerImpl*>(old_pending_root.release()));
-      pending_layer->SetPile(pile);
-    } else {
-      pending_layer =
-          FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
-      pending_layer->SetDrawsContent(true);
-    }
-    // The bounds() just mirror the pile size.
-    pending_layer->SetBounds(pending_layer->pile()->tiling_size());
+    scoped_ptr<FakePictureLayerImpl> pending_layer =
+        FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
+    pending_layer->SetDrawsContent(true);
     pending_tree->SetRootLayer(pending_layer.Pass());
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
@@ -2037,62 +2026,6 @@ TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {
   EXPECT_FALSE(active_layer_->needs_post_commit_initialization());
 }
 
-TEST_F(PictureLayerImplTest, ShareTilesOnNextFrame) {
-  SetupDefaultTrees(gfx::Size(1500, 1500));
-
-  PictureLayerTiling* tiling = pending_layer_->AddTiling(1.f);
-  gfx::Rect first_invalidate = tiling->TilingDataForTesting().TileBounds(0, 0);
-  first_invalidate.Inset(tiling->TilingDataForTesting().border_texels(),
-                         tiling->TilingDataForTesting().border_texels());
-  gfx::Rect second_invalidate = tiling->TilingDataForTesting().TileBounds(1, 1);
-  second_invalidate.Inset(tiling->TilingDataForTesting().border_texels(),
-                          tiling->TilingDataForTesting().border_texels());
-
-  // Make a pending tree with an invalidated raster tile 0,0.
-  tiling->CreateAllTilesForTesting();
-  pending_layer_->set_invalidation(first_invalidate);
-
-  // Activate and make a pending tree with an invalidated raster tile 1,1.
-  ActivateTree();
-
-  host_impl_.CreatePendingTree();
-  pending_layer_ = static_cast<FakePictureLayerImpl*>(
-      host_impl_.pending_tree()->root_layer());
-  pending_layer_->set_invalidation(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));
-  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());
-
-  // Drop the tiles on the active tree and recreate them. The same tiles
-  // should be shared or not.
-  active_tiling->ComputeTilePriorityRects(
-      ACTIVE_TREE, 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));
-  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());
-}
-
 TEST_F(PictureLayerImplTest, ShareTilesOnSync) {
   SetupDefaultTrees(gfx::Size(1500, 1500));
   AddDefaultTilingsWithInvalidation(gfx::Rect());
@@ -2315,11 +2248,12 @@ TEST_F(PictureLayerImplTest, HighResCreatedWhenBoundsShrink) {
   // other words we want the pending layer to sync from the active layer.
   pending_layer_->SetBounds(gfx::Size(1, 1));
   pending_layer_->SetNeedsPostCommitInitialization();
+  pending_layer_->set_twin_layer(nullptr);
+  active_layer_->set_twin_layer(nullptr);
   EXPECT_TRUE(pending_layer_->needs_post_commit_initialization());
 
   // Update the draw properties: sync from active tree should happen here.
   host_impl_.pending_tree()->UpdateDrawProperties();
-  EXPECT_FALSE(pending_layer_->needs_post_commit_initialization());
 
   // Another sanity check.
   ASSERT_EQ(1.f, pending_layer_->MinimumContentsScale());
@@ -4209,8 +4143,8 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, DifferentOcclusionOnTrees) {
       // 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());
+      Tile* twin_tile =
+          pending_layer_->GetTwinTiling(tiling)->TileAt(iter.i(), iter.j());
       gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
           tile->content_rect(), 1.0f / tile->contents_scale());
 
@@ -4244,8 +4178,8 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, DifferentOcclusionOnTrees) {
         continue;
       const Tile* tile = *iter;
 
-      Tile* twin_tile = active_layer_->GetPendingOrActiveTwinTiling(tiling)
-                            ->TileAt(iter.i(), iter.j());
+      Tile* twin_tile =
+          active_layer_->GetTwinTiling(tiling)->TileAt(iter.i(), iter.j());
       gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
           tile->content_rect(), 1.0f / tile->contents_scale());
 
@@ -4422,33 +4356,6 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
                                    total_expected_occluded_tile_count);
 }
 
-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);
-  EXPECT_FALSE(pending_layer_->GetPendingOrActiveTwinLayer());
-
-  ActivateTree();
-  EXPECT_FALSE(active_layer_->GetPendingOrActiveTwinLayer());
-
-  SetupPendingTree(pile);
-  EXPECT_TRUE(pending_layer_->GetPendingOrActiveTwinLayer());
-  EXPECT_TRUE(active_layer_->GetPendingOrActiveTwinLayer());
-  EXPECT_EQ(pending_layer_, active_layer_->GetPendingOrActiveTwinLayer());
-  EXPECT_EQ(active_layer_, pending_layer_->GetPendingOrActiveTwinLayer());
-
-  ActivateTree();
-  EXPECT_FALSE(active_layer_->GetPendingOrActiveTwinLayer());
-
-  // Make an empty pending tree.
-  host_impl_.CreatePendingTree();
-  host_impl_.pending_tree()->DetachLayerTree();
-  EXPECT_FALSE(active_layer_->GetPendingOrActiveTwinLayer());
-}
-
 TEST_F(PictureLayerImplTest, RecycledTwinLayer) {
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
@@ -4470,9 +4377,7 @@ TEST_F(PictureLayerImplTest, RecycledTwinLayer) {
   EXPECT_TRUE(active_layer_->GetRecycledTwinLayer());
   EXPECT_EQ(old_pending_layer_, active_layer_->GetRecycledTwinLayer());
 
-  // Make an empty pending tree.
-  host_impl_.CreatePendingTree();
-  host_impl_.pending_tree()->DetachLayerTree();
+  host_impl_.ResetRecycleTreeForTesting();
   EXPECT_FALSE(active_layer_->GetRecycledTwinLayer());
 }
 
diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index 771826f..4dc46e0 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -126,8 +126,7 @@ Tile* PictureLayerTiling::CreateTile(int i,
     if (Tile* candidate_tile = twin_tiling->TileAt(i, j)) {
       gfx::Rect rect =
           gfx::ScaleToEnclosingRect(paint_rect, 1.0f / contents_scale_);
-      const Region* invalidation = client_->GetPendingInvalidation();
-      if (!invalidation || !invalidation->Intersects(rect)) {
+      if (!client_->GetInvalidation()->Intersects(rect)) {
         DCHECK(!candidate_tile->is_shared());
         DCHECK_EQ(i, candidate_tile->tiling_i_index());
         DCHECK_EQ(j, candidate_tile->tiling_j_index());
@@ -149,8 +148,7 @@ Tile* PictureLayerTiling::CreateTile(int i,
 }
 
 void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() {
-  const PictureLayerTiling* twin_tiling =
-      client_->GetPendingOrActiveTwinTiling(this);
+  const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
   bool include_borders = false;
   for (TilingData::Iterator iter(
            &tiling_data_, live_tiles_rect_, include_borders);
@@ -227,8 +225,7 @@ void PictureLayerTiling::UpdateTilesToCurrentPile(
 
     // If the layer grew, the live_tiles_rect_ is not changed, but a new row
     // and/or column of tiles may now exist inside the same live_tiles_rect_.
-    const PictureLayerTiling* twin_tiling =
-        client_->GetPendingOrActiveTwinTiling(this);
+    const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
     if (after_right > before_right) {
       DCHECK_EQ(after_right, before_right + 1);
       for (int j = before_top; j <= after_bottom; ++j)
@@ -632,8 +629,7 @@ void PictureLayerTiling::SetLiveTilesRect(
     RemoveTileAt(iter.index_x(), iter.index_y(), recycled_twin);
   }
 
-  const PictureLayerTiling* twin_tiling =
-      client_->GetPendingOrActiveTwinTiling(this);
+  const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
 
   // Iterate to allocate new tiles for all regions with newly exposed area.
   for (TilingData::DifferenceIterator iter(&tiling_data_,
@@ -721,8 +717,7 @@ bool PictureLayerTiling::IsTileRequiredForActivation(const Tile* tile) const {
   if (client_->RequiresHighResToDraw())
     return true;
 
-  const PictureLayerTiling* twin_tiling =
-      client_->GetPendingOrActiveTwinTiling(this);
+  const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
   if (!twin_tiling)
     return true;
 
@@ -745,8 +740,7 @@ bool PictureLayerTiling::IsTileRequiredForActivation(const Tile* tile) const {
 void PictureLayerTiling::UpdateTileAndTwinPriority(Tile* tile) const {
   UpdateTilePriority(tile);
 
-  const PictureLayerTiling* twin_tiling =
-      client_->GetPendingOrActiveTwinTiling(this);
+  const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
   if (!tile->is_shared() || !twin_tiling) {
     WhichTree tree = client_->GetTree();
     WhichTree twin_tree = tree == ACTIVE_TREE ? PENDING_TREE : ACTIVE_TREE;
diff --git a/cc/resources/picture_layer_tiling.h b/cc/resources/picture_layer_tiling.h
index fba3df3..f692702 100644
--- a/cc/resources/picture_layer_tiling.h
+++ b/cc/resources/picture_layer_tiling.h
@@ -41,10 +41,8 @@ class CC_EXPORT PictureLayerTilingClient {
   virtual PicturePileImpl* GetPile() = 0;
   virtual gfx::Size CalculateTileSize(
     const gfx::Size& content_bounds) const = 0;
-  // This invalidation region defines the area (if any, it can by null) that
-  // tiles can not be shared between pending and active trees.
-  virtual const Region* GetPendingInvalidation() = 0;
-  virtual const PictureLayerTiling* GetPendingOrActiveTwinTiling(
+  virtual const Region* GetInvalidation() = 0;
+  virtual const PictureLayerTiling* GetTwinTiling(
       const PictureLayerTiling* tiling) const = 0;
   virtual PictureLayerTiling* GetRecycledTwinTiling(
       const PictureLayerTiling* tiling) = 0;
diff --git a/cc/resources/tile_manager_unittest.cc b/cc/resources/tile_manager_unittest.cc
index 2f0735c..398474b 100644
--- a/cc/resources/tile_manager_unittest.cc
+++ b/cc/resources/tile_manager_unittest.cc
@@ -100,23 +100,12 @@ class TileManagerTilePriorityQueueTest : public testing::Test {
   void SetupPendingTree(scoped_refptr<PicturePileImpl> pile) {
     host_impl_.CreatePendingTree();
     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
+    // Clear recycled tree.
+    pending_tree->DetachLayerTree();
 
-    // Steal from the recycled tree.
-    scoped_ptr<LayerImpl> old_pending_root = pending_tree->DetachLayerTree();
-    DCHECK_IMPLIES(old_pending_root, old_pending_root->id() == id_);
-
-    scoped_ptr<FakePictureLayerImpl> pending_layer;
-    if (old_pending_root) {
-      pending_layer.reset(
-          static_cast<FakePictureLayerImpl*>(old_pending_root.release()));
-      pending_layer->SetPile(pile);
-    } else {
-      pending_layer =
-          FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
-      pending_layer->SetDrawsContent(true);
-    }
-    // The bounds() just mirror the pile size.
-    pending_layer->SetBounds(pending_layer->pile()->tiling_size());
+    scoped_ptr<FakePictureLayerImpl> pending_layer =
+        FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
+    pending_layer->SetDrawsContent(true);
     pending_tree->SetRootLayer(pending_layer.Pass());
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
diff --git a/cc/test/fake_picture_layer_impl.cc b/cc/test/fake_picture_layer_impl.cc
index 73c1ae3..8082685 100644
--- a/cc/test/fake_picture_layer_impl.cc
+++ b/cc/test/fake_picture_layer_impl.cc
@@ -97,16 +97,6 @@ PictureLayerTiling* FakePictureLayerImpl::LowResTiling() const {
   return result;
 }
 
-void FakePictureLayerImpl::SetPile(scoped_refptr<PicturePileImpl> pile) {
-  pile_.swap(pile);
-  if (tilings()) {
-    for (size_t i = 0; i < num_tilings(); ++i) {
-      tilings()->tiling_at(i)->UpdateTilesToCurrentPile(Region(),
-                                                        pile_->tiling_size());
-    }
-  }
-}
-
 void FakePictureLayerImpl::SetAllTilesVisible() {
   WhichTree tree =
       layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
diff --git a/cc/test/fake_picture_layer_impl.h b/cc/test/fake_picture_layer_impl.h
index a3c69c5..ef554b3 100644
--- a/cc/test/fake_picture_layer_impl.h
+++ b/cc/test/fake_picture_layer_impl.h
@@ -80,9 +80,10 @@ class FakePictureLayerImpl : public PictureLayerImpl {
   PictureLayerTiling* LowResTiling() const;
   size_t num_tilings() const { return tilings_->num_tilings(); }
 
+  PictureLayerImpl* twin_layer() { return twin_layer_; }
+  void set_twin_layer(PictureLayerImpl* twin) { twin_layer_ = twin; }
   PictureLayerTilingSet* tilings() { return tilings_.get(); }
   PicturePileImpl* pile() { return pile_.get(); }
-  void SetPile(scoped_refptr<PicturePileImpl> pile);
   size_t append_quads_count() { return append_quads_count_; }
 
   const Region& invalidation() const { return invalidation_; }
diff --git a/cc/test/fake_picture_layer_tiling_client.cc b/cc/test/fake_picture_layer_tiling_client.cc
index a0096d1..ce46c91 100644
--- a/cc/test/fake_picture_layer_tiling_client.cc
+++ b/cc/test/fake_picture_layer_tiling_client.cc
@@ -73,13 +73,12 @@ int FakePictureLayerTilingClient::GetSkewportExtrapolationLimitInContentPixels()
   return skewport_extrapolation_limit_in_content_pixels_;
 }
 
-const Region* FakePictureLayerTilingClient::GetPendingInvalidation() {
+const Region* FakePictureLayerTilingClient::GetInvalidation() {
   return &invalidation_;
 }
 
-const PictureLayerTiling*
-FakePictureLayerTilingClient::GetPendingOrActiveTwinTiling(
-    const PictureLayerTiling* tiling) const {
+const PictureLayerTiling* FakePictureLayerTilingClient::GetTwinTiling(
+      const PictureLayerTiling* tiling) const {
   return twin_tiling_;
 }
 
diff --git a/cc/test/fake_picture_layer_tiling_client.h b/cc/test/fake_picture_layer_tiling_client.h
index c128990..0e2f645 100644
--- a/cc/test/fake_picture_layer_tiling_client.h
+++ b/cc/test/fake_picture_layer_tiling_client.h
@@ -33,8 +33,8 @@ class FakePictureLayerTilingClient : public PictureLayerTilingClient {
   void SetTileSize(const gfx::Size& tile_size);
   gfx::Size TileSize() const { return tile_size_; }
 
-  const Region* GetPendingInvalidation() override;
-  const PictureLayerTiling* GetPendingOrActiveTwinTiling(
+  const Region* GetInvalidation() override;
+  const PictureLayerTiling* GetTwinTiling(
       const PictureLayerTiling* tiling) const override;
   PictureLayerTiling* GetRecycledTwinTiling(
       const PictureLayerTiling* tiling) override;
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 2cd7033..5e89bbe 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -1183,6 +1183,12 @@ void LayerTreeHostImpl::ResetTreesForTesting() {
   recycle_tree_ = nullptr;
 }
 
+void LayerTreeHostImpl::ResetRecycleTreeForTesting() {
+  if (recycle_tree_)
+    recycle_tree_->DetachLayerTree();
+  recycle_tree_ = nullptr;
+}
+
 void LayerTreeHostImpl::EnforceManagedMemoryPolicy(
     const ManagedMemoryPolicy& policy) {
 
@@ -1280,7 +1286,7 @@ void LayerTreeHostImpl::GetPictureLayerImplPairs(
     if (!layer->HasValidTilePriorities())
       continue;
 
-    PictureLayerImpl* twin_layer = layer->GetPendingOrActiveTwinLayer();
+    PictureLayerImpl* twin_layer = layer->GetTwinLayer();
 
     // Ignore the twin layer when tile priorities are invalid.
     // TODO(vmpstr): Iterators should handle this instead. crbug.com/381704
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 0a62f65..450b272 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -218,6 +218,7 @@ class CC_EXPORT LayerTreeHostImpl
 
   // Resets all of the trees to an empty state.
   void ResetTreesForTesting();
+  void ResetRecycleTreeForTesting();
 
   DrawMode GetDrawMode() const;
 
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index fb23ba6..64758be 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -4,7 +4,6 @@
 
 #include "cc/trees/layer_tree_host_impl.h"
 
-#include <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
@@ -7444,64 +7443,47 @@ TEST_F(LayerTreeHostImplTest, ScrollAnimated) {
 
 TEST_F(LayerTreeHostImplTest, GetPictureLayerImplPairs) {
   host_impl_->CreatePendingTree();
-  host_impl_->pending_tree()->SetRootLayer(
-      PictureLayerImpl::Create(host_impl_->pending_tree(), 10));
-
-  LayerTreeImpl* pending_tree = host_impl_->pending_tree();
-  LayerImpl* pending_layer = pending_tree->root_layer();
-
-  std::vector<PictureLayerImpl::Pair> layer_pairs;
-  host_impl_->GetPictureLayerImplPairs(&layer_pairs);
-  EXPECT_EQ(1u, layer_pairs.size());
-  EXPECT_EQ(pending_layer, layer_pairs[0].pending);
-  EXPECT_EQ(nullptr, layer_pairs[0].active);
-
   host_impl_->ActivateSyncTree();
+  host_impl_->CreatePendingTree();
 
   LayerTreeImpl* active_tree = host_impl_->active_tree();
-  LayerImpl* active_layer = active_tree->root_layer();
+  LayerTreeImpl* pending_tree = host_impl_->pending_tree();
   EXPECT_NE(active_tree, pending_tree);
-  EXPECT_NE(active_layer, pending_layer);
-  EXPECT_NE(nullptr, active_tree);
-  EXPECT_NE(nullptr, active_layer);
 
-  host_impl_->CreatePendingTree();
+  scoped_ptr<FakePictureLayerImpl> active_layer =
+      FakePictureLayerImpl::Create(active_tree, 10);
+  scoped_ptr<FakePictureLayerImpl> pending_layer =
+      FakePictureLayerImpl::Create(pending_tree, 10);
 
-  layer_pairs.clear();
+  std::vector<PictureLayerImpl::Pair> layer_pairs;
   host_impl_->GetPictureLayerImplPairs(&layer_pairs);
-  EXPECT_EQ(1u, layer_pairs.size());
-  EXPECT_EQ(active_layer, layer_pairs[0].active);
-  EXPECT_EQ(pending_layer, layer_pairs[0].pending);
-
-  // Activate, the active layer has no twin now.
-  host_impl_->ActivateSyncTree();
 
-  layer_pairs.clear();
-  host_impl_->GetPictureLayerImplPairs(&layer_pairs);
-  EXPECT_EQ(1u, layer_pairs.size());
-  EXPECT_EQ(active_layer, layer_pairs[0].active);
-  EXPECT_EQ(nullptr, layer_pairs[0].pending);
+  EXPECT_EQ(2u, layer_pairs.size());
+  if (layer_pairs[0].active) {
+    EXPECT_EQ(active_layer.get(), layer_pairs[0].active);
+    EXPECT_EQ(NULL, layer_pairs[0].pending);
+  } else {
+    EXPECT_EQ(pending_layer.get(), layer_pairs[0].pending);
+    EXPECT_EQ(NULL, layer_pairs[0].active);
+  }
 
-  // Create another layer in the pending tree that's not in the active tree. We
-  // should get two pairs.
-  host_impl_->CreatePendingTree();
-  host_impl_->pending_tree()->root_layer()->AddChild(
-      PictureLayerImpl::Create(host_impl_->pending_tree(), 11));
+  if (layer_pairs[1].active) {
+    EXPECT_EQ(active_layer.get(), layer_pairs[1].active);
+    EXPECT_EQ(NULL, layer_pairs[1].pending);
+  } else {
+    EXPECT_EQ(pending_layer.get(), layer_pairs[1].pending);
+    EXPECT_EQ(NULL, layer_pairs[1].active);
+  }
 
-  LayerImpl* new_pending_layer = pending_tree->root_layer()->children()[0];
+  active_layer->set_twin_layer(pending_layer.get());
+  pending_layer->set_twin_layer(active_layer.get());
 
   layer_pairs.clear();
   host_impl_->GetPictureLayerImplPairs(&layer_pairs);
-  EXPECT_EQ(2u, layer_pairs.size());
-
-  // The pair ordering is flaky, so make it consistent.
-  if (layer_pairs[0].active != active_layer)
-    std::swap(layer_pairs[0], layer_pairs[1]);
+  EXPECT_EQ(1u, layer_pairs.size());
 
-  EXPECT_EQ(active_layer, layer_pairs[0].active);
-  EXPECT_EQ(pending_layer, layer_pairs[0].pending);
-  EXPECT_EQ(new_pending_layer, layer_pairs[1].pending);
-  EXPECT_EQ(nullptr, layer_pairs[1].active);
+  EXPECT_EQ(active_layer.get(), layer_pairs[0].active);
+  EXPECT_EQ(pending_layer.get(), layer_pairs[0].pending);
 }
 
 TEST_F(LayerTreeHostImplTest, DidBecomeActive) {
diff --git a/cc/trees/layer_tree_host_unittest_picture.cc b/cc/trees/layer_tree_host_unittest_picture.cc
index 2d485b4..b81fdff 100644
--- a/cc/trees/layer_tree_host_unittest_picture.cc
+++ b/cc/trees/layer_tree_host_unittest_picture.cc
@@ -66,13 +66,13 @@ class LayerTreeHostPictureTestTwinLayer
 
     if (!active_root_impl) {
       EXPECT_EQ(0, activates_);
-      EXPECT_EQ(nullptr, pending_picture_impl->GetPendingOrActiveTwinLayer());
+      EXPECT_EQ(NULL, pending_picture_impl->twin_layer());
       return;
     }
 
     if (active_root_impl->children().empty()) {
       EXPECT_EQ(3, activates_);
-      EXPECT_EQ(nullptr, pending_picture_impl->GetPendingOrActiveTwinLayer());
+      EXPECT_EQ(NULL, pending_picture_impl->twin_layer());
       return;
     }
 
@@ -84,28 +84,20 @@ class LayerTreeHostPictureTestTwinLayer
     // and the next commit will have a pending and active twin again.
     EXPECT_TRUE(activates_ == 1 || activates_ == 4);
 
-    EXPECT_EQ(pending_picture_impl,
-              active_picture_impl->GetPendingOrActiveTwinLayer());
-    EXPECT_EQ(active_picture_impl,
-              pending_picture_impl->GetPendingOrActiveTwinLayer());
-    EXPECT_EQ(nullptr, active_picture_impl->GetRecycledTwinLayer());
+    EXPECT_EQ(pending_picture_impl, active_picture_impl->twin_layer());
+    EXPECT_EQ(active_picture_impl, pending_picture_impl->twin_layer());
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* active_root_impl = impl->active_tree()->root_layer();
-    LayerImpl* recycle_root_impl = impl->recycle_tree()->root_layer();
 
     if (active_root_impl->children().empty()) {
       EXPECT_EQ(2, activates_);
     } else {
       FakePictureLayerImpl* active_picture_impl =
           static_cast<FakePictureLayerImpl*>(active_root_impl->children()[0]);
-      FakePictureLayerImpl* recycle_picture_impl =
-          static_cast<FakePictureLayerImpl*>(recycle_root_impl->children()[0]);
 
-      EXPECT_EQ(nullptr, active_picture_impl->GetPendingOrActiveTwinLayer());
-      EXPECT_EQ(recycle_picture_impl,
-                active_picture_impl->GetRecycledTwinLayer());
+      EXPECT_EQ(NULL, active_picture_impl->twin_layer());
     }
 
     ++activates_;
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 304b9fb..1fe9ba6 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -750,6 +750,13 @@ LayerImpl* LayerTreeImpl::FindPendingTreeLayerById(int id) {
   return tree->LayerById(id);
 }
 
+LayerImpl* LayerTreeImpl::FindRecycleTreeLayerById(int id) {
+  LayerTreeImpl* tree = layer_tree_host_impl_->recycle_tree();
+  if (!tree)
+    return NULL;
+  return tree->LayerById(id);
+}
+
 bool LayerTreeImpl::PinchGestureActive() const {
   return layer_tree_host_impl_->pinch_gesture_active();
 }
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index 57e6ca1..260b90b 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -77,6 +77,7 @@ class CC_EXPORT LayerTreeImpl {
   bool IsRecycleTree() const;
   LayerImpl* FindActiveTreeLayerById(int id);
   LayerImpl* FindPendingTreeLayerById(int id);
+  LayerImpl* FindRecycleTreeLayerById(int id);
   bool PinchGestureActive() const;
   BeginFrameArgs CurrentBeginFrameArgs() const;
   base::TimeDelta begin_impl_frame_interval() const;