cc: Use Element Id to Record Animation Changes

cc/trees/property_tree.h

 // 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.
 
 #ifndef CC_TREES_PROPERTY_TREE_H_
 #define CC_TREES_PROPERTY_TREE_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 86 matching lines @@
   }
   PropertyTrees* property_trees() const { return property_trees_; }
 
   void AsValueInto(base::trace_event::TracedValue* value) const;
 
   const T* FindNodeFromOwningLayerId(int id) const {
     return Node(FindNodeIndexFromOwningLayerId(id));
   }
   T* UpdateNodeFromOwningLayerId(int id) {
     int index = FindNodeIndexFromOwningLayerId(id);
-    if (index == kInvalidNodeId && property_trees()->is_main_thread) {
+    if (index == kInvalidNodeId) {
+      DCHECK(property_trees()->is_main_thread);
       property_trees()->needs_rebuild = true;
     }
 
     return Node(index);
   }
 
   int FindNodeIndexFromOwningLayerId(int id) const {
     auto iter = owning_layer_id_to_node_index.find(id);
     if (iter == owning_layer_id_to_node_index.end())
       return kInvalidNodeId;
@@ skipping 46 matching lines @@
   TransformTree& operator=(const TransformTree&);
 
   bool operator==(const TransformTree& other) const;
 
   static const int kContentsRootNodeId = 1;
 
   int Insert(const TransformNode& tree_node, int parent_id);
 
   void clear();
 
+  TransformNode* FindNodeFromElementId(ElementId id);
   void OnTransformAnimated(const gfx::Transform& transform,
                            int id,
                            LayerTreeImpl* layer_tree_impl);
   // Computes the change of basis transform from node |source_id| to |dest_id|.
   // This is used by scroll children to compute transform from their scroll
   // parent space (source) to their parent space (destination) and it can atmost
   // be a translation. This function assumes that the path from source to
   // destination has only translations. So, it should not be called when there
   // can be intermediate 3d transforms but the end result is a translation.
   bool ComputeTranslation(int source_id,
@@ skipping 149 matching lines @@
   static const int kContentsRootNodeId = 1;
 
   int Insert(const EffectNode& tree_node, int parent_id);
 
   void clear();
 
   float EffectiveOpacity(const EffectNode* node) const;
 
   void UpdateSurfaceContentsScale(EffectNode* node);
 
+  EffectNode* FindNodeFromElementId(ElementId id);
   void OnOpacityAnimated(float opacity, int id, LayerTreeImpl* layer_tree_impl);
   void OnFilterAnimated(const FilterOperations& filters,
                         int id,
                         LayerTreeImpl* layer_tree_impl);
 
   void UpdateEffects(int id);
 
   void UpdateEffectChanged(EffectNode* node, EffectNode* parent_node);
 
   void AddCopyRequest(int node_id, std::unique_ptr<CopyOutputRequest> request);
@@ skipping 335 matching lines @@
   DrawTransforms& GetDrawTransforms(int transform_id, int effect_id) const;
   DrawTransformData& FetchDrawTransformsDataFromCache(int transform_id,
                                                       int effect_id) const;
 
   PropertyTreesCachedData cached_data_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_PROPERTY_TREE_H_