cc: Make property trees support resourceless draw mode

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 <vector>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/draw_properties.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/render_surface_draw_properties.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/property_tree.h"
 #include "cc/trees/property_tree_builder.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 
 namespace {
 
 template <typename LayerType>
 void CalculateVisibleRects(const std::vector<LayerType*>& visible_layer_list,
                            const ClipTree& clip_tree,
-                           const TransformTree& transform_tree) {
+                           const TransformTree& transform_tree,
+                           bool non_root_surfaces_enabled) {
   for (auto& layer : visible_layer_list) {
     gfx::Size layer_bounds = layer->bounds();
     const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index());
-    const bool is_unclipped =
-        clip_node->data.resets_clip && !clip_node->data.applies_local_clip;
+    const bool is_unclipped = clip_node->data.resets_clip &&
+                              !clip_node->data.applies_local_clip &&
+                              non_root_surfaces_enabled;
     // When both the layer and the target are unclipped, the entire layer
     // content rect is visible.
     const bool fully_visible = !clip_node->data.layers_are_clipped &&
-                               !clip_node->data.target_is_clipped;
+                               !clip_node->data.target_is_clipped &&
+                               non_root_surfaces_enabled;
     const TransformNode* transform_node =
         transform_tree.Node(layer->transform_tree_index());
     if (!is_unclipped && !fully_visible) {
       const TransformNode* target_node =
-          transform_tree.Node(transform_node->data.content_target_id);
+          non_root_surfaces_enabled
+              ? transform_tree.Node(transform_node->data.content_target_id)
+              : transform_tree.Node(0);
 
       // The clip node stores clip rect in its target space. If required,
       // this clip rect should be mapped to the current layer's target space.
       gfx::Rect clip_rect_in_target_space;
       gfx::Rect combined_clip_rect_in_target_space;
       bool success = true;
 
-      if (clip_node->data.target_id != target_node->id) {
+      // When we only have a root surface, the clip node and the layer must
+      // necessarily have the same target (the root).
+      if (clip_node->data.target_id != target_node->id &&
+          non_root_surfaces_enabled) {
         // In this case, layer has a clip parent (or shares the target with an
         // ancestor layer that has clip parent) and the clip parent's target is
         // different from the layer's target. As the layer's target has
         // unclippped descendants, it is unclippped.
         if (!clip_node->data.layers_are_clipped) {
           layer->set_visible_rect_from_property_trees(gfx::Rect(layer_bounds));
           layer->set_clip_rect_in_target_space_from_property_trees(gfx::Rect());
           continue;
         }
         gfx::Transform clip_to_target;
@@ skipping 16 matching lines @@
         // visible rect computation.
         combined_clip_rect_in_target_space =
             gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
                 clip_to_target, clip_node->data.clip_in_target_space));
         clip_rect_in_target_space =
             gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
                 clip_to_target, clip_node->data.clip_in_target_space));
       } else {
         clip_rect_in_target_space =
             gfx::ToEnclosingRect(clip_node->data.clip_in_target_space);
-        if (clip_node->data.target_is_clipped)
+        if (clip_node->data.target_is_clipped || !non_root_surfaces_enabled)
           combined_clip_rect_in_target_space = gfx::ToEnclosingRect(
               clip_node->data.combined_clip_in_target_space);
         else
           combined_clip_rect_in_target_space = clip_rect_in_target_space;
       }
 
       if (!clip_rect_in_target_space.IsEmpty()) {
         layer->set_clip_rect_in_target_space_from_property_trees(
             clip_rect_in_target_space);
       } else {
         layer->set_clip_rect_in_target_space_from_property_trees(gfx::Rect());
       }
 
       // The clip rect should be intersected with layer rect in target space.
-      gfx::Transform content_to_target = transform_node->data.to_target;
+      gfx::Transform content_to_target = non_root_surfaces_enabled
+                                             ? transform_node->data.to_target
+                                             : transform_node->data.to_screen;
 
       content_to_target.Translate(layer->offset_to_transform_parent().x(),
                                   layer->offset_to_transform_parent().y());
       gfx::Rect layer_content_rect = gfx::Rect(layer_bounds);
       gfx::Rect layer_content_bounds_in_target_space =
           MathUtil::MapEnclosingClippedRect(content_to_target,
                                             layer_content_rect);
       combined_clip_rect_in_target_space.Intersect(
           layer_content_bounds_in_target_space);
       if (combined_clip_rect_in_target_space.IsEmpty()) {
         layer->set_visible_rect_from_property_trees(gfx::Rect());
         continue;
       }
 
       // If the layer is fully contained within the clip, treat it as fully
       // visible. Since clip_rect_in_target_space has already been intersected
       // with layer_content_bounds_in_target_space, the layer is fully contained
       // within the clip iff these rects are equal.
       if (combined_clip_rect_in_target_space ==
           layer_content_bounds_in_target_space) {
         layer->set_visible_rect_from_property_trees(gfx::Rect(layer_bounds));
         continue;
       }
 
       gfx::Transform target_to_content;
       gfx::Transform target_to_layer;
 
       if (transform_node->data.ancestors_are_invertible) {
-        target_to_layer = transform_node->data.from_target;
+        target_to_layer = non_root_surfaces_enabled
+                              ? transform_node->data.from_target
+                              : transform_node->data.from_screen;
         success = true;
       } else {
         success = transform_tree.ComputeTransformWithSourceSublayerScale(
             target_node->id, transform_node->id, &target_to_layer);
       }
 
       if (!success) {
         // An animated singular transform may become non-singular during the
         // animation, so we still need to compute a visible rect. In this
         // situation, we treat the entire layer as visible.
@@ skipping 268 matching lines @@
   }
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     FindLayersThatNeedUpdates(layer->child_at(i), tree, layer_is_drawn,
                               update_layer_list, visible_layer_list);
   }
 }
 
 }  // namespace
 
-void ComputeClips(ClipTree* clip_tree, const TransformTree& transform_tree) {
+void ComputeClips(ClipTree* clip_tree,
+                  const TransformTree& transform_tree,
+                  bool non_root_surfaces_enabled) {
   if (!clip_tree->needs_update())
     return;
   for (int i = 1; i < static_cast<int>(clip_tree->size()); ++i) {
     ClipNode* clip_node = clip_tree->Node(i);
 
     if (clip_node->id == 1) {
       clip_node->data.combined_clip_in_target_space = clip_node->data.clip;
       clip_node->data.clip_in_target_space = clip_node->data.clip;
       continue;
     }
@@ skipping 11 matching lines @@
     // transforms. Say we have the following tree T->A->B->C, and B clips C, but
     // draw into target T. It may be the case that A applies a perspective
     // transform, and B and C are at different z positions. When projected into
     // 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->data.combined_clip_in_target_space;
-    if (parent_clip_node->data.target_id != clip_node->data.target_id) {
+    if (parent_clip_node->data.target_id != clip_node->data.target_id &&
+        non_root_surfaces_enabled) {
       success &= transform_tree.ComputeTransformWithDestinationSublayerScale(
           parent_clip_node->data.target_id, clip_node->data.target_id,
           &parent_to_current);
       if (parent_transform_node->data.sublayer_scale.x() > 0 &&
           parent_transform_node->data.sublayer_scale.y() > 0)
         parent_to_current.Scale(
             1.f / parent_transform_node->data.sublayer_scale.x(),
             1.f / parent_transform_node->data.sublayer_scale.y());
       // If we can't compute a transform, it's because we had to use the inverse
       // of a singular transform. We won't draw in this case, so there's no need
       // to compute clips.
       if (!success)
         continue;
       parent_combined_clip_in_target_space = MathUtil::ProjectClippedRect(
           parent_to_current,
           parent_clip_node->data.combined_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->data.resets_clip) {
+    if (clip_node->data.resets_clip && non_root_surfaces_enabled) {
       if (clip_node->data.applies_local_clip) {
         clip_node->data.clip_in_target_space = MathUtil::MapClippedRect(
             transform_node->data.to_target, clip_node->data.clip);
         clip_node->data.combined_clip_in_target_space =
             gfx::IntersectRects(clip_node->data.clip_in_target_space,
                                 parent_combined_clip_in_target_space);
       } else {
         DCHECK(!clip_node->data.target_is_clipped);
         DCHECK(!clip_node->data.layers_are_clipped);
         clip_node->data.combined_clip_in_target_space =
             parent_combined_clip_in_target_space;
       }
       continue;
     }
 
     bool use_only_parent_clip = !clip_node->data.applies_local_clip;
     if (use_only_parent_clip) {
       clip_node->data.combined_clip_in_target_space =
           parent_combined_clip_in_target_space;
-      if (!clip_node->data.target_is_clipped) {
+      if (!non_root_surfaces_enabled) {
+        clip_node->data.clip_in_target_space =
+            parent_clip_node->data.clip_in_target_space;
+      } else if (!clip_node->data.target_is_clipped) {
         clip_node->data.clip_in_target_space =
             parent_combined_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->data.clip_in_target_space = gfx::RectF();
       }
     } else {
       gfx::Transform source_to_target;
 
-      if (transform_node->data.content_target_id == clip_node->data.target_id) {
+      if (!non_root_surfaces_enabled) {
+        source_to_target = transform_node->data.to_screen;
+      } else if (transform_node->data.content_target_id ==
+                 clip_node->data.target_id) {
         source_to_target = transform_node->data.to_target;
       } else {
         success = transform_tree.ComputeTransformWithDestinationSublayerScale(
             transform_node->id, clip_node->data.target_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->data.clip);
 
-      if (!clip_node->data.layer_clipping_uses_only_local_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->data.layer_clipping_uses_only_local_clip
+              : !parent_clip_node->data
+                     .layers_are_clipped_when_surfaces_disabled;
+      if (!layer_clipping_uses_only_local_clip) {
         gfx::RectF parent_clip_in_target_space = MathUtil::ProjectClippedRect(
             parent_to_current, parent_clip_node->data.clip_in_target_space);
         clip_node->data.clip_in_target_space = gfx::IntersectRects(
             parent_clip_in_target_space, source_clip_in_target_space);
       } else {
         clip_node->data.clip_in_target_space = source_clip_in_target_space;
       }
 
       clip_node->data.combined_clip_in_target_space = gfx::IntersectRects(
           parent_combined_clip_in_target_space, source_clip_in_target_space);
@@ skipping 15 matching lines @@
     return;
   for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i)
     effect_tree->UpdateOpacities(i);
   effect_tree->set_needs_update(false);
 }
 
 template <typename LayerType>
 void ComputeVisibleRectsUsingPropertyTreesInternal(
     LayerType* root_layer,
     PropertyTrees* property_trees,
+    bool can_render_to_separate_surface,
     typename LayerType::LayerListType* update_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);
   ComputeTransforms(&property_trees->transform_tree);
-  ComputeClips(&property_trees->clip_tree, property_trees->transform_tree);
+  ComputeClips(&property_trees->clip_tree, property_trees->transform_tree,
+               can_render_to_separate_surface);
   ComputeOpacities(&property_trees->effect_tree);
 
   const bool subtree_is_visible_from_ancestor = true;
   std::vector<LayerType*> visible_layer_list;
   FindLayersThatNeedUpdates(root_layer, property_trees->transform_tree,
                             subtree_is_visible_from_ancestor, update_layer_list,
                             &visible_layer_list);
-  CalculateVisibleRects<LayerType>(visible_layer_list,
-                                   property_trees->clip_tree,
-                                   property_trees->transform_tree);
+  CalculateVisibleRects<LayerType>(
+      visible_layer_list, property_trees->clip_tree,
+      property_trees->transform_tree, can_render_to_separate_surface);
 }
 
 void BuildPropertyTreesAndComputeVisibleRects(
     Layer* root_layer,
     const Layer* page_scale_layer,
     const Layer* inner_viewport_scroll_layer,
     const Layer* outer_viewport_scroll_layer,
     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,
     LayerList* update_layer_list) {
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, page_scale_factor, device_scale_factor,
       viewport, device_transform, property_trees);
   ComputeVisibleRectsUsingPropertyTrees(root_layer, property_trees,
+                                        can_render_to_separate_surface,
                                         update_layer_list);
 }
 
 void BuildPropertyTreesAndComputeVisibleRects(
     LayerImpl* root_layer,
     const LayerImpl* page_scale_layer,
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
     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* update_layer_list) {
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, page_scale_factor, device_scale_factor,
       viewport, device_transform, property_trees);
   ComputeVisibleRectsUsingPropertyTrees(root_layer, property_trees,
+                                        can_render_to_separate_surface,
                                         update_layer_list);
 }
 
 void ComputeVisibleRectsUsingPropertyTrees(Layer* root_layer,
                                            PropertyTrees* property_trees,
+                                           bool can_render_to_separate_surface,
                                            LayerList* update_layer_list) {
   ComputeVisibleRectsUsingPropertyTreesInternal(root_layer, property_trees,
+                                                can_render_to_separate_surface,
                                                 update_layer_list);
 }
 
 void ComputeVisibleRectsUsingPropertyTrees(LayerImpl* root_layer,
                                            PropertyTrees* property_trees,
+                                           bool can_render_to_separate_surface,
                                            LayerImplList* update_layer_list) {
   ComputeVisibleRectsUsingPropertyTreesInternal(root_layer, property_trees,
+                                                can_render_to_separate_surface,
                                                 update_layer_list);
 }
 
 template <typename LayerType>
 gfx::Transform DrawTransformFromPropertyTreesInternal(
     const LayerType* layer,
     const TransformNode* node) {
   gfx::Transform xform;
   const bool owns_non_root_surface =
       layer->parent() && layer->has_render_surface();
@@ skipping 213 matching lines @@
   draw_properties->visible_layer_rect =
       layer->visible_rect_from_property_trees();
 
   const TransformNode* transform_node =
       property_trees->transform_tree.Node(layer->transform_tree_index());
   const EffectNode* effect_node =
       property_trees->effect_tree.Node(layer->effect_tree_index());
   const ClipNode* clip_node =
       property_trees->clip_tree.Node(layer->clip_tree_index());
 
-  draw_properties->target_space_transform =
-      DrawTransformFromPropertyTreesInternal(layer, transform_node);
   draw_properties->screen_space_transform =
       ScreenSpaceTransformFromPropertyTreesInternal(layer, transform_node);
+  if (property_trees->non_root_surfaces_enabled) {
+    draw_properties->target_space_transform =
+        DrawTransformFromPropertyTreesInternal(layer, transform_node);
+  } else {
+    draw_properties->target_space_transform =
+        draw_properties->screen_space_transform;
+  }
   draw_properties->screen_space_transform_is_animating =
       transform_node->data.to_screen_is_animated;
   if (layer->layer_tree_impl()
           ->settings()
           .layer_transforms_should_scale_layer_contents) {
     draw_properties->maximum_animation_contents_scale =
         transform_node->data.combined_maximum_animation_target_scale;
     draw_properties->starting_animation_contents_scale =
         transform_node->data.combined_starting_animation_scale;
   } else {
     draw_properties->maximum_animation_contents_scale = 0.f;
     draw_properties->starting_animation_contents_scale = 0.f;
   }
 
   draw_properties->opacity =
       LayerDrawOpacity(layer, property_trees->effect_tree);
   draw_properties->can_use_lcd_text =
       LayerCanUseLcdText(layer, layers_always_allowed_lcd_text,
                          can_use_lcd_text, transform_node, effect_node);
-  draw_properties->is_clipped = clip_node->data.layers_are_clipped;
+  if (property_trees->non_root_surfaces_enabled) {
+    draw_properties->is_clipped = clip_node->data.layers_are_clipped;
+  } else {
+    draw_properties->is_clipped =
+        clip_node->data.layers_are_clipped_when_surfaces_disabled;
+  }
 
   gfx::Rect bounds_in_target_space = MathUtil::MapEnclosingClippedRect(
       draw_properties->target_space_transform, gfx::Rect(layer->bounds()));
   draw_properties->clip_rect = LayerClipRect(layer, bounds_in_target_space);
   draw_properties->drawable_content_rect = LayerDrawableContentRect(
       layer, bounds_in_target_space, draw_properties->clip_rect);
 }
 
 void ComputeSurfaceDrawPropertiesUsingPropertyTrees(
     RenderSurfaceImpl* render_surface,
@@ skipping 81 matching lines @@
     const Layer* page_scale_layer,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Transform device_transform) {
   UpdatePageScaleFactorInPropertyTreesInternal(
       property_trees, page_scale_layer, page_scale_factor, device_scale_factor,
       device_transform);
 }
 
 }  // namespace cc