Made top controls work with virtual viewport pinch-to-zoom. (Blink)

Source/web/tests/PinchViewportTest.cpp

 // Copyright 2014 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 "config.h"
 
 #include "core/frame/PinchViewport.h"
 
 #include "core/frame/FrameHost.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 144 matching lines @@
         settings->setShrinksViewportContentToFit(true);
         settings->setMainFrameResizesAreOrientationChanges(true);
     }
 
 protected:
     std::string m_baseURL;
     FrameTestHelpers::TestWebViewClient m_mockWebViewClient;
 
 private:
     FrameTestHelpers::WebViewHelper m_helper;
+
+    // To prevent platform differneces in content rendering, use mock
+    // scrollbars. This is especially needed for Mac, where the presence
+    // or absence of a mouse will change frame sizes because of different
+    // scrollbar themes.
+    FrameTestHelpers::UseMockScrollbarSettings m_useMockScrollbars;
 };
 
 // Test that resizing the PinchViewport works as expected and that resizing the
 // WebView resizes the PinchViewport.
 TEST_F(PinchViewportTest, TestResize)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(320, 240));
 
     navigateTo("about:blank");
@@ skipping 340 matching lines @@
     pinchViewport.setLocation(FloatPoint(200, 200));
     EXPECT_FLOAT_POINT_EQ(FloatPoint(160, 120), pinchViewport.visibleRect().location());
 
     // Now resize the viewport to make it 10px smaller. Since we're zoomed in by 2X it should
     // allow us to scroll by 5px more.
     pinchViewport.setSize(IntSize(310, 230));
     pinchViewport.setLocation(FloatPoint(200, 200));
     EXPECT_FLOAT_POINT_EQ(FloatPoint(165, 125), pinchViewport.visibleRect().location());
 
     // The viewport can be larger than the main frame (currently 320, 240) though typically
-    // the scale will be clamped to prevent it from actually being larger. Make sure size
-    // changes clamp the offset so the inner remains within the outer.
+    // the scale will be clamped to prevent it from actually being larger.
     pinchViewport.setSize(IntSize(330, 250));
     EXPECT_SIZE_EQ(IntSize(330, 250), pinchViewport.size());
-    EXPECT_FLOAT_POINT_EQ(FloatPoint(155, 115), pinchViewport.visibleRect().location());
-    pinchViewport.setLocation(FloatPoint(200, 200));
-    EXPECT_FLOAT_POINT_EQ(FloatPoint(155, 115), pinchViewport.visibleRect().location());
 
     // Resize both the viewport and the frame to be larger.
     webViewImpl()->resize(IntSize(640, 480));
     webViewImpl()->layout();
     EXPECT_SIZE_EQ(IntSize(webViewImpl()->size()), pinchViewport.size());
     EXPECT_SIZE_EQ(IntSize(webViewImpl()->size()), frame()->view()->frameRect().size());
     pinchViewport.setLocation(FloatPoint(1000, 1000));
     EXPECT_FLOAT_POINT_EQ(FloatPoint(320, 240), pinchViewport.visibleRect().location());
 
     // Make sure resizing the viewport doesn't change its offset if the resize doesn't make
     // the viewport go out of bounds.
     pinchViewport.setLocation(FloatPoint(200, 200));
     pinchViewport.setSize(IntSize(880, 560));
     EXPECT_FLOAT_POINT_EQ(FloatPoint(200, 200), pinchViewport.visibleRect().location());
-
-    // Resizing the viewport such that the viewport is out of bounds should move the
-    // viewport.
-    pinchViewport.setSize(IntSize(920, 640));
-    EXPECT_FLOAT_POINT_EQ(FloatPoint(180, 160), pinchViewport.visibleRect().location());
 }
 
 // The main FrameView's size should be set such that its the size of the pinch viewport
 // at minimum scale. If there's no explicit minimum scale set, the FrameView should be
 // set to the content width and height derived by the aspect ratio.
 TEST_F(PinchViewportTest, TestFrameViewSizedToContent)
 {
     initializeWithAndroidSettings();
     webViewImpl()->resize(IntSize(320, 240));
 
     registerMockedHttpURLLoad("200-by-300-viewport.html");
     navigateTo(m_baseURL + "200-by-300-viewport.html");
 
     webViewImpl()->resize(IntSize(600, 800));
     webViewImpl()->layout();
 
-    EXPECT_SIZE_EQ(IntSize(200, 266),
+    // Note: the size is ceiled and should match the behavior in CC's LayerImpl::bounds().
+    EXPECT_SIZE_EQ(IntSize(200, 267),
         webViewImpl()->mainFrameImpl()->frameView()->frameRect().size());
 }
 
 // The main FrameView's size should be set such that its the size of the pinch viewport
 // at minimum scale. On Desktop, the minimum scale is set at 1 so make sure the FrameView
 // is sized to the viewport.
 TEST_F(PinchViewportTest, TestFrameViewSizedToMinimumScale)
 {
     initializeWithDesktopSettings();
     webViewImpl()->resize(IntSize(320, 240));
@@ skipping 382 matching lines @@
 
     pinchViewport.scrollIntoView(FloatRect(50, 75, 50, 75));
     EXPECT_POINT_EQ(IntPoint(50, 75), frame()->view()->scrollPosition());
     EXPECT_FLOAT_POINT_EQ(FloatPoint(), pinchViewport.visibleRect().location());
 
     pinchViewport.scrollIntoView(FloatRect(190, 290, 10, 10));
     EXPECT_POINT_EQ(IntPoint(100, 150), frame()->view()->scrollPosition());
     EXPECT_FLOAT_POINT_EQ(FloatPoint(50, 75), pinchViewport.visibleRect().location());
 }
 
+static IntPoint expectedMaxFrameViewScrollOffset(PinchViewport& pinchViewport, FrameView& frameView)
+{
+    float aspectRatio = pinchViewport.visibleRect().width() / pinchViewport.visibleRect().height();
+    float newHeight = frameView.frameRect().width() / aspectRatio;
+    return IntPoint(
+        frameView.contentsSize().width() - frameView.frameRect().width(),
+        frameView.contentsSize().height() - newHeight);
+}
+
+TEST_F(PinchViewportTest, TestTopControlsAdjustment)
+{
+    initializeWithAndroidSettings();
+    webViewImpl()->resize(IntSize(100, 150));
+
+    registerMockedHttpURLLoad("content-width-1000.html");
+    navigateTo(m_baseURL + "content-width-1000.html");
+
+    PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
+    FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
+
+    pinchViewport.setScale(1);
+    EXPECT_SIZE_EQ(IntSize(100, 150), pinchViewport.visibleRect().size());
+    EXPECT_SIZE_EQ(IntSize(1000, 1500), frameView.frameRect().size());
+
+    // Simulate bringing down the top controls by 20px.
+    webViewImpl()->applyViewportDeltas(WebSize(), WebSize(), 1, 20);
+    EXPECT_SIZE_EQ(IntSize(100, 130), pinchViewport.visibleRect().size());
+
+    // Test that the scroll bounds are adjusted appropriately: the pinch viewport
+    // should be shrunk by 20px to 130px. The outer viewport was shrunk to maintain the
+    // aspect ratio so it's height is 1300px.
+    pinchViewport.move(FloatPoint(10000, 10000));
+    EXPECT_POINT_EQ(FloatPoint(900, 1300 - 130), pinchViewport.location());
+
+    // The outer viewport (FrameView) should be affected as well.
+    frameView.scrollBy(IntSize(10000, 10000));
+    EXPECT_POINT_EQ(
+        expectedMaxFrameViewScrollOffset(pinchViewport, frameView),
+        frameView.scrollPosition());
+
+    // Simulate bringing up the top controls by 10.5px.
+    webViewImpl()->applyViewportDeltas(WebSize(), WebSize(), 1, -10.5f);
+    EXPECT_SIZE_EQ(FloatSize(100, 140.5f), pinchViewport.visibleRect().size());
+
+    // maximumScrollPosition floors the final values.
+    pinchViewport.move(FloatPoint(10000, 10000));
+    EXPECT_POINT_EQ(FloatPoint(900, floor(1405 - 140.5f)), pinchViewport.location());
+
+    // The outer viewport (FrameView) should be affected as well.
+    frameView.scrollBy(IntSize(10000, 10000));
+    EXPECT_POINT_EQ(
+        expectedMaxFrameViewScrollOffset(pinchViewport, frameView),
+        frameView.scrollPosition());
+}
+
+TEST_F(PinchViewportTest, TestTopControlsAdjustmentWithScale)
+{
+    initializeWithAndroidSettings();
+    webViewImpl()->resize(IntSize(100, 150));
+
+    registerMockedHttpURLLoad("content-width-1000.html");
+    navigateTo(m_baseURL + "content-width-1000.html");
+
+    PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
+    FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
+
+    pinchViewport.setScale(2);
+    EXPECT_SIZE_EQ(IntSize(50, 75), pinchViewport.visibleRect().size());
+    EXPECT_SIZE_EQ(IntSize(1000, 1500), frameView.frameRect().size());
+
+    // Simulate bringing down the top controls by 20px. Since we're zoomed in,
+    // the top controls take up half as much space (in document-space) than
+    // they do at an unzoomed level.
+    webViewImpl()->applyViewportDeltas(WebSize(), WebSize(), 1, 20);
+    EXPECT_SIZE_EQ(IntSize(50, 65), pinchViewport.visibleRect().size());
+
+    // Test that the scroll bounds are adjusted appropriately.
+    pinchViewport.move(FloatPoint(10000, 10000));
+    EXPECT_POINT_EQ(FloatPoint(950, 1300 - 65), pinchViewport.location());
+
+    // The outer viewport (FrameView) should be affected as well.
+    frameView.scrollBy(IntSize(10000, 10000));
+    IntPoint expected = expectedMaxFrameViewScrollOffset(pinchViewport, frameView);
+    EXPECT_POINT_EQ(expected, frameView.scrollPosition());
+
+    // Scale back out, FrameView max scroll shouldn't have changed. Pinch
+    // viewport should be moved up to accomodate larger view.
+    webViewImpl()->applyViewportDeltas(WebSize(), WebSize(), 0.5f, 0);
+    EXPECT_EQ(1, pinchViewport.scale());
+    EXPECT_POINT_EQ(expected, frameView.scrollPosition());
+    frameView.scrollBy(IntSize(10000, 10000));
+    EXPECT_POINT_EQ(expected, frameView.scrollPosition());
+
+    EXPECT_POINT_EQ(FloatPoint(900, 1300 - 130), pinchViewport.location());
+    pinchViewport.move(FloatPoint(10000, 10000));
+    EXPECT_POINT_EQ(FloatPoint(900, 1300 - 130), pinchViewport.location());
+
+    // Scale out, use a scale that causes fractional rects.
+    webViewImpl()->applyViewportDeltas(WebSize(), WebSize(), 0.8f, -20);
+    EXPECT_SIZE_EQ(FloatSize(125, 187.5), pinchViewport.visibleRect().size());
+
+    // Bring out the top controls by 11px.
+    webViewImpl()->applyViewportDeltas(WebSize(), WebSize(), 1, 11);
+    EXPECT_SIZE_EQ(FloatSize(125, 173.75), pinchViewport.visibleRect().size());
+
+    // Ensure max scroll offsets are updated properly.
+    pinchViewport.move(FloatPoint(10000, 10000));
+    EXPECT_POINT_EQ(FloatPoint(875, floor(1390 - 173.75)), pinchViewport.location());
+
+    frameView.scrollBy(IntSize(10000, 10000));
+    EXPECT_POINT_EQ(
+        expectedMaxFrameViewScrollOffset(pinchViewport, frameView),
+        frameView.scrollPosition());
+
+}
+
+TEST_F(PinchViewportTest, TestTopControlsAdjustmentAndResize)
+{
+    initializeWithAndroidSettings();
+    webViewImpl()->resize(IntSize(100, 150));
+
+    registerMockedHttpURLLoad("content-width-1000.html");
+    navigateTo(m_baseURL + "content-width-1000.html");
+
+    PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
+    FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
+
+    pinchViewport.setScale(2);
+    EXPECT_SIZE_EQ(IntSize(50, 75), pinchViewport.visibleRect().size());
+    EXPECT_SIZE_EQ(IntSize(1000, 1500), frameView.frameRect().size());
+
+    webViewImpl()->applyViewportDeltas(WebSize(), WebSize(), 1, 20);
+    EXPECT_SIZE_EQ(IntSize(100, 150), pinchViewport.size());
+    EXPECT_SIZE_EQ(IntSize(50, 65), pinchViewport.visibleRect().size());
+
+    // Scroll all the way to the bottom.
+    pinchViewport.move(FloatPoint(10000, 10000));
+    frameView.scrollBy(IntSize(10000, 10000));
+    IntPoint frameViewExpected = expectedMaxFrameViewScrollOffset(pinchViewport, frameView);
+    FloatPoint pinchViewportExpected = FloatPoint(950, 1300 - 65);
+    EXPECT_POINT_EQ(pinchViewportExpected, pinchViewport.location());
+    EXPECT_POINT_EQ(frameViewExpected, frameView.scrollPosition());
+
+    // Resize the widget to match the top controls adjustment. Ensure that scroll
+    // offsets don't get clamped in the the process.
+    webViewImpl()->setTopControlsLayoutHeight(20);
+    webViewImpl()->resize(WebSize(100, 130));
+
+    EXPECT_SIZE_EQ(IntSize(100, 130), pinchViewport.size());
+    EXPECT_SIZE_EQ(IntSize(50, 65), pinchViewport.visibleRect().size());
+    EXPECT_SIZE_EQ(IntSize(1000, 1300), frameView.frameRect().size());
+
+    EXPECT_POINT_EQ(frameViewExpected, frameView.scrollPosition());
+    EXPECT_POINT_EQ(pinchViewportExpected, pinchViewport.location());
+}
+
 } // namespace