cc: Use Element Id to Record Animation Changes

cc/trees/layer_tree_impl.cc

 // Copyright 2011 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/trees/layer_tree_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 608 matching lines @@
                layer->id());
 
   layer_tree_host_impl_->mutator_host()->UnregisterElement(
       layer->element_id(),
       IsActiveTree() ? ElementListType::ACTIVE : ElementListType::PENDING);
 
   element_layers_map_.erase(layer->element_id());
 }
 
 void LayerTreeImpl::AddToOpacityAnimationsMap(int id, float opacity) {
-  opacity_animations_map_[id] = opacity;
+  if (LayerImpl* layer = LayerById(id))
+    element_id_to_opacity_animations_[layer->element_id()] = opacity;
 }
 
 void LayerTreeImpl::AddToTransformAnimationsMap(int id,
                                                 gfx::Transform transform) {
-  transform_animations_map_[id] = transform;
+  if (LayerImpl* layer = LayerById(id))
+    element_id_to_transform_animations_[layer->element_id()] = transform;
 }
 
 void LayerTreeImpl::AddToFilterAnimationsMap(int id,
                                              const FilterOperations& filters) {
-  filter_animations_map_[id] = filters;
+  if (LayerImpl* layer = LayerById(id))
+    element_id_to_filter_animations_[layer->element_id()] = filters;
 }
 
 LayerImpl* LayerTreeImpl::InnerViewportContainerLayer() const {
   return InnerViewportScrollLayer()
              ? InnerViewportScrollLayer()->scroll_clip_layer()
              : NULL;
 }
 
 LayerImpl* LayerTreeImpl::OuterViewportContainerLayer() const {
   return OuterViewportScrollLayer()
@@ skipping 66 matching lines @@
 
 void LayerTreeImpl::UpdatePropertyTreeScrollingAndAnimationFromMainThread() {
   // TODO(enne): This should get replaced by pulling out scrolling and
   // animations into their own trees.  Then scrolls and animations would have
   // their own ways of synchronizing across commits.  This occurs to push
   // updates from scrolling deltas on the compositor thread that have occurred
   // after begin frame and updates from animations that have ticked since begin
   // 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 = element_id_to_opacity_animations_.begin();
+  while (element_id_to_opacity != element_id_to_opacity_animations_.end()) {
+    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) {
+        element_id_to_opacity_animations_.erase(element_id_to_opacity++);
         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;
-    if (TransformNode* node =
-            property_trees_.transform_tree.UpdateNodeFromOwningLayerId(id)) {
-      if (!node->is_currently_animating ||
-          node->local == layer_id_to_transform.second) {
-        layer_ids_to_remove.push_back(id);
+  auto element_id_to_filter = element_id_to_filter_animations_.begin();
+  while (element_id_to_filter != element_id_to_filter_animations_.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) {
+        element_id_to_filter_animations_.erase(element_id_to_filter++);
         continue;
       }
-      node->local = layer_id_to_transform.second;
+      node->filters = element_id_to_filter->second;
+      property_trees_.effect_tree.set_needs_update(true);
+    }
+    ++element_id_to_filter;
+  }
+
+  auto element_id_to_transform = element_id_to_transform_animations_.begin();
+  while (element_id_to_transform != element_id_to_transform_animations_.end()) {
+    const ElementId id = element_id_to_transform->first;
+    if (TransformNode* node =
+            property_trees_.transform_tree.FindNodeFromElementId(id)) {
+      if (!node->is_currently_animating ||
+          node->local == element_id_to_transform->second) {
+        element_id_to_transform_animations_.erase(element_id_to_transform++);
+        continue;
+      }
+      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();
   });
 }
 
 void LayerTreeImpl::SetPageScaleOnActiveTree(float active_page_scale) {
   DCHECK(IsActiveTree());
   if (page_scale_factor()->SetCurrent(
           ClampPageScaleFactorToLimits(active_page_scale))) {
@@ skipping 214 matching lines @@
 }
 
 // For unit tests, we use the layer's id as its element id.
 static void SetElementIdForTesting(LayerImpl* layer) {
   layer->SetElementId(LayerIdToElementIdForTesting(layer->id()));
 }
 
 void LayerTreeImpl::SetElementIdsForTesting() {
   LayerListIterator<LayerImpl> it(root_layer_for_testing_);
   for (; it != LayerListIterator<LayerImpl>(nullptr); ++it) {
-    SetElementIdForTesting(*it);
+    if (!it->element_id())
+      SetElementIdForTesting(*it);
   }
 }
 
 bool LayerTreeImpl::UpdateDrawProperties(
     bool update_lcd_text,
     bool force_skip_verify_visible_rect_calculations) {
   if (!needs_update_draw_properties_)
     return true;
 
   // Calling UpdateDrawProperties must clear this flag, so there can be no
@@ skipping 158 matching lines @@
       << "CalcDrawProperties should not set_needs_update_draw_properties()";
   return true;
 }
 
 void LayerTreeImpl::BuildLayerListAndPropertyTreesForTesting() {
   BuildLayerListForTesting();
   BuildPropertyTreesForTesting();
 }
 
 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);
   PropertyTreeBuilder::BuildPropertyTrees(
       layer_list_[0], PageScaleLayer(), InnerViewportScrollLayer(),
       OuterViewportScrollLayer(), OverscrollElasticityLayer(),
       elastic_overscroll()->Current(IsActiveTree()),
       current_page_scale_factor(), device_scale_factor(),
       gfx::Rect(DrawViewportSize()), layer_tree_host_impl_->DrawTransform(),
       &property_trees_);
@@ skipping 52 matching lines @@
 }
 
 void LayerTreeImpl::RegisterLayer(LayerImpl* layer) {
   DCHECK(!LayerById(layer->id()));
   layer_id_map_[layer->id()] = 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());
+  element_id_to_transform_animations_.erase(layer->element_id());
+  element_id_to_opacity_animations_.erase(layer->element_id());
+  element_id_to_filter_animations_.erase(layer->element_id());
   layer_id_map_.erase(layer->id());
 }
 
 // These manage ownership of the LayerImpl.
 void LayerTreeImpl::AddLayer(std::unique_ptr<LayerImpl> layer) {
   DCHECK(std::find(layers_->begin(), layers_->end(), layer) == layers_->end());
 
   // TODO(ajuma): Change this to a DCHECK once we've figured out what's causing
   // crbug.com/701279.
   CHECK(layer);
@@ skipping 877 matching lines @@
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   // Iterate over all layers, including masks.
   for (auto& layer : *layers_)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc