cc : Track ids for which active opacity always wins on property trees

cc/trees/property_tree.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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 1909 matching lines @@
 PropertyTrees::~PropertyTrees() {}
 
 bool PropertyTrees::operator==(const PropertyTrees& other) const {
   return transform_tree == other.transform_tree &&
          effect_tree == other.effect_tree && clip_tree == other.clip_tree &&
          scroll_tree == other.scroll_tree &&
          transform_id_to_index_map == other.transform_id_to_index_map &&
          effect_id_to_index_map == other.effect_id_to_index_map &&
          clip_id_to_index_map == other.clip_id_to_index_map &&
          scroll_id_to_index_map == other.scroll_id_to_index_map &&
+         always_use_active_tree_opacity_effect_ids ==
+             other.always_use_active_tree_opacity_effect_ids &&
          needs_rebuild == other.needs_rebuild && changed == other.changed &&
          full_tree_damaged == other.full_tree_damaged &&
          is_main_thread == other.is_main_thread &&
          is_active == other.is_active &&
          non_root_surfaces_enabled == other.non_root_surfaces_enabled &&
          sequence_number == other.sequence_number;
 }
 
 PropertyTrees& PropertyTrees::operator=(const PropertyTrees& from) {
   transform_tree = from.transform_tree;
   effect_tree = from.effect_tree;
   clip_tree = from.clip_tree;
   scroll_tree = from.scroll_tree;
   transform_id_to_index_map = from.transform_id_to_index_map;
   effect_id_to_index_map = from.effect_id_to_index_map;
+  always_use_active_tree_opacity_effect_ids =
+      from.always_use_active_tree_opacity_effect_ids;
   clip_id_to_index_map = from.clip_id_to_index_map;
   scroll_id_to_index_map = from.scroll_id_to_index_map;
   needs_rebuild = from.needs_rebuild;
   changed = from.changed;
   full_tree_damaged = from.full_tree_damaged;
   non_root_surfaces_enabled = from.non_root_surfaces_enabled;
   sequence_number = from.sequence_number;
   is_main_thread = from.is_main_thread;
   is_active = from.is_active;
   inner_viewport_container_bounds_delta_ =
@@ skipping 19 matching lines @@
   proto->set_needs_rebuild(needs_rebuild);
   proto->set_changed(changed);
   proto->set_full_tree_damaged(full_tree_damaged);
   proto->set_non_root_surfaces_enabled(non_root_surfaces_enabled);
   proto->set_is_main_thread(is_main_thread);
   proto->set_is_active(is_active);
 
   // TODO(khushalsagar): Consider using the sequence number to decide if
   // property trees need to be serialized again for a commit. See crbug/555370.
   proto->set_sequence_number(sequence_number);
+
+  for (auto i : always_use_active_tree_opacity_effect_ids)
+    proto->add_always_use_active_tree_opacity_effect_ids(i);
 }
 
 // static
 void PropertyTrees::FromProtobuf(const proto::PropertyTrees& proto) {
   transform_tree.FromProtobuf(proto.transform_tree(),
                               &transform_id_to_index_map);
   effect_tree.FromProtobuf(proto.effect_tree(), &effect_id_to_index_map);
   clip_tree.FromProtobuf(proto.clip_tree(), &clip_id_to_index_map);
   scroll_tree.FromProtobuf(proto.scroll_tree(), &scroll_id_to_index_map);
 
   needs_rebuild = proto.needs_rebuild();
   changed = proto.changed();
   full_tree_damaged = proto.full_tree_damaged();
   non_root_surfaces_enabled = proto.non_root_surfaces_enabled();
   sequence_number = proto.sequence_number();
   is_main_thread = proto.is_main_thread();
   is_active = proto.is_active();
 
   transform_tree.SetPropertyTrees(this);
   effect_tree.SetPropertyTrees(this);
   clip_tree.SetPropertyTrees(this);
   scroll_tree.SetPropertyTrees(this);
+  for (auto i : proto.always_use_active_tree_opacity_effect_ids())
+    always_use_active_tree_opacity_effect_ids.push_back(i);
 }
 
 void PropertyTrees::SetInnerViewportContainerBoundsDelta(
     gfx::Vector2dF bounds_delta) {
   if (inner_viewport_container_bounds_delta_ == bounds_delta)
     return;
 
   inner_viewport_container_bounds_delta_ = bounds_delta;
   transform_tree.UpdateInnerViewportContainerBoundsDelta();
 }
 
 void PropertyTrees::SetOuterViewportContainerBoundsDelta(
     gfx::Vector2dF bounds_delta) {
   if (outer_viewport_container_bounds_delta_ == bounds_delta)
     return;
 
   outer_viewport_container_bounds_delta_ = bounds_delta;
   transform_tree.UpdateOuterViewportContainerBoundsDelta();
 }
 
 void PropertyTrees::SetInnerViewportScrollBoundsDelta(
     gfx::Vector2dF bounds_delta) {
   inner_viewport_scroll_bounds_delta_ = bounds_delta;
 }
 
+void PropertyTrees::PushOpacityIfNeeded(PropertyTrees* target_tree) {
+  for (int id : target_tree->always_use_active_tree_opacity_effect_ids) {
+    if (effect_id_to_index_map.find(id) == effect_id_to_index_map.end())
+      continue;
+    EffectNode* source_effect_node =
+        effect_tree.Node(effect_id_to_index_map[id]);
+    EffectNode* target_effect_node =
+        target_tree->effect_tree.Node(target_tree->effect_id_to_index_map[id]);
+    target_effect_node->data.opacity = source_effect_node->data.opacity;
+    target_tree->effect_tree.set_needs_update(true);

[ajuma, 2016/05/18 13:53:48]

This should be conditional on the opacity value changing.

[jaydasika, 2016/05/19 00:27:09]

Done.

+  }
+}
+
 void PropertyTrees::UpdateChangeTracking() {
   for (int id = 1; id < static_cast<int>(effect_tree.size()); ++id) {
     EffectNode* node = effect_tree.Node(id);
     EffectNode* parent_node = effect_tree.parent(node);
     effect_tree.UpdateEffectChanged(node, parent_node);
   }
   for (int i = 1; i < static_cast<int>(transform_tree.size()); ++i) {
     TransformNode* node = transform_tree.Node(i);
     TransformNode* parent_node = transform_tree.parent(node);
     TransformNode* source_node = transform_tree.Node(node->data.source_node_id);
@@ skipping 57 matching lines @@
   value->EndDictionary();
 
   value->BeginDictionary("scroll_tree");
   scroll_tree.AsValueInto(value.get());
   value->EndDictionary();
 
   return value;
 }
 
 }  // namespace cc