cc: Main thread skip single layers instead of subtrees

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 121 matching lines @@
 
 TransformNodeData::TransformNodeData()
     : target_id(-1),
       content_target_id(-1),
       source_node_id(-1),
       sorting_context_id(0),
       needs_local_transform_update(true),
       is_invertible(true),
       ancestors_are_invertible(true),
       is_animated(false),
-      to_screen_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),
       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),
@@ skipping 17 matching lines @@
          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 &&
          is_invertible == other.is_invertible &&
          ancestors_are_invertible == other.ancestors_are_invertible &&
          is_animated == other.is_animated &&
-         to_screen_is_animated == other.to_screen_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 &&
          node_and_ancestors_have_only_integer_translation ==
              other.node_and_ancestors_have_only_integer_translation &&
          scrolls == other.scrolls &&
          needs_sublayer_scale == other.needs_sublayer_scale &&
          affected_by_inner_viewport_bounds_delta_x ==
@@ skipping 61 matching lines @@
   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_is_invertible(is_invertible);
   data->set_ancestors_are_invertible(ancestors_are_invertible);
 
   data->set_is_animated(is_animated);
-  data->set_to_screen_is_animated(to_screen_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);
   data->set_node_and_ancestors_are_flat(node_and_ancestors_are_flat);
 
   data->set_node_and_ancestors_have_only_integer_translation(
       node_and_ancestors_have_only_integer_translation);
   data->set_scrolls(scrolls);
   data->set_needs_sublayer_scale(needs_sublayer_scale);
@@ skipping 45 matching lines @@
   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();
 
   is_invertible = data.is_invertible();
   ancestors_are_invertible = data.ancestors_are_invertible();
 
   is_animated = data.is_animated();
-  to_screen_is_animated = data.to_screen_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();
 
   node_and_ancestors_have_only_integer_translation =
       data.node_and_ancestors_have_only_integer_translation();
   scrolls = data.scrolls();
   needs_sublayer_scale = data.needs_sublayer_scale();
@@ skipping 517 matching lines @@
   node->data.set_to_parent(transform);
   node->data.needs_local_transform_update = false;
 }
 
 void TransformTree::UpdateScreenSpaceTransform(TransformNode* node,
                                                TransformNode* parent_node,
                                                TransformNode* target_node) {
   if (!parent_node) {
     node->data.to_screen = node->data.to_parent;
     node->data.ancestors_are_invertible = true;
-    node->data.to_screen_is_animated = false;
+    node->data.to_screen_is_potentially_animated = false;
     node->data.node_and_ancestors_are_flat = node->data.to_parent.IsFlat();
   } else {
     node->data.to_screen = parent_node->data.to_screen;
     if (node->data.flattens_inherited_transform)
       node->data.to_screen.FlattenTo2d();
     node->data.to_screen.PreconcatTransform(node->data.to_parent);
     node->data.ancestors_are_invertible =
         parent_node->data.ancestors_are_invertible;
     node->data.node_and_ancestors_are_flat =
         parent_node->data.node_and_ancestors_are_flat &&
@@ skipping 37 matching lines @@
     node->data.ancestors_are_invertible = false;
 }
 
 void TransformTree::UpdateAnimationProperties(TransformNode* node,
                                               TransformNode* parent_node) {
   bool ancestor_is_animating = false;
   bool ancestor_is_animating_scale = false;
   float ancestor_maximum_target_scale = 0.f;
   float ancestor_starting_animation_scale = 0.f;
   if (parent_node) {
-    ancestor_is_animating = parent_node->data.to_screen_is_animated;
+    ancestor_is_animating = parent_node->data.to_screen_is_potentially_animated;
     ancestor_is_animating_scale =
         parent_node->data.to_screen_has_scale_animation;
     ancestor_maximum_target_scale =
         parent_node->data.combined_maximum_animation_target_scale;
     ancestor_starting_animation_scale =
         parent_node->data.combined_starting_animation_scale;
   }
-  node->data.to_screen_is_animated =
+  node->data.to_screen_is_potentially_animated =
       node->data.is_animated || ancestor_is_animating;
   node->data.to_screen_has_scale_animation =
       !node->data.has_only_translation_animations ||
       ancestor_is_animating_scale;
 
   // Once we've failed to compute a maximum animated scale at an ancestor, we
   // continue to fail.
   bool failed_at_ancestor =
       ancestor_is_animating_scale && ancestor_maximum_target_scale == 0.f;
 
@@ skipping 62 matching lines @@
 
 void TransformTree::UndoSnapping(TransformNode* node) {
   // to_parent transform has the scroll snap from previous frame baked in.
   // We need to undo it and use the un-snapped transform to compute current
   // target and screen space transforms.
   node->data.to_parent.Translate(-node->data.scroll_snap.x(),
                                  -node->data.scroll_snap.y());
 }
 
 void TransformTree::UpdateSnapping(TransformNode* node) {
-  if (!node->data.scrolls || node->data.to_screen_is_animated ||
+  if (!node->data.scrolls || node->data.to_screen_is_potentially_animated ||
       !node->data.to_target.IsScaleOrTranslation() ||
       !node->data.ancestors_are_invertible) {
     return;
   }
 
   // Scroll snapping must be done in target space (the pixels we care about).
   // This means we effectively snap the target space transform. If TT is the
   // target space transform and TT' is TT with its translation components
   // rounded, then what we're after is the scroll delta X, where TT * X = TT'.
   // I.e., we want a transform that will realize our scroll snap. It follows
@@ skipping 892 matching lines @@
       break;
     case ALL_TREES:
       transform_tree.ResetChangeTracking();
       effect_tree.ResetChangeTracking();
   }
   changed = false;
   full_tree_damaged = false;
 }
 
 }  // namespace cc