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 393 matching lines @@
       << "CalcDrawProperties should not set_needs_update_draw_properties()";
   return true;
 }
 
 void LayerTreeImpl::BuildLayerListAndPropertyTreesForTesting() {
   BuildLayerListForTesting();
   BuildPropertyTreesForTesting();
 }
 
 void LayerTreeImpl::BuildPropertyTreesForTesting() {
+  SetElementIdsForTesting();

[ajuma, 2017/03/22 19:28:22]

It looks like this is conflicting with
CompositorMutableStateTest.MutableStateMutableProperties that wants to set its
own element ids but also needs to build properties for testing. Perhaps
SetElementIdForTesting can be changed to only set element ids on layers that
don't already have one.

   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