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

cc/trees/draw_property_utils.cc

 // Copyright 2014 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/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 695 matching lines @@
 }
 
 static ConditionalClip LayerClipRect(PropertyTrees* property_trees,
                                      LayerImpl* layer) {
   const EffectTree* effect_tree = &property_trees->effect_tree;
   const EffectNode* effect_node = effect_tree->Node(layer->effect_tree_index());
   const EffectNode* target_node =
       effect_node->has_render_surface
           ? effect_node
           : effect_tree->Node(effect_node->target_id);
-  // TODO(weiliangc): When effect node has up to date render surface info on
-  // compositor thread, no need to check for resourceless draw mode
-  if (!property_trees->non_root_surfaces_enabled) {
-    target_node = effect_tree->Node(1);
-  }
-
   bool include_expanding_clips = false;
   return ComputeAccumulatedClip(property_trees, include_expanding_clips,
                                 layer->clip_tree_index(), target_node->id);
 }
 
-static void UpdateRenderTarget(EffectTree* effect_tree,
-                               bool can_render_to_separate_surface) {
+static void UpdateRenderTarget(EffectTree* effect_tree) {
   for (int i = EffectTree::kContentsRootNodeId;
        i < static_cast<int>(effect_tree->size()); ++i) {
     EffectNode* node = effect_tree->Node(i);
     if (i == EffectTree::kContentsRootNodeId) {
       // Render target of the node corresponding to root is itself.
       node->target_id = EffectTree::kContentsRootNodeId;
-    } else if (!can_render_to_separate_surface) {
-      node->target_id = EffectTree::kContentsRootNodeId;
     } else if (effect_tree->parent(node)->has_render_surface) {
       node->target_id = node->parent_id;
     } else {
       node->target_id = effect_tree->parent(node)->target_id;
     }
   }
 }
 
 static void UpdateScrollTree(ScrollTree* scroll_tree,
                              const LayerTreeHost* layer_tree_host) {
@@ skipping 123 matching lines @@
 void ComputeEffects(EffectTree* effect_tree) {
   if (!effect_tree->needs_update())
     return;
   for (int i = EffectTree::kContentsRootNodeId;
        i < static_cast<int>(effect_tree->size()); ++i)
     effect_tree->UpdateEffects(i);
   effect_tree->set_needs_update(false);
 }
 
 void UpdatePropertyTrees(LayerTreeHost* layer_tree_host,
-                         PropertyTrees* property_trees,
-                         bool can_render_to_separate_surface) {
+                         PropertyTrees* property_trees) {
   DCHECK(layer_tree_host);
   DCHECK(property_trees);
   DCHECK_EQ(layer_tree_host->property_trees(), property_trees);
-  if (property_trees->non_root_surfaces_enabled !=
-      can_render_to_separate_surface) {
-    property_trees->non_root_surfaces_enabled = can_render_to_separate_surface;
-    property_trees->transform_tree.set_needs_update(true);
-  }
   if (property_trees->transform_tree.needs_update()) {
     property_trees->clip_tree.set_needs_update(true);
     property_trees->effect_tree.set_needs_update(true);
   }
   UpdateScrollTree(&property_trees->scroll_tree, layer_tree_host);
   ComputeTransforms(&property_trees->transform_tree);
   ComputeEffects(&property_trees->effect_tree);
   // Computation of clips uses ToScreen which is updated while computing
   // transforms. So, ComputeTransforms should be before ComputeClips.
   ComputeClips(property_trees);
 }
 
 void UpdatePropertyTreesAndRenderSurfaces(LayerImpl* root_layer,
                                           PropertyTrees* property_trees,
-                                          bool can_render_to_separate_surface,
                                           bool can_adjust_raster_scales) {
   bool render_surfaces_need_update = false;
-  if (property_trees->non_root_surfaces_enabled !=
-      can_render_to_separate_surface) {
-    property_trees->non_root_surfaces_enabled = can_render_to_separate_surface;
-    property_trees->transform_tree.set_needs_update(true);
-    render_surfaces_need_update = true;
-  }
   if (property_trees->can_adjust_raster_scales != can_adjust_raster_scales) {
     property_trees->can_adjust_raster_scales = can_adjust_raster_scales;
     property_trees->transform_tree.set_needs_update(true);
     render_surfaces_need_update = true;
   }
   if (property_trees->transform_tree.needs_update()) {
     property_trees->clip_tree.set_needs_update(true);
     property_trees->effect_tree.set_needs_update(true);
   }
   if (render_surfaces_need_update) {
     property_trees->effect_tree.UpdateRenderSurfaces(
-        root_layer->layer_tree_impl(),
-        property_trees->non_root_surfaces_enabled);
+        root_layer->layer_tree_impl());
   }
-  UpdateRenderTarget(&property_trees->effect_tree,
-                     property_trees->non_root_surfaces_enabled);
+  UpdateRenderTarget(&property_trees->effect_tree);
 
   ComputeTransforms(&property_trees->transform_tree);
   ComputeEffects(&property_trees->effect_tree);
   // Computation of clips uses ToScreen which is updated while computing
   // transforms. So, ComputeTransforms should be before ComputeClips.
   ComputeClips(property_trees);
 }
 
 bool LayerNeedsUpdate(Layer* layer,
                       bool layer_is_drawn,
                       const PropertyTrees* property_trees) {
   return LayerNeedsUpdateInternal(layer, layer_is_drawn, property_trees);
 }
 
 bool LayerNeedsUpdate(LayerImpl* layer,
                       bool layer_is_drawn,
                       const PropertyTrees* property_trees) {
   return LayerNeedsUpdateInternal(layer, layer_is_drawn, property_trees);
 }
 
 gfx::Transform DrawTransform(const LayerImpl* layer,
                              const TransformTree& transform_tree,
                              const EffectTree& effect_tree) {
   // TransformTree::ToTarget computes transform between the layer's transform
   // node and surface's transform node and scales it by the surface's content
   // scale.
   gfx::Transform xform;
-  if (transform_tree.property_trees()->non_root_surfaces_enabled)
-    transform_tree.property_trees()->GetToTarget(
-        layer->transform_tree_index(), layer->render_target_effect_tree_index(),
-        &xform);
-  else
-    xform = transform_tree.ToScreen(layer->transform_tree_index());
+  transform_tree.property_trees()->GetToTarget(
+      layer->transform_tree_index(), layer->render_target_effect_tree_index(),
+      &xform);
   if (layer->should_flatten_transform_from_property_tree())
     xform.FlattenTo2d();
   xform.Translate(layer->offset_to_transform_parent().x(),
                   layer->offset_to_transform_parent().y());
   return xform;
 }
 
 gfx::Transform ScreenSpaceTransform(const Layer* layer,
                                     const TransformTree& tree) {
   return ScreenSpaceTransformInternal(layer, tree);
@@ skipping 118 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc