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

cc/trees/layer_tree_host_impl_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/layer_tree_host_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 10237 matching lines @@
   pending_tree->BuildLayerListForTesting();
   ASSERT_EQ(raw_pending_layer, pending_tree->root_layer());
 
   EXPECT_EQ(0u, raw_pending_layer->did_become_active_call_count());
   pending_tree->DidBecomeActive();
   EXPECT_EQ(1u, raw_pending_layer->did_become_active_call_count());
 
   std::unique_ptr<FakePictureLayerImpl> mask_layer =
       FakePictureLayerImpl::Create(pending_tree, 11);
   FakePictureLayerImpl* raw_mask_layer = mask_layer.get();
-  raw_pending_layer->SetMaskLayer(std::move(mask_layer));
-  ASSERT_EQ(raw_mask_layer, raw_pending_layer->mask_layer());
+  raw_pending_layer->test_properties()->SetMaskLayer(std::move(mask_layer));
+  ASSERT_EQ(raw_mask_layer, raw_pending_layer->test_properties()->mask_layer);
+  pending_tree->BuildLayerListAndPropertyTreesForTesting();
 
   EXPECT_EQ(1u, raw_pending_layer->did_become_active_call_count());
   EXPECT_EQ(0u, raw_mask_layer->did_become_active_call_count());
   pending_tree->DidBecomeActive();
   EXPECT_EQ(2u, raw_pending_layer->did_become_active_call_count());
   EXPECT_EQ(1u, raw_mask_layer->did_become_active_call_count());
 
   std::unique_ptr<FakePictureLayerImpl> replica_layer =
       FakePictureLayerImpl::Create(pending_tree, 12);
   std::unique_ptr<FakePictureLayerImpl> replica_mask_layer =
       FakePictureLayerImpl::Create(pending_tree, 13);
   FakePictureLayerImpl* raw_replica_mask_layer = replica_mask_layer.get();
-  replica_layer->SetMaskLayer(std::move(replica_mask_layer));
-  raw_pending_layer->SetReplicaLayer(std::move(replica_layer));
-  ASSERT_EQ(raw_replica_mask_layer,
-            raw_pending_layer->replica_layer()->mask_layer());
+  replica_layer->test_properties()->SetMaskLayer(std::move(replica_mask_layer));
+  raw_pending_layer->test_properties()->SetReplicaLayer(
+      std::move(replica_layer));
+  ASSERT_EQ(raw_replica_mask_layer, raw_pending_layer->test_properties()
+                                        ->replica_layer->test_properties()
+                                        ->mask_layer);
+  pending_tree->property_trees()->needs_rebuild = true;
+  pending_tree->BuildLayerListAndPropertyTreesForTesting();
 
   EXPECT_EQ(2u, raw_pending_layer->did_become_active_call_count());
   EXPECT_EQ(1u, raw_mask_layer->did_become_active_call_count());
   EXPECT_EQ(0u, raw_replica_mask_layer->did_become_active_call_count());
   pending_tree->DidBecomeActive();
   EXPECT_EQ(3u, raw_pending_layer->did_become_active_call_count());
   EXPECT_EQ(2u, raw_mask_layer->did_become_active_call_count());
   EXPECT_EQ(1u, raw_replica_mask_layer->did_become_active_call_count());
 }
 
@@ skipping 543 matching lines @@
 
   // Re-initialize with a software output surface.
   output_surface_ = FakeOutputSurface::CreateSoftware(
       base::WrapUnique(new SoftwareOutputDevice));
   host_impl_->InitializeRenderer(output_surface_.get());
   EXPECT_FALSE(host_impl_->use_gpu_rasterization());
 }
 
 }  // namespace
 }  // namespace cc