cc: Add mask and replica layer ids to the effect tree

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 78 matching lines @@
     LayerImpl* layer_impl = *layer_impl_iter;
     ASSERT_TRUE(layer);
     ASSERT_TRUE(layer_impl);
 
     EXPECT_EQ(layer->id(), layer_impl->id());
     EXPECT_EQ(layer_impl->layer_tree_impl(), tree_impl);
 
     EXPECT_EQ(layer->non_fast_scrollable_region(),
               layer_impl->non_fast_scrollable_region());
 
-    ASSERT_EQ(!!layer->mask_layer(), !!layer_impl->mask_layer());
+    const EffectTree& effect_tree = tree_impl->property_trees()->effect_tree;
     if (layer->mask_layer()) {
       SCOPED_TRACE("mask_layer");
-      EXPECT_EQ(layer->mask_layer()->id(), layer_impl->mask_layer()->id());
+      int mask_layer_id = layer->mask_layer()->id();
+      EXPECT_TRUE(tree_impl->LayerById(mask_layer_id));
+      EXPECT_EQ(mask_layer_id,
+                effect_tree.Node(layer_impl->effect_tree_index())
+                    ->data.mask_layer_id);
     }
 
-    ASSERT_EQ(!!layer->replica_layer(), !!layer_impl->replica_layer());
     if (layer->replica_layer()) {
       SCOPED_TRACE("replica_layer");
-      EXPECT_EQ(layer->replica_layer()->id(),
-                layer_impl->replica_layer()->id());
-      ASSERT_EQ(!!layer->replica_layer()->mask_layer(),
-                !!layer_impl->replica_layer()->mask_layer());
+      int replica_layer_id = layer->replica_layer()->id();
+      EXPECT_TRUE(tree_impl->LayerById(layer->replica_layer()->id()));
+      EXPECT_EQ(replica_layer_id,
+                effect_tree.Node(layer_impl->effect_tree_index())
+                    ->data.replica_layer_id);
       if (layer->replica_layer()->mask_layer()) {
-        SCOPED_TRACE("mask_layer");
-        EXPECT_EQ(layer->replica_layer()->mask_layer()->id(),
-                  layer_impl->replica_layer()->mask_layer()->id());
+        SCOPED_TRACE("replica_mask_layer");
+        int replica_mask_layer_id = layer->replica_layer()->mask_layer()->id();
+        EXPECT_TRUE(tree_impl->LayerById(replica_mask_layer_id));
+        EXPECT_EQ(replica_mask_layer_id,
+                  effect_tree.Node(layer_impl->effect_tree_index())
+                      ->data.replica_mask_layer_id);
       }
     }
 
     const Layer* layer_scroll_parent = layer->scroll_parent();
 
     if (layer_scroll_parent) {
       ASSERT_TRUE(layer_scroll_parent->scroll_children()->find(layer) !=
                   layer_scroll_parent->scroll_children()->end());
     }
 
@@ skipping 332 matching lines @@
   layer_tree_root->children()[1]->SetReplicaLayer(replica_layer.get());
 
   // Third child gets a replica layer with a mask layer.
   scoped_refptr<Layer> replica_layer_with_mask = Layer::Create();
   scoped_refptr<Layer> replica_mask_layer = Layer::Create();
   replica_layer_with_mask->SetMaskLayer(replica_mask_layer.get());
   layer_tree_root->children()[2]->SetReplicaLayer(
       replica_layer_with_mask.get());
 
   host_->SetRootLayer(layer_tree_root);
+  host_->BuildPropertyTreesForTesting();
+  host_->CommitAndCreateLayerImplTree();
 
-  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
-                                     host_->active_tree());
   LayerImpl* layer_impl_tree_root = host_->active_tree()->root_layer();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // Remove the mask layer.
   layer_tree_root->children()[0]->SetMaskLayer(NULL);
-  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
-                                     host_->active_tree());
+  host_->BuildPropertyTreesForTesting();
+  host_->CommitAndCreateLayerImplTree();
+
   layer_impl_tree_root = host_->active_tree()->root_layer();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // Remove the replica layer.
   layer_tree_root->children()[1]->SetReplicaLayer(NULL);
-  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
-                                     host_->active_tree());
+  host_->BuildPropertyTreesForTesting();
+  host_->CommitAndCreateLayerImplTree();
+
   layer_impl_tree_root = host_->active_tree()->root_layer();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // Remove the replica mask.
   replica_layer_with_mask->SetMaskLayer(NULL);
-  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
-                                     host_->active_tree());
+  host_->BuildPropertyTreesForTesting();
+  host_->CommitAndCreateLayerImplTree();
+
   layer_impl_tree_root = host_->active_tree()->root_layer();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   host_->active_tree()->DetachLayers();
 }
 
 TEST_F(TreeSynchronizerTest, SynchronizeCurrentlyScrollingNode) {
   LayerTreeSettings settings;
   FakeLayerTreeHostImplClient client;
@@ skipping 131 matching lines @@
   scroll_offset_map[scroll_layer->id()]->PullDeltaForMainThread();
   scroll_offset_map[scroll_layer->id()]->SetCurrent(gfx::ScrollOffset(40, 50));
   scroll_offset_map[scroll_layer->id()]->PushFromMainThread(
       gfx::ScrollOffset(100, 100));
   scroll_offset_map[scroll_layer->id()]->PushPendingToActive();
   EXPECT_TRUE(is_equal(scroll_offset_map, scroll_tree.scroll_offset_map()));
 }
 
 }  // namespace
 }  // namespace cc