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 |
| 975 void SimulateWheelEventPossiblyIncludingPhase( |
| 976 bool ignore_phase, |
| 977 float dX, |
| 978 float dY, |
| 979 int modifiers, |
| 980 bool precise, |
| 981 WebMouseWheelEvent::Phase phase) { |
| 982 if (ignore_phase) { |
| 983 SimulateWheelEvent(dX, dY, modifiers, precise); |
| 984 } else { |
| 985 SimulateWheelEventWithPhase(dX, dY, modifiers, precise, phase); |
| 986 } |
| 987 } |
| 988 |
943 void SimulateWheelEventWithLatencyInfo(float dX, | 989 void SimulateWheelEventWithLatencyInfo(float dX, |
944 float dY, | 990 float dY, |
945 int modifiers, | 991 int modifiers, |
946 bool precise, | 992 bool precise, |
947 const ui::LatencyInfo& ui_latency) { | 993 const ui::LatencyInfo& ui_latency) { |
948 widget_host_->ForwardWheelEventWithLatencyInfo( | 994 widget_host_->ForwardWheelEventWithLatencyInfo( |
949 SyntheticWebMouseWheelEventBuilder::Build(0, 0, dX, dY, modifiers, | 995 SyntheticWebMouseWheelEventBuilder::Build(0, 0, dX, dY, modifiers, |
950 precise), | 996 precise), |
951 ui_latency); | 997 ui_latency); |
952 } | 998 } |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1070 void ReleaseTouchPoint(int index) { | 1116 void ReleaseTouchPoint(int index) { |
1071 touch_event_.ReleasePoint(index); | 1117 touch_event_.ReleasePoint(index); |
1072 } | 1118 } |
1073 | 1119 |
1074 void ExpectGestureScrollEndForWheelScrolling(bool is_last) { | 1120 void ExpectGestureScrollEndForWheelScrolling(bool is_last) { |
1075 if (wheel_scroll_latching_enabled_) { | 1121 if (wheel_scroll_latching_enabled_) { |
1076 if (!is_last) { | 1122 if (!is_last) { |
1077 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); | 1123 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); |
1078 return; | 1124 return; |
1079 } | 1125 } |
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 } | 1126 } |
1088 | 1127 |
1089 EXPECT_EQ(1U, sink_->message_count()); | 1128 EXPECT_EQ(1U, sink_->message_count()); |
1090 InputMsg_HandleInputEvent::Param params; | 1129 InputMsg_HandleInputEvent::Param params; |
1091 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(0), ¶ms)) { | 1130 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(0), ¶ms)) { |
1092 const blink::WebInputEvent* event = std::get<0>(params); | 1131 const blink::WebInputEvent* event = std::get<0>(params); |
1093 EXPECT_EQ(WebInputEvent::kGestureScrollEnd, event->GetType()); | 1132 EXPECT_EQ(WebInputEvent::kGestureScrollEnd, event->GetType()); |
1094 } | 1133 } |
1095 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 1134 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
1096 } | 1135 } |
(...skipping 622 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1719 | 1758 |
1720 ui::TouchEvent release2( | 1759 ui::TouchEvent release2( |
1721 ui::ET_TOUCH_RELEASED, gfx::Point(20, 20), base::TimeTicks::Now(), | 1760 ui::ET_TOUCH_RELEASED, gfx::Point(20, 20), base::TimeTicks::Now(), |
1722 ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, 0)); | 1761 ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH, 0)); |
1723 view_->OnTouchEvent(&release2); | 1762 view_->OnTouchEvent(&release2); |
1724 EXPECT_TRUE(press.synchronous_handling_disabled()); | 1763 EXPECT_TRUE(press.synchronous_handling_disabled()); |
1725 EXPECT_EQ(0U, pointer_state().GetPointerCount()); | 1764 EXPECT_EQ(0U, pointer_state().GetPointerCount()); |
1726 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); | 1765 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); |
1727 } | 1766 } |
1728 | 1767 |
| 1768 TEST_F(RenderWidgetHostViewAuraWheelScrollLatchingEnabledTest, |
| 1769 TimerBasedWheelEventPhaseInfo) { |
| 1770 view_->InitAsChild(nullptr); |
| 1771 view_->Show(); |
| 1772 sink_->ClearMessages(); |
| 1773 |
| 1774 ui::MouseWheelEvent event(gfx::Vector2d(0, 5), gfx::Point(2, 2), |
| 1775 gfx::Point(2, 2), ui::EventTimeForNow(), 0, 0); |
| 1776 view_->OnMouseEvent(&event); |
| 1777 const WebInputEvent* input_event = |
| 1778 GetInputEventFromMessage(*sink_->GetMessageAt(0)); |
| 1779 const WebMouseWheelEvent* wheel_event = |
| 1780 static_cast<const WebMouseWheelEvent*>(input_event); |
| 1781 EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, wheel_event->phase); |
| 1782 SendInputEventACK(blink::WebInputEvent::kMouseWheel, |
| 1783 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 1784 |
| 1785 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1)); |
| 1786 const WebGestureEvent* gesture_event = |
| 1787 static_cast<const WebGestureEvent*>(input_event); |
| 1788 EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType()); |
| 1789 |
| 1790 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(2)); |
| 1791 gesture_event = static_cast<const WebGestureEvent*>(input_event); |
| 1792 EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType()); |
| 1793 EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x); |
| 1794 EXPECT_EQ(5U, gesture_event->data.scroll_update.delta_y); |
| 1795 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
| 1796 INPUT_EVENT_ACK_STATE_CONSUMED); |
| 1797 sink_->ClearMessages(); |
| 1798 |
| 1799 // Send a ui::ScrollEvent instead of ui::MouseWheel event, the timer based |
| 1800 // phase info doesn't diffrentiate between the two types of events. |
| 1801 ui::ScrollEvent scroll1(ui::ET_SCROLL, gfx::Point(2, 2), |
| 1802 ui::EventTimeForNow(), 0, 0, 2, 0, 2, 2); |
| 1803 view_->OnScrollEvent(&scroll1); |
| 1804 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0)); |
| 1805 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); |
| 1806 EXPECT_EQ(WebMouseWheelEvent::kPhaseChanged, wheel_event->phase); |
| 1807 SendInputEventACK(blink::WebInputEvent::kMouseWheel, |
| 1808 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 1809 |
| 1810 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1)); |
| 1811 gesture_event = static_cast<const WebGestureEvent*>(input_event); |
| 1812 EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType()); |
| 1813 EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x); |
| 1814 EXPECT_EQ(2U, gesture_event->data.scroll_update.delta_y); |
| 1815 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
| 1816 INPUT_EVENT_ACK_STATE_CONSUMED); |
| 1817 sink_->ClearMessages(); |
| 1818 |
| 1819 // Let the RenderWidgetHostViewEventHandler::mouse_wheel_phase_timer_ fire. A |
| 1820 // synthetic wheel event with zero deltas and kPhaseEnded will be sent. |
| 1821 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
| 1822 FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), |
| 1823 base::TimeDelta::FromMilliseconds( |
| 1824 kDefaultMouseWheelLatchingTransactionMs)); |
| 1825 base::RunLoop().Run(); |
| 1826 |
| 1827 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0)); |
| 1828 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); |
| 1829 EXPECT_EQ(WebMouseWheelEvent::kPhaseEnded, wheel_event->phase); |
| 1830 EXPECT_EQ(0U, wheel_event->delta_x); |
| 1831 EXPECT_EQ(0U, wheel_event->delta_y); |
| 1832 SendInputEventACK(blink::WebInputEvent::kMouseWheel, |
| 1833 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 1834 |
| 1835 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1)); |
| 1836 gesture_event = static_cast<const WebGestureEvent*>(input_event); |
| 1837 EXPECT_EQ(WebInputEvent::kGestureScrollEnd, gesture_event->GetType()); |
| 1838 sink_->ClearMessages(); |
| 1839 } |
| 1840 |
| 1841 // Tests that a gesture fling start with touchpad source stops the |
| 1842 // RenderWidgetHostViewEventHandler::mouse_wheel_phase_timer_ and no synthetic |
| 1843 // wheel event will be sent. |
| 1844 TEST_F(RenderWidgetHostViewAuraWheelScrollLatchingEnabledTest, |
| 1845 TouchpadFlingStartStopsWheelPhaseTimer) { |
| 1846 ui::ScrollEvent scroll0(ui::ET_SCROLL, gfx::Point(2, 2), |
| 1847 ui::EventTimeForNow(), 0, 0, 5, 0, 5, 2); |
| 1848 view_->OnScrollEvent(&scroll0); |
| 1849 const WebInputEvent* input_event = |
| 1850 GetInputEventFromMessage(*sink_->GetMessageAt(0)); |
| 1851 const WebMouseWheelEvent* wheel_event = |
| 1852 static_cast<const WebMouseWheelEvent*>(input_event); |
| 1853 EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, wheel_event->phase); |
| 1854 SendInputEventACK(blink::WebInputEvent::kMouseWheel, |
| 1855 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 1856 |
| 1857 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1)); |
| 1858 const WebGestureEvent* gesture_event = |
| 1859 static_cast<const WebGestureEvent*>(input_event); |
| 1860 EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType()); |
| 1861 |
| 1862 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(2)); |
| 1863 gesture_event = static_cast<const WebGestureEvent*>(input_event); |
| 1864 EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType()); |
| 1865 EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x); |
| 1866 EXPECT_EQ(5U, gesture_event->data.scroll_update.delta_y); |
| 1867 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
| 1868 INPUT_EVENT_ACK_STATE_CONSUMED); |
| 1869 sink_->ClearMessages(); |
| 1870 |
| 1871 ui::ScrollEvent fling_start(ui::ET_SCROLL_FLING_START, gfx::Point(2, 2), |
| 1872 ui::EventTimeForNow(), 0, 0, 10, 0, 10, 2); |
| 1873 view_->OnScrollEvent(&fling_start); |
| 1874 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0)); |
| 1875 gesture_event = static_cast<const WebGestureEvent*>(input_event); |
| 1876 EXPECT_EQ(WebInputEvent::kGestureFlingStart, gesture_event->GetType()); |
| 1877 SendInputEventACK(WebInputEvent::kGestureFlingStart, |
| 1878 INPUT_EVENT_ACK_STATE_CONSUMED); |
| 1879 sink_->ClearMessages(); |
| 1880 |
| 1881 // Let the RenderWidgetHostViewEventHandler::mouse_wheel_phase_timer_ fire. No |
| 1882 // synthetic wheel event will be sent since the timer has stopped. |
| 1883 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
| 1884 FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), |
| 1885 base::TimeDelta::FromMilliseconds( |
| 1886 kDefaultMouseWheelLatchingTransactionMs)); |
| 1887 base::RunLoop().Run(); |
| 1888 |
| 1889 EXPECT_EQ(0U, sink_->message_count()); |
| 1890 |
| 1891 // Handling the next ui::ET_SCROLL event will send a fling cancellation and a |
| 1892 // mouse wheel with kPhaseBegan. |
| 1893 ui::ScrollEvent scroll1(ui::ET_SCROLL, gfx::Point(2, 2), |
| 1894 ui::EventTimeForNow(), 0, 0, 15, 0, 15, 2); |
| 1895 view_->OnScrollEvent(&scroll1); |
| 1896 EXPECT_EQ(2U, sink_->message_count()); |
| 1897 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0)); |
| 1898 gesture_event = static_cast<const WebGestureEvent*>(input_event); |
| 1899 |
| 1900 EXPECT_EQ(WebInputEvent::kGestureFlingCancel, gesture_event->GetType()); |
| 1901 SendInputEventACK(WebInputEvent::kGestureFlingCancel, |
| 1902 INPUT_EVENT_ACK_STATE_CONSUMED); |
| 1903 |
| 1904 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1)); |
| 1905 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); |
| 1906 EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, wheel_event->phase); |
| 1907 sink_->ClearMessages(); |
| 1908 } |
| 1909 |
| 1910 TEST_F(RenderWidgetHostViewAuraWheelScrollLatchingEnabledTest, |
| 1911 GSBWithTouchSourceStopsWheelScrollSequence) { |
| 1912 ui::ScrollEvent scroll0(ui::ET_SCROLL, gfx::Point(2, 2), |
| 1913 ui::EventTimeForNow(), 0, 0, 5, 0, 5, 2); |
| 1914 view_->OnScrollEvent(&scroll0); |
| 1915 const WebInputEvent* input_event = |
| 1916 GetInputEventFromMessage(*sink_->GetMessageAt(0)); |
| 1917 const WebMouseWheelEvent* wheel_event = |
| 1918 static_cast<const WebMouseWheelEvent*>(input_event); |
| 1919 EXPECT_EQ(WebMouseWheelEvent::kPhaseBegan, wheel_event->phase); |
| 1920 SendInputEventACK(blink::WebInputEvent::kMouseWheel, |
| 1921 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 1922 |
| 1923 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1)); |
| 1924 const WebGestureEvent* gesture_event = |
| 1925 static_cast<const WebGestureEvent*>(input_event); |
| 1926 EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType()); |
| 1927 |
| 1928 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(2)); |
| 1929 gesture_event = static_cast<const WebGestureEvent*>(input_event); |
| 1930 EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, gesture_event->GetType()); |
| 1931 EXPECT_EQ(0U, gesture_event->data.scroll_update.delta_x); |
| 1932 EXPECT_EQ(5U, gesture_event->data.scroll_update.delta_y); |
| 1933 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
| 1934 INPUT_EVENT_ACK_STATE_CONSUMED); |
| 1935 sink_->ClearMessages(); |
| 1936 |
| 1937 ui::GestureEventDetails event_details(ui::ET_GESTURE_SCROLL_BEGIN); |
| 1938 event_details.set_device_type(ui::GestureDeviceType::DEVICE_TOUCHSCREEN); |
| 1939 ui::GestureEvent scroll_begin(2, 2, 0, ui::EventTimeForNow(), event_details); |
| 1940 view_->OnGestureEvent(&scroll_begin); |
| 1941 EXPECT_EQ(3U, sink_->message_count()); |
| 1942 |
| 1943 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(0)); |
| 1944 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); |
| 1945 EXPECT_EQ(WebMouseWheelEvent::kPhaseEnded, wheel_event->phase); |
| 1946 EXPECT_EQ(0U, wheel_event->delta_x); |
| 1947 EXPECT_EQ(0U, wheel_event->delta_y); |
| 1948 |
| 1949 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(1)); |
| 1950 gesture_event = static_cast<const WebGestureEvent*>(input_event); |
| 1951 EXPECT_EQ(WebInputEvent::kGestureScrollEnd, gesture_event->GetType()); |
| 1952 EXPECT_EQ(blink::kWebGestureDeviceTouchpad, gesture_event->source_device); |
| 1953 |
| 1954 input_event = GetInputEventFromMessage(*sink_->GetMessageAt(2)); |
| 1955 gesture_event = static_cast<const WebGestureEvent*>(input_event); |
| 1956 EXPECT_EQ(WebInputEvent::kGestureScrollBegin, gesture_event->GetType()); |
| 1957 EXPECT_EQ(blink::kWebGestureDeviceTouchscreen, gesture_event->source_device); |
| 1958 sink_->ClearMessages(); |
| 1959 } |
| 1960 |
1729 // Checks that touch-event state is maintained correctly for multiple touch | 1961 // Checks that touch-event state is maintained correctly for multiple touch |
1730 // points. | 1962 // points. |
1731 TEST_F(RenderWidgetHostViewAuraTest, MultiTouchPointsStates) { | 1963 TEST_F(RenderWidgetHostViewAuraTest, MultiTouchPointsStates) { |
1732 view_->InitAsFullscreen(parent_view_); | 1964 view_->InitAsFullscreen(parent_view_); |
1733 view_->Show(); | 1965 view_->Show(); |
1734 view_->UseFakeDispatcher(); | 1966 view_->UseFakeDispatcher(); |
1735 GetSentMessageCountAndResetSink(); | 1967 GetSentMessageCountAndResetSink(); |
1736 | 1968 |
1737 ui::TouchEvent press0( | 1969 ui::TouchEvent press0( |
1738 ui::ET_TOUCH_PRESSED, gfx::Point(30, 30), ui::EventTimeForNow(), | 1970 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()); | 3753 EXPECT_EQ(ui::MotionEvent::ACTION_DOWN, pointer_state().GetAction()); |
3522 EXPECT_EQ(1U, pointer_state().GetPointerCount()); | 3754 EXPECT_EQ(1U, pointer_state().GetPointerCount()); |
3523 EXPECT_EQ(kX, pointer_state().GetX(0)); | 3755 EXPECT_EQ(kX, pointer_state().GetX(0)); |
3524 EXPECT_EQ(kY, pointer_state().GetY(0)); | 3756 EXPECT_EQ(kY, pointer_state().GetY(0)); |
3525 } | 3757 } |
3526 | 3758 |
3527 void RenderWidgetHostViewAuraOverscrollTest::WheelNotPreciseScrollEvent() { | 3759 void RenderWidgetHostViewAuraOverscrollTest::WheelNotPreciseScrollEvent() { |
3528 SetUpOverscrollEnvironment(); | 3760 SetUpOverscrollEnvironment(); |
3529 | 3761 |
3530 // Simulate wheel events. | 3762 // Simulate wheel events. |
3531 SimulateWheelEvent(-5, 0, 0, false); // sent directly | 3763 SimulateWheelEventPossiblyIncludingPhase( |
3532 SimulateWheelEvent(-60, 1, 0, false); // enqueued | 3764 !wheel_scroll_latching_enabled_, -5, 0, 0, false, |
| 3765 WebMouseWheelEvent::kPhaseBegan); // sent directly |
| 3766 SimulateWheelEventPossiblyIncludingPhase( |
| 3767 !wheel_scroll_latching_enabled_, -60, 1, 0, false, |
| 3768 WebMouseWheelEvent::kPhaseChanged); // enqueued |
3533 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3769 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3534 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 3770 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3535 | 3771 |
3536 // Receive ACK the first wheel event as not processed. | 3772 // Receive ACK the first wheel event as not processed. |
3537 SendInputEventACK(WebInputEvent::kMouseWheel, | 3773 SendInputEventACK(WebInputEvent::kMouseWheel, |
3538 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3774 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3539 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 3775 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); |
3540 | 3776 |
3541 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3777 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3542 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3778 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3543 ExpectGestureScrollEndForWheelScrolling(false); | 3779 ExpectGestureScrollEndForWheelScrolling(false); |
3544 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3780 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3545 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 3781 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3546 | 3782 |
3547 SendInputEventACK(WebInputEvent::kMouseWheel, | 3783 SendInputEventACK(WebInputEvent::kMouseWheel, |
3548 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3784 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3549 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 3785 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3550 | 3786 |
3551 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3787 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3552 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3788 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 3789 if (wheel_scroll_latching_enabled_) { |
| 3790 SimulateWheelEventWithPhase(0, 0, 0, false, |
| 3791 WebMouseWheelEvent::kPhaseEnded); |
| 3792 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
| 3793 SendInputEventACK(WebInputEvent::kMouseWheel, |
| 3794 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 3795 } |
3553 ExpectGestureScrollEndForWheelScrolling(true); | 3796 ExpectGestureScrollEndForWheelScrolling(true); |
3554 | 3797 |
3555 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3798 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3556 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 3799 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3557 } | 3800 } |
3558 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelNotPreciseScrollEvent) { | 3801 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelNotPreciseScrollEvent) { |
3559 WheelNotPreciseScrollEvent(); | 3802 WheelNotPreciseScrollEvent(); |
3560 } | 3803 } |
3561 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 3804 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
3562 WheelNotPreciseScrollEvent) { | 3805 WheelNotPreciseScrollEvent) { |
3563 WheelNotPreciseScrollEvent(); | 3806 WheelNotPreciseScrollEvent(); |
3564 } | 3807 } |
3565 | 3808 |
3566 void RenderWidgetHostViewAuraOverscrollTest::WheelScrollEventOverscrolls() { | 3809 void RenderWidgetHostViewAuraOverscrollTest::WheelScrollEventOverscrolls() { |
3567 SetUpOverscrollEnvironment(); | 3810 SetUpOverscrollEnvironment(); |
3568 | 3811 |
3569 // Simulate wheel events. | 3812 // Simulate wheel events. |
3570 SimulateWheelEvent(-5, 0, 0, true); // sent directly | 3813 SimulateWheelEventPossiblyIncludingPhase( |
3571 SimulateWheelEvent(-1, 1, 0, true); // enqueued | 3814 !wheel_scroll_latching_enabled_, -5, 0, 0, true, |
3572 SimulateWheelEvent(-10, -3, 0, true); // coalesced into previous event | 3815 WebMouseWheelEvent::kPhaseBegan); // sent directly |
3573 SimulateWheelEvent(-15, -1, 0, true); // coalesced into previous event | 3816 SimulateWheelEventPossiblyIncludingPhase( |
3574 SimulateWheelEvent(-30, -3, 0, true); // coalesced into previous event | 3817 !wheel_scroll_latching_enabled_, -1, 1, 0, true, |
3575 SimulateWheelEvent(-20, 6, 1, true); // enqueued, different modifiers | 3818 WebMouseWheelEvent::kPhaseChanged); // enqueued |
| 3819 SimulateWheelEventPossiblyIncludingPhase( |
| 3820 !wheel_scroll_latching_enabled_, -10, -3, 0, true, |
| 3821 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
| 3822 SimulateWheelEventPossiblyIncludingPhase( |
| 3823 !wheel_scroll_latching_enabled_, -15, -1, 0, true, |
| 3824 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
| 3825 SimulateWheelEventPossiblyIncludingPhase( |
| 3826 !wheel_scroll_latching_enabled_, -30, -3, 0, true, |
| 3827 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
| 3828 SimulateWheelEventPossiblyIncludingPhase( |
| 3829 !wheel_scroll_latching_enabled_, -20, 6, 1, true, |
| 3830 WebMouseWheelEvent::kPhaseChanged); // enqueued, different modifiers |
3576 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3831 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3577 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 3832 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3578 | 3833 |
3579 // Receive ACK the first wheel event as not processed. | 3834 // Receive ACK the first wheel event as not processed. |
3580 SendInputEventACK(WebInputEvent::kMouseWheel, | 3835 SendInputEventACK(WebInputEvent::kMouseWheel, |
3581 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3836 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3582 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 3837 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); |
3583 | 3838 |
3584 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3839 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3585 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3840 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3632 WheelScrollEventOverscrolls(); | 3887 WheelScrollEventOverscrolls(); |
3633 } | 3888 } |
3634 | 3889 |
3635 // Tests that if some scroll events are consumed towards the start, then | 3890 // Tests that if some scroll events are consumed towards the start, then |
3636 // subsequent scrolls do not horizontal overscroll. | 3891 // subsequent scrolls do not horizontal overscroll. |
3637 void RenderWidgetHostViewAuraOverscrollTest:: | 3892 void RenderWidgetHostViewAuraOverscrollTest:: |
3638 WheelScrollConsumedDoNotHorizOverscroll() { | 3893 WheelScrollConsumedDoNotHorizOverscroll() { |
3639 SetUpOverscrollEnvironment(); | 3894 SetUpOverscrollEnvironment(); |
3640 | 3895 |
3641 // Simulate wheel events. | 3896 // Simulate wheel events. |
3642 SimulateWheelEvent(-5, 0, 0, true); // sent directly | 3897 SimulateWheelEventPossiblyIncludingPhase( |
3643 SimulateWheelEvent(-1, -1, 0, true); // enqueued | 3898 !wheel_scroll_latching_enabled_, -5, 0, 0, true, |
3644 SimulateWheelEvent(-10, -3, 0, true); // coalesced into previous event | 3899 WebMouseWheelEvent::kPhaseBegan); // sent directly |
3645 SimulateWheelEvent(-15, -1, 0, true); // coalesced into previous event | 3900 SimulateWheelEventPossiblyIncludingPhase( |
3646 SimulateWheelEvent(-30, -3, 0, true); // coalesced into previous event | 3901 !wheel_scroll_latching_enabled_, -1, -1, 0, true, |
3647 SimulateWheelEvent(-20, 6, 1, true); // enqueued, different modifiers | 3902 WebMouseWheelEvent::kPhaseChanged); // enqueued |
| 3903 SimulateWheelEventPossiblyIncludingPhase( |
| 3904 !wheel_scroll_latching_enabled_, -10, -3, 0, true, |
| 3905 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
| 3906 SimulateWheelEventPossiblyIncludingPhase( |
| 3907 !wheel_scroll_latching_enabled_, -15, -1, 0, true, |
| 3908 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
| 3909 SimulateWheelEventPossiblyIncludingPhase( |
| 3910 !wheel_scroll_latching_enabled_, -30, -3, 0, true, |
| 3911 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
| 3912 SimulateWheelEventPossiblyIncludingPhase( |
| 3913 !wheel_scroll_latching_enabled_, -20, 6, 1, true, |
| 3914 WebMouseWheelEvent::kPhaseChanged); // enqueued, different modifiers |
| 3915 |
3648 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3916 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3649 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 3917 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3650 | 3918 |
3651 // Receive ACK the first wheel event as processed. | 3919 // Receive ACK the first wheel event as processed. |
3652 SendInputEventACK(WebInputEvent::kMouseWheel, | 3920 SendInputEventACK(WebInputEvent::kMouseWheel, |
3653 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3921 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3654 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 3922 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); |
3655 | 3923 |
3656 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3924 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3657 INPUT_EVENT_ACK_STATE_CONSUMED); | 3925 INPUT_EVENT_ACK_STATE_CONSUMED); |
(...skipping 14 matching lines...) Expand all Loading... |
3672 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3940 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3673 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3941 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3674 ExpectGestureScrollEndForWheelScrolling(false); | 3942 ExpectGestureScrollEndForWheelScrolling(false); |
3675 | 3943 |
3676 SendInputEventACK(WebInputEvent::kMouseWheel, | 3944 SendInputEventACK(WebInputEvent::kMouseWheel, |
3677 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3945 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3678 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 3946 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3679 | 3947 |
3680 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3948 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3681 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3949 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 3950 if (wheel_scroll_latching_enabled_) { |
| 3951 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); |
| 3952 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
| 3953 SendInputEventACK(WebInputEvent::kMouseWheel, |
| 3954 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 3955 } |
| 3956 |
3682 ExpectGestureScrollEndForWheelScrolling(true); | 3957 ExpectGestureScrollEndForWheelScrolling(true); |
3683 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3958 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3684 } | 3959 } |
3685 TEST_F(RenderWidgetHostViewAuraOverscrollTest, | 3960 TEST_F(RenderWidgetHostViewAuraOverscrollTest, |
3686 WheelScrollConsumedDoNotHorizOverscroll) { | 3961 WheelScrollConsumedDoNotHorizOverscroll) { |
3687 WheelScrollConsumedDoNotHorizOverscroll(); | 3962 WheelScrollConsumedDoNotHorizOverscroll(); |
3688 } | 3963 } |
3689 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 3964 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
3690 WheelScrollConsumedDoNotHorizOverscroll) { | 3965 WheelScrollConsumedDoNotHorizOverscroll) { |
3691 WheelScrollConsumedDoNotHorizOverscroll(); | 3966 WheelScrollConsumedDoNotHorizOverscroll(); |
3692 } | 3967 } |
3693 | 3968 |
3694 // Tests that wheel-scrolling correctly turns overscroll on and off. | 3969 // Tests that wheel-scrolling correctly turns overscroll on and off. |
3695 void RenderWidgetHostViewAuraOverscrollTest::WheelScrollOverscrollToggle() { | 3970 void RenderWidgetHostViewAuraOverscrollTest::WheelScrollOverscrollToggle() { |
3696 SetUpOverscrollEnvironment(); | 3971 SetUpOverscrollEnvironment(); |
3697 | 3972 |
3698 // Send a wheel event. ACK the event as not processed. This should not | 3973 // 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. | 3974 // initiate an overscroll gesture since it doesn't cross the threshold yet. |
3700 SimulateWheelEvent(10, 0, 0, true); | 3975 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 10, |
| 3976 0, 0, true, |
| 3977 WebMouseWheelEvent::kPhaseBegan); |
3701 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 3978 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3702 SendInputEventACK(WebInputEvent::kMouseWheel, | 3979 SendInputEventACK(WebInputEvent::kMouseWheel, |
3703 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3980 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3704 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); | 3981 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); |
3705 | 3982 |
3706 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3983 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3707 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3984 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3708 ExpectGestureScrollEndForWheelScrolling(false); | 3985 ExpectGestureScrollEndForWheelScrolling(false); |
3709 | 3986 |
3710 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3987 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3711 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 3988 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3712 | 3989 |
3713 // Scroll some more so as to not overscroll. | 3990 // Scroll some more so as to not overscroll. |
3714 SimulateWheelEvent(10, 0, 0, true); | 3991 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 10, |
| 3992 0, 0, true, |
| 3993 WebMouseWheelEvent::kPhaseChanged); |
3715 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 3994 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3716 SendInputEventACK(WebInputEvent::kMouseWheel, | 3995 SendInputEventACK(WebInputEvent::kMouseWheel, |
3717 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3996 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3718 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 3997 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3719 | 3998 |
3720 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3999 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3721 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4000 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3722 ExpectGestureScrollEndForWheelScrolling(false); | 4001 ExpectGestureScrollEndForWheelScrolling(false); |
3723 | 4002 |
3724 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4003 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3725 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4004 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3726 | 4005 |
3727 // Scroll some more to initiate an overscroll. | 4006 // Scroll some more to initiate an overscroll. |
3728 SimulateWheelEvent(40, 0, 0, true); | 4007 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 40, |
| 4008 0, 0, true, |
| 4009 WebMouseWheelEvent::kPhaseChanged); |
3729 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4010 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3730 SendInputEventACK(WebInputEvent::kMouseWheel, | 4011 SendInputEventACK(WebInputEvent::kMouseWheel, |
3731 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4012 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3732 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4013 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3733 | 4014 |
3734 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4015 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3735 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4016 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3736 ExpectGestureScrollEndForWheelScrolling(false); | 4017 ExpectGestureScrollEndForWheelScrolling(false); |
3737 | 4018 |
3738 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); | 4019 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); |
3739 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); | 4020 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); |
3740 EXPECT_EQ(60.f, overscroll_delta_x()); | 4021 EXPECT_EQ(60.f, overscroll_delta_x()); |
3741 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); | 4022 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); |
3742 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); | 4023 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); |
3743 | 4024 |
3744 // Scroll in the reverse direction enough to abort the overscroll. | 4025 // Scroll in the reverse direction enough to abort the overscroll. |
3745 SimulateWheelEvent(-20, 0, 0, true); | 4026 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, -20, |
| 4027 0, 0, true, |
| 4028 WebMouseWheelEvent::kPhaseChanged); |
3746 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4029 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3747 SendInputEventACK(WebInputEvent::kMouseWheel, | 4030 SendInputEventACK(WebInputEvent::kMouseWheel, |
3748 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4031 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3749 if (wheel_scroll_latching_enabled_) { | 4032 if (wheel_scroll_latching_enabled_) { |
3750 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); | 4033 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); |
3751 } else { | 4034 } else { |
3752 // ScrollBegin and ScrollEnd will be queued events. | 4035 // ScrollBegin and ScrollEnd will be queued events. |
3753 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); | 4036 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); |
3754 } | 4037 } |
3755 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4038 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3756 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4039 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3757 | 4040 |
3758 // Continue to scroll in the reverse direction. | 4041 // Continue to scroll in the reverse direction. |
3759 SimulateWheelEvent(-20, 0, 0, true); | 4042 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, -20, |
| 4043 0, 0, true, |
| 4044 WebMouseWheelEvent::kPhaseChanged); |
| 4045 |
3760 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4046 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3761 SendInputEventACK(WebInputEvent::kMouseWheel, | 4047 SendInputEventACK(WebInputEvent::kMouseWheel, |
3762 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4048 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3763 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4049 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3764 | 4050 |
3765 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4051 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3766 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4052 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3767 ExpectGestureScrollEndForWheelScrolling(false); | 4053 ExpectGestureScrollEndForWheelScrolling(false); |
3768 | 4054 |
3769 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4055 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3770 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4056 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3771 | 4057 |
3772 // Continue to scroll in the reverse direction enough to initiate overscroll | 4058 // Continue to scroll in the reverse direction enough to initiate overscroll |
3773 // in that direction. | 4059 // in that direction. |
3774 SimulateWheelEvent(-55, 0, 0, true); | 4060 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, -55, |
| 4061 0, 0, true, |
| 4062 WebMouseWheelEvent::kPhaseChanged); |
3775 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4063 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3776 SendInputEventACK(WebInputEvent::kMouseWheel, | 4064 SendInputEventACK(WebInputEvent::kMouseWheel, |
3777 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4065 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3778 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4066 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3779 | 4067 |
3780 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4068 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3781 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4069 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 4070 if (wheel_scroll_latching_enabled_) { |
| 4071 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); |
| 4072 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
| 4073 SendInputEventACK(WebInputEvent::kMouseWheel, |
| 4074 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 4075 } |
3782 ExpectGestureScrollEndForWheelScrolling(true); | 4076 ExpectGestureScrollEndForWheelScrolling(true); |
3783 | 4077 |
3784 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); | 4078 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); |
3785 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); | 4079 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); |
3786 EXPECT_EQ(-75.f, overscroll_delta_x()); | 4080 EXPECT_EQ(-75.f, overscroll_delta_x()); |
3787 EXPECT_EQ(-25.f, overscroll_delegate()->delta_x()); | 4081 EXPECT_EQ(-25.f, overscroll_delegate()->delta_x()); |
3788 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); | 4082 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); |
3789 } | 4083 } |
3790 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelScrollOverscrollToggle) { | 4084 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelScrollOverscrollToggle) { |
3791 WheelScrollOverscrollToggle(); | 4085 WheelScrollOverscrollToggle(); |
3792 } | 4086 } |
3793 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 4087 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
3794 WheelScrollOverscrollToggle) { | 4088 WheelScrollOverscrollToggle) { |
3795 WheelScrollOverscrollToggle(); | 4089 WheelScrollOverscrollToggle(); |
3796 } | 4090 } |
3797 | 4091 |
3798 void RenderWidgetHostViewAuraOverscrollTest::ScrollEventsOverscrollWithFling() { | 4092 void RenderWidgetHostViewAuraOverscrollTest::ScrollEventsOverscrollWithFling() { |
3799 SetUpOverscrollEnvironment(); | 4093 SetUpOverscrollEnvironment(); |
3800 | 4094 |
3801 // Send a wheel event. ACK the event as not processed. This should not | 4095 // 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. | 4096 // initiate an overscroll gesture since it doesn't cross the threshold yet. |
3803 SimulateWheelEvent(10, 0, 0, true); | 4097 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 10, |
| 4098 0, 0, true, |
| 4099 WebMouseWheelEvent::kPhaseBegan); |
3804 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4100 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3805 SendInputEventACK(WebInputEvent::kMouseWheel, | 4101 SendInputEventACK(WebInputEvent::kMouseWheel, |
3806 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4102 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3807 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); | 4103 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); |
3808 | 4104 |
3809 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4105 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3810 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4106 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3811 ExpectGestureScrollEndForWheelScrolling(false); | 4107 ExpectGestureScrollEndForWheelScrolling(false); |
3812 | 4108 |
3813 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4109 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3814 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4110 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3815 | 4111 |
3816 // Scroll some more so as to not overscroll. | 4112 // Scroll some more so as to not overscroll. |
3817 SimulateWheelEvent(20, 0, 0, true); | 4113 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 20, |
| 4114 0, 0, true, |
| 4115 WebMouseWheelEvent::kPhaseChanged); |
3818 EXPECT_EQ(1U, sink_->message_count()); | 4116 EXPECT_EQ(1U, sink_->message_count()); |
3819 SendInputEventACK(WebInputEvent::kMouseWheel, | 4117 SendInputEventACK(WebInputEvent::kMouseWheel, |
3820 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4118 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3821 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4119 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3822 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4120 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3823 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4121 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3824 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4122 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3825 sink_->ClearMessages(); | 4123 sink_->ClearMessages(); |
3826 | 4124 |
3827 // Scroll some more to initiate an overscroll. | 4125 // Scroll some more to initiate an overscroll. |
3828 SimulateWheelEvent(30, 0, 0, true); | 4126 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 30, |
| 4127 0, 0, true, |
| 4128 WebMouseWheelEvent::kPhaseChanged); |
3829 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4129 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3830 SendInputEventACK(WebInputEvent::kMouseWheel, | 4130 SendInputEventACK(WebInputEvent::kMouseWheel, |
3831 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4131 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3832 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4132 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3833 | 4133 |
3834 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4134 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3835 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4135 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3836 ExpectGestureScrollEndForWheelScrolling(false); | 4136 ExpectGestureScrollEndForWheelScrolling(false); |
3837 | 4137 |
3838 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); | 4138 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); |
3839 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); | 4139 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); |
3840 | 4140 |
3841 EXPECT_EQ(60.f, overscroll_delta_x()); | 4141 EXPECT_EQ(60.f, overscroll_delta_x()); |
3842 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); | 4142 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); |
3843 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); | 4143 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); |
3844 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); | 4144 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); |
3845 | 4145 |
3846 // Send a fling start, but with a small velocity, so that the overscroll is | 4146 // 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 | 4147 // aborted. The fling should proceed to the renderer, through the gesture |
3848 // event filter. | 4148 // event filter. |
3849 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, | 4149 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, |
3850 blink::kWebGestureDeviceTouchscreen); | 4150 blink::kWebGestureDeviceTouchscreen); |
3851 SimulateGestureFlingStartEvent(0.f, 0.1f, blink::kWebGestureDeviceTouchpad); | 4151 SimulateGestureFlingStartEvent(0.f, 0.1f, blink::kWebGestureDeviceTouchpad); |
3852 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4152 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3853 | 4153 |
3854 if (!wheel_scroll_latching_enabled_) { | 4154 // ScrollBegin and FlingStart will be queued events. |
3855 // ScrollBegin and FlingStart will be queued events. | 4155 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 } | 4156 } |
3862 TEST_F(RenderWidgetHostViewAuraOverscrollTest, | 4157 TEST_F(RenderWidgetHostViewAuraOverscrollTest, |
3863 ScrollEventsOverscrollWithFling) { | 4158 ScrollEventsOverscrollWithFling) { |
3864 ScrollEventsOverscrollWithFling(); | 4159 ScrollEventsOverscrollWithFling(); |
3865 } | 4160 } |
3866 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 4161 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
3867 ScrollEventsOverscrollWithFling) { | 4162 ScrollEventsOverscrollWithFling) { |
3868 ScrollEventsOverscrollWithFling(); | 4163 ScrollEventsOverscrollWithFling(); |
3869 } | 4164 } |
3870 | 4165 |
3871 // Same as ScrollEventsOverscrollWithFling, but with zero velocity. Checks that | 4166 // Same as ScrollEventsOverscrollWithFling, but with zero velocity. Checks that |
3872 // the zero-velocity fling does not reach the renderer. | 4167 // the zero-velocity fling does not reach the renderer. |
3873 void RenderWidgetHostViewAuraOverscrollTest:: | 4168 void RenderWidgetHostViewAuraOverscrollTest:: |
3874 ScrollEventsOverscrollWithZeroFling() { | 4169 ScrollEventsOverscrollWithZeroFling() { |
3875 SetUpOverscrollEnvironment(); | 4170 SetUpOverscrollEnvironment(); |
3876 | 4171 |
3877 // Send a wheel event. ACK the event as not processed. This should not | 4172 // 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. | 4173 // initiate an overscroll gesture since it doesn't cross the threshold yet. |
3879 SimulateWheelEvent(10, 0, 0, true); | 4174 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 10, |
| 4175 0, 0, true, |
| 4176 WebMouseWheelEvent::kPhaseBegan); |
3880 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4177 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3881 SendInputEventACK(WebInputEvent::kMouseWheel, | 4178 SendInputEventACK(WebInputEvent::kMouseWheel, |
3882 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4179 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3883 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); | 4180 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); |
3884 | 4181 |
3885 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4182 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3886 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4183 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3887 ExpectGestureScrollEndForWheelScrolling(false); | 4184 ExpectGestureScrollEndForWheelScrolling(false); |
3888 | 4185 |
3889 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4186 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3890 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4187 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3891 | 4188 |
3892 // Scroll some more so as to not overscroll. | 4189 // Scroll some more so as to not overscroll. |
3893 SimulateWheelEvent(20, 0, 0, true); | 4190 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 20, |
| 4191 0, 0, true, |
| 4192 WebMouseWheelEvent::kPhaseChanged); |
3894 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4193 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3895 SendInputEventACK(WebInputEvent::kMouseWheel, | 4194 SendInputEventACK(WebInputEvent::kMouseWheel, |
3896 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4195 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3897 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4196 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3898 | 4197 |
3899 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4198 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3900 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4199 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3901 ExpectGestureScrollEndForWheelScrolling(false); | 4200 ExpectGestureScrollEndForWheelScrolling(false); |
3902 | 4201 |
3903 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4202 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3904 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4203 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3905 | 4204 |
3906 // Scroll some more to initiate an overscroll. | 4205 // Scroll some more to initiate an overscroll. |
3907 SimulateWheelEvent(30, 0, 0, true); | 4206 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 30, |
| 4207 0, 0, true, |
| 4208 WebMouseWheelEvent::kPhaseChanged); |
3908 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4209 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3909 SendInputEventACK(WebInputEvent::kMouseWheel, | 4210 SendInputEventACK(WebInputEvent::kMouseWheel, |
3910 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4211 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3911 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4212 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
3912 | 4213 |
3913 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4214 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3914 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4215 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3915 ExpectGestureScrollEndForWheelScrolling(false); | 4216 ExpectGestureScrollEndForWheelScrolling(false); |
3916 | 4217 |
3917 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); | 4218 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); |
3918 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); | 4219 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); |
3919 | 4220 |
3920 EXPECT_EQ(60.f, overscroll_delta_x()); | 4221 EXPECT_EQ(60.f, overscroll_delta_x()); |
3921 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); | 4222 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); |
3922 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); | 4223 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); |
3923 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); | 4224 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); |
3924 | 4225 |
3925 // Send a fling start, but with a small velocity, so that the overscroll is | 4226 // 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 | 4227 // aborted. The fling should proceed to the renderer, through the gesture |
3927 // event filter. | 4228 // event filter. |
3928 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, | 4229 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, |
3929 blink::kWebGestureDeviceTouchscreen); | 4230 blink::kWebGestureDeviceTouchscreen); |
3930 SimulateGestureFlingStartEvent(10.f, 0.f, blink::kWebGestureDeviceTouchpad); | 4231 SimulateGestureFlingStartEvent(10.f, 0.f, blink::kWebGestureDeviceTouchpad); |
3931 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4232 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3932 | 4233 |
3933 if (!wheel_scroll_latching_enabled_) { | |
3934 // ScrollBegin and FlingStart will be queued events. | 4234 // ScrollBegin and FlingStart will be queued events. |
3935 EXPECT_EQ(2U, sink_->message_count()); | 4235 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 } | 4236 } |
3941 TEST_F(RenderWidgetHostViewAuraOverscrollTest, | 4237 TEST_F(RenderWidgetHostViewAuraOverscrollTest, |
3942 ScrollEventsOverscrollWithZeroFling) { | 4238 ScrollEventsOverscrollWithZeroFling) { |
3943 ScrollEventsOverscrollWithZeroFling(); | 4239 ScrollEventsOverscrollWithZeroFling(); |
3944 } | 4240 } |
3945 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 4241 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
3946 ScrollEventsOverscrollWithZeroFling) { | 4242 ScrollEventsOverscrollWithZeroFling) { |
3947 ScrollEventsOverscrollWithZeroFling(); | 4243 ScrollEventsOverscrollWithZeroFling(); |
3948 } | 4244 } |
3949 | 4245 |
(...skipping 440 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4390 SimulateGestureScrollUpdateEvent(-20, 0, 0); | 4686 SimulateGestureScrollUpdateEvent(-20, 0, 0); |
4391 EXPECT_EQ(1U, sink_->message_count()); | 4687 EXPECT_EQ(1U, sink_->message_count()); |
4392 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4688 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4393 } | 4689 } |
4394 | 4690 |
4395 void RenderWidgetHostViewAuraOverscrollTest:: | 4691 void RenderWidgetHostViewAuraOverscrollTest:: |
4396 OverscrollDirectionChangeMouseWheel() { | 4692 OverscrollDirectionChangeMouseWheel() { |
4397 SetUpOverscrollEnvironment(); | 4693 SetUpOverscrollEnvironment(); |
4398 | 4694 |
4399 // Send wheel event and receive ack as not consumed. | 4695 // Send wheel event and receive ack as not consumed. |
4400 SimulateWheelEvent(125, -5, 0, true); | 4696 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 125, |
| 4697 -5, 0, true, |
| 4698 WebMouseWheelEvent::kPhaseBegan); |
4401 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4699 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4402 SendInputEventACK(WebInputEvent::kMouseWheel, | 4700 SendInputEventACK(WebInputEvent::kMouseWheel, |
4403 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4701 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4404 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); | 4702 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); |
4405 | 4703 |
4406 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4704 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4407 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4705 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4408 ExpectGestureScrollEndForWheelScrolling(false); | 4706 ExpectGestureScrollEndForWheelScrolling(false); |
4409 | 4707 |
4410 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); | 4708 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); |
4411 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); | 4709 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); |
4412 | 4710 |
4413 // Send another wheel event, but in the reverse direction. The overscroll | 4711 // Send another wheel event, but in the reverse direction. The overscroll |
4414 // controller will not consume the event, because it is not triggering | 4712 // controller will not consume the event, because it is not triggering |
4415 // gesture-nav. | 4713 // gesture-nav. |
4416 | 4714 |
4417 SimulateWheelEvent(-260, 0, 0, true); | 4715 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, |
| 4716 -260, 0, 0, true, |
| 4717 WebMouseWheelEvent::kPhaseChanged); |
4418 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4718 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4419 SendInputEventACK(WebInputEvent::kMouseWheel, | 4719 SendInputEventACK(WebInputEvent::kMouseWheel, |
4420 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4720 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4421 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4721 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
4422 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4722 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4423 | 4723 |
4424 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4724 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4425 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4725 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4426 ExpectGestureScrollEndForWheelScrolling(false); | 4726 ExpectGestureScrollEndForWheelScrolling(false); |
4427 | 4727 |
4428 // Since it was unhandled; the overscroll should now be west | 4728 // Since it was unhandled; the overscroll should now be west |
4429 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); | 4729 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); |
4430 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); | 4730 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); |
4431 | 4731 |
4432 SimulateWheelEvent(-20, 0, 0, true); | 4732 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, -20, |
| 4733 0, 0, true, |
| 4734 WebMouseWheelEvent::kPhaseChanged); |
4433 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4735 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4434 SendInputEventACK(WebInputEvent::kMouseWheel, | 4736 SendInputEventACK(WebInputEvent::kMouseWheel, |
4435 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4737 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4436 | 4738 |
4437 // wheel event ack generates gesture scroll update; which gets consumed | 4739 // wheel event ack generates gesture scroll update; which gets consumed |
4438 // solely by the overflow controller. | 4740 // solely by the overflow controller. |
4439 if (!wheel_scroll_latching_enabled_) { | 4741 if (!wheel_scroll_latching_enabled_) { |
4440 // No ScrollUpdates, only ScrollBegin and ScrollEnd will be queued events. | 4742 // No ScrollUpdates, only ScrollBegin and ScrollEnd will be queued events. |
4441 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); | 4743 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); |
4442 } else { | 4744 } else { |
4443 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); | 4745 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); |
4444 } | 4746 } |
4445 | 4747 |
4446 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); | 4748 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); |
4447 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); | 4749 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); |
4448 } | 4750 } |
4449 TEST_F(RenderWidgetHostViewAuraOverscrollTest, | 4751 TEST_F(RenderWidgetHostViewAuraOverscrollTest, |
4450 OverscrollDirectionChangeMouseWheel) { | 4752 OverscrollDirectionChangeMouseWheel) { |
4451 OverscrollDirectionChangeMouseWheel(); | 4753 OverscrollDirectionChangeMouseWheel(); |
4452 } | 4754 } |
4453 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 4755 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
4454 OverscrollDirectionChangeMouseWheel) { | 4756 OverscrollDirectionChangeMouseWheel) { |
4455 OverscrollDirectionChangeMouseWheel(); | 4757 OverscrollDirectionChangeMouseWheel(); |
4456 } | 4758 } |
4457 | 4759 |
4458 void RenderWidgetHostViewAuraOverscrollTest::OverscrollMouseMoveCompletion() { | 4760 void RenderWidgetHostViewAuraOverscrollTest::OverscrollMouseMoveCompletion() { |
4459 SetUpOverscrollEnvironment(); | 4761 SetUpOverscrollEnvironment(); |
4460 | 4762 |
4461 SimulateWheelEvent(5, 0, 0, true); // sent directly | 4763 SimulateWheelEventPossiblyIncludingPhase( |
4462 SimulateWheelEvent(-1, 0, 0, true); // enqueued | 4764 !wheel_scroll_latching_enabled_, 5, 0, 0, true, |
4463 SimulateWheelEvent(-10, -3, 0, true); // coalesced into previous event | 4765 WebMouseWheelEvent::kPhaseBegan); // sent directly |
4464 SimulateWheelEvent(-15, -1, 0, true); // coalesced into previous event | 4766 SimulateWheelEventPossiblyIncludingPhase( |
4465 SimulateWheelEvent(-30, -3, 0, true); // coalesced into previous event | 4767 !wheel_scroll_latching_enabled_, -1, 0, 0, true, |
| 4768 WebMouseWheelEvent::kPhaseChanged); // enqueued |
| 4769 SimulateWheelEventPossiblyIncludingPhase( |
| 4770 !wheel_scroll_latching_enabled_, -10, -3, 0, true, |
| 4771 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
| 4772 SimulateWheelEventPossiblyIncludingPhase( |
| 4773 !wheel_scroll_latching_enabled_, -15, -1, 0, true, |
| 4774 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
| 4775 SimulateWheelEventPossiblyIncludingPhase( |
| 4776 !wheel_scroll_latching_enabled_, -30, -3, 0, true, |
| 4777 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
| 4778 |
4466 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4779 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4467 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4780 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4468 | 4781 |
4469 // Receive ACK the first wheel event as not processed. | 4782 // Receive ACK the first wheel event as not processed. |
4470 SendInputEventACK(WebInputEvent::kMouseWheel, | 4783 SendInputEventACK(WebInputEvent::kMouseWheel, |
4471 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4784 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4472 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 4785 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); |
4473 | 4786 |
4474 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4787 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4475 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4788 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4549 OverscrollMouseMoveCompletion) { | 4862 OverscrollMouseMoveCompletion) { |
4550 OverscrollMouseMoveCompletion(); | 4863 OverscrollMouseMoveCompletion(); |
4551 } | 4864 } |
4552 | 4865 |
4553 // Tests that if a page scrolled, then the overscroll controller's states are | 4866 // Tests that if a page scrolled, then the overscroll controller's states are |
4554 // reset after the end of the scroll. | 4867 // reset after the end of the scroll. |
4555 void RenderWidgetHostViewAuraOverscrollTest:: | 4868 void RenderWidgetHostViewAuraOverscrollTest:: |
4556 OverscrollStateResetsAfterScroll() { | 4869 OverscrollStateResetsAfterScroll() { |
4557 SetUpOverscrollEnvironment(); | 4870 SetUpOverscrollEnvironment(); |
4558 | 4871 |
4559 SimulateWheelEvent(0, 5, 0, true); // sent directly | 4872 SimulateWheelEventPossiblyIncludingPhase( |
4560 SimulateWheelEvent(0, 30, 0, true); // enqueued | 4873 !wheel_scroll_latching_enabled_, 0, 5, 0, true, |
4561 SimulateWheelEvent(0, 40, 0, true); // coalesced into previous event | 4874 WebMouseWheelEvent::kPhaseBegan); // sent directly |
4562 SimulateWheelEvent(0, 10, 0, true); // coalesced into previous event | 4875 SimulateWheelEventPossiblyIncludingPhase( |
| 4876 !wheel_scroll_latching_enabled_, 0, 30, 0, true, |
| 4877 WebMouseWheelEvent::kPhaseChanged); // enqueued |
| 4878 SimulateWheelEventPossiblyIncludingPhase( |
| 4879 !wheel_scroll_latching_enabled_, 0, 40, 0, true, |
| 4880 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
| 4881 SimulateWheelEventPossiblyIncludingPhase( |
| 4882 !wheel_scroll_latching_enabled_, 0, 10, 0, true, |
| 4883 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
4563 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4884 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4564 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4885 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4565 | 4886 |
4566 // The first wheel event is consumed. Dispatches the queued wheel event. | 4887 // The first wheel event is consumed. Dispatches the queued wheel event. |
4567 SendInputEventACK(WebInputEvent::kMouseWheel, | 4888 SendInputEventACK(WebInputEvent::kMouseWheel, |
4568 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4889 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4569 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 4890 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); |
4570 | 4891 |
4571 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4892 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4572 INPUT_EVENT_ACK_STATE_CONSUMED); | 4893 INPUT_EVENT_ACK_STATE_CONSUMED); |
4573 ExpectGestureScrollEndForWheelScrolling(false); | 4894 ExpectGestureScrollEndForWheelScrolling(false); |
4574 EXPECT_TRUE(ScrollStateIsContentScrolling()); | 4895 EXPECT_TRUE(ScrollStateIsContentScrolling()); |
4575 | 4896 |
4576 // The second wheel event is consumed. | 4897 // The second wheel event is consumed. |
4577 SendInputEventACK(WebInputEvent::kMouseWheel, | 4898 SendInputEventACK(WebInputEvent::kMouseWheel, |
4578 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4899 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4579 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4900 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
4580 | 4901 |
4581 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4902 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4582 INPUT_EVENT_ACK_STATE_CONSUMED); | 4903 INPUT_EVENT_ACK_STATE_CONSUMED); |
| 4904 |
| 4905 if (wheel_scroll_latching_enabled_) { |
| 4906 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); |
| 4907 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
| 4908 SendInputEventACK(WebInputEvent::kMouseWheel, |
| 4909 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 4910 } |
4583 ExpectGestureScrollEndForWheelScrolling(true); | 4911 ExpectGestureScrollEndForWheelScrolling(true); |
4584 EXPECT_TRUE(ScrollStateIsContentScrolling()); | 4912 EXPECT_TRUE(ScrollStateIsContentScrolling()); |
4585 | 4913 |
4586 // Touchpad scroll can end with a zero-velocity fling. But it is not | 4914 // Touchpad scroll can end with a zero-velocity fling. But it is not |
4587 // dispatched, but it should still reset the overscroll controller state. | 4915 // dispatched, but it should still reset the overscroll controller state. |
4588 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, | 4916 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, |
4589 blink::kWebGestureDeviceTouchscreen); | 4917 blink::kWebGestureDeviceTouchscreen); |
4590 SimulateGestureFlingStartEvent(0.f, 0.f, blink::kWebGestureDeviceTouchpad); | 4918 SimulateGestureFlingStartEvent(0.f, 0.f, blink::kWebGestureDeviceTouchpad); |
4591 EXPECT_TRUE(ScrollStateIsUnknown()); | 4919 EXPECT_TRUE(ScrollStateIsUnknown()); |
4592 // ScrollBegin will be queued events. | 4920 // ScrollBegin will be queued events. |
4593 EXPECT_EQ(1U, sink_->message_count()); | 4921 EXPECT_EQ(1U, sink_->message_count()); |
4594 | 4922 |
4595 // Dropped flings should neither propagate *nor* indicate that they were | 4923 // Dropped flings should neither propagate *nor* indicate that they were |
4596 // consumed and have triggered a fling animation (as tracked by the router). | 4924 // consumed and have triggered a fling animation (as tracked by the router). |
4597 EXPECT_FALSE(parent_host_->input_router()->HasPendingEvents()); | 4925 EXPECT_FALSE(parent_host_->input_router()->HasPendingEvents()); |
4598 | 4926 |
4599 SimulateGestureEvent(WebInputEvent::kGestureScrollEnd, | 4927 SimulateGestureEvent(WebInputEvent::kGestureScrollEnd, |
4600 blink::kWebGestureDeviceTouchscreen); | 4928 blink::kWebGestureDeviceTouchscreen); |
4601 // ScrollBegin, and ScrollEnd will be queued events. | 4929 // ScrollBegin, and ScrollEnd will be queued events. |
4602 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); | 4930 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); |
4603 | 4931 |
4604 SimulateWheelEvent(-5, 0, 0, true); // sent directly | 4932 SimulateWheelEventPossiblyIncludingPhase( |
4605 SimulateWheelEvent(-60, 0, 0, true); // enqueued | 4933 !wheel_scroll_latching_enabled_, -5, 0, 0, true, |
4606 SimulateWheelEvent(-100, 0, 0, true); // coalesced into previous event | 4934 WebMouseWheelEvent::kPhaseBegan); // sent directly |
| 4935 SimulateWheelEventPossiblyIncludingPhase( |
| 4936 !wheel_scroll_latching_enabled_, -60, 0, 0, true, |
| 4937 WebMouseWheelEvent::kPhaseChanged); // enqueued |
| 4938 SimulateWheelEventPossiblyIncludingPhase( |
| 4939 !wheel_scroll_latching_enabled_, -100, 0, 0, true, |
| 4940 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
| 4941 |
4607 EXPECT_TRUE(ScrollStateIsUnknown()); | 4942 EXPECT_TRUE(ScrollStateIsUnknown()); |
4608 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4943 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4609 | 4944 |
4610 // The first wheel scroll did not scroll content. Overscroll should not start | 4945 // The first wheel scroll did not scroll content. Overscroll should not start |
4611 // yet, since enough hasn't been scrolled. | 4946 // yet, since enough hasn't been scrolled. |
4612 SendInputEventACK(WebInputEvent::kMouseWheel, | 4947 SendInputEventACK(WebInputEvent::kMouseWheel, |
4613 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4948 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4614 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 4949 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); |
4615 | 4950 |
4616 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4951 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4617 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4952 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4618 ExpectGestureScrollEndForWheelScrolling(false); | 4953 ExpectGestureScrollEndForWheelScrolling(false); |
4619 EXPECT_TRUE(ScrollStateIsUnknown()); | 4954 EXPECT_TRUE(ScrollStateIsUnknown()); |
4620 | 4955 |
4621 SendInputEventACK(WebInputEvent::kMouseWheel, | 4956 SendInputEventACK(WebInputEvent::kMouseWheel, |
4622 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4957 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4623 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4958 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); |
4624 | 4959 |
4625 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4960 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4626 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4961 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 4962 |
| 4963 if (wheel_scroll_latching_enabled_) { |
| 4964 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); |
| 4965 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
| 4966 SendInputEventACK(WebInputEvent::kMouseWheel, |
| 4967 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
| 4968 } |
| 4969 |
4627 ExpectGestureScrollEndForWheelScrolling(true); | 4970 ExpectGestureScrollEndForWheelScrolling(true); |
4628 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); | 4971 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); |
4629 EXPECT_TRUE(ScrollStateIsOverscrolling()); | 4972 EXPECT_TRUE(ScrollStateIsOverscrolling()); |
4630 | 4973 |
4631 // The GestureScrollBegin will reset the delegate's mode, so check it here. | 4974 // The GestureScrollBegin will reset the delegate's mode, so check it here. |
4632 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); | 4975 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); |
4633 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, | 4976 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, |
4634 blink::kWebGestureDeviceTouchscreen); | 4977 blink::kWebGestureDeviceTouchscreen); |
4635 SimulateGestureFlingStartEvent(0.f, 0.f, blink::kWebGestureDeviceTouchpad); | 4978 SimulateGestureFlingStartEvent(0.f, 0.f, blink::kWebGestureDeviceTouchpad); |
4636 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4979 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. | 5890 // There is no composition in the beginning. |
5548 EXPECT_FALSE(has_composition_text()); | 5891 EXPECT_FALSE(has_composition_text()); |
5549 SetHasCompositionTextToTrue(); | 5892 SetHasCompositionTextToTrue(); |
5550 view->ImeCancelComposition(); | 5893 view->ImeCancelComposition(); |
5551 // The composition must have been canceled. | 5894 // The composition must have been canceled. |
5552 EXPECT_FALSE(has_composition_text()); | 5895 EXPECT_FALSE(has_composition_text()); |
5553 } | 5896 } |
5554 } | 5897 } |
5555 | 5898 |
5556 } // namespace content | 5899 } // namespace content |
OLD | NEW |