Revert of cc: Make visible rect computation aware of pixel-moving filters

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 119 matching lines @@
   ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_local);
 
   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 19 matching lines @@
 
   const EffectTree& effect_tree = property_trees->effect_tree;
   gfx::RectF current_clip = clip_node->clip;
   gfx::Vector2dF surface_contents_scale =
       effect_tree.Node(target_effect_id)->surface_contents_scale;
   if (surface_contents_scale.x() > 0 && surface_contents_scale.y() > 0)
     current_clip.Scale(surface_contents_scale.x(), surface_contents_scale.y());
   return ConditionalClip{true /* is_clipped */, current_clip};
 }
 
-static bool ApplyClipNodeToAccumulatedClip(const PropertyTrees* property_trees,
-                                           bool include_expanding_clips,
-                                           int target_id,
-                                           int target_transform_id,
-                                           const ClipNode* clip_node,
-                                           gfx::RectF* accumulated_clip) {
-  switch (clip_node->clip_type) {
-    case ClipNode::ClipType::APPLIES_LOCAL_CLIP: {
-      ConditionalClip current_clip = ComputeCurrentClip(
-          clip_node, property_trees, target_transform_id, target_id);
-
-      // If transform is not invertible, no clip will be applied.
-      if (!current_clip.is_clipped)
-        return false;
-
-      *accumulated_clip =
-          gfx::IntersectRects(*accumulated_clip, current_clip.clip_rect);
-      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);
-      // If transform is not invertible, no clip will be applied.
-      if (!accumulated_clip_in_expanding_space.is_clipped)
-        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),
-              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);
-      // If transform is not invertible, no clip will be applied.
-      if (!expanded_clip_in_target_space.is_clipped)
-        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(
     const PropertyTrees* property_trees,
     bool include_viewport_clip,
-    bool include_expanding_clips,
     int local_clip_id,
     int target_id) {
   DCHECK(!include_viewport_clip ||
          target_id == EffectTree::kContentsRootNodeId);
   const ClipTree& clip_tree = property_trees->clip_tree;
   const EffectTree& effect_tree = property_trees->effect_tree;
 
   const ClipNode* clip_node = clip_tree.Node(local_clip_id);
   const EffectNode* target_node = effect_tree.Node(target_id);
   int target_transform_id = target_node->transform_id;
+  bool is_clipped = false;
 
   // Collect all the clips that need to be accumulated.
   std::stack<const ClipNode*> parent_chain;
 
   // If target is not direct ancestor of clip, this will find least common
   // ancestor between the target and the clip.
   while (target_node->clip_id > clip_node->id ||
          target_node->has_unclipped_descendants) {
     target_node = effect_tree.Node(target_node->target_id);
   }
 
   // Collect clip nodes up to the least common ancestor.
   while (target_node->clip_id < clip_node->id) {
     parent_chain.push(clip_node);
     clip_node = clip_tree.parent(clip_node);
   }
   DCHECK_EQ(target_node->clip_id, clip_node->id);
 
   if (!include_viewport_clip && parent_chain.size() == 0) {
     // There aren't any clips to apply.
     return ConditionalClip{false, gfx::RectF()};
   }
 
   if (!include_viewport_clip) {
     clip_node = parent_chain.top();
     parent_chain.pop();
   }
 
-  // Find the first clip in the chain that we need to apply.
+  // TODO(weiliangc): If we don't create clip for render surface, we don't need
+  // to check applies_local_clip.
   while (clip_node->clip_type != ClipNode::ClipType::APPLIES_LOCAL_CLIP &&
          parent_chain.size() > 0) {
     clip_node = parent_chain.top();
     parent_chain.pop();
   }
 
-  if (clip_node->clip_type != ClipNode::ClipType::APPLIES_LOCAL_CLIP) {
+  if (clip_node->clip_type != ClipNode::ClipType::APPLIES_LOCAL_CLIP)
     // No clip node applying clip in between.
     return ConditionalClip{false, gfx::RectF()};
-  }
 
   ConditionalClip current_clip = ComputeCurrentClip(
       clip_node, property_trees, target_transform_id, target_id);
-
-  // If transform is not invertible, no clip will be applied.
-  if (!current_clip.is_clipped)
-    return ConditionalClip{false, gfx::RectF()};
+  is_clipped = current_clip.is_clipped;
   gfx::RectF accumulated_clip = current_clip.clip_rect;
 
   while (parent_chain.size() > 0) {
     clip_node = parent_chain.top();
     parent_chain.pop();
-    bool success = ApplyClipNodeToAccumulatedClip(
-        property_trees, include_expanding_clips, target_id, target_transform_id,
-        clip_node, &accumulated_clip);
+    if (clip_node->clip_type != ClipNode::ClipType::APPLIES_LOCAL_CLIP) {
+      continue;
+    }
+    ConditionalClip current_clip = ComputeCurrentClip(
+        clip_node, property_trees, target_transform_id, target_id);
 
-    // Failure to apply the clip means we encountered an uninvertible transform,
-    // so no clip will be applied.
-    if (!success)
-      return ConditionalClip{false /* is_clipped */, gfx::RectF()};
+    // If transform is not invertible, no clip will be applied.
+    if (!current_clip.is_clipped)
+      return ConditionalClip{false, gfx::RectF()};
+
+    is_clipped = true;
+    accumulated_clip =
+        gfx::IntersectRects(accumulated_clip, current_clip.clip_rect);
   }
 
-  return ConditionalClip{true /* is_clipped */, accumulated_clip.IsEmpty()
-                                                    ? gfx::RectF()
-                                                    : accumulated_clip};
+  return ConditionalClip{
+      is_clipped, accumulated_clip.IsEmpty() ? gfx::RectF() : accumulated_clip};
 }
 
 static gfx::RectF ComputeAccumulatedClipInRootSpaceForVisibleRect(
     const PropertyTrees* property_trees,
     int local_clip_id) {
   const int root_effect_id = EffectTree::kContentsRootNodeId;
   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);
+      property_trees, include_viewport_clip, 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 ClipTree& clip_tree = property_trees->clip_tree;
   for (auto& layer : visible_layer_list) {
     const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index());
@@ skipping 51 matching lines @@
   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 > 1) {
       // Non root copy request.
       bool include_viewport_clip = false;
-      bool include_expanding_clips = true;
       ConditionalClip accumulated_clip_rect = ComputeAccumulatedClip(
-          property_trees, include_viewport_clip, include_expanding_clips,
-          layer->clip_tree_index(), effect_ancestor_with_copy_request);
+          property_trees, include_viewport_clip, layer->clip_tree_index(),
+          effect_ancestor_with_copy_request);
       if (!accumulated_clip_rect.is_clipped) {
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
 
       gfx::RectF accumulated_clip_in_copy_request_space =
           accumulated_clip_rect.clip_rect;
 
       const EffectNode* copy_request_effect_node =
           effect_tree.Node(effect_ancestor_with_copy_request);
@@ skipping 440 matching lines @@
         ConcatInverseSurfaceContentsScale(parent_target_effect_node,
                                           &parent_to_current);
       }
       // 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);
     }
     // 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) {
@@ skipping 118 matching lines @@
       gfx::ToEnclosingRect(clip_tree->Node(root_effect_node->clip_id)->clip);
   if (root_render_surface->is_clipped())
     DCHECK(root_clip == root_render_surface->clip_rect())
         << "clip on root render surface: "
         << root_render_surface->clip_rect().ToString()
         << " v.s. root effect node's clip: " << root_clip.ToString();
   for (int i = 2; i < static_cast<int>(effect_tree->size()); ++i) {
     EffectNode* effect_node = effect_tree->Node(i);
     const EffectNode* target_node = effect_tree->Node(effect_node->target_id);
     bool include_viewport_clip = false;
-    bool include_expanding_clips = false;
-    ConditionalClip accumulated_clip_rect = ComputeAccumulatedClip(
-        property_trees, include_viewport_clip, include_expanding_clips,
-        effect_node->clip_id, target_node->id);
+    ConditionalClip accumulated_clip_rect =
+        ComputeAccumulatedClip(property_trees, include_viewport_clip,
+                               effect_node->clip_id, target_node->id);
     gfx::RectF accumulated_clip = accumulated_clip_rect.clip_rect;
     const RenderSurfaceImpl* render_surface = effect_node->render_surface;
     if (render_surface && render_surface->is_clipped()) {
       DCHECK(gfx::ToEnclosingRect(accumulated_clip) ==
              render_surface->clip_rect())
           << " render surface's clip rect: "
           << render_surface->clip_rect().ToString()
           << " v.s. accumulated clip: "
           << gfx::ToEnclosingRect(accumulated_clip).ToString();
     }
   }
 }
 
 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 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);
+  ConditionalClip accumulated_clip_rect =
+      ComputeAccumulatedClip(property_trees, include_viewport_clip,
+                             layer->clip_tree_index(), target_node->id);
 
   gfx::RectF accumulated_clip = accumulated_clip_rect.clip_rect;
 
   if ((!property_trees->non_root_surfaces_enabled &&
        clip_tree->Node(layer->clip_tree_index())
            ->layers_are_clipped_when_surfaces_disabled) ||
       clip_tree->Node(layer->clip_tree_index())->layers_are_clipped) {
     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. "
@@ skipping 110 matching lines @@
                                          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;
   gfx::Rect layer_content_rect = gfx::Rect(layer->bounds());
   gfx::RectF accumulated_clip_in_root_space;
   if (non_root_copy_request) {
     bool include_viewport_clip = false;
-    bool include_expanding_clips = true;
     ConditionalClip accumulated_clip = ComputeAccumulatedClip(
-        property_trees, include_viewport_clip, include_expanding_clips,
-        layer->clip_tree_index(), effect_ancestor_with_copy_request);
+        property_trees, include_viewport_clip, layer->clip_tree_index(),
+        effect_ancestor_with_copy_request);
     if (!accumulated_clip.is_clipped)
       return layer_content_rect;
     accumulated_clip_in_root_space = accumulated_clip.clip_rect;
   } else {
     accumulated_clip_in_root_space =
         ComputeAccumulatedClipInRootSpaceForVisibleRect(
             property_trees, layer->clip_tree_index());
   }
 
   const EffectNode* root_effect_node =
@@ skipping 350 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