cc: Use Element Id to Record Animation Changes

cc/layers/layer.cc

 // Copyright 2010 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 <stdint.h>
 
 #include <algorithm>
@@ skipping 1319 matching lines @@
 void Layer::OnTransformAnimated(const gfx::Transform& transform) {
   inputs_.transform = transform;
 }
 
 void Layer::OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset) {
   // Do nothing. Scroll deltas will be sent from the compositor thread back
   // to the main thread in the same manner as during non-animated
   // compositor-driven scrolling.
 }
 
-void Layer::OnIsAnimatingChanged(const PropertyAnimationState& mask,
-                                 const PropertyAnimationState& state) {
-  DCHECK(layer_tree_host_);
-  PropertyTrees* property_trees = layer_tree_host_->property_trees();
-
-  for (int property = TargetProperty::FIRST_TARGET_PROPERTY;
-       property <= TargetProperty::LAST_TARGET_PROPERTY; ++property) {
-    if (!mask.currently_running[property] &&
-        !mask.potentially_animating[property])
-      continue;
-
-    switch (property) {
-      case TargetProperty::TRANSFORM:
-        if (TransformNode* transform_node =
-                property_trees->transform_tree.UpdateNodeFromOwningLayerId(
-                    id())) {
-          DCHECK_EQ(transform_node->id, transform_tree_index());
-          if (mask.currently_running[property])
-            transform_node->is_currently_animating =
-                state.currently_running[property];
-          if (mask.potentially_animating[property]) {
-            transform_node->has_potential_animation =
-                state.potentially_animating[property];
-            if (state.potentially_animating[property]) {
-              transform_node->has_only_translation_animations =
-                  HasOnlyTranslationTransforms();
-            } else {
-              transform_node->has_only_translation_animations = true;
-            }
-            property_trees->transform_tree.set_needs_update(true);
-          }
-        } else {
-          DCHECK(property_trees->needs_rebuild)
-              << "Attempting to animate non existent transform node";
-        }
-        break;
-      case TargetProperty::OPACITY:
-        if (EffectNode* effect_node =
-                property_trees->effect_tree.UpdateNodeFromOwningLayerId(id())) {
-          if (mask.currently_running[property])
-            effect_node->is_currently_animating_opacity =
-                state.currently_running[property];
-          if (mask.potentially_animating[property]) {
-            effect_node->has_potential_opacity_animation =
-                state.potentially_animating[property] ||
-                OpacityCanAnimateOnImplThread();
-            property_trees->effect_tree.set_needs_update(true);
-          }
-        } else {
-          DCHECK(property_trees->needs_rebuild)
-              << "Attempting to animate opacity on non existent effect node";
-        }
-        break;
-      case TargetProperty::FILTER:
-        if (EffectNode* effect_node =
-                property_trees->effect_tree.UpdateNodeFromOwningLayerId(id())) {
-          if (mask.currently_running[property])
-            effect_node->is_currently_animating_filter =
-                state.currently_running[property];
-          if (mask.potentially_animating[property])
-            effect_node->has_potential_filter_animation =
-                state.potentially_animating[property];
-        } else {
-          DCHECK(property_trees->needs_rebuild)
-              << "Attempting to animate filter on non existent effect node";
-        }
-        break;
-      default:
-        break;
-    }
-  }
-}
-
 bool Layer::HasTickingAnimationForTesting() const {
   return layer_tree_host_
              ? GetMutatorHost()->HasTickingAnimationForTesting(element_id())
              : false;
 }
 
 void Layer::SetHasWillChangeTransformHint(bool has_will_change) {
   if (inputs_.has_will_change_transform_hint == has_will_change)
     return;
   inputs_.has_will_change_transform_hint = has_will_change;
@@ skipping 104 matching lines @@
       ->num_copy_requests_in_subtree;
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, TransformTree::kInvalidNodeId);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc