cc: Move tracking of layer_property_changed to main thread (3)

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 84 matching lines @@
     layer_tree_host_ = nullptr;
   }
 
   // Serializes |src| to proto and back again to a Layer, then verifies that
   // the two Layers are equal for serialization purposes.
   void VerifyBaseLayerPropertiesSerializationAndDeserialization(Layer* src) {
     // This is required to ensure that properties are serialized.
     src->SetNeedsPushProperties();
     src->SetLayerTreeHost(layer_tree_host_.get());
 
-    // The following two members are reset during serialization, so
-    // store the original values.
-    bool stacking_order_changed = src->stacking_order_changed_;
+    // 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));
     ASSERT_EQ(1, layer_update.layers_size());
     proto::LayerProperties props = layer_update.layers(0);
 
@@ skipping 60 matching lines @@
     EXPECT_EQ(src->num_descendants_that_draw_content_,
               dest->num_descendants_that_draw_content_);
     EXPECT_EQ(src->scroll_clip_layer_id_, dest->scroll_clip_layer_id_);
     EXPECT_EQ(src->user_scrollable_horizontal_,
               dest->user_scrollable_horizontal_);
     EXPECT_EQ(src->user_scrollable_vertical_, dest->user_scrollable_vertical_);
     EXPECT_EQ(src->scroll_offset_, dest->scroll_offset_);
     EXPECT_EQ(src->scroll_compensation_adjustment_,
               dest->scroll_compensation_adjustment_);
     EXPECT_EQ(update_rect, dest->update_rect_);
-    EXPECT_EQ(stacking_order_changed, dest->stacking_order_changed_);
 
     if (src->scroll_parent_) {
       ASSERT_TRUE(dest->scroll_parent_);
       EXPECT_EQ(src->scroll_parent_->id(), dest->scroll_parent_->id());
     } else {
       EXPECT_FALSE(dest->scroll_parent_);
     }
     if (src->scroll_children_) {
       ASSERT_TRUE(dest->scroll_children_);
       EXPECT_EQ(*(src->scroll_children_), *(dest->scroll_children_));
     } else {
       EXPECT_FALSE(dest->scroll_children_);
     }
 
     if (src->clip_parent_) {
       ASSERT_TRUE(dest->clip_parent_);
       EXPECT_EQ(src->clip_parent_->id(), dest->clip_parent_->id());
     } else {
       ASSERT_FALSE(dest->clip_parent_);
     }
     if (src->clip_children_) {
       ASSERT_TRUE(dest->clip_children_);
       EXPECT_EQ(*(src->clip_children_), *(dest->clip_children_));
     } else {
       EXPECT_FALSE(dest->clip_children_);
     }
 
-    // The following two members should have been reset during serialization.
-    EXPECT_FALSE(src->stacking_order_changed_);
+    // The following member should have been reset during serialization.
     EXPECT_EQ(gfx::Rect(), src->update_rect_);
 
     // Before deleting |dest|, the LayerTreeHost must be unset.
     dest->SetLayerTreeHost(nullptr);
 
     // Cleanup scroll tree.
     if (src->scroll_parent_)
       layer_tree_host_->UnregisterLayer(src->scroll_parent_);
     src->scroll_parent_ = nullptr;
     dest->scroll_parent_ = nullptr;
@@ skipping 58 matching lines @@
     layer->transform_ = transform;
     layer->transform_is_invertible_ = true;
     layer->sorting_context_id_ = 0;
     layer->num_descendants_that_draw_content_ = 5;
     layer->scroll_clip_layer_id_ = Layer::INVALID_ID;
     layer->user_scrollable_horizontal_ = false;
     layer->user_scrollable_vertical_ = true;
     layer->scroll_offset_ = gfx::ScrollOffset(3, 14);
     layer->scroll_compensation_adjustment_ = gfx::Vector2dF(6.28f, 3.14f);
     layer->update_rect_ = gfx::Rect(14, 15);
-    layer->stacking_order_changed_ = true;
 
     VerifyBaseLayerPropertiesSerializationAndDeserialization(layer.get());
   }
 
   void RunAllMembersChangedTest() {
     scoped_refptr<Layer> layer = Layer::Create(LayerSettings());
     layer->transform_origin_ = gfx::Point3F(3.0f, 1.0f, 4.0f);
     layer->background_color_ = SK_ColorRED;
     layer->bounds_ = gfx::Size(3, 14);
     layer->transform_tree_index_ = 39;
@@ skipping 30 matching lines @@
     layer->transform_ = transform;
     layer->transform_is_invertible_ = !layer->transform_is_invertible_;
     layer->sorting_context_id_ = 42;
     layer->num_descendants_that_draw_content_ = 5;
     layer->scroll_clip_layer_id_ = 17;
     layer->user_scrollable_horizontal_ = !layer->user_scrollable_horizontal_;
     layer->user_scrollable_vertical_ = !layer->user_scrollable_vertical_;
     layer->scroll_offset_ = gfx::ScrollOffset(3, 14);
     layer->scroll_compensation_adjustment_ = gfx::Vector2dF(6.28f, 3.14f);
     layer->update_rect_ = gfx::Rect(14, 15);
-    layer->stacking_order_changed_ = !layer->stacking_order_changed_;
 
     VerifyBaseLayerPropertiesSerializationAndDeserialization(layer.get());
   }
 
   void RunScrollAndClipLayersTest() {
     scoped_refptr<Layer> layer = Layer::Create(LayerSettings());
 
     scoped_refptr<Layer> scroll_parent = Layer::Create(LayerSettings());
     layer->scroll_parent_ = scroll_parent.get();
     scoped_refptr<Layer> scroll_child = Layer::Create(LayerSettings());
@@ skipping 681 matching lines @@
   node = layer_tree_host_->property_trees()->transform_tree.Node(
       child->transform_tree_index());
   EXPECT_FALSE(node->data.transform_changed);
 
   gfx::Point3F arbitrary_point_3f = gfx::Point3F(0.125f, 0.25f, 0.f);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
   root->SetTransformOrigin(arbitrary_point_3f);
   node = layer_tree_host_->property_trees()->transform_tree.Node(
       root->transform_tree_index());
   EXPECT_TRUE(node->data.transform_changed);
+  EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
+      root->PushPropertiesTo(root_impl.get());
+      child->PushPropertiesTo(child_impl.get());
+      child2->PushPropertiesTo(child2_impl.get());
+      grand_child->PushPropertiesTo(grand_child_impl.get());
+      layer_tree_host_->property_trees()->transform_tree.ResetChangeTracking());
+
+  gfx::Transform arbitrary_transform;
+  arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f);
+  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
+  root->SetTransform(arbitrary_transform);
+  node = layer_tree_host_->property_trees()->transform_tree.Node(
+      root->transform_tree_index());
+  EXPECT_TRUE(node->data.transform_changed);
 }
 
 TEST_F(LayerTest, AddAndRemoveChild) {
   scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
   scoped_refptr<Layer> child = Layer::Create(layer_settings_);
 
   // Upon creation, layers should not have children or parent.
   ASSERT_EQ(0U, parent->children().size());
   EXPECT_FALSE(child->parent());
 
@@ skipping 532 matching lines @@
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetOpacity(0.5f));
 
   EXPECT_FALSE(impl_layer->LayerPropertyChanged());
 
   test_layer->PushPropertiesTo(impl_layer.get());
 
   EXPECT_TRUE(impl_layer->LayerPropertyChanged());
 }
 
 TEST_F(LayerTest,
-       PushPropsDoesntCauseLayerPropertyChangedDuringImplOnlyTransformAnim) {
-  scoped_refptr<Layer> test_layer = Layer::Create(layer_settings_);
-  scoped_ptr<LayerImpl> impl_layer =
-      LayerImpl::Create(host_impl_.active_tree(), 1);
-
-  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
-                                  layer_tree_host_->SetRootLayer(test_layer));
-
-  scoped_ptr<AnimationRegistrar> registrar;
-  if (settings().use_compositor_animation_timelines) {
-    AddAnimatedTransformToLayerWithPlayer(impl_layer->id(), timeline_impl(),
-                                          1.0, 0, 100);
-  } else {
-    registrar = AnimationRegistrar::Create();
-    impl_layer->layer_animation_controller()->SetAnimationRegistrar(
-        registrar.get());
-
-    AddAnimatedTransformToController(impl_layer->layer_animation_controller(),
-                                     1.0, 0, 100);
-  }
-
-  gfx::Transform transform;
-  transform.Rotate(45.0);
-  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetTransform(transform));
-
-  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
-  test_layer->PushPropertiesTo(impl_layer.get());
-  EXPECT_TRUE(impl_layer->LayerPropertyChanged());
-
-  impl_layer->ResetAllChangeTrackingForSubtree();
-  if (settings().use_compositor_animation_timelines) {
-    int animation_id = AddAnimatedTransformToLayerWithPlayer(
-        impl_layer->id(), timeline_impl(), 1.0, 0, 100);
-    GetAnimationFromLayerWithExistingPlayer(impl_layer->id(), timeline_impl(),
-                                            animation_id)
-        ->set_is_impl_only(true);
-  } else {
-    AddAnimatedTransformToController(impl_layer->layer_animation_controller(),
-                                     1.0, 0, 100);
-    impl_layer->layer_animation_controller()
-        ->GetAnimation(Animation::TRANSFORM)
-        ->set_is_impl_only(true);
-  }
-  transform.Rotate(45.0);
-  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetTransform(transform));
-
-  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
-  test_layer->PushPropertiesTo(impl_layer.get());
-  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
-}
-
-TEST_F(LayerTest,
        PushPropsDoesntCauseLayerPropertyChangedDuringImplOnlyOpacityAnim) {
   scoped_refptr<Layer> test_layer = Layer::Create(layer_settings_);
   scoped_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
                                   layer_tree_host_->SetRootLayer(test_layer));
 
   scoped_ptr<AnimationRegistrar> registrar;
   if (settings().use_compositor_animation_timelines) {
@@ skipping 875 matching lines @@
   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.
-  proto::LayerUpdate layer_update_root;
   EXPECT_TRUE(layer_src_root->ToLayerPropertiesProto(&layer_update_root));
-  proto::LayerUpdate layer_update_a;
   EXPECT_FALSE(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_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));
-  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));
 
   // 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());
@@ skipping 112 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