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

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 @@
                 clip_children_impl->end());
   }
 
   for (size_t i = 0; i < layer_children.size(); ++i) {
     SCOPED_TRACE(base::StringPrintf("child layer %" PRIuS, i).c_str());
     ExpectTreesAreIdentical(layer_children[i].get(),
                             layer_impl_children[i].get(), tree_impl);
   }
 }
 
+void PushLayerPropertiesTo(LayerTreeHost* tree_host, LayerTreeImpl* tree_impl) {

[ajuma, 2016/03/21 13:41:20]

Is this still needed now that we have a method in TreeSyncrhonizer with the same
logic?

[jaydasika, 2016/03/21 17:32:03]

Removed.

+  std::unordered_set<Layer*> layers_that_should_push_properties =
+      tree_host->LayersThatShouldPushProperties();
+  for (auto layer : layers_that_should_push_properties) {
+    LayerImpl* impl_layer = tree_impl->LayerById(layer->id());
+    DCHECK(impl_layer) << layer->id();
+    layer->PushPropertiesTo(impl_layer);
+  }
+}
+
 class TreeSynchronizerTest : public testing::Test {
  public:
   TreeSynchronizerTest()
       : client_(FakeLayerTreeHostClient::DIRECT_3D),
         host_(FakeLayerTreeHost::Create(&client_, &task_graph_runner_)) {}
 
  protected:
   FakeLayerTreeHostClient client_;
   TestTaskGraphRunner task_graph_runner_;
   scoped_ptr<FakeLayerTreeHost> host_;
@@ skipping 58 matching lines @@
   host_->SetRootLayer(layer_tree_root);
 
   scoped_ptr<LayerImpl> layer_impl_tree_root =
       TreeSynchronizer::SynchronizeTrees(
           layer_tree_root.get(), nullptr, host_->active_tree());
   ExpectTreesAreIdentical(layer_tree_root.get(),
                           layer_impl_tree_root.get(),
                           host_->active_tree());
 
   // We have to push properties to pick up the destruction list pointer.
-  TreeSynchronizer::PushProperties(layer_tree_root.get(),
-                                   layer_impl_tree_root.get());
+  PushLayerPropertiesTo(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();
   int second_layer_impl_id = layer_impl_tree_root->children()[1]->id();
 
   // Synchronize again. After the sync the trees should be equivalent and we
   // should have created and destroyed one LayerImpl.
@@ skipping 23 matching lines @@
 
   host_->SetRootLayer(layer_tree_root);
 
   host_->active_tree()->SetRootLayer(TreeSynchronizer::SynchronizeTrees(
       layer_tree_root.get(), nullptr, 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());
 
   // We have to push properties to pick up the destruction list pointer.
-  TreeSynchronizer::PushProperties(layer_tree_root.get(), layer_impl_tree_root);
+  PushLayerPropertiesTo(layer_tree_root->layer_tree_host(),
+                        host_->active_tree());
 
   host_->active_tree()->ResetAllChangeTracking(
       PropertyTrees::ResetFlags::ALL_TREES);
 
   // re-insert the layer and sync again.
   child2->RemoveFromParent();
   layer_tree_root->AddChild(child2);
   host_->active_tree()->SetRootLayer(TreeSynchronizer::SynchronizeTrees(
       layer_tree_root.get(), host_->active_tree()->DetachLayerTree(),
       host_->active_tree()));
   layer_impl_tree_root = host_->active_tree()->root_layer();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
-  TreeSynchronizer::PushProperties(layer_tree_root.get(), layer_impl_tree_root);
+  PushLayerPropertiesTo(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(layer_impl_tree_root->children()[0]->LayerPropertyChanged());
   EXPECT_TRUE(layer_impl_tree_root->children()[1]->LayerPropertyChanged());
   host_->active_tree()->DetachLayerTree();
 }
 
 TEST_F(TreeSynchronizerTest, SyncSimpleTreeAndProperties) {
   scoped_refptr<Layer> layer_tree_root = Layer::Create();
@@ skipping 14 matching lines @@
   layer_tree_root->children()[1]->SetBounds(second_child_bounds);
   layer_tree_root->children()[1]->SavePaintProperties();
 
   scoped_ptr<LayerImpl> layer_impl_tree_root =
       TreeSynchronizer::SynchronizeTrees(
           layer_tree_root.get(), nullptr, host_->active_tree());
   ExpectTreesAreIdentical(layer_tree_root.get(),
                           layer_impl_tree_root.get(),
                           host_->active_tree());
 
-  TreeSynchronizer::PushProperties(layer_tree_root.get(),
-                                   layer_impl_tree_root.get());
+  PushLayerPropertiesTo(layer_tree_root->layer_tree_host(),
+                        host_->active_tree());
 
   // Check that the property values we set on the Layer tree are reflected in
   // the LayerImpl tree.
   gfx::PointF root_layer_impl_position = layer_impl_tree_root->position();
   EXPECT_EQ(root_position.x(), root_layer_impl_position.x());
   EXPECT_EQ(root_position.y(), root_layer_impl_position.y());
 
   EXPECT_EQ(first_child_opacity,
             layer_impl_tree_root->children()[0]->opacity());
 
@@ skipping 29 matching lines @@
   host_->SetRootLayer(layer_tree_root);
 
   scoped_ptr<LayerImpl> layer_impl_tree_root =
       TreeSynchronizer::SynchronizeTrees(
           layer_tree_root.get(), nullptr, host_->active_tree());
   ExpectTreesAreIdentical(layer_tree_root.get(),
                           layer_impl_tree_root.get(),
                           host_->active_tree());
 
   // We have to push properties to pick up the destruction list pointer.
-  TreeSynchronizer::PushProperties(layer_tree_root.get(),
-                                   layer_impl_tree_root.get());
+  PushLayerPropertiesTo(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);
@@ skipping 33 matching lines @@
   int old_tree_second_child_layer_id = old_layer_tree_root->children()[1]->id();
 
   scoped_ptr<LayerImpl> layer_impl_tree_root =
       TreeSynchronizer::SynchronizeTrees(
           old_layer_tree_root.get(), nullptr, host_->active_tree());
   ExpectTreesAreIdentical(old_layer_tree_root.get(),
                           layer_impl_tree_root.get(),
                           host_->active_tree());
 
   // We have to push properties to pick up the destruction list pointer.
-  TreeSynchronizer::PushProperties(old_layer_tree_root.get(),
-                                   layer_impl_tree_root.get());
+  PushLayerPropertiesTo(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);
   layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
       new_layer_tree_root.get(), std::move(layer_impl_tree_root),
@@ skipping 96 matching lines @@
 
   host_->SetRootLayer(layer_tree_root);
 
   // First child is the second and third child's scroll parent.
   layer_tree_root->children()[1]->SetScrollParent(scroll_parent.get());
   layer_tree_root->children()[2]->SetScrollParent(scroll_parent.get());
 
   scoped_ptr<LayerImpl> layer_impl_tree_root =
       TreeSynchronizer::SynchronizeTrees(
           layer_tree_root.get(), nullptr, host_impl->active_tree());
-  TreeSynchronizer::PushProperties(layer_tree_root.get(),
-                                   layer_impl_tree_root.get());
+  PushLayerPropertiesTo(layer_tree_root->layer_tree_host(),
+                        host_impl->active_tree());
   {
     SCOPED_TRACE("case one");
     ExpectTreesAreIdentical(layer_tree_root.get(),
                             layer_impl_tree_root.get(),
                             host_impl->active_tree());
   }
 
   // Remove the first scroll child.
   layer_tree_root->children()[1]->RemoveFromParent();
   layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
       layer_tree_root.get(), std::move(layer_impl_tree_root),
       host_impl->active_tree());
-  TreeSynchronizer::PushProperties(layer_tree_root.get(),
-                                   layer_impl_tree_root.get());
+  PushLayerPropertiesTo(layer_tree_root->layer_tree_host(),
+                        host_impl->active_tree());
   {
     SCOPED_TRACE("case two");
     ExpectTreesAreIdentical(layer_tree_root.get(),
                             layer_impl_tree_root.get(),
                             host_impl->active_tree());
   }
 
   // Add an additional scroll layer.
   scoped_refptr<Layer> additional_scroll_child = Layer::Create();
   layer_tree_root->AddChild(additional_scroll_child);
   additional_scroll_child->SetScrollParent(scroll_parent.get());
   layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
       layer_tree_root.get(), std::move(layer_impl_tree_root),
       host_impl->active_tree());
-  TreeSynchronizer::PushProperties(layer_tree_root.get(),
-                                   layer_impl_tree_root.get());
+  PushLayerPropertiesTo(layer_tree_root->layer_tree_host(),
+                        host_impl->active_tree());
   {
     SCOPED_TRACE("case three");
     ExpectTreesAreIdentical(layer_tree_root.get(),
                             layer_impl_tree_root.get(),
                             host_impl->active_tree());
   }
 }
 
 TEST_F(TreeSynchronizerTest, SynchronizeClipParent) {
   LayerTreeSettings settings;
@@ skipping 17 matching lines @@
 
   host_->SetRootLayer(layer_tree_root);
 
   // First child is the second and third child's scroll parent.
   clip_child1->SetClipParent(clip_parent.get());
   clip_child2->SetClipParent(clip_parent.get());
 
   scoped_ptr<LayerImpl> layer_impl_tree_root =
       TreeSynchronizer::SynchronizeTrees(
           layer_tree_root.get(), nullptr, host_impl->active_tree());
-  TreeSynchronizer::PushProperties(layer_tree_root.get(),
-                                   layer_impl_tree_root.get());
+  PushLayerPropertiesTo(layer_tree_root->layer_tree_host(),
+                        host_impl->active_tree());
   ExpectTreesAreIdentical(layer_tree_root.get(),
                           layer_impl_tree_root.get(),
                           host_impl->active_tree());
 
   // Remove the first clip child.
   clip_child1->RemoveFromParent();
   clip_child1 = NULL;
 
   layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
       layer_tree_root.get(), std::move(layer_impl_tree_root),
       host_impl->active_tree());
-  TreeSynchronizer::PushProperties(layer_tree_root.get(),
-                                   layer_impl_tree_root.get());
+  PushLayerPropertiesTo(layer_tree_root->layer_tree_host(),
+                        host_impl->active_tree());
   ExpectTreesAreIdentical(layer_tree_root.get(),
                           layer_impl_tree_root.get(),
                           host_impl->active_tree());
 
   // Add an additional clip child.
   scoped_refptr<Layer> additional_clip_child = Layer::Create();
   intervening->AddChild(additional_clip_child);
   additional_clip_child->SetClipParent(clip_parent.get());
   layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
       layer_tree_root.get(), std::move(layer_impl_tree_root),
       host_impl->active_tree());
-  TreeSynchronizer::PushProperties(layer_tree_root.get(),
-                                   layer_impl_tree_root.get());
+  PushLayerPropertiesTo(layer_tree_root->layer_tree_host(),
+                        host_impl->active_tree());
   ExpectTreesAreIdentical(layer_tree_root.get(),
                           layer_impl_tree_root.get(),
                           host_impl->active_tree());
 
   // Remove the nearest clipping ancestor.
   clip_parent->RemoveFromParent();
   clip_parent = NULL;
   layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
       layer_tree_root.get(), std::move(layer_impl_tree_root),
       host_impl->active_tree());
-  TreeSynchronizer::PushProperties(layer_tree_root.get(),
-                                   layer_impl_tree_root.get());
+  PushLayerPropertiesTo(layer_tree_root->layer_tree_host(),
+                        host_impl->active_tree());
   ExpectTreesAreIdentical(layer_tree_root.get(),
                           layer_impl_tree_root.get(),
                           host_impl->active_tree());
 
   // The clip children should have been unhooked.
   EXPECT_EQ(2u, intervening->children().size());
   EXPECT_FALSE(clip_child2->clip_parent());
   EXPECT_FALSE(additional_clip_child->clip_parent());
 }
 
@@ skipping 134 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