Clean up PointIsClippedBySurfaceOrClipRect

cc/trees/layer_tree_impl.cc

 // Copyright 2011 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/layer_tree_impl.h"
 
 #include <limits>
 #include <set>
 
 #include "base/debug/trace_event.h"
@@ skipping 1077 matching lines @@
 
   // If ProjectPoint could not project to a valid value, then we assume that
   // this point doesn't hit this region.
   if (clipped)
     return false;
 
   return layer_space_region.Contains(
       gfx::ToRoundedPoint(hit_test_point_in_layer_space));
 }
 
+static LayerImpl* GetNextClippingLayer(LayerImpl* layer) {
+  if (layer->scroll_parent())
+    return layer->scroll_parent();
+  if (layer->clip_parent())
+    return layer->clip_parent();
+  return layer->parent();
+}
+
 static bool PointIsClippedBySurfaceOrClipRect(
     const gfx::PointF& screen_space_point,
     LayerImpl* layer) {
-  LayerImpl* current_layer = layer;
+  LayerImpl* render_target = NULL;
+  bool last_layer_had_surface = false;
 
   // Walk up the layer tree and hit-test any render_surfaces and any layer
   // clip rects that are active.
-  while (current_layer) {
-    if (current_layer->render_surface() &&
+  for (; layer; layer = GetNextClippingLayer(layer)) {
+    if (last_layer_had_surface || layer->IsDrawnRenderSurfaceLayerListMember())
+      render_target = layer->render_target();
+
+    if (layer->render_surface() &&
+        !PointHitsRect(screen_space_point,
+                       layer->render_surface()->screen_space_transform(),
+                       layer->render_surface()->content_rect(),
+                       NULL))
+      return true;
+
+    // Note that drawable content rects are actually in target surface space,
+    // so the transform we have to provide is the target surface's
+    // screen_space_transform.
+    if (render_target && LayerClipsSubtree(layer) &&
         !PointHitsRect(
             screen_space_point,
-            current_layer->render_surface()->screen_space_transform(),
-            current_layer->render_surface()->content_rect(),
+            render_target->render_surface()->screen_space_transform(),
+            gfx::Rect(layer->drawable_content_rect()),

[danakj, 2014/06/11 17:43:06]

no gfx::Rect needed

is there some guarantee that layer->IsDrawnRenderSurfaceLayerListMember() is
true here ie the rect is valid/fresh?

             NULL))
       return true;
 
-    // Note that drawable content rects are actually in target surface space, so
-    // the transform we have to provide is the target surface's
-    // screen_space_transform.
-    LayerImpl* render_target = current_layer->render_target();
-    if (LayerClipsSubtree(current_layer) &&
-        !PointHitsRect(
-            screen_space_point,
-            render_target->render_surface()->screen_space_transform(),
-            current_layer->drawable_content_rect(),
-            NULL))
-      return true;
-
-    current_layer = current_layer->parent();
+    last_layer_had_surface = !!layer->render_surface();
   }
 
   // If we have finished walking all ancestors without having already exited,
   // then the point is not clipped by any ancestors.
   return false;
 }
 
 static bool PointHitsLayer(LayerImpl* layer,
                            const gfx::PointF& screen_space_point,
                            float* distance_to_intersection) {
@@ skipping 132 matching lines @@
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPointInTouchHandlerRegion(
     const gfx::PointF& screen_space_point) {
   FindTouchEventLayerFunctor func = {screen_space_point};
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
   FindClosestMatchingLayer(
       screen_space_point, root_layer(), func, &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
 }  // namespace cc