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"

[danakj, 2014/09/03 19:30:34]

including cc/test from a non-test file, this looks like a mistake?

[awoloszyn, 2014/09/09 15:31:36]

Done.

 #include "cc/trees/layer_sorter.h"
+#include "cc/trees/layer_tree_host.h"

[danakj, 2014/09/03 19:30:34]

why?

[awoloszyn, 2014/09/09 15:31:36]

This is no longer needed, was from earlier patch. Have removed.

 #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 535 matching lines @@
     *combined_maximum_animation_contents_scale = 0.f;
     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(
-    LayerType* layer) {
-  if (!layer->render_surface()) {
-    layer->CreateRenderSurface();
-    return layer->render_surface();
-  }
-
-  layer->render_surface()->ClearLayerLists();
-  return layer->render_surface();
-}
-
 template <typename LayerTypePtr>
 static inline void MarkLayerWithRenderSurfaceLayerListId(
     LayerTypePtr layer,
     int current_render_surface_layer_list_id) {
   layer->draw_properties().last_drawn_render_surface_layer_list_id =
       current_render_surface_layer_list_id;
 }
 
 template <typename LayerTypePtr>
 static inline void MarkMasksWithRenderSurfaceLayerListId(
@@ skipping 675 matching lines @@
       data_from_ancestor.full_hierarchy_matrix;
 
   // 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());
-  } else {
-    render_to_separate_surface = IsRootLayer(layer);
-  }
+  bool render_to_separate_surface =
+      IsRootLayer(layer) ||
+      (globals.can_render_to_separate_surface && layer->render_surface());
+
+  DCHECK(globals.can_render_to_separate_surface || IsRootLayer(layer) ||

[danakj, 2014/09/03 19:30:34]

this looks a bit awkward, like it's just repeating back the above. i think we
can remove this and instead..

[awoloszyn, 2014/09/09 15:31:37]

Done.

+         !render_to_separate_surface);
+
   if (render_to_separate_surface) {
     // Check back-face visibility before continuing with this surface and its

[danakj, 2014/09/03 19:30:34]

DCHECK(layer->render_surface()) here

[awoloszyn, 2014/09/09 15:31:36]

Done.

     // subtree
     if (!layer->double_sided() && TransformToParentIsKnown(layer) &&
         IsSurfaceBackFaceVisible(layer, combined_transform)) {
       layer->ClearRenderSurfaceLayerList();

[danakj, 2014/09/03 19:30:34]

I'm noticing all the ways we have to clear the RS layer list. This is the exact
same thing as you added below on 1824, but goes down a different path. Can we
maybe remove one of these two methods?

[awoloszyn, 2014/09/09 15:31:36]

I will replace all with layer->ClearRenderSurfaceLayerList()

       return;
     }
 
+    layer_draw_properties.render_target = layer;

[danakj, 2014/09/03 19:30:34]

remove this, did this twice also on L1825

[awoloszyn, 2014/09/09 15:31:37]

Done.

     typename LayerType::RenderSurfaceType* render_surface =
-        CreateOrReuseRenderSurface(layer);
-
+        layer->render_surface();
+    render_surface->ClearLayerLists();
+    layer_draw_properties.render_target = layer;
     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.
     clip_rect_of_target_surface_in_target_space =
         data_from_ancestor.clip_rect_of_target_surface_in_target_space;
 
     // Layers that are not their own render_target will render into the target
     // of their nearest ancestor.
     layer_draw_properties.render_target = layer->parent()->render_target();
   }
 
   if (adjust_text_aa)
     layer_draw_properties.can_use_lcd_text = layer_can_use_lcd_text;
 
   gfx::Rect rect_in_target_space =
       MathUtil::MapEnclosingClippedRect(layer->draw_transform(), content_rect);
 
   if (LayerClipsSubtree(layer)) {
     layer_or_ancestor_clips_descendants = true;
-    if (ancestor_clips_subtree && !layer->render_surface()) {
+    if (ancestor_clips_subtree && !render_to_separate_surface) {
       // A layer without render surface shares the same target as its ancestor.
       clip_rect_in_target_space =
           ancestor_clip_rect_in_target_space;
       clip_rect_in_target_space.Intersect(rect_in_target_space);
     } else {
       clip_rect_in_target_space = rect_in_target_space;
     }
   }
 
   // Tell the layer the rect that it's clipped by. In theory we could use a
   // tighter clip rect here (drawable_content_rect), but that actually does not
   // reduce how much would be drawn, and instead it would create unnecessary
   // changes to scissor state affecting GPU performance. Our clip information
   // is used in the recursion below, so we must set it beforehand.
   layer_draw_properties.is_clipped = layer_or_ancestor_clips_descendants;
   if (layer_or_ancestor_clips_descendants) {
     layer_draw_properties.clip_rect = clip_rect_in_target_space;
   } else {
     // Initialize the clip rect to a safe value that will not clip the
     // layer, just in case clipping is still accidentally used.
     layer_draw_properties.clip_rect = rect_in_target_space;
   }
 
   typename LayerType::LayerListType& descendants =
-      (layer->render_surface() ? layer->render_surface()->layer_list()
-                               : *layer_list);
+      (render_to_separate_surface ? layer->render_surface()->layer_list()
+                                  : *layer_list);
 
   // Any layers that are appended after this point are in the layer's subtree
   // and should be included in the sorting process.
   size_t sorting_start_index = descendants.size();
 
   if (!LayerShouldBeSkipped(layer, layer_is_drawn)) {
     MarkLayerWithRenderSurfaceLayerListId(layer,
                                           current_render_surface_layer_list_id);
     descendants.push_back(layer);
   }
@@ skipping 57 matching lines @@
         render_surface_layer_list->size();
 
     CalculateDrawPropertiesInternal<LayerType>(
         child,
         globals,
         data_for_children,
         render_surface_layer_list,
         &descendants,
         accumulated_surface_state,
         current_render_surface_layer_list_id);
-    if (child->render_surface() &&
+    // If our child has a render_target that is not our render_target
+    // then it has it's own surface

[danakj, 2014/09/03 19:30:34]

nit: period

[awoloszyn, 2014/09/09 15:31:36]

Done.

+    if (child->render_target() != layer->render_target() &&
+        child->render_surface() &&

[danakj, 2014/09/03 19:30:34]

the render_surface() must be true in that case, so no need to check it here?

[awoloszyn, 2014/09/09 15:31:36]

I have re-worked this to be a bit more clear. A child has a render_surface if
child->render_target() == child.

         !child->render_surface()->layer_list().empty() &&
         !child->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, current_render_surface_layer_list_id);
       descendants.push_back(child);
     }
 
@@ skipping 18 matching lines @@
         *layer,
         &descendants,
         layer_list_child_sorting_start_index,
         &GetNewDescendantsStartIndexAndCount<LayerType>);
   }
 
   // Compute the total drawable_content_rect for this subtree (the rect is in
   // target surface space).
   gfx::Rect local_drawable_content_rect_of_subtree =
       accumulated_surface_state->back().drawable_content_rect;
-  if (layer->render_surface()) {
+  if (render_to_separate_surface) {
     DCHECK(accumulated_surface_state->back().render_target == layer);
     accumulated_surface_state->pop_back();
   }
 
-  if (layer->render_surface() && !IsRootLayer(layer) &&
+  if (render_to_separate_surface && !IsRootLayer(layer) &&
       layer->render_surface()->layer_list().empty()) {
     RemoveSurfaceForEarlyExit(layer, render_surface_layer_list);
     return;
   }
 
   // Compute the layer's drawable content rect (the rect is in target surface
   // space).
   layer_draw_properties.drawable_content_rect = rect_in_target_space;
   if (layer_or_ancestor_clips_descendants) {
     layer_draw_properties.drawable_content_rect.Intersect(
         clip_rect_in_target_space);
   }
   if (layer->DrawsContent()) {
     local_drawable_content_rect_of_subtree.Union(
         layer_draw_properties.drawable_content_rect);
   }
 
   // Compute the layer's visible content rect (the rect is in content space).
   layer_draw_properties.visible_content_rect = CalculateVisibleContentRect(
       layer, clip_rect_of_target_surface_in_target_space, rect_in_target_space);
 
   // Compute the remaining properties for the render surface, if the layer has
   // one.
   if (IsRootLayer(layer)) {
     // The root layer's surface's content_rect is always the entire viewport.
-    DCHECK(layer->render_surface());
+    DCHECK(render_to_separate_surface);
     layer->render_surface()->SetContentRect(
         ancestor_clip_rect_in_target_space);
-  } else if (layer->render_surface()) {
+  } else if (render_to_separate_surface) {
     typename LayerType::RenderSurfaceType* render_surface =
         layer->render_surface();
     gfx::Rect clipped_content_rect = local_drawable_content_rect_of_subtree;
 
     // Don't clip if the layer is reflected as the reflection shouldn't be
     // clipped. If the layer is animating, then the surface's transform to
     // its target is not known on the main thread, and we should not use it
     // to clip.
     if (!layer->replica_layer() && TransformToParentIsKnown(layer)) {
       // Note, it is correct to use data_from_ancestor.ancestor_clips_subtree
@@ skipping 73 matching lines @@
           surface_origin_to_replica_origin_transform;
       render_surface->SetReplicaScreenSpaceTransform(
           replica_screen_space_transform);
     }
   }
 
   SavePaintPropertiesLayer(layer);
 
   // If neither this layer nor any of its children were added, early out.
   if (sorting_start_index == descendants.size()) {
-    DCHECK(!layer->render_surface() || IsRootLayer(layer));
+    DCHECK(!render_to_separate_surface || IsRootLayer(layer));
     return;
   }
 
   // If preserves-3d then sort all the descendants in 3D so that they can be
   // drawn from back to front. If the preserves-3d property is also set on the
   // parent then skip the sorting as the parent will sort all the descendants
   // anyway.
   if (globals.layer_sorter && descendants.size() && layer->Is3dSorted() &&
       !LayerIsInExisting3DRenderingContext(layer)) {
     SortLayers(descendants.begin() + sorting_start_index,
@@ skipping 57 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,
+                                  bool can_render_to_separate_surface,
+                                  gfx::Transform* transform) {
+  if (IsRootLayer(layer) ||
+      (can_render_to_separate_surface &&
+       SubtreeShouldRenderToSeparateSurface(
+           layer,
+           transform->IsIdentity() || transform->Preserves2dAxisAlignment()))) {

[danakj, 2014/09/03 19:30:34]

nit: Preserves2dAxisAlignment should already return true for Identity?

[awoloszyn, 2014/09/09 15:31:37]

It does already return true for Identity. transform->IsIdentity will be a
cheaper check than transform->Preserves... although this is true only in the
case where SkMatrix44::getType() is already cached. I will remove the
IsIdentity, since it does not obviously provide us with an improvement.

+    transform->MakeIdentity();
+    if (!layer->render_surface()) {
+      layer->CreateRenderSurface();
+    }
+    layer->SetHasRenderSurface(true);
+    return;
+  }
+  layer->SetHasRenderSurface(false);
+  if (layer->render_surface())
+    layer->ClearRenderSurface();
+}
+
+static void CreateRenderSurfaces(Layer* layer,
+                                 bool can_render_to_separate_surface,
+                                 const gfx::Transform& parent_transform) {
+  if (!layer)
+    return;
+  gfx::Transform transformForChildren = layer->transform();
+  transformForChildren *= parent_transform;

[danakj, 2014/09/03 19:30:34]

This is not really the same thing as checking the combined_transform. That one
includes things like the layer position, and the transform origin, etc. Couldn't
those things change whether a rotation ends up causing the transform to be 2d
aligned or not? What do you think about that?

[awoloszyn, 2014/09/09 15:31:36]

2d offsets are not able to change the 2d axis aligment of an element. Rotations
will always rotate the rect by Xdeg regardless of where the origin or position
is. We will be unable to use this to determine the ACTUAL position, but we can
safely determine the axis-align-ness of the element.

+  CreateOrDestroyRenderSurface(
+      layer, can_render_to_separate_surface, &transformForChildren);
+
+  for (size_t i = 0; i < layer->children().size(); ++i) {
+    CreateRenderSurfaces(layer->children()[i],
+                         can_render_to_separate_surface,
+                         transformForChildren);
+  }
+}
+
 void LayerTreeHostCommon::CalculateDrawProperties(
     CalcDrawPropsMainInputs* inputs) {
+  CreateRenderSurfaces(inputs->root_layer,
+                       inputs->can_render_to_separate_surface,
+                       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