cc: Don't consider HUD layer for touches

cc/layer_tree_host_common.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/layer_tree_host_common.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
+#include "cc/heads_up_display_layer_impl.h"

[danakj, 2013/02/19 20:08:12]

you don't need this header i don't think?

 #include "cc/layer.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_sorter.h"
+#include "cc/layer_tree_impl.h"
 #include "cc/math_util.h"
 #include "cc/render_surface.h"
 #include "cc/render_surface_impl.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 ScrollAndScaleSet::ScrollAndScaleSet()
@@ skipping 1102 matching lines @@
         currentLayer = currentLayer->parent();
     }
 
     // If we have finished walking all ancestors without having already exited, then the point is not clipped by any ancestors.
     return false;
 }
 
 LayerImpl* LayerTreeHostCommon::findLayerThatIsHitByPoint(const gfx::PointF& screenSpacePoint, const std::vector<LayerImpl*>& renderSurfaceLayerList)
 {
     LayerImpl* foundLayer = 0;
+    LayerImpl* hudLayer = 0;
+    if (renderSurfaceLayerList.empty())
+        return foundLayer;
+    else
+        hudLayer = renderSurfaceLayerList.front()->layerTreeImpl()->hud_layer();

[danakj, 2013/02/19 20:08:12]

If this code is going to move to LTImpl anyways, I think this would be cleaner
if you just pass in the LayerTreeImpl* here.

You can grab the RenderSurfaceLayerList() off it, as well as the hud_layer()
then.

[danakj, 2013/02/19 22:52:58]

Nix that. It will require a lot of test changes.. let's leave that until the
code moves separately so the behaviour change is concise and clear.

This seems a little round-a-bout just to avoid a pointer deref, which will
disappear anyways when we move this into LayerTreeImpl. How about not caching
the hudLayer and just checking currentLayer == currentLayer->ltI()->hud_layer()
below?

 
     typedef LayerIterator<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> LayerIteratorType;
     LayerIteratorType end = LayerIteratorType::end(&renderSurfaceLayerList);
 
     for (LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
         // We don't want to consider renderSurfaces for hit testing.
         if (!it.representsItself())
             continue;
 
         LayerImpl* currentLayer = (*it);
 
+        if (currentLayer == hudLayer)

[danakj, 2013/02/19 22:52:58]

Since this is the least likely thing to exclude a layer, how about moving this
down to be the last continue?

+            continue;
+
         gfx::RectF contentRect(gfx::PointF(), currentLayer->contentBounds());
         if (!pointHitsRect(screenSpacePoint, currentLayer->screenSpaceTransform(), contentRect))
             continue;
 
         // At this point, we think the point does hit the layer, but we need to walk up
         // the parents to ensure that the layer was not clipped in such a way that the
         // hit point actually should not hit the layer.
         if (pointIsClippedBySurfaceOrClipRect(screenSpacePoint, currentLayer))
             continue;
 
@@ skipping 39 matching lines @@
 
   // At this point, we think the point does hit the touch event handler region on the layer, but we need to walk up
   // the parents to ensure that the layer was not clipped in such a way that the
   // hit point actually should not hit the layer.
   if (pointIsClippedBySurfaceOrClipRect(screenSpacePoint, layerImpl))
      return false;
 
   return true;
 }
 }  // namespace cc