Create RenderSurface on Effect Tree

cc/trees/layer_tree_host_common.cc

 // Copyright 2011 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/layer_tree_host_common.h"
 
 #include <algorithm>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 607 matching lines @@
     return false;
 
   // The opacity of a layer always applies to its children (either implicitly
   // via a render surface or explicitly if the parent preserves 3D), so the
   // entire subtree can be skipped if this layer is fully transparent.
   return !layer->opacity();
 }
 
 static inline void SavePaintPropertiesLayer(LayerImpl* layer) {}
 
-static bool SubtreeShouldRenderToSeparateSurface(
-    Layer* layer,
-    bool axis_aligned_with_respect_to_parent) {
-  //
-  // A layer and its descendants should render onto a new RenderSurfaceImpl if
-  // any of these rules hold:
-  //
-
-  // The root layer owns a render surface, but it never acts as a contributing
-  // surface to another render target. Compositor features that are applied via
-  // a contributing surface can not be applied to the root layer. In order to
-  // use these effects, another child of the root would need to be introduced
-  // in order to act as a contributing surface to the root layer's surface.
-  bool is_root = IsRootLayer(layer);
-
-  // If the layer uses a mask.
-  if (layer->mask_layer()) {
-    DCHECK(!is_root);
-    return true;
-  }
-
-  // If the layer has a reflection.
-  if (layer->replica_layer()) {
-    DCHECK(!is_root);
-    return true;
-  }
-
-  // If the layer uses a CSS filter.
-  if (!layer->filters().IsEmpty() || !layer->background_filters().IsEmpty()) {
-    DCHECK(!is_root);
-    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()) {
-    DCHECK(!is_root);
-    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",
-        "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface flattening",
-        TRACE_EVENT_SCOPE_THREAD);
-    DCHECK(!is_root);
-    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",
-        "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface blending",
-        TRACE_EVENT_SCOPE_THREAD);
-    DCHECK(!is_root);
-    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 && !axis_aligned_with_respect_to_parent &&
-      num_descendants_that_draw_content > 0) {
-    TRACE_EVENT_INSTANT0(
-        "cc",
-        "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface clipping",
-        TRACE_EVENT_SCOPE_THREAD);
-    DCHECK(!is_root);
-    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",
-        "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface opacity",
-        TRACE_EVENT_SCOPE_THREAD);
-    DCHECK(!is_root);
-    return true;
-  }
-
-  // The root layer should always have a render_surface.
-  if (is_root)
-    return true;
-
-  //
-  // These are allowed on the root surface, as they don't require the surface to
-  // be used as a contributing surface in order to apply correctly.
-  //
-
-  // 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",
-        "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface 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;
-}
-
 // This function returns a translation matrix that can be applied on a vector
 // that's in the layer's target surface coordinate, while the position offset is
 // specified in some ancestor layer's coordinate.
 gfx::Transform ComputeSizeDeltaCompensation(
     LayerImpl* layer,
     LayerImpl* container,
     const gfx::Vector2dF& position_offset) {
   gfx::Transform result_transform;
 
   // To apply a translate in the container's layer space,
@@ skipping 366 matching lines @@
       &layer_to_remove->render_surface()->layer_list(), 0);
   MarkLayerWithRenderSurfaceLayerListId(layer_to_remove, 0);
   render_surface_layer_list->pop_back();
   layer_to_remove->ClearRenderSurfaceLayerList();
 }
 
 struct PreCalculateMetaInformationRecursiveData {
   size_t num_unclipped_descendants;
   int num_layer_or_descendants_with_copy_request;
   int num_layer_or_descendants_with_input_handler;
+  int num_descendants_that_draw_content;
 
   PreCalculateMetaInformationRecursiveData()
       : num_unclipped_descendants(0),
         num_layer_or_descendants_with_copy_request(0),
-        num_layer_or_descendants_with_input_handler(0) {}
+        num_layer_or_descendants_with_input_handler(0),
+        num_descendants_that_draw_content(0) {}
 
   void Merge(const PreCalculateMetaInformationRecursiveData& data) {
     num_layer_or_descendants_with_copy_request +=
         data.num_layer_or_descendants_with_copy_request;
     num_layer_or_descendants_with_input_handler +=
         data.num_layer_or_descendants_with_input_handler;
     num_unclipped_descendants += data.num_unclipped_descendants;
+    num_descendants_that_draw_content += data.num_descendants_that_draw_content;
   }
 };
 
-static void ValidateRenderSurface(LayerImpl* layer) {
-  // This test verifies that there are no cases where a LayerImpl needs
-  // a render surface, but doesn't have one.
-  if (layer->render_surface())
-    return;
-
-  DCHECK(layer->filters().IsEmpty()) << "layer: " << layer->id();
-  DCHECK(layer->background_filters().IsEmpty()) << "layer: " << layer->id();
-  DCHECK(!layer->mask_layer()) << "layer: " << layer->id();
-  DCHECK(!layer->replica_layer()) << "layer: " << layer->id();
-  DCHECK(!IsRootLayer(layer)) << "layer: " << layer->id();
-  DCHECK(!layer->is_root_for_isolated_group()) << "layer: " << layer->id();
-  DCHECK(!layer->HasCopyRequest()) << "layer: " << layer->id();
-}
-
-static void ValidateRenderSurface(Layer* layer) {
-}
-
 static bool IsMetaInformationRecomputationNeeded(Layer* layer) {
   return layer->layer_tree_host()->needs_meta_info_recomputation();
 }
 
 static void UpdateMetaInformationSequenceNumber(Layer* root_layer) {
   root_layer->layer_tree_host()->IncrementMetaInformationSequenceNumber();
 }
 
 static void UpdateMetaInformationSequenceNumber(LayerImpl* root_layer) {
 }
 
 // Recursively walks the layer tree(if needed) to compute any information
 // that is needed before doing the main recursion.
 static void PreCalculateMetaInformationInternal(
     Layer* layer,
     PreCalculateMetaInformationRecursiveData* recursive_data) {
-  ValidateRenderSurface(layer);
-
   if (!IsMetaInformationRecomputationNeeded(layer)) {
     DCHECK(IsRootLayer(layer));
     return;
   }
 
   layer->set_sorted_for_recursion(false);
   layer->set_layer_or_descendant_is_drawn(false);
   layer->set_visited(false);
 
   if (!HasInvertibleOrAnimatedTransform(layer)) {
@@ skipping 31 matching lines @@
   layer->set_num_layer_or_descendant_with_copy_request(
       recursive_data->num_layer_or_descendants_with_copy_request);
 
   if (IsRootLayer(layer))
     layer->layer_tree_host()->SetNeedsMetaInfoRecomputation(false);
 }
 
 static void PreCalculateMetaInformationInternal(
     LayerImpl* layer,
     PreCalculateMetaInformationRecursiveData* recursive_data) {
-  ValidateRenderSurface(layer);
-
   layer->set_sorted_for_recursion(false);
   layer->draw_properties().has_child_with_a_scroll_parent = false;
   layer->set_layer_or_descendant_is_drawn(false);
   layer->set_visited(false);
 
   if (!HasInvertibleOrAnimatedTransform(layer)) {
     // Layers with singular transforms should not be drawn, the whole subtree
     // can be skipped.
     return;
   }
@@ skipping 26 matching lines @@
     recursive_data->num_layer_or_descendants_with_input_handler++;
 
   layer->draw_properties().num_unclipped_descendants =
       recursive_data->num_unclipped_descendants;
   layer->set_layer_or_descendant_has_input_handler(
       (recursive_data->num_layer_or_descendants_with_input_handler != 0));
   // TODO(enne): this should be synced from the main thread, so is only
   // for tests constructing layers on the compositor thread.
   layer->set_num_layer_or_descendant_with_copy_request(
       recursive_data->num_layer_or_descendants_with_copy_request);
+  layer->SetNumDescendantsThatDrawContent(
+      recursive_data->num_descendants_that_draw_content);
+
+  if (layer->DrawsContent())
+    recursive_data->num_descendants_that_draw_content++;
 }
 
 void LayerTreeHostCommon::PreCalculateMetaInformation(Layer* root_layer) {
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformationInternal(root_layer, &recursive_data);
 }
 
 void LayerTreeHostCommon::PreCalculateMetaInformationForTesting(
     LayerImpl* root_layer) {
   PreCalculateMetaInformationRecursiveData recursive_data;
@@ skipping 901 matching lines @@
       device_viewport_rect;
   data_for_recursion->maximum_animation_contents_scale = 0.f;
   data_for_recursion->starting_animation_contents_scale = 0.f;
   data_for_recursion->ancestor_is_animating_scale = false;
   data_for_recursion->ancestor_clips_subtree = true;
   data_for_recursion->in_subtree_of_page_scale_layer = false;
   data_for_recursion->subtree_can_use_lcd_text = inputs.can_use_lcd_text;
   data_for_recursion->subtree_is_visible_from_ancestor = true;
 }
 
-void LayerTreeHostCommon::UpdateRenderSurface(
-    Layer* layer,
-    bool can_render_to_separate_surface,
-    gfx::Transform* transform,
-    bool* draw_transform_is_axis_aligned) {
-  bool preserves_2d_axis_alignment =
-      transform->Preserves2dAxisAlignment() && *draw_transform_is_axis_aligned;
-  if (IsRootLayer(layer) || (can_render_to_separate_surface &&
-                             SubtreeShouldRenderToSeparateSurface(
-                                 layer, preserves_2d_axis_alignment))) {
-    // We reset the transform here so that any axis-changing transforms
-    // will now be relative to this RenderSurface.
-    transform->MakeIdentity();
-    *draw_transform_is_axis_aligned = true;
-    layer->SetHasRenderSurface(true);
-    return;
-  }
-  layer->SetHasRenderSurface(false);
-}
-
-void LayerTreeHostCommon::UpdateRenderSurfaces(
-    Layer* layer,
-    bool can_render_to_separate_surface,
-    const gfx::Transform& parent_transform,
-    bool draw_transform_is_axis_aligned) {
-  gfx::Transform transform_for_children = layer->transform();
-  transform_for_children *= parent_transform;
-  draw_transform_is_axis_aligned &= layer->AnimationsPreserveAxisAlignment();
-  UpdateRenderSurface(layer, can_render_to_separate_surface,
-                      &transform_for_children, &draw_transform_is_axis_aligned);
-
-  for (size_t i = 0; i < layer->children().size(); ++i) {
-    UpdateRenderSurfaces(layer->children()[i].get(),
-                         can_render_to_separate_surface, transform_for_children,
-                         draw_transform_is_axis_aligned);
-  }
-}
 
 static bool ApproximatelyEqual(const gfx::Rect& r1, const gfx::Rect& r2) {
   // TODO(vollick): This tolerance should be lower: crbug.com/471786
   static const int tolerance = 1;
 
   return std::abs(r1.x() - r2.x()) <= tolerance &&
          std::abs(r1.y() - r2.y()) <= tolerance &&
          std::abs(r1.right() - r2.right()) <= tolerance &&
          std::abs(r1.bottom() - r2.bottom()) <= tolerance;
 }
@@ skipping 78 matching lines @@
 }
 
 void VerifyPropertyTreeValuesForLayer(LayerImpl* current_layer,
                                       PropertyTrees* property_trees,
                                       bool layers_always_allowed_lcd_text,
                                       bool can_use_lcd_text) {
   DrawProperties draw_properties;
   ComputeLayerDrawPropertiesUsingPropertyTrees(
       current_layer, property_trees, layers_always_allowed_lcd_text,
       can_use_lcd_text, &draw_properties);
-
   const bool visible_rects_match = ApproximatelyEqual(
       current_layer->visible_layer_rect(), draw_properties.visible_layer_rect);
   CHECK(visible_rects_match)
       << "expected: " << current_layer->visible_layer_rect().ToString()
       << " actual: " << draw_properties.visible_layer_rect.ToString();
 
   const bool draw_transforms_match = ApproximatelyEqual(
       current_layer->draw_properties().target_space_transform,
       draw_properties.target_space_transform);
   CHECK(draw_transforms_match)
@@ skipping 61 matching lines @@
   if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_drawn)) {
     layer->draw_properties().render_target = nullptr;
     return;
   }
 
   bool render_to_separate_surface =
       IsRootLayer(layer) ||
       (can_render_to_separate_surface && layer->render_surface());
 
   if (render_to_separate_surface) {
-    DCHECK(layer->render_surface());
+    DCHECK(layer->render_surface()) << IsRootLayer(layer)
+                                    << can_render_to_separate_surface
+                                    << layer->has_render_surface();
     layer->draw_properties().render_target = layer;
 
     if (layer->mask_layer())
       layer->mask_layer()->draw_properties().render_target = layer;
 
     if (layer->replica_layer() && layer->replica_layer()->mask_layer())
       layer->replica_layer()->mask_layer()->draw_properties().render_target =
           layer;
 
   } else {
@@ skipping 290 matching lines @@
 }
 
 void CalculateDrawPropertiesAndVerify(
     LayerTreeHostCommon::CalcDrawPropsImplInputs* inputs,
     PropertyTreeOption property_tree_option) {
   inputs->render_surface_layer_list->clear();
 
   UpdateMetaInformationSequenceNumber(inputs->root_layer);
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformationInternal(inputs->root_layer, &recursive_data);
-
   const bool should_measure_property_tree_performance =
       inputs->verify_property_trees &&
       (property_tree_option == BUILD_PROPERTY_TREES_IF_NEEDED);
 
   LayerImplList visible_layer_list;
   if (inputs->verify_property_trees || inputs->use_property_trees) {
     switch (property_tree_option) {
       case BUILD_PROPERTY_TREES_IF_NEEDED: {
         // The translation from layer to property trees is an intermediate
         // state. We will eventually get these data passed directly to the
@@ skipping 55 matching lines @@
       }
     }
   }
 
   if (should_measure_property_tree_performance) {
     TRACE_EVENT_BEGIN0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
                        "LayerTreeHostCommon::CalculateDrawProperties");
   }
 
   std::vector<AccumulatedSurfaceState> accumulated_surface_state;
+  DCHECK(inputs->can_render_to_separate_surface ==
+         inputs->property_trees->non_root_surfaces_enabled);
   CalculateRenderTarget(inputs);
   if (inputs->use_property_trees) {
     for (LayerImpl* layer : visible_layer_list) {
       ComputeLayerDrawPropertiesUsingPropertyTrees(
           layer, inputs->property_trees, inputs->layers_always_allowed_lcd_text,
           inputs->can_use_lcd_text, &layer->draw_properties());
       if (layer->mask_layer())
         ComputeMaskLayerDrawProperties(layer, layer->mask_layer());
       LayerImpl* replica_mask_layer = layer->replica_layer()
                                           ? layer->replica_layer()->mask_layer()
@@ skipping 21 matching lines @@
 
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
   DCHECK(inputs->root_layer->render_surface());
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     CalcDrawPropsMainInputs* inputs) {
   LayerList update_layer_list;
   bool can_render_to_separate_surface = true;
-  UpdateRenderSurfaces(inputs->root_layer, can_render_to_separate_surface,
-                       gfx::Transform(), false);
   PropertyTrees* property_trees =
       inputs->root_layer->layer_tree_host()->property_trees();
   BuildPropertyTreesAndComputeVisibleRects(
       inputs->root_layer, inputs->page_scale_layer,
       inputs->inner_viewport_scroll_layer, inputs->outer_viewport_scroll_layer,
       inputs->page_scale_factor, inputs->device_scale_factor,
       gfx::Rect(inputs->device_viewport_size), inputs->device_transform,
       can_render_to_separate_surface, property_trees, &update_layer_list);
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     CalcDrawPropsImplInputs* inputs) {
   CalculateDrawPropertiesAndVerify(inputs, DONT_BUILD_PROPERTY_TREES);
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     CalcDrawPropsImplInputsForTesting* inputs) {
   CalculateDrawPropertiesAndVerify(inputs, BUILD_PROPERTY_TREES_IF_NEEDED);
 }
 
 PropertyTrees* GetPropertyTrees(Layer* layer) {
   return layer->layer_tree_host()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 
 }  // namespace cc