| // 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 "third_party/blink/renderer/core/frame/root_frame_viewport.h" |
| |
| #include "base/single_thread_task_runner.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/blink/public/platform/platform.h" |
| #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h" |
| #include "third_party/blink/public/platform/web_scroll_into_view_params.h" |
| #include "third_party/blink/public/platform/web_thread.h" |
| #include "third_party/blink/renderer/core/scroll/scrollable_area.h" |
| #include "third_party/blink/renderer/core/scroll/scrollbar_theme_mock.h" |
| #include "third_party/blink/renderer/platform/geometry/double_rect.h" |
| #include "third_party/blink/renderer/platform/geometry/layout_rect.h" |
| #include "third_party/blink/renderer/platform/scheduler/public/thread_scheduler.h" |
| #include "third_party/blink/renderer/platform/scroll/scroll_alignment.h" |
| #include "third_party/blink/renderer/platform/scroll/scroll_types.h" |
| |
| namespace { |
| blink::ScrollbarThemeMock scrollbar_theme_; |
| } |
| |
| namespace blink { |
| |
| class ScrollableAreaStub : public GarbageCollectedFinalized<ScrollableAreaStub>, |
| public ScrollableArea { |
| USING_GARBAGE_COLLECTED_MIXIN(ScrollableAreaStub); |
| |
| public: |
| static ScrollableAreaStub* Create(const IntSize& viewport_size, |
| const IntSize& contents_size) { |
| return new ScrollableAreaStub(viewport_size, contents_size); |
| } |
| |
| void SetViewportSize(const IntSize& viewport_size) { |
| viewport_size_ = viewport_size; |
| } |
| |
| IntSize ViewportSize() const { return viewport_size_; } |
| |
| // ScrollableArea Impl |
| int ScrollSize(ScrollbarOrientation orientation) const override { |
| IntSize scroll_dimensions = |
| MaximumScrollOffsetInt() - MinimumScrollOffsetInt(); |
| |
| return (orientation == kHorizontalScrollbar) ? scroll_dimensions.Width() |
| : scroll_dimensions.Height(); |
| } |
| |
| void SetUserInputScrollable(bool x, bool y) { |
| user_input_scrollable_x_ = x; |
| user_input_scrollable_y_ = y; |
| } |
| |
| IntSize ScrollOffsetInt() const override { |
| return FlooredIntSize(scroll_offset_); |
| } |
| ScrollOffset GetScrollOffset() const override { return scroll_offset_; } |
| IntSize MinimumScrollOffsetInt() const override { return IntSize(); } |
| ScrollOffset MinimumScrollOffset() const override { return ScrollOffset(); } |
| IntSize MaximumScrollOffsetInt() const override { |
| return FlooredIntSize(MaximumScrollOffset()); |
| } |
| |
| IntRect VisibleContentRect( |
| IncludeScrollbarsInRect = kExcludeScrollbars) const override { |
| return IntRect(IntPoint(FlooredIntSize(scroll_offset_)), viewport_size_); |
| } |
| |
| IntSize ContentsSize() const override { return contents_size_; } |
| void SetContentSize(const IntSize& contents_size) { |
| contents_size_ = contents_size; |
| } |
| |
| scoped_refptr<base::SingleThreadTaskRunner> GetTimerTaskRunner() const final { |
| return timer_task_runner_; |
| } |
| |
| ScrollbarTheme& GetPageScrollbarTheme() const override { |
| return scrollbar_theme_; |
| } |
| |
| void Trace(blink::Visitor* visitor) override { |
| ScrollableArea::Trace(visitor); |
| } |
| |
| protected: |
| ScrollableAreaStub(const IntSize& viewport_size, const IntSize& contents_size) |
| : user_input_scrollable_x_(true), |
| user_input_scrollable_y_(true), |
| viewport_size_(viewport_size), |
| contents_size_(contents_size), |
| timer_task_runner_( |
| blink::scheduler::GetSingleThreadTaskRunnerForTesting()) {} |
| |
| CompositorElementId GetCompositorElementId() const override { |
| return CompositorElementId(); |
| } |
| void UpdateScrollOffset(const ScrollOffset& offset, ScrollType) override { |
| scroll_offset_ = offset; |
| } |
| bool ShouldUseIntegerScrollOffset() const override { return true; } |
| bool IsThrottled() const override { return false; } |
| bool IsActive() const override { return true; } |
| bool IsScrollCornerVisible() const override { return true; } |
| IntRect ScrollCornerRect() const override { return IntRect(); } |
| bool ScrollbarsCanBeActive() const override { return true; } |
| IntRect ScrollableAreaBoundingBox() const override { return IntRect(); } |
| bool ShouldPlaceVerticalScrollbarOnLeft() const override { return true; } |
| void ScrollControlWasSetNeedsPaintInvalidation() override {} |
| GraphicsLayer* LayerForContainer() const override { return nullptr; } |
| GraphicsLayer* LayerForScrolling() const override { return nullptr; } |
| GraphicsLayer* LayerForHorizontalScrollbar() const override { |
| return nullptr; |
| } |
| GraphicsLayer* LayerForVerticalScrollbar() const override { return nullptr; } |
| bool UserInputScrollable(ScrollbarOrientation orientation) const override { |
| return orientation == kHorizontalScrollbar ? user_input_scrollable_x_ |
| : user_input_scrollable_y_; |
| } |
| |
| ScrollOffset ClampedScrollOffset(const ScrollOffset& offset) { |
| ScrollOffset min_offset = MinimumScrollOffset(); |
| ScrollOffset max_offset = MaximumScrollOffset(); |
| float width = std::min(std::max(offset.Width(), min_offset.Width()), |
| max_offset.Width()); |
| float height = std::min(std::max(offset.Height(), min_offset.Height()), |
| max_offset.Height()); |
| return ScrollOffset(width, height); |
| } |
| |
| bool user_input_scrollable_x_; |
| bool user_input_scrollable_y_; |
| ScrollOffset scroll_offset_; |
| IntSize viewport_size_; |
| IntSize contents_size_; |
| scoped_refptr<base::SingleThreadTaskRunner> timer_task_runner_; |
| }; |
| |
| class RootLayoutViewportStub : public ScrollableAreaStub { |
| public: |
| static RootLayoutViewportStub* Create(const IntSize& viewport_size, |
| const IntSize& contents_size) { |
| return new RootLayoutViewportStub(viewport_size, contents_size); |
| } |
| |
| ScrollOffset MaximumScrollOffset() const override { |
| return ScrollOffset(ContentsSize() - ViewportSize()); |
| } |
| |
| LayoutRect DocumentToFrame(const LayoutRect& rect) const { |
| LayoutRect ret = rect; |
| ret.Move(LayoutSize(-GetScrollOffset())); |
| return ret; |
| } |
| |
| private: |
| RootLayoutViewportStub(const IntSize& viewport_size, |
| const IntSize& contents_size) |
| : ScrollableAreaStub(viewport_size, contents_size) {} |
| |
| int VisibleWidth() const override { return viewport_size_.Width(); } |
| int VisibleHeight() const override { return viewport_size_.Height(); } |
| }; |
| |
| class VisualViewportStub : public ScrollableAreaStub { |
| public: |
| static VisualViewportStub* Create(const IntSize& viewport_size, |
| const IntSize& contents_size) { |
| return new VisualViewportStub(viewport_size, contents_size); |
| } |
| |
| ScrollOffset MaximumScrollOffset() const override { |
| ScrollOffset visible_viewport(ViewportSize()); |
| visible_viewport.Scale(1 / scale_); |
| |
| ScrollOffset max_offset = ScrollOffset(ContentsSize()) - visible_viewport; |
| return ScrollOffset(max_offset); |
| } |
| |
| void SetScale(float scale) { scale_ = scale; } |
| |
| private: |
| VisualViewportStub(const IntSize& viewport_size, const IntSize& contents_size) |
| : ScrollableAreaStub(viewport_size, contents_size), scale_(1) {} |
| |
| int VisibleWidth() const override { return viewport_size_.Width() / scale_; } |
| int VisibleHeight() const override { |
| return viewport_size_.Height() / scale_; |
| } |
| IntRect VisibleContentRect(IncludeScrollbarsInRect) const override { |
| FloatSize size(viewport_size_); |
| size.Scale(1 / scale_); |
| return IntRect(IntPoint(FlooredIntSize(GetScrollOffset())), |
| ExpandedIntSize(size)); |
| } |
| |
| float scale_; |
| }; |
| |
| class RootFrameViewportTest : public testing::Test { |
| public: |
| RootFrameViewportTest() = default; |
| |
| protected: |
| void SetUp() override {} |
| }; |
| |
| // Tests that scrolling the viewport when the layout viewport is |
| // !userInputScrollable (as happens when overflow:hidden is set) works |
| // correctly, that is, the visual viewport can scroll, but not the layout. |
| TEST_F(RootFrameViewportTest, UserInputScrollable) { |
| IntSize viewport_size(100, 150); |
| RootLayoutViewportStub* layout_viewport = |
| RootLayoutViewportStub::Create(viewport_size, IntSize(200, 300)); |
| VisualViewportStub* visual_viewport = |
| VisualViewportStub::Create(viewport_size, viewport_size); |
| |
| ScrollableArea* root_frame_viewport = |
| RootFrameViewport::Create(*visual_viewport, *layout_viewport); |
| |
| visual_viewport->SetScale(2); |
| |
| // Disable just the layout viewport's horizontal scrolling, the |
| // RootFrameViewport should remain scrollable overall. |
| layout_viewport->SetUserInputScrollable(false, true); |
| visual_viewport->SetUserInputScrollable(true, true); |
| |
| EXPECT_TRUE(root_frame_viewport->UserInputScrollable(kHorizontalScrollbar)); |
| EXPECT_TRUE(root_frame_viewport->UserInputScrollable(kVerticalScrollbar)); |
| |
| // Layout viewport shouldn't scroll since it's not horizontally scrollable, |
| // but visual viewport should. |
| root_frame_viewport->UserScroll(kScrollByPixel, FloatSize(300, 0)); |
| EXPECT_EQ(ScrollOffset(0, 0), layout_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(50, 0), visual_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(50, 0), root_frame_viewport->GetScrollOffset()); |
| |
| // Vertical scrolling should be unaffected. |
| root_frame_viewport->UserScroll(kScrollByPixel, FloatSize(0, 300)); |
| EXPECT_EQ(ScrollOffset(0, 150), layout_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(50, 75), visual_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(50, 225), root_frame_viewport->GetScrollOffset()); |
| |
| // Try the same checks as above but for the vertical direction. |
| // =============================================== |
| |
| root_frame_viewport->SetScrollOffset(ScrollOffset(), kProgrammaticScroll); |
| |
| // Disable just the layout viewport's vertical scrolling, the |
| // RootFrameViewport should remain scrollable overall. |
| layout_viewport->SetUserInputScrollable(true, false); |
| visual_viewport->SetUserInputScrollable(true, true); |
| |
| EXPECT_TRUE(root_frame_viewport->UserInputScrollable(kHorizontalScrollbar)); |
| EXPECT_TRUE(root_frame_viewport->UserInputScrollable(kVerticalScrollbar)); |
| |
| // Layout viewport shouldn't scroll since it's not vertically scrollable, |
| // but visual viewport should. |
| root_frame_viewport->UserScroll(kScrollByPixel, FloatSize(0, 300)); |
| EXPECT_EQ(ScrollOffset(0, 0), layout_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(0, 75), visual_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(0, 75), root_frame_viewport->GetScrollOffset()); |
| |
| // Horizontal scrolling should be unaffected. |
| root_frame_viewport->UserScroll(kScrollByPixel, FloatSize(300, 0)); |
| EXPECT_EQ(ScrollOffset(100, 0), layout_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(50, 75), visual_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(150, 75), root_frame_viewport->GetScrollOffset()); |
| } |
| |
| // Make sure scrolls using the scroll animator (scroll(), setScrollOffset()) |
| // work correctly when one of the subviewports is explicitly scrolled without |
| // using the // RootFrameViewport interface. |
| TEST_F(RootFrameViewportTest, TestScrollAnimatorUpdatedBeforeScroll) { |
| IntSize viewport_size(100, 150); |
| RootLayoutViewportStub* layout_viewport = |
| RootLayoutViewportStub::Create(viewport_size, IntSize(200, 300)); |
| VisualViewportStub* visual_viewport = |
| VisualViewportStub::Create(viewport_size, viewport_size); |
| |
| ScrollableArea* root_frame_viewport = |
| RootFrameViewport::Create(*visual_viewport, *layout_viewport); |
| |
| visual_viewport->SetScale(2); |
| |
| visual_viewport->SetScrollOffset(ScrollOffset(50, 75), kProgrammaticScroll); |
| EXPECT_EQ(ScrollOffset(50, 75), root_frame_viewport->GetScrollOffset()); |
| |
| // If the scroll animator doesn't update, it will still think it's at (0, 0) |
| // and so it may early exit. |
| root_frame_viewport->SetScrollOffset(ScrollOffset(0, 0), kProgrammaticScroll); |
| EXPECT_EQ(ScrollOffset(0, 0), root_frame_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(0, 0), visual_viewport->GetScrollOffset()); |
| |
| // Try again for userScroll() |
| visual_viewport->SetScrollOffset(ScrollOffset(50, 75), kProgrammaticScroll); |
| EXPECT_EQ(ScrollOffset(50, 75), root_frame_viewport->GetScrollOffset()); |
| |
| root_frame_viewport->UserScroll(kScrollByPixel, FloatSize(-50, 0)); |
| EXPECT_EQ(ScrollOffset(0, 75), root_frame_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(0, 75), visual_viewport->GetScrollOffset()); |
| |
| // Make sure the layout viewport is also accounted for. |
| root_frame_viewport->SetScrollOffset(ScrollOffset(0, 0), kProgrammaticScroll); |
| layout_viewport->SetScrollOffset(ScrollOffset(100, 150), kProgrammaticScroll); |
| EXPECT_EQ(ScrollOffset(100, 150), root_frame_viewport->GetScrollOffset()); |
| |
| root_frame_viewport->UserScroll(kScrollByPixel, FloatSize(-100, 0)); |
| EXPECT_EQ(ScrollOffset(0, 150), root_frame_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(0, 150), layout_viewport->GetScrollOffset()); |
| } |
| |
| // Test that the scrollIntoView correctly scrolls the main frame |
| // and visual viewport such that the given rect is centered in the viewport. |
| TEST_F(RootFrameViewportTest, ScrollIntoView) { |
| IntSize viewport_size(100, 150); |
| RootLayoutViewportStub* layout_viewport = |
| RootLayoutViewportStub::Create(viewport_size, IntSize(200, 300)); |
| VisualViewportStub* visual_viewport = |
| VisualViewportStub::Create(viewport_size, viewport_size); |
| |
| ScrollableArea* root_frame_viewport = |
| RootFrameViewport::Create(*visual_viewport, *layout_viewport); |
| |
| // Test that the visual viewport is scrolled if the viewport has been |
| // resized (as is the case when the ChromeOS keyboard comes up) but not |
| // scaled. |
| visual_viewport->SetViewportSize(IntSize(100, 100)); |
| root_frame_viewport->ScrollIntoView( |
| layout_viewport->DocumentToFrame(LayoutRect(100, 250, 50, 50)), |
| WebScrollIntoViewParams(ScrollAlignment::kAlignToEdgeIfNeeded, |
| ScrollAlignment::kAlignToEdgeIfNeeded, |
| kProgrammaticScroll, true, |
| kScrollBehaviorInstant)); |
| EXPECT_EQ(ScrollOffset(50, 150), layout_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(0, 50), visual_viewport->GetScrollOffset()); |
| |
| root_frame_viewport->ScrollIntoView( |
| layout_viewport->DocumentToFrame(LayoutRect(25, 75, 50, 50)), |
| WebScrollIntoViewParams(ScrollAlignment::kAlignToEdgeIfNeeded, |
| ScrollAlignment::kAlignToEdgeIfNeeded, |
| kProgrammaticScroll, true, |
| kScrollBehaviorInstant)); |
| EXPECT_EQ(ScrollOffset(25, 75), layout_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(0, 0), visual_viewport->GetScrollOffset()); |
| |
| // Reset the visual viewport's size, scale the page, and repeat the test |
| visual_viewport->SetViewportSize(IntSize(100, 150)); |
| visual_viewport->SetScale(2); |
| root_frame_viewport->SetScrollOffset(ScrollOffset(), kProgrammaticScroll); |
| |
| root_frame_viewport->ScrollIntoView( |
| layout_viewport->DocumentToFrame(LayoutRect(50, 75, 50, 75)), |
| WebScrollIntoViewParams(ScrollAlignment::kAlignToEdgeIfNeeded, |
| ScrollAlignment::kAlignToEdgeIfNeeded, |
| kProgrammaticScroll, true, |
| kScrollBehaviorInstant)); |
| EXPECT_EQ(ScrollOffset(0, 0), layout_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(50, 75), visual_viewport->GetScrollOffset()); |
| |
| root_frame_viewport->ScrollIntoView( |
| layout_viewport->DocumentToFrame(LayoutRect(190, 290, 10, 10)), |
| WebScrollIntoViewParams(ScrollAlignment::kAlignToEdgeIfNeeded, |
| ScrollAlignment::kAlignToEdgeIfNeeded, |
| kProgrammaticScroll, true, |
| kScrollBehaviorInstant)); |
| EXPECT_EQ(ScrollOffset(100, 150), layout_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(50, 75), visual_viewport->GetScrollOffset()); |
| |
| // Scrolling into view the viewport rect itself should be a no-op. |
| visual_viewport->SetViewportSize(IntSize(100, 100)); |
| visual_viewport->SetScale(1.5f); |
| visual_viewport->SetScrollOffset(ScrollOffset(0, 10), kProgrammaticScroll); |
| layout_viewport->SetScrollOffset(ScrollOffset(50, 50), kProgrammaticScroll); |
| root_frame_viewport->SetScrollOffset(root_frame_viewport->GetScrollOffset(), |
| kProgrammaticScroll); |
| |
| root_frame_viewport->ScrollIntoView( |
| layout_viewport->DocumentToFrame(LayoutRect( |
| root_frame_viewport->VisibleContentRect(kExcludeScrollbars))), |
| WebScrollIntoViewParams(ScrollAlignment::kAlignToEdgeIfNeeded, |
| ScrollAlignment::kAlignToEdgeIfNeeded, |
| kProgrammaticScroll, true, |
| kScrollBehaviorInstant)); |
| EXPECT_EQ(ScrollOffset(50, 50), layout_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(0, 10), visual_viewport->GetScrollOffset()); |
| |
| root_frame_viewport->ScrollIntoView( |
| layout_viewport->DocumentToFrame(LayoutRect( |
| root_frame_viewport->VisibleContentRect(kExcludeScrollbars))), |
| WebScrollIntoViewParams(ScrollAlignment::kAlignCenterAlways, |
| ScrollAlignment::kAlignCenterAlways, |
| kProgrammaticScroll, true, |
| kScrollBehaviorInstant)); |
| EXPECT_EQ(ScrollOffset(50, 50), layout_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(0, 10), visual_viewport->GetScrollOffset()); |
| |
| root_frame_viewport->ScrollIntoView( |
| layout_viewport->DocumentToFrame(LayoutRect( |
| root_frame_viewport->VisibleContentRect(kExcludeScrollbars))), |
| WebScrollIntoViewParams( |
| ScrollAlignment::kAlignTopAlways, ScrollAlignment::kAlignTopAlways, |
| kProgrammaticScroll, true, kScrollBehaviorInstant)); |
| EXPECT_EQ(ScrollOffset(50, 50), layout_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(0, 10), visual_viewport->GetScrollOffset()); |
| } |
| |
| // Tests that the setScrollOffset method works correctly with both viewports. |
| TEST_F(RootFrameViewportTest, SetScrollOffset) { |
| IntSize viewport_size(500, 500); |
| RootLayoutViewportStub* layout_viewport = |
| RootLayoutViewportStub::Create(viewport_size, IntSize(1000, 2000)); |
| VisualViewportStub* visual_viewport = |
| VisualViewportStub::Create(viewport_size, viewport_size); |
| |
| ScrollableArea* root_frame_viewport = |
| RootFrameViewport::Create(*visual_viewport, *layout_viewport); |
| |
| visual_viewport->SetScale(2); |
| |
| // Ensure that the visual viewport scrolls first. |
| root_frame_viewport->SetScrollOffset(ScrollOffset(100, 100), |
| kProgrammaticScroll); |
| EXPECT_EQ(ScrollOffset(100, 100), visual_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(0, 0), layout_viewport->GetScrollOffset()); |
| |
| // Scroll to the visual viewport's extent, the layout viewport should scroll |
| // the remainder. |
| root_frame_viewport->SetScrollOffset(ScrollOffset(300, 400), |
| kProgrammaticScroll); |
| EXPECT_EQ(ScrollOffset(250, 250), visual_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(50, 150), layout_viewport->GetScrollOffset()); |
| |
| // Only the layout viewport should scroll further. Make sure it doesn't scroll |
| // out of bounds. |
| root_frame_viewport->SetScrollOffset(ScrollOffset(780, 1780), |
| kProgrammaticScroll); |
| EXPECT_EQ(ScrollOffset(250, 250), visual_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(500, 1500), layout_viewport->GetScrollOffset()); |
| |
| // Scroll all the way back. |
| root_frame_viewport->SetScrollOffset(ScrollOffset(0, 0), kProgrammaticScroll); |
| EXPECT_EQ(ScrollOffset(0, 0), visual_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(0, 0), layout_viewport->GetScrollOffset()); |
| } |
| |
| // Tests that the visible rect (i.e. visual viewport rect) is correctly |
| // calculated, taking into account both viewports and page scale. |
| TEST_F(RootFrameViewportTest, VisibleContentRect) { |
| IntSize viewport_size(500, 401); |
| RootLayoutViewportStub* layout_viewport = |
| RootLayoutViewportStub::Create(viewport_size, IntSize(1000, 2000)); |
| VisualViewportStub* visual_viewport = |
| VisualViewportStub::Create(viewport_size, viewport_size); |
| |
| ScrollableArea* root_frame_viewport = |
| RootFrameViewport::Create(*visual_viewport, *layout_viewport); |
| |
| root_frame_viewport->SetScrollOffset(ScrollOffset(100, 75), |
| kProgrammaticScroll); |
| |
| EXPECT_EQ(IntPoint(100, 75), |
| root_frame_viewport->VisibleContentRect().Location()); |
| EXPECT_EQ(ScrollOffset(500, 401), |
| DoubleSize(root_frame_viewport->VisibleContentRect().Size())); |
| |
| visual_viewport->SetScale(2); |
| |
| EXPECT_EQ(IntPoint(100, 75), |
| root_frame_viewport->VisibleContentRect().Location()); |
| EXPECT_EQ(ScrollOffset(250, 201), |
| DoubleSize(root_frame_viewport->VisibleContentRect().Size())); |
| } |
| |
| // Tests that scrolls on the root frame scroll the visual viewport before |
| // trying to scroll the layout viewport. |
| TEST_F(RootFrameViewportTest, ViewportScrollOrder) { |
| IntSize viewport_size(100, 100); |
| RootLayoutViewportStub* layout_viewport = |
| RootLayoutViewportStub::Create(viewport_size, IntSize(200, 300)); |
| VisualViewportStub* visual_viewport = |
| VisualViewportStub::Create(viewport_size, viewport_size); |
| |
| ScrollableArea* root_frame_viewport = |
| RootFrameViewport::Create(*visual_viewport, *layout_viewport); |
| |
| visual_viewport->SetScale(2); |
| |
| root_frame_viewport->SetScrollOffset(ScrollOffset(40, 40), kUserScroll); |
| EXPECT_EQ(ScrollOffset(40, 40), visual_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(0, 0), layout_viewport->GetScrollOffset()); |
| |
| root_frame_viewport->SetScrollOffset(ScrollOffset(60, 60), |
| kProgrammaticScroll); |
| EXPECT_EQ(ScrollOffset(50, 50), visual_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(10, 10), layout_viewport->GetScrollOffset()); |
| } |
| |
| // Tests that setting an alternate layout viewport scrolls the alternate |
| // instead of the original. |
| TEST_F(RootFrameViewportTest, SetAlternateLayoutViewport) { |
| IntSize viewport_size(100, 100); |
| RootLayoutViewportStub* layout_viewport = |
| RootLayoutViewportStub::Create(viewport_size, IntSize(200, 300)); |
| VisualViewportStub* visual_viewport = |
| VisualViewportStub::Create(viewport_size, viewport_size); |
| |
| RootLayoutViewportStub* alternate_scroller = |
| RootLayoutViewportStub::Create(viewport_size, IntSize(600, 500)); |
| |
| RootFrameViewport* root_frame_viewport = |
| RootFrameViewport::Create(*visual_viewport, *layout_viewport); |
| |
| visual_viewport->SetScale(2); |
| |
| root_frame_viewport->SetScrollOffset(ScrollOffset(100, 100), kUserScroll); |
| EXPECT_EQ(ScrollOffset(50, 50), visual_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(50, 50), layout_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(100, 100), root_frame_viewport->GetScrollOffset()); |
| |
| root_frame_viewport->SetLayoutViewport(*alternate_scroller); |
| EXPECT_EQ(ScrollOffset(50, 50), visual_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(0, 0), alternate_scroller->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(50, 50), root_frame_viewport->GetScrollOffset()); |
| |
| root_frame_viewport->SetScrollOffset(ScrollOffset(200, 200), kUserScroll); |
| EXPECT_EQ(ScrollOffset(50, 50), visual_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(150, 150), alternate_scroller->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(200, 200), root_frame_viewport->GetScrollOffset()); |
| EXPECT_EQ(ScrollOffset(50, 50), layout_viewport->GetScrollOffset()); |
| |
| EXPECT_EQ(ScrollOffset(550, 450), root_frame_viewport->MaximumScrollOffset()); |
| } |
| |
| } // namespace blink |
