Use the pinch viewport offset for tap disambiguation.

Source/web/tests/WebFrameTest.cpp

 /*
  * Copyright (C) 2010 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 31 matching lines @@
 #include "core/dom/DocumentMarkerController.h"
 #include "core/dom/Fullscreen.h"
 #include "core/dom/NodeRenderStyle.h"
 #include "core/dom/Range.h"
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/SpellChecker.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/events/MouseEvent.h"
 #include "core/fetch/MemoryCache.h"
+#include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
+#include "core/frame/PinchViewport.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLDocument.h"
 #include "core/html/HTMLFormElement.h"
 #include "core/loader/DocumentThreadableLoader.h"
 #include "core/loader/DocumentThreadableLoaderClient.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/loader/ThreadableLoader.h"
 #include "core/page/EventHandler.h"
 #include "core/page/Page.h"
 #include "core/rendering/HitTestResult.h"
@@ skipping 45 matching lines @@
 #include <v8.h>
 
 namespace {
 
 using blink::URLTestHelpers::toKURL;
 using blink::FrameTestHelpers::runPendingTasks;
 using namespace blink;
 
 const int touchPointPadding = 32;
 
-#define EXPECT_EQ_RECT(a, b) \
-    EXPECT_EQ(a.x(), b.x()); \
-    EXPECT_EQ(a.y(), b.y()); \
-    EXPECT_EQ(a.width(), b.width()); \
-    EXPECT_EQ(a.height(), b.height());
+#define EXPECT_RECT_EQ(a, b) \
+    do {                                   \
+        EXPECT_EQ(a.x(), b.x());           \
+        EXPECT_EQ(a.y(), b.y());           \
+        EXPECT_EQ(a.width(), b.width());   \
+        EXPECT_EQ(a.height(), b.height()); \
+    } while (false)
+
+#define EXPECT_POINT_EQ(expected, actual) \
+    do { \
+        EXPECT_EQ((expected).x(), (actual).x()); \
+        EXPECT_EQ((expected).y(), (actual).y()); \
+    } while (false)
+
+#define EXPECT_FLOAT_POINT_EQ(expected, actual) \
+    do { \
+        EXPECT_FLOAT_EQ((expected).x(), (actual).x()); \
+        EXPECT_FLOAT_EQ((expected).y(), (actual).y()); \
+    } while (false)
 
 class FakeCompositingWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
     virtual bool enterFullScreen() OVERRIDE { return true; }
 };
 
 class WebFrameTest : public testing::Test {
 protected:
     WebFrameTest()
         : m_baseURL("http://www.test.com/")
@@ skipping 2056 matching lines @@
     webViewHelper.webView()->setPageScaleFactor(0.5);
 
     SkBitmap bitmap;
     bitmap.allocN32Pixels(200, 200);
     bitmap.eraseColor(0);
     SkCanvas canvas(bitmap);
 
     GraphicsContext context(&canvas);
     context.setRegionTrackingMode(GraphicsContext::RegionTrackingOpaque);
 
-    EXPECT_EQ_RECT(IntRect(0, 0, 0, 0), context.opaqueRegion().asRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 0, 0), context.opaqueRegion().asRect());
 
     FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
     IntRect paintRect(0, 0, 200, 200);
     view->paint(&context, paintRect);
 
     // FIXME: This test broke in release builds when changing the FixedLayoutTestWebViewClient
     // to return a non-null layerTreeView, which is what all our shipping configurations do,
     // so this is just exposing an existing bug.
     // crbug.com/365812
 #ifndef NDEBUG
     int viewportWidthMinusScrollbar = 50 - (view->verticalScrollbar()->isOverlayScrollbar() ? 0 : 15);
     int viewportHeightMinusScrollbar = 50 - (view->horizontalScrollbar()->isOverlayScrollbar() ? 0 : 15);
     IntRect clippedRect(0, 0, viewportWidthMinusScrollbar * 2, viewportHeightMinusScrollbar * 2);
-    EXPECT_EQ_RECT(clippedRect, context.opaqueRegion().asRect());
+    EXPECT_RECT_EQ(clippedRect, context.opaqueRegion().asRect());
 #endif
 }
 
 TEST_F(WebFrameTest, pageScaleFactorUpdatesScrollbars)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
@@ skipping 1899 matching lines @@
 
     frame = webViewHelper.webView()->mainFrame();
     frame->executeCommand(WebString::fromUTF8("Unselect"));
     webViewHelper.webView()->layout();
     ASSERT_FALSE(frame->hasSelection());
     EXPECT_TRUE(fakeSelectionLayerTreeView.getAndResetSelectionCleared());
 }
 
 class DisambiguationPopupTestWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
-    virtual bool didTapMultipleTargets(const WebGestureEvent&, const WebVector<WebRect>& targetRects) OVERRIDE
+    virtual bool didTapMultipleTargets(const WebSize&, const WebRect&, const WebVector<WebRect>& targetRects) OVERRIDE
     {
         EXPECT_GE(targetRects.size(), 2u);
         m_triggered = true;
         return true;
     }
 
     bool triggered() const { return m_triggered; }
     void resetTriggered() { m_triggered = false; }
     bool m_triggered;
 };
@@ skipping 137 matching lines @@
         EXPECT_FALSE(client.triggered());
     }
 
     for (int i = 0; i <= 46; i++) {
         client.resetTriggered();
         webViewHelper.webView()->handleInputEvent(fatTap(10 + i * 5, 590));
         EXPECT_FALSE(client.triggered());
     }
 }
 
+static void enableVirtualViewport(WebSettings* settings)
+{
+    settings->setPinchVirtualViewportEnabled(true);
+    settings->setViewportEnabled(true);
+    settings->setViewportMetaEnabled(true);
+    settings->setShrinksViewportContentToFit(true);
+}
+
+TEST_F(WebFrameTest, DisambiguationPopupPinchViewport)
+{
+    const std::string htmlFile = "disambiguation_popup_200_by_800.html";
+    registerMockedHttpURLLoad(htmlFile);
+
+    DisambiguationPopupTestWebViewClient client;
+
+    FrameTestHelpers::WebViewHelper webViewHelper;
+    webViewHelper.initializeAndLoad(m_baseURL + htmlFile, true, 0, &client, enableVirtualViewport);
+
+    WebViewImpl* webViewImpl = webViewHelper.webViewImpl();
+    ASSERT_TRUE(webViewImpl);
+    LocalFrame* frame = webViewImpl->mainFrameImpl()->frame();
+    ASSERT_TRUE(frame);
+
+    webViewHelper.webView()->resize(WebSize(200, 400));
+
+    // Scroll main frame to the bottom of the document
+    webViewImpl->setMainFrameScrollOffset(WebPoint(0, 400));
+    EXPECT_POINT_EQ(IntPoint(0, 400), frame->view()->scrollPosition());
+
+    webViewImpl->setPageScaleFactor(2.0);
+
+    // Scroll pinch viewport to the top of the main frame.
+    PinchViewport& pinchViewport = frame->page()->frameHost().pinchViewport();
+    pinchViewport.setLocation(FloatPoint(0, 0));
+    EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 0), pinchViewport.location());
+
+    // Tap at the top: there is nothing there.
+    client.resetTriggered();
+    webViewHelper.webView()->handleInputEvent(fatTap(10, 60));
+    EXPECT_FALSE(client.triggered());
+
+    // Scroll pinch viewport to the bottom of the main frame.
+    pinchViewport.setLocation(FloatPoint(0, 200));
+    EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 200), pinchViewport.location());
+
+    // Now the tap with the same coordinates should hit two elements.
+    client.resetTriggered();
+    webViewHelper.webView()->handleInputEvent(fatTap(10, 60));
+    EXPECT_TRUE(client.triggered());
+}
+
 TEST_F(WebFrameTest, DisambiguationPopupBlacklist)
 {
     const unsigned viewportWidth = 500;
     const unsigned viewportHeight = 1000;
     const unsigned divHeight = 100;
     const std::string htmlFile = "disambiguation_popup_blacklist.html";
     registerMockedHttpURLLoad(htmlFile);
 
     DisambiguationPopupTestWebViewClient client;
 
@@ skipping 1412 matching lines @@
     EXPECT_EQ(200, leftRightFixed->offsetWidth());
 }
 
 TEST_F(WebFrameTest, FrameViewSetFrameRect)
 {
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank");
 
     FrameView* frameView = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
     frameView->setFrameRect(IntRect(0, 0, 200, 200));
-    EXPECT_EQ_RECT(IntRect(0, 0, 200, 200), frameView->frameRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 200, 200), frameView->frameRect());
     frameView->setFrameRect(IntRect(100, 100, 200, 200));
-    EXPECT_EQ_RECT(IntRect(100, 100, 200, 200), frameView->frameRect());
+    EXPECT_RECT_EQ(IntRect(100, 100, 200, 200), frameView->frameRect());
 }
 
 TEST_F(WebFrameTest, FullscreenLayerNonScrollable)
 {
     FakeCompositingWebViewClient client;
     registerMockedHttpURLLoad("fullscreen_div.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     int viewportWidth = 640;
     int viewportHeight = 480;
     WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(m_baseURL + "fullscreen_div.html", true, 0, &client, &configueCompositingWebView);
@@ skipping 531 matching lines @@
     EXPECT_EQ(1u, frameClient.navigationalDataReceivedCount());
 
     // Neither should a page reload.
     localFrame->reload();
     EXPECT_EQ(4u, frameClient.provisionalLoadCount());
     EXPECT_FALSE(frameClient.wasLastProvisionalLoadATransition());
     EXPECT_EQ(1u, frameClient.navigationalDataReceivedCount());
 }
 
 } // namespace