cc: Use Element Id to Record Animation Changes

cc/trees/layer_tree_impl.cc

Index: cc/trees/layer_tree_impl.cc
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 2cd1cb124cd8713e753acc16fc2f4a950ad8a60e..1bc5fad92beac9af88ef8942217928628b771050 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -624,17 +624,20 @@ void LayerTreeImpl::RemoveFromElementMap(LayerImpl* layer) {
 }
 
 void LayerTreeImpl::AddToOpacityAnimationsMap(int id, float opacity) {
-  opacity_animations_map_[id] = opacity;
+  if (LayerImpl* layer = LayerById(id))

[ajuma, 2017/03/20 21:40:38]

This logic is a bit roundabout in that (looking at the call stack that gets
here) we start with an element id, that gets converted to a node id, then we get
a layer id at the node, and then here we use that to find a layer to find the
element id again :)

Will this be fixed as part of removing the LayerTreeImpl* argument to
EffectTree::OnOpacityAnimated?

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

Yeah.

+    opacity_animations_map_[layer->element_id()] = opacity;
 }
 
 void LayerTreeImpl::AddToTransformAnimationsMap(int id,
                                                 gfx::Transform transform) {
-  transform_animations_map_[id] = transform;
+  if (LayerImpl* layer = LayerById(id))
+    transform_animations_map_[layer->element_id()] = transform;
 }
 
 void LayerTreeImpl::AddToFilterAnimationsMap(int id,
                                              const FilterOperations& filters) {
-  filter_animations_map_[id] = filters;
+  if (LayerImpl* layer = LayerById(id))
+    filter_animations_map_[layer->element_id()] = filters;
 }
 
 LayerImpl* LayerTreeImpl::InnerViewportContainerLayer() const {
@@ -721,57 +724,54 @@ void LayerTreeImpl::UpdatePropertyTreeScrollingAndAnimationFromMainThread() {
   // frame to a newly-committed property tree.
   if (layer_list_.empty())
     return;
-  std::vector<int> layer_ids_to_remove;
-  for (auto& layer_id_to_opacity : opacity_animations_map_) {
-    const int id = layer_id_to_opacity.first;
+  auto element_id_to_opacity = opacity_animations_map_.begin();
+  for (; element_id_to_opacity != opacity_animations_map_.end();) {

[ajuma, 2017/03/20 21:40:38]

Since this just has a condition now, it can be turned into a while loop. Same
comment for the loops below.

+    const ElementId id = element_id_to_opacity->first;
     if (EffectNode* node =
-            property_trees_.effect_tree.UpdateNodeFromOwningLayerId(id)) {
+            property_trees_.effect_tree.FindNodeFromElementId(id)) {
       if (!node->is_currently_animating_opacity ||
-          node->opacity == layer_id_to_opacity.second) {
-        layer_ids_to_remove.push_back(id);
+          node->opacity == element_id_to_opacity->second) {
+        opacity_animations_map_.erase(element_id_to_opacity++);

[ajuma, 2017/03/20 21:40:38]

Is the iterator guaranteed to still be valid after this?

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

Yes. It's post increment, so the current iterator is passed into erase, and the
iterator is incremented.

         continue;
       }
-      node->opacity = layer_id_to_opacity.second;
+      node->opacity = element_id_to_opacity->second;
       property_trees_.effect_tree.set_needs_update(true);
     }
+    ++element_id_to_opacity;
   }
-  for (auto id : layer_ids_to_remove)
-    opacity_animations_map_.erase(id);
-  layer_ids_to_remove.clear();
 
-  for (auto& layer_id_to_transform : transform_animations_map_) {
-    const int id = layer_id_to_transform.first;
+  auto element_id_to_filter = filter_animations_map_.begin();
+  for (; element_id_to_filter != filter_animations_map_.end();) {
+    const ElementId id = element_id_to_filter->first;
+    if (EffectNode* node =
+            property_trees_.effect_tree.FindNodeFromElementId(id)) {
+      if (!node->is_currently_animating_filter ||
+          node->filters == element_id_to_filter->second) {
+        filter_animations_map_.erase(element_id_to_filter++);
+        continue;
+      }
+      node->filters = element_id_to_filter->second;
+      property_trees_.effect_tree.set_needs_update(true);
+    }
+    ++element_id_to_filter;
+  }
+
+  auto element_id_to_transform = transform_animations_map_.begin();
+  for (; element_id_to_transform != transform_animations_map_.end();) {
+    const ElementId id = element_id_to_transform->first;
     if (TransformNode* node =
-            property_trees_.transform_tree.UpdateNodeFromOwningLayerId(id)) {
+            property_trees_.transform_tree.FindNodeFromElementId(id)) {
       if (!node->is_currently_animating ||
-          node->local == layer_id_to_transform.second) {
-        layer_ids_to_remove.push_back(id);
+          node->local == element_id_to_transform->second) {
+        transform_animations_map_.erase(element_id_to_transform++);
         continue;
       }
-      node->local = layer_id_to_transform.second;
+      node->local = element_id_to_transform->second;
       node->needs_local_transform_update = true;
       property_trees_.transform_tree.set_needs_update(true);
     }
+    ++element_id_to_transform;
   }
-  for (auto id : layer_ids_to_remove)
-    transform_animations_map_.erase(id);
-  layer_ids_to_remove.clear();
-
-  for (auto& layer_id_to_filters : filter_animations_map_) {
-    const int id = layer_id_to_filters.first;
-    if (EffectNode* node =
-            property_trees_.effect_tree.UpdateNodeFromOwningLayerId(id)) {
-      if (!node->is_currently_animating_filter ||
-          node->filters == layer_id_to_filters.second) {
-        layer_ids_to_remove.push_back(id);
-        continue;
-      }
-      node->filters = layer_id_to_filters.second;
-      property_trees_.effect_tree.set_needs_update(true);
-    }
-  }
-  for (auto id : layer_ids_to_remove)
-    filter_animations_map_.erase(id);
 
   LayerTreeHostCommon::CallFunctionForEveryLayer(this, [](LayerImpl* layer) {
     layer->UpdatePropertyTreeForScrollingAndAnimationIfNeeded();
@@ -1185,6 +1185,7 @@ void LayerTreeImpl::BuildLayerListAndPropertyTreesForTesting() {
 }
 
 void LayerTreeImpl::BuildPropertyTreesForTesting() {
+  SetElementIdsForTesting();
   PropertyTreeBuilder::PreCalculateMetaInformationForTesting(layer_list_[0]);
   property_trees_.needs_rebuild = true;
   property_trees_.transform_tree.set_source_to_parent_updates_allowed(true);
@@ -1257,8 +1258,9 @@ void LayerTreeImpl::RegisterLayer(LayerImpl* layer) {
 void LayerTreeImpl::UnregisterLayer(LayerImpl* layer) {
   DCHECK(LayerById(layer->id()));
   layers_that_should_push_properties_.erase(layer);
-  transform_animations_map_.erase(layer->id());
-  opacity_animations_map_.erase(layer->id());
+  transform_animations_map_.erase(layer->element_id());
+  opacity_animations_map_.erase(layer->element_id());
+  filter_animations_map_.erase(layer->element_id());
   layer_id_map_.erase(layer->id());
 }