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 337 matching lines @@
   bool include_viewport_clip = true;
   bool include_expanding_clips = true;
   ConditionalClip accumulated_clip = ComputeAccumulatedClip(
       property_trees, include_viewport_clip, include_expanding_clips,
       local_clip_id, root_effect_id);
   DCHECK(accumulated_clip.is_clipped);
   return accumulated_clip.clip_rect;
 }
 
 void CalculateClipRects(const std::vector<LayerImpl*>& visible_layer_list,
-                        const PropertyTrees* property_trees,
-                        bool non_root_surfaces_enabled) {
+                        const PropertyTrees* property_trees) {
   const ClipTree& clip_tree = property_trees->clip_tree;
   for (auto* layer : visible_layer_list) {
     const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index());
-    bool layer_needs_clip_rect =
-        non_root_surfaces_enabled
-            ? clip_node->layers_are_clipped
-            : clip_node->layers_are_clipped_when_surfaces_disabled;
-    if (!layer_needs_clip_rect) {
+    if (!clip_node->layers_are_clipped) {
       layer->set_clip_rect(gfx::Rect());
       continue;
     }
-    if (!non_root_surfaces_enabled) {
-      layer->set_clip_rect(
-          gfx::ToEnclosingRect(clip_node->clip_in_target_space));
-      continue;
-    }
 
     const TransformTree& transform_tree = property_trees->transform_tree;
     const TransformNode* transform_node =
         transform_tree.Node(layer->transform_tree_index());
     int target_node_id = transform_tree.ContentTargetId(transform_node->id);
 
     // The clip node stores clip rect in its target space.
     gfx::RectF clip_rect_in_target_space = clip_node->clip_in_target_space;
 
     // If required, this clip rect should be mapped to the current layer's
@@ skipping 16 matching lines @@
 
     if (!clip_rect_in_target_space.IsEmpty()) {
       layer->set_clip_rect(gfx::ToEnclosingRect(clip_rect_in_target_space));
     } else {
       layer->set_clip_rect(gfx::Rect());
     }
   }
 }
 
 void CalculateVisibleRects(const LayerImplList& visible_layer_list,
-                           const PropertyTrees* property_trees,
-                           bool non_root_surfaces_enabled) {
+                           const PropertyTrees* property_trees) {
   const EffectTree& effect_tree = property_trees->effect_tree;
   const TransformTree& transform_tree = property_trees->transform_tree;
   const ClipTree& clip_tree = property_trees->clip_tree;
   for (auto* layer : visible_layer_list) {
     gfx::Size layer_bounds = layer->bounds();
 
     int effect_ancestor_with_copy_request =
         effect_tree.ClosestAncestorWithCopyRequest(layer->effect_tree_index());
     if (effect_ancestor_with_copy_request > EffectTree::kContentsRootNodeId) {
       // Non root copy request.
@@ skipping 25 matching lines @@
         layer->set_visible_layer_rect(visible_rect);
       } else {
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
       }
       continue;
     }
 
     const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index());
     const TransformNode* transform_node =
         transform_tree.Node(layer->transform_tree_index());
-    if (!non_root_surfaces_enabled) {
-      // When we only have a root surface, the clip node and the layer must
-      // necessarily have the same target (the root).
-      if (transform_node->ancestors_are_invertible) {
-        gfx::RectF combined_clip_rect_in_target_space =
-            clip_node->combined_clip_in_target_space;
-        gfx::Transform target_to_content;
-        target_to_content.Translate(-layer->offset_to_transform_parent().x(),
-                                    -layer->offset_to_transform_parent().y());
-        target_to_content.PreconcatTransform(
-            transform_tree.FromScreen(transform_node->id));
-
-        gfx::Rect visible_rect =
-            gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
-                target_to_content, combined_clip_rect_in_target_space));
-        visible_rect.Intersect(gfx::Rect(layer_bounds));
-        layer->set_visible_layer_rect(visible_rect);
-      } else {
-        layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
-      }
-      continue;
-    }
 
     // When both the layer and the target are unclipped, we only have to apply
     // the viewport clip.
     const bool fully_visible =
         !clip_node->layers_are_clipped &&
         !effect_tree.Node(clip_node->target_effect_id)->surface_is_clipped;
 
     if (fully_visible) {
       if (!transform_node->ancestors_are_invertible) {
         // An animated singular transform may become non-singular during the
@@ skipping 218 matching lines @@
 
     bool layer_is_drawn =
         effect_tree.Node(layer_impl->effect_tree_index())->is_drawn;
 
     if (LayerNeedsUpdate(layer_impl, layer_is_drawn, property_trees))
       visible_layer_list->push_back(layer_impl);
   }
 }
 
 void UpdateRenderSurfaceForLayer(EffectTree* effect_tree,
-                                 bool non_root_surfaces_enabled,
                                  LayerImpl* layer) {
-  if (!non_root_surfaces_enabled) {
-    layer->SetHasRenderSurface(IsRootLayer(layer));
-    return;
-  }
-
   EffectNode* node = effect_tree->Node(layer->effect_tree_index());
 
   if (node->owning_layer_id == layer->id() && node->has_render_surface)
     layer->SetHasRenderSurface(true);
   else
     layer->SetHasRenderSurface(false);
 }
 }  // namespace
 
 template <typename LayerType>
@@ skipping 72 matching lines @@
 
 void ConcatInverseSurfaceContentsScale(const EffectNode* effect_node,
                                        gfx::Transform* transform) {
   DCHECK(effect_node->has_render_surface);
   if (effect_node->surface_contents_scale.x() != 0.0 &&
       effect_node->surface_contents_scale.y() != 0.0)
     transform->Scale(1.0 / effect_node->surface_contents_scale.x(),
                      1.0 / effect_node->surface_contents_scale.y());
 }
 
-void ComputeClips(PropertyTrees* property_trees,
-                  bool non_root_surfaces_enabled) {
+void ComputeClips(PropertyTrees* property_trees) {
   ClipTree* clip_tree = &property_trees->clip_tree;
   if (!clip_tree->needs_update())
     return;
   for (int i = ClipTree::kViewportNodeId;
        i < static_cast<int>(clip_tree->size()); ++i) {
     ClipNode* clip_node = clip_tree->Node(i);
 
     if (clip_node->id == ClipTree::kViewportNodeId) {
       ResetIfHasNanCoordinate(&clip_node->clip);
       clip_node->clip_in_target_space = clip_node->clip;
@@ skipping 22 matching lines @@
     // target space, the relative sizes and positions of B and C can shift.
     // Since it's the relationship in target space that matters, that's where we
     // must combine clips. For each clip node, we save the clip rects in its
     // target space. So, we need to get the ancestor clip rect in the current
     // clip node's target space.
     gfx::RectF parent_combined_clip_in_target_space =
         parent_clip_node->combined_clip_in_target_space;
     gfx::RectF parent_clip_in_target_space =
         parent_clip_node->clip_in_target_space;
     if (parent_target_transform_node &&
-        parent_target_transform_node->id != clip_node->target_transform_id &&
-        non_root_surfaces_enabled) {
+        parent_target_transform_node->id != clip_node->target_transform_id) {
       success &= property_trees->ComputeTransformFromTarget(
           clip_node->target_transform_id, parent_clip_node->target_effect_id,
           &parent_to_current);
       const EffectNode* target_effect_node =
           effect_tree.Node(clip_node->target_effect_id);
       PostConcatSurfaceContentsScale(target_effect_node, &parent_to_current);
       const EffectNode* parent_target_effect_node =
           effect_tree.Node(parent_clip_node->target_effect_id);
       ConcatInverseSurfaceContentsScale(parent_target_effect_node,
                                         &parent_to_current);
@@ skipping 11 matching lines @@
                 property_trees));
       }
       parent_clip_in_target_space = MathUtil::ProjectClippedRect(
           parent_to_current, parent_clip_node->clip_in_target_space);
     }
     // Only nodes affected by ancestor clips will have their clip adjusted due
     // to intersecting with an ancestor clip. But, we still need to propagate
     // the combined clip to our children because if they are clipped, they may
     // need to clip using our parent clip and if we don't propagate it here,
     // it will be lost.
-    if (clip_node->resets_clip && non_root_surfaces_enabled) {
+    if (clip_node->resets_clip) {
       if (clip_node->clip_type == ClipNode::ClipType::APPLIES_LOCAL_CLIP) {
         gfx::Transform to_target;
         property_trees->GetToTarget(clip_node->transform_id,
                                     clip_node->target_effect_id, &to_target);
         clip_node->clip_in_target_space =
             MathUtil::MapClippedRect(to_target, clip_node->clip);
         ResetIfHasNanCoordinate(&clip_node->clip_in_target_space);
         clip_node->combined_clip_in_target_space =
             gfx::IntersectRects(clip_node->clip_in_target_space,
                                 parent_combined_clip_in_target_space);
       } else {
         DCHECK(!target_is_clipped);
         DCHECK(!clip_node->layers_are_clipped);
         clip_node->combined_clip_in_target_space =
             parent_combined_clip_in_target_space;
       }
       ResetIfHasNanCoordinate(&clip_node->combined_clip_in_target_space);
       continue;
     }
     bool use_only_parent_clip =
         clip_node->clip_type != ClipNode::ClipType::APPLIES_LOCAL_CLIP;
     if (use_only_parent_clip) {
       clip_node->combined_clip_in_target_space =
           parent_combined_clip_in_target_space;
-      if (!non_root_surfaces_enabled) {
-        clip_node->clip_in_target_space =
-            parent_clip_node->clip_in_target_space;
-      } else if (!target_is_clipped) {
+      if (!target_is_clipped) {
         clip_node->clip_in_target_space = parent_clip_in_target_space;
       } else {
         // Render Surface applies clip and the owning layer itself applies
         // no clip. So, clip_in_target_space is not used and hence we can set
         // it to an empty rect.
         clip_node->clip_in_target_space = gfx::RectF();
       }
     } else {
       gfx::Transform source_to_target;
 
-      if (!non_root_surfaces_enabled) {
-        source_to_target = transform_tree.ToScreen(clip_node->transform_id);
-      } else if (transform_tree.ContentTargetId(transform_node->id) ==
-                 clip_node->target_transform_id) {
+      if (transform_tree.ContentTargetId(transform_node->id) ==
+          clip_node->target_transform_id) {
         property_trees->GetToTarget(clip_node->transform_id,
                                     clip_node->target_effect_id,
                                     &source_to_target);
       } else {
         success = property_trees->GetToTarget(
             transform_node->id, clip_node->target_effect_id, &source_to_target);
         // source_to_target computation should be successful as target is an
         // ancestor of the transform node.
         DCHECK(success);
       }
 
       gfx::RectF source_clip_in_target_space =
           MathUtil::MapClippedRect(source_to_target, clip_node->clip);
 
       // With surfaces disabled, the only case where we use only the local clip
       // for layer clipping is the case where no non-viewport ancestor node
       // applies a local clip.
       bool layer_clipping_uses_only_local_clip =
-          non_root_surfaces_enabled
-              ? clip_node->layer_clipping_uses_only_local_clip
-              : !parent_clip_node->layers_are_clipped_when_surfaces_disabled;
+          clip_node->layer_clipping_uses_only_local_clip;
       if (!layer_clipping_uses_only_local_clip) {
         clip_node->clip_in_target_space = gfx::IntersectRects(
             parent_clip_in_target_space, source_clip_in_target_space);
       } else {
         clip_node->clip_in_target_space = source_clip_in_target_space;
       }
 
       clip_node->combined_clip_in_target_space = gfx::IntersectRects(
           parent_combined_clip_in_target_space, source_clip_in_target_space);
     }
     ResetIfHasNanCoordinate(&clip_node->clip_in_target_space);
     ResetIfHasNanCoordinate(&clip_node->combined_clip_in_target_space);
   }
   clip_tree->set_needs_update(false);
 }
 
 void ComputeTransforms(TransformTree* transform_tree) {
   if (!transform_tree->needs_update())
     return;
   for (int i = TransformTree::kContentsRootNodeId;
        i < static_cast<int>(transform_tree->size()); ++i)
     transform_tree->UpdateTransforms(i);
   transform_tree->set_needs_update(false);
 }
 
-void UpdateRenderTarget(EffectTree* effect_tree,
-                        bool can_render_to_separate_surface) {
+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;
     }
   }
 }
 
 void ComputeEffects(EffectTree* effect_tree) {
   if (!effect_tree->needs_update())
@@ skipping 41 matching lines @@
 static void ComputeLayerClipRect(const PropertyTrees* property_trees,
                                  const LayerImpl* layer) {
   const EffectTree* effect_tree = &property_trees->effect_tree;
   const ClipTree* clip_tree = &property_trees->clip_tree;
   const ClipNode* clip_node = clip_tree->Node(layer->clip_tree_index());
   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_viewport_clip = false;
   bool include_expanding_clips = false;
   ConditionalClip accumulated_clip_rect = ComputeAccumulatedClip(
       property_trees, include_viewport_clip, include_expanding_clips,
       layer->clip_tree_index(), target_node->id);
 
-  bool is_clipped_from_clip_tree =
-      property_trees->non_root_surfaces_enabled
-          ? clip_node->layers_are_clipped
-          : clip_node->layers_are_clipped_when_surfaces_disabled;
+  bool is_clipped_from_clip_tree = clip_node->layers_are_clipped;
   DCHECK_EQ(is_clipped_from_clip_tree, accumulated_clip_rect.is_clipped);
 
   gfx::RectF accumulated_clip = accumulated_clip_rect.clip_rect;
 
   DCHECK(layer->clip_rect() == gfx::ToEnclosingRect(accumulated_clip))
       << " layer: " << layer->id() << " clip id: " << layer->clip_tree_index()
       << " layer clip: " << layer->clip_rect().ToString() << " v.s. "
       << gfx::ToEnclosingRect(accumulated_clip).ToString()
       << " and clip node clip: "
       << gfx::ToEnclosingRect(clip_node->clip_in_target_space).ToString();
 }
 
 static void ComputeVisibleRectsInternal(
     LayerImpl* root_layer,
     PropertyTrees* property_trees,
-    bool can_render_to_separate_surface,
     std::vector<LayerImpl*>* visible_layer_list) {
-  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);
   }
-  UpdateRenderTarget(&property_trees->effect_tree,
-                     property_trees->non_root_surfaces_enabled);
+  UpdateRenderTarget(&property_trees->effect_tree);
   ComputeTransforms(&property_trees->transform_tree);
   // Computation of clips uses surface contents scale which is updated while
   // computing effects. So, ComputeEffects should be before ComputeClips.
   ComputeEffects(&property_trees->effect_tree);
-  ComputeClips(property_trees, can_render_to_separate_surface);
+  ComputeClips(property_trees);
 
   FindLayersThatNeedUpdates(root_layer->layer_tree_impl(), property_trees,
                             visible_layer_list);
-  CalculateClipRects(*visible_layer_list, property_trees,
-                     can_render_to_separate_surface);
-  CalculateVisibleRects(*visible_layer_list, property_trees,
-                        can_render_to_separate_surface);
+  CalculateClipRects(*visible_layer_list, property_trees);
+  CalculateVisibleRects(*visible_layer_list, property_trees);
 }
 
-void UpdatePropertyTrees(PropertyTrees* property_trees,
-                         bool can_render_to_separate_surface) {
-  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);
-  }
+void UpdatePropertyTrees(PropertyTrees* property_trees) {
   if (property_trees->transform_tree.needs_update()) {
     property_trees->clip_tree.set_needs_update(true);
     property_trees->effect_tree.set_needs_update(true);
   }
   ComputeTransforms(&property_trees->transform_tree);
   // Computation of clips uses surface contents scale which is updated while
   // computing effects. So, ComputeEffects should be before ComputeClips.
   ComputeEffects(&property_trees->effect_tree);
-  ComputeClips(property_trees, can_render_to_separate_surface);
+  ComputeClips(property_trees);
 }
 
 void BuildPropertyTreesAndComputeVisibleRects(
     LayerImpl* root_layer,
     const LayerImpl* page_scale_layer,
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
     const LayerImpl* overscroll_elasticity_layer,
     const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
-    bool can_render_to_separate_surface,
     PropertyTrees* property_trees,
     LayerImplList* visible_layer_list) {
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees);
-  ComputeVisibleRects(root_layer, property_trees,
-                      can_render_to_separate_surface, visible_layer_list);
+  ComputeVisibleRects(root_layer, property_trees, visible_layer_list);
 }
 
 void VerifyClipTreeCalculations(const LayerImplList& layer_list,
                                 PropertyTrees* property_trees) {
-  if (property_trees->non_root_surfaces_enabled) {
-    ComputeClipsWithEffectTree(property_trees);
-  }
+  ComputeClipsWithEffectTree(property_trees);
   for (auto* layer : layer_list)
     ComputeLayerClipRect(property_trees, layer);
 }
 
 void ComputeVisibleRects(LayerImpl* root_layer,
                          PropertyTrees* property_trees,
-                         bool can_render_to_separate_surface,
                          LayerImplList* visible_layer_list) {
   for (auto* layer : *root_layer->layer_tree_impl()) {
-    UpdateRenderSurfaceForLayer(&property_trees->effect_tree,
-                                can_render_to_separate_surface, layer);
+    UpdateRenderSurfaceForLayer(&property_trees->effect_tree, layer);
     EffectNode* node =
         property_trees->effect_tree.Node(layer->effect_tree_index());
     if (node->owning_layer_id == layer->id()) {
       node->render_surface = layer->render_surface();
       if (node->render_surface)
         node->render_surface->set_effect_tree_index(node->id);
     }
 #if DCHECK_IS_ON()
-    if (can_render_to_separate_surface)
-      ValidateRenderSurfaceForLayer(layer);
+    ValidateRenderSurfaceForLayer(layer);
 #endif
   }
   ComputeVisibleRectsInternal(root_layer, property_trees,
-                              can_render_to_separate_surface,
                               visible_layer_list);
 }
 
 gfx::Rect ComputeLayerVisibleRectDynamic(const PropertyTrees* property_trees,
                                          const LayerImpl* layer) {
   int effect_ancestor_with_copy_request =
       property_trees->effect_tree.ClosestAncestorWithCopyRequest(
           layer->effect_tree_index());
   bool non_root_copy_request =
       effect_ancestor_with_copy_request > EffectTree::kContentsRootNodeId;
@@ skipping 58 matching lines @@
   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;
 }
 
 static void SetSurfaceDrawTransform(const PropertyTrees* property_trees,
                                     RenderSurfaceImpl* render_surface) {
   const TransformTree& transform_tree = property_trees->transform_tree;
@@ skipping 136 matching lines @@
 
   layer->draw_properties().screen_space_transform =
       ScreenSpaceTransformInternal(layer, property_trees->transform_tree);
   layer->draw_properties().target_space_transform = DrawTransform(
       layer, property_trees->transform_tree, property_trees->effect_tree);
   layer->draw_properties().screen_space_transform_is_animating =
       transform_node->to_screen_is_potentially_animated;
 
   layer->draw_properties().opacity =
       LayerDrawOpacity(layer, property_trees->effect_tree);
-  if (property_trees->non_root_surfaces_enabled) {
-    layer->draw_properties().is_clipped = clip_node->layers_are_clipped;
-  } else {
-    layer->draw_properties().is_clipped =
-        clip_node->layers_are_clipped_when_surfaces_disabled;
-  }
+  layer->draw_properties().is_clipped = clip_node->layers_are_clipped;
 
   gfx::Rect bounds_in_target_space = MathUtil::MapEnclosingClippedRect(
       layer->draw_properties().target_space_transform,
       gfx::Rect(layer->bounds()));
   layer->draw_properties().drawable_content_rect = LayerDrawableContentRect(
       layer, bounds_in_target_space, layer->draw_properties().clip_rect);
 }
 
 void ComputeMaskDrawProperties(LayerImpl* mask_layer,
                                const PropertyTrees* property_trees) {
@@ skipping 119 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