Set opacity and transform mutations directly on property tree for SPv2.

cc/trees/layer_tree_host.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_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1253 matching lines @@
                                             ElementListType list_type,
                                             const FilterOperations& filters) {
   Layer* layer = LayerByElementId(element_id);
   DCHECK(layer);
   layer->OnFilterAnimated(filters);
 }
 
 void LayerTreeHost::SetElementOpacityMutated(ElementId element_id,
                                              ElementListType list_type,
                                              float opacity) {
+  DCHECK_GE(opacity, 0.f);
+  DCHECK_LE(opacity, 1.f);
+
+  if (settings_.use_layer_lists) {
+    // TODO(wkorman): Do we need to do the update-node-from-owning-layer-id

[wkorman, 2017/05/11 18:19:14]

Seeking your input here. I'm not sure how to think about the calls to
UpdateNodeFromOwningLayerId() in the SPv1 code path for both this method and the
one below. See callers of:

https://cs.chromium.org/chromium/src/cc/trees/property_tree.h?sq=package:chro...

Aside from these two methods it's also called in many other Layer methods. I'll
see whether any tests fail.

Are we planning to remove owning layer id for effect/transform nodes? Should we
still execute the owning node logic in both of these methods in the SPv2 code
path? Can we retrieve the owning layer node by walking up the respective trees
in some manner rather than using layer id?

[chrishtr, 2017/05/11 19:52:46]

Yes, we should remove the owning node logic and map. See for example
https://codereview.chromium.org/2866733002 (not ready for review yet, still has
bugs).

+    // below?
+    property_trees_.effect_tree.OnOpacityAnimated(element_id, opacity);
+    return;
+  }
+
   Layer* layer = LayerByElementId(element_id);
   DCHECK(layer);
-  DCHECK_GE(opacity, 0.f);
-  DCHECK_LE(opacity, 1.f);
   layer->OnOpacityAnimated(opacity);
 
   if (EffectNode* node =
           property_trees_.effect_tree.UpdateNodeFromOwningLayerId(
               layer->id())) {
     DCHECK_EQ(layer->effect_tree_index(), node->id);
     if (node->opacity == opacity)
       return;
 
     node->opacity = opacity;
     property_trees_.effect_tree.set_needs_update(true);
   }
 
   SetNeedsUpdateLayers();
 }
 
 void LayerTreeHost::SetElementTransformMutated(
     ElementId element_id,
     ElementListType list_type,
     const gfx::Transform& transform) {
+  if (settings_.use_layer_lists) {
+    // TODO(wkorman): Do we need to do the update-node-from-owning-layer-id
+    // below?
+    property_trees_.transform_tree.OnTransformAnimated(element_id, transform);
+    return;
+  }
+
   Layer* layer = LayerByElementId(element_id);
   DCHECK(layer);
   layer->OnTransformAnimated(transform);
 
   if (TransformNode* node =
           property_trees_.transform_tree.UpdateNodeFromOwningLayerId(
               layer->id())) {
     DCHECK_EQ(layer->transform_tree_index(), node->id);
     if (node->local == transform)
       return;
@@ skipping 130 matching lines @@
 void LayerTreeHost::SetNeedsDisplayOnAllLayers() {
   for (auto* layer : *this)
     layer->SetNeedsDisplay();
 }
 
 void LayerTreeHost::SetHasCopyRequest(bool has_copy_request) {
   has_copy_request_ = has_copy_request;
 }
 
 }  // namespace cc