Create RenderSurface on Effect Tree

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"
@@ skipping 27 matching lines @@
   const LayerType* inner_viewport_scroll_layer;
   const LayerType* outer_viewport_scroll_layer;
   float page_scale_factor;
   bool in_subtree_of_page_scale_layer;
   bool affected_by_inner_viewport_bounds_delta;
   bool affected_by_outer_viewport_bounds_delta;
   bool should_flatten;
   bool target_is_clipped;
   const gfx::Transform* device_transform;
   gfx::Vector2dF scroll_compensation_adjustment;
+  gfx::Transform compound_transform_since_render_target;
+  bool axis_align_since_render_target;
   int sequence_number;
 };
 
 template <typename LayerType>
 static LayerType* GetTransformParent(const DataForRecursion<LayerType>& data,
                                      LayerType* layer) {
   return layer->position_constraint().is_fixed_position()
              ? data.transform_fixed_parent
              : data.transform_tree_parent;
 }
 
 template <typename LayerType>
 static ClipNode* GetClipParent(const DataForRecursion<LayerType>& data,
                                LayerType* layer) {
   const bool inherits_clip = !layer->parent() || !layer->clip_parent();
   const int id = inherits_clip ? data.clip_tree_parent
                                : layer->clip_parent()->clip_tree_index();
   return data.clip_tree->Node(id);
 }
 
 template <typename LayerType>
 static bool AppliesClip(LayerType* layer,
                         const DataForRecursion<LayerType>& data,
+                        bool created_render_surface,
                         bool is_clipped) {
-  const bool render_surface_applies_clip =
-      layer->has_render_surface() && is_clipped;
+  const bool render_surface_applies_clip = created_render_surface && is_clipped;
   const bool render_surface_may_grow_due_to_clip_children =
-      layer->has_render_surface() && layer->num_unclipped_descendants() > 0;
+      created_render_surface && layer->num_unclipped_descendants() > 0;
 
   if (layer->masks_to_bounds() || layer->mask_layer() ||
       render_surface_may_grow_due_to_clip_children)
     return true;
 
   if (!render_surface_applies_clip)
     return false;
 
   return true;
 }
@@ skipping 13 matching lines @@
   int parent_id = parent->id;
 
   bool is_root = !layer->parent();
 
   // Whether we have an ancestor clip that we might need to apply.
   bool ancestor_clips_subtree = is_root || parent->data.layers_are_clipped;
 
   bool layers_are_clipped = false;
   bool has_unclipped_surface = false;
 
-  if (layer->has_render_surface()) {
+  if (created_render_surface) {
     // Clips can usually be applied to a surface's descendants simply by
     // clipping the surface (or applied implicitly by the surface's bounds).
     // However, if the surface has unclipped descendants (layers that aren't
     // affected by the ancestor clip), we cannot clip the surface itself, and
     // must instead apply clips to the clipped descendants.
     if (ancestor_clips_subtree && layer->num_unclipped_descendants() > 0) {
       layers_are_clipped = true;
     } else if (!ancestor_clips_subtree) {
       // When there are no ancestor clips that need to be applied to a render
       // surface, we reset clipping state. The surface might contribute a clip
@@ skipping 18 matching lines @@
   if (layer_clips_subtree)
     layers_are_clipped = true;
 
   // Without surfaces, all non-viewport clips have to be applied using layer
   // clipping.
   bool layers_are_clipped_when_surfaces_disabled =
       layer_clips_subtree ||
       parent->data.layers_are_clipped_when_surfaces_disabled;
 
   bool applies_clip =
-      AppliesClip(layer, data_from_ancestor, ancestor_clips_subtree);
+      AppliesClip(layer, data_from_ancestor, created_render_surface,
+                  ancestor_clips_subtree);
   bool parent_applies_clip = !parent->data.resets_clip;
 
   // When we have an unclipped surface, all ancestor clips no longer apply.
   // However, if our parent already clears ancestor clips and applies no clip of
   // its own, there aren't any ancestor clips that need clearing.
   bool needs_to_clear_ancestor_clips =
       has_unclipped_surface && parent_applies_clip;
   bool requires_node = applies_clip || needs_to_clear_ancestor_clips;
 
   if (!requires_node) {
@@ skipping 14 matching lines @@
     node.data.transform_id = transform_parent->transform_tree_index();
     node.data.target_id =
         data_for_children->effect_tree->Node(data_for_children->render_target)
             ->data.transform_id;
     node.owner_id = layer->id();
 
     if (ancestor_clips_subtree || layer_clips_subtree) {
       // Surfaces reset the rect used for layer clipping. At other nodes, layer
       // clipping state from ancestors must continue to get propagated.
       node.data.layer_clipping_uses_only_local_clip =
-          layer->has_render_surface() || !ancestor_clips_subtree;
+          created_render_surface || !ancestor_clips_subtree;
     } else {
       // Otherwise, we're either unclipped, or exist only in order to apply our
       // parent's clips in our space.
       node.data.layer_clipping_uses_only_local_clip = false;
     }
 
     node.data.applies_local_clip = layer_clips_subtree;
     node.data.resets_clip = has_unclipped_surface;
     node.data.target_is_clipped = data_for_children->target_is_clipped;
     node.data.layers_are_clipped = layers_are_clipped;
     node.data.layers_are_clipped_when_surfaces_disabled =
         layers_are_clipped_when_surfaces_disabled;
 
     data_for_children->clip_tree_parent =
         data_for_children->clip_tree->Insert(node, parent_id);
   }
 
   layer->SetClipTreeIndex(data_for_children->clip_tree_parent);
-
   // TODO(awoloszyn): Right now when we hit a node with a replica, we reset the
   // clip for all children since we may need to draw. We need to figure out a
   // better way, since we will need both the clipped and unclipped versions.
 }
 
 template <typename LayerType>
 bool AddTransformNodeIfNeeded(
     const DataForRecursion<LayerType>& data_from_ancestor,
     LayerType* layer,
     bool created_render_surface,
     DataForRecursion<LayerType>* data_for_children) {
   const bool is_root = !layer->parent();
   const bool is_page_scale_layer = layer == data_from_ancestor.page_scale_layer;
   const bool is_scrollable = layer->scrollable();
   const bool is_fixed = layer->position_constraint().is_fixed_position();
 
   const bool has_significant_transform =
       !layer->transform().IsIdentityOr2DTranslation();
 
   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_surface = layer->has_render_surface();
+  const bool has_surface = created_render_surface;
 
   bool requires_node = is_root || is_scrollable || has_significant_transform ||
                        has_any_transform_animation || has_surface || is_fixed ||
                        is_page_scale_layer;
 
   LayerType* transform_parent = GetTransformParent(data_from_ancestor, layer);
   DCHECK(is_root || transform_parent);
 
   int parent_index = kRootPropertyTreeNodeId;
   if (transform_parent)
@@ skipping 172 matching lines @@
 bool IsAnimatingOpacity(Layer* layer) {
   return layer->HasPotentiallyRunningOpacityAnimation() ||
          layer->OpacityCanAnimateOnImplThread();
 }
 
 bool IsAnimatingOpacity(LayerImpl* layer) {
   return layer->HasPotentiallyRunningOpacityAnimation();
 }
 
 template <typename LayerType>
+static inline bool LayerIsInExisting3DRenderingContext(LayerType* layer) {
+  return layer->Is3dSorted() && layer->parent() &&
+         layer->parent()->Is3dSorted() &&
+         (layer->parent()->sorting_context_id() == layer->sorting_context_id());
+}
+
+template <typename LayerType>
+bool ShouldCreateRenderSurface(LayerType* layer,
+                               gfx::Transform current_transform,
+                               bool axis_aligned,
+                               bool* child_axis_alignment) {
+  *child_axis_alignment =

[enne (OOO), 2015/12/02 21:59:51]

This doesn't seem like it fits in this function.  Can it just get calculated by
the caller, since it doesn't get used here?

[weiliangc, 2015/12/04 00:54:54]

Moved out.

+      axis_aligned && layer->AnimationsPreserveAxisAlignment();
+  const bool preserves_2d_axis_alignment =
+      (current_transform * layer->transform()).Preserves2dAxisAlignment() &&
+      axis_aligned && layer->AnimationsPreserveAxisAlignment();
+  const bool is_root = !layer->parent();
+  if (is_root)
+    return true;
+
+  // If the layer uses a mask and the layer is not a replica layer.
+  // TODO(weiliangc): After slimming paint there won't be replica layers.

[enne (OOO), 2015/12/02 21:59:51]

Such hope!

[weiliangc, 2015/12/04 00:54:54]

It's a TODO now. TODOs are never wrong!

+  if (layer->mask_layer() && layer->parent()->replica_layer() != layer) {
+    return true;
+  }
+
+  // If the layer has a reflection.
+  if (layer->replica_layer()) {
+    return true;
+  }
+
+  // If the layer uses a CSS filter.
+  if (!layer->filters().IsEmpty() || !layer->background_filters().IsEmpty()) {
+    return true;
+  }
+
+  // If the layer will use a CSS filter.  In this case, the animation
+  // will start and add a filter to this layer, so it needs a surface.
+  if (layer->HasPotentiallyRunningFilterAnimation()) {
+    return true;
+  }
+
+  int num_descendants_that_draw_content =
+      layer->NumDescendantsThatDrawContent();
+
+  // If the layer flattens its subtree, but it is treated as a 3D object by its
+  // parent (i.e. parent participates in a 3D rendering context).
+  if (LayerIsInExisting3DRenderingContext(layer) &&
+      layer->should_flatten_transform() &&
+      num_descendants_that_draw_content > 0) {
+    TRACE_EVENT_INSTANT0(
+        "cc", "PropertyTreeBuilder::ShouldCreateRenderSurface flattening",
+        TRACE_EVENT_SCOPE_THREAD);
+    return true;
+  }
+
+  // If the layer has blending.
+  // TODO(rosca): this is temporary, until blending is implemented for other
+  // types of quads than RenderPassDrawQuad. Layers having descendants that draw
+  // content will still create a separate rendering surface.
+  if (!layer->uses_default_blend_mode()) {
+    TRACE_EVENT_INSTANT0(
+        "cc", "PropertyTreeBuilder::ShouldCreateRenderSurface blending",
+        TRACE_EVENT_SCOPE_THREAD);
+    return true;
+  }
+  // If the layer clips its descendants but it is not axis-aligned with respect
+  // to its parent.
+  bool layer_clips_external_content =
+      LayerClipsSubtree(layer) || layer->HasDelegatedContent();
+  if (layer_clips_external_content && !preserves_2d_axis_alignment &&
+      num_descendants_that_draw_content > 0) {
+    TRACE_EVENT_INSTANT0(
+        "cc", "PropertyTreeBuilder::ShouldCreateRenderSurface clipping",
+        TRACE_EVENT_SCOPE_THREAD);
+    return true;
+  }
+
+  // If the layer has some translucency and does not have a preserves-3d
+  // transform style.  This condition only needs a render surface if two or more
+  // layers in the subtree overlap. But checking layer overlaps is unnecessarily
+  // costly so instead we conservatively create a surface whenever at least two
+  // layers draw content for this subtree.
+  bool at_least_two_layers_in_subtree_draw_content =
+      num_descendants_that_draw_content > 0 &&
+      (layer->DrawsContent() || num_descendants_that_draw_content > 1);
+
+  if (layer->opacity() != 1.f && layer->should_flatten_transform() &&
+      at_least_two_layers_in_subtree_draw_content) {
+    TRACE_EVENT_INSTANT0(
+        "cc", "PropertyTreeBuilder::ShouldCreateRenderSurface opacity",
+        TRACE_EVENT_SCOPE_THREAD);
+    DCHECK(!is_root);
+    return true;
+  }
+  // If the layer has isolation.
+  // TODO(rosca): to be optimized - create separate rendering surface only when
+  // the blending descendants might have access to the content behind this layer
+  // (layer has transparent background or descendants overflow).
+  // https://code.google.com/p/chromium/issues/detail?id=301738
+  if (layer->is_root_for_isolated_group()) {
+    TRACE_EVENT_INSTANT0(
+        "cc", "PropertyTreeBuilder::ShouldCreateRenderSurface isolation",
+        TRACE_EVENT_SCOPE_THREAD);
+    return true;
+  }
+
+  // If we force it.
+  if (layer->force_render_surface())
+    return true;
+
+  // If we'll make a copy of the layer's contents.
+  if (layer->HasCopyRequest())
+    return true;
+
+  return false;
+}
+
+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_render_surface = layer->has_render_surface();
-  bool requires_node =
-      is_root || has_transparency || has_animated_opacity || has_render_surface;
+  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));
+
+  bool requires_node = is_root || has_transparency || has_animated_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 *=

[enne (OOO), 2015/12/02 21:59:51]

It's kind of sad to me we have to drag along this transform recursively.  Can
you ask the transform tree about it?  Alternatively, can we just simplify and
consider axis_align_since_render_target to just be if every transform along the
way preserves axis alignment independently?  Does the math work out on that?

[weiliangc, 2015/12/04 00:54:54]

Unfortunately Preserves2dAxisAlignment() is distributive, since A * B might ends
up have x or y perspective making it non-axis-aligned, when both A and B are
axis aligned.
(https://code.google.com/p/chromium/codesearch#chromium/src/ui/gfx/transform.c...)

Since it's building the transform tree at the same time, I'm not sure there is
nice value to ask directly. 

:(

[ajuma, 2015/12/04 14:38:38]

I wonder if we could get away with pessimistically treating any matrix along the
way that isn't a scale or translation as non-axis-aligned, just like
TransformOperations::PreservesAxisAlignment does. In some situations that would
cause additional render surfaces, but probably those are rare in practice? On
the other hand, since it's a behavior change, it might best be left as an
optimization to be done in a separate CL.

[ajuma, 2015/12/04 15:17:01]

Hmm, it turns out we used to do something pessimistic before (checking if the
combined transform was a scale or translation rather than the more complicated
logic in gfx::Transform::Preserves2dAxisAlignment), and the additional surfaces
did in fact cause problems -- see http://crbug.com/258760 and
http://crrev.com/11576036. So I think we're stuck with needing to know the
combined transform.

+        layer->transform();
     return false;
   }
 
   EffectNode node;
   node.owner_id = layer->id();
   node.data.opacity = layer->opacity();
   node.data.screen_space_opacity = layer->opacity();
-  node.data.has_render_surface = has_render_surface;
+  node.data.has_render_surface = should_create_render_surface;
+
   if (!is_root) {
     // For every effect node, we create a transform node, so it's safe to use
     // the next available id from the transform tree as this effect node's
     // transform id.
     node.data.transform_id =
         data_from_ancestor.transform_tree->next_available_id();
     node.data.clip_id = data_from_ancestor.clip_tree_parent;
 
     node.data.screen_space_opacity *=
         data_from_ancestor.effect_tree->Node(parent_id)
             ->data.screen_space_opacity;
   } else {
     // Root render surface acts the unbounded and untransformed to draw content
     // into. Transform node created from root layer (includes device scale
     // factor) and clip node created from root layer (include viewports) applies
     // to root render surface's content, but not root render surface itself.
     node.data.transform_id = kRootPropertyTreeNodeId;
     node.data.clip_id = kRootPropertyTreeNodeId;
   }
   data_for_children->effect_tree_parent =
       data_for_children->effect_tree->Insert(node, parent_id);
   layer->SetEffectTreeIndex(data_for_children->effect_tree_parent);
-  return has_render_surface;
+  if (should_create_render_surface) {
+    data_for_children->compound_transform_since_render_target =
+        gfx::Transform();
+    data_for_children->axis_align_since_render_target = true;
+  }
+  return should_create_render_surface;
 }
 
 template <typename LayerType>
 void BuildPropertyTreesInternal(
     LayerType* layer,
     const DataForRecursion<LayerType>& data_from_parent) {
   layer->set_property_tree_sequence_number(data_from_parent.sequence_number);
   DataForRecursion<LayerType> data_for_children(data_from_parent);
 
   bool created_render_surface =
@@ skipping 77 matching lines @@
   data_for_recursion.in_subtree_of_page_scale_layer = false;
   data_for_recursion.affected_by_inner_viewport_bounds_delta = false;
   data_for_recursion.affected_by_outer_viewport_bounds_delta = false;
   data_for_recursion.should_flatten = false;
   data_for_recursion.target_is_clipped = false;
   data_for_recursion.device_transform = &device_transform;
 
   data_for_recursion.transform_tree->clear();
   data_for_recursion.clip_tree->clear();
   data_for_recursion.effect_tree->clear();
+  data_for_recursion.compound_transform_since_render_target = gfx::Transform();
+  data_for_recursion.axis_align_since_render_target = true;
   data_for_recursion.sequence_number = property_trees->sequence_number;
   data_for_recursion.transform_tree->set_device_scale_factor(
       device_scale_factor);
 
   ClipNode root_clip;
   root_clip.data.resets_clip = true;
   root_clip.data.applies_local_clip = true;
   root_clip.data.clip = gfx::RectF(viewport);
   root_clip.data.transform_id = kRootPropertyTreeNodeId;
   data_for_recursion.clip_tree_parent =
@@ skipping 35 matching lines @@
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
     PropertyTrees* property_trees) {
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, page_scale_factor, device_scale_factor,
       viewport, device_transform, property_trees);
 }
 
 }  // namespace cc