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

Source/web/tests/TouchActionTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 101 matching lines @@
     }
 
     virtual void TearDown()
     {
         Platform::current()->unitTestSupport()->unregisterAllMockedURLs();
     }
 
 protected:
     void runTouchActionTest(std::string file);
     void runShadowDOMTest(std::string file);
+    void runTouchActionHitTest(std::string file);
     void sendTouchEvent(WebView*, WebInputEvent::Type, WebCore::IntPoint clientPoint);
     WebView* setupTest(std::string file, TouchActionTrackingWebViewClient&);
     void runTestOnTree(WebCore::Node* root, WebView*, TouchActionTrackingWebViewClient&);
+    void runHitTestOnTree(WebCore::Node* root, WebView*, TouchActionTrackingWebViewClient&);
 
     std::string m_baseURL;
     FrameTestHelpers::WebViewHelper m_webViewHelper;
 };
 
 void TouchActionTest::runTouchActionTest(std::string file)
 {
     TouchActionTrackingWebViewClient client;
 
     WebView* webView = setupTest(file, client);
@@ skipping 16 matching lines @@
 
     for (unsigned index = 0; index < hostNodes->length(); index++) {
         WebCore::ShadowRoot* shadowRoot = WebCore::toElement(hostNodes->item(index))->shadowRoot();
         runTestOnTree(shadowRoot, webView, client);
     }
 
     // Projections show up in the main document.
     runTestOnTree(document.get(), webView, client);
 }
 
+void TouchActionTest::runTouchActionHitTest(std::string file)
+{
+    TouchActionTrackingWebViewClient client;
+
+    WebView* webView = setupTest(file, client);
+
+    RefPtr<WebCore::Document> document = static_cast<PassRefPtr<WebCore::Document> >(webView->mainFrame()->document());
+    runHitTestOnTree(document.get(), webView, client);
+}
+
 WebView* TouchActionTest::setupTest(std::string file, TouchActionTrackingWebViewClient& client)
 {
     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL), WebString::fromUTF8(file));
     // Note that JavaScript must be enabled for shadow DOM tests.
     WebView* webView = m_webViewHelper.initializeAndLoad(m_baseURL + file, true, 0, &client);
 
     // Set size to enable hit testing, and avoid line wrapping for consistency with browser.
     webView->resize(WebSize(700, 1000));
 
     // Scroll to verify the code properly transforms windows to client co-ords.
@@ skipping 104 matching lines @@
                 }
             }
 
             // Reset webview touch state.
             client.reset();
             sendTouchEvent(webView, WebInputEvent::TouchCancel, clientPoint);
             EXPECT_EQ(0, client.touchActionSetCount());
         }
     }
 }
+
+void TouchActionTest::runHitTestOnTree(WebCore::Node* root, WebView* webView, TouchActionTrackingWebViewClient& client)

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

Is there reason you need to add a new type of test?  I think the existing
'runTestOnTree' infrastructure should work perfectly for this (and test more of
the codepath than what you're testing here).  Just create some elements with the
desired stype and apply touch-action: none, and verify you get an
expected-action of none.

Eg. see the reference to bug 319479 in touch-action-simple.html - it's already
testing the main case you're fixing here (we just need to change the expected
result).  Sorry I didn't make this clear earlier.

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

Ok. i understood. i will apply this in next patch.

+{
+    // Find all elements to test the touch-action of in the document.
+    WebCore::TrackExceptionState es;
+    RefPtr<WebCore::NodeList> expectedNodes = root->querySelectorAll("[expected-hittest]", es);
+    ASSERT_FALSE(es.hadException());
+
+    RefPtr<WebCore::NodeList> nodes = root->querySelectorAll("[hittest]", es);
+    ASSERT_FALSE(es.hadException());
+
+    for (unsigned index = 0; index < nodes->length(); index++) {
+        WebCore::Element* element = toElement(nodes->item(index));
+        element->scrollIntoViewIfNeeded();
+        ASSERT_TRUE(nodes->item(index)->isElementNode());
+
+        std::string failureContext("Test case: ");
+        if (element->hasID()) {
+            failureContext.append(element->getIdAttribute().ascii().data());
+        } else if (element->firstChild()) {
+            failureContext.append("\"");
+            failureContext.append(element->firstChild()->textContent(false).stripWhiteSpace().ascii().data());
+            failureContext.append("\"");
+        } else {
+            failureContext += "<missing ID>";
+        }
+
+        // Run each test three times at different positions in the element.
+        // Note that we don't want the bounding box because our tests sometimes have elements with
+        // multiple border boxes with other elements in between. Use the first border box (which
+        // we can easily visualize in a browser for debugging).
+        RefPtr<WebCore::ClientRectList> rects = element->getClientRects();
+        ASSERT_GE(rects->length(), 0u) << failureContext;
+        RefPtr<WebCore::ClientRect> r = rects->item(0);
+        WebCore::FloatRect clientFloatRect = WebCore::FloatRect(r->left(), r->top(), r->width(), r->height());
+        WebCore::IntRect clientRect =  enclosedIntRect(clientFloatRect);
+        for (int locIdx = 0; locIdx < 3; locIdx++) {
+            WebCore::IntPoint clientPoint;
+            std::stringstream contextStream;
+            contextStream << failureContext << " (";
+            switch (locIdx) {
+            case 0:
+                clientPoint = clientRect.center();
+                contextStream << "center";
+                break;
+            case 1:
+                clientPoint = clientRect.location();
+                contextStream << "top-left";
+                break;
+            case 2:
+                clientPoint = clientRect.maxXMaxYCorner();
+                clientPoint.move(-1, -1);
+                contextStream << "bottom-right";
+                break;
+            default:
+                FAIL() << "Invalid location index.";
+            }
+            contextStream << "=" << clientPoint.x() << "," << clientPoint.y() << ").";
+            std::string failureContextPos = contextStream.str();
+
+            WebCore::Frame* frame = root->document().frame();
+            WebCore::FrameView* frameView = frame->view();
+            WebCore::IntRect visibleRect = frameView->windowClipRect();
+            ASSERT_TRUE(visibleRect.contains(clientPoint)) << failureContextPos
+                << " Test point not contained in visible area: " << visibleRect.x() << "," << visibleRect.y()
+                << "-" << visibleRect.maxX() << "," << visibleRect.maxY();
+
+            // First validate that a hit test at this point will really hit the element
+            // we intended. This is the easiest way for a test to be broken, but has nothing really
+            // to do with touch action.
+            // Note that we can't use WebView's hit test API because it doesn't look into shadow DOM.
+            WebCore::IntPoint docPoint(frameView->windowToContents(clientPoint));
+            WebCore::HitTestResult result = frame->eventHandler().hitTestResultAtPoint(docPoint, WebCore::HitTestRequest::ReadOnly | WebCore::HitTestRequest::Active | WebCore::HitTestRequest::TouchAction);
+            WebCore::Element* expectedElement = toElement(expectedNodes->item(index));
+            ASSERT_EQ(expectedElement, result.innerElement()) << "Unexpected hit test result " << failureContextPos
+                << "  Got element: \"" << result.innerElement()->outerHTML().stripWhiteSpace().left(80).ascii().data() << "\""
+                << std::endl << "Document render tree:" << std::endl << externalRepresentation(root->document().frame()).utf8().data();
+        }
+    }
+}
+
 void TouchActionTest::sendTouchEvent(WebView* webView, WebInputEvent::Type type, WebCore::IntPoint clientPoint)
 {
     ASSERT_TRUE(type == WebInputEvent::TouchStart || type == WebInputEvent::TouchCancel);
 
     WebTouchEvent webTouchEvent;
     webTouchEvent.type = type;
     webTouchEvent.touchesLength = 1;
     webTouchEvent.touches[0].state = (type == WebInputEvent::TouchStart ?
         WebTouchPoint::StatePressed :
         WebTouchPoint::StateCancelled);
@@ skipping 22 matching lines @@
 TEST_F(TouchActionTest, ShadowDOM)
 {
     runShadowDOMTest("touch-action-shadow-dom.html");
 }
 
 TEST_F(TouchActionTest, Pan)
 {
     runTouchActionTest("touch-action-pan.html");
 }
 
+TEST_F(TouchActionTest, HitTest)
+{
+    runTouchActionHitTest("touch-action-hittest.html");
 }
+
+}