compositor-worker: blink->cc plumbing

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 <stddef.h>
 
 #include <map>
 #include <set>
 
+#include "cc/animation/mutable_properties.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/layer_tree_host.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 
@@ skipping 193 matching lines @@
   const bool has_potentially_animated_transform =
       layer->HasPotentiallyRunningTransformAnimation();
 
   // A transform node is needed even for a finished animation, since differences
   // in the timing of animation state updates can mean that an animation that's
   // in the Finished state at tree-building time on the main thread is still in
   // the Running state right after commit on the compositor thread.
   const bool has_any_transform_animation =
       layer->HasAnyAnimationTargetingProperty(Animation::TRANSFORM);
 
+  const bool has_proxied_transform_related_property =
+      layer->mutable_properties() & MutableProperty::kTransformRelated;
+
   const bool has_surface = created_render_surface;
 
   // A transform node is needed to change the render target for subtree when
   // a scroll child's render target is different from the scroll parent's render
   // target.
   const bool scroll_child_has_different_target =
       layer->scroll_parent() &&
       layer->parent()->effect_tree_index() !=
           layer->scroll_parent()->effect_tree_index();
 
   bool requires_node = is_root || is_scrollable || has_significant_transform ||
                        has_any_transform_animation || has_surface || is_fixed ||
                        is_page_scale_layer || is_overscroll_elasticity_layer ||
+                       has_proxied_transform_related_property ||
                        scroll_child_has_different_target;
 
   LayerType* transform_parent = GetTransformParent(data_from_ancestor, layer);
   DCHECK(is_root || transform_parent);
 
   int parent_index = kRootPropertyTreeNodeId;
   if (transform_parent)
     parent_index = transform_parent->transform_tree_index();
 
   int source_index = parent_index;
@@ skipping 304 matching lines @@
 }
 
 template <typename LayerType>
 bool AddEffectNodeIfNeeded(
     const DataForRecursion<LayerType>& data_from_ancestor,
     LayerType* layer,
     DataForRecursion<LayerType>* data_for_children) {
   const bool is_root = !layer->parent();
   const bool has_transparency = layer->opacity() != 1.f;
   const bool has_animated_opacity = IsAnimatingOpacity(layer);
+  const bool has_proxied_opacity =
+      layer->mutable_properties() & MutableProperty::kOpacity;
   const bool should_create_render_surface = ShouldCreateRenderSurface(
       layer, data_from_ancestor.compound_transform_since_render_target,
       data_from_ancestor.axis_align_since_render_target);
   data_for_children->axis_align_since_render_target &=
       layer->AnimationsPreserveAxisAlignment();
 
   bool requires_node = is_root || has_transparency || has_animated_opacity ||
-                       should_create_render_surface;
+                       has_proxied_opacity || should_create_render_surface;
 
   int parent_id = data_from_ancestor.effect_tree_parent;
 
   if (!requires_node) {
     layer->SetEffectTreeIndex(parent_id);
     data_for_children->effect_tree_parent = parent_id;
     data_for_children->compound_transform_since_render_target *=
         layer->transform();
     return false;
   }
@@ skipping 227 matching lines @@
     const gfx::Transform& device_transform,
     PropertyTrees* property_trees) {
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees);
 }
 
 }  // namespace cc