cc: Visible Rect Calculation use RectF between transformations

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 44 matching lines @@
   DCHECK(!layer->replica_layer()) << "layer: " << layer->id();
 }
 
 #endif
 
 template <typename LayerType>
 bool ComputeClipRectInTargetSpace(const LayerType* layer,
                                   const ClipNode* clip_node,
                                   const TransformTree& transform_tree,
                                   int target_node_id,
-                                  gfx::Rect* clip_rect_in_target_space) {
+                                  gfx::RectF* clip_rect_in_target_space) {
   DCHECK(layer->clip_tree_index() == clip_node->id);
   DCHECK(clip_node->data.target_id != target_node_id);
 
   gfx::Transform clip_to_target;
   if (clip_node->data.target_id > target_node_id) {
     // In this case, layer has a scroll parent. We need to keep the scale
     // at the layer's target but remove the scale at the scroll parent's
     // target.
     if (transform_tree.ComputeTransformWithDestinationSublayerScale(
             clip_node->data.target_id, target_node_id, &clip_to_target)) {
       const TransformNode* source_node =
           transform_tree.Node(clip_node->data.target_id);
       if (source_node->data.sublayer_scale.x() != 0.f &&
           source_node->data.sublayer_scale.y() != 0.f)
         clip_to_target.Scale(1.0f / source_node->data.sublayer_scale.x(),
                              1.0f / source_node->data.sublayer_scale.y());
-      *clip_rect_in_target_space =
-          gfx::ToEnclosingRect(MathUtil::MapClippedRect(
-              clip_to_target, clip_node->data.clip_in_target_space));
+      *clip_rect_in_target_space = MathUtil::MapClippedRect(
+          clip_to_target, clip_node->data.clip_in_target_space);
     } else {
       return false;
     }
   } else {
     if (transform_tree.ComputeTransform(clip_node->data.target_id,
                                         target_node_id, &clip_to_target)) {
-      *clip_rect_in_target_space =
-          gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
-              clip_to_target, clip_node->data.clip_in_target_space));
+      *clip_rect_in_target_space = MathUtil::ProjectClippedRect(
+          clip_to_target, clip_node->data.clip_in_target_space);
     } else {
       return false;
     }
   }
   return true;
 }
 
 template <typename LayerType>
 void CalculateClipRects(
     const typename LayerType::LayerListType& visible_layer_list,
@@ skipping 20 matching lines @@
     // content rect is visible.
     const bool fully_visible = !clip_node->data.layers_are_clipped &&
                                !clip_node->data.target_is_clipped;
 
     if (!fully_visible) {
       const TransformNode* transform_node =
           transform_tree.Node(layer->transform_tree_index());
       int target_node_id = transform_node->data.content_target_id;
 
       // The clip node stores clip rect in its target space.
-      gfx::Rect clip_rect_in_target_space =
-          gfx::ToEnclosingRect(clip_node->data.clip_in_target_space);
+      gfx::RectF clip_rect_in_target_space =
+          clip_node->data.clip_in_target_space;
 
       // If required, this clip rect should be mapped to the current layer's
       // target space.
       if (clip_node->data.target_id != target_node_id) {
         // In this case, layer has a clip parent or scroll 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)
           continue;
 
         // Compute the clip rect in target space and store it.
         if (!ComputeClipRectInTargetSpace(layer, clip_node, transform_tree,
                                           target_node_id,
                                           &clip_rect_in_target_space))
           continue;
       }
 
       if (!clip_rect_in_target_space.IsEmpty()) {
-        layer->set_clip_rect(clip_rect_in_target_space);
+        layer->set_clip_rect(gfx::ToEnclosingRect(clip_rect_in_target_space));
       } else {
         layer->set_clip_rect(gfx::Rect());
       }
     }
   }
 }
 
 bool GetLayerClipRect(const scoped_refptr<Layer> layer,
                       const ClipNode* clip_node,
                       const TransformTree& transform_tree,
                       int target_node_id,
-                      gfx::Rect* clip_rect_in_target_space) {
+                      gfx::RectF* clip_rect_in_target_space) {
   return ComputeClipRectInTargetSpace(layer.get(), clip_node, transform_tree,
                                       target_node_id,
                                       clip_rect_in_target_space);
 }
 
 bool GetLayerClipRect(const LayerImpl* layer,
                       const ClipNode* clip_node,
                       const TransformTree& transform_tree,
                       int target_node_id,
-                      gfx::Rect* clip_rect_in_target_space) {
+                      gfx::RectF* clip_rect_in_target_space) {
   // This is equivalent of calling ComputeClipRectInTargetSpace.
-  *clip_rect_in_target_space = layer->clip_rect();
+  *clip_rect_in_target_space = gfx::RectF(layer->clip_rect());
   return transform_tree.Node(target_node_id)->data.ancestors_are_invertible;
 }
 
 template <typename LayerType>
 void CalculateVisibleRects(
     const typename LayerType::LayerListType& visible_layer_list,
     const ClipTree& clip_tree,
     const TransformTree& transform_tree,
     const EffectTree& effect_tree,
     bool non_root_surfaces_enabled) {
   for (auto& layer : visible_layer_list) {
     gfx::Size layer_bounds = layer->bounds();
 
     const EffectNode* effect_node =
         effect_tree.Node(layer->effect_tree_index());
     if (effect_node->data.has_copy_request &&
         effect_node->owner_id == layer->id()) {
       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->data.ancestors_are_invertible) {
-        gfx::Rect combined_clip_rect_in_target_space =
-            gfx::ToEnclosingRect(clip_node->data.combined_clip_in_target_space);
+        gfx::RectF combined_clip_rect_in_target_space =
+            clip_node->data.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_node->data.from_screen);
 
-        gfx::Rect visible_rect = MathUtil::ProjectEnclosingClippedRect(
-            target_to_content, combined_clip_rect_in_target_space);
+        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, the entire layer
     // content rect is visible.
     const bool fully_visible = !clip_node->data.layers_are_clipped &&
                                !clip_node->data.target_is_clipped;
 
     if (fully_visible) {
       layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
       continue;
     }
 
     int target_node_id = transform_node->data.content_target_id;
 
     // 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 combined_clip_rect_in_target_space;
+    gfx::RectF combined_clip_rect_in_target_space;
 
     if (clip_node->data.target_id != target_node_id) {
       // In this case, layer has a clip parent or scroll 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_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
 
       // We use the clip node's clip_in_target_space (and not
       // combined_clip_in_target_space) here because we want to clip
       // with respect to clip parent's local clip and not its combined clip as
       // the combined clip has even the clip parent's target's clip baked into
       // it and as our target is different, we don't want to use it in our
       // visible rect computation.
       if (!GetLayerClipRect(layer, clip_node, transform_tree, target_node_id,
                             &combined_clip_rect_in_target_space)) {
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
     } else {
       if (clip_node->data.target_is_clipped) {
         combined_clip_rect_in_target_space =
-            gfx::ToEnclosingRect(clip_node->data.combined_clip_in_target_space);
+            clip_node->data.combined_clip_in_target_space;
       } else {
         combined_clip_rect_in_target_space =
-            gfx::ToEnclosingRect(clip_node->data.clip_in_target_space);
+            clip_node->data.clip_in_target_space;
       }
     }
 
     // The clip rect should be intersected with layer rect in target space.
     gfx::Transform content_to_target = transform_node->data.to_target;
     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);
+    gfx::RectF layer_content_bounds_in_target_space = MathUtil::MapClippedRect(
+        content_to_target, gfx::RectF(layer_content_rect));
+    // If the layer is fully contained within the clip, treat it as fully
+    // visible.
+    if (!layer_content_bounds_in_target_space.IsEmpty() &&
+        combined_clip_rect_in_target_space.Contains(
+            layer_content_bounds_in_target_space)) {
+      layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
+      continue;
+    }
+
     combined_clip_rect_in_target_space.Intersect(
         layer_content_bounds_in_target_space);
     if (combined_clip_rect_in_target_space.IsEmpty()) {
       layer->set_visible_layer_rect(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_layer_rect(gfx::Rect(layer_bounds));
-      continue;
-    }
-
     gfx::Transform target_to_layer;
     if (transform_node->data.ancestors_are_invertible) {
       target_to_layer = transform_node->data.from_target;
     } else {
       if (!transform_tree.ComputeTransformWithSourceSublayerScale(
               target_node_id, transform_node->id, &target_to_layer)) {
         // 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.
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
     }
 
     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(target_to_layer);
 
-    gfx::Rect visible_rect = MathUtil::ProjectEnclosingClippedRect(
-        target_to_content, combined_clip_rect_in_target_space);
+    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);
   }
 }
 
 static bool HasSingularTransform(int transform_tree_index,
                                  const TransformTree& tree) {
   const TransformNode* node = tree.Node(transform_tree_index);
   return !node->data.is_invertible || !node->data.ancestors_are_invertible;
 }
@@ skipping 980 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