cc : Use effect node data to determine which opacity wins at commit.

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 466 matching lines @@
   ElementLayers& layers = element_layers_map_[layer->element_id()];
   if (!layer->scrollable())
     layers.main = nullptr;
   if (layer->scrollable())
     layers.scroll = nullptr;
 
   if (!layers.main && !layers.scroll)
     element_layers_map_.erase(layer->element_id());
 }
 
+void LayerTreeImpl::AddToOpacityAnimationsMap(int id, float opacity) {
+  opacity_animations_map_[id] = opacity;
+}
+
 LayerTreeImpl::ElementLayers LayerTreeImpl::GetMutableLayers(
     uint64_t element_id) {
   auto iter = element_layers_map_.find(element_id);
   if (iter == element_layers_map_.end())
     return ElementLayers();
 
   return iter->second;
 }
 
 LayerImpl* LayerTreeImpl::InnerViewportContainerLayer() const {
@@ skipping 58 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 (!root_layer())
     return;
+  for (auto& layer_id_to_opacity : opacity_animations_map_) {
+    if (LayerImpl* layer = LayerById(layer_id_to_opacity.first)) {

[ajuma, 2016/05/11 00:10:59]

We'll need a map from layer ids to node ids (which will eventually become a map
from stable node ids to node ids) so that we don't need to find the owning layer
here, but that can be done in a separate CL.

[jaydasika, 2016/05/11 01:00:54]

Acknowledged.

+      EffectNode* node =
+          property_trees_.effect_tree.Node(layer->effect_tree_index());
+      if (node->owner_id != layer->id() ||
+          !node->data.is_currently_animating_opacity)
+        continue;
+      DCHECK_EQ(layer->opacity(), layer_id_to_opacity.second);
+      node->data.opacity = layer_id_to_opacity.second;
+      property_trees_.effect_tree.set_needs_update(true);
+    }
+  }
+  opacity_animations_map_.clear();

[ajuma, 2016/05/11 00:11:00]

What kind of test coverage do we have for this logic right now? Are there tests
that fail if we don't update the value in the property tree node, or if we don't
clear the map?

[jaydasika, 2016/05/11 01:00:54]

There is only one unit test hitting this path :
LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations. I have added one
more.

   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))) {
     DidUpdatePageScale();
@@ skipping 1514 matching lines @@
 }
 
 void LayerTreeImpl::ResetAllChangeTracking(PropertyTrees::ResetFlags flag) {
   layers_that_should_push_properties_.clear();
   for (auto* layer : *this)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking(flag);
 }
 
 }  // namespace cc