Don't reset touch-action zoom state at scrollers

third_party/WebKit/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 20 matching lines @@
 #include "config.h"
 
 #include "core/dom/ClientRect.h"
 #include "core/dom/ClientRectList.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/StaticNodeList.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
+#include "core/html/HTMLIFrameElement.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutTreeAsText.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebUnitTestSupport.h"
 #include "public/web/WebDocument.h"
 #include "public/web/WebFrame.h"
 #include "public/web/WebHitTestResult.h"
 #include "public/web/WebInputEvent.h"
 #include "public/web/WebTouchAction.h"
 #include "public/web/WebView.h"
 #include "public/web/WebViewClient.h"
 #include "public/web/WebWidgetClient.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "web/WebFrameImplBase.h"
 #include "web/WebViewImpl.h"
 #include "web/tests/FrameTestHelpers.h"
 
 using blink::testing::runPendingTasks;
 
 namespace blink {
 
 class TouchActionTrackingWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
     TouchActionTrackingWebViewClient() :
@@ skipping 44 matching lines @@
     }
 
     void TearDown() override
     {
         Platform::current()->unitTestSupport()->unregisterAllMockedURLs();
     }
 
 protected:
     void runTouchActionTest(std::string file);
     void runShadowDOMTest(std::string file);
+    void runIFrameTest(std::string file);
     void sendTouchEvent(WebView*, WebInputEvent::Type, IntPoint clientPoint);
     WebView* setupTest(std::string file, TouchActionTrackingWebViewClient&);
     void runTestOnTree(ContainerNode* root, WebView*, TouchActionTrackingWebViewClient&);
 
     std::string m_baseURL;
     FrameTestHelpers::WebViewHelper m_webViewHelper;
 };
 
 void TouchActionTest::runTouchActionTest(std::string file)
 {
@@ skipping 35 matching lines @@
         ShadowRoot* shadowRoot = hostNodes->item(index)->openShadowRoot();
         runTestOnTree(shadowRoot, webView, client);
     }
 
     // Projections show up in the main document.
     runTestOnTree(document.get(), webView, client);
 
     m_webViewHelper.reset(); // Explicitly reset to break dependency on locally scoped client.
 }
 
+void TouchActionTest::runIFrameTest(std::string file)
+{
+    TouchActionTrackingWebViewClient client;
+
+    WebView* webView = setupTest(file, client);
+    WebFrame* curFrame = webView->mainFrame()->firstChild();
+    ASSERT_TRUE(curFrame);
+
+    for (; curFrame; curFrame = curFrame->nextSibling()) {
+        // Oilpan: see runTouchActionTest() comment why these are persistent references.
+        RefPtrWillBePersistent<Document> contentDoc = static_cast<PassRefPtrWillBeRawPtr<Document>>(curFrame->document());
+        runTestOnTree(contentDoc.get(), webView, client);
+    }
+
+    m_webViewHelper.reset(); // Explicitly reset to break dependency on locally scoped 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(800, 1200));
 
     // Scroll to verify the code properly transforms windows to client co-ords.
@@ skipping 31 matching lines @@
         // 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).
         Persistent<ClientRectList> rects = element->getClientRects();
         ASSERT_GE(rects->length(), 0u) << failureContext;
         Persistent<ClientRect> r = rects->item(0);
         FloatRect clientFloatRect = FloatRect(r->left(), r->top(), r->width(), r->height());
         IntRect clientRect =  enclosedIntRect(clientFloatRect);
         for (int locIdx = 0; locIdx < 3; locIdx++) {
-            IntPoint clientPoint;
+            IntPoint framePoint;
             std::stringstream contextStream;
             contextStream << failureContext << " (";
             switch (locIdx) {
             case 0:
-                clientPoint = clientRect.center();
+                framePoint = clientRect.center();
                 contextStream << "center";
                 break;
             case 1:
-                clientPoint = clientRect.location();
+                framePoint = clientRect.location();
                 contextStream << "top-left";
                 break;
             case 2:
-                clientPoint = clientRect.maxXMaxYCorner();
-                clientPoint.move(-1, -1);
+                framePoint = clientRect.maxXMaxYCorner();
+                framePoint.move(-1, -1);
                 contextStream << "bottom-right";
                 break;
             default:
                 FAIL() << "Invalid location index.";
             }
-            contextStream << "=" << clientPoint.x() << "," << clientPoint.y() << ").";
+
+            IntPoint windowPoint = root->document().frame()->view()->convertToRootFrame(framePoint);
+            contextStream << "=" << windowPoint.x() << "," << windowPoint.y() << ").";
             std::string failureContextPos = contextStream.str();
 
-            LocalFrame* frame = root->document().frame();
-            FrameView* frameView = frame->view();
-            IntRect visibleRect = frameView->windowClipRect();
-            ASSERT_TRUE(visibleRect.contains(clientPoint)) << failureContextPos
+            LocalFrame* mainFrame = static_cast<LocalFrame*>(webView->mainFrame()->toImplBase()->frame());
+            FrameView* mainFrameView = mainFrame->view();
+            IntRect visibleRect = mainFrameView->windowClipRect();
+            ASSERT_TRUE(visibleRect.contains(windowPoint)) << 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.
-            IntPoint docPoint(frameView->rootFrameToContents(clientPoint));
-            HitTestResult result = frame->eventHandler().hitTestResultAtPoint(docPoint, HitTestRequest::ReadOnly | HitTestRequest::Active);
+            IntPoint docPoint(mainFrameView->frameToContents(windowPoint));
+            HitTestResult result = mainFrame->eventHandler().hitTestResultAtPoint(docPoint, HitTestRequest::ReadOnly | HitTestRequest::Active);
             ASSERT_EQ(element, 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();
 
             // Now send the touch event and check any touch action result.
-            sendTouchEvent(webView, WebInputEvent::TouchStart, clientPoint);
+            sendTouchEvent(webView, WebInputEvent::TouchStart, windowPoint);
 
             AtomicString expectedAction = element->getAttribute("expected-action");
             if (expectedAction == "auto") {
                 // Auto is the default - no action set.
                 EXPECT_EQ(0, client.touchActionSetCount()) << failureContextPos;
                 EXPECT_EQ(WebTouchActionAuto, client.lastTouchAction()) << failureContextPos;
             } else {
                 // Should have received exactly one touch action.
                 EXPECT_EQ(1, client.touchActionSetCount()) << failureContextPos;
                 if (client.touchActionSetCount()) {
                     if (expectedAction == "none") {
                         EXPECT_EQ(WebTouchActionNone, client.lastTouchAction()) << failureContextPos;
                     } else if (expectedAction == "pan-x") {
                         EXPECT_EQ(WebTouchActionPanX, client.lastTouchAction()) << failureContextPos;
                     } else if (expectedAction == "pan-y") {
                         EXPECT_EQ(WebTouchActionPanY, client.lastTouchAction()) << failureContextPos;
                     } else if (expectedAction == "pan-x-y") {
-                        EXPECT_EQ((WebTouchActionPanX | WebTouchActionPanY), client.lastTouchAction()) << failureContextPos;
+                        EXPECT_EQ((WebTouchActionPan), client.lastTouchAction()) << failureContextPos;
                     } else if (expectedAction == "manipulation") {
-                        EXPECT_EQ((WebTouchActionPanX | WebTouchActionPanY | WebTouchActionPinchZoom), client.lastTouchAction()) << failureContextPos;
+                        EXPECT_EQ((WebTouchActionManipulation), client.lastTouchAction()) << failureContextPos;
                     } else {
                         FAIL() << "Unrecognized expected-action \"" << expectedAction.ascii().data()
                             << "\" " << failureContextPos;
                     }
                 }
             }
 
             // Reset webview touch state.
             client.reset();
-            sendTouchEvent(webView, WebInputEvent::TouchCancel, clientPoint);
+            sendTouchEvent(webView, WebInputEvent::TouchCancel, windowPoint);
             EXPECT_EQ(0, client.touchActionSetCount());
         }
     }
 }
 void TouchActionTest::sendTouchEvent(WebView* webView, WebInputEvent::Type type, IntPoint clientPoint)
 {
     ASSERT_TRUE(type == WebInputEvent::TouchStart || type == WebInputEvent::TouchCancel);
 
     WebTouchEvent webTouchEvent;
     webTouchEvent.type = type;
@@ skipping 19 matching lines @@
 TEST_F(TouchActionTest, Simple)
 {
     runTouchActionTest("touch-action-simple.html");
 }
 
 TEST_F(TouchActionTest, Overflow)
 {
     runTouchActionTest("touch-action-overflow.html");
 }
 
+TEST_F(TouchActionTest, IFrame)
+{
+    runIFrameTest("touch-action-iframe.html");
+}
+
 TEST_F(TouchActionTest, ShadowDOM)
 {
     runShadowDOMTest("touch-action-shadow-dom.html");
 }
 
 TEST_F(TouchActionTest, Pan)
 {
     runTouchActionTest("touch-action-pan.html");
 }
 
 } // namespace blink