OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/renderer_host/render_widget_host_view_aura.h" | 5 #include "content/browser/renderer_host/render_widget_host_view_aura.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include <tuple> | 10 #include <tuple> |
(...skipping 725 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
736 void EnableRafAlignedTouchInput() { | 736 void EnableRafAlignedTouchInput() { |
737 feature_list_.InitFromCommandLine( | 737 feature_list_.InitFromCommandLine( |
738 features::kRafAlignedTouchInputEvents.name, ""); | 738 features::kRafAlignedTouchInputEvents.name, ""); |
739 } | 739 } |
740 | 740 |
741 void DisableRafAlignedTouchInput() { | 741 void DisableRafAlignedTouchInput() { |
742 feature_list_.InitFromCommandLine( | 742 feature_list_.InitFromCommandLine( |
743 "", features::kRafAlignedTouchInputEvents.name); | 743 "", features::kRafAlignedTouchInputEvents.name); |
744 } | 744 } |
745 | 745 |
746 void EnableWheelScrollLatching() { | |
747 feature_list_.InitFromCommandLine( | |
748 features::kTouchpadAndWheelScrollLatching.name, ""); | |
749 } | |
750 | |
751 void DisableWheelScrollLatching() { | |
752 feature_list_.InitFromCommandLine( | |
753 "", features::kTouchpadAndWheelScrollLatching.name); | |
754 } | |
755 | |
746 void SetFeatureList(bool raf_aligned_touch, bool wheel_scroll_latching) { | 756 void SetFeatureList(bool raf_aligned_touch, bool wheel_scroll_latching) { |
747 if (raf_aligned_touch && wheel_scroll_latching) { | 757 if (raf_aligned_touch && wheel_scroll_latching) { |
748 feature_list_.InitWithFeatures( | 758 feature_list_.InitWithFeatures( |
749 {features::kRafAlignedTouchInputEvents, | 759 {features::kRafAlignedTouchInputEvents, |
750 features::kTouchpadAndWheelScrollLatching}, | 760 features::kTouchpadAndWheelScrollLatching}, |
751 {}); | 761 {}); |
752 } else if (raf_aligned_touch && !wheel_scroll_latching) { | 762 } else if (raf_aligned_touch && !wheel_scroll_latching) { |
753 feature_list_.InitWithFeatures( | 763 feature_list_.InitWithFeatures( |
754 {features::kRafAlignedTouchInputEvents}, | 764 {features::kRafAlignedTouchInputEvents}, |
755 {features::kTouchpadAndWheelScrollLatching}); | 765 {features::kTouchpadAndWheelScrollLatching}); |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
840 | 850 |
841 class RenderWidgetHostViewAuraRafAlignedTouchDisabledTest | 851 class RenderWidgetHostViewAuraRafAlignedTouchDisabledTest |
842 : public RenderWidgetHostViewAuraTest { | 852 : public RenderWidgetHostViewAuraTest { |
843 public: | 853 public: |
844 void SetUp() override { | 854 void SetUp() override { |
845 DisableRafAlignedTouchInput(); | 855 DisableRafAlignedTouchInput(); |
846 RenderWidgetHostViewAuraTest::SetUp(); | 856 RenderWidgetHostViewAuraTest::SetUp(); |
847 } | 857 } |
848 }; | 858 }; |
849 | 859 |
860 class RenderWidgetHostViewAuraWheelScrollLatchingEnabledTest | |
861 : public RenderWidgetHostViewAuraTest { | |
862 public: | |
863 void SetUp() override { | |
864 EnableWheelScrollLatching(); | |
865 ui::GestureConfiguration::GetInstance()->set_scroll_debounce_interval_in_ms( | |
866 0); | |
867 RenderWidgetHostViewAuraTest::SetUp(); | |
868 } | |
869 }; | |
870 | |
850 void InstallDelegatedFrameHostClient( | 871 void InstallDelegatedFrameHostClient( |
851 RenderWidgetHostViewAura* render_widget_host_view, | 872 RenderWidgetHostViewAura* render_widget_host_view, |
852 std::unique_ptr<DelegatedFrameHostClient> delegated_frame_host_client) { | 873 std::unique_ptr<DelegatedFrameHostClient> delegated_frame_host_client) { |
853 RenderWidgetHostViewAuraTest::InstallDelegatedFrameHostClient( | 874 RenderWidgetHostViewAuraTest::InstallDelegatedFrameHostClient( |
854 render_widget_host_view, std::move(delegated_frame_host_client)); | 875 render_widget_host_view, std::move(delegated_frame_host_client)); |
855 } | 876 } |
856 | 877 |
857 // Helper class to instantiate RenderWidgetHostViewGuest which is backed | 878 // Helper class to instantiate RenderWidgetHostViewGuest which is backed |
858 // by an aura platform view. | 879 // by an aura platform view. |
859 class RenderWidgetHostViewGuestAuraTest : public RenderWidgetHostViewAuraTest { | 880 class RenderWidgetHostViewGuestAuraTest : public RenderWidgetHostViewAuraTest { |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
933 const ui::LatencyInfo& ui_latency) { | 954 const ui::LatencyInfo& ui_latency) { |
934 widget_host_->ForwardMouseEventWithLatencyInfo( | 955 widget_host_->ForwardMouseEventWithLatencyInfo( |
935 SyntheticWebMouseEventBuilder::Build(type), ui_latency); | 956 SyntheticWebMouseEventBuilder::Build(type), ui_latency); |
936 } | 957 } |
937 | 958 |
938 void SimulateWheelEvent(float dX, float dY, int modifiers, bool precise) { | 959 void SimulateWheelEvent(float dX, float dY, int modifiers, bool precise) { |
939 widget_host_->ForwardWheelEvent(SyntheticWebMouseWheelEventBuilder::Build( | 960 widget_host_->ForwardWheelEvent(SyntheticWebMouseWheelEventBuilder::Build( |
940 0, 0, dX, dY, modifiers, precise)); | 961 0, 0, dX, dY, modifiers, precise)); |
941 } | 962 } |
942 | 963 |
964 void SimulateWheelEventWithPhase(float dX, | |
965 float dY, | |
966 int modifiers, | |
967 bool precise, | |
968 WebMouseWheelEvent::Phase phase) { | |
969 WebMouseWheelEvent wheel_event = SyntheticWebMouseWheelEventBuilder::Build( | |
970 0, 0, dX, dY, modifiers, precise); | |
971 wheel_event.phase = phase; | |
972 widget_host_->ForwardWheelEvent(wheel_event); | |
973 } | |
974 | |
943 void SimulateWheelEventWithLatencyInfo(float dX, | 975 void SimulateWheelEventWithLatencyInfo(float dX, |
944 float dY, | 976 float dY, |
945 int modifiers, | 977 int modifiers, |
946 bool precise, | 978 bool precise, |
947 const ui::LatencyInfo& ui_latency) { | 979 const ui::LatencyInfo& ui_latency) { |
948 widget_host_->ForwardWheelEventWithLatencyInfo( | 980 widget_host_->ForwardWheelEventWithLatencyInfo( |
949 SyntheticWebMouseWheelEventBuilder::Build(0, 0, dX, dY, modifiers, | 981 SyntheticWebMouseWheelEventBuilder::Build(0, 0, dX, dY, modifiers, |
950 precise), | 982 precise), |
951 ui_latency); | 983 ui_latency); |
952 } | 984 } |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1070 void ReleaseTouchPoint(int index) { | 1102 void ReleaseTouchPoint(int index) { |
1071 touch_event_.ReleasePoint(index); | 1103 touch_event_.ReleasePoint(index); |
1072 } | 1104 } |
1073 | 1105 |
1074 void ExpectGestureScrollEndForWheelScrolling(bool is_last) { | 1106 void ExpectGestureScrollEndForWheelScrolling(bool is_last) { |
1075 if (wheel_scroll_latching_enabled_) { | 1107 if (wheel_scroll_latching_enabled_) { |
1076 if (!is_last) { | 1108 if (!is_last) { |
1077 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); | 1109 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); |
1078 return; | 1110 return; |
1079 } | 1111 } |
1080 // Let the ScrollEnd timer in mouseWheelEventQueue fire. This will cause | |
1081 // the mouseWheelEventQueue to send a GestureScrollEnd event. | |
1082 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
1083 FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), | |
1084 base::TimeDelta::FromMilliseconds( | |
1085 kDefaultWheelScrollLatchingTransactionMs)); | |
1086 base::RunLoop().Run(); | |
1087 } | 1112 } |
1088 | 1113 |
1089 EXPECT_EQ(1U, sink_->message_count()); | 1114 EXPECT_EQ(1U, sink_->message_count()); |
1090 InputMsg_HandleInputEvent::Param params; | 1115 InputMsg_HandleInputEvent::Param params; |
1091 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(0), ¶ms)) { | 1116 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(0), ¶ms)) { |
1092 const blink::WebInputEvent* event = std::get<0>(params); | 1117 const blink::WebInputEvent* event = std::get<0>(params); |
1093 EXPECT_EQ(WebInputEvent::kGestureScrollEnd, event->GetType()); | 1118 EXPECT_EQ(WebInputEvent::kGestureScrollEnd, event->GetType()); |
1094 } | 1119 } |
1095 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 1120 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
1096 } | 1121 } |
(...skipping 622 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1719 | 1744 |
1720 ui::TouchEvent release2( | 1745 ui::TouchEvent release2( |
1721 ui::ET_TOUCH_RELEASED, gfx::Point(20, 20), base::TimeTicks::Now(), | 1746 ui::ET_TOUCH_RELEASED, gfx::Point(20, 20), base::TimeTicks::Now(), |
1722 ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, 0)); | 1747 ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, 0)); |
1723 view_->OnTouchEvent(&release2); | 1748 view_->OnTouchEvent(&release2); |
1724 EXPECT_TRUE(press.synchronous_handling_disabled()); | 1749 EXPECT_TRUE(press.synchronous_handling_disabled()); |
1725 EXPECT_EQ(0U, pointer_state().GetPointerCount()); | 1750 EXPECT_EQ(0U, pointer_state().GetPointerCount()); |
1726 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); | 1751 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); |
1727 } | 1752 } |
1728 | 1753 |
1754 TEST_F(RenderWidgetHostViewAuraWheelScrollLatchingEnabledTest, | |
1755 TimerBasedWheelEventPhaseInfo) { | |
1756 view_->InitAsChild(nullptr); | |
1757 view_->Show(); | |
1758 sink_->ClearMessages(); | |
1759 | |
1760 ui::MouseWheelEvent event(gfx::Vector2d(0, 5), gfx::Point(2, 2), | |
1761 gfx::Point(2, 2), ui::EventTimeForNow(), 0, 0); | |
1762 view_->OnMouseEvent(&event); | |
1763 const WebInputEvent* input_event = | |
1764 GetInputEventFromMessage(*sink_->GetMessageAt(0)); | |
1765 const WebMouseWheelEvent* wheel_event = | |
1766 static_cast<const WebMouseWheelEvent*>(input_event); | |
1767 EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, wheel_event->phase); | |
1768 SendInputEventACK(blink::WebInputEvent::kMouseWheel, | |
1769 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
1770 | |
1771 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1)); | |
1772 const WebGestureEvent* gesture_event = | |
1773 static_cast<const WebGestureEvent*>(input_event); | |
1774 EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType()); | |
1775 | |
1776 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(2)); | |
1777 gesture_event = static_cast<const WebGestureEvent*>(input_event); | |
1778 EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType()); | |
1779 EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x); | |
1780 EXPECT_EQ(5U, gesture_event->data.scroll_update.delta_y); | |
1781 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | |
1782 INPUT_EVENT_ACK_STATE_CONSUMED); | |
1783 sink_->ClearMessages(); | |
1784 | |
1785 // Send a ui::ScrollEvent instead of ui::MouseWheel event, the timer based | |
1786 // phase info doesn't diffrentiate between the two types of events. | |
1787 ui::ScrollEvent scroll1(ui::ET_SCROLL, gfx::Point(2, 2), | |
1788 ui::EventTimeForNow(), 0, 0, 2, 0, 2, 2); | |
1789 view_->OnScrollEvent(&scroll1); | |
1790 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0)); | |
1791 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); | |
1792 EXPECT_EQ(WebMouseWheelEvent::kPhaseChanged, wheel_event->phase); | |
1793 SendInputEventACK(blink::WebInputEvent::kMouseWheel, | |
1794 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
1795 | |
1796 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1)); | |
1797 gesture_event = static_cast<const WebGestureEvent*>(input_event); | |
1798 EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType()); | |
1799 EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x); | |
1800 EXPECT_EQ(2U, gesture_event->data.scroll_update.delta_y); | |
1801 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | |
1802 INPUT_EVENT_ACK_STATE_CONSUMED); | |
1803 sink_->ClearMessages(); | |
1804 | |
1805 // Let the RenderWidgetHostViewEventHandler::mouse_wheel_phase_timer_ fire. A | |
1806 // synthetic wheel event with zero deltas and kPhaseEnded will be sent. | |
1807 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
1808 FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), | |
1809 base::TimeDelta::FromMilliseconds( | |
1810 kDefaultMouseWheelLatchingTransactionMs)); | |
1811 base::RunLoop().Run(); | |
1812 | |
1813 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0)); | |
1814 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); | |
1815 EXPECT_EQ(WebMouseWheelEvent::kPhaseEnded, wheel_event->phase); | |
1816 EXPECT_EQ(0U, wheel_event->delta_x); | |
1817 EXPECT_EQ(0U, wheel_event->delta_y); | |
1818 SendInputEventACK(blink::WebInputEvent::kMouseWheel, | |
1819 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
1820 | |
1821 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1)); | |
1822 gesture_event = static_cast<const WebGestureEvent*>(input_event); | |
1823 EXPECT_EQ(WebInputEvent::kGestureScrollEnd, gesture_event->GetType()); | |
1824 sink_->ClearMessages(); | |
1825 } | |
1826 | |
1827 // Tests that a gesture fling start with touchpad source stops the | |
1828 // RenderWidgetHostViewEventHandler::mouse_wheel_phase_timer_ and no synthetic | |
1829 // wheel event will be sent. | |
1830 TEST_F(RenderWidgetHostViewAuraWheelScrollLatchingEnabledTest, | |
1831 TouchpadFlingStartStopsWheelPhaseTimer) { | |
1832 ui::ScrollEvent scroll0(ui::ET_SCROLL, gfx::Point(2, 2), | |
1833 ui::EventTimeForNow(), 0, 0, 5, 0, 5, 2); | |
1834 view_->OnScrollEvent(&scroll0); | |
1835 const WebInputEvent* input_event = | |
1836 GetInputEventFromMessage(*sink_->GetMessageAt(0)); | |
1837 const WebMouseWheelEvent* wheel_event = | |
1838 static_cast<const WebMouseWheelEvent*>(input_event); | |
1839 EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, wheel_event->phase); | |
1840 SendInputEventACK(blink::WebInputEvent::kMouseWheel, | |
1841 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
1842 | |
1843 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1)); | |
1844 const WebGestureEvent* gesture_event = | |
1845 static_cast<const WebGestureEvent*>(input_event); | |
1846 EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType()); | |
1847 | |
1848 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(2)); | |
1849 gesture_event = static_cast<const WebGestureEvent*>(input_event); | |
1850 EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType()); | |
1851 EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x); | |
1852 EXPECT_EQ(5U, gesture_event->data.scroll_update.delta_y); | |
1853 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | |
1854 INPUT_EVENT_ACK_STATE_CONSUMED); | |
1855 sink_->ClearMessages(); | |
1856 | |
1857 ui::ScrollEvent fling_start(ui::ET_SCROLL_FLING_START, gfx::Point(2, 2), | |
1858 ui::EventTimeForNow(), 0, 0, 10, 0, 10, 2); | |
1859 view_->OnScrollEvent(&fling_start); | |
1860 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0)); | |
1861 gesture_event = static_cast<const WebGestureEvent*>(input_event); | |
1862 EXPECT_EQ(WebInputEvent::kGestureFlingStart, gesture_event->GetType()); | |
1863 SendInputEventACK(WebInputEvent::kGestureFlingStart, | |
1864 INPUT_EVENT_ACK_STATE_CONSUMED); | |
1865 sink_->ClearMessages(); | |
1866 | |
1867 // Let the RenderWidgetHostViewEventHandler::mouse_wheel_phase_timer_ fire. No | |
1868 // synthetic wheel event will be sent since the timer has stopped. | |
1869 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
1870 FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), | |
1871 base::TimeDelta::FromMilliseconds( | |
1872 kDefaultMouseWheelLatchingTransactionMs)); | |
1873 base::RunLoop().Run(); | |
1874 | |
1875 EXPECT_EQ(0U, sink_->message_count()); | |
1876 | |
1877 // Handling the next ui::ET_SCROLL event will send a fling cancellation and a | |
1878 // mouse wheel with kPhaseBegan. | |
1879 ui::ScrollEvent scroll1(ui::ET_SCROLL, gfx::Point(2, 2), | |
1880 ui::EventTimeForNow(), 0, 0, 15, 0, 15, 2); | |
1881 view_->OnScrollEvent(&scroll1); | |
1882 EXPECT_EQ(2U, sink_->message_count()); | |
1883 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0)); | |
1884 gesture_event = static_cast<const WebGestureEvent*>(input_event); | |
1885 | |
1886 EXPECT_EQ(WebInputEvent::kGestureFlingCancel, gesture_event->GetType()); | |
1887 SendInputEventACK(WebInputEvent::kGestureFlingCancel, | |
1888 INPUT_EVENT_ACK_STATE_CONSUMED); | |
1889 | |
1890 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1)); | |
1891 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); | |
1892 EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, wheel_event->phase); | |
1893 sink_->ClearMessages(); | |
1894 } | |
1895 | |
1896 TEST_F(RenderWidgetHostViewAuraWheelScrollLatchingEnabledTest, | |
1897 GSBWithTouchSourceStopsWheelScrollSequence) { | |
1898 ui::ScrollEvent scroll0(ui::ET_SCROLL, gfx::Point(2, 2), | |
1899 ui::EventTimeForNow(), 0, 0, 5, 0, 5, 2); | |
1900 view_->OnScrollEvent(&scroll0); | |
1901 const WebInputEvent* input_event = | |
1902 GetInputEventFromMessage(*sink_->GetMessageAt(0)); | |
1903 const WebMouseWheelEvent* wheel_event = | |
1904 static_cast<const WebMouseWheelEvent*>(input_event); | |
1905 EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, wheel_event->phase); | |
1906 SendInputEventACK(blink::WebInputEvent::kMouseWheel, | |
1907 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
1908 | |
1909 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1)); | |
1910 const WebGestureEvent* gesture_event = | |
1911 static_cast<const WebGestureEvent*>(input_event); | |
1912 EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType()); | |
1913 | |
1914 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(2)); | |
1915 gesture_event = static_cast<const WebGestureEvent*>(input_event); | |
1916 EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType()); | |
1917 EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x); | |
1918 EXPECT_EQ(5U, gesture_event->data.scroll_update.delta_y); | |
1919 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | |
1920 INPUT_EVENT_ACK_STATE_CONSUMED); | |
1921 sink_->ClearMessages(); | |
1922 | |
1923 ui::GestureEventDetails event_details(ui::ET_GESTURE_SCROLL_BEGIN); | |
1924 event_details.set_device_type(ui::GestureDeviceType::DEVICE_TOUCHSCREEN); | |
1925 ui::GestureEvent scroll_begin(2, 2, 0, ui::EventTimeForNow(), event_details); | |
1926 view_->OnGestureEvent(&scroll_begin); | |
1927 EXPECT_EQ(3U, sink_->message_count()); | |
1928 | |
1929 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0)); | |
1930 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); | |
1931 EXPECT_EQ(WebMouseWheelEvent::kPhaseEnded, wheel_event->phase); | |
1932 EXPECT_EQ(0U, wheel_event->delta_x); | |
1933 EXPECT_EQ(0U, wheel_event->delta_y); | |
1934 | |
1935 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1)); | |
1936 gesture_event = static_cast<const WebGestureEvent*>(input_event); | |
1937 EXPECT_EQ(WebInputEvent::kGestureScrollEnd, gesture_event->GetType()); | |
1938 EXPECT_EQ(blink::kWebGestureDeviceTouchpad, gesture_event->source_device); | |
1939 | |
1940 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(2)); | |
1941 gesture_event = static_cast<const WebGestureEvent*>(input_event); | |
1942 EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType()); | |
1943 EXPECT_EQ(blink::kWebGestureDeviceTouchscreen, gesture_event->source_device); | |
1944 sink_->ClearMessages(); | |
1945 } | |
1946 | |
1729 // Checks that touch-event state is maintained correctly for multiple touch | 1947 // Checks that touch-event state is maintained correctly for multiple touch |
1730 // points. | 1948 // points. |
1731 TEST_F(RenderWidgetHostViewAuraTest, MultiTouchPointsStates) { | 1949 TEST_F(RenderWidgetHostViewAuraTest, MultiTouchPointsStates) { |
1732 view_->InitAsFullscreen(parent_view_); | 1950 view_->InitAsFullscreen(parent_view_); |
1733 view_->Show(); | 1951 view_->Show(); |
1734 view_->UseFakeDispatcher(); | 1952 view_->UseFakeDispatcher(); |
1735 GetSentMessageCountAndResetSink(); | 1953 GetSentMessageCountAndResetSink(); |
1736 | 1954 |
1737 ui::TouchEvent press0( | 1955 ui::TouchEvent press0( |
1738 ui::ET_TOUCH_PRESSED, gfx::Point(30, 30), ui::EventTimeForNow(), | 1956 ui::ET_TOUCH_PRESSED, gfx::Point(30, 30), ui::EventTimeForNow(), |
(...skipping 1782 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3521 EXPECT_EQ(ui::MotionEvent::ACTION_DOWN, pointer_state().GetAction()); | 3739 EXPECT_EQ(ui::MotionEvent::ACTION_DOWN, pointer_state().GetAction()); |
3522 EXPECT_EQ(1U, pointer_state().GetPointerCount()); | 3740 EXPECT_EQ(1U, pointer_state().GetPointerCount()); |
3523 EXPECT_EQ(kX, pointer_state().GetX(0)); | 3741 EXPECT_EQ(kX, pointer_state().GetX(0)); |
3524 EXPECT_EQ(kY, pointer_state().GetY(0)); | 3742 EXPECT_EQ(kY, pointer_state().GetY(0)); |
3525 } | 3743 } |
3526 | 3744 |
3527 void RenderWidgetHostViewAuraOverscrollTest::WheelNotPreciseScrollEvent() { | 3745 void RenderWidgetHostViewAuraOverscrollTest::WheelNotPreciseScrollEvent() { |
3528 SetUpOverscrollEnvironment(); | 3746 SetUpOverscrollEnvironment(); |
3529 | 3747 |
3530 // Simulate wheel events. | 3748 // Simulate wheel events. |
3531 SimulateWheelEvent(-5, 0, 0, false); // sent directly | 3749 if (!wheel_scroll_latching_enabled_) { |
3532 SimulateWheelEvent(-60, 1, 0, false); // enqueued | 3750 SimulateWheelEvent(-5, 0, 0, false); // sent directly |
3751 SimulateWheelEvent(-60, 1, 0, false); // enqueued | |
3752 } else { | |
3753 SimulateWheelEventWithPhase( | |
3754 -5, 0, 0, false, WebMouseWheelEvent::kPhaseBegan); // sent directly | |
3755 SimulateWheelEventWithPhase(-60, 1, 0, false, | |
3756 WebMouseWheelEvent::kPhaseChanged); // enqueued | |
3757 } | |
3533 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3758 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3534 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 3759 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3535 | 3760 |
3536 // Receive ACK the first wheel event as not processed. | 3761 // Receive ACK the first wheel event as not processed. |
3537 SendInputEventACK(WebInputEvent::kMouseWheel, | 3762 SendInputEventACK(WebInputEvent::kMouseWheel, |
3538 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3763 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3539 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 3764 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); |
3540 | 3765 |
3541 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3766 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3542 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3767 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3543 ExpectGestureScrollEndForWheelScrolling(false); | 3768 ExpectGestureScrollEndForWheelScrolling(false); |
3544 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3769 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3545 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 3770 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3546 | 3771 |
3547 SendInputEventACK(WebInputEvent::kMouseWheel, | 3772 SendInputEventACK(WebInputEvent::kMouseWheel, |
3548 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3773 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3549 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 3774 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3550 | 3775 |
3551 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3776 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3552 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3777 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3778 if (wheel_scroll_latching_enabled_) { | |
3779 SimulateWheelEventWithPhase(0, 0, 0, false, | |
3780 WebMouseWheelEvent::kPhaseEnded); | |
3781 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | |
3782 SendInputEventACK(WebInputEvent::kMouseWheel, | |
3783 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
3784 } | |
3553 ExpectGestureScrollEndForWheelScrolling(true); | 3785 ExpectGestureScrollEndForWheelScrolling(true); |
3554 | 3786 |
3555 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3787 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3556 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 3788 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3557 } | 3789 } |
3558 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelNotPreciseScrollEvent) { | 3790 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelNotPreciseScrollEvent) { |
3559 WheelNotPreciseScrollEvent(); | 3791 WheelNotPreciseScrollEvent(); |
3560 } | 3792 } |
3561 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 3793 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
3562 WheelNotPreciseScrollEvent) { | 3794 WheelNotPreciseScrollEvent) { |
3563 WheelNotPreciseScrollEvent(); | 3795 WheelNotPreciseScrollEvent(); |
3564 } | 3796 } |
3565 | 3797 |
3566 void RenderWidgetHostViewAuraOverscrollTest::WheelScrollEventOverscrolls() { | 3798 void RenderWidgetHostViewAuraOverscrollTest::WheelScrollEventOverscrolls() { |
3567 SetUpOverscrollEnvironment(); | 3799 SetUpOverscrollEnvironment(); |
3568 | 3800 |
3569 // Simulate wheel events. | 3801 // Simulate wheel events. |
3570 SimulateWheelEvent(-5, 0, 0, true); // sent directly | 3802 if (!wheel_scroll_latching_enabled_) { |
3571 SimulateWheelEvent(-1, 1, 0, true); // enqueued | 3803 SimulateWheelEvent(-5, 0, 0, true); // sent directly |
3572 SimulateWheelEvent(-10, -3, 0, true); // coalesced into previous event | 3804 SimulateWheelEvent(-1, 1, 0, true); // enqueued |
3573 SimulateWheelEvent(-15, -1, 0, true); // coalesced into previous event | 3805 SimulateWheelEvent(-10, -3, 0, true); // coalesced into previous event |
3574 SimulateWheelEvent(-30, -3, 0, true); // coalesced into previous event | 3806 SimulateWheelEvent(-15, -1, 0, true); // coalesced into previous event |
3575 SimulateWheelEvent(-20, 6, 1, true); // enqueued, different modifiers | 3807 SimulateWheelEvent(-30, -3, 0, true); // coalesced into previous event |
3808 SimulateWheelEvent(-20, 6, 1, true); // enqueued, different modifiers | |
3809 } else { | |
3810 SimulateWheelEventWithPhase( | |
3811 -5, 0, 0, true, WebMouseWheelEvent::kPhaseBegan); // sent directly | |
3812 SimulateWheelEventWithPhase(-1, 1, 0, true, | |
3813 WebMouseWheelEvent::kPhaseChanged); // enqueued | |
3814 SimulateWheelEventWithPhase( | |
3815 -10, -3, 0, true, | |
3816 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | |
3817 SimulateWheelEventWithPhase( | |
3818 -15, -1, 0, true, | |
3819 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | |
3820 SimulateWheelEventWithPhase( | |
3821 -30, -3, 0, true, | |
3822 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | |
3823 SimulateWheelEventWithPhase( | |
3824 -20, 6, 1, true, | |
3825 WebMouseWheelEvent::kPhaseChanged); // enqueued, different modifiers | |
3826 } | |
3576 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3827 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3577 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 3828 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3578 | 3829 |
3579 // Receive ACK the first wheel event as not processed. | 3830 // Receive ACK the first wheel event as not processed. |
3580 SendInputEventACK(WebInputEvent::kMouseWheel, | 3831 SendInputEventACK(WebInputEvent::kMouseWheel, |
3581 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3832 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3582 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 3833 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); |
3583 | 3834 |
3584 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3835 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3585 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3836 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3632 WheelScrollEventOverscrolls(); | 3883 WheelScrollEventOverscrolls(); |
3633 } | 3884 } |
3634 | 3885 |
3635 // Tests that if some scroll events are consumed towards the start, then | 3886 // Tests that if some scroll events are consumed towards the start, then |
3636 // subsequent scrolls do not horizontal overscroll. | 3887 // subsequent scrolls do not horizontal overscroll. |
3637 void RenderWidgetHostViewAuraOverscrollTest:: | 3888 void RenderWidgetHostViewAuraOverscrollTest:: |
3638 WheelScrollConsumedDoNotHorizOverscroll() { | 3889 WheelScrollConsumedDoNotHorizOverscroll() { |
3639 SetUpOverscrollEnvironment(); | 3890 SetUpOverscrollEnvironment(); |
3640 | 3891 |
3641 // Simulate wheel events. | 3892 // Simulate wheel events. |
3642 SimulateWheelEvent(-5, 0, 0, true); // sent directly | 3893 if (!wheel_scroll_latching_enabled_) { |
3643 SimulateWheelEvent(-1, -1, 0, true); // enqueued | 3894 SimulateWheelEvent(-5, 0, 0, true); // sent directly |
3644 SimulateWheelEvent(-10, -3, 0, true); // coalesced into previous event | 3895 SimulateWheelEvent(-1, -1, 0, true); // enqueued |
3645 SimulateWheelEvent(-15, -1, 0, true); // coalesced into previous event | 3896 SimulateWheelEvent(-10, -3, 0, true); // coalesced into previous event |
3646 SimulateWheelEvent(-30, -3, 0, true); // coalesced into previous event | 3897 SimulateWheelEvent(-15, -1, 0, true); // coalesced into previous event |
3647 SimulateWheelEvent(-20, 6, 1, true); // enqueued, different modifiers | 3898 SimulateWheelEvent(-30, -3, 0, true); // coalesced into previous event |
3899 SimulateWheelEvent(-20, 6, 1, true); // enqueued, different modifiers | |
3900 } else { | |
3901 SimulateWheelEventWithPhase( | |
3902 -5, 0, 0, true, WebMouseWheelEvent::kPhaseBegan); // sent directly | |
3903 SimulateWheelEventWithPhase(-1, -1, 0, true, | |
3904 WebMouseWheelEvent::kPhaseChanged); // enqueued | |
3905 SimulateWheelEventWithPhase( | |
3906 -10, -3, 0, true, | |
3907 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | |
3908 SimulateWheelEventWithPhase( | |
3909 -15, -1, 0, true, | |
3910 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | |
3911 SimulateWheelEventWithPhase( | |
3912 -30, -3, 0, true, | |
3913 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | |
3914 SimulateWheelEventWithPhase( | |
3915 -20, 6, 1, true, | |
3916 WebMouseWheelEvent::kPhaseChanged); // enqueued, different modifiers | |
3917 } | |
3648 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3918 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3649 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 3919 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3650 | 3920 |
3651 // Receive ACK the first wheel event as processed. | 3921 // Receive ACK the first wheel event as processed. |
3652 SendInputEventACK(WebInputEvent::kMouseWheel, | 3922 SendInputEventACK(WebInputEvent::kMouseWheel, |
3653 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3923 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3654 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 3924 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); |
3655 | 3925 |
3656 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3926 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3657 INPUT_EVENT_ACK_STATE_CONSUMED); | 3927 INPUT_EVENT_ACK_STATE_CONSUMED); |
(...skipping 14 matching lines...) Expand all Loading... | |
3672 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3942 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3673 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3943 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3674 ExpectGestureScrollEndForWheelScrolling(false); | 3944 ExpectGestureScrollEndForWheelScrolling(false); |
3675 | 3945 |
3676 SendInputEventACK(WebInputEvent::kMouseWheel, | 3946 SendInputEventACK(WebInputEvent::kMouseWheel, |
3677 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3947 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3678 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 3948 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3679 | 3949 |
3680 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3950 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3681 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3951 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3952 if (wheel_scroll_latching_enabled_) { | |
3953 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); | |
3954 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | |
3955 SendInputEventACK(WebInputEvent::kMouseWheel, | |
3956 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
3957 } | |
3958 | |
3682 ExpectGestureScrollEndForWheelScrolling(true); | 3959 ExpectGestureScrollEndForWheelScrolling(true); |
3683 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3960 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3684 } | 3961 } |
3685 TEST_F(RenderWidgetHostViewAuraOverscrollTest, | 3962 TEST_F(RenderWidgetHostViewAuraOverscrollTest, |
3686 WheelScrollConsumedDoNotHorizOverscroll) { | 3963 WheelScrollConsumedDoNotHorizOverscroll) { |
3687 WheelScrollConsumedDoNotHorizOverscroll(); | 3964 WheelScrollConsumedDoNotHorizOverscroll(); |
3688 } | 3965 } |
3689 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 3966 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
3690 WheelScrollConsumedDoNotHorizOverscroll) { | 3967 WheelScrollConsumedDoNotHorizOverscroll) { |
3691 WheelScrollConsumedDoNotHorizOverscroll(); | 3968 WheelScrollConsumedDoNotHorizOverscroll(); |
3692 } | 3969 } |
3693 | 3970 |
3694 // Tests that wheel-scrolling correctly turns overscroll on and off. | 3971 // Tests that wheel-scrolling correctly turns overscroll on and off. |
3695 void RenderWidgetHostViewAuraOverscrollTest::WheelScrollOverscrollToggle() { | 3972 void RenderWidgetHostViewAuraOverscrollTest::WheelScrollOverscrollToggle() { |
3696 SetUpOverscrollEnvironment(); | 3973 SetUpOverscrollEnvironment(); |
3697 | 3974 |
3698 // Send a wheel event. ACK the event as not processed. This should not | 3975 // Send a wheel event. ACK the event as not processed. This should not |
3699 // initiate an overscroll gesture since it doesn't cross the threshold yet. | 3976 // initiate an overscroll gesture since it doesn't cross the threshold yet. |
3700 SimulateWheelEvent(10, 0, 0, true); | 3977 if (!wheel_scroll_latching_enabled_) { |
3978 SimulateWheelEvent(10, 0, 0, true); | |
3979 } else { | |
3980 SimulateWheelEventWithPhase(10, 0, 0, true, | |
3981 WebMouseWheelEvent::kPhaseBegan); | |
3982 } | |
3701 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 3983 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3702 SendInputEventACK(WebInputEvent::kMouseWheel, | 3984 SendInputEventACK(WebInputEvent::kMouseWheel, |
3703 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3985 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3704 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); | 3986 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); |
3705 | 3987 |
3706 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3988 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3707 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3989 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3708 ExpectGestureScrollEndForWheelScrolling(false); | 3990 ExpectGestureScrollEndForWheelScrolling(false); |
3709 | 3991 |
3710 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3992 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3711 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 3993 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3712 | 3994 |
3713 // Scroll some more so as to not overscroll. | 3995 // Scroll some more so as to not overscroll. |
3714 SimulateWheelEvent(10, 0, 0, true); | 3996 if (!wheel_scroll_latching_enabled_) { |
3997 SimulateWheelEvent(10, 0, 0, true); | |
3998 } else { | |
3999 SimulateWheelEventWithPhase(10, 0, 0, true, | |
4000 WebMouseWheelEvent::kPhaseChanged); | |
4001 } | |
3715 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4002 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3716 SendInputEventACK(WebInputEvent::kMouseWheel, | 4003 SendInputEventACK(WebInputEvent::kMouseWheel, |
3717 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4004 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3718 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4005 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3719 | 4006 |
3720 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4007 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3721 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4008 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3722 ExpectGestureScrollEndForWheelScrolling(false); | 4009 ExpectGestureScrollEndForWheelScrolling(false); |
3723 | 4010 |
3724 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4011 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3725 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4012 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3726 | 4013 |
3727 // Scroll some more to initiate an overscroll. | 4014 // Scroll some more to initiate an overscroll. |
3728 SimulateWheelEvent(40, 0, 0, true); | 4015 if (!wheel_scroll_latching_enabled_) { |
4016 SimulateWheelEvent(40, 0, 0, true); | |
4017 } else { | |
4018 SimulateWheelEventWithPhase(40, 0, 0, true, | |
4019 WebMouseWheelEvent::kPhaseChanged); | |
4020 } | |
3729 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4021 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3730 SendInputEventACK(WebInputEvent::kMouseWheel, | 4022 SendInputEventACK(WebInputEvent::kMouseWheel, |
3731 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4023 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3732 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4024 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3733 | 4025 |
3734 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4026 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3735 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4027 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3736 ExpectGestureScrollEndForWheelScrolling(false); | 4028 ExpectGestureScrollEndForWheelScrolling(false); |
3737 | 4029 |
3738 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); | 4030 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); |
3739 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); | 4031 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); |
3740 EXPECT_EQ(60.f, overscroll_delta_x()); | 4032 EXPECT_EQ(60.f, overscroll_delta_x()); |
3741 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); | 4033 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); |
3742 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); | 4034 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); |
3743 | 4035 |
3744 // Scroll in the reverse direction enough to abort the overscroll. | 4036 // Scroll in the reverse direction enough to abort the overscroll. |
3745 SimulateWheelEvent(-20, 0, 0, true); | 4037 if (!wheel_scroll_latching_enabled_) { |
4038 SimulateWheelEvent(-20, 0, 0, true); | |
4039 } else { | |
4040 SimulateWheelEventWithPhase(-20, 0, 0, true, | |
4041 WebMouseWheelEvent::kPhaseChanged); | |
4042 } | |
3746 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4043 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3747 SendInputEventACK(WebInputEvent::kMouseWheel, | 4044 SendInputEventACK(WebInputEvent::kMouseWheel, |
3748 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4045 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3749 if (wheel_scroll_latching_enabled_) { | 4046 if (wheel_scroll_latching_enabled_) { |
3750 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); | 4047 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); |
3751 } else { | 4048 } else { |
3752 // ScrollBegin and ScrollEnd will be queued events. | 4049 // ScrollBegin and ScrollEnd will be queued events. |
3753 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); | 4050 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); |
3754 } | 4051 } |
3755 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4052 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3756 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4053 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3757 | 4054 |
3758 // Continue to scroll in the reverse direction. | 4055 // Continue to scroll in the reverse direction. |
3759 SimulateWheelEvent(-20, 0, 0, true); | 4056 if (!wheel_scroll_latching_enabled_) { |
4057 SimulateWheelEvent(-20, 0, 0, true); | |
4058 } else { | |
4059 SimulateWheelEventWithPhase(-20, 0, 0, true, | |
4060 WebMouseWheelEvent::kPhaseChanged); | |
4061 } | |
3760 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4062 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3761 SendInputEventACK(WebInputEvent::kMouseWheel, | 4063 SendInputEventACK(WebInputEvent::kMouseWheel, |
3762 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4064 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3763 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4065 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3764 | 4066 |
3765 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4067 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3766 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4068 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3767 ExpectGestureScrollEndForWheelScrolling(false); | 4069 ExpectGestureScrollEndForWheelScrolling(false); |
3768 | 4070 |
3769 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4071 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3770 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4072 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3771 | 4073 |
3772 // Continue to scroll in the reverse direction enough to initiate overscroll | 4074 // Continue to scroll in the reverse direction enough to initiate overscroll |
3773 // in that direction. | 4075 // in that direction. |
3774 SimulateWheelEvent(-55, 0, 0, true); | 4076 if (!wheel_scroll_latching_enabled_) { |
4077 SimulateWheelEvent(-55, 0, 0, true); | |
4078 } else { | |
4079 SimulateWheelEventWithPhase(-55, 0, 0, true, | |
4080 WebMouseWheelEvent::kPhaseChanged); | |
4081 } | |
3775 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4082 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3776 SendInputEventACK(WebInputEvent::kMouseWheel, | 4083 SendInputEventACK(WebInputEvent::kMouseWheel, |
3777 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4084 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3778 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4085 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3779 | 4086 |
3780 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4087 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3781 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4088 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4089 if (wheel_scroll_latching_enabled_) { | |
4090 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); | |
4091 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | |
4092 SendInputEventACK(WebInputEvent::kMouseWheel, | |
4093 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4094 } | |
3782 ExpectGestureScrollEndForWheelScrolling(true); | 4095 ExpectGestureScrollEndForWheelScrolling(true); |
3783 | 4096 |
3784 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); | 4097 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); |
3785 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); | 4098 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); |
3786 EXPECT_EQ(-75.f, overscroll_delta_x()); | 4099 EXPECT_EQ(-75.f, overscroll_delta_x()); |
3787 EXPECT_EQ(-25.f, overscroll_delegate()->delta_x()); | 4100 EXPECT_EQ(-25.f, overscroll_delegate()->delta_x()); |
3788 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); | 4101 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); |
3789 } | 4102 } |
3790 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelScrollOverscrollToggle) { | 4103 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelScrollOverscrollToggle) { |
3791 WheelScrollOverscrollToggle(); | 4104 WheelScrollOverscrollToggle(); |
3792 } | 4105 } |
3793 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 4106 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
3794 WheelScrollOverscrollToggle) { | 4107 WheelScrollOverscrollToggle) { |
3795 WheelScrollOverscrollToggle(); | 4108 WheelScrollOverscrollToggle(); |
3796 } | 4109 } |
3797 | 4110 |
3798 void RenderWidgetHostViewAuraOverscrollTest::ScrollEventsOverscrollWithFling() { | 4111 void RenderWidgetHostViewAuraOverscrollTest::ScrollEventsOverscrollWithFling() { |
3799 SetUpOverscrollEnvironment(); | 4112 SetUpOverscrollEnvironment(); |
3800 | 4113 |
3801 // Send a wheel event. ACK the event as not processed. This should not | 4114 // Send a wheel event. ACK the event as not processed. This should not |
3802 // initiate an overscroll gesture since it doesn't cross the threshold yet. | 4115 // initiate an overscroll gesture since it doesn't cross the threshold yet. |
3803 SimulateWheelEvent(10, 0, 0, true); | 4116 if (!wheel_scroll_latching_enabled_) { |
4117 SimulateWheelEvent(10, 0, 0, true); | |
4118 } else { | |
4119 SimulateWheelEventWithPhase(10, 0, 0, true, | |
4120 WebMouseWheelEvent::kPhaseBegan); | |
4121 } | |
3804 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4122 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3805 SendInputEventACK(WebInputEvent::kMouseWheel, | 4123 SendInputEventACK(WebInputEvent::kMouseWheel, |
3806 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4124 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3807 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); | 4125 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); |
3808 | 4126 |
3809 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4127 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3810 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4128 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3811 ExpectGestureScrollEndForWheelScrolling(false); | 4129 ExpectGestureScrollEndForWheelScrolling(false); |
3812 | 4130 |
3813 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4131 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3814 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4132 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3815 | 4133 |
3816 // Scroll some more so as to not overscroll. | 4134 // Scroll some more so as to not overscroll. |
3817 SimulateWheelEvent(20, 0, 0, true); | 4135 if (!wheel_scroll_latching_enabled_) { |
4136 SimulateWheelEvent(20, 0, 0, true); | |
4137 } else { | |
4138 SimulateWheelEventWithPhase(20, 0, 0, true, | |
4139 WebMouseWheelEvent::kPhaseChanged); | |
4140 } | |
3818 EXPECT_EQ(1U, sink_->message_count()); | 4141 EXPECT_EQ(1U, sink_->message_count()); |
3819 SendInputEventACK(WebInputEvent::kMouseWheel, | 4142 SendInputEventACK(WebInputEvent::kMouseWheel, |
3820 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4143 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3821 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4144 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3822 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4145 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3823 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4146 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3824 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4147 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3825 sink_->ClearMessages(); | 4148 sink_->ClearMessages(); |
3826 | 4149 |
3827 // Scroll some more to initiate an overscroll. | 4150 // Scroll some more to initiate an overscroll. |
3828 SimulateWheelEvent(30, 0, 0, true); | 4151 if (!wheel_scroll_latching_enabled_) { |
4152 SimulateWheelEvent(30, 0, 0, true); | |
4153 } else { | |
4154 SimulateWheelEventWithPhase(30, 0, 0, true, | |
4155 WebMouseWheelEvent::kPhaseChanged); | |
4156 } | |
3829 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4157 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3830 SendInputEventACK(WebInputEvent::kMouseWheel, | 4158 SendInputEventACK(WebInputEvent::kMouseWheel, |
3831 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4159 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3832 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4160 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3833 | 4161 |
3834 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4162 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3835 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4163 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3836 ExpectGestureScrollEndForWheelScrolling(false); | 4164 ExpectGestureScrollEndForWheelScrolling(false); |
3837 | 4165 |
3838 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); | 4166 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); |
3839 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); | 4167 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); |
3840 | 4168 |
3841 EXPECT_EQ(60.f, overscroll_delta_x()); | 4169 EXPECT_EQ(60.f, overscroll_delta_x()); |
3842 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); | 4170 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); |
3843 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); | 4171 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); |
3844 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); | 4172 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); |
3845 | 4173 |
3846 // Send a fling start, but with a small velocity, so that the overscroll is | 4174 // Send a fling start, but with a small velocity, so that the overscroll is |
3847 // aborted. The fling should proceed to the renderer, through the gesture | 4175 // aborted. The fling should proceed to the renderer, through the gesture |
3848 // event filter. | 4176 // event filter. |
3849 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, | 4177 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, |
3850 blink::kWebGestureDeviceTouchscreen); | 4178 blink::kWebGestureDeviceTouchscreen); |
3851 SimulateGestureFlingStartEvent(0.f, 0.1f, blink::kWebGestureDeviceTouchpad); | 4179 SimulateGestureFlingStartEvent(0.f, 0.1f, blink::kWebGestureDeviceTouchpad); |
3852 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4180 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3853 | 4181 |
3854 if (!wheel_scroll_latching_enabled_) { | 4182 // ScrollBegin and FlingStart will be queued events. |
3855 // ScrollBegin and FlingStart will be queued events. | 4183 EXPECT_EQ(2U, sink_->message_count()); |
3856 EXPECT_EQ(2U, sink_->message_count()); | |
3857 } else { | |
3858 // ScrollEnd, ScrollBegin, and FlingStart will be queued events. | |
3859 EXPECT_EQ(3U, sink_->message_count()); | |
3860 } | |
3861 } | 4184 } |
3862 TEST_F(RenderWidgetHostViewAuraOverscrollTest, | 4185 TEST_F(RenderWidgetHostViewAuraOverscrollTest, |
3863 ScrollEventsOverscrollWithFling) { | 4186 ScrollEventsOverscrollWithFling) { |
3864 ScrollEventsOverscrollWithFling(); | 4187 ScrollEventsOverscrollWithFling(); |
3865 } | 4188 } |
3866 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 4189 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
3867 ScrollEventsOverscrollWithFling) { | 4190 ScrollEventsOverscrollWithFling) { |
3868 ScrollEventsOverscrollWithFling(); | 4191 ScrollEventsOverscrollWithFling(); |
3869 } | 4192 } |
3870 | 4193 |
3871 // Same as ScrollEventsOverscrollWithFling, but with zero velocity. Checks that | 4194 // Same as ScrollEventsOverscrollWithFling, but with zero velocity. Checks that |
3872 // the zero-velocity fling does not reach the renderer. | 4195 // the zero-velocity fling does not reach the renderer. |
3873 void RenderWidgetHostViewAuraOverscrollTest:: | 4196 void RenderWidgetHostViewAuraOverscrollTest:: |
3874 ScrollEventsOverscrollWithZeroFling() { | 4197 ScrollEventsOverscrollWithZeroFling() { |
3875 SetUpOverscrollEnvironment(); | 4198 SetUpOverscrollEnvironment(); |
3876 | 4199 |
3877 // Send a wheel event. ACK the event as not processed. This should not | 4200 // Send a wheel event. ACK the event as not processed. This should not |
3878 // initiate an overscroll gesture since it doesn't cross the threshold yet. | 4201 // initiate an overscroll gesture since it doesn't cross the threshold yet. |
3879 SimulateWheelEvent(10, 0, 0, true); | 4202 if (!wheel_scroll_latching_enabled_) { |
4203 SimulateWheelEvent(10, 0, 0, true); | |
4204 } else { | |
4205 SimulateWheelEventWithPhase(10, 0, 0, true, | |
4206 WebMouseWheelEvent::kPhaseBegan); | |
4207 } | |
3880 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4208 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3881 SendInputEventACK(WebInputEvent::kMouseWheel, | 4209 SendInputEventACK(WebInputEvent::kMouseWheel, |
3882 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4210 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3883 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); | 4211 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); |
3884 | 4212 |
3885 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4213 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3886 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4214 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3887 ExpectGestureScrollEndForWheelScrolling(false); | 4215 ExpectGestureScrollEndForWheelScrolling(false); |
3888 | 4216 |
3889 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4217 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3890 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4218 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3891 | 4219 |
3892 // Scroll some more so as to not overscroll. | 4220 // Scroll some more so as to not overscroll. |
3893 SimulateWheelEvent(20, 0, 0, true); | 4221 if (!wheel_scroll_latching_enabled_) { |
4222 SimulateWheelEvent(20, 0, 0, true); | |
4223 } else { | |
4224 SimulateWheelEventWithPhase(20, 0, 0, true, | |
4225 WebMouseWheelEvent::kPhaseChanged); | |
4226 } | |
3894 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4227 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3895 SendInputEventACK(WebInputEvent::kMouseWheel, | 4228 SendInputEventACK(WebInputEvent::kMouseWheel, |
3896 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4229 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3897 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4230 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3898 | 4231 |
3899 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4232 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3900 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4233 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3901 ExpectGestureScrollEndForWheelScrolling(false); | 4234 ExpectGestureScrollEndForWheelScrolling(false); |
3902 | 4235 |
3903 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4236 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3904 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4237 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3905 | 4238 |
3906 // Scroll some more to initiate an overscroll. | 4239 // Scroll some more to initiate an overscroll. |
3907 SimulateWheelEvent(30, 0, 0, true); | 4240 if (!wheel_scroll_latching_enabled_) { |
4241 SimulateWheelEvent(30, 0, 0, true); | |
4242 } else { | |
4243 SimulateWheelEventWithPhase(30, 0, 0, true, | |
4244 WebMouseWheelEvent::kPhaseChanged); | |
4245 } | |
3908 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4246 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3909 SendInputEventACK(WebInputEvent::kMouseWheel, | 4247 SendInputEventACK(WebInputEvent::kMouseWheel, |
3910 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4248 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3911 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4249 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3912 | 4250 |
3913 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4251 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3914 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4252 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3915 ExpectGestureScrollEndForWheelScrolling(false); | 4253 ExpectGestureScrollEndForWheelScrolling(false); |
3916 | 4254 |
3917 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); | 4255 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); |
3918 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); | 4256 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); |
3919 | 4257 |
3920 EXPECT_EQ(60.f, overscroll_delta_x()); | 4258 EXPECT_EQ(60.f, overscroll_delta_x()); |
3921 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); | 4259 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); |
3922 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); | 4260 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); |
3923 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); | 4261 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); |
3924 | 4262 |
3925 // Send a fling start, but with a small velocity, so that the overscroll is | 4263 // Send a fling start, but with a small velocity, so that the overscroll is |
3926 // aborted. The fling should proceed to the renderer, through the gesture | 4264 // aborted. The fling should proceed to the renderer, through the gesture |
3927 // event filter. | 4265 // event filter. |
3928 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, | 4266 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, |
3929 blink::kWebGestureDeviceTouchscreen); | 4267 blink::kWebGestureDeviceTouchscreen); |
3930 SimulateGestureFlingStartEvent(10.f, 0.f, blink::kWebGestureDeviceTouchpad); | 4268 SimulateGestureFlingStartEvent(10.f, 0.f, blink::kWebGestureDeviceTouchpad); |
3931 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4269 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3932 | 4270 |
3933 if (!wheel_scroll_latching_enabled_) { | |
3934 // ScrollBegin and FlingStart will be queued events. | 4271 // ScrollBegin and FlingStart will be queued events. |
3935 EXPECT_EQ(2U, sink_->message_count()); | 4272 EXPECT_EQ(2U, sink_->message_count()); |
3936 } else { | |
3937 // ScrollEnd, ScrollBegin, and FlingStart will be queued events. | |
3938 EXPECT_EQ(3U, sink_->message_count()); | |
3939 } | |
3940 } | 4273 } |
3941 TEST_F(RenderWidgetHostViewAuraOverscrollTest, | 4274 TEST_F(RenderWidgetHostViewAuraOverscrollTest, |
3942 ScrollEventsOverscrollWithZeroFling) { | 4275 ScrollEventsOverscrollWithZeroFling) { |
3943 ScrollEventsOverscrollWithZeroFling(); | 4276 ScrollEventsOverscrollWithZeroFling(); |
3944 } | 4277 } |
3945 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 4278 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
3946 ScrollEventsOverscrollWithZeroFling) { | 4279 ScrollEventsOverscrollWithZeroFling) { |
3947 ScrollEventsOverscrollWithZeroFling(); | 4280 ScrollEventsOverscrollWithZeroFling(); |
3948 } | 4281 } |
3949 | 4282 |
(...skipping 440 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4390 SimulateGestureScrollUpdateEvent(-20, 0, 0); | 4723 SimulateGestureScrollUpdateEvent(-20, 0, 0); |
4391 EXPECT_EQ(1U, sink_->message_count()); | 4724 EXPECT_EQ(1U, sink_->message_count()); |
4392 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4725 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4393 } | 4726 } |
4394 | 4727 |
4395 void RenderWidgetHostViewAuraOverscrollTest:: | 4728 void RenderWidgetHostViewAuraOverscrollTest:: |
4396 OverscrollDirectionChangeMouseWheel() { | 4729 OverscrollDirectionChangeMouseWheel() { |
4397 SetUpOverscrollEnvironment(); | 4730 SetUpOverscrollEnvironment(); |
4398 | 4731 |
4399 // Send wheel event and receive ack as not consumed. | 4732 // Send wheel event and receive ack as not consumed. |
4400 SimulateWheelEvent(125, -5, 0, true); | 4733 if (!wheel_scroll_latching_enabled_) { |
4734 SimulateWheelEvent(125, -5, 0, true); | |
4735 } else { | |
4736 SimulateWheelEventWithPhase(125, -5, 0, true, | |
4737 WebMouseWheelEvent::kPhaseBegan); | |
4738 } | |
4401 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4739 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4402 SendInputEventACK(WebInputEvent::kMouseWheel, | 4740 SendInputEventACK(WebInputEvent::kMouseWheel, |
4403 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4741 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4404 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); | 4742 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); |
4405 | 4743 |
4406 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4744 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4407 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4745 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4408 ExpectGestureScrollEndForWheelScrolling(false); | 4746 ExpectGestureScrollEndForWheelScrolling(false); |
4409 | 4747 |
4410 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); | 4748 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); |
4411 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); | 4749 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); |
4412 | 4750 |
4413 // Send another wheel event, but in the reverse direction. The overscroll | 4751 // Send another wheel event, but in the reverse direction. The overscroll |
4414 // controller will not consume the event, because it is not triggering | 4752 // controller will not consume the event, because it is not triggering |
4415 // gesture-nav. | 4753 // gesture-nav. |
4416 | 4754 |
4417 SimulateWheelEvent(-260, 0, 0, true); | 4755 if (!wheel_scroll_latching_enabled_) { |
4756 SimulateWheelEvent(-260, 0, 0, true); | |
4757 } else { | |
4758 SimulateWheelEventWithPhase(-260, 0, 0, true, | |
4759 WebMouseWheelEvent::kPhaseChanged); | |
4760 } | |
4418 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4761 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4419 SendInputEventACK(WebInputEvent::kMouseWheel, | 4762 SendInputEventACK(WebInputEvent::kMouseWheel, |
4420 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4763 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4421 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4764 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
4422 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4765 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4423 | 4766 |
4424 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4767 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4425 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4768 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4426 ExpectGestureScrollEndForWheelScrolling(false); | 4769 ExpectGestureScrollEndForWheelScrolling(false); |
4427 | 4770 |
4428 // Since it was unhandled; the overscroll should now be west | 4771 // Since it was unhandled; the overscroll should now be west |
4429 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); | 4772 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); |
4430 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); | 4773 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); |
4431 | 4774 |
4432 SimulateWheelEvent(-20, 0, 0, true); | 4775 if (!wheel_scroll_latching_enabled_) { |
4776 SimulateWheelEvent(-20, 0, 0, true); | |
4777 } else { | |
4778 SimulateWheelEventWithPhase(-20, 0, 0, true, | |
4779 WebMouseWheelEvent::kPhaseChanged); | |
tdresser
2017/05/19 16:17:33
Is it worth using the same trick here of adding a
sahel
2017/05/19 17:39:16
Done.
| |
4780 } | |
4433 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4781 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4434 SendInputEventACK(WebInputEvent::kMouseWheel, | 4782 SendInputEventACK(WebInputEvent::kMouseWheel, |
4435 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4783 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4436 | 4784 |
4437 // wheel event ack generates gesture scroll update; which gets consumed | 4785 // wheel event ack generates gesture scroll update; which gets consumed |
4438 // solely by the overflow controller. | 4786 // solely by the overflow controller. |
4439 if (!wheel_scroll_latching_enabled_) { | 4787 if (!wheel_scroll_latching_enabled_) { |
4440 // No ScrollUpdates, only ScrollBegin and ScrollEnd will be queued events. | 4788 // No ScrollUpdates, only ScrollBegin and ScrollEnd will be queued events. |
4441 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); | 4789 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); |
4442 } else { | 4790 } else { |
4443 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); | 4791 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); |
4444 } | 4792 } |
4445 | 4793 |
4446 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); | 4794 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); |
4447 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); | 4795 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); |
4448 } | 4796 } |
4449 TEST_F(RenderWidgetHostViewAuraOverscrollTest, | 4797 TEST_F(RenderWidgetHostViewAuraOverscrollTest, |
4450 OverscrollDirectionChangeMouseWheel) { | 4798 OverscrollDirectionChangeMouseWheel) { |
4451 OverscrollDirectionChangeMouseWheel(); | 4799 OverscrollDirectionChangeMouseWheel(); |
4452 } | 4800 } |
4453 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 4801 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
4454 OverscrollDirectionChangeMouseWheel) { | 4802 OverscrollDirectionChangeMouseWheel) { |
4455 OverscrollDirectionChangeMouseWheel(); | 4803 OverscrollDirectionChangeMouseWheel(); |
4456 } | 4804 } |
4457 | 4805 |
4458 void RenderWidgetHostViewAuraOverscrollTest::OverscrollMouseMoveCompletion() { | 4806 void RenderWidgetHostViewAuraOverscrollTest::OverscrollMouseMoveCompletion() { |
4459 SetUpOverscrollEnvironment(); | 4807 SetUpOverscrollEnvironment(); |
4460 | 4808 |
4461 SimulateWheelEvent(5, 0, 0, true); // sent directly | 4809 if (!wheel_scroll_latching_enabled_) { |
4462 SimulateWheelEvent(-1, 0, 0, true); // enqueued | 4810 SimulateWheelEvent(5, 0, 0, true); // sent directly |
4463 SimulateWheelEvent(-10, -3, 0, true); // coalesced into previous event | 4811 SimulateWheelEvent(-1, 0, 0, true); // enqueued |
4464 SimulateWheelEvent(-15, -1, 0, true); // coalesced into previous event | 4812 SimulateWheelEvent(-10, -3, 0, true); // coalesced into previous event |
4465 SimulateWheelEvent(-30, -3, 0, true); // coalesced into previous event | 4813 SimulateWheelEvent(-15, -1, 0, true); // coalesced into previous event |
4814 SimulateWheelEvent(-30, -3, 0, true); // coalesced into previous event | |
4815 } else { | |
4816 SimulateWheelEventWithPhase( | |
4817 5, 0, 0, true, WebMouseWheelEvent::kPhaseBegan); // sent directly | |
4818 SimulateWheelEventWithPhase(-1, 0, 0, true, | |
4819 WebMouseWheelEvent::kPhaseChanged); // enqueued | |
4820 SimulateWheelEventWithPhase( | |
4821 -10, -3, 0, true, | |
4822 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | |
4823 SimulateWheelEventWithPhase( | |
4824 -15, -1, 0, true, | |
4825 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | |
4826 SimulateWheelEventWithPhase( | |
4827 -30, -3, 0, true, | |
4828 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | |
4829 } | |
4466 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4830 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4467 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4831 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4468 | 4832 |
4469 // Receive ACK the first wheel event as not processed. | 4833 // Receive ACK the first wheel event as not processed. |
4470 SendInputEventACK(WebInputEvent::kMouseWheel, | 4834 SendInputEventACK(WebInputEvent::kMouseWheel, |
4471 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4835 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4472 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 4836 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); |
4473 | 4837 |
4474 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4838 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4475 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4839 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4549 OverscrollMouseMoveCompletion) { | 4913 OverscrollMouseMoveCompletion) { |
4550 OverscrollMouseMoveCompletion(); | 4914 OverscrollMouseMoveCompletion(); |
4551 } | 4915 } |
4552 | 4916 |
4553 // Tests that if a page scrolled, then the overscroll controller's states are | 4917 // Tests that if a page scrolled, then the overscroll controller's states are |
4554 // reset after the end of the scroll. | 4918 // reset after the end of the scroll. |
4555 void RenderWidgetHostViewAuraOverscrollTest:: | 4919 void RenderWidgetHostViewAuraOverscrollTest:: |
4556 OverscrollStateResetsAfterScroll() { | 4920 OverscrollStateResetsAfterScroll() { |
4557 SetUpOverscrollEnvironment(); | 4921 SetUpOverscrollEnvironment(); |
4558 | 4922 |
4559 SimulateWheelEvent(0, 5, 0, true); // sent directly | 4923 if (!wheel_scroll_latching_enabled_) { |
4560 SimulateWheelEvent(0, 30, 0, true); // enqueued | 4924 SimulateWheelEvent(0, 5, 0, true); // sent directly |
4561 SimulateWheelEvent(0, 40, 0, true); // coalesced into previous event | 4925 SimulateWheelEvent(0, 30, 0, true); // enqueued |
4562 SimulateWheelEvent(0, 10, 0, true); // coalesced into previous event | 4926 SimulateWheelEvent(0, 40, 0, true); // coalesced into previous event |
4927 SimulateWheelEvent(0, 10, 0, true); // coalesced into previous event | |
4928 } else { | |
4929 SimulateWheelEventWithPhase( | |
4930 0, 5, 0, true, WebMouseWheelEvent::kPhaseBegan); // sent directly | |
4931 SimulateWheelEventWithPhase(0, 30, 0, true, | |
4932 WebMouseWheelEvent::kPhaseChanged); // enqueued | |
4933 SimulateWheelEventWithPhase( | |
4934 0, 40, 0, true, | |
4935 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | |
4936 SimulateWheelEventWithPhase( | |
4937 0, 10, 0, true, | |
4938 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | |
4939 } | |
4563 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4940 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4564 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4941 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4565 | 4942 |
4566 // The first wheel event is consumed. Dispatches the queued wheel event. | 4943 // The first wheel event is consumed. Dispatches the queued wheel event. |
4567 SendInputEventACK(WebInputEvent::kMouseWheel, | 4944 SendInputEventACK(WebInputEvent::kMouseWheel, |
4568 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4945 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4569 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 4946 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); |
4570 | 4947 |
4571 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4948 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4572 INPUT_EVENT_ACK_STATE_CONSUMED); | 4949 INPUT_EVENT_ACK_STATE_CONSUMED); |
4573 ExpectGestureScrollEndForWheelScrolling(false); | 4950 ExpectGestureScrollEndForWheelScrolling(false); |
4574 EXPECT_TRUE(ScrollStateIsContentScrolling()); | 4951 EXPECT_TRUE(ScrollStateIsContentScrolling()); |
4575 | 4952 |
4576 // The second wheel event is consumed. | 4953 // The second wheel event is consumed. |
4577 SendInputEventACK(WebInputEvent::kMouseWheel, | 4954 SendInputEventACK(WebInputEvent::kMouseWheel, |
4578 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4955 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4579 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4956 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
4580 | 4957 |
4581 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4958 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4582 INPUT_EVENT_ACK_STATE_CONSUMED); | 4959 INPUT_EVENT_ACK_STATE_CONSUMED); |
4960 | |
4961 if (wheel_scroll_latching_enabled_) { | |
4962 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); | |
4963 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | |
4964 SendInputEventACK(WebInputEvent::kMouseWheel, | |
4965 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4966 } | |
4583 ExpectGestureScrollEndForWheelScrolling(true); | 4967 ExpectGestureScrollEndForWheelScrolling(true); |
4584 EXPECT_TRUE(ScrollStateIsContentScrolling()); | 4968 EXPECT_TRUE(ScrollStateIsContentScrolling()); |
4585 | 4969 |
4586 // Touchpad scroll can end with a zero-velocity fling. But it is not | 4970 // Touchpad scroll can end with a zero-velocity fling. But it is not |
4587 // dispatched, but it should still reset the overscroll controller state. | 4971 // dispatched, but it should still reset the overscroll controller state. |
4588 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, | 4972 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, |
4589 blink::kWebGestureDeviceTouchscreen); | 4973 blink::kWebGestureDeviceTouchscreen); |
4590 SimulateGestureFlingStartEvent(0.f, 0.f, blink::kWebGestureDeviceTouchpad); | 4974 SimulateGestureFlingStartEvent(0.f, 0.f, blink::kWebGestureDeviceTouchpad); |
4591 EXPECT_TRUE(ScrollStateIsUnknown()); | 4975 EXPECT_TRUE(ScrollStateIsUnknown()); |
4592 // ScrollBegin will be queued events. | 4976 // ScrollBegin will be queued events. |
4593 EXPECT_EQ(1U, sink_->message_count()); | 4977 EXPECT_EQ(1U, sink_->message_count()); |
4594 | 4978 |
4595 // Dropped flings should neither propagate *nor* indicate that they were | 4979 // Dropped flings should neither propagate *nor* indicate that they were |
4596 // consumed and have triggered a fling animation (as tracked by the router). | 4980 // consumed and have triggered a fling animation (as tracked by the router). |
4597 EXPECT_FALSE(parent_host_->input_router()->HasPendingEvents()); | 4981 EXPECT_FALSE(parent_host_->input_router()->HasPendingEvents()); |
4598 | 4982 |
4599 SimulateGestureEvent(WebInputEvent::kGestureScrollEnd, | 4983 SimulateGestureEvent(WebInputEvent::kGestureScrollEnd, |
4600 blink::kWebGestureDeviceTouchscreen); | 4984 blink::kWebGestureDeviceTouchscreen); |
4601 // ScrollBegin, and ScrollEnd will be queued events. | 4985 // ScrollBegin, and ScrollEnd will be queued events. |
4602 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); | 4986 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); |
4603 | 4987 |
4604 SimulateWheelEvent(-5, 0, 0, true); // sent directly | 4988 if (!wheel_scroll_latching_enabled_) { |
4605 SimulateWheelEvent(-60, 0, 0, true); // enqueued | 4989 SimulateWheelEvent(-5, 0, 0, true); // sent directly |
4606 SimulateWheelEvent(-100, 0, 0, true); // coalesced into previous event | 4990 SimulateWheelEvent(-60, 0, 0, true); // enqueued |
4991 SimulateWheelEvent(-100, 0, 0, true); // coalesced into previous event | |
4992 } else { | |
4993 SimulateWheelEventWithPhase( | |
4994 -5, 0, 0, true, WebMouseWheelEvent::kPhaseBegan); // sent directly | |
4995 SimulateWheelEventWithPhase(-60, 0, 0, true, | |
4996 WebMouseWheelEvent::kPhaseChanged); // enqueued | |
4997 SimulateWheelEventWithPhase( | |
4998 -100, 0, 0, true, | |
4999 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | |
5000 } | |
4607 EXPECT_TRUE(ScrollStateIsUnknown()); | 5001 EXPECT_TRUE(ScrollStateIsUnknown()); |
4608 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 5002 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4609 | 5003 |
4610 // The first wheel scroll did not scroll content. Overscroll should not start | 5004 // The first wheel scroll did not scroll content. Overscroll should not start |
4611 // yet, since enough hasn't been scrolled. | 5005 // yet, since enough hasn't been scrolled. |
4612 SendInputEventACK(WebInputEvent::kMouseWheel, | 5006 SendInputEventACK(WebInputEvent::kMouseWheel, |
4613 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5007 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4614 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 5008 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); |
4615 | 5009 |
4616 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 5010 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4617 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5011 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4618 ExpectGestureScrollEndForWheelScrolling(false); | 5012 ExpectGestureScrollEndForWheelScrolling(false); |
4619 EXPECT_TRUE(ScrollStateIsUnknown()); | 5013 EXPECT_TRUE(ScrollStateIsUnknown()); |
4620 | 5014 |
4621 SendInputEventACK(WebInputEvent::kMouseWheel, | 5015 SendInputEventACK(WebInputEvent::kMouseWheel, |
4622 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5016 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4623 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 5017 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
4624 | 5018 |
4625 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 5019 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4626 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5020 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
5021 | |
5022 if (wheel_scroll_latching_enabled_) { | |
5023 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); | |
5024 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | |
5025 SendInputEventACK(WebInputEvent::kMouseWheel, | |
5026 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
5027 } | |
5028 | |
4627 ExpectGestureScrollEndForWheelScrolling(true); | 5029 ExpectGestureScrollEndForWheelScrolling(true); |
4628 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); | 5030 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); |
4629 EXPECT_TRUE(ScrollStateIsOverscrolling()); | 5031 EXPECT_TRUE(ScrollStateIsOverscrolling()); |
4630 | 5032 |
4631 // The GestureScrollBegin will reset the delegate's mode, so check it here. | 5033 // The GestureScrollBegin will reset the delegate's mode, so check it here. |
4632 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); | 5034 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); |
4633 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, | 5035 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, |
4634 blink::kWebGestureDeviceTouchscreen); | 5036 blink::kWebGestureDeviceTouchscreen); |
4635 SimulateGestureFlingStartEvent(0.f, 0.f, blink::kWebGestureDeviceTouchpad); | 5037 SimulateGestureFlingStartEvent(0.f, 0.f, blink::kWebGestureDeviceTouchpad); |
4636 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 5038 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
(...skipping 910 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
5547 // There is no composition in the beginning. | 5949 // There is no composition in the beginning. |
5548 EXPECT_FALSE(has_composition_text()); | 5950 EXPECT_FALSE(has_composition_text()); |
5549 SetHasCompositionTextToTrue(); | 5951 SetHasCompositionTextToTrue(); |
5550 view->ImeCancelComposition(); | 5952 view->ImeCancelComposition(); |
5551 // The composition must have been canceled. | 5953 // The composition must have been canceled. |
5552 EXPECT_FALSE(has_composition_text()); | 5954 EXPECT_FALSE(has_composition_text()); |
5553 } | 5955 } |
5554 } | 5956 } |
5555 | 5957 |
5556 } // namespace content | 5958 } // namespace content |
OLD | NEW |