Rename OpacityTree to EffectTree

Effect tree is going to contain opacity as well as other render effects.
Change the name as a first step.

BUG=521717
R=enne
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1284103007

Cr-Commit-Position: refs/heads/master@{#343936}

11 files changed, 79 insertions, 83 deletions

diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index 77994e3..4f7eeba 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -51,7 +51,7 @@ Layer::Layer(const LayerSettings& settings)
       scroll_clip_layer_id_(INVALID_ID),
       num_descendants_that_draw_content_(0),
       transform_tree_index_(-1),
-      opacity_tree_index_(-1),
+      effect_tree_index_(-1),
       clip_tree_index_(-1),
       property_tree_sequence_number_(-1),
       num_layer_or_descendants_with_copy_request_(0),
@@ -1061,28 +1061,28 @@ int Layer::clip_tree_index() const {
   return clip_tree_index_;
 }
 
-void Layer::SetOpacityTreeIndex(int index) {
+void Layer::SetEffectTreeIndex(int index) {
   DCHECK(IsPropertyChangeAllowed());
-  if (opacity_tree_index_ == index)
+  if (effect_tree_index_ == index)
     return;
-  opacity_tree_index_ = index;
+  effect_tree_index_ = index;
   SetNeedsPushProperties();
 }
 
-int Layer::opacity_tree_index() const {
+int Layer::effect_tree_index() const {
   if (!layer_tree_host_ ||
       layer_tree_host_->property_trees()->sequence_number !=
           property_tree_sequence_number_) {
     return -1;
   }
-  return opacity_tree_index_;
+  return effect_tree_index_;
 }
 
 void Layer::InvalidatePropertyTreesIndices() {
   int invalid_property_tree_index = -1;
   SetTransformTreeIndex(invalid_property_tree_index);
   SetClipTreeIndex(invalid_property_tree_index);
-  SetOpacityTreeIndex(invalid_property_tree_index);
+  SetEffectTreeIndex(invalid_property_tree_index);
 }
 
 void Layer::SetShouldFlattenTransform(bool should_flatten) {
@@ -1184,7 +1184,7 @@ void Layer::PushPropertiesTo(LayerImpl* layer) {
     layer->SetDebugInfo(TakeDebugInfo());
 
   layer->SetTransformTreeIndex(transform_tree_index());
-  layer->SetOpacityTreeIndex(opacity_tree_index());
+  layer->SetEffectTreeIndex(effect_tree_index());
   layer->SetClipTreeIndex(clip_tree_index());
   layer->set_offset_to_transform_parent(offset_to_transform_parent_);
   layer->SetDoubleSided(double_sided_);
@@ -1450,12 +1450,11 @@ void Layer::OnFilterAnimated(const FilterOperations& filters) {
 void Layer::OnOpacityAnimated(float opacity) {
   opacity_ = opacity;
   if (layer_tree_host_) {
-    if (OpacityNode* node =
-            layer_tree_host_->property_trees()->opacity_tree.Node(
-                opacity_tree_index())) {
+    if (EffectNode* node = layer_tree_host_->property_trees()->effect_tree.Node(
+            effect_tree_index())) {
       if (node->owner_id == id()) {
         node->data.opacity = opacity;
-        layer_tree_host_->property_trees()->opacity_tree.set_needs_update(true);
+        layer_tree_host_->property_trees()->effect_tree.set_needs_update(true);
       }
     }
   }
diff --git a/cc/layers/layer.h b/cc/layers/layer.h
index 7011058..f25954f 100644
--- a/cc/layers/layer.h
+++ b/cc/layers/layer.h
@@ -460,8 +460,8 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
   void SetClipTreeIndex(int index);
   int clip_tree_index() const;
 
-  void SetOpacityTreeIndex(int index);
-  int opacity_tree_index() const;
+  void SetEffectTreeIndex(int index);
+  int effect_tree_index() const;
 
   void set_offset_to_transform_parent(gfx::Vector2dF offset) {
     if (offset_to_transform_parent_ == offset)
@@ -704,7 +704,7 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
   int scroll_clip_layer_id_;
   int num_descendants_that_draw_content_;
   int transform_tree_index_;
-  int opacity_tree_index_;
+  int effect_tree_index_;
   int clip_tree_index_;
   int property_tree_sequence_number_;
   int num_layer_or_descendants_with_copy_request_;
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 379db37..699edfb 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -78,7 +78,7 @@ LayerImpl::LayerImpl(LayerTreeImpl* tree_impl,
       draw_blend_mode_(SkXfermode::kSrcOver_Mode),
       num_descendants_that_draw_content_(0),
       transform_tree_index_(-1),
-      opacity_tree_index_(-1),
+      effect_tree_index_(-1),
       clip_tree_index_(-1),
       draw_depth_(0.f),
       needs_push_properties_(false),
@@ -254,8 +254,8 @@ void LayerImpl::SetClipTreeIndex(int index) {
   SetNeedsPushProperties();
 }
 
-void LayerImpl::SetOpacityTreeIndex(int index) {
-  opacity_tree_index_ = index;
+void LayerImpl::SetEffectTreeIndex(int index) {
+  effect_tree_index_ = index;
   SetNeedsPushProperties();
 }
 
@@ -589,7 +589,7 @@ void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
 
   layer->SetTransformTreeIndex(transform_tree_index_);
   layer->SetClipTreeIndex(clip_tree_index_);
-  layer->SetOpacityTreeIndex(opacity_tree_index_);
+  layer->SetEffectTreeIndex(effect_tree_index_);
   layer->set_offset_to_transform_parent(offset_to_transform_parent_);
 
   LayerImpl* scroll_parent = nullptr;
@@ -850,10 +850,9 @@ void LayerImpl::UpdatePropertyTreeTransformIsAnimated(bool is_animated) {
 }
 
 void LayerImpl::UpdatePropertyTreeOpacity() {
-  if (opacity_tree_index_ != -1) {
-    OpacityTree& opacity_tree =
-        layer_tree_impl()->property_trees()->opacity_tree;
-    OpacityNode* node = opacity_tree.Node(opacity_tree_index_);
+  if (effect_tree_index_ != -1) {
+    EffectTree& effect_tree = layer_tree_impl()->property_trees()->effect_tree;
+    EffectNode* node = effect_tree.Node(effect_tree_index_);
     // A LayerImpl's own current state is insufficient for determining whether
     // it owns an OpacityNode, since this depends on the state of the
     // corresponding Layer at the time of the last commit. For example, an
@@ -862,7 +861,7 @@ void LayerImpl::UpdatePropertyTreeOpacity() {
     if (node->owner_id != id())
       return;
     node->data.opacity = opacity_;
-    opacity_tree.set_needs_update(true);
+    effect_tree.set_needs_update(true);
   }
 }
 
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index 5601fb3..d5d9261 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -57,7 +57,7 @@ class LayerTreeHostImpl;
 class LayerTreeImpl;
 class MicroBenchmarkImpl;
 class Occlusion;
-class OpacityTree;
+class EffectTree;
 class PrioritizedTile;
 class RenderPass;
 class RenderPassId;
@@ -162,8 +162,8 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   void SetClipTreeIndex(int index);
   int clip_tree_index() const { return clip_tree_index_; }
 
-  void SetOpacityTreeIndex(int index);
-  int opacity_tree_index() const { return opacity_tree_index_; }
+  void SetEffectTreeIndex(int index);
+  int effect_tree_index() const { return effect_tree_index_; }
 
   void set_offset_to_transform_parent(const gfx::Vector2dF& offset) {
     offset_to_transform_parent_ = offset;
@@ -821,7 +821,7 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   gfx::Rect visible_rect_from_property_trees_;
   gfx::Rect clip_rect_in_target_space_from_property_trees_;
   int transform_tree_index_;
-  int opacity_tree_index_;
+  int effect_tree_index_;
   int clip_tree_index_;
 
   // The global depth value of the center of the layer. This value is used
diff --git a/cc/trees/draw_property_utils.cc b/cc/trees/draw_property_utils.cc
index 6906239..f8c6008 100644
--- a/cc/trees/draw_property_utils.cc
+++ b/cc/trees/draw_property_utils.cc
@@ -543,12 +543,12 @@ void ComputeTransforms(TransformTree* transform_tree) {
   transform_tree->set_needs_update(false);
 }
 
-void ComputeOpacities(OpacityTree* opacity_tree) {
-  if (!opacity_tree->needs_update())
+void ComputeOpacities(EffectTree* effect_tree) {
+  if (!effect_tree->needs_update())
     return;
-  for (int i = 1; i < static_cast<int>(opacity_tree->size()); ++i)
-    opacity_tree->UpdateOpacities(i);
-  opacity_tree->set_needs_update(false);
+  for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i)
+    effect_tree->UpdateOpacities(i);
+  effect_tree->set_needs_update(false);
 }
 
 template <typename LayerType>
@@ -560,7 +560,7 @@ void ComputeVisibleRectsUsingPropertyTreesInternal(
     property_trees->clip_tree.set_needs_update(true);
   ComputeTransforms(&property_trees->transform_tree);
   ComputeClips(&property_trees->clip_tree, property_trees->transform_tree);
-  ComputeOpacities(&property_trees->opacity_tree);
+  ComputeOpacities(&property_trees->effect_tree);
 
   const bool subtree_is_visible_from_ancestor = true;
   std::vector<LayerType*> visible_layer_list;
@@ -745,13 +745,13 @@ bool ScreenSpaceTransformIsAnimatingFromPropertyTrees(
 
 template <typename LayerType>
 float DrawOpacityFromPropertyTreesInternal(LayerType layer,
-                                           const OpacityTree& tree) {
+                                           const EffectTree& tree) {
   if (!layer->render_target())
     return 0.f;
 
-  const OpacityNode* target_node =
-      tree.Node(layer->render_target()->opacity_tree_index());
-  const OpacityNode* node = tree.Node(layer->opacity_tree_index());
+  const EffectNode* target_node =
+      tree.Node(layer->render_target()->effect_tree_index());
+  const EffectNode* node = tree.Node(layer->effect_tree_index());
   if (node == target_node)
     return 1.f;
 
@@ -763,13 +763,12 @@ float DrawOpacityFromPropertyTreesInternal(LayerType layer,
   return draw_opacity;
 }
 
-float DrawOpacityFromPropertyTrees(const Layer* layer,
-                                   const OpacityTree& tree) {
+float DrawOpacityFromPropertyTrees(const Layer* layer, const EffectTree& tree) {
   return DrawOpacityFromPropertyTreesInternal(layer, tree);
 }
 
 float DrawOpacityFromPropertyTrees(const LayerImpl* layer,
-                                   const OpacityTree& tree) {
+                                   const EffectTree& tree) {
   return DrawOpacityFromPropertyTreesInternal(layer, tree);
 }
 
@@ -784,10 +783,10 @@ bool CanUseLcdTextFromPropertyTrees(const LayerImpl* layer,
   if (!layer->contents_opaque())
     return false;
   DCHECK(!property_trees->transform_tree.needs_update());
-  DCHECK(!property_trees->opacity_tree.needs_update());
+  DCHECK(!property_trees->effect_tree.needs_update());
 
-  const OpacityNode* opacity_node =
-      property_trees->opacity_tree.Node(layer->opacity_tree_index());
+  const EffectNode* opacity_node =
+      property_trees->effect_tree.Node(layer->effect_tree_index());
   if (opacity_node->data.screen_space_opacity != 1.f)
     return false;
   const TransformNode* transform_node =
diff --git a/cc/trees/draw_property_utils.h b/cc/trees/draw_property_utils.h
index cb47e5c..971fe10 100644
--- a/cc/trees/draw_property_utils.h
+++ b/cc/trees/draw_property_utils.h
@@ -19,7 +19,7 @@ class ClipTree;
 class Layer;
 class LayerImpl;
 class RenderSurfaceImpl;
-class OpacityTree;
+class EffectTree;
 class TransformTree;
 class PropertyTrees;
 
@@ -35,7 +35,7 @@ ComputeClips(ClipTree* clip_tree, const TransformTree& transform_tree);
 void CC_EXPORT ComputeTransforms(TransformTree* transform_tree);
 
 // Computes screen space opacity for every node in the opacity tree.
-void CC_EXPORT ComputeOpacities(OpacityTree* opacity_tree);
+void CC_EXPORT ComputeOpacities(EffectTree* effect_tree);
 
 // Computes the visible content rect for every layer under |root_layer|. The
 // visible content rect is the clipped content space rect that will be used for
@@ -109,11 +109,11 @@ bool CC_EXPORT
 ScreenSpaceTransformIsAnimatingFromPropertyTrees(const LayerImpl* layer,
                                                  const TransformTree& tree);
 
-float CC_EXPORT
-DrawOpacityFromPropertyTrees(const Layer* layer, const OpacityTree& tree);
+float CC_EXPORT DrawOpacityFromPropertyTrees(const Layer* layer,
+                                             const EffectTree& tree);
 
-float CC_EXPORT
-DrawOpacityFromPropertyTrees(const LayerImpl* layer, const OpacityTree& tree);
+float CC_EXPORT DrawOpacityFromPropertyTrees(const LayerImpl* layer,
+                                             const EffectTree& tree);
 
 bool CC_EXPORT
 CanUseLcdTextFromPropertyTrees(const LayerImpl* layer,
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index 0f07bf7..abf2146 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -2327,11 +2327,11 @@ void VerifyPropertyTreeValuesForLayer(LayerImpl* current_layer,
 
   const bool draw_opacities_match =
       current_layer->draw_opacity() ==
-      DrawOpacityFromPropertyTrees(current_layer, property_trees->opacity_tree);
+      DrawOpacityFromPropertyTrees(current_layer, property_trees->effect_tree);
   CHECK(draw_opacities_match)
       << "expected: " << current_layer->draw_opacity()
       << " actual: " << DrawOpacityFromPropertyTrees(
-                            current_layer, property_trees->opacity_tree);
+                            current_layer, property_trees->effect_tree);
 
   const bool can_use_lcd_text_match =
       CanUseLcdTextFromPropertyTrees(
diff --git a/cc/trees/property_tree.cc b/cc/trees/property_tree.cc
index 86adab4..cf845a1 100644
--- a/cc/trees/property_tree.cc
+++ b/cc/trees/property_tree.cc
@@ -49,7 +49,7 @@ void PropertyTree<T>::clear() {
 
 template class PropertyTree<TransformNode>;
 template class PropertyTree<ClipNode>;
-template class PropertyTree<OpacityNode>;
+template class PropertyTree<EffectNode>;
 
 TransformNodeData::TransformNodeData()
     : target_id(-1),
@@ -101,8 +101,7 @@ ClipNodeData::ClipNodeData()
       requires_tight_clip_rect(true),
       render_surface_is_clipped(false) {}
 
-OpacityNodeData::OpacityNodeData() : opacity(1.f), screen_space_opacity(1.f) {
-}
+EffectNodeData::EffectNodeData() : opacity(1.f), screen_space_opacity(1.f) {}
 
 void TransformTree::clear() {
   PropertyTree<TransformNode>::clear();
@@ -487,11 +486,11 @@ bool TransformTree::HasNodesAffectedByOuterViewportBoundsDelta() const {
   return !nodes_affected_by_outer_viewport_bounds_delta_.empty();
 }
 
-void OpacityTree::UpdateOpacities(int id) {
-  OpacityNode* node = Node(id);
+void EffectTree::UpdateOpacities(int id) {
+  EffectNode* node = Node(id);
   node->data.screen_space_opacity = node->data.opacity;
 
-  OpacityNode* parent_node = parent(node);
+  EffectNode* parent_node = parent(node);
   if (parent_node)
     node->data.screen_space_opacity *= parent_node->data.screen_space_opacity;
 }
diff --git a/cc/trees/property_tree.h b/cc/trees/property_tree.h
index d196af2..e3f00a7 100644
--- a/cc/trees/property_tree.h
+++ b/cc/trees/property_tree.h
@@ -150,14 +150,14 @@ struct CC_EXPORT ClipNodeData {
 
 typedef TreeNode<ClipNodeData> ClipNode;
 
-struct CC_EXPORT OpacityNodeData {
-  OpacityNodeData();
+struct CC_EXPORT EffectNodeData {
+  EffectNodeData();
 
   float opacity;
   float screen_space_opacity;
 };
 
-typedef TreeNode<OpacityNodeData> OpacityNode;
+typedef TreeNode<EffectNodeData> EffectNode;
 
 template <typename T>
 class CC_EXPORT PropertyTree {
@@ -316,7 +316,7 @@ class CC_EXPORT TransformTree final : public PropertyTree<TransformNode> {
 
 class CC_EXPORT ClipTree final : public PropertyTree<ClipNode> {};
 
-class CC_EXPORT OpacityTree final : public PropertyTree<OpacityNode> {
+class CC_EXPORT EffectTree final : public PropertyTree<EffectNode> {
  public:
   void UpdateOpacities(int id);
 };
@@ -326,7 +326,7 @@ class CC_EXPORT PropertyTrees final {
   PropertyTrees();
 
   TransformTree transform_tree;
-  OpacityTree opacity_tree;
+  EffectTree effect_tree;
   ClipTree clip_tree;
   bool needs_rebuild;
   int sequence_number;
diff --git a/cc/trees/property_tree_builder.cc b/cc/trees/property_tree_builder.cc
index d69fcba..ae338f4 100644
--- a/cc/trees/property_tree_builder.cc
+++ b/cc/trees/property_tree_builder.cc
@@ -24,12 +24,12 @@ template <typename LayerType>
 struct DataForRecursion {
   TransformTree* transform_tree;
   ClipTree* clip_tree;
-  OpacityTree* opacity_tree;
+  EffectTree* effect_tree;
   LayerType* transform_tree_parent;
   LayerType* transform_fixed_parent;
   LayerType* render_target;
   int clip_tree_parent;
-  int opacity_tree_parent;
+  int effect_tree_parent;
   const LayerType* page_scale_layer;
   const LayerType* inner_viewport_scroll_layer;
   const LayerType* outer_viewport_scroll_layer;
@@ -357,7 +357,7 @@ bool IsAnimatingOpacity(LayerImpl* layer) {
 }
 
 template <typename LayerType>
-void AddOpacityNodeIfNeeded(
+void AddEffectNodeIfNeeded(
     const DataForRecursion<LayerType>& data_from_ancestor,
     LayerType* layer,
     DataForRecursion<LayerType>* data_for_children) {
@@ -366,25 +366,25 @@ void AddOpacityNodeIfNeeded(
   const bool has_animated_opacity = IsAnimatingOpacity(layer);
   bool requires_node = is_root || has_transparency || has_animated_opacity;
 
-  int parent_id = data_from_ancestor.opacity_tree_parent;
+  int parent_id = data_from_ancestor.effect_tree_parent;
 
   if (!requires_node) {
-    layer->SetOpacityTreeIndex(parent_id);
-    data_for_children->opacity_tree_parent = parent_id;
+    layer->SetEffectTreeIndex(parent_id);
+    data_for_children->effect_tree_parent = parent_id;
     return;
   }
 
-  OpacityNode node;
+  EffectNode node;
   node.owner_id = layer->id();
   node.data.opacity = layer->opacity();
   node.data.screen_space_opacity = layer->opacity();
   if (!is_root)
     node.data.screen_space_opacity *=
-        data_from_ancestor.opacity_tree->Node(parent_id)
+        data_from_ancestor.effect_tree->Node(parent_id)
             ->data.screen_space_opacity;
-  data_for_children->opacity_tree_parent =
-      data_for_children->opacity_tree->Insert(node, parent_id);
-  layer->SetOpacityTreeIndex(data_for_children->opacity_tree_parent);
+  data_for_children->effect_tree_parent =
+      data_for_children->effect_tree->Insert(node, parent_id);
+  layer->SetEffectTreeIndex(data_for_children->effect_tree_parent);
 }
 
 template <typename LayerType>
@@ -405,8 +405,8 @@ void BuildPropertyTreesInternal(
   AddClipNodeIfNeeded(data_from_parent, layer, created_transform_node,
                       &data_for_children);
 
-  if (data_from_parent.opacity_tree)
-    AddOpacityNodeIfNeeded(data_from_parent, layer, &data_for_children);
+  if (data_from_parent.effect_tree)
+    AddEffectNodeIfNeeded(data_from_parent, layer, &data_for_children);
 
   if (layer == data_from_parent.page_scale_layer)
     data_for_children.in_subtree_of_page_scale_layer = true;
@@ -454,12 +454,12 @@ void BuildPropertyTreesTopLevelInternal(
   DataForRecursion<LayerType> data_for_recursion;
   data_for_recursion.transform_tree = &property_trees->transform_tree;
   data_for_recursion.clip_tree = &property_trees->clip_tree;
-  data_for_recursion.opacity_tree = &property_trees->opacity_tree;
+  data_for_recursion.effect_tree = &property_trees->effect_tree;
   data_for_recursion.transform_tree_parent = nullptr;
   data_for_recursion.transform_fixed_parent = nullptr;
   data_for_recursion.render_target = root_layer;
   data_for_recursion.clip_tree_parent = 0;
-  data_for_recursion.opacity_tree_parent = -1;
+  data_for_recursion.effect_tree_parent = -1;
   data_for_recursion.page_scale_layer = page_scale_layer;
   data_for_recursion.inner_viewport_scroll_layer = inner_viewport_scroll_layer;
   data_for_recursion.outer_viewport_scroll_layer = outer_viewport_scroll_layer;
@@ -474,7 +474,7 @@ void BuildPropertyTreesTopLevelInternal(
 
   data_for_recursion.transform_tree->clear();
   data_for_recursion.clip_tree->clear();
-  data_for_recursion.opacity_tree->clear();
+  data_for_recursion.effect_tree->clear();
   data_for_recursion.sequence_number = property_trees->sequence_number;
 
   ClipNode root_clip;
@@ -490,7 +490,7 @@ void BuildPropertyTreesTopLevelInternal(
   // building.
   property_trees->transform_tree.set_needs_update(false);
   property_trees->clip_tree.set_needs_update(true);
-  property_trees->opacity_tree.set_needs_update(false);
+  property_trees->effect_tree.set_needs_update(false);
 }
 
 void PropertyTreeBuilder::BuildPropertyTrees(
diff --git a/cc/trees/property_tree_unittest.cc b/cc/trees/property_tree_unittest.cc
index 8497dca..e72a9ad 100644
--- a/cc/trees/property_tree_unittest.cc
+++ b/cc/trees/property_tree_unittest.cc
@@ -529,10 +529,10 @@ TEST(PropertyTreeTest, FlatteningWhenDestinationHasOnlyFlatAncestors) {
 TEST(PropertyTreeTest, ScreenSpaceOpacityUpdateTest) {
   // This tests that screen space opacity is updated for the subtree when
   // opacity of a node changes.
-  OpacityTree tree;
+  EffectTree tree;
 
-  int parent = tree.Insert(OpacityNode(), 0);
-  int child = tree.Insert(OpacityNode(), parent);
+  int parent = tree.Insert(EffectNode(), 0);
+  int child = tree.Insert(EffectNode(), parent);
 
   EXPECT_EQ(tree.Node(child)->data.screen_space_opacity, 1.f);
   tree.Node(parent)->data.opacity = 0.5f;