Create RenderSurface on Effect Tree

cc/trees/draw_property_utils.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/draw_property_utils.h"
 
 #include <vector>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/draw_properties.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/render_surface_draw_properties.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/property_tree.h"
 #include "cc/trees/property_tree_builder.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 
 namespace {
 
 template <typename LayerType>
+static void ValidateRenderSurfaces(LayerType* layer) {
+  for (size_t i = 0; i < layer->children().size(); ++i) {
+    ValidateRenderSurfaces(layer->child_at(i));
+  }
+
+  // This test verifies that there are no cases where a LayerImpl needs
+  // a render surface, but doesn't have one.
+  if (layer->has_render_surface())
+    return;
+
+  DCHECK(layer->filters().IsEmpty()) << "layer: " << layer->id();
+  DCHECK(layer->background_filters().IsEmpty()) << "layer: " << layer->id();
+  DCHECK(layer->parent()) << "layer: " << layer->id();
+  if (layer->parent()->replica_layer() == layer)
+    return;
+  DCHECK(!layer->mask_layer()) << "layer: " << layer->id();
+  DCHECK(!layer->replica_layer()) << "layer: " << layer->id();
+  DCHECK(!layer->is_root_for_isolated_group()) << "layer: " << layer->id();
+  DCHECK(!layer->HasCopyRequest()) << "layer: " << layer->id();
+}
+
+template <typename LayerType>
 void CalculateVisibleRects(const std::vector<LayerType*>& visible_layer_list,
                            const ClipTree& clip_tree,
                            const TransformTree& transform_tree,
                            bool non_root_surfaces_enabled) {
   for (auto& layer : visible_layer_list) {
     gfx::Size layer_bounds = layer->bounds();
     const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index());
     const bool is_unclipped = clip_node->data.resets_clip &&
                               !clip_node->data.applies_local_clip &&
                               non_root_surfaces_enabled;
@@ skipping 397 matching lines @@
     if (LayerType* mask_layer = replica_layer->mask_layer())
       update_layer_list->push_back(mask_layer);
   }
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     FindLayersThatNeedUpdates(layer->child_at(i), tree, layer_is_drawn,
                               update_layer_list, visible_layer_list);
   }
 }
 
+template <typename LayerType>
+void UpdateRenderSurfacesWithEffectTreeInternal(EffectTree* effect_tree,
+                                                LayerType* layer) {
+  EffectNode* node = effect_tree->Node(layer->effect_tree_index());
+
+  if (node->owner_id == layer->id() && node->data.has_render_surface)
+    layer->SetHasRenderSurface(true);
+  else
+    layer->SetHasRenderSurface(false);
+
+  for (size_t i = 0; i < layer->children().size(); ++i) {
+    UpdateRenderSurfacesWithEffectTreeInternal<LayerType>(effect_tree,
+                                                          layer->child_at(i));
+  }
+}
+
+void UpdateRenderSurfacesWithEffectTree(EffectTree* effect_tree, Layer* layer) {
+  UpdateRenderSurfacesWithEffectTreeInternal<Layer>(effect_tree, layer);
+}
+
+void UpdateRenderSurfacesNonRootSurfacesDisabled(LayerImpl* layer) {
+  // Only root layer has render surface, all other layers don't.
+  layer->SetHasRenderSurface(!layer->parent());
+
+  for (size_t i = 0; i < layer->children().size(); ++i)
+    UpdateRenderSurfacesNonRootSurfacesDisabled(layer->child_at(i));
+}
+
+void UpdateRenderSurfacesWithEffectTree(EffectTree* effect_tree,
+                                        bool non_root_surfaces_enabled,
+                                        LayerImpl* layer) {
+  if (!non_root_surfaces_enabled)
+    UpdateRenderSurfacesNonRootSurfacesDisabled(layer);
+  else
+    UpdateRenderSurfacesWithEffectTreeInternal<LayerImpl>(effect_tree, layer);
+}
+
 }  // namespace
 
 static void ResetIfHasNanCoordinate(gfx::RectF* rect) {
   if (std::isnan(rect->x()) || std::isnan(rect->y()) ||
       std::isnan(rect->right()) || std::isnan(rect->bottom()))
     *rect = gfx::RectF();
 }
 
 void ComputeClips(ClipTree* clip_tree,
                   const TransformTree& transform_tree,
@@ skipping 42 matching lines @@
             1.f / parent_transform_node->data.sublayer_scale.y());
       // If we can't compute a transform, it's because we had to use the inverse
       // of a singular transform. We won't draw in this case, so there's no need
       // to compute clips.
       if (!success)
         continue;
       parent_combined_clip_in_target_space = MathUtil::ProjectClippedRect(
           parent_to_current,
           parent_clip_node->data.combined_clip_in_target_space);
     }
-
     // Only nodes affected by ancestor clips will have their clip adjusted due
     // to intersecting with an ancestor clip. But, we still need to propagate
     // the combined clip to our children because if they are clipped, they may
     // need to clip using our parent clip and if we don't propagate it here,
     // it will be lost.
     if (clip_node->data.resets_clip && non_root_surfaces_enabled) {
       if (clip_node->data.applies_local_clip) {
         clip_node->data.clip_in_target_space = MathUtil::MapClippedRect(
             transform_node->data.to_target, clip_node->data.clip);
         ResetIfHasNanCoordinate(&clip_node->data.clip_in_target_space);
         clip_node->data.combined_clip_in_target_space =
             gfx::IntersectRects(clip_node->data.clip_in_target_space,
                                 parent_combined_clip_in_target_space);
       } else {
         DCHECK(!clip_node->data.target_is_clipped);
         DCHECK(!clip_node->data.layers_are_clipped);
         clip_node->data.combined_clip_in_target_space =
             parent_combined_clip_in_target_space;
       }
       ResetIfHasNanCoordinate(&clip_node->data.combined_clip_in_target_space);
       continue;
     }
-
     bool use_only_parent_clip = !clip_node->data.applies_local_clip;
     if (use_only_parent_clip) {
       clip_node->data.combined_clip_in_target_space =
           parent_combined_clip_in_target_space;
       if (!non_root_surfaces_enabled) {
         clip_node->data.clip_in_target_space =
             parent_clip_node->data.clip_in_target_space;
       } else if (!clip_node->data.target_is_clipped) {
         clip_node->data.clip_in_target_space =
             parent_combined_clip_in_target_space;
@@ skipping 104 matching lines @@
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
     bool can_render_to_separate_surface,
     PropertyTrees* property_trees,
     LayerList* update_layer_list) {
   PropertyTreeBuilder::BuildPropertyTrees(
       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);
+  UpdateRenderSurfacesWithEffectTree(&property_trees->effect_tree, root_layer);
+  ValidateRenderSurfaces(root_layer);
   ComputeVisibleRectsUsingPropertyTrees(root_layer, property_trees,
                                         can_render_to_separate_surface,
                                         update_layer_list);
 }
 
 void BuildPropertyTreesAndComputeVisibleRects(
     LayerImpl* root_layer,
     const LayerImpl* page_scale_layer,
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
@@ skipping 23 matching lines @@
   std::vector<Layer*> visible_layer_list;
   ComputeVisibleRectsUsingPropertyTreesInternal(
       root_layer, property_trees, can_render_to_separate_surface,
       update_layer_list, &visible_layer_list);
 }
 
 void ComputeVisibleRectsUsingPropertyTrees(LayerImpl* root_layer,
                                            PropertyTrees* property_trees,
                                            bool can_render_to_separate_surface,
                                            LayerImplList* visible_layer_list) {
+  UpdateRenderSurfacesWithEffectTree(
+      &property_trees->effect_tree, can_render_to_separate_surface, root_layer);
+  if (can_render_to_separate_surface)
+    ValidateRenderSurfaces(root_layer);
   LayerImplList update_layer_list;
   ComputeVisibleRectsUsingPropertyTreesInternal(
       root_layer, property_trees, can_render_to_separate_surface,
       &update_layer_list, visible_layer_list);
 }
 
 template <typename LayerType>
 static gfx::Transform DrawTransformFromPropertyTreesInternal(
     const LayerType* layer,
     const TransformNode* node) {
@@ skipping 409 matching lines @@
 
 void UpdateElasticOverscrollInPropertyTrees(
     PropertyTrees* property_trees,
     const Layer* overscroll_elasticity_layer,
     const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInPropertyTreesInternal(
       property_trees, overscroll_elasticity_layer, elastic_overscroll);
 }
 
 }  // namespace cc