cc : Add DCHECKs to ensure we have valid proprety tree indices at commit

cc/trees/tree_synchronizer_unittest.cc

 // Copyright 2011 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/trees/tree_synchronizer.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 147 matching lines @@
 }
 
 // Constructs a very simple tree and synchronizes it without trying to reuse any
 // preexisting layers.
 TEST_F(TreeSynchronizerTest, SyncSimpleTreeFromEmpty) {
   scoped_refptr<Layer> layer_tree_root = Layer::Create();
   layer_tree_root->AddChild(Layer::Create());
   layer_tree_root->AddChild(Layer::Create());
 
   host_->SetRootLayer(layer_tree_root);
+  host_->BuildPropertyTreesForTesting();
 
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
 
   ExpectTreesAreIdentical(layer_tree_root.get(),
                           host_->active_tree()->root_layer_for_testing(),
                           host_->active_tree());
 }
 
 // Constructs a very simple tree and synchronizes it attempting to reuse some
 // layers
 TEST_F(TreeSynchronizerTest, SyncSimpleTreeReusingLayers) {
   std::vector<int> layer_impl_destruction_list;
 
   scoped_refptr<Layer> layer_tree_root =
       MockLayer::Create(&layer_impl_destruction_list);
   layer_tree_root->AddChild(MockLayer::Create(&layer_impl_destruction_list));
   layer_tree_root->AddChild(MockLayer::Create(&layer_impl_destruction_list));
   int second_layer_impl_id = layer_tree_root->children()[1]->id();
 
   host_->SetRootLayer(layer_tree_root);
+  host_->BuildPropertyTreesForTesting();
 
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
   LayerImpl* layer_impl_tree_root =
       host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // We have to push properties to pick up the destruction list pointer.
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_->active_tree());
 
   // Add a new layer to the Layer side
   layer_tree_root->children()[0]->AddChild(
       MockLayer::Create(&layer_impl_destruction_list));
   // Remove one.
   layer_tree_root->children()[1]->RemoveFromParent();
 
   // Synchronize again. After the sync the trees should be equivalent and we
   // should have created and destroyed one LayerImpl.
+  host_->BuildPropertyTreesForTesting();
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
   layer_impl_tree_root = host_->active_tree()->root_layer_for_testing();
 
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   ASSERT_EQ(1u, layer_impl_destruction_list.size());
   EXPECT_EQ(second_layer_impl_id, layer_impl_destruction_list[0]);
 
@@ skipping 10 matching lines @@
   scoped_refptr<Layer> layer_tree_root =
       MockLayer::Create(&layer_impl_destruction_list);
   scoped_refptr<Layer> child2 = MockLayer::Create(&layer_impl_destruction_list);
   layer_tree_root->AddChild(MockLayer::Create(&layer_impl_destruction_list));
   layer_tree_root->AddChild(child2);
   int child1_id = layer_tree_root->children()[0]->id();
   int child2_id = layer_tree_root->children()[1]->id();
 
   host_->SetRootLayer(layer_tree_root);
 
+  host_->BuildPropertyTreesForTesting();
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
   LayerImpl* layer_impl_tree_root =
       host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // We have to push properties to pick up the destruction list pointer.
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_->active_tree());
 
   host_->active_tree()->ResetAllChangeTracking();
 
   // re-insert the layer and sync again.
   child2->RemoveFromParent();
   layer_tree_root->AddChild(child2);
+  host_->BuildPropertyTreesForTesting();
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
   layer_impl_tree_root = host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
+  host_->active_tree()->SetPropertyTrees(
+      layer_tree_root->layer_tree_host()->property_trees());
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_->active_tree());
 
   // Check that the impl thread properly tracked the change.
   EXPECT_FALSE(layer_impl_tree_root->LayerPropertyChanged());
   EXPECT_FALSE(
       host_->active_tree()->LayerById(child1_id)->LayerPropertyChanged());
   EXPECT_TRUE(
       host_->active_tree()->LayerById(child2_id)->LayerPropertyChanged());
   host_->active_tree()->DetachLayers();
 }
 
 TEST_F(TreeSynchronizerTest, SyncSimpleTreeAndProperties) {
   scoped_refptr<Layer> layer_tree_root = Layer::Create();
   layer_tree_root->AddChild(Layer::Create());
   layer_tree_root->AddChild(Layer::Create());
 
   host_->SetRootLayer(layer_tree_root);
 
   // Pick some random properties to set. The values are not important, we're
   // just testing that at least some properties are making it through.
   gfx::PointF root_position = gfx::PointF(2.3f, 7.4f);
   layer_tree_root->SetPosition(root_position);
 
   gfx::Size second_child_bounds = gfx::Size(25, 53);
   layer_tree_root->children()[1]->SetBounds(second_child_bounds);
   layer_tree_root->children()[1]->SavePaintProperties();
   int second_child_id = layer_tree_root->children()[1]->id();
 
+  host_->BuildPropertyTreesForTesting();
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
   LayerImpl* layer_impl_tree_root =
       host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_->active_tree());
 
@@ skipping 28 matching lines @@
   layer_a->AddChild(MockLayer::Create(&layer_impl_destruction_list));
 
   scoped_refptr<Layer> layer_b = layer_a->children()[0];
   layer_b->AddChild(MockLayer::Create(&layer_impl_destruction_list));
 
   scoped_refptr<Layer> layer_c = layer_b->children()[0];
   layer_b->AddChild(MockLayer::Create(&layer_impl_destruction_list));
   scoped_refptr<Layer> layer_d = layer_b->children()[1];
 
   host_->SetRootLayer(layer_tree_root);
+  host_->BuildPropertyTreesForTesting();
 
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
   LayerImpl* layer_impl_tree_root =
       host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // We have to push properties to pick up the destruction list pointer.
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_->active_tree());
 
   // Now restructure the tree to look like this:
   // root --- D ---+--- A
   //               |
   //               +--- C --- B
   layer_tree_root->RemoveAllChildren();
   layer_d->RemoveAllChildren();
   layer_tree_root->AddChild(layer_d);
   layer_a->RemoveAllChildren();
   layer_d->AddChild(layer_a);
   layer_c->RemoveAllChildren();
   layer_d->AddChild(layer_c);
   layer_b->RemoveAllChildren();
   layer_c->AddChild(layer_b);
 
   // After another synchronize our trees should match and we should not have
   // destroyed any LayerImpls
+  host_->BuildPropertyTreesForTesting();
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
   layer_impl_tree_root = host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   EXPECT_EQ(0u, layer_impl_destruction_list.size());
 
   host_->active_tree()->DetachLayers();
 }
 
 // Constructs a very simple tree, synchronizes it, then synchronizes to a
 // totally new tree. All layers from the old tree should be deleted.
 TEST_F(TreeSynchronizerTest, SyncSimpleTreeThenDestroy) {
   std::vector<int> layer_impl_destruction_list;
 
   scoped_refptr<Layer> old_layer_tree_root =
       MockLayer::Create(&layer_impl_destruction_list);
   old_layer_tree_root->AddChild(
       MockLayer::Create(&layer_impl_destruction_list));
   old_layer_tree_root->AddChild(
       MockLayer::Create(&layer_impl_destruction_list));
 
   host_->SetRootLayer(old_layer_tree_root);
 
   int old_tree_root_layer_id = old_layer_tree_root->id();
   int old_tree_first_child_layer_id = old_layer_tree_root->children()[0]->id();
   int old_tree_second_child_layer_id = old_layer_tree_root->children()[1]->id();
 
+  host_->BuildPropertyTreesForTesting();
   TreeSynchronizer::SynchronizeTrees(old_layer_tree_root.get(),
                                      host_->active_tree());
   LayerImpl* layer_impl_tree_root =
       host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(old_layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // We have to push properties to pick up the destruction list pointer.
   TreeSynchronizer::PushLayerProperties(old_layer_tree_root->layer_tree_host(),
                                         host_->active_tree());
 
   // Remove all children on the Layer side.
   old_layer_tree_root->RemoveAllChildren();
 
   // Synchronize again. After the sync all LayerImpls from the old tree should
   // be deleted.
   scoped_refptr<Layer> new_layer_tree_root = Layer::Create();
   host_->SetRootLayer(new_layer_tree_root);
 
+  host_->BuildPropertyTreesForTesting();
   TreeSynchronizer::SynchronizeTrees(new_layer_tree_root.get(),
                                      host_->active_tree());
   layer_impl_tree_root = host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(new_layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   ASSERT_EQ(3u, layer_impl_destruction_list.size());
 
   EXPECT_TRUE(std::find(layer_impl_destruction_list.begin(),
                         layer_impl_destruction_list.end(),
@@ skipping 251 matching lines @@
   host_->CommitAndCreatePendingTree();
   host_impl->ActivateSyncTree();
   EXPECT_EQ(
       CombinedAnimationScale(0.f, 0.f),
       host_impl->active_tree()->property_trees()->GetAnimationScales(
           transform_layer->transform_tree_index(), host_impl->active_tree()));
 }
 
 }  // namespace
 }  // namespace cc