cc: Remove support for disabling non-root render surfaces.

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 60 matching lines @@
     const gfx::Size& device_viewport_size,
     const gfx::Transform& device_transform,
     float device_scale_factor,
     float page_scale_factor,
     const LayerImpl* page_scale_layer,
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
     const gfx::Vector2dF& elastic_overscroll,
     const LayerImpl* elastic_overscroll_application_layer,
     int max_texture_size,
-    bool can_render_to_separate_surface,
     bool can_adjust_raster_scales,
     RenderSurfaceList* render_surface_list,
     PropertyTrees* property_trees)
     : root_layer(root_layer),
       device_viewport_size(device_viewport_size),
       device_transform(device_transform),
       device_scale_factor(device_scale_factor),
       page_scale_factor(page_scale_factor),
       page_scale_layer(page_scale_layer),
       inner_viewport_scroll_layer(inner_viewport_scroll_layer),
       outer_viewport_scroll_layer(outer_viewport_scroll_layer),
       elastic_overscroll(elastic_overscroll),
       elastic_overscroll_application_layer(
           elastic_overscroll_application_layer),
       max_texture_size(max_texture_size),
-      can_render_to_separate_surface(can_render_to_separate_surface),
       can_adjust_raster_scales(can_adjust_raster_scales),
       render_surface_list(render_surface_list),
       property_trees(property_trees) {}
 
 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting::
     CalcDrawPropsImplInputsForTesting(LayerImpl* root_layer,
                                       const gfx::Size& device_viewport_size,
                                       const gfx::Transform& device_transform,
                                       float device_scale_factor,
                                       RenderSurfaceList* render_surface_list)
     : CalcDrawPropsImplInputs(root_layer,
                               device_viewport_size,
                               device_transform,
                               device_scale_factor,
                               1.f,
                               NULL,
                               NULL,
                               NULL,
                               gfx::Vector2dF(),
                               NULL,
                               std::numeric_limits<int>::max() / 2,
-                              true,
                               false,
                               render_surface_list,
                               GetPropertyTrees(root_layer)) {
   DCHECK(root_layer);
   DCHECK(render_surface_list);
 }
 
 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting::
     CalcDrawPropsImplInputsForTesting(LayerImpl* root_layer,
                                       const gfx::Size& device_viewport_size,
@@ skipping 210 matching lines @@
              ? !property_trees->GetFromTarget(
                    layer->transform_tree_index(),
                    effect_node->closest_ancestor_with_copy_request_id,
                    &from_target)
              : !transform_node->ancestors_are_invertible;
 }
 
 static void ComputeInitialRenderSurfaceList(
     LayerTreeImpl* layer_tree_impl,
     PropertyTrees* property_trees,
-    RenderSurfaceList* render_surface_list,
-    bool can_render_to_separate_surface) {
+    RenderSurfaceList* render_surface_list) {
   EffectTree& effect_tree = property_trees->effect_tree;
   for (int i = EffectTree::kContentsRootNodeId;
        i < static_cast<int>(effect_tree.size()); ++i) {
     if (RenderSurfaceImpl* render_surface = effect_tree.GetRenderSurface(i)) {
       render_surface->set_is_render_surface_list_member(false);
       render_surface->reset_num_contributors();
       ClearMaskLayersContributeToDrawnRenderSurface(render_surface);
     }
   }
 
@@ skipping 119 matching lines @@
         }
       }
     }
   }
 }
 
 static void CalculateRenderSurfaceLayerList(
     LayerTreeImpl* layer_tree_impl,
     PropertyTrees* property_trees,
     RenderSurfaceList* render_surface_list,
-    const bool can_render_to_separate_surface,
     const int max_texture_size) {
   RenderSurfaceList initial_render_surface_list;
 
   // First compute a list that might include surfaces that later turn out to
   // have an empty content rect. After surface content rects are computed,
   // produce a final list that omits empty surfaces.
   ComputeInitialRenderSurfaceList(layer_tree_impl, property_trees,
-                                  &initial_render_surface_list,
-                                  can_render_to_separate_surface);
+                                  &initial_render_surface_list);
   ComputeSurfaceContentRects(layer_tree_impl, property_trees,
                              &initial_render_surface_list, max_texture_size);
   ComputeListOfNonEmptySurfaces(layer_tree_impl, property_trees,
                                 &initial_render_surface_list,
                                 render_surface_list);
 }
 
 void CalculateDrawPropertiesInternal(
     LayerTreeHostCommon::CalcDrawPropsImplInputs* inputs,
     PropertyTreeOption property_tree_option) {
@@ skipping 17 matching lines @@
       PropertyTreeBuilder::BuildPropertyTrees(
           inputs->root_layer, inputs->page_scale_layer,
           inputs->inner_viewport_scroll_layer,
           inputs->outer_viewport_scroll_layer,
           inputs->elastic_overscroll_application_layer,
           inputs->elastic_overscroll, inputs->page_scale_factor,
           inputs->device_scale_factor, gfx::Rect(inputs->device_viewport_size),
           inputs->device_transform, inputs->property_trees);
       draw_property_utils::UpdatePropertyTreesAndRenderSurfaces(
           inputs->root_layer, inputs->property_trees,
-          inputs->can_render_to_separate_surface,
           inputs->can_adjust_raster_scales);
 
       // Property trees are normally constructed on the main thread and
       // passed to compositor thread. Source to parent updates on them are not
       // allowed in the compositor thread. Some tests build them on the
       // compositor thread, so we need to explicitly disallow source to parent
       // updates when they are built on compositor thread.
       inputs->property_trees->transform_tree
           .set_source_to_parent_updates_allowed(false);
       if (should_measure_property_tree_performance) {
@@ skipping 26 matching lines @@
           gfx::RectF(gfx::SizeF(inputs->device_viewport_size)));
       float page_scale_factor_for_root =
           inputs->page_scale_layer == inputs->root_layer
               ? inputs->page_scale_factor
               : 1.f;
       property_trees->transform_tree.SetRootTransformsAndScales(
           inputs->device_scale_factor, page_scale_factor_for_root,
           inputs->device_transform, inputs->root_layer->position());
       draw_property_utils::UpdatePropertyTreesAndRenderSurfaces(
           inputs->root_layer, inputs->property_trees,
-          inputs->can_render_to_separate_surface,
           inputs->can_adjust_raster_scales);
       break;
     }
   }
 
   if (should_measure_property_tree_performance) {
     TRACE_EVENT_BEGIN0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
                        "LayerTreeHostCommon::CalculateDrawProperties");
   }
 
   draw_property_utils::FindLayersThatNeedUpdates(
       inputs->root_layer->layer_tree_impl(), inputs->property_trees,
       &visible_layer_list);
-  DCHECK(inputs->can_render_to_separate_surface ==
-         inputs->property_trees->non_root_surfaces_enabled);
   draw_property_utils::ComputeDrawPropertiesOfVisibleLayers(
       &visible_layer_list, inputs->property_trees);
 
   CalculateRenderSurfaceLayerList(
       inputs->root_layer->layer_tree_impl(), inputs->property_trees,
-      inputs->render_surface_list, inputs->can_render_to_separate_surface,
-      inputs->max_texture_size);
+      inputs->render_surface_list, inputs->max_texture_size);
 
   if (should_measure_property_tree_performance) {
     TRACE_EVENT_END0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
                      "LayerTreeHostCommon::CalculateDrawProperties");
   }
 
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
   DCHECK(inputs->property_trees->effect_tree.GetRenderSurface(
       EffectTree::kContentsRootNodeId));
 }
 
 void LayerTreeHostCommon::CalculateDrawPropertiesForTesting(
     CalcDrawPropsMainInputsForTesting* inputs) {
   LayerList update_layer_list;
-  bool can_render_to_separate_surface = true;
   PropertyTrees* property_trees =
       inputs->root_layer->layer_tree_host()->property_trees();
   Layer* overscroll_elasticity_layer = nullptr;
   gfx::Vector2dF elastic_overscroll;
   PropertyTreeBuilder::BuildPropertyTrees(
       inputs->root_layer, inputs->page_scale_layer,
       inputs->inner_viewport_scroll_layer, inputs->outer_viewport_scroll_layer,
       overscroll_elasticity_layer, elastic_overscroll,
       inputs->page_scale_factor, inputs->device_scale_factor,
       gfx::Rect(inputs->device_viewport_size), inputs->device_transform,
       property_trees);
   draw_property_utils::UpdatePropertyTrees(
-      inputs->root_layer->layer_tree_host(), property_trees,
-      can_render_to_separate_surface);
+      inputs->root_layer->layer_tree_host(), property_trees);
   draw_property_utils::FindLayersThatNeedUpdates(
       inputs->root_layer->layer_tree_host(), property_trees,
       &update_layer_list);
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     CalcDrawPropsImplInputs* inputs) {
   CalculateDrawPropertiesInternal(inputs, DONT_BUILD_PROPERTY_TREES);
 
   if (CdpPerfTracingEnabled()) {
@@ skipping 46 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