cc: Rename clip rects in 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"
@@ skipping 131 matching lines @@
 }
 
 template <typename LayerType>
 static inline bool LayerClipsSubtree(LayerType* layer) {
   return layer->masks_to_bounds() || layer->mask_layer();
 }
 
 template <typename LayerType>
 static gfx::Rect CalculateVisibleContentRect(
     LayerType* layer,
-    gfx::Rect ancestor_clip_rect_in_descendant_surface_space,
+    gfx::Rect clip_rect_of_target_surface_in_target_space,
     gfx::Rect layer_rect_in_target_space) {
   DCHECK(layer->render_target());
 
   // Nothing is visible if the layer bounds are empty.
   if (!layer->DrawsContent() || layer->content_bounds().IsEmpty() ||
       layer->drawable_content_rect().IsEmpty())
     return gfx::Rect();
 
   // Compute visible bounds in target surface space.
   gfx::Rect visible_rect_in_target_surface_space =
       layer->drawable_content_rect();
 
   if (!layer->render_target()->render_surface()->clip_rect().IsEmpty()) {
-    // In this case the target surface does clip layers that contribute to
-    // it. So, we have to convert the current surface's clip rect from its
-    // ancestor surface space to the current (descendant) surface
-    // space. This conversion is done outside this function so that it can
-    // be cached instead of computing it redundantly for every layer.
+    // The |layer| L has a target T which owns a surface Ts. The surface Ts
+    // has a target TsT.
+    //
+    // In this case the target surface Ts does clip the layer L that contributes
+    // to it. So, we have to convert the clip rect of Ts from the target space
+    // of Ts (that is the space of TsT), to the current render target's space
+    // (that is the space of T). This conversion is done outside this function
+    // so that it can be cached instead of computing it redundantly for every
+    // layer.
     visible_rect_in_target_surface_space.Intersect(
-        ancestor_clip_rect_in_descendant_surface_space);
+        clip_rect_of_target_surface_in_target_space);
   }
 
   if (visible_rect_in_target_surface_space.IsEmpty())
     return gfx::Rect();
 
   return CalculateVisibleRectWithCachedLayerRect(
       visible_rect_in_target_surface_space,
       gfx::Rect(layer->content_bounds()),
       layer_rect_in_target_space,
       layer->draw_transform());
@@ skipping 672 matching lines @@
 // the necessary transformations, clip rects, render surfaces, etc.
 template <typename LayerType,
           typename LayerListType,
           typename RenderSurfaceType>
 static void CalculateDrawPropertiesInternal(
     LayerType* layer,
     const gfx::Transform& parent_matrix,
     const gfx::Transform& full_hierarchy_matrix,
     const gfx::Transform& current_scroll_compensation_matrix,
     LayerType* current_fixed_container,
-    gfx::Rect clip_rect_from_ancestor,
-    gfx::Rect clip_rect_from_ancestor_in_descendant_space,
+    gfx::Rect clip_rect_from_ancestor_in_ancestor_target_space,
+    gfx::Rect clip_rect_of_target_surface_from_ancestor_in_target_space,
     bool ancestor_clips_subtree,
     RenderSurfaceType* nearest_ancestor_that_moves_pixels,
     LayerListType* render_surface_layer_list,
     LayerListType* layer_list,
     LayerSorter* layer_sorter,
     int max_texture_size,
     float device_scale_factor,
     float page_scale_factor,
     LayerType* page_scale_application_layer,
     bool in_subtree_of_page_scale_application_layer,
@@ skipping 143 matching lines @@
   if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_visible))
     return;
 
   // As this function proceeds, these are the properties for the current
   // layer that actually get computed. To avoid unnecessary copies
   // (particularly for matrices), we do computations directly on these values
   // when possible.
   DrawProperties<LayerType, RenderSurfaceType>& layer_draw_properties =
       layer->draw_properties();
 
-  gfx::Rect clip_rect_for_subtree;
-  bool subtree_should_be_clipped = false;
+  gfx::Rect clip_rect_in_target_space;
+  bool layer_or_ancestor_clips_descendants = false;
 
   // This value is cached on the stack so that we don't have to inverse-project
   // the surface's clip rect redundantly for every layer. This value is the
-  // same as the surface's clip rect, except that instead of being described
-  // in the target surface space (i.e. the ancestor surface space), it is
-  // described in the current surface space.
-  gfx::Rect clip_rect_for_subtree_in_descendant_space;
+  // same as the target surface's clip rect, except that instead of being
+  // described in the target surface's target's space, it is described in the
+  // current render target's space.
+  gfx::Rect clip_rect_of_target_surface_in_target_space;
 
   float accumulated_draw_opacity = layer->opacity();
   bool animating_opacity_to_target = layer->OpacityIsAnimating();
   bool animating_opacity_to_screen = animating_opacity_to_target;
   if (layer->parent()) {
     accumulated_draw_opacity *= layer->parent()->draw_opacity();
     animating_opacity_to_target |= layer->parent()->draw_opacity_is_animating();
     animating_opacity_to_screen |=
         layer->parent()->screen_space_opacity_is_animating();
   }
@@ skipping 179 matching lines @@
 
     // Update the aggregate hierarchy matrix to include the transform of the
     // newly created RenderSurfaceImpl.
     next_hierarchy_matrix.PreconcatTransform(render_surface->draw_transform());
 
     // The new render_surface here will correctly clip the entire subtree. So,
     // we do not need to continue propagating the clipping state further down
     // the tree. This way, we can avoid transforming clip rects from ancestor
     // target surface space to current target surface space that could cause
     // more w < 0 headaches.
-    subtree_should_be_clipped = false;
+    layer_or_ancestor_clips_descendants = false;
 
     if (layer->mask_layer()) {
       DrawProperties<LayerType, RenderSurfaceType>& mask_layer_draw_properties =
           layer->mask_layer()->draw_properties();
       mask_layer_draw_properties.render_target = layer;
       mask_layer_draw_properties.visible_content_rect =
           gfx::Rect(layer->content_bounds());
     }
 
     if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
       DrawProperties<LayerType, RenderSurfaceType>&
       replica_mask_draw_properties =
           layer->replica_layer()->mask_layer()->draw_properties();
       replica_mask_draw_properties.render_target = layer;
       replica_mask_draw_properties.visible_content_rect =
           gfx::Rect(layer->content_bounds());
     }
 
     // TODO(senorblanco): make this smarter for the SkImageFilter case (check
     // for pixel-moving filters)
     if (layer->filters().HasFilterThatMovesPixels() || layer->filter())
       nearest_ancestor_that_moves_pixels = render_surface;
 
     // The render surface clip rect is expressed in the space where this surface
-    // draws, i.e. the same space as clip_rect_from_ancestor.
+    // draws, i.e. the same space as
+    // clip_rect_from_ancestor_in_ancestor_target_space.
     render_surface->SetIsClipped(ancestor_clips_subtree);
     if (ancestor_clips_subtree) {
-      render_surface->SetClipRect(clip_rect_from_ancestor);
+      render_surface->SetClipRect(
+          clip_rect_from_ancestor_in_ancestor_target_space);
 
       gfx::Transform inverse_surface_draw_transform(
           gfx::Transform::kSkipInitialization);
       if (!render_surface->draw_transform().GetInverse(
               &inverse_surface_draw_transform)) {
         // TODO(shawnsingh): Either we need to handle uninvertible transforms
         // here, or DCHECK that the transform is invertible.
       }
-      clip_rect_for_subtree_in_descendant_space =
+      clip_rect_of_target_surface_in_target_space =
           gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
               inverse_surface_draw_transform, render_surface->clip_rect()));
     } else {
       render_surface->SetClipRect(gfx::Rect());
-      clip_rect_for_subtree_in_descendant_space =
-          clip_rect_from_ancestor_in_descendant_space;
+      clip_rect_of_target_surface_in_target_space =
+          clip_rect_of_target_surface_from_ancestor_in_target_space;
     }
 
     render_surface->SetNearestAncestorThatMovesPixels(
         nearest_ancestor_that_moves_pixels);
 
     // If the new render surface is drawn translucent or with a non-integral
     // translation then the subtree that gets drawn on this render surface
     // cannot use LCD text.
     subtree_can_use_lcd_text = layer_can_use_lcd_text;
 
@@ skipping 10 matching lines @@
     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;
     sublayer_matrix = combined_transform;
 
     layer->ClearRenderSurface();
 
     // Layers without render_surfaces directly inherit the ancestor's clip
     // status.
-    subtree_should_be_clipped = ancestor_clips_subtree;
-    if (ancestor_clips_subtree)
-      clip_rect_for_subtree = clip_rect_from_ancestor;
+    layer_or_ancestor_clips_descendants = ancestor_clips_subtree;
+    if (ancestor_clips_subtree) {
+      clip_rect_in_target_space =
+          clip_rect_from_ancestor_in_ancestor_target_space;
+    }
 
     // The surface's cached clip rect value propagates regardless of what
     // clipping goes on between layers here.
-    clip_rect_for_subtree_in_descendant_space =
-        clip_rect_from_ancestor_in_descendant_space;
+    clip_rect_of_target_surface_in_target_space =
+        clip_rect_of_target_surface_from_ancestor_in_target_space;
 
     // Layers that are not their own render_target will render into the target
     // of their nearest ancestor.
     layer_draw_properties.render_target = layer->parent()->render_target();
   }
 
   // Mark whether a layer could be drawn directly to the back buffer, for
   // example when it could use LCD text even though it's in a non-contents
   // opaque layer.  This means that it can't be drawn to an intermediate
   // render target and also that no blending is applied to the layer as a whole
   // (meaning that its contents don't have to be pre-composited into a bitmap or
   // a render target).
   //
   // Ignoring animations is an optimization,
   // as it means that we're going to need some retained resources for this
   // layer in the near future even if its opacity is 1 now.
   layer_draw_properties.can_draw_directly_to_backbuffer =
       IsRootLayer(layer_draw_properties.render_target) &&
       layer->draw_properties().opacity == 1.f &&
       !animating_opacity_to_screen;
 
   if (adjust_text_aa)
     layer_draw_properties.can_use_lcd_text = layer_can_use_lcd_text;
 
   gfx::Rect rect_in_target_space = ToEnclosingRect(
       MathUtil::MapClippedRect(layer->draw_transform(), content_rect));
 
   if (LayerClipsSubtree(layer)) {
-    subtree_should_be_clipped = true;
+    layer_or_ancestor_clips_descendants = true;
     if (ancestor_clips_subtree && !layer->render_surface()) {
-      clip_rect_for_subtree = clip_rect_from_ancestor;
-      clip_rect_for_subtree.Intersect(rect_in_target_space);
+      // A layer without render surface shares the same target as its ancestor.
+      clip_rect_in_target_space =
+          clip_rect_from_ancestor_in_ancestor_target_space;
+      clip_rect_in_target_space.Intersect(rect_in_target_space);
     } else {
-      clip_rect_for_subtree = rect_in_target_space;
+      clip_rect_in_target_space = rect_in_target_space;
     }
   }
 
   if (layer == page_scale_application_layer) {
     sublayer_matrix.Scale(page_scale_factor, page_scale_factor);
     in_subtree_of_page_scale_application_layer = true;
   }
 
   // Flatten to 2D if the layer doesn't preserve 3D.
   if (!layer->preserves_3d())
@@ skipping 35 matching lines @@
     gfx::Rect drawable_content_rect_of_child_subtree;
     gfx::Transform identity_matrix;
     CalculateDrawPropertiesInternal<LayerType,
                                     LayerListType,
                                     RenderSurfaceType>(
         child,
         sublayer_matrix,
         next_hierarchy_matrix,
         next_scroll_compensation_matrix,
         next_fixed_container,
-        clip_rect_for_subtree,
-        clip_rect_for_subtree_in_descendant_space,
-        subtree_should_be_clipped,
+        clip_rect_in_target_space,
+        clip_rect_of_target_surface_in_target_space,
+        layer_or_ancestor_clips_descendants,
         nearest_ancestor_that_moves_pixels,
         render_surface_layer_list,
         &descendants,
         layer_sorter,
         max_texture_size,
         device_scale_factor,
         page_scale_factor,
         page_scale_application_layer,
         in_subtree_of_page_scale_application_layer,
         subtree_can_use_lcd_text,
@@ skipping 13 matching lines @@
     RemoveSurfaceForEarlyExit(layer, render_surface_layer_list);
     return;
   }
 
   // Compute the total drawable_content_rect for this subtree (the rect is in
   // target surface space).
   gfx::Rect local_drawable_content_rect_of_subtree =
       accumulated_drawable_content_rect_of_children;
   if (layer->DrawsContent())
     local_drawable_content_rect_of_subtree.Union(rect_in_target_space);
-  if (subtree_should_be_clipped)
-    local_drawable_content_rect_of_subtree.Intersect(clip_rect_for_subtree);
+  if (layer_or_ancestor_clips_descendants)
+    local_drawable_content_rect_of_subtree.Intersect(clip_rect_in_target_space);
 
   // Compute the layer's drawable content rect (the rect is in target surface
   // space).
   layer_draw_properties.drawable_content_rect = rect_in_target_space;
-  if (subtree_should_be_clipped) {
+  if (layer_or_ancestor_clips_descendants) {
     layer_draw_properties.drawable_content_rect.
-        Intersect(clip_rect_for_subtree);
+        Intersect(clip_rect_in_target_space);
   }
 
   // Tell the layer the rect that is clipped by. In theory we could use a
   // tighter clip rect here (drawable_content_rect), but that actually does not
   // reduce how much would be drawn, and instead it would create unnecessary
   // changes to scissor state affecting GPU performance.
-  layer_draw_properties.is_clipped = subtree_should_be_clipped;
-  if (subtree_should_be_clipped) {
-    layer_draw_properties.clip_rect = clip_rect_for_subtree;
+  layer_draw_properties.is_clipped = layer_or_ancestor_clips_descendants;
+  if (layer_or_ancestor_clips_descendants) {
+    layer_draw_properties.clip_rect = clip_rect_in_target_space;
   } else {
     // Initialize the clip rect to a safe value that will not clip the
     // layer, just in case clipping is still accidentally used.
     layer_draw_properties.clip_rect = rect_in_target_space;
   }
 
-  // Compute the layer's visible content rect (the rect is in content space)
+  // Compute the layer's visible content rect (the rect is in content space).
   layer_draw_properties.visible_content_rect = CalculateVisibleContentRect(
-      layer, clip_rect_for_subtree_in_descendant_space, rect_in_target_space);
+      layer, clip_rect_of_target_surface_in_target_space, rect_in_target_space);
 
   // Compute the remaining properties for the render surface, if the layer has
   // one.
   if (IsRootLayer(layer)) {
     // The root layer's surface's content_rect is always the entire viewport.
     DCHECK(layer->render_surface());
-    layer->render_surface()->SetContentRect(clip_rect_from_ancestor);
+    layer->render_surface()->SetContentRect(
+        clip_rect_from_ancestor_in_ancestor_target_space);
   } else if (layer->render_surface() && !IsRootLayer(layer)) {
     RenderSurfaceType* render_surface = layer->render_surface();
     gfx::Rect clipped_content_rect = local_drawable_content_rect_of_subtree;
 
     // Don't clip if the layer is reflected as the reflection shouldn't be
     // clipped. If the layer is animating, then the surface's transform to
     // its target is not known on the main thread, and we should not use it
     // to clip.
     if (!layer->replica_layer() && TransformToParentIsKnown(layer)) {
       // Note, it is correct to use ancestor_clips_subtree here, because we are
@@ skipping 108 matching lines @@
     bool can_adjust_raster_scales,
     RenderSurfaceLayerList* render_surface_layer_list) {
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
   gfx::Transform scaled_device_transform = device_transform;
   scaled_device_transform.Scale(device_scale_factor, device_scale_factor);
   RenderSurfaceLayerList dummy_layer_list;
 
   // The root layer's render_surface should receive the device viewport as the
   // initial clip rect.
-  bool subtree_should_be_clipped = true;
+  bool layer_or_ancestor_clips_descendants = true;
   gfx::Rect device_viewport_rect(device_viewport_size);
   bool in_subtree_of_page_scale_application_layer = false;
   bool subtree_is_visible = true;
 
   // This function should have received a root layer.
   DCHECK(IsRootLayer(root_layer));
 
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformation(root_layer, &recursive_data);
 
   CalculateDrawPropertiesInternal<Layer, RenderSurfaceLayerList, RenderSurface>(
       root_layer,
       scaled_device_transform,
       identity_matrix,
       identity_matrix,
       root_layer,
       device_viewport_rect,
       device_viewport_rect,
-      subtree_should_be_clipped,
+      layer_or_ancestor_clips_descendants,
       NULL,
       render_surface_layer_list,
       &dummy_layer_list,
       NULL,
       max_texture_size,
       device_scale_factor,
       page_scale_factor,
       page_scale_application_layer,
       in_subtree_of_page_scale_application_layer,
       can_use_lcd_text,
@@ skipping 21 matching lines @@
     LayerImplList* render_surface_layer_list) {
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
   gfx::Transform scaled_device_transform = device_transform;
   scaled_device_transform.Scale(device_scale_factor, device_scale_factor);
   LayerImplList dummy_layer_list;
   LayerSorter layer_sorter;
 
   // The root layer's render_surface should receive the device viewport as the
   // initial clip rect.
-  bool subtree_should_be_clipped = true;
+  bool layer_or_ancestor_clips_descendants = true;
   gfx::Rect device_viewport_rect(device_viewport_size);
   bool in_subtree_of_page_scale_application_layer = false;
   bool subtree_is_visible = true;
 
   // This function should have received a root layer.
   DCHECK(IsRootLayer(root_layer));
 
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformation(root_layer, &recursive_data);
 
   CalculateDrawPropertiesInternal<LayerImpl,
                                   LayerImplList,
                                   RenderSurfaceImpl>(
       root_layer,
       scaled_device_transform,
       identity_matrix,
       identity_matrix,
       root_layer,
       device_viewport_rect,
       device_viewport_rect,
-      subtree_should_be_clipped,
+      layer_or_ancestor_clips_descendants,
       NULL,
       render_surface_layer_list,
       &dummy_layer_list,
       &layer_sorter,
       max_texture_size,
       device_scale_factor,
       page_scale_factor,
       page_scale_application_layer,
       in_subtree_of_page_scale_application_layer,
       can_use_lcd_text,
@@ skipping 193 matching lines @@
   // At this point, we think the point does hit the touch event handler region
   // on the layer, but we need to walk up the parents to ensure that the layer
   // was not clipped in such a way that the hit point actually should not hit
   // the layer.
   if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 }  // namespace cc