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 1780 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);
   }
+  layer->SetRenderSurfaceActive(render_to_separate_surface);
+
   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);
       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;
 }
 
+template <typename LayerType>
+void CreateOrDestroyRenderSurface(LayerType* type, gfx::Transform* t) {
+}
+
+template <>
+void CreateOrDestroyRenderSurface<LayerImpl>(LayerImpl* layer,
+                                             gfx::Transform* transform) {
+  if (SubtreeShouldRenderToSeparateSurface<LayerImpl>(
+          layer,
+          transform->IsIdentity() || transform->Preserves2dAxisAlignment())) {
+    transform->MakeIdentity();
+    if (!layer->render_surface()) {
+      layer->CreateRenderSurface();
+    }
+    return;
+  }
+  if (layer->render_surface())
+    layer->ClearRenderSurface();
+}
+
+template <>
+void CreateOrDestroyRenderSurface<Layer>(Layer* layer,
+                                         gfx::Transform* transform) {
+  if (SubtreeShouldRenderToSeparateSurface<Layer>(
+          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);
+}
+
+template <typename LayerType>
+static void CreateRenderSurfaces(LayerType* layer,
+                                 const gfx::Transform& parent_transform) {
+  gfx::Transform transformForChildren = layer->transform();
+  transformForChildren *= parent_transform;
+  CreateOrDestroyRenderSurface(layer, &transformForChildren);
+
+  for (size_t i = 0; i < layer->children().size(); ++i) {
+    CreateRenderSurfaces<LayerType>(layer->children()[i], transformForChildren);
+  }
+}
+
+void LayerTreeHostCommon::CalculateDrawProperties(
+    CalcDrawPropsImplInputsForTesting* inputs) {
+  CreateRenderSurfaces(inputs->root_layer, gfx::Transform());
+  CalculateDrawProperties(static_cast<CalcDrawPropsImplInputs*>(inputs));
+}
+
 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