cc: Move RenderTarget Information to 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 <stddef.h>
 
 #include <algorithm>
 
@@ skipping 509 matching lines @@
     }
   }
   return jitter;
 }
 
 enum PropertyTreeOption {
   BUILD_PROPERTY_TREES_IF_NEEDED,
   DONT_BUILD_PROPERTY_TREES
 };
 
-void CalculateRenderTarget(LayerImpl* layer,
-                           PropertyTrees* property_trees,
-                           bool subtree_visible_from_ancestor,
-                           bool can_render_to_separate_surface) {
-  bool layer_is_drawn;
-  DCHECK_GE(layer->effect_tree_index(), 0);
-  layer_is_drawn = property_trees->effect_tree.Node(layer->effect_tree_index())
-                       ->data.is_drawn;
-
-  // The root layer cannot be skipped.
-  if (!IsRootLayer(layer) &&
-      draw_property_utils::LayerShouldBeSkipped(layer, layer_is_drawn,
-                                                property_trees->transform_tree,
-                                                property_trees->effect_tree)) {
-    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()) << 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 {
-    DCHECK(!IsRootLayer(layer));
-    layer->draw_properties().render_target = layer->parent()->render_target();
-  }
-  for (size_t i = 0; i < layer->children().size(); ++i) {
-    CalculateRenderTarget(
-        LayerTreeHostCommon::get_layer_as_raw_ptr(layer->children(), i),
-        property_trees, layer_is_drawn, can_render_to_separate_surface);
-  }
-}
-
 void CalculateRenderSurfaceLayerList(
     LayerImpl* layer,
     PropertyTrees* property_trees,
     LayerImplList* render_surface_layer_list,
     LayerImplList* descendants,
     RenderSurfaceImpl* nearest_occlusion_immune_ancestor,
     bool subtree_visible_from_ancestor,
     const bool can_render_to_separate_surface,
     const int current_render_surface_layer_list_id,
     const int max_texture_size) {
@@ skipping 17 matching lines @@
   layer_is_drawn = property_trees->effect_tree.Node(layer->effect_tree_index())
                        ->data.is_drawn;
 
   // The root layer cannot be skipped.
   if (!IsRootLayer(layer) &&
       draw_property_utils::LayerShouldBeSkipped(layer, layer_is_drawn,
                                                 property_trees->transform_tree,
                                                 property_trees->effect_tree)) {
     if (layer->render_surface())
       layer->ClearRenderSurfaceLayerList();
-    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());
     draw_property_utils::ComputeSurfaceDrawProperties(property_trees,
@@ skipping 39 matching lines @@
       layer, layer_is_drawn, property_trees->transform_tree);
   if (!layer_should_be_skipped) {
     MarkLayerWithRenderSurfaceLayerListId(layer,
                                           current_render_surface_layer_list_id);
     descendants->push_back(layer);
   }
 
 
   // Clear the old accumulated content rect of surface.
   if (render_to_separate_surface)
-    layer->render_surface()->SetAccumulatedContentRect(gfx::Rect());
+    layer->render_surface()->ClearAccumulatedContentRect();
 
   for (auto* child_layer : layer->children()) {
     CalculateRenderSurfaceLayerList(
         child_layer, property_trees, render_surface_layer_list, descendants,
         nearest_occlusion_immune_ancestor, layer_is_drawn,
         can_render_to_separate_surface, current_render_surface_layer_list_id,
         max_texture_size);
 
     // If the child is its own render target, then it has a render surface.
-    if (child_layer->render_target() == child_layer &&
+    if (child_layer->has_render_surface() &&
+        child_layer->render_target() == child_layer->render_surface() &&
         !child_layer->render_surface()->layer_list().empty() &&
         !child_layer->render_surface()->content_rect().IsEmpty()) {
       // This child will contribute its render surface, which means
       // we need to mark just the mask layer (and replica mask layer)
       // with the id.
       MarkMasksWithRenderSurfaceLayerListId(
           child_layer, current_render_surface_layer_list_id);
       descendants->push_back(child_layer);
     }
 
     if (child_layer->layer_or_descendant_is_drawn()) {
       bool layer_or_descendant_is_drawn = true;
       layer->set_layer_or_descendant_is_drawn(layer_or_descendant_is_drawn);
     }
   }
 
   if (render_to_separate_surface && !IsRootLayer(layer) &&
       layer->render_surface()->layer_list().empty()) {
     RemoveSurfaceForEarlyExit(layer, render_surface_layer_list);
     return;
   }
 
   // The render surface's content rect is the union of drawable content rects
   // of the layers that draw into the surface. If the render surface is clipped,
   // it is also intersected with the render's surface clip rect.
   if (!IsRootLayer(layer)) {
+    // Layer contriubutes its drawable content rect to its render target.
+    if (layer->DrawsContent())
+      layer->render_target()->AccumulateContentRectFromContributingLayer(layer);
+
     if (render_to_separate_surface) {
       gfx::Rect surface_content_rect =
           layer->render_surface()->accumulated_content_rect();
-      // If the owning layer of a render surface draws content, the content
-      // rect of the render surface is expanded to include the drawable
-      // content rect of the layer.
-      if (layer->DrawsContent())
-        surface_content_rect.Union(layer->drawable_content_rect());
 
       if (!layer->replica_layer() && !layer->HasCopyRequest() &&
           layer->render_surface()->is_clipped()) {
         // Here, we clip the render surface's content rect with its clip rect.
         // As the clip rect of render surface is in the surface's target
         // space, we first map the content rect into the target space,
         // intersect it with clip rect and project back the result to the
         // surface space.
         if (!surface_content_rect.IsEmpty()) {
           gfx::Rect surface_clip_rect =
               LayerTreeHostCommon::CalculateVisibleRect(
                   layer->render_surface()->clip_rect(), surface_content_rect,
                   layer->render_surface()->draw_transform());
           surface_content_rect.Intersect(surface_clip_rect);
         }
       }
       // The RenderSurfaceImpl backing texture cannot exceed the maximum
       // supported texture size.
       surface_content_rect.set_width(
           std::min(surface_content_rect.width(), max_texture_size));
       surface_content_rect.set_height(
           std::min(surface_content_rect.height(), max_texture_size));
       layer->render_surface()->SetContentRect(surface_content_rect);
-    }
-    const LayerImpl* parent_target = layer->parent()->render_target();
-    if (!IsRootLayer(parent_target)) {
-      gfx::Rect surface_content_rect =
-          parent_target->render_surface()->accumulated_content_rect();
-      if (render_to_separate_surface) {
-        // If the layer owns a surface, then the content rect is in the wrong
-        // space. Instead, we will use the surface's DrawableContentRect which
-        // is in target space as required. We also need to clip it with the
-        // target's clip if the target is clipped.
-        surface_content_rect.Union(gfx::ToEnclosedRect(
-            layer->render_surface()->DrawableContentRect()));
-        if (parent_target->is_clipped())
-          surface_content_rect.Intersect(parent_target->clip_rect());
-      } else if (layer->DrawsContent()) {
-        surface_content_rect.Union(layer->drawable_content_rect());
-      }
-      parent_target->render_surface()->SetAccumulatedContentRect(
-          surface_content_rect);
+
+      // Now the render surface's content rect is calculated correctly, it could
+      // contribute to its render target.
+      layer->render_surface()
+          ->render_target()
+          ->AccumulateContentRectFromContributingRenderSurface(
+              layer->render_surface());
     }
   } else {
     // The root layer's surface content rect is always the entire viewport.
     gfx::Rect viewport =
         gfx::ToEnclosingRect(property_trees->clip_tree.ViewportClip());
     layer->render_surface()->SetContentRect(viewport);
   }
 
   if (render_to_separate_surface && !IsRootLayer(layer) &&
       layer->render_surface()->DrawableContentRect().IsEmpty()) {
@@ skipping 98 matching lines @@
   }
 
   if (should_measure_property_tree_performance) {
     TRACE_EVENT_BEGIN0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
                        "LayerTreeHostCommon::CalculateDrawProperties");
   }
 
   DCHECK(inputs->can_render_to_separate_surface ==
          inputs->property_trees->non_root_surfaces_enabled);
   const bool subtree_visible_from_ancestor = true;
-  for (auto* layer : *inputs->root_layer->layer_tree_impl())
-    layer->draw_properties().render_target = nullptr;
-  CalculateRenderTarget(inputs->root_layer, inputs->property_trees,
-                        subtree_visible_from_ancestor,
-                        inputs->can_render_to_separate_surface);
   for (LayerImpl* layer : visible_layer_list) {
     draw_property_utils::ComputeLayerDrawProperties(
         layer, inputs->property_trees, inputs->layers_always_allowed_lcd_text,
         inputs->can_use_lcd_text);
     if (layer->mask_layer())
       ComputeMaskLayerDrawProperties(layer, layer->mask_layer());
     LayerImpl* replica_mask_layer =
         layer->replica_layer() ? layer->replica_layer()->mask_layer() : nullptr;
     if (replica_mask_layer)
       ComputeMaskLayerDrawProperties(layer, replica_mask_layer);
@@ skipping 100 matching lines @@
 
 PropertyTrees* GetPropertyTrees(Layer* layer) {
   return layer->layer_tree_host()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 
 }  // namespace cc