cc: Derive draw opacity from property trees

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 <map>
 #include <set>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
 #include "cc/trees/layer_tree_host.h"
 #include "ui/gfx/geometry/point_f.h"
 
 namespace cc {
 
 class LayerTreeHost;
 
 namespace {
 
 struct DataForRecursion {
   TransformTree* transform_tree;
   ClipTree* clip_tree;
+  OpacityTree* opacity_tree;
   Layer* transform_tree_parent;
   Layer* transform_fixed_parent;
   Layer* render_target;
   int clip_tree_parent;
+  int opacity_tree_parent;
   gfx::Vector2dF offset_to_transform_tree_parent;
   gfx::Vector2dF offset_to_transform_fixed_parent;
   const Layer* page_scale_layer;
   float page_scale_factor;
   float device_scale_factor;
   bool in_subtree_of_page_scale_application_layer;
   const gfx::Transform* device_transform;
 };
 
 static Layer* GetTransformParent(const DataForRecursion& data, Layer* layer) {
@@ skipping 178 matching lines @@
   node->data.pre_local.Translate3d(-layer->transform_origin().x(),
                                    -layer->transform_origin().y(),
                                    -layer->transform_origin().z());
 
   node->data.needs_local_transform_update = true;
   data_from_ancestor.transform_tree->UpdateTransforms(node->id);
 
   layer->set_offset_to_transform_parent(gfx::Vector2dF());
 }
 
+void AddOpacityNodeIfNeeded(const DataForRecursion& data_from_ancestor,
+                            Layer* layer,
+                            DataForRecursion* data_for_children) {
+  const bool is_root = !layer->parent();
+  const bool has_transparency = layer->opacity() != 1.f;
+  const bool has_animated_opacity =
+      layer->layer_animation_controller()->IsAnimatingProperty(
+          Animation::OPACITY) ||
+      layer->OpacityCanAnimateOnImplThread();
+  bool requires_node = is_root || has_transparency || has_animated_opacity;
+
+  int parent_id = data_from_ancestor.opacity_tree_parent;
+
+  if (!requires_node) {
+    layer->set_opacity_tree_index(parent_id);
+    data_for_children->opacity_tree_parent = parent_id;
+    return;
+  }
+
+  OpacityNode node;
+  node.data = layer->opacity();
+  data_for_children->opacity_tree_parent =
+      data_for_children->opacity_tree->Insert(node, parent_id);
+  layer->set_opacity_tree_index(data_for_children->opacity_tree_parent);
+}
+
 void BuildPropertyTreesInternal(Layer* layer,
                                 const DataForRecursion& data_from_parent) {
   DataForRecursion data_for_children(data_from_parent);
   if (layer->render_surface())
     data_for_children.render_target = layer;
 
   AddTransformNodeIfNeeded(data_from_parent, layer, &data_for_children);
   AddClipNodeIfNeeded(data_from_parent, layer, &data_for_children);
 
+  if (data_from_parent.opacity_tree)
+    AddOpacityNodeIfNeeded(data_from_parent, layer, &data_for_children);
+
   if (layer == data_from_parent.page_scale_layer)
     data_for_children.in_subtree_of_page_scale_application_layer = true;
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     if (!layer->children()[i]->scroll_parent())
       BuildPropertyTreesInternal(layer->children()[i].get(), data_for_children);
   }
 
   if (layer->scroll_children()) {
     for (Layer* scroll_child : *layer->scroll_children()) {
       BuildPropertyTreesInternal(scroll_child, data_for_children);
     }
   }
 
   if (layer->has_replica())
     BuildPropertyTreesInternal(layer->replica_layer(), data_for_children);
 }
 
 }  // namespace
 
 void PropertyTreeBuilder::BuildPropertyTrees(
     Layer* root_layer,
     const Layer* page_scale_layer,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
     TransformTree* transform_tree,
-    ClipTree* clip_tree) {
+    ClipTree* clip_tree,
+    OpacityTree* opacity_tree) {
   DataForRecursion data_for_recursion;
   data_for_recursion.transform_tree = transform_tree;
   data_for_recursion.clip_tree = clip_tree;
+  data_for_recursion.opacity_tree = opacity_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.page_scale_layer = page_scale_layer;
   data_for_recursion.page_scale_factor = page_scale_factor;
   data_for_recursion.device_scale_factor = device_scale_factor;
   data_for_recursion.in_subtree_of_page_scale_application_layer = false;
   data_for_recursion.device_transform = &device_transform;
 
   ClipNode root_clip;
   root_clip.data.clip = viewport;
   root_clip.data.transform_id = 0;
   data_for_recursion.clip_tree_parent = clip_tree->Insert(root_clip, 0);
   BuildPropertyTreesInternal(root_layer, data_for_recursion);
 }
 
 }  // namespace cc