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
*/
+ // Disable the test on Mac OSX until futher investigation.
+ // Local build on Mac is OK but thes bot fails.
+#if OS(MACOSX)
+ return;
+#endif
+
initializeWithAndroidSettings();
registerMockedHttpURLLoad("200-by-800-viewport.html");
*/
+ // Disable the test on Mac OSX until futher investigation.
+ // Local build on Mac is OK but thes bot fails.
+#if OS(MACOSX)
+ return;
+#endif
+
initializeWithAndroidSettings();
registerMockedHttpURLLoad("200-by-800-viewport.html");
PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
EXPECT_FLOAT_SIZE_EQ(FloatSize(320, 240), pinchViewport.containerLayer()->size());
}
+
// Make sure that the visibleRect method acurately reflects the scale and scroll location
// of the viewport.
TEST_F(PinchViewportTest, TestVisibleRect)
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));
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
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());
}
webViewImpl()->mainFrameImpl()->frameView()->frameRect().size());
}
+// Test that attaching a new frame view resets the size of the inner viewport scroll
+// layer. crbug.com/423189.
+TEST_F(PinchViewportTest, TestAttachingNewFrameSetsInnerScrollLayerSize)
+{
+ initializeWithAndroidSettings();
+ webViewImpl()->resize(IntSize(320, 240));
+
+ // Load a wider page first, the navigation should resize the scroll layer to
+ // the smaller size on the second navigation.
+ registerMockedHttpURLLoad("content-width-1000.html");
+ navigateTo(m_baseURL + "content-width-1000.html");
+ webViewImpl()->layout();
+
+ PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
+ pinchViewport.setScale(2);
+ pinchViewport.move(FloatPoint(50, 60));
+
+ // Move and scale the viewport to make sure it gets reset in the navigation.
+ EXPECT_POINT_EQ(FloatPoint(50, 60), pinchViewport.location());
+ EXPECT_EQ(2, pinchViewport.scale());
+
+ // Navigate again, this time the FrameView should be smaller.
+ registerMockedHttpURLLoad("viewport-device-width.html");
+ navigateTo(m_baseURL + "viewport-device-width.html");
+
+ // Ensure the scroll layer matches the frame view's size.
+ EXPECT_SIZE_EQ(FloatSize(320, 240), pinchViewport.scrollLayer()->size());
+
+ // Ensure the location and scale were reset.
+ EXPECT_POINT_EQ(FloatPoint(), pinchViewport.location());
+ EXPECT_EQ(1, pinchViewport.scale());
+}
+
// The main FrameView's size should be set such that its the size of the pinch viewport
// at minimum scale. Test that the FrameView is appropriately sized in the presence
// of a viewport <meta> tag.
EXPECT_FLOAT_POINT_EQ(FloatPoint(20, 30), pinchViewport.visibleRect().location());
}
+// Test that navigation to a new page with a different sized main frame doesn't
+// clobber the history item's main frame scroll offset. crbug.com/371867
+TEST_F(PinchViewportTest, TestNavigateToSmallerFrameViewHistoryItemClobberBug)
+{
+ initializeWithAndroidSettings();
+ webViewImpl()->resize(IntSize(100, 100));
+ webViewImpl()->layout();
+
+ registerMockedHttpURLLoad("content-width-1000.html");
+ navigateTo(m_baseURL + "content-width-1000.html");
+
+ FrameView* frameView = webViewImpl()->mainFrameImpl()->frameView();
+ frameView->setScrollOffset(IntPoint(0, 1000));
+
+ // The frameView should be 1000x1000 since the viewport meta width=1000 and
+ // the aspect ratio is 1:1.
+ EXPECT_SIZE_EQ(IntSize(1000, 1000), frameView->frameRect().size());
+
+ PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
+ pinchViewport.setScale(2);
+ pinchViewport.setLocation(FloatPoint(950, 950));
+
+ RefPtrWillBePersistent<HistoryItem> firstItem = webViewImpl()->mainFrameImpl()->frame()->loader().currentItem();
+ EXPECT_POINT_EQ(IntPoint(0, 1000), firstItem->scrollPoint());
+
+ // Now navigate to a page which causes a smaller frameView. Make sure that
+ // navigating doesn't cause the history item to set a new scroll offset
+ // before the item was replaced.
+ navigateTo("about:blank");
+ frameView = webViewImpl()->mainFrameImpl()->frameView();
+
+ EXPECT_NE(firstItem, webViewImpl()->mainFrameImpl()->frame()->loader().currentItem());
+ EXPECT_LT(frameView->frameRect().size().width(), 1000);
+ EXPECT_POINT_EQ(IntPoint(0, 1000), firstItem->scrollPoint());
+}
+
// Test that the coordinates sent into moveRangeSelection are offset by the
// pinch viewport's location.
-TEST_F(PinchViewportTest, TestWebFrameRangeAccountsForPinchViewportScroll)
+TEST_F(PinchViewportTest, DISABLED_TestWebFrameRangeAccountsForPinchViewportScroll)
{
initializeWithDesktopSettings();
webViewImpl()->settings()->setDefaultFontSize(12);
// Test that the scrollIntoView correctly scrolls the main frame
// and pinch viewports such that the given rect is centered in the viewport.
-TEST_F(PinchViewportTest, DISABLED_TestScrollingDocumentRegionIntoView)
+TEST_F(PinchViewportTest, TestScrollingDocumentRegionIntoView)
{
initializeWithDesktopSettings();
webViewImpl()->resize(IntSize(100, 150));
// resized (as is the case when the ChromeOS keyboard comes up) but not
// scaled.
webViewImpl()->resizePinchViewport(WebSize(100, 100));
- pinchViewport.scrollIntoView(FloatRect(100, 250, 50, 50));
+ pinchViewport.scrollIntoView(LayoutRect(100, 250, 50, 50));
EXPECT_POINT_EQ(IntPoint(75, 150), frame()->view()->scrollPosition());
EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 50), pinchViewport.visibleRect().location());
- pinchViewport.scrollIntoView(FloatRect(25, 75, 50, 50));
+ pinchViewport.scrollIntoView(LayoutRect(25, 75, 50, 50));
EXPECT_POINT_EQ(IntPoint(0, 0), frame()->view()->scrollPosition());
EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 50), pinchViewport.visibleRect().location());
webViewImpl()->setPageScaleFactor(2);
pinchViewport.setLocation(FloatPoint());
- pinchViewport.scrollIntoView(FloatRect(50, 75, 50, 75));
+ pinchViewport.scrollIntoView(LayoutRect(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));
+ pinchViewport.scrollIntoView(LayoutRect(190, 290, 10, 10));
EXPECT_POINT_EQ(IntPoint(100, 150), frame()->view()->scrollPosition());
EXPECT_FLOAT_POINT_EQ(FloatPoint(50, 75), pinchViewport.visibleRect().location());
+
+ // Scrolling into view the viewport rect itself should be a no-op.
+ webViewImpl()->resizePinchViewport(IntSize(100, 100));
+ webViewImpl()->setPageScaleFactor(1.5f);
+ frame()->view()->scrollTo(IntPoint(50, 50));
+ pinchViewport.setLocation(FloatPoint(0, 10));
+
+ pinchViewport.scrollIntoView(LayoutRect(pinchViewport.visibleRectInDocument()));
+ EXPECT_POINT_EQ(IntPoint(50, 50), frame()->view()->scrollPosition());
+ EXPECT_FLOAT_POINT_EQ(FloatPoint(0, 10), 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());
+}
+
+// Tests that the layout viewport's scroll layer bounds are updated in a compositing
+// change update. crbug.com/423188.
+TEST_F(PinchViewportTest, TestChangingContentSizeAffectsScrollBounds)
+{
+ initializeWithAndroidSettings();
+ webViewImpl()->resize(IntSize(100, 150));
+
+ registerMockedHttpURLLoad("content-width-1000.html");
+ navigateTo(m_baseURL + "content-width-1000.html");
+
+ FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
+ WebLayer* scrollLayer = frameView.layerForScrolling()->platformLayer();
+
+ frameView.setContentsSize(IntSize(1500, 2400));
+ frameView.updateLayoutAndStyleForPainting();
+
+ EXPECT_SIZE_EQ(IntSize(1500, 2400), IntSize(scrollLayer->bounds()));
+}
+
+// Tests that a resize due to top controls hiding doesn't incorrectly clamp the
+// main frame's scroll offset. crbug.com/428193.
+TEST_F(PinchViewportTest, TestTopControlHidingResizeDoesntClampMainFrame)
+{
+ initializeWithAndroidSettings();
+ webViewImpl()->applyViewportDeltas(WebSize(), WebSize(), 1, 500);
+ webViewImpl()->setTopControlsLayoutHeight(500);
+ webViewImpl()->resize(IntSize(1000, 1000));
+
+ registerMockedHttpURLLoad("content-width-1000.html");
+ navigateTo(m_baseURL + "content-width-1000.html");
+
+ // Scroll the FrameView to the bottom of the page but "hide" the top
+ // controls on the compositor side so the max scroll position should account
+ // for the full viewport height.
+ webViewImpl()->applyViewportDeltas(WebSize(), WebSize(), 1, -500);
+ FrameView& frameView = *webViewImpl()->mainFrameImpl()->frameView();
+ frameView.setScrollPosition(IntPoint(0, 10000));
+ EXPECT_EQ(500, frameView.scrollPositionDouble().y());
+
+ // Now send the resize, make sure the scroll offset doesn't change.
+ webViewImpl()->setTopControlsLayoutHeight(0);
+ webViewImpl()->resize(IntSize(1000, 1500));
+ EXPECT_EQ(500, frameView.scrollPositionDouble().y());
+}
+
+// Tests that resizing the pinch viepwort keeps its bounds within the outer
+// viewport.
+TEST_F(PinchViewportTest, ResizePinchViewportStaysWithinOuterViewport)
+{
+ initializeWithDesktopSettings();
+ webViewImpl()->resize(IntSize(100, 200));
+
+ navigateTo("about:blank");
+ webViewImpl()->layout();
+
+ webViewImpl()->resizePinchViewport(IntSize(100, 100));
+
+ PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
+ pinchViewport.move(FloatPoint(0, 100));
+
+ EXPECT_EQ(100, pinchViewport.location().y());
+
+ webViewImpl()->resizePinchViewport(IntSize(100, 200));
+
+ EXPECT_EQ(0, pinchViewport.location().y());
+}
+
+// Tests that when a new frame is created, it is created with the intended
+// size (i.e. the contentWidth).
+TEST_F(PinchViewportTest, TestMainFrameInitializationSizing)
+{
+ initializeWithAndroidSettings();
+
+ webViewImpl()->setPageScaleFactorLimits(0.5, 2.0);
+ webViewImpl()->resize(IntSize(100, 200));
+
+ registerMockedHttpURLLoad("content-width-1000.html");
+ navigateTo(m_baseURL + "content-width-1000.html");
+
+ WebLocalFrameImpl* localFrame = webViewImpl()->mainFrameImpl();
+ FrameView& frameView = *localFrame->frameView();
+ localFrame->createFrameView();
+
+ EXPECT_SIZE_EQ(IntSize(200, 400), frameView.frameRect().size());
}
} // namespace
projects / platform / framework / web / crosswalk.git / blobdiff