cc: Add a helper function for transforming rects between surface spaces

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 25 matching lines @@
 
 static const EffectNode* ContentsTargetEffectNode(
     const int effect_tree_index,
     const EffectTree& effect_tree) {
   const EffectNode* effect_node = effect_tree.Node(effect_tree_index);
   return effect_tree.GetRenderSurface(effect_tree_index)
              ? effect_node
              : effect_tree.Node(effect_node->target_id);
 }
 
+static bool ConvertRectBetweenSurfaceSpaces(const PropertyTrees* property_trees,
+                                            int source_effect_id,
+                                            int dest_effect_id,
+                                            gfx::RectF clip_in_source_space,
+                                            gfx::RectF* clip_in_dest_space) {
+  const EffectNode* source_effect_node =
+      property_trees->effect_tree.Node(source_effect_id);
+  int source_transform_id = source_effect_node->transform_id;
+  const EffectNode* dest_effect_node =
+      property_trees->effect_tree.Node(dest_effect_id);
+  int dest_transform_id = dest_effect_node->transform_id;
+  gfx::Transform source_to_dest;
+  if (source_transform_id > dest_transform_id) {
+    if (property_trees->GetToTarget(source_transform_id, dest_effect_id,
+                                    &source_to_dest)) {
+      ConcatInverseSurfaceContentsScale(source_effect_node, &source_to_dest);
+      *clip_in_dest_space =
+          MathUtil::MapClippedRect(source_to_dest, clip_in_source_space);
+    } else {
+      return false;
+    }
+  } else {
+    if (property_trees->GetFromTarget(dest_transform_id, source_effect_id,
+                                      &source_to_dest)) {
+      PostConcatSurfaceContentsScale(dest_effect_node, &source_to_dest);
+      *clip_in_dest_space =
+          MathUtil::ProjectClippedRect(source_to_dest, clip_in_source_space);
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
 bool ComputeClipRectInTargetSpace(const LayerImpl* layer,
                                   const ClipNode* clip_node,
                                   const PropertyTrees* property_trees,
                                   int target_node_id,
                                   bool for_visible_rect_calculation,
                                   gfx::RectF* clip_rect_in_target_space) {
   DCHECK(layer->clip_tree_index() == clip_node->id);
   DCHECK(clip_node->target_transform_id != target_node_id);
 
   const EffectTree& effect_tree = property_trees->effect_tree;
   const EffectNode* target_effect_node =
       ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree);
   gfx::Transform clip_to_target;
   // We use the local clip for clip rect calculation and combined clip for
   // visible rect calculation.
   gfx::RectF clip_from_clip_node =
       for_visible_rect_calculation ? clip_node->combined_clip_in_target_space
                                    : clip_node->clip_in_target_space;
 
-  if (clip_node->target_transform_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 (property_trees->GetToTarget(clip_node->target_transform_id,
-                                    target_effect_node->id, &clip_to_target)) {
-      const EffectNode* source_node =
-          effect_tree.Node(clip_node->target_effect_id);
-      ConcatInverseSurfaceContentsScale(source_node, &clip_to_target);
-      *clip_rect_in_target_space =
-          MathUtil::MapClippedRect(clip_to_target, clip_from_clip_node);
-    } else {
-      return false;
-    }
-  } else {
-    if (property_trees->GetFromTarget(
-            target_node_id, clip_node->target_effect_id, &clip_to_target)) {
-      PostConcatSurfaceContentsScale(target_effect_node, &clip_to_target);
-      *clip_rect_in_target_space =
-          MathUtil::ProjectClippedRect(clip_to_target, clip_from_clip_node);
-    } else {
-      return false;
-    }
-  }
-  return true;
+  return ConvertRectBetweenSurfaceSpaces(
+      property_trees, clip_node->target_effect_id, target_effect_node->id,
+      clip_from_clip_node, clip_rect_in_target_space);
 }
 
 struct ConditionalClip {
   bool is_clipped;
   gfx::RectF clip_rect;
 };
 
 static ConditionalClip ComputeTargetRectInLocalSpace(
     gfx::RectF rect,
     const PropertyTrees* property_trees,
     int target_transform_id,
     int local_transform_id,
     const int target_effect_id) {
   gfx::Transform target_to_local;
   bool success = property_trees->GetFromTarget(
       local_transform_id, target_effect_id, &target_to_local);
   if (!success)
     // If transform is not invertible, cannot apply clip.
     return ConditionalClip{false, gfx::RectF()};
 
   if (target_transform_id > local_transform_id)
     return ConditionalClip{true,  // is_clipped.
                            MathUtil::MapClippedRect(target_to_local, rect)};
 
   return ConditionalClip{true,  // is_clipped.
                          MathUtil::ProjectClippedRect(target_to_local, rect)};
 }
 
-static ConditionalClip ConvertRectBetweenSurfaceSpaces(
-    gfx::RectF rect,
-    const PropertyTrees* property_trees,
-    int source_transform_id,
-    int source_effect_id,
-    int dest_transform_id,
-    int dest_effect_id) {
-  gfx::Transform source_to_dest;
-  bool success = property_trees->GetToTarget(source_transform_id,
-                                             dest_effect_id, &source_to_dest);
-  if (!success)
-    return ConditionalClip{false, gfx::RectF()};
-  const EffectTree& effect_tree = property_trees->effect_tree;
-  const EffectNode* source_effect_node = effect_tree.Node(source_effect_id);
-  ConcatInverseSurfaceContentsScale(source_effect_node, &source_to_dest);
-  if (source_transform_id > dest_transform_id) {
-    return ConditionalClip{true,  // is_clipped
-                           MathUtil::MapClippedRect(source_to_dest, rect)};
-  }
-  return ConditionalClip{true,  // is_clipped
-                         MathUtil::ProjectClippedRect(source_to_dest, rect)};
-}
-
 static ConditionalClip ComputeLocalRectInTargetSpace(
     gfx::RectF rect,
     const PropertyTrees* property_trees,
     int current_transform_id,
     int target_transform_id,
     int target_effect_id) {
   gfx::Transform current_to_target;
   if (!property_trees->GetToTarget(current_transform_id, target_effect_id,
                                    &current_to_target)) {
     // If transform is not invertible, cannot apply clip.
@@ skipping 48 matching lines @@
       return true;
     }
     case ClipNode::ClipType::EXPANDS_CLIP: {
       if (!include_expanding_clips)
         return true;
 
       // Bring the accumulated clip to the space of the expanding effect.
       const EffectNode* expanding_effect_node =
           property_trees->effect_tree.Node(
               clip_node->clip_expander->target_effect_id());
-      ConditionalClip accumulated_clip_in_expanding_space =
-          ConvertRectBetweenSurfaceSpaces(
-              *accumulated_clip, property_trees, target_transform_id, target_id,
-              expanding_effect_node->transform_id, expanding_effect_node->id);
+      gfx::RectF accumulated_clip_rect_in_expanding_space;
+      bool success = ConvertRectBetweenSurfaceSpaces(
+          property_trees, target_id, expanding_effect_node->id,
+          *accumulated_clip, &accumulated_clip_rect_in_expanding_space);
       // If transform is not invertible, no clip will be applied.
-      if (!accumulated_clip_in_expanding_space.is_clipped)
+      if (!success)
         return false;
 
       // Do the expansion.
       gfx::RectF expanded_clip_in_expanding_space =
           gfx::RectF(clip_node->clip_expander->MapRectReverse(
-              gfx::ToEnclosingRect(
-                  accumulated_clip_in_expanding_space.clip_rect),
+              gfx::ToEnclosingRect(accumulated_clip_rect_in_expanding_space),
               property_trees));
 
       // Put the expanded clip back into the original target space.
-      ConditionalClip expanded_clip_in_target_space =
-          ConvertRectBetweenSurfaceSpaces(
-              expanded_clip_in_expanding_space, property_trees,
-              expanding_effect_node->transform_id, expanding_effect_node->id,
-              target_transform_id, target_id);
+      success = ConvertRectBetweenSurfaceSpaces(
+          property_trees, expanding_effect_node->id, target_id,
+          expanded_clip_in_expanding_space, accumulated_clip);
       // If transform is not invertible, no clip will be applied.
-      if (!expanded_clip_in_target_space.is_clipped)
+      if (!success)
         return false;
-      *accumulated_clip = expanded_clip_in_target_space.clip_rect;
       return true;
     }
     case ClipNode::ClipType::NONE:
       return true;
   }
   NOTREACHED();
   return true;
 }
 
 static ConditionalClip ComputeAccumulatedClip(
@@ skipping 567 matching lines @@
     // 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) {
-      success &= property_trees->GetFromTarget(
-          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);
+      success &= ConvertRectBetweenSurfaceSpaces(
+          property_trees, parent_clip_node->target_effect_id,
+          clip_node->target_effect_id,
+          parent_clip_node->combined_clip_in_target_space,
+          &parent_combined_clip_in_target_space);
       // 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->combined_clip_in_target_space);
       if (clip_node->clip_type == ClipNode::ClipType::EXPANDS_CLIP) {
         parent_combined_clip_in_target_space =
             gfx::RectF(clip_node->clip_expander->MapRectReverse(
                 gfx::ToEnclosingRect(parent_combined_clip_in_target_space),
                 property_trees));
       }
-      parent_clip_in_target_space = MathUtil::ProjectClippedRect(
-          parent_to_current, parent_clip_node->clip_in_target_space);
+      ConvertRectBetweenSurfaceSpaces(
+          property_trees, parent_clip_node->target_effect_id,
+          clip_node->target_effect_id, parent_clip_node->clip_in_target_space,
+          &parent_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->clip_type == ClipNode::ClipType::APPLIES_LOCAL_CLIP) {
         gfx::Transform to_target;
         property_trees->GetToTarget(clip_node->transform_id,
@@ skipping 396 matching lines @@
   if (transform_tree.TargetId(transform_node->id) ==
       parent_clip_node->target_transform_id) {
     render_surface->SetClipRect(
         gfx::ToEnclosingRect(parent_clip_node->clip_in_target_space));
     return;
   }
 
   // In this case, the clip child has reset the clip node for subtree and hence
   // the parent clip node's clip rect is in clip parent's target space and not
   // our target space. We need to transform it to our target space.
-  gfx::Transform clip_parent_target_to_target;
   const EffectNode* effect_node =
       effect_tree.Node(render_surface->EffectTreeIndex());
   int target_effect_id = effect_node->target_id;
-  const bool success = property_trees->GetToTarget(
-      parent_clip_node->target_transform_id, target_effect_id,
-      &clip_parent_target_to_target);
+  gfx::RectF clip_rect;
+  const bool success = ConvertRectBetweenSurfaceSpaces(
+      property_trees, parent_clip_node->target_effect_id, target_effect_id,
+      parent_clip_node->clip_in_target_space, &clip_rect);
 
   if (!success) {
     render_surface->SetClipRect(gfx::Rect());
     return;
   }
-
-  if (parent_clip_node->target_transform_id <
-      transform_tree.TargetId(transform_node->id)) {
-    render_surface->SetClipRect(gfx::ToEnclosingRect(
-        MathUtil::ProjectClippedRect(clip_parent_target_to_target,
-                                     parent_clip_node->clip_in_target_space)));
-  } else {
-    render_surface->SetClipRect(gfx::ToEnclosingRect(MathUtil::MapClippedRect(
-        clip_parent_target_to_target, parent_clip_node->clip_in_target_space)));
-  }
+  render_surface->SetClipRect(gfx::ToEnclosingRect(clip_rect));
 }
 
 template <typename LayerType>
 static gfx::Transform ScreenSpaceTransformInternal(LayerType* layer,
                                                    const TransformTree& tree) {
   gfx::Transform xform(1, 0, 0, 1, layer->offset_to_transform_parent().x(),
                        layer->offset_to_transform_parent().y());
   gfx::Transform ssxform = tree.ToScreen(layer->transform_tree_index());
   xform.ConcatTransform(ssxform);
   if (layer->should_flatten_transform_from_property_tree())
@@ skipping 206 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