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

cc/trees/property_tree.cc

 // Copyright 2014 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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 127 matching lines @@
       flattens_inherited_transform(false),
       node_and_ancestors_are_flat(true),
       node_and_ancestors_have_only_integer_translation(true),
       scrolls(false),
       needs_sublayer_scale(false),
       affected_by_inner_viewport_bounds_delta_x(false),
       affected_by_inner_viewport_bounds_delta_y(false),
       affected_by_outer_viewport_bounds_delta_x(false),
       affected_by_outer_viewport_bounds_delta_y(false),
       in_subtree_of_page_scale_layer(false),
+      transform_changed(false),
       post_local_scale_factor(1.0f),
       local_maximum_animation_target_scale(0.f),
       local_starting_animation_scale(0.f),
       combined_maximum_animation_target_scale(0.f),
       combined_starting_animation_scale(0.f) {}
 
 TransformNodeData::~TransformNodeData() {
 }
 
 bool TransformNodeData::operator==(const TransformNodeData& other) const {
@@ skipping 22 matching lines @@
          affected_by_inner_viewport_bounds_delta_x ==
              other.affected_by_inner_viewport_bounds_delta_x &&
          affected_by_inner_viewport_bounds_delta_y ==
              other.affected_by_inner_viewport_bounds_delta_y &&
          affected_by_outer_viewport_bounds_delta_x ==
              other.affected_by_outer_viewport_bounds_delta_x &&
          affected_by_outer_viewport_bounds_delta_y ==
              other.affected_by_outer_viewport_bounds_delta_y &&
          in_subtree_of_page_scale_layer ==
              other.in_subtree_of_page_scale_layer &&
+         transform_changed == other.transform_changed &&
          post_local_scale_factor == other.post_local_scale_factor &&
          local_maximum_animation_target_scale ==
              other.local_maximum_animation_target_scale &&
          local_starting_animation_scale ==
              other.local_starting_animation_scale &&
          combined_maximum_animation_target_scale ==
              other.combined_maximum_animation_target_scale &&
          combined_starting_animation_scale ==
              other.combined_starting_animation_scale &&
          sublayer_scale == other.sublayer_scale &&
@@ skipping 63 matching lines @@
   data->set_affected_by_inner_viewport_bounds_delta_x(
       affected_by_inner_viewport_bounds_delta_x);
   data->set_affected_by_inner_viewport_bounds_delta_y(
       affected_by_inner_viewport_bounds_delta_y);
   data->set_affected_by_outer_viewport_bounds_delta_x(
       affected_by_outer_viewport_bounds_delta_x);
   data->set_affected_by_outer_viewport_bounds_delta_y(
       affected_by_outer_viewport_bounds_delta_y);
 
   data->set_in_subtree_of_page_scale_layer(in_subtree_of_page_scale_layer);
+  data->set_transform_changed(transform_changed);
   data->set_post_local_scale_factor(post_local_scale_factor);
   data->set_local_maximum_animation_target_scale(
       local_maximum_animation_target_scale);
   data->set_local_starting_animation_scale(local_starting_animation_scale);
   data->set_combined_maximum_animation_target_scale(
       combined_maximum_animation_target_scale);
   data->set_combined_starting_animation_scale(
       combined_starting_animation_scale);
 
   Vector2dFToProto(sublayer_scale, data->mutable_sublayer_scale());
@@ skipping 45 matching lines @@
   affected_by_inner_viewport_bounds_delta_x =
       data.affected_by_inner_viewport_bounds_delta_x();
   affected_by_inner_viewport_bounds_delta_y =
       data.affected_by_inner_viewport_bounds_delta_y();
   affected_by_outer_viewport_bounds_delta_x =
       data.affected_by_outer_viewport_bounds_delta_x();
   affected_by_outer_viewport_bounds_delta_y =
       data.affected_by_outer_viewport_bounds_delta_y();
 
   in_subtree_of_page_scale_layer = data.in_subtree_of_page_scale_layer();
+  transform_changed = data.transform_changed();
   post_local_scale_factor = data.post_local_scale_factor();
   local_maximum_animation_target_scale =
       data.local_maximum_animation_target_scale();
   local_starting_animation_scale = data.local_starting_animation_scale();
   combined_maximum_animation_target_scale =
       data.combined_maximum_animation_target_scale();
   combined_starting_animation_scale = data.combined_starting_animation_scale();
 
   sublayer_scale = ProtoToVector2dF(data.sublayer_scale());
   scroll_offset = ProtoToScrollOffset(data.scroll_offset());
@@ skipping 239 matching lines @@
   gfx::Transform transform;
   return ComputeTransform(source_id, dest_id, &transform) &&
          transform.Preserves2dAxisAlignment();
 }
 
 bool TransformTree::NeedsSourceToParentUpdate(TransformNode* node) {
   return (source_to_parent_updates_allowed() &&
           node->parent_id != node->data.source_node_id);
 }
 
+void TransformTree::ResetChangeTracking() {
+  for (int id = 1; id < static_cast<int>(size()); ++id) {
+    TransformNode* node = Node(id);
+    node->data.transform_changed = false;
+  }
+}
+
 void TransformTree::UpdateTransforms(int id) {
   TransformNode* node = Node(id);
   TransformNode* parent_node = parent(node);
   TransformNode* target_node = Node(node->data.target_id);
+  TransformNode* source_node = Node(node->data.source_node_id);
   if (node->data.needs_local_transform_update ||
       NeedsSourceToParentUpdate(node))
     UpdateLocalTransform(node);
   else
     UndoSnapping(node);
   UpdateScreenSpaceTransform(node, parent_node, target_node);
   UpdateSublayerScale(node);
   UpdateTargetSpaceTransform(node, target_node);
   UpdateAnimationProperties(node, parent_node);
   UpdateSnapping(node);
   UpdateNodeAndAncestorsHaveIntegerTranslations(node, parent_node);
+  UpdateTransformChanged(node, parent_node, source_node);
 }
 
 bool TransformTree::IsDescendant(int desc_id, int source_id) const {
   while (desc_id != source_id) {
     if (desc_id < 0)
       return false;
     desc_id = Node(desc_id)->parent_id;
   }
   return true;
 }
@@ skipping 339 matching lines @@
   node->data.to_parent.Translate(translation.x(), translation.y());
   node->data.from_target.matrix().postTranslate(-translation.x(),
                                                 -translation.y(), 0);
   node->data.to_screen.Translate(translation.x(), translation.y());
   node->data.from_screen.matrix().postTranslate(-translation.x(),
                                                 -translation.y(), 0);
 
   node->data.scroll_snap = translation;
 }
 
+void TransformTree::UpdateTransformChanged(TransformNode* node,
+                                           TransformNode* parent_node,
+                                           TransformNode* source_node) {
+  if (!source_node || (source_node->id != parent_node->id &&
+                       !source_to_parent_updates_allowed_))
+    return;
+  if (source_node->data.transform_changed)
+    node->data.transform_changed = true;

[ajuma, 2016/02/16 22:55:50]

What about if just the parent node changes (and the source node doesn't)? That
still has the effect of changing the to_screen transform.

[jaydasika, 2016/02/16 23:08:22]

Yes, to_screen will change in that case. But, I don't think we were handling
that case before this CL. Do you think that's a bug ?

[ajuma, 2016/02/17 00:05:33]

Yes, if a layer's to_screen transform changed, then the layer moved, so it
should be treated as damaged. 

+}
+
 void TransformTree::SetDeviceTransform(const gfx::Transform& transform,
                                        gfx::PointF root_position) {
   gfx::Transform root_post_local = transform;
   TransformNode* node = Node(1);
   root_post_local.Scale(node->data.post_local_scale_factor,
                         node->data.post_local_scale_factor);
   root_post_local.Translate(root_position.x(), root_position.y());
   if (node->data.post_local == root_post_local)
     return;
 
@@ skipping 386 matching lines @@
   outer_viewport_container_bounds_delta_ = bounds_delta;
   transform_tree.UpdateOuterViewportContainerBoundsDelta();
 }
 
 void PropertyTrees::SetInnerViewportScrollBoundsDelta(
     gfx::Vector2dF bounds_delta) {
   inner_viewport_scroll_bounds_delta_ = bounds_delta;
 }
 
 }  // namespace cc