Add hittest mode for Touch-action which ignore inline elements and svg elements

Source/core/rendering/RootInlineBox.cpp

 /*
  * Copyright (C) 2003, 2006, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 159 matching lines @@
 }
 
 void RootInlineBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
 {
     InlineFlowBox::paint(paintInfo, paintOffset, lineTop, lineBottom);
     paintEllipsisBox(paintInfo, paintOffset, lineTop, lineBottom);
 }
 
 bool RootInlineBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
 {
+    if (request.touchAction())

[Rick Byers, 2014/01/17 16:12:46]

Does this need to be on a inline-box by inline-box basis, as opposed to just on
the appropriate RenderObject objects?  Eg. I was hoping we could just tie it to
RenderBlock (or maybe RenderBox - probably need to test the non-block
RenderBoxes to see what we want).

It's probably better to opt-in to touch-action hit testing then to opt-out (just
to reduce the risk of having bugs down the line where CC and main-thread
hit-testing disagree).

I think this really belongs inside of visibleToHitTestRequest (for any other
consumers of that API) as opposed to directly in nodeAtPoint.  You can either
expand visibleToHitTestRequest to look for specific types of renderers, or make
it virtual and override it in the appropriate RenderObject subclass(es).

[gnana, 2014/01/21 14:00:16]

Ok. i will apply Opt-in way.
ok, i too feel this belongs to visibleToHitTestRequest. But only my concern was
if it was called in all cases.
I m checking on visibleToHitTestRequest approach. I felt instead of  renderer we
can check for display property like this 
bool visibleToHitTestRequest(const HitTestRequest& request) const
{
    bool touchAction = request.TouchAction() ? style()->display() == BLOCK ||
style()->display() == INLINE_BLOCK : true;	
    bool pointerEvent = request.ignorePointerEventsNone() ||
style()->pointerEvents() != PE_NONE; 
	
    return style()->visibility() == VISIBLE && touchAction && pointerEvent &&
!isInert(); 
}
and for SVG case we can still use RenderSvgRoot change. 

Also I feel other way of making virtual and overriding with opt-in touchaction
may not work, as hit test will still happen for non-block elements.

[Rick Byers, 2014/01/21 15:24:20]

This might be OK.  We'd probably need to look at each of the EDisplay values and
decide which it should apply for (I'm guessing it should for flex, and many of
the table ones).  My gut instinct is that using the RenderObject type is going
to be more reliable, but I don't know this well enough.  I've pinged leviw@ (who
will probably do the OWNERS review of this CL) to ask him to add his opinion.
Right, sorry - what I meant was that the base class would return false for all
TouchAction-type hit tests, then sub-classes could opt-in.

[leviw_travelin_and_unemployed, 2014/01/21 19:15:00]

Generally speaking, I agree that what you really want here is to look at the
type of renderer. If you want it to apply for blocks, I'd add a virtual method
that only RenderBlock (the base class for all block-type renderers) returns true
for. Otherwise if new block-level display types come around, they get the
expected behavior.

Either way, this isn't the right place to do this if, as you seem to specify,
you want inline-blocks. You'll never get to them if you bail here.
 

+        return false;
     if (hasEllipsisBox() && visibleToHitTestRequest(request)) {
         if (ellipsisBox()->nodeAtPoint(request, result, locationInContainer, accumulatedOffset, lineTop, lineBottom)) {
             renderer()->updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));
             return true;
         }
     }
     return InlineFlowBox::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, lineTop, lineBottom);
 }
 
 void RootInlineBox::adjustPosition(float dx, float dy)
@@ skipping 799 matching lines @@
 }
 
 #ifndef NDEBUG
 const char* RootInlineBox::boxName() const
 {
     return "RootInlineBox";
 }
 #endif
 
 } // namespace WebCore