cc : Make visible rect independant of render surface's is_clipped value

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 587 matching lines @@
   gfx::Transform render_surface_transform;
   const EffectNode* target_effect_node =
       effect_tree.Node(effect_node->target_id);
   property_trees->GetToTarget(transform_node->id, target_effect_node->id,
                               &render_surface_transform);
 
   ConcatInverseSurfaceContentsScale(effect_node, &render_surface_transform);
   render_surface->SetDrawTransform(render_surface_transform);
 }
 
+static bool LayerIsFullyVisible(LayerImpl* layer,
+                                const PropertyTrees* property_trees) {
+  // If a layer is clipped, it is not fully visible
+  if (layer->is_clipped())
+    return false;
+
+  const EffectNode* effect_node = property_trees->effect_tree.Node(
+      layer->render_target_effect_tree_index());
+  const EffectNode* target_effect_node =
+      property_trees->effect_tree.Node(effect_node->target_id);
+
+  // TODO(crbug.com/702010) : Remove this function's dependency on
+  // effect node's has_unclipped_descendants.
+  if (effect_node->clip_id == target_effect_node->clip_id) {
+    // In this case, the layer is fully visible when the render surface it draws
+    // into is not clipped. The render surface is clipped only if its target has
+    // unclipped descendants and it doesn't.
+    return target_effect_node->has_unclipped_descendants
+               ? effect_node->has_unclipped_descendants
+               : true;
+  }
+
+  // In this case, the render surface that the layer draws into is clipped
+  // unless the render surface's clip node doesn't apply clip but expands it.
+  const ClipNode* clip_node =
+      property_trees->clip_tree.Node(effect_node->clip_id);
+  return clip_node->clip_type == ClipNode::ClipType::EXPANDS_CLIP;
+}
+
 static gfx::Rect LayerVisibleRect(PropertyTrees* property_trees,
                                   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_expanding_clips = true;
     ConditionalClip accumulated_clip = ComputeAccumulatedClip(
         property_trees, include_expanding_clips, 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 {
     const ClipNode* clip_node =
         property_trees->clip_tree.Node(layer->clip_tree_index());
-    const EffectNode* effect_node = property_trees->effect_tree.Node(
-        layer->render_target_effect_tree_index());
-    bool fully_visible =
-        !layer->is_clipped() && !effect_node->surface_is_clipped;
+    bool fully_visible = LayerIsFullyVisible(layer, property_trees);
     if (fully_visible) {

[weiliangc, 2017/03/24 18:52:25]

Do we still need to check for fully_visible here? Even when a layer is not
clipped and its target surface isn't clipped, the layer is still under the
influence of the clip node right? We could use clip node's accumulated rect in
screen space in both cases?

[jaydasika, 2017/03/24 23:11:32]

There was a layout test failure which made me think we need this case. But,
after logging the values for that test I realized, the visible rect was smaller
when we use viewport clip instead of accumulated rect. So, I think its just a
snapping issue and rebaselining the test should be ok ?
The reason using just viewport clip results in smaller visible rect is : the
page has a blur filter which causes the accumulated clip to expand, so the
accumulated clip is larger than viewport clip. 

       accumulated_clip_in_root_space = property_trees->clip_tree.ViewportClip();
     } else {
       accumulated_clip_in_root_space =
           clip_node->cached_accumulated_rect_in_screen_space;
     }
   }
 
   const EffectNode* root_effect_node =
       non_root_copy_request
           ? property_trees->effect_tree.Node(effect_ancestor_with_copy_request)
@@ skipping 387 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