Moving RenderSurface creation outside of CalcDrawProps

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/debug/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/render_surface.h"
 #include "cc/layers/render_surface_impl.h"
+#include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/trees/layer_sorter.h"
+#include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 ScrollAndScaleSet::ScrollAndScaleSet() {}
 
 ScrollAndScaleSet::~ScrollAndScaleSet() {}
 
@@ skipping 513 matching lines @@
 
 static inline void SavePaintPropertiesLayer(Layer* layer) {
   layer->SavePaintProperties();
 
   if (layer->mask_layer())
     layer->mask_layer()->SavePaintProperties();
   if (layer->replica_layer() && layer->replica_layer()->mask_layer())
     layer->replica_layer()->mask_layer()->SavePaintProperties();
 }
 
-template <typename LayerType>
 static bool SubtreeShouldRenderToSeparateSurface(
-    LayerType* layer,
+    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
@@ skipping 536 matching lines @@
     return;
   }
   gfx::Vector2dF ancestor_transform_scales =
       MathUtil::ComputeTransform2dScaleComponents(ancestor_transform, 0.f);
   *combined_maximum_animation_contents_scale =
       layer_maximum_animated_scale *
       std::max(ancestor_transform_scales.x(), ancestor_transform_scales.y());
 }
 
 template <typename LayerType>
 static inline typename LayerType::RenderSurfaceType* CreateOrReuseRenderSurface(

[danakj, 2014/08/26 18:06:13]

unused?

[awoloszyn, 2014/08/28 19:31:43]

Done.

     LayerType* layer) {
   if (!layer->render_surface()) {
     layer->CreateRenderSurface();
     return layer->render_surface();
   }
 
   layer->render_surface()->ClearLayerLists();
   return layer->render_surface();
 }
 
@@ skipping 687 matching lines @@
   // If the subtree will scale layer contents by the transform hierarchy, then
   // we should scale things into the render surface by the transform hierarchy
   // to take advantage of that.
   gfx::Vector2dF render_surface_sublayer_scale =
       globals.can_adjust_raster_scales
       ? combined_transform_scales
       : gfx::Vector2dF(layer_scale_factors, layer_scale_factors);
 
   bool render_to_separate_surface;
   if (globals.can_render_to_separate_surface) {
-    render_to_separate_surface = SubtreeShouldRenderToSeparateSurface(
-          layer, combined_transform.Preserves2dAxisAlignment());
+    render_to_separate_surface = layer->ShouldHaveRenderSurface();
   } else {
-    render_to_separate_surface = IsRootLayer(layer);
+    render_to_separate_surface =
+        layer->ShouldHaveRenderSurface() && IsRootLayer(layer);

[danakj, 2014/08/26 18:06:13]

the root has to have a surface, and nothing else is allowed in this case. can
you instead do

bool render_to_separate_surface = layer->ShouldHaveRenderSurface();

// Root must own a surface.
DCHECK(!IsRootLayer(layer) || render_to_separate_surface);
// When globals.can_render_to_separate_surface is false, non-root layers can't
own a surface.
DCHECK(globals.can_render_to_separate_surface ||
    IsRootLayer(layer) ||
    !render_to_separate_surface);

[awoloszyn, 2014/08/28 19:31:43]

We may still have a render-surface if !globals.can_render_to_separate_surface,
since that can be changed per-frame on the impl-thread. The first check is done
already on 1983
if (render_to_...) { 
} else {
 DCHECK(layer->parent());
}
but I will add the second check.

   }
+  layer->SetRenderSurfaceActive(render_to_separate_surface);

[danakj, 2014/08/26 18:06:13]

The RS computation decides if the render surface should exist. ISTM that this
method call should not exist, cuz the surface already exists or not correctly.

[awoloszyn, 2014/08/28 19:31:43]

Done.

+
   if (render_to_separate_surface) {
     // Check back-face visibility before continuing with this surface and its
     // subtree
     if (!layer->double_sided() && TransformToParentIsKnown(layer) &&
         IsSurfaceBackFaceVisible(layer, combined_transform)) {
-      layer->ClearRenderSurfaceLayerList();
+      layer->SetRenderSurfaceActive(false);

[danakj, 2014/08/26 18:06:13]

And since the RS exists or not correctly, we shouldn't be deleting it here?

[awoloszyn, 2014/08/28 19:31:43]

Done.

       return;
     }
 
     typename LayerType::RenderSurfaceType* render_surface =
-        CreateOrReuseRenderSurface(layer);
-
+        layer->render_surface();
+    render_surface->ClearLayerLists();
     if (IsRootLayer(layer)) {
       // The root layer's render surface size is predetermined and so the root
       // layer can't directly support non-identity transforms.  It should just
       // forward top-level transforms to the rest of the tree.
       data_for_children.parent_matrix = combined_transform;
 
       // The root surface does not contribute to any other surface, it has no
       // target.
       layer->render_surface()->set_contributes_to_drawn_surface(false);
     } else {
@@ skipping 154 matching lines @@
     layer_draw_properties.target_space_transform_is_animating =
         animating_transform_to_target;
     layer_draw_properties.screen_space_transform_is_animating =
         animating_transform_to_screen;
     layer_draw_properties.opacity = accumulated_draw_opacity;
     layer_draw_properties.opacity_is_animating = animating_opacity_to_target;
     layer_draw_properties.screen_space_opacity_is_animating =
         animating_opacity_to_screen;
     data_for_children.parent_matrix = combined_transform;
 
-    layer->ClearRenderSurface();
-
     // Layers without render_surfaces directly inherit the ancestor's clip
     // status.
     layer_or_ancestor_clips_descendants = ancestor_clips_subtree;
     if (ancestor_clips_subtree) {
       clip_rect_in_target_space =
           ancestor_clip_rect_in_target_space;
     }
 
     // The surface's cached clip rect value propagates regardless of what
     // clipping goes on between layers here.
@@ skipping 355 matching lines @@
       device_viewport_rect;
   data_for_recursion->maximum_animation_contents_scale = 0.f;
   data_for_recursion->ancestor_is_animating_scale = false;
   data_for_recursion->ancestor_clips_subtree = true;
   data_for_recursion->nearest_occlusion_immune_ancestor_surface = NULL;
   data_for_recursion->in_subtree_of_page_scale_application_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 CreateOrDestroyRenderSurface(Layer* layer, gfx::Transform* transform) {
+  if (SubtreeShouldRenderToSeparateSurface(
+          layer,
+          transform->IsIdentity() || transform->Preserves2dAxisAlignment())) {
+    transform->MakeIdentity();
+    layer->SetShouldHaveRenderSurface(true);
+    if (!layer->render_surface()) {
+      layer->CreateRenderSurface();
+    }
+    return;
+  }
+  if (layer->render_surface())
+    layer->ClearRenderSurface();
+  layer->SetShouldHaveRenderSurface(false);
+}
+
+static void CreateRenderSurfaces(Layer* layer,
+                                 const gfx::Transform& parent_transform) {
+  if (!layer)
+    return;
+  gfx::Transform transformForChildren = layer->transform();
+  transformForChildren *= parent_transform;
+  CreateOrDestroyRenderSurface(layer, &transformForChildren);
+
+  for (size_t i = 0; i < layer->children().size(); ++i) {
+    CreateRenderSurfaces(layer->children()[i], transformForChildren);
+  }
+}
+
 void LayerTreeHostCommon::CalculateDrawProperties(
     CalcDrawPropsMainInputs* inputs) {
+  CreateRenderSurfaces(inputs->root_layer, gfx::Transform());
   LayerList dummy_layer_list;
   SubtreeGlobals<Layer> globals;
   DataForRecursion<Layer> data_for_recursion;
   ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion);
 
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
   std::vector<AccumulatedSurfaceState<Layer> > accumulated_surface_state;
   CalculateDrawPropertiesInternal<Layer>(
       inputs->root_layer,
@@ skipping 35 matching lines @@
       inputs->current_render_surface_layer_list_id);
 
   // The dummy layer list should not have been used.
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
   DCHECK(inputs->root_layer->render_surface());
 }
 
 }  // namespace cc