Move cc::ClipNode::target_is_clipped to cc::EffectNode

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 379 matching lines @@
         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, we only have to apply
     // the viewport clip.
     const bool fully_visible =
-        !clip_node->layers_are_clipped && !clip_node->target_is_clipped;
+        !clip_node->layers_are_clipped &&
+        !effect_tree.Node(clip_node->target_effect_id)->surface_is_clipped;
 
     if (fully_visible) {
       if (!transform_node->ancestors_are_invertible) {
         // 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));
       } else {
         gfx::Transform from_screen;
         from_screen.Translate(-layer->offset_to_transform_parent().x(),
@@ skipping 330 matching lines @@
       clip_node->clip_in_target_space = clip_node->clip;
       clip_node->combined_clip_in_target_space = clip_node->clip;
       continue;
     }
     const TransformTree& transform_tree = property_trees->transform_tree;
     const EffectTree& effect_tree = property_trees->effect_tree;
     const TransformNode* transform_node =
         transform_tree.Node(clip_node->transform_id);
     ClipNode* parent_clip_node = clip_tree->parent(clip_node);
 
+    bool target_is_clipped =
+        effect_tree.Node(clip_node->target_effect_id)->surface_is_clipped;
+
     gfx::Transform parent_to_current;
     const TransformNode* parent_target_transform_node =
         transform_tree.Node(parent_clip_node->target_transform_id);
     bool success = true;
 
     // Clips must be combined in target space. We cannot, for example, combine
     // clips in the space of the child clip. The reason is non-affine
     // transforms. Say we have the following tree T->A->B->C, and B clips C, but
     // draw into target T. It may be the case that A applies a perspective
     // transform, and B and C are at different z positions. When projected into
@@ skipping 39 matching lines @@
         gfx::Transform to_target;
         property_trees->GetToTarget(clip_node->transform_id,
                                     clip_node->target_effect_id, &to_target);
         clip_node->clip_in_target_space =
             MathUtil::MapClippedRect(to_target, clip_node->clip);
         ResetIfHasNanCoordinate(&clip_node->clip_in_target_space);
         clip_node->combined_clip_in_target_space =
             gfx::IntersectRects(clip_node->clip_in_target_space,
                                 parent_combined_clip_in_target_space);
       } else {
-        DCHECK(!clip_node->target_is_clipped);
+        DCHECK(!target_is_clipped);
         DCHECK(!clip_node->layers_are_clipped);
         clip_node->combined_clip_in_target_space =
             parent_combined_clip_in_target_space;
       }
       ResetIfHasNanCoordinate(&clip_node->combined_clip_in_target_space);
       continue;
     }
     bool use_only_parent_clip =
         clip_node->clip_type != ClipNode::ClipType::APPLIES_LOCAL_CLIP;
     if (use_only_parent_clip) {
       clip_node->combined_clip_in_target_space =
           parent_combined_clip_in_target_space;
       if (!non_root_surfaces_enabled) {
         clip_node->clip_in_target_space =
             parent_clip_node->clip_in_target_space;
-      } else if (!clip_node->target_is_clipped) {
+      } else if (!target_is_clipped) {
         clip_node->clip_in_target_space = parent_clip_in_target_space;
       } else {
         // Render Surface applies clip and the owning layer itself applies
         // no clip. So, clip_in_target_space is not used and hence we can set
         // it to an empty rect.
         clip_node->clip_in_target_space = gfx::RectF();
       }
     } else {
       gfx::Transform source_to_target;
 
@@ skipping 346 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 void SetSurfaceIsClipped(const ClipNode* clip_node,
-                                RenderSurfaceImpl* render_surface) {
-  DCHECK(render_surface->OwningLayerId() == clip_node->owner_id)
-      << "we now create clip node for every render surface";
-
-  render_surface->SetIsClipped(clip_node->target_is_clipped);
-}
-
 static void SetSurfaceClipRect(const ClipNode* parent_clip_node,
                                const PropertyTrees* property_trees,
                                RenderSurfaceImpl* render_surface) {
   if (!render_surface->is_clipped()) {
     render_surface->SetClipRect(gfx::Rect());
     return;
   }
 
   const EffectTree& effect_tree = property_trees->effect_tree;
   const TransformTree& transform_tree = property_trees->transform_tree;
@@ skipping 127 matching lines @@
   // properties computed for other layers are not needed.
   mask_layer->draw_properties().screen_space_transform =
       ScreenSpaceTransformInternal(mask_layer,
                                    property_trees->transform_tree);
   mask_layer->draw_properties().visible_layer_rect =
       gfx::Rect(mask_layer->bounds());
 }
 
 void ComputeSurfaceDrawProperties(const PropertyTrees* property_trees,
                                   RenderSurfaceImpl* render_surface) {
-  const ClipNode* clip_node =
-      property_trees->clip_tree.Node(render_surface->ClipTreeIndex());
-
-  SetSurfaceIsClipped(clip_node, render_surface);
+  const EffectNode* effect_node =
+      property_trees->effect_tree.Node(render_surface->EffectTreeIndex());
+  render_surface->SetIsClipped(effect_node->surface_is_clipped);
   SetSurfaceDrawOpacity(property_trees->effect_tree, render_surface);
   SetSurfaceDrawTransform(property_trees, render_surface);
   render_surface->SetScreenSpaceTransform(
       property_trees->ToScreenSpaceTransformWithoutSurfaceContentsScale(
           render_surface->TransformTreeIndex(),
           render_surface->EffectTreeIndex()));
 
+  const ClipNode* clip_node =
+      property_trees->clip_tree.Node(render_surface->ClipTreeIndex());
   SetSurfaceClipRect(property_trees->clip_tree.parent(clip_node),
                      property_trees, render_surface);
 }
 
 #if DCHECK_IS_ON()
 static void ValidatePageScaleLayer(const Layer* page_scale_layer) {
   DCHECK_EQ(page_scale_layer->position().ToString(), gfx::PointF().ToString());
   DCHECK_EQ(page_scale_layer->transform_origin().ToString(),
             gfx::Point3F().ToString());
 }
@@ skipping 87 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