cc: Always keep the PictureLayerImpl::twin_layer_ pointer valid.

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 120 matching lines @@
       active_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting();
     pending_layer_->set_invalidation(invalidation);
     for (size_t i = 0; i < pending_layer_->tilings()->num_tilings(); ++i)
       pending_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting();
   }
 
   void SetupPendingTree(scoped_refptr<PicturePileImpl> pile) {
     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();
 
-    scoped_ptr<FakePictureLayerImpl> pending_layer =
-        FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
-    pending_layer->SetDrawsContent(true);
+    // 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());
     pending_tree->SetRootLayer(pending_layer.Pass());
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
     pending_layer_->DoPostCommitInitializationIfNeeded();
   }
 
   void SetupDrawPropertiesAndUpdateTiles(FakePictureLayerImpl* layer,
                                          float ideal_contents_scale,
                                          float device_scale_factor,
@@ skipping 2046 matching lines @@
   // Sanity checks.
   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
   ASSERT_EQ(tiling, active_layer_->tilings()->TilingAtScale(0.5f));
 
   // Now, set the bounds to be 1x1 (so that minimum contents scale becomes
   // 1.0f). Note that we should also ensure that the pending layer needs post
   // commit initialization, since this is what would happen during commit. In
   // 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());
 
   // Now we should've synced 1.5f tiling, since that's the only one that doesn't
   // violate minimum contents scale. At the same time, we should've created a
   // new high res tiling at scale 1.0f.
   EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
   ASSERT_TRUE(pending_layer_->tilings()->TilingAtScale(1.0f));
   EXPECT_EQ(HIGH_RESOLUTION,
@@ skipping 2083 matching lines @@
   }
 
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
 
   VerifyEvictionConsidersOcclusion(pending_layer_,
                                    total_expected_occluded_tile_count);
   VerifyEvictionConsidersOcclusion(active_layer_,
                                    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);
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   SetupPendingTree(pile);
   EXPECT_FALSE(pending_layer_->GetRecycledTwinLayer());
 
   ActivateTree();
   EXPECT_TRUE(active_layer_->GetRecycledTwinLayer());
   EXPECT_EQ(old_pending_layer_, active_layer_->GetRecycledTwinLayer());
 
   SetupPendingTree(pile);
   EXPECT_FALSE(pending_layer_->GetRecycledTwinLayer());
   EXPECT_FALSE(active_layer_->GetRecycledTwinLayer());
 
   ActivateTree();
   EXPECT_TRUE(active_layer_->GetRecycledTwinLayer());
   EXPECT_EQ(old_pending_layer_, active_layer_->GetRecycledTwinLayer());
 
-  host_impl_.ResetRecycleTreeForTesting();
+  // Make an empty pending tree.
+  host_impl_.CreatePendingTree();
+  host_impl_.pending_tree()->DetachLayerTree();

[vmpstr, 2014/10/24 16:47:05]

I'm not sure this tests the same thing since we now have a pending tree.
However, the previous test was also impossible since the active tree structure
should always match the recycle tree structure... That's just a hard thing to
enforce, I think.

[danakj, 2014/10/24 16:53:30]

I think the only way the layer can be deleted from the recycle tree is by making
a pending tree without it. I'm not sure what other scenario would be good to
test here, do you have any in mind?

   EXPECT_FALSE(active_layer_->GetRecycledTwinLayer());
 }
 
 void PictureLayerImplTest::TestQuadsForSolidColor(bool test_for_solid) {
   base::TimeTicks time_ticks;
   time_ticks += base::TimeDelta::FromMilliseconds(1);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(time_ticks));
 
   gfx::Size tile_size(100, 100);
@@ skipping 256 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