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);

[wkorman, 2017/03/20 21:59:57]

Sometimes code guidelines prefer naming methods differently rather than relying
on varying return types. I'm actually not sure what Chromium style says here,
thought worth checkpoint for me to learn. Is this ok w/ the one below or should
be have Transform/Effect in the method name for more clarity?

I don't see anything about this explicitly in Chromium/Google C++ style docs.

[weiliangc, 2017/03/21 15:18:52]

Since this is a member function on transform/effect tree, I omitted what node
this function is referring to. I could make FindNodeFromElementId a pure virtual
function on property tree and only override it for transform and effect tree?

[wkorman, 2017/03/21 19:44:23]

Ah, that's right, I think it's ok as is then.

   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_