cc : Make tree synchronization independent of layer tree hierarchy (2)

cc/layers/layer_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/layers/layer.h"
 
 #include <stddef.h>
 
 #include "base/thread_task_runner_handle.h"
 #include "cc/animation/animation_host.h"
@@ skipping 35 matching lines @@
 using ::testing::StrictMock;
 using ::testing::_;
 
 #define EXPECT_SET_NEEDS_FULL_TREE_SYNC(expect, code_to_test)               \
   do {                                                                      \
     EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times((expect)); \
     code_to_test;                                                           \
     Mock::VerifyAndClearExpectations(layer_tree_host_.get());               \
   } while (false)
 
-#define EXECUTE_AND_VERIFY_SUBTREE_CHANGED(code_to_test)   \
-  code_to_test;                                            \
-  root->layer_tree_host()->BuildPropertyTreesForTesting(); \
-  EXPECT_TRUE(root->subtree_property_changed());           \
-  EXPECT_TRUE(root->needs_push_properties());              \
-  EXPECT_TRUE(child->subtree_property_changed());          \
-  EXPECT_TRUE(child->needs_push_properties());             \
-  EXPECT_TRUE(grand_child->subtree_property_changed());    \
-  EXPECT_TRUE(grand_child->needs_push_properties());
+#define EXECUTE_AND_VERIFY_SUBTREE_CHANGED(code_to_test)                    \
+  code_to_test;                                                             \
+  root->layer_tree_host()->BuildPropertyTreesForTesting();                  \
+  EXPECT_TRUE(root->subtree_property_changed());                            \
+  EXPECT_TRUE(root->layer_tree_host()->LayerNeedsPushPropertiesForTesting(  \
+      root.get()));                                                         \
+  EXPECT_TRUE(child->subtree_property_changed());                           \
+  EXPECT_TRUE(child->layer_tree_host()->LayerNeedsPushPropertiesForTesting( \
+      child.get()));                                                        \
+  EXPECT_TRUE(grand_child->subtree_property_changed());                     \
+  EXPECT_TRUE(                                                              \
+      grand_child->layer_tree_host()->LayerNeedsPushPropertiesForTesting(   \
+          grand_child.get()));
 
-#define EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(code_to_test) \
-  code_to_test;                                                \
-  EXPECT_FALSE(root->subtree_property_changed());              \
-  EXPECT_FALSE(root->needs_push_properties());                 \
-  EXPECT_FALSE(child->subtree_property_changed());             \
-  EXPECT_FALSE(child->needs_push_properties());                \
-  EXPECT_FALSE(grand_child->subtree_property_changed());       \
-  EXPECT_FALSE(grand_child->needs_push_properties());
+#define EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(code_to_test)               \
+  code_to_test;                                                              \
+  EXPECT_FALSE(root->subtree_property_changed());                            \
+  EXPECT_FALSE(root->layer_tree_host()->LayerNeedsPushPropertiesForTesting(  \
+      root.get()));                                                          \
+  EXPECT_FALSE(child->subtree_property_changed());                           \
+  EXPECT_FALSE(child->layer_tree_host()->LayerNeedsPushPropertiesForTesting( \
+      child.get()));                                                         \
+  EXPECT_FALSE(grand_child->subtree_property_changed());                     \
+  EXPECT_FALSE(                                                              \
+      grand_child->layer_tree_host()->LayerNeedsPushPropertiesForTesting(    \
+          grand_child.get()));
 
 namespace cc {
 
 // This class is a friend of Layer, and is used as a wrapper for all the tests
 // related to proto serialization. This is done so that it is unnecessary to
 // add FRIEND_TEST_ALL_PREFIXES in //cc/layers/layer.h for all the tests.
 // It is in the cc namespace so that it can be a friend of Layer.
 // The tests still have helpful names, and a test with the name FooBar would
 // have a wrapper method in this class called RunFooBarTest.
 class LayerSerializationTest : public testing::Test {
@@ skipping 19 matching lines @@
     src->SetLayerTreeHost(layer_tree_host_.get());
 
     // The following member is reset during serialization, so store the original
     // values.
     gfx::Rect update_rect = src->update_rect_;
 
     // Serialize |src| to protobuf and read the first entry in the
     // LayerUpdate. There are no descendants, so the serialization
     // of |src| is the only entry.
     proto::LayerUpdate layer_update;
-    EXPECT_FALSE(src->ToLayerPropertiesProto(&layer_update));
+    src->ToLayerPropertiesProto(&layer_update);
     ASSERT_EQ(1, layer_update.layers_size());
     proto::LayerProperties props = layer_update.layers(0);
 
     // The |dest| layer needs to be able to lookup the scroll and clip parents.
     if (src->scroll_parent_)
       layer_tree_host_->RegisterLayer(src->scroll_parent_);
     if (src->scroll_children_) {
       for (auto* child : *(src->scroll_children_))
         layer_tree_host_->RegisterLayer(child);
     }
@@ skipping 1207 matching lines @@
   EXPECT_EQ(child2, parent->children()[1]);
 
   EXPECT_SET_NEEDS_COMMIT(2, child1->SetScrollParent(child2.get()));
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, child2->RemoveFromParent());
 
   child1->reset_needs_push_properties_for_testing();
 
   EXPECT_SET_NEEDS_COMMIT(1, child2 = nullptr);
 
-  EXPECT_TRUE(child1->needs_push_properties());
+  EXPECT_TRUE(
+      layer_tree_host_->LayerNeedsPushPropertiesForTesting(child1.get()));
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(nullptr));
 }
 
 TEST_F(LayerTest, DeleteRemovedScrollChild) {
   scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
   scoped_refptr<Layer> child1 = Layer::Create(layer_settings_);
   scoped_refptr<Layer> child2 = Layer::Create(layer_settings_);
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(parent));
 
   ASSERT_EQ(0U, parent->children().size());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child1, 0));
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child2, 1));
 
   ASSERT_EQ(2U, parent->children().size());
   EXPECT_EQ(child1, parent->children()[0]);
   EXPECT_EQ(child2, parent->children()[1]);
 
   EXPECT_SET_NEEDS_COMMIT(2, child1->SetScrollParent(child2.get()));
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, child1->RemoveFromParent());
 
   child2->reset_needs_push_properties_for_testing();
 
   EXPECT_SET_NEEDS_COMMIT(1, child1 = nullptr);
 
-  EXPECT_TRUE(child2->needs_push_properties());
+  EXPECT_TRUE(
+      layer_tree_host_->LayerNeedsPushPropertiesForTesting(child2.get()));
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(nullptr));
 }
 
 TEST_F(LayerTest, ReplaceChildWithSameChild) {
   CreateSimpleTestTree();
 
   // SetNeedsFullTreeSync / SetNeedsCommit should not be called because its the
   // same child.
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
@@ skipping 1121 matching lines @@
 TEST_F(LayerSerializationTest,
        NonDestructiveDeserializationMoveChildEarlierTest) {
   RunNonDestructiveDeserializationMoveChildEarlierTest();
 }
 
 TEST_F(LayerSerializationTest,
        NonDestructiveDeserializationMoveChildLaterTest) {
   RunNonDestructiveDeserializationMoveChildLaterTest();
 }
 
-TEST_F(LayerTest, SimplePropertiesSerialization) {

[jaydasika, 2016/03/17 23:38:37]

Deleted this as what gets serialized is no longer decided by
ToLayerPropertiesProto

-  /* Testing serialization of properties for a tree that looks like this:
-          root+
-          /  \
-         a*   b*+[mask:*,replica]
-        /      \
-       c        d*
-     Layers marked with * have changed properties.
-     Layers marked with + have descendants with changed properties.
-     Layer b also has a mask layer and a replica layer.
-  */
-  scoped_refptr<Layer> layer_src_root = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_a = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_b = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_b_mask = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_b_replica = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_c = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_d = Layer::Create(LayerSettings());
-  layer_src_root->AddChild(layer_src_a);
-  layer_src_root->AddChild(layer_src_b);
-  layer_src_a->AddChild(layer_src_c);
-  layer_src_b->AddChild(layer_src_d);
-  layer_src_b->SetMaskLayer(layer_src_b_mask.get());
-  layer_src_b->SetReplicaLayer(layer_src_b_replica.get());
-
-  proto::LayerUpdate layer_update_root;
-  // Only layers with descendants that require pushing properties will
-  // return true from ToLayerPropertiesProto and AddChild will change the
-  // stacking order of child which will make it push properties.
-  EXPECT_TRUE(layer_src_root->ToLayerPropertiesProto(&layer_update_root));
-  proto::LayerUpdate layer_update_a;
-  EXPECT_TRUE(layer_src_a->ToLayerPropertiesProto(&layer_update_a));
-  proto::LayerUpdate layer_update_b;
-  EXPECT_TRUE(layer_src_b->ToLayerPropertiesProto(&layer_update_b));
-  proto::LayerUpdate layer_update_c;
-  EXPECT_FALSE(layer_src_c->ToLayerPropertiesProto(&layer_update_c));
-  proto::LayerUpdate layer_update_d;
-  EXPECT_FALSE(layer_src_d->ToLayerPropertiesProto(&layer_update_d));
-  layer_update_root.Clear();
-  layer_update_a.Clear();
-  layer_update_b.Clear();
-  layer_update_c.Clear();
-  layer_update_d.Clear();
-
-  layer_src_a->SetNeedsPushProperties();
-  layer_src_b->SetNeedsPushProperties();
-  layer_src_b_mask->SetNeedsPushProperties();
-  layer_src_d->SetNeedsPushProperties();
-
-  // Only layers with descendants that require pushing properties will
-  // return true from ToLayerPropertiesProto.
-  EXPECT_TRUE(layer_src_root->ToLayerPropertiesProto(&layer_update_root));
-  EXPECT_FALSE(layer_src_a->ToLayerPropertiesProto(&layer_update_a));
-  EXPECT_TRUE(layer_src_b->ToLayerPropertiesProto(&layer_update_b));
-  proto::LayerUpdate layer_update_b_mask;
-  EXPECT_FALSE(layer_src_b_mask->ToLayerPropertiesProto(&layer_update_b_mask));
-  proto::LayerUpdate layer_update_b_replica;
-  EXPECT_FALSE(
-      layer_src_b_replica->ToLayerPropertiesProto(&layer_update_b_replica));
-  EXPECT_FALSE(layer_src_c->ToLayerPropertiesProto(&layer_update_c));
-  EXPECT_FALSE(layer_src_d->ToLayerPropertiesProto(&layer_update_d));
-
-  // All flags for pushing properties should have been cleared.
-  EXPECT_FALSE(layer_src_root->needs_push_properties());
-  EXPECT_FALSE(layer_src_root->descendant_needs_push_properties());
-  EXPECT_FALSE(layer_src_a->needs_push_properties());
-  EXPECT_FALSE(layer_src_a->descendant_needs_push_properties());
-  EXPECT_FALSE(layer_src_b->needs_push_properties());
-  EXPECT_FALSE(layer_src_b->descendant_needs_push_properties());
-  EXPECT_FALSE(layer_src_b_mask->needs_push_properties());
-  EXPECT_FALSE(layer_src_b_mask->descendant_needs_push_properties());
-  EXPECT_FALSE(layer_src_b_replica->needs_push_properties());
-  EXPECT_FALSE(layer_src_b_replica->descendant_needs_push_properties());
-  EXPECT_FALSE(layer_src_c->needs_push_properties());
-  EXPECT_FALSE(layer_src_c->descendant_needs_push_properties());
-  EXPECT_FALSE(layer_src_d->needs_push_properties());
-  EXPECT_FALSE(layer_src_d->descendant_needs_push_properties());
-
-  // Only 5 of the layers should have been serialized.
-  ASSERT_EQ(1, layer_update_root.layers_size());
-  EXPECT_EQ(layer_src_root->id(), layer_update_root.layers(0).id());
-  proto::LayerProperties dest_root = layer_update_root.layers(0);
-  ASSERT_EQ(1, layer_update_a.layers_size());
-  EXPECT_EQ(layer_src_a->id(), layer_update_a.layers(0).id());
-  proto::LayerProperties dest_a = layer_update_a.layers(0);
-  ASSERT_EQ(1, layer_update_b.layers_size());
-  EXPECT_EQ(layer_src_b->id(), layer_update_b.layers(0).id());
-  proto::LayerProperties dest_b = layer_update_b.layers(0);
-  ASSERT_EQ(1, layer_update_b_mask.layers_size());
-  EXPECT_EQ(layer_src_b_mask->id(), layer_update_b_mask.layers(0).id());
-  proto::LayerProperties dest_b_mask = layer_update_b_mask.layers(0);
-  EXPECT_EQ(0, layer_update_b_replica.layers_size());
-  EXPECT_EQ(0, layer_update_c.layers_size());
-  ASSERT_EQ(1, layer_update_d.layers_size());
-  EXPECT_EQ(layer_src_d->id(), layer_update_d.layers(0).id());
-  proto::LayerProperties dest_d = layer_update_d.layers(0);
-
-  // Ensure the properties and dependants metadata is correctly serialized.
-  EXPECT_FALSE(dest_root.needs_push_properties());
-  EXPECT_EQ(2, dest_root.num_dependents_need_push_properties());
-  EXPECT_FALSE(dest_root.has_base());
-
-  EXPECT_TRUE(dest_a.needs_push_properties());
-  EXPECT_EQ(0, dest_a.num_dependents_need_push_properties());
-  EXPECT_TRUE(dest_a.has_base());
-
-  EXPECT_TRUE(dest_b.needs_push_properties());
-  EXPECT_EQ(2, dest_b.num_dependents_need_push_properties());
-  EXPECT_TRUE(dest_b.has_base());
-
-  EXPECT_TRUE(dest_d.needs_push_properties());
-  EXPECT_EQ(0, dest_d.num_dependents_need_push_properties());
-  EXPECT_TRUE(dest_d.has_base());
-
-  EXPECT_TRUE(dest_b_mask.needs_push_properties());
-  EXPECT_EQ(0, dest_b_mask.num_dependents_need_push_properties());
-  EXPECT_TRUE(dest_b_mask.has_base());
-}
-
-TEST_F(LayerSerializationTest, SimplePropertiesDeserialization) {
-  scoped_refptr<Layer> layer = Layer::Create(LayerSettings());
-  layer->SetLayerTreeHost(layer_tree_host_.get());
-  proto::LayerProperties properties;
-  properties.set_id(layer->id());
-
-  properties.set_needs_push_properties(true);
-  properties.set_num_dependents_need_push_properties(2);
-  properties.mutable_base();
-  layer->FromLayerPropertiesProto(properties);
-  EXPECT_TRUE(layer->needs_push_properties());
-  EXPECT_TRUE(layer->descendant_needs_push_properties());
-
-  properties.set_needs_push_properties(false);
-  properties.mutable_base()->Clear();
-  layer->FromLayerPropertiesProto(properties);
-  EXPECT_FALSE(layer->needs_push_properties());
-  EXPECT_TRUE(layer->descendant_needs_push_properties());
-
-  properties.set_num_dependents_need_push_properties(0);
-  layer->FromLayerPropertiesProto(properties);
-  EXPECT_FALSE(layer->needs_push_properties());
-  EXPECT_FALSE(layer->descendant_needs_push_properties());
-
-  properties.set_needs_push_properties(true);
-  properties.mutable_base();
-  layer->FromLayerPropertiesProto(properties);
-  EXPECT_TRUE(layer->needs_push_properties());
-  EXPECT_FALSE(layer->descendant_needs_push_properties());
-
-  layer->SetLayerTreeHost(nullptr);
-}
-
 TEST_F(LayerSerializationTest, NoMembersChanged) {
   RunNoMembersChangedTest();
 }
 
 TEST_F(LayerSerializationTest, ArbitraryMembersChanged) {
   RunArbitraryMembersChangedTest();
 }
 
 TEST_F(LayerSerializationTest, AllMembersChanged) {
   RunAllMembersChangedTest();
@@ skipping 20 matching lines @@
   EXPECT_EQ(MutableProperty::kNone, impl_layer->mutable_properties());
 
   test_layer->PushPropertiesTo(impl_layer.get());
 
   EXPECT_EQ(2lu, impl_layer->element_id());
   EXPECT_EQ(MutableProperty::kTransform, impl_layer->mutable_properties());
 }
 
 }  // namespace
 }  // namespace cc