cc : Add node and ancestors are animated or invertible to transform tree

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 118 matching lines @@
 template class PropertyTree<ClipNode>;
 template class PropertyTree<EffectNode>;
 template class PropertyTree<ScrollNode>;
 
 TransformNodeData::TransformNodeData()
     : target_id(-1),
       content_target_id(-1),
       source_node_id(-1),
       sorting_context_id(0),
       needs_local_transform_update(true),
+      node_and_ancestors_are_animated_or_invertible(true),
       is_invertible(true),
       ancestors_are_invertible(true),
       is_animated(false),
       to_screen_is_potentially_animated(false),
       has_only_translation_animations(true),
       to_screen_has_scale_animation(false),
       flattens_inherited_transform(false),
       node_and_ancestors_are_flat(true),
       node_and_ancestors_have_only_integer_translation(true),
       scrolls(false),
@@ skipping 18 matching lines @@
 bool TransformNodeData::operator==(const TransformNodeData& other) const {
   return pre_local == other.pre_local && local == other.local &&
          post_local == other.post_local && to_parent == other.to_parent &&
          to_target == other.to_target && from_target == other.from_target &&
          to_screen == other.to_screen && from_screen == other.from_screen &&
          target_id == other.target_id &&
          content_target_id == other.content_target_id &&
          source_node_id == other.source_node_id &&
          sorting_context_id == other.sorting_context_id &&
          needs_local_transform_update == other.needs_local_transform_update &&
+         node_and_ancestors_are_animated_or_invertible ==
+             other.node_and_ancestors_are_animated_or_invertible &&
          is_invertible == other.is_invertible &&
          ancestors_are_invertible == other.ancestors_are_invertible &&
          is_animated == other.is_animated &&
          to_screen_is_potentially_animated ==
              other.to_screen_is_potentially_animated &&
          has_only_translation_animations ==
              other.has_only_translation_animations &&
          to_screen_has_scale_animation == other.to_screen_has_scale_animation &&
          flattens_inherited_transform == other.flattens_inherited_transform &&
          node_and_ancestors_are_flat == other.node_and_ancestors_are_flat &&
@@ skipping 62 matching lines @@
   TransformToProto(to_screen, data->mutable_to_screen());
   TransformToProto(from_screen, data->mutable_from_screen());
 
   data->set_target_id(target_id);
   data->set_content_target_id(content_target_id);
   data->set_source_node_id(source_node_id);
   data->set_sorting_context_id(sorting_context_id);
 
   data->set_needs_local_transform_update(needs_local_transform_update);
 
+  data->set_node_and_ancestors_are_animated_or_invertible(
+      node_and_ancestors_are_animated_or_invertible);
+
   data->set_is_invertible(is_invertible);
   data->set_ancestors_are_invertible(ancestors_are_invertible);
 
   data->set_is_animated(is_animated);
   data->set_to_screen_is_potentially_animated(
       to_screen_is_potentially_animated);
   data->set_has_only_translation_animations(has_only_translation_animations);
   data->set_to_screen_has_scale_animation(to_screen_has_scale_animation);
 
   data->set_flattens_inherited_transform(flattens_inherited_transform);
@@ skipping 47 matching lines @@
   to_screen = ProtoToTransform(data.to_screen());
   from_screen = ProtoToTransform(data.from_screen());
 
   target_id = data.target_id();
   content_target_id = data.content_target_id();
   source_node_id = data.source_node_id();
   sorting_context_id = data.sorting_context_id();
 
   needs_local_transform_update = data.needs_local_transform_update();
 
+  node_and_ancestors_are_animated_or_invertible =
+      data.node_and_ancestors_are_animated_or_invertible();
+
   is_invertible = data.is_invertible();
   ancestors_are_invertible = data.ancestors_are_invertible();
 
   is_animated = data.is_animated();
   to_screen_is_potentially_animated = data.to_screen_is_potentially_animated();
   has_only_translation_animations = data.has_only_translation_animations();
   to_screen_has_scale_animation = data.to_screen_has_scale_animation();
 
   flattens_inherited_transform = data.flattens_inherited_transform();
   node_and_ancestors_are_flat = data.node_and_ancestors_are_flat();
@@ skipping 347 matching lines @@
     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);
+  UpdateNodeAndAncestorsAreAnimatedOrInvertible(node, parent_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 352 matching lines @@
   if (parent_node && parent_node->data.transform_changed) {
     node->data.transform_changed = true;
     return;
   }
 
   if (source_node && source_node->id != parent_node->id &&
       source_to_parent_updates_allowed_ && source_node->data.transform_changed)
     node->data.transform_changed = true;
 }
 
+void TransformTree::UpdateNodeAndAncestorsAreAnimatedOrInvertible(
+    TransformNode* node,
+    TransformNode* parent_node) {
+  if (!parent_node) {
+    node->data.node_and_ancestors_are_animated_or_invertible =
+        node->data.is_animated || node->data.is_invertible;
+    return;
+  }
+  if (!parent_node->data.node_and_ancestors_are_animated_or_invertible) {
+    node->data.node_and_ancestors_are_animated_or_invertible = false;
+    return;
+  }
+  bool is_invertible = node->data.is_invertible;
+  // Even when the current node's transform and the parent's screen space
+  // transform are invertible, the current node's screen space transform can
+  // become uninvertible due to floating-point arithmetic.
+  if (!node->data.ancestors_are_invertible &&
+      parent_node->data.ancestors_are_invertible)
+    is_invertible = false;
+  node->data.node_and_ancestors_are_animated_or_invertible =
+      node->data.is_animated || is_invertible;
+}
+
 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 845 matching lines @@
       break;
     case ALL_TREES:
       transform_tree.ResetChangeTracking();
       effect_tree.ResetChangeTracking();
   }
   changed = false;
   full_tree_damaged = false;
 }
 
 }  // namespace cc