cc : Track opacity animation changes on effect tree

cc/trees/property_tree_builder.cc

 // 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.
 
 #include "cc/trees/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 609 matching lines @@
   // Flattening (if needed) will be handled by |node|.
   layer->set_should_flatten_transform_from_property_tree(false);
 
   data_for_children->scroll_snap += node->data.scroll_snap;
 
   node->owner_id = layer->id();
 
   return true;
 }
 
-bool IsAnimatingOpacity(Layer* layer) {
+static inline bool HasPotentialOpacityAnimation(Layer* layer) {
   return layer->HasPotentiallyRunningOpacityAnimation() ||
          layer->OpacityCanAnimateOnImplThread();
 }
 
-bool IsAnimatingOpacity(LayerImpl* layer) {
+static inline bool HasPotentialOpacityAnimation(LayerImpl* layer) {
   return layer->HasPotentiallyRunningOpacityAnimation();
 }
 
 static inline bool DoubleSided(Layer* layer) {
   return layer->double_sided();
 }
 
 static inline bool DoubleSided(LayerImpl* layer) {
   return layer->test_properties()->double_sided;
 }
@@ skipping 152 matching lines @@
   return false;
 }
 
 template <typename LayerType>
 bool AddEffectNodeIfNeeded(
     const DataForRecursion<LayerType>& data_from_ancestor,
     LayerType* layer,
     DataForRecursion<LayerType>* data_for_children) {
   const bool is_root = !layer->parent();
   const bool has_transparency = EffectiveOpacity(layer) != 1.f;
-  const bool has_animated_opacity = IsAnimatingOpacity(layer);
+  const bool has_potential_opacity_animation =
+      HasPotentialOpacityAnimation(layer);
   const bool should_create_render_surface = ShouldCreateRenderSurface(
       layer, data_from_ancestor.compound_transform_since_render_target,
       data_from_ancestor.axis_align_since_render_target);
   data_for_children->axis_align_since_render_target &=
       layer->AnimationsPreserveAxisAlignment();
 
-  bool requires_node = is_root || has_transparency || has_animated_opacity ||
+  bool requires_node = is_root || has_transparency ||
+                       has_potential_opacity_animation ||
                        should_create_render_surface;
 
   int parent_id = data_from_ancestor.effect_tree_parent;
 
   if (!requires_node) {
     layer->SetEffectTreeIndex(parent_id);
     data_for_children->effect_tree_parent = parent_id;
     data_for_children->compound_transform_since_render_target *=
         layer->transform();
     return false;
   }
 
   EffectNode node;
   node.owner_id = layer->id();
   node.data.opacity = layer->opacity();
   node.data.has_render_surface = should_create_render_surface;
   node.data.has_copy_request = layer->HasCopyRequest();
   node.data.has_background_filters = !layer->background_filters().IsEmpty();
-  node.data.has_animated_opacity = has_animated_opacity;
+  node.data.has_potential_opacity_animation = has_potential_opacity_animation;
   node.data.double_sided = DoubleSided(layer);
   node.data.subtree_hidden = HideLayerAndSubtree(layer);
+  node.data.is_currently_animating_opacity = layer->OpacityIsAnimating();
 
   if (!is_root) {
     // The effect node's transform id is used only when we create a render
     // surface. So, we can leave the default value when we don't create a render
     // surface.
     if (should_create_render_surface) {
       // In this case, we will create a transform node, so it's safe to use the
       // next available id from the transform tree as this effect node's
       // transform id.
       node.data.transform_id =
@@ skipping 423 matching lines @@
   if (SkColorGetA(color) != 255)
     color = SkColorSetA(color, 255);
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees, color);
 }
 
 }  // namespace cc