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 557 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
568 | 568 |
569 const WebInputEvent* GetInputEventFromMessage(const IPC::Message& message) { | 569 const WebInputEvent* GetInputEventFromMessage(const IPC::Message& message) { |
570 base::PickleIterator iter(message); | 570 base::PickleIterator iter(message); |
571 const char* data; | 571 const char* data; |
572 int data_length; | 572 int data_length; |
573 if (!iter.ReadData(&data, &data_length)) | 573 if (!iter.ReadData(&data, &data_length)) |
574 return nullptr; | 574 return nullptr; |
575 return reinterpret_cast<const WebInputEvent*>(data); | 575 return reinterpret_cast<const WebInputEvent*>(data); |
576 } | 576 } |
577 | 577 |
578 enum WheelScrollingMode { | |
579 kWheelScrollingModeNone, | |
580 kWheelScrollLatching, | |
581 kAsyncWheelEvents, | |
582 }; | |
583 | |
578 } // namespace | 584 } // namespace |
579 | 585 |
580 class RenderWidgetHostViewAuraTest : public testing::Test { | 586 class RenderWidgetHostViewAuraTest : public testing::Test { |
581 public: | 587 public: |
582 RenderWidgetHostViewAuraTest() | 588 RenderWidgetHostViewAuraTest() |
583 : widget_host_uses_shutdown_to_destroy_(false), | 589 : widget_host_uses_shutdown_to_destroy_(false), |
584 is_guest_view_hack_(false) {} | 590 is_guest_view_hack_(false) {} |
585 | 591 |
586 static void InstallDelegatedFrameHostClient( | 592 static void InstallDelegatedFrameHostClient( |
587 RenderWidgetHostViewAura* render_widget_host_view, | 593 RenderWidgetHostViewAura* render_widget_host_view, |
(...skipping 147 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
735 void EnableWheelScrollLatching() { | 741 void EnableWheelScrollLatching() { |
736 feature_list_.InitFromCommandLine( | 742 feature_list_.InitFromCommandLine( |
737 features::kTouchpadAndWheelScrollLatching.name, ""); | 743 features::kTouchpadAndWheelScrollLatching.name, ""); |
738 } | 744 } |
739 | 745 |
740 void DisableWheelScrollLatching() { | 746 void DisableWheelScrollLatching() { |
741 feature_list_.InitFromCommandLine( | 747 feature_list_.InitFromCommandLine( |
742 "", features::kTouchpadAndWheelScrollLatching.name); | 748 "", features::kTouchpadAndWheelScrollLatching.name); |
743 } | 749 } |
744 | 750 |
745 void SetFeatureList(bool raf_aligned_touch, bool wheel_scroll_latching) { | 751 void SetFeatureList( |
746 if (raf_aligned_touch && wheel_scroll_latching) { | 752 bool raf_aligned_touch, |
753 WheelScrollingMode wheel_scrolling_mode = kWheelScrollLatching) { | |
754 if (raf_aligned_touch && wheel_scrolling_mode == kAsyncWheelEvents) { | |
755 feature_list_.InitWithFeatures({features::kRafAlignedTouchInputEvents, | |
756 features::kTouchpadAndWheelScrollLatching, | |
757 features::kAsyncWheelEvents}, | |
758 {}); | |
759 } else if (raf_aligned_touch && | |
760 wheel_scrolling_mode == kWheelScrollLatching) { | |
747 feature_list_.InitWithFeatures( | 761 feature_list_.InitWithFeatures( |
748 {features::kRafAlignedTouchInputEvents, | 762 {features::kRafAlignedTouchInputEvents, |
749 features::kTouchpadAndWheelScrollLatching}, | 763 features::kTouchpadAndWheelScrollLatching}, |
750 {}); | 764 {features::kAsyncWheelEvents}); |
751 } else if (raf_aligned_touch && !wheel_scroll_latching) { | 765 } else if (raf_aligned_touch && |
752 feature_list_.InitWithFeatures( | 766 wheel_scrolling_mode == kWheelScrollingModeNone) { |
753 {features::kRafAlignedTouchInputEvents}, | 767 feature_list_.InitWithFeatures({features::kRafAlignedTouchInputEvents}, |
754 {features::kTouchpadAndWheelScrollLatching}); | 768 {features::kTouchpadAndWheelScrollLatching, |
755 } else if (!raf_aligned_touch && wheel_scroll_latching) { | 769 features::kAsyncWheelEvents}); |
770 } else if (!raf_aligned_touch && | |
771 wheel_scrolling_mode == kAsyncWheelEvents) { | |
772 feature_list_.InitWithFeatures({features::kTouchpadAndWheelScrollLatching, | |
773 features::kAsyncWheelEvents}, | |
774 {features::kRafAlignedTouchInputEvents}); | |
775 } else if (!raf_aligned_touch && | |
776 wheel_scrolling_mode == kWheelScrollLatching) { | |
756 feature_list_.InitWithFeatures( | 777 feature_list_.InitWithFeatures( |
757 {features::kTouchpadAndWheelScrollLatching}, | 778 {features::kTouchpadAndWheelScrollLatching}, |
758 {features::kRafAlignedTouchInputEvents}); | 779 {features::kRafAlignedTouchInputEvents, features::kAsyncWheelEvents}); |
759 } else { // !raf_aligned_touch && !wheel_scroll_latching | 780 } else { // !raf_aligned_touch && wheel_scroll_latching == |
760 feature_list_.InitWithFeatures( | 781 // kWheelScrollingModeNone. |
761 {}, {features::kRafAlignedTouchInputEvents, | 782 feature_list_.InitWithFeatures({}, |
762 features::kTouchpadAndWheelScrollLatching}); | 783 {features::kRafAlignedTouchInputEvents, |
784 features::kTouchpadAndWheelScrollLatching, | |
785 features::kAsyncWheelEvents}); | |
763 } | 786 } |
764 } | 787 } |
765 | 788 |
766 protected: | 789 protected: |
767 BrowserContext* browser_context() { return browser_context_.get(); } | 790 BrowserContext* browser_context() { return browser_context_.get(); } |
768 | 791 |
769 MockRenderWidgetHostDelegate* render_widget_host_delegate() const { | 792 MockRenderWidgetHostDelegate* render_widget_host_delegate() const { |
770 return delegates_.back().get(); | 793 return delegates_.back().get(); |
771 } | 794 } |
772 | 795 |
(...skipping 125 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
898 | 921 |
899 private: | 922 private: |
900 | 923 |
901 DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewGuestAuraTest); | 924 DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewGuestAuraTest); |
902 }; | 925 }; |
903 | 926 |
904 class RenderWidgetHostViewAuraOverscrollTest | 927 class RenderWidgetHostViewAuraOverscrollTest |
905 : public RenderWidgetHostViewAuraTest { | 928 : public RenderWidgetHostViewAuraTest { |
906 public: | 929 public: |
907 RenderWidgetHostViewAuraOverscrollTest( | 930 RenderWidgetHostViewAuraOverscrollTest( |
908 bool wheel_scroll_latching_enabled = true) | 931 WheelScrollingMode wheel_scrolling_mode = kWheelScrollLatching) |
909 : wheel_scroll_latching_enabled_(wheel_scroll_latching_enabled) {} | 932 : wheel_scroll_latching_enabled_(wheel_scrolling_mode != |
933 kWheelScrollingModeNone), | |
934 wheel_scrolling_mode_(wheel_scrolling_mode) {} | |
910 | 935 |
911 // We explicitly invoke SetUp to allow gesture debounce customization. | 936 // We explicitly invoke SetUp to allow gesture debounce customization. |
912 void SetUp() override {} | 937 void SetUp() override {} |
913 | 938 |
914 protected: | 939 protected: |
915 void SetUpOverscrollEnvironmentWithDebounce(int debounce_interval_in_ms) { | 940 void SetUpOverscrollEnvironmentWithDebounce(int debounce_interval_in_ms) { |
916 SetUpOverscrollEnvironmentImpl(debounce_interval_in_ms); | 941 SetUpOverscrollEnvironmentImpl(debounce_interval_in_ms); |
917 } | 942 } |
918 | 943 |
919 void SetUpOverscrollEnvironment() { SetUpOverscrollEnvironmentImpl(0); } | 944 void SetUpOverscrollEnvironment() { SetUpOverscrollEnvironmentImpl(0); } |
920 | 945 |
921 void SetUpOverscrollEnvironmentImpl(int debounce_interval_in_ms) { | 946 void SetUpOverscrollEnvironmentImpl(int debounce_interval_in_ms) { |
922 SetFeatureList(true, wheel_scroll_latching_enabled_); | 947 SetFeatureList(true, wheel_scrolling_mode_); |
923 ui::GestureConfiguration::GetInstance()->set_scroll_debounce_interval_in_ms( | 948 ui::GestureConfiguration::GetInstance()->set_scroll_debounce_interval_in_ms( |
924 debounce_interval_in_ms); | 949 debounce_interval_in_ms); |
925 | 950 |
926 RenderWidgetHostViewAuraTest::SetUp(); | 951 RenderWidgetHostViewAuraTest::SetUp(); |
927 | 952 |
928 view_->SetOverscrollControllerEnabled(true); | 953 view_->SetOverscrollControllerEnabled(true); |
929 overscroll_delegate_.reset(new TestOverscrollDelegate(view_)); | 954 overscroll_delegate_.reset(new TestOverscrollDelegate(view_)); |
930 view_->overscroll_controller()->set_delegate(overscroll_delegate_.get()); | 955 view_->overscroll_controller()->set_delegate(overscroll_delegate_.get()); |
931 | 956 |
932 view_->InitAsChild(nullptr); | 957 view_->InitAsChild(nullptr); |
(...skipping 185 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1118 | 1143 |
1119 EXPECT_EQ(1U, sink_->message_count()); | 1144 EXPECT_EQ(1U, sink_->message_count()); |
1120 InputMsg_HandleInputEvent::Param params; | 1145 InputMsg_HandleInputEvent::Param params; |
1121 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(0), ¶ms)) { | 1146 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(0), ¶ms)) { |
1122 const blink::WebInputEvent* event = std::get<0>(params); | 1147 const blink::WebInputEvent* event = std::get<0>(params); |
1123 EXPECT_EQ(WebInputEvent::kGestureScrollEnd, event->GetType()); | 1148 EXPECT_EQ(WebInputEvent::kGestureScrollEnd, event->GetType()); |
1124 } | 1149 } |
1125 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 1150 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
1126 } | 1151 } |
1127 | 1152 |
1128 void ExpectGestureScrollEventsAfterMouseWheelACK(bool is_first_ack, | 1153 void ExpectGestureScrollEventsAfterMouseWheelACK( |
1129 bool enqueued_mouse_wheel) { | 1154 bool is_first_ack, |
1155 size_t enqueued_wheel_event_count) { | |
1130 InputMsg_HandleInputEvent::Param params; | 1156 InputMsg_HandleInputEvent::Param params; |
1131 const blink::WebInputEvent* event; | 1157 const blink::WebInputEvent* event; |
1132 size_t expected_message_count; | 1158 size_t expected_message_count; |
1133 if (is_first_ack) { | 1159 if (is_first_ack) { |
1134 expected_message_count = enqueued_mouse_wheel ? 3 : 2; | 1160 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
1161 expected_message_count = enqueued_wheel_event_count + 2; | |
dtapuska
2017/06/20 20:53:14
Can we add some more comments here? These seem mag
sahel
2017/06/21 18:09:59
Done.
| |
1162 } else { | |
1163 // Regardless of the number of enqueued wheel events, only one wheel | |
1164 // event will be sent if the wheel events are blocking. | |
1165 expected_message_count = enqueued_wheel_event_count ? 3 : 2; | |
1166 } | |
1167 | |
1135 EXPECT_EQ(expected_message_count, sink_->message_count()); | 1168 EXPECT_EQ(expected_message_count, sink_->message_count()); |
1136 | 1169 |
1137 // The first message is GestureScrollBegin. | 1170 // The first message is GestureScrollBegin. |
1138 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(0), ¶ms)) { | 1171 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(0), ¶ms)) { |
1139 event = std::get<0>(params); | 1172 event = std::get<0>(params); |
1140 EXPECT_EQ(WebInputEvent::kGestureScrollBegin, event->GetType()); | 1173 EXPECT_EQ(WebInputEvent::kGestureScrollBegin, event->GetType()); |
1141 } | 1174 } |
1142 | 1175 |
1143 // The second message is GestureScrollUpdate. | 1176 // The second message is GestureScrollUpdate. |
1144 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(1), ¶ms)) { | 1177 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(1), ¶ms)) { |
1145 event = std::get<0>(params); | 1178 event = std::get<0>(params); |
1146 EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, event->GetType()); | 1179 EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, event->GetType()); |
1147 } | 1180 } |
1148 | 1181 |
1149 if (enqueued_mouse_wheel) { | 1182 for (size_t i = 2; i < expected_message_count; i++) { |
1150 // The last message is the queued MouseWheel. | 1183 // The last messages are the queued MouseWheel event(s). |
1151 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(2), ¶ms)) { | 1184 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(i), ¶ms)) { |
1152 event = std::get<0>(params); | 1185 event = std::get<0>(params); |
1153 EXPECT_EQ(WebInputEvent::kMouseWheel, event->GetType()); | 1186 EXPECT_EQ(WebInputEvent::kMouseWheel, event->GetType()); |
1154 } | 1187 } |
1155 } | 1188 } |
1156 } else { // !is_first_ack | 1189 } else { // !is_first_ack |
1157 expected_message_count = enqueued_mouse_wheel ? 2 : 1; | 1190 expected_message_count = enqueued_wheel_event_count ? 2 : 1; |
1158 size_t scroll_update_index = 0; | 1191 size_t scroll_update_index = 0; |
1159 | 1192 |
1160 if (!wheel_scroll_latching_enabled_) { | 1193 if (!wheel_scroll_latching_enabled_) { |
1161 // The first message is GestureScrollBegin even in the middle of | 1194 // The first message is GestureScrollBegin even in the middle of |
1162 // scrolling. | 1195 // scrolling. |
1163 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(0), ¶ms)) { | 1196 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(0), ¶ms)) { |
1164 event = std::get<0>(params); | 1197 event = std::get<0>(params); |
1165 EXPECT_EQ(WebInputEvent::kGestureScrollBegin, event->GetType()); | 1198 EXPECT_EQ(WebInputEvent::kGestureScrollBegin, event->GetType()); |
1166 } | 1199 } |
1167 expected_message_count++; | 1200 expected_message_count++; |
1168 scroll_update_index++; | 1201 scroll_update_index++; |
1169 } | 1202 } |
1170 | 1203 |
1171 // Check the GestureScrollUpdate message. | 1204 // Check the GestureScrollUpdate message. |
1172 if (InputMsg_HandleInputEvent::Read( | 1205 if (InputMsg_HandleInputEvent::Read( |
1173 sink_->GetMessageAt(scroll_update_index), ¶ms)) { | 1206 sink_->GetMessageAt(scroll_update_index), ¶ms)) { |
1174 event = std::get<0>(params); | 1207 event = std::get<0>(params); |
1175 EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, event->GetType()); | 1208 EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, event->GetType()); |
1176 } | 1209 } |
1177 | 1210 |
1178 if (enqueued_mouse_wheel) { | 1211 if (enqueued_wheel_event_count) { |
1179 // The last message is the queued MouseWheel. | 1212 // The last message is the queued MouseWheel. |
1180 if (InputMsg_HandleInputEvent::Read( | 1213 if (InputMsg_HandleInputEvent::Read( |
1181 sink_->GetMessageAt(expected_message_count - 1), ¶ms)) { | 1214 sink_->GetMessageAt(expected_message_count - 1), ¶ms)) { |
1182 event = std::get<0>(params); | 1215 event = std::get<0>(params); |
1183 EXPECT_EQ(WebInputEvent::kMouseWheel, event->GetType()); | 1216 EXPECT_EQ(WebInputEvent::kMouseWheel, event->GetType()); |
1184 } | 1217 } |
1185 } | 1218 } |
1186 } | 1219 } |
1187 EXPECT_EQ(expected_message_count, GetSentMessageCountAndResetSink()); | 1220 EXPECT_EQ(expected_message_count, GetSentMessageCountAndResetSink()); |
1188 } | 1221 } |
1189 | 1222 |
1223 void ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK( | |
1224 bool wheel_was_queued) { | |
1225 size_t gesture_scroll_update_index; | |
1226 InputMsg_HandleInputEvent::Param params; | |
1227 if (wheel_was_queued) { | |
1228 // The queued wheel event is already sent. | |
1229 gesture_scroll_update_index = 0; | |
1230 } else { | |
1231 // The first sent must be the wheel event and the second one must be | |
1232 // GestureScrollUpdate since the ack for the wheel event is non-blocking. | |
1233 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(0), ¶ms)) { | |
1234 EXPECT_EQ(WebInputEvent::kMouseWheel, (std::get<0>(params))->GetType()); | |
1235 } | |
1236 gesture_scroll_update_index = 1; | |
1237 } | |
1238 if (InputMsg_HandleInputEvent::Read( | |
1239 sink_->GetMessageAt(gesture_scroll_update_index), ¶ms)) { | |
1240 EXPECT_EQ(WebInputEvent::kGestureScrollUpdate, | |
1241 (std::get<0>(params))->GetType()); | |
1242 } | |
1243 EXPECT_EQ(gesture_scroll_update_index + 1, | |
1244 GetSentMessageCountAndResetSink()); | |
1245 } | |
1246 | |
1247 void ExpectGestureScrollEndAfterNonBlockingMouseWheelACK() { | |
1248 InputMsg_HandleInputEvent::Param params; | |
1249 // The first sent must be the wheel event and the second one must be | |
1250 // GestureScrollEnd since the ack for the wheel event is non-blocking. | |
1251 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(0), ¶ms)) { | |
1252 EXPECT_EQ(WebInputEvent::kMouseWheel, (std::get<0>(params))->GetType()); | |
1253 } | |
1254 | |
1255 if (InputMsg_HandleInputEvent::Read(sink_->GetMessageAt(1), ¶ms)) { | |
1256 EXPECT_EQ(WebInputEvent::kGestureScrollEnd, | |
1257 (std::get<0>(params))->GetType()); | |
1258 } | |
1259 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); | |
1260 } | |
1261 | |
1190 void WheelNotPreciseScrollEvent(); | 1262 void WheelNotPreciseScrollEvent(); |
1191 void WheelScrollOverscrollToggle(); | 1263 void WheelScrollOverscrollToggle(); |
1192 void OverscrollMouseMoveCompletion(); | 1264 void OverscrollMouseMoveCompletion(); |
1193 void WheelScrollEventOverscrolls(); | 1265 void WheelScrollEventOverscrolls(); |
1194 void WheelScrollConsumedDoNotHorizOverscroll(); | 1266 void WheelScrollConsumedDoNotHorizOverscroll(); |
1195 void ScrollEventsOverscrollWithFling(); | 1267 void ScrollEventsOverscrollWithFling(); |
1196 void OverscrollDirectionChangeMouseWheel(); | 1268 void OverscrollDirectionChangeMouseWheel(); |
1197 void OverscrollStateResetsAfterScroll(); | 1269 void OverscrollStateResetsAfterScroll(); |
1270 void ScrollDeltasResetOnEnd(); | |
1198 void ScrollEventsOverscrollWithZeroFling(); | 1271 void ScrollEventsOverscrollWithZeroFling(); |
1199 | 1272 |
1200 SyntheticWebTouchEvent touch_event_; | 1273 SyntheticWebTouchEvent touch_event_; |
1201 | 1274 |
1202 std::unique_ptr<TestOverscrollDelegate> overscroll_delegate_; | 1275 std::unique_ptr<TestOverscrollDelegate> overscroll_delegate_; |
1203 | 1276 |
1204 bool wheel_scroll_latching_enabled_; | 1277 bool wheel_scroll_latching_enabled_; |
1278 WheelScrollingMode wheel_scrolling_mode_; | |
1205 | 1279 |
1206 private: | 1280 private: |
1207 DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAuraOverscrollTest); | 1281 DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAuraOverscrollTest); |
1208 }; | 1282 }; |
1209 | 1283 |
1210 class RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest | 1284 class RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest |
1211 : public RenderWidgetHostViewAuraOverscrollTest { | 1285 : public RenderWidgetHostViewAuraOverscrollTest { |
1212 public: | 1286 public: |
1213 RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest() | 1287 RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest() |
1214 : RenderWidgetHostViewAuraOverscrollTest(false) {} | 1288 : RenderWidgetHostViewAuraOverscrollTest(kWheelScrollingModeNone) {} |
1289 }; | |
1290 | |
1291 class RenderWidgetHostViewAuraOverScrollAsyncWheelEventsEnabledTest | |
1292 : public RenderWidgetHostViewAuraOverscrollTest { | |
1293 public: | |
1294 RenderWidgetHostViewAuraOverScrollAsyncWheelEventsEnabledTest() | |
1295 : RenderWidgetHostViewAuraOverscrollTest(kAsyncWheelEvents) {} | |
1215 }; | 1296 }; |
1216 | 1297 |
1217 class RenderWidgetHostViewAuraShutdownTest | 1298 class RenderWidgetHostViewAuraShutdownTest |
1218 : public RenderWidgetHostViewAuraTest { | 1299 : public RenderWidgetHostViewAuraTest { |
1219 public: | 1300 public: |
1220 RenderWidgetHostViewAuraShutdownTest() {} | 1301 RenderWidgetHostViewAuraShutdownTest() {} |
1221 | 1302 |
1222 void TearDown() override { | 1303 void TearDown() override { |
1223 // No TearDownEnvironment here, we do this explicitly during the test. | 1304 // No TearDownEnvironment here, we do this explicitly during the test. |
1224 } | 1305 } |
(...skipping 2487 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3712 WebMouseWheelEvent::kPhaseBegan); // sent directly | 3793 WebMouseWheelEvent::kPhaseBegan); // sent directly |
3713 SimulateWheelEventPossiblyIncludingPhase( | 3794 SimulateWheelEventPossiblyIncludingPhase( |
3714 !wheel_scroll_latching_enabled_, -60, 1, 0, false, | 3795 !wheel_scroll_latching_enabled_, -60, 1, 0, false, |
3715 WebMouseWheelEvent::kPhaseChanged); // enqueued | 3796 WebMouseWheelEvent::kPhaseChanged); // enqueued |
3716 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3797 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3717 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 3798 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3718 | 3799 |
3719 // Receive ACK the first wheel event as not processed. | 3800 // Receive ACK the first wheel event as not processed. |
3720 SendInputEventACK(WebInputEvent::kMouseWheel, | 3801 SendInputEventACK(WebInputEvent::kMouseWheel, |
3721 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3802 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3722 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 3803 ExpectGestureScrollEventsAfterMouseWheelACK(true, 1); |
3723 | 3804 |
3724 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3805 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3725 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3806 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3726 ExpectGestureScrollEndForWheelScrolling(false); | |
3727 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3807 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3728 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 3808 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3729 | 3809 |
3730 SendInputEventACK(WebInputEvent::kMouseWheel, | 3810 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
3731 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3811 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(true); |
3732 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 3812 } else { |
3813 ExpectGestureScrollEndForWheelScrolling(false); | |
3814 SendInputEventACK(WebInputEvent::kMouseWheel, | |
3815 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
3816 ExpectGestureScrollEventsAfterMouseWheelACK(false, 0); | |
3817 } | |
3733 | 3818 |
3734 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3819 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3735 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3820 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3736 if (wheel_scroll_latching_enabled_) { | 3821 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
3737 SimulateWheelEventWithPhase(0, 0, 0, false, | 3822 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); |
3738 WebMouseWheelEvent::kPhaseEnded); | 3823 ExpectGestureScrollEndAfterNonBlockingMouseWheelACK(); |
3824 } else if (wheel_scroll_latching_enabled_) { | |
3825 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); | |
3739 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 3826 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3740 SendInputEventACK(WebInputEvent::kMouseWheel, | 3827 SendInputEventACK(WebInputEvent::kMouseWheel, |
3741 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3828 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3829 ExpectGestureScrollEndForWheelScrolling(true); | |
3830 } else { | |
3831 ExpectGestureScrollEndForWheelScrolling(true); | |
3742 } | 3832 } |
3743 ExpectGestureScrollEndForWheelScrolling(true); | |
3744 | 3833 |
3745 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3834 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3746 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 3835 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3747 } | 3836 } |
3748 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelNotPreciseScrollEvent) { | 3837 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelNotPreciseScrollEvent) { |
3749 WheelNotPreciseScrollEvent(); | 3838 WheelNotPreciseScrollEvent(); |
3750 } | 3839 } |
3751 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 3840 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
3752 WheelNotPreciseScrollEvent) { | 3841 WheelNotPreciseScrollEvent) { |
3753 WheelNotPreciseScrollEvent(); | 3842 WheelNotPreciseScrollEvent(); |
3754 } | 3843 } |
3844 TEST_F(RenderWidgetHostViewAuraOverScrollAsyncWheelEventsEnabledTest, | |
3845 WheelNotPreciseScrollEvent) { | |
3846 WheelNotPreciseScrollEvent(); | |
3847 } | |
3755 | 3848 |
3756 void RenderWidgetHostViewAuraOverscrollTest::WheelScrollEventOverscrolls() { | 3849 void RenderWidgetHostViewAuraOverscrollTest::WheelScrollEventOverscrolls() { |
3757 SetUpOverscrollEnvironment(); | 3850 SetUpOverscrollEnvironment(); |
3758 | 3851 |
3759 // Simulate wheel events. | 3852 // Simulate wheel events. |
3760 SimulateWheelEventPossiblyIncludingPhase( | 3853 SimulateWheelEventPossiblyIncludingPhase( |
3761 !wheel_scroll_latching_enabled_, -5, 0, 0, true, | 3854 !wheel_scroll_latching_enabled_, -5, 0, 0, true, |
3762 WebMouseWheelEvent::kPhaseBegan); // sent directly | 3855 WebMouseWheelEvent::kPhaseBegan); // sent directly |
3763 SimulateWheelEventPossiblyIncludingPhase( | 3856 SimulateWheelEventPossiblyIncludingPhase( |
3764 !wheel_scroll_latching_enabled_, -1, 1, 0, true, | 3857 !wheel_scroll_latching_enabled_, -1, 1, 0, true, |
3765 WebMouseWheelEvent::kPhaseChanged); // enqueued | 3858 WebMouseWheelEvent::kPhaseChanged); // enqueued |
3766 SimulateWheelEventPossiblyIncludingPhase( | 3859 SimulateWheelEventPossiblyIncludingPhase( |
3767 !wheel_scroll_latching_enabled_, -10, -3, 0, true, | 3860 !wheel_scroll_latching_enabled_, -10, -3, 0, true, |
3768 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | 3861 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
3769 SimulateWheelEventPossiblyIncludingPhase( | 3862 SimulateWheelEventPossiblyIncludingPhase( |
3770 !wheel_scroll_latching_enabled_, -15, -1, 0, true, | 3863 !wheel_scroll_latching_enabled_, -15, -1, 0, true, |
3771 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | 3864 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
3772 SimulateWheelEventPossiblyIncludingPhase( | 3865 SimulateWheelEventPossiblyIncludingPhase( |
3773 !wheel_scroll_latching_enabled_, -30, -3, 0, true, | 3866 !wheel_scroll_latching_enabled_, -30, -3, 0, true, |
3774 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | 3867 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
3775 SimulateWheelEventPossiblyIncludingPhase( | 3868 SimulateWheelEventPossiblyIncludingPhase( |
3776 !wheel_scroll_latching_enabled_, -20, 6, 1, true, | 3869 !wheel_scroll_latching_enabled_, -20, 6, 1, true, |
3777 WebMouseWheelEvent::kPhaseChanged); // enqueued, different modifiers | 3870 WebMouseWheelEvent::kPhaseChanged); // enqueued, different modifiers |
3778 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3871 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3779 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 3872 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3780 | 3873 |
3781 // Receive ACK the first wheel event as not processed. | 3874 // Receive ACK the first wheel event as not processed. |
3782 SendInputEventACK(WebInputEvent::kMouseWheel, | 3875 SendInputEventACK(WebInputEvent::kMouseWheel, |
3783 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3876 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3784 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 3877 ExpectGestureScrollEventsAfterMouseWheelACK(true, 2); |
3785 | 3878 |
3786 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3879 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3787 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3880 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3788 ExpectGestureScrollEndForWheelScrolling(false); | |
3789 | 3881 |
3790 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3882 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3791 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 3883 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3792 | 3884 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
3793 // Receive ACK for the second (coalesced) event as not processed. This will | 3885 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(true); |
3794 // start a back navigation. However, this will also cause the queued next | 3886 } else { |
3795 // event to be sent to the renderer. But since overscroll navigation has | 3887 ExpectGestureScrollEndForWheelScrolling(false); |
3796 // started, that event will also be included in the overscroll computation | 3888 // Receive ACK for the second (coalesced) event as not processed. This will |
3797 // instead of being sent to the renderer. So the result will be an overscroll | 3889 // start a back navigation. However, this will also cause the queued next |
3798 // back navigation, and no ScrollUpdate event will be sent to the renderer. | 3890 // event to be sent to the renderer. But since overscroll navigation has |
3799 SendInputEventACK(WebInputEvent::kMouseWheel, | 3891 // started, that event will also be included in the overscroll computation |
3800 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3892 // instead of being sent to the renderer. So the result will be an |
3801 ExpectGestureScrollEventsAfterMouseWheelACK(false, true); | 3893 // overscroll back navigation, and no ScrollUpdate event will be sent to the |
3802 | 3894 // renderer. |
3895 SendInputEventACK(WebInputEvent::kMouseWheel, | |
3896 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
3897 ExpectGestureScrollEventsAfterMouseWheelACK(false, 1); | |
3898 } | |
3803 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 3899 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3804 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3900 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3805 ExpectGestureScrollEndForWheelScrolling(false); | 3901 ExpectGestureScrollEndForWheelScrolling(false); |
3806 | 3902 |
3807 SendInputEventACK(WebInputEvent::kMouseWheel, | 3903 SendInputEventACK(WebInputEvent::kMouseWheel, |
3808 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3904 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3809 if (wheel_scroll_latching_enabled_) { | 3905 if (wheel_scroll_latching_enabled_) { |
3810 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); | 3906 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); |
3811 } else { | 3907 } else { |
3812 // ScrollBegin and ScrollEnd will be queued events. | 3908 // ScrollBegin and ScrollEnd will be queued events. |
(...skipping 13 matching lines...) Expand all Loading... | |
3826 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 3922 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3827 EXPECT_EQ(1U, sink_->message_count()); | 3923 EXPECT_EQ(1U, sink_->message_count()); |
3828 } | 3924 } |
3829 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelScrollEventOverscrolls) { | 3925 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelScrollEventOverscrolls) { |
3830 WheelScrollEventOverscrolls(); | 3926 WheelScrollEventOverscrolls(); |
3831 } | 3927 } |
3832 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 3928 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
3833 WheelScrollEventOverscrolls) { | 3929 WheelScrollEventOverscrolls) { |
3834 WheelScrollEventOverscrolls(); | 3930 WheelScrollEventOverscrolls(); |
3835 } | 3931 } |
3932 TEST_F(RenderWidgetHostViewAuraOverScrollAsyncWheelEventsEnabledTest, | |
3933 WheelScrollEventOverscrolls) { | |
3934 WheelScrollEventOverscrolls(); | |
3935 } | |
3836 | 3936 |
3837 // Tests that if some scroll events are consumed towards the start, then | 3937 // Tests that if some scroll events are consumed towards the start, then |
3838 // subsequent scrolls do not horizontal overscroll. | 3938 // subsequent scrolls do not horizontal overscroll. |
3839 void RenderWidgetHostViewAuraOverscrollTest:: | 3939 void RenderWidgetHostViewAuraOverscrollTest:: |
3840 WheelScrollConsumedDoNotHorizOverscroll() { | 3940 WheelScrollConsumedDoNotHorizOverscroll() { |
3841 SetUpOverscrollEnvironment(); | 3941 SetUpOverscrollEnvironment(); |
3842 | 3942 |
3843 // Simulate wheel events. | 3943 // Simulate wheel events. |
3844 SimulateWheelEventPossiblyIncludingPhase( | 3944 SimulateWheelEventPossiblyIncludingPhase( |
3845 !wheel_scroll_latching_enabled_, -5, 0, 0, true, | 3945 !wheel_scroll_latching_enabled_, -5, 0, 0, true, |
(...skipping 13 matching lines...) Expand all Loading... | |
3859 SimulateWheelEventPossiblyIncludingPhase( | 3959 SimulateWheelEventPossiblyIncludingPhase( |
3860 !wheel_scroll_latching_enabled_, -20, 6, 1, true, | 3960 !wheel_scroll_latching_enabled_, -20, 6, 1, true, |
3861 WebMouseWheelEvent::kPhaseChanged); // enqueued, different modifiers | 3961 WebMouseWheelEvent::kPhaseChanged); // enqueued, different modifiers |
3862 | 3962 |
3863 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3963 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3864 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 3964 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3865 | 3965 |
3866 // Receive ACK the first wheel event as processed. | 3966 // Receive ACK the first wheel event as processed. |
3867 SendInputEventACK(WebInputEvent::kMouseWheel, | 3967 SendInputEventACK(WebInputEvent::kMouseWheel, |
3868 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3968 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3869 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 3969 ExpectGestureScrollEventsAfterMouseWheelACK(true, 2); |
3870 | |
3871 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | |
3872 INPUT_EVENT_ACK_STATE_CONSUMED); | |
3873 ExpectGestureScrollEndForWheelScrolling(false); | |
3874 | 3970 |
3875 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3971 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3876 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 3972 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3877 | 3973 |
3878 // Receive ACK for the second (coalesced) event as not processed. This should | 3974 if (wheel_scrolling_mode_ != kAsyncWheelEvents) { |
3879 // not initiate overscroll, since the beginning of the scroll has been | 3975 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3880 // consumed. The queued event with different modifiers should be sent to the | 3976 INPUT_EVENT_ACK_STATE_CONSUMED); |
3881 // renderer. | 3977 ExpectGestureScrollEndForWheelScrolling(false); |
3882 SendInputEventACK(WebInputEvent::kMouseWheel, | 3978 // Receive ACK for the second (coalesced) event as not processed. This |
3883 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 3979 // should not initiate overscroll, since the beginning of the scroll has |
3980 // been consumed. The queued event with different modifiers should be sent | |
3981 // to the renderer. | |
3982 SendInputEventACK(WebInputEvent::kMouseWheel, | |
3983 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
3984 ExpectGestureScrollEventsAfterMouseWheelACK(false, 1); | |
3985 } | |
3884 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 3986 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3885 ExpectGestureScrollEventsAfterMouseWheelACK(false, true); | 3987 |
3988 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { | |
3989 // The first and second GSU events are coalesced. This is the ack for the | |
3990 // coalesced event. Since it is the first GSU, the ack should be consumed. | |
3991 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | |
3992 INPUT_EVENT_ACK_STATE_CONSUMED); | |
3993 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(true); | |
3994 } else { | |
3995 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | |
3996 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
3997 ExpectGestureScrollEndForWheelScrolling(false); | |
3998 SendInputEventACK(WebInputEvent::kMouseWheel, | |
3999 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4000 ExpectGestureScrollEventsAfterMouseWheelACK(false, 0); | |
4001 } | |
3886 | 4002 |
3887 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4003 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3888 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4004 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3889 ExpectGestureScrollEndForWheelScrolling(false); | 4005 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
3890 | 4006 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); |
3891 SendInputEventACK(WebInputEvent::kMouseWheel, | 4007 ExpectGestureScrollEndAfterNonBlockingMouseWheelACK(); |
3892 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4008 } else if (wheel_scroll_latching_enabled_) { |
3893 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | |
3894 | |
3895 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | |
3896 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
3897 if (wheel_scroll_latching_enabled_) { | |
3898 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); | 4009 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); |
3899 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4010 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3900 SendInputEventACK(WebInputEvent::kMouseWheel, | 4011 SendInputEventACK(WebInputEvent::kMouseWheel, |
3901 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4012 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4013 ExpectGestureScrollEndForWheelScrolling(true); | |
4014 } else { | |
4015 ExpectGestureScrollEndForWheelScrolling(true); | |
3902 } | 4016 } |
3903 | |
3904 ExpectGestureScrollEndForWheelScrolling(true); | |
3905 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4017 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3906 } | 4018 } |
3907 TEST_F(RenderWidgetHostViewAuraOverscrollTest, | 4019 TEST_F(RenderWidgetHostViewAuraOverscrollTest, |
3908 WheelScrollConsumedDoNotHorizOverscroll) { | 4020 WheelScrollConsumedDoNotHorizOverscroll) { |
3909 WheelScrollConsumedDoNotHorizOverscroll(); | 4021 WheelScrollConsumedDoNotHorizOverscroll(); |
3910 } | 4022 } |
3911 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 4023 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
3912 WheelScrollConsumedDoNotHorizOverscroll) { | 4024 WheelScrollConsumedDoNotHorizOverscroll) { |
3913 WheelScrollConsumedDoNotHorizOverscroll(); | 4025 WheelScrollConsumedDoNotHorizOverscroll(); |
3914 } | 4026 } |
4027 TEST_F(RenderWidgetHostViewAuraOverScrollAsyncWheelEventsEnabledTest, | |
4028 WheelScrollConsumedDoNotHorizOverscroll) { | |
4029 WheelScrollConsumedDoNotHorizOverscroll(); | |
4030 } | |
3915 | 4031 |
3916 // Tests that wheel-scrolling correctly turns overscroll on and off. | 4032 // Tests that wheel-scrolling correctly turns overscroll on and off. |
3917 void RenderWidgetHostViewAuraOverscrollTest::WheelScrollOverscrollToggle() { | 4033 void RenderWidgetHostViewAuraOverscrollTest::WheelScrollOverscrollToggle() { |
3918 SetUpOverscrollEnvironment(); | 4034 SetUpOverscrollEnvironment(); |
3919 | 4035 |
3920 // Send a wheel event. ACK the event as not processed. This should not | 4036 // Send a wheel event. ACK the event as not processed. This should not |
3921 // initiate an overscroll gesture since it doesn't cross the threshold yet. | 4037 // initiate an overscroll gesture since it doesn't cross the threshold yet. |
3922 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 10, | 4038 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 10, |
3923 0, 0, true, | 4039 0, 0, true, |
3924 WebMouseWheelEvent::kPhaseBegan); | 4040 WebMouseWheelEvent::kPhaseBegan); |
3925 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4041 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
3926 SendInputEventACK(WebInputEvent::kMouseWheel, | 4042 SendInputEventACK(WebInputEvent::kMouseWheel, |
3927 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4043 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3928 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); | 4044 ExpectGestureScrollEventsAfterMouseWheelACK(true, 0); |
3929 | 4045 |
3930 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4046 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3931 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4047 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3932 ExpectGestureScrollEndForWheelScrolling(false); | 4048 ExpectGestureScrollEndForWheelScrolling(false); |
3933 | 4049 |
3934 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4050 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3935 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4051 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3936 | 4052 |
3937 // Scroll some more so as to not overscroll. | 4053 // Scroll some more so as to not overscroll. |
3938 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 10, | 4054 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 10, |
3939 0, 0, true, | 4055 0, 0, true, |
3940 WebMouseWheelEvent::kPhaseChanged); | 4056 WebMouseWheelEvent::kPhaseChanged); |
3941 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4057 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
3942 SendInputEventACK(WebInputEvent::kMouseWheel, | 4058 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(false); |
3943 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4059 } else { |
3944 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4060 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4061 SendInputEventACK(WebInputEvent::kMouseWheel, | |
4062 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4063 ExpectGestureScrollEventsAfterMouseWheelACK(false, 0); | |
4064 } | |
3945 | 4065 |
3946 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4066 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3947 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4067 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3948 ExpectGestureScrollEndForWheelScrolling(false); | 4068 ExpectGestureScrollEndForWheelScrolling(false); |
3949 | 4069 |
3950 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4070 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3951 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4071 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3952 | 4072 |
3953 // Scroll some more to initiate an overscroll. | 4073 // Scroll some more to initiate an overscroll. |
3954 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 40, | 4074 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 40, |
3955 0, 0, true, | 4075 0, 0, true, |
3956 WebMouseWheelEvent::kPhaseChanged); | 4076 WebMouseWheelEvent::kPhaseChanged); |
3957 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4077 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
3958 SendInputEventACK(WebInputEvent::kMouseWheel, | 4078 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(false); |
3959 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4079 } else { |
3960 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4080 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4081 SendInputEventACK(WebInputEvent::kMouseWheel, | |
4082 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4083 ExpectGestureScrollEventsAfterMouseWheelACK(false, 0); | |
4084 } | |
3961 | 4085 |
3962 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4086 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3963 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4087 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
3964 ExpectGestureScrollEndForWheelScrolling(false); | 4088 ExpectGestureScrollEndForWheelScrolling(false); |
3965 | 4089 |
3966 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); | 4090 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); |
3967 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); | 4091 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); |
3968 EXPECT_EQ(60.f, overscroll_delta_x()); | 4092 EXPECT_EQ(60.f, overscroll_delta_x()); |
3969 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); | 4093 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); |
3970 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); | 4094 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); |
(...skipping 12 matching lines...) Expand all Loading... | |
3983 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); | 4107 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); |
3984 } | 4108 } |
3985 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4109 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
3986 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4110 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
3987 | 4111 |
3988 // Continue to scroll in the reverse direction. | 4112 // Continue to scroll in the reverse direction. |
3989 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, -20, | 4113 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, -20, |
3990 0, 0, true, | 4114 0, 0, true, |
3991 WebMouseWheelEvent::kPhaseChanged); | 4115 WebMouseWheelEvent::kPhaseChanged); |
3992 | 4116 |
3993 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4117 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
3994 SendInputEventACK(WebInputEvent::kMouseWheel, | 4118 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(false); |
3995 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4119 } else { |
3996 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4120 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4121 SendInputEventACK(WebInputEvent::kMouseWheel, | |
4122 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4123 ExpectGestureScrollEventsAfterMouseWheelACK(false, 0); | |
4124 } | |
3997 | 4125 |
3998 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4126 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
3999 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4127 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4000 ExpectGestureScrollEndForWheelScrolling(false); | 4128 ExpectGestureScrollEndForWheelScrolling(false); |
4001 | 4129 |
4002 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4130 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4003 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4131 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
4004 | 4132 |
4005 // Continue to scroll in the reverse direction enough to initiate overscroll | 4133 // Continue to scroll in the reverse direction enough to initiate overscroll |
4006 // in that direction. | 4134 // in that direction. |
4007 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, -55, | 4135 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, -55, |
4008 0, 0, true, | 4136 0, 0, true, |
4009 WebMouseWheelEvent::kPhaseChanged); | 4137 WebMouseWheelEvent::kPhaseChanged); |
4010 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4138 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
4011 SendInputEventACK(WebInputEvent::kMouseWheel, | 4139 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(false); |
4012 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4140 } else { |
4013 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4141 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4142 SendInputEventACK(WebInputEvent::kMouseWheel, | |
4143 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4144 ExpectGestureScrollEventsAfterMouseWheelACK(false, 0); | |
4145 } | |
4014 | 4146 |
4015 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4147 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4016 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4148 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4017 if (wheel_scroll_latching_enabled_) { | 4149 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
4150 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); | |
4151 ExpectGestureScrollEndAfterNonBlockingMouseWheelACK(); | |
4152 } else if (wheel_scroll_latching_enabled_) { | |
4018 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); | 4153 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); |
4019 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4154 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4020 SendInputEventACK(WebInputEvent::kMouseWheel, | 4155 SendInputEventACK(WebInputEvent::kMouseWheel, |
4021 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4156 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4157 ExpectGestureScrollEndForWheelScrolling(true); | |
4158 } else { | |
4159 ExpectGestureScrollEndForWheelScrolling(true); | |
4022 } | 4160 } |
4023 ExpectGestureScrollEndForWheelScrolling(true); | |
4024 | 4161 |
4025 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); | 4162 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); |
4026 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); | 4163 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); |
4027 EXPECT_EQ(-75.f, overscroll_delta_x()); | 4164 EXPECT_EQ(-75.f, overscroll_delta_x()); |
4028 EXPECT_EQ(-25.f, overscroll_delegate()->delta_x()); | 4165 EXPECT_EQ(-25.f, overscroll_delegate()->delta_x()); |
4029 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); | 4166 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); |
4030 } | 4167 } |
4031 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelScrollOverscrollToggle) { | 4168 TEST_F(RenderWidgetHostViewAuraOverscrollTest, WheelScrollOverscrollToggle) { |
4032 WheelScrollOverscrollToggle(); | 4169 WheelScrollOverscrollToggle(); |
4033 } | 4170 } |
4034 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 4171 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
4035 WheelScrollOverscrollToggle) { | 4172 WheelScrollOverscrollToggle) { |
4036 WheelScrollOverscrollToggle(); | 4173 WheelScrollOverscrollToggle(); |
4037 } | 4174 } |
4175 TEST_F(RenderWidgetHostViewAuraOverScrollAsyncWheelEventsEnabledTest, | |
4176 WheelScrollOverscrollToggle) { | |
4177 WheelScrollOverscrollToggle(); | |
4178 } | |
4038 | 4179 |
4039 void RenderWidgetHostViewAuraOverscrollTest::ScrollEventsOverscrollWithFling() { | 4180 void RenderWidgetHostViewAuraOverscrollTest::ScrollEventsOverscrollWithFling() { |
4040 SetUpOverscrollEnvironment(); | 4181 SetUpOverscrollEnvironment(); |
4041 | 4182 |
4042 // Send a wheel event. ACK the event as not processed. This should not | 4183 // Send a wheel event. ACK the event as not processed. This should not |
4043 // initiate an overscroll gesture since it doesn't cross the threshold yet. | 4184 // initiate an overscroll gesture since it doesn't cross the threshold yet. |
4044 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 10, | 4185 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 10, |
4045 0, 0, true, | 4186 0, 0, true, |
4046 WebMouseWheelEvent::kPhaseBegan); | 4187 WebMouseWheelEvent::kPhaseBegan); |
4047 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4188 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4048 SendInputEventACK(WebInputEvent::kMouseWheel, | 4189 SendInputEventACK(WebInputEvent::kMouseWheel, |
4049 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4190 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4050 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); | 4191 ExpectGestureScrollEventsAfterMouseWheelACK(true, 0); |
4051 | 4192 |
4052 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4193 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4053 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4194 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4054 ExpectGestureScrollEndForWheelScrolling(false); | 4195 ExpectGestureScrollEndForWheelScrolling(false); |
4055 | 4196 |
4056 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4197 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4057 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4198 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
4058 | 4199 |
4059 // Scroll some more so as to not overscroll. | 4200 // Scroll some more so as to not overscroll. |
4060 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 20, | 4201 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 20, |
4061 0, 0, true, | 4202 0, 0, true, |
4062 WebMouseWheelEvent::kPhaseChanged); | 4203 WebMouseWheelEvent::kPhaseChanged); |
4063 EXPECT_EQ(1U, sink_->message_count()); | 4204 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
4064 SendInputEventACK(WebInputEvent::kMouseWheel, | 4205 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(false); |
4065 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4206 } else { |
4207 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | |
4208 SendInputEventACK(WebInputEvent::kMouseWheel, | |
4209 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4210 ExpectGestureScrollEventsAfterMouseWheelACK(false, 0); | |
4211 } | |
4066 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4212 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4067 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4213 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4068 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4214 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4069 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4215 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
4070 sink_->ClearMessages(); | 4216 sink_->ClearMessages(); |
4071 | 4217 |
4072 // Scroll some more to initiate an overscroll. | 4218 // Scroll some more to initiate an overscroll. |
4073 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 30, | 4219 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 30, |
4074 0, 0, true, | 4220 0, 0, true, |
4075 WebMouseWheelEvent::kPhaseChanged); | 4221 WebMouseWheelEvent::kPhaseChanged); |
4076 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4222 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
4077 SendInputEventACK(WebInputEvent::kMouseWheel, | 4223 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(false); |
4078 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4224 } else { |
4079 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4225 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4080 | 4226 SendInputEventACK(WebInputEvent::kMouseWheel, |
4227 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4228 ExpectGestureScrollEventsAfterMouseWheelACK(false, 0); | |
4229 } | |
4081 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4230 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4082 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4231 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4083 ExpectGestureScrollEndForWheelScrolling(false); | 4232 ExpectGestureScrollEndForWheelScrolling(false); |
4084 | 4233 |
4085 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); | 4234 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); |
4086 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); | 4235 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); |
4087 | 4236 |
4088 EXPECT_EQ(60.f, overscroll_delta_x()); | 4237 EXPECT_EQ(60.f, overscroll_delta_x()); |
4089 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); | 4238 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); |
4090 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); | 4239 EXPECT_EQ(0.f, overscroll_delegate()->delta_y()); |
(...skipping 11 matching lines...) Expand all Loading... | |
4102 EXPECT_EQ(2U, sink_->message_count()); | 4251 EXPECT_EQ(2U, sink_->message_count()); |
4103 } | 4252 } |
4104 TEST_F(RenderWidgetHostViewAuraOverscrollTest, | 4253 TEST_F(RenderWidgetHostViewAuraOverscrollTest, |
4105 ScrollEventsOverscrollWithFling) { | 4254 ScrollEventsOverscrollWithFling) { |
4106 ScrollEventsOverscrollWithFling(); | 4255 ScrollEventsOverscrollWithFling(); |
4107 } | 4256 } |
4108 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 4257 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
4109 ScrollEventsOverscrollWithFling) { | 4258 ScrollEventsOverscrollWithFling) { |
4110 ScrollEventsOverscrollWithFling(); | 4259 ScrollEventsOverscrollWithFling(); |
4111 } | 4260 } |
4261 TEST_F(RenderWidgetHostViewAuraOverScrollAsyncWheelEventsEnabledTest, | |
4262 ScrollEventsOverscrollWithFling) { | |
4263 ScrollEventsOverscrollWithFling(); | |
4264 } | |
4112 | 4265 |
4113 // Same as ScrollEventsOverscrollWithFling, but with zero velocity. Checks that | 4266 // Same as ScrollEventsOverscrollWithFling, but with zero velocity. Checks that |
4114 // the zero-velocity fling does not reach the renderer. | 4267 // the zero-velocity fling does not reach the renderer. |
4115 void RenderWidgetHostViewAuraOverscrollTest:: | 4268 void RenderWidgetHostViewAuraOverscrollTest:: |
4116 ScrollEventsOverscrollWithZeroFling() { | 4269 ScrollEventsOverscrollWithZeroFling() { |
4117 SetUpOverscrollEnvironment(); | 4270 SetUpOverscrollEnvironment(); |
4118 | 4271 |
4119 // Send a wheel event. ACK the event as not processed. This should not | 4272 // Send a wheel event. ACK the event as not processed. This should not |
4120 // initiate an overscroll gesture since it doesn't cross the threshold yet. | 4273 // initiate an overscroll gesture since it doesn't cross the threshold yet. |
4121 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 10, | 4274 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 10, |
4122 0, 0, true, | 4275 0, 0, true, |
4123 WebMouseWheelEvent::kPhaseBegan); | 4276 WebMouseWheelEvent::kPhaseBegan); |
4124 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4277 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4125 SendInputEventACK(WebInputEvent::kMouseWheel, | 4278 SendInputEventACK(WebInputEvent::kMouseWheel, |
4126 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4279 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4127 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); | 4280 ExpectGestureScrollEventsAfterMouseWheelACK(true, 0); |
4128 | 4281 |
4129 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4282 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4130 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4283 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4131 ExpectGestureScrollEndForWheelScrolling(false); | 4284 ExpectGestureScrollEndForWheelScrolling(false); |
4132 | 4285 |
4133 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4286 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4134 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4287 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
4135 | 4288 |
4136 // Scroll some more so as to not overscroll. | 4289 // Scroll some more so as to not overscroll. |
4137 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 20, | 4290 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 20, |
4138 0, 0, true, | 4291 0, 0, true, |
4139 WebMouseWheelEvent::kPhaseChanged); | 4292 WebMouseWheelEvent::kPhaseChanged); |
4140 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4293 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
4141 SendInputEventACK(WebInputEvent::kMouseWheel, | 4294 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(false); |
4142 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4295 } else { |
4143 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4296 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4297 SendInputEventACK(WebInputEvent::kMouseWheel, | |
4298 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4299 ExpectGestureScrollEventsAfterMouseWheelACK(false, 0); | |
4300 } | |
4144 | 4301 |
4145 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4302 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4146 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4303 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4147 ExpectGestureScrollEndForWheelScrolling(false); | 4304 ExpectGestureScrollEndForWheelScrolling(false); |
4148 | 4305 |
4149 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4306 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4150 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4307 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
4151 | 4308 |
4152 // Scroll some more to initiate an overscroll. | 4309 // Scroll some more to initiate an overscroll. |
4153 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 30, | 4310 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 30, |
4154 0, 0, true, | 4311 0, 0, true, |
4155 WebMouseWheelEvent::kPhaseChanged); | 4312 WebMouseWheelEvent::kPhaseChanged); |
4156 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4313 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
4157 SendInputEventACK(WebInputEvent::kMouseWheel, | 4314 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(false); |
4158 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4315 } else { |
4159 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4316 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4317 SendInputEventACK(WebInputEvent::kMouseWheel, | |
4318 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4319 ExpectGestureScrollEventsAfterMouseWheelACK(false, 0); | |
4320 } | |
4160 | 4321 |
4161 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4322 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4162 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4323 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4163 ExpectGestureScrollEndForWheelScrolling(false); | 4324 ExpectGestureScrollEndForWheelScrolling(false); |
4164 | 4325 |
4165 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); | 4326 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); |
4166 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); | 4327 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); |
4167 | 4328 |
4168 EXPECT_EQ(60.f, overscroll_delta_x()); | 4329 EXPECT_EQ(60.f, overscroll_delta_x()); |
4169 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); | 4330 EXPECT_EQ(10.f, overscroll_delegate()->delta_x()); |
(...skipping 12 matching lines...) Expand all Loading... | |
4182 EXPECT_EQ(2U, sink_->message_count()); | 4343 EXPECT_EQ(2U, sink_->message_count()); |
4183 } | 4344 } |
4184 TEST_F(RenderWidgetHostViewAuraOverscrollTest, | 4345 TEST_F(RenderWidgetHostViewAuraOverscrollTest, |
4185 ScrollEventsOverscrollWithZeroFling) { | 4346 ScrollEventsOverscrollWithZeroFling) { |
4186 ScrollEventsOverscrollWithZeroFling(); | 4347 ScrollEventsOverscrollWithZeroFling(); |
4187 } | 4348 } |
4188 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 4349 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
4189 ScrollEventsOverscrollWithZeroFling) { | 4350 ScrollEventsOverscrollWithZeroFling) { |
4190 ScrollEventsOverscrollWithZeroFling(); | 4351 ScrollEventsOverscrollWithZeroFling(); |
4191 } | 4352 } |
4353 TEST_F(RenderWidgetHostViewAuraOverScrollAsyncWheelEventsEnabledTest, | |
4354 ScrollEventsOverscrollWithZeroFling) { | |
4355 ScrollEventsOverscrollWithZeroFling(); | |
4356 } | |
4192 | 4357 |
4193 // Tests that a fling in the opposite direction of the overscroll cancels the | 4358 // Tests that a fling in the opposite direction of the overscroll cancels the |
4194 // overscroll nav instead of completing it. | 4359 // overscroll nav instead of completing it. |
4195 TEST_F(RenderWidgetHostViewAuraOverscrollTest, ReverseFlingCancelsOverscroll) { | 4360 TEST_F(RenderWidgetHostViewAuraOverscrollTest, ReverseFlingCancelsOverscroll) { |
4196 SetUpOverscrollEnvironment(); | 4361 SetUpOverscrollEnvironment(); |
4197 | 4362 |
4198 { | 4363 { |
4199 // Start and end a gesture in the same direction without processing the | 4364 // Start and end a gesture in the same direction without processing the |
4200 // gesture events in the renderer. This should initiate and complete an | 4365 // gesture events in the renderer. This should initiate and complete an |
4201 // overscroll navigation. | 4366 // overscroll navigation. |
(...skipping 437 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4639 OverscrollDirectionChangeMouseWheel() { | 4804 OverscrollDirectionChangeMouseWheel() { |
4640 SetUpOverscrollEnvironment(); | 4805 SetUpOverscrollEnvironment(); |
4641 | 4806 |
4642 // Send wheel event and receive ack as not consumed. | 4807 // Send wheel event and receive ack as not consumed. |
4643 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 125, | 4808 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 125, |
4644 -5, 0, true, | 4809 -5, 0, true, |
4645 WebMouseWheelEvent::kPhaseBegan); | 4810 WebMouseWheelEvent::kPhaseBegan); |
4646 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4811 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4647 SendInputEventACK(WebInputEvent::kMouseWheel, | 4812 SendInputEventACK(WebInputEvent::kMouseWheel, |
4648 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4813 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4649 ExpectGestureScrollEventsAfterMouseWheelACK(true, false); | 4814 ExpectGestureScrollEventsAfterMouseWheelACK(true, 0); |
4650 | 4815 |
4651 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4816 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4652 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4817 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4653 ExpectGestureScrollEndForWheelScrolling(false); | 4818 ExpectGestureScrollEndForWheelScrolling(false); |
4654 | 4819 |
4655 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); | 4820 EXPECT_EQ(OVERSCROLL_EAST, overscroll_mode()); |
4656 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); | 4821 EXPECT_EQ(OVERSCROLL_EAST, overscroll_delegate()->current_mode()); |
4657 | 4822 |
4658 // Send another wheel event, but in the reverse direction. The overscroll | 4823 // Send another wheel event, but in the reverse direction. The overscroll |
4659 // controller will not consume the event, because it is not triggering | 4824 // controller will not consume the event, because it is not triggering |
4660 // gesture-nav. | 4825 // gesture-nav. |
4661 | 4826 |
4662 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, | 4827 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, |
4663 -260, 0, 0, true, | 4828 -260, 0, 0, true, |
4664 WebMouseWheelEvent::kPhaseChanged); | 4829 WebMouseWheelEvent::kPhaseChanged); |
4665 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4830 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
4666 SendInputEventACK(WebInputEvent::kMouseWheel, | 4831 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(false); |
4667 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4832 } else { |
4668 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4833 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4834 SendInputEventACK(WebInputEvent::kMouseWheel, | |
4835 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4836 ExpectGestureScrollEventsAfterMouseWheelACK(false, 0); | |
4837 } | |
4838 | |
4669 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4839 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4670 | 4840 |
4671 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4841 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4672 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4842 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4673 ExpectGestureScrollEndForWheelScrolling(false); | 4843 ExpectGestureScrollEndForWheelScrolling(false); |
4674 | 4844 |
4675 // Since it was unhandled; the overscroll should now be west | 4845 // Since it was unhandled; the overscroll should now be west |
4676 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); | 4846 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); |
4677 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); | 4847 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); |
4678 | 4848 |
4679 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, -20, | 4849 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, -20, |
4680 0, 0, true, | 4850 0, 0, true, |
4681 WebMouseWheelEvent::kPhaseChanged); | 4851 WebMouseWheelEvent::kPhaseChanged); |
4682 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4852 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4683 SendInputEventACK(WebInputEvent::kMouseWheel, | 4853 if (wheel_scrolling_mode_ != kAsyncWheelEvents) { |
4684 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4854 SendInputEventACK(WebInputEvent::kMouseWheel, |
4855 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4856 } | |
4685 | 4857 |
4686 // wheel event ack generates gesture scroll update; which gets consumed | 4858 // wheel event ack generates gesture scroll update; which gets consumed |
4687 // solely by the overflow controller. | 4859 // solely by the overflow controller. |
4688 if (!wheel_scroll_latching_enabled_) { | 4860 if (!wheel_scroll_latching_enabled_) { |
4689 // No ScrollUpdates, only ScrollBegin and ScrollEnd will be queued events. | 4861 // No ScrollUpdates, only ScrollBegin and ScrollEnd will be queued events. |
4690 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); | 4862 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); |
4691 } else { | 4863 } else { |
4692 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); | 4864 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); |
4693 } | 4865 } |
4694 | 4866 |
4695 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); | 4867 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); |
4696 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); | 4868 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); |
4697 } | 4869 } |
4698 TEST_F(RenderWidgetHostViewAuraOverscrollTest, | 4870 TEST_F(RenderWidgetHostViewAuraOverscrollTest, |
4699 OverscrollDirectionChangeMouseWheel) { | 4871 OverscrollDirectionChangeMouseWheel) { |
4700 OverscrollDirectionChangeMouseWheel(); | 4872 OverscrollDirectionChangeMouseWheel(); |
4701 } | 4873 } |
4702 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 4874 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
4703 OverscrollDirectionChangeMouseWheel) { | 4875 OverscrollDirectionChangeMouseWheel) { |
4704 OverscrollDirectionChangeMouseWheel(); | 4876 OverscrollDirectionChangeMouseWheel(); |
4705 } | 4877 } |
4878 TEST_F(RenderWidgetHostViewAuraOverScrollAsyncWheelEventsEnabledTest, | |
4879 OverscrollDirectionChangeMouseWheel) { | |
4880 OverscrollDirectionChangeMouseWheel(); | |
4881 } | |
4706 | 4882 |
4707 void RenderWidgetHostViewAuraOverscrollTest::OverscrollMouseMoveCompletion() { | 4883 void RenderWidgetHostViewAuraOverscrollTest::OverscrollMouseMoveCompletion() { |
4708 SetUpOverscrollEnvironment(); | 4884 SetUpOverscrollEnvironment(); |
4709 | 4885 |
4710 SimulateWheelEventPossiblyIncludingPhase( | 4886 SimulateWheelEventPossiblyIncludingPhase( |
4711 !wheel_scroll_latching_enabled_, 5, 0, 0, true, | 4887 !wheel_scroll_latching_enabled_, 5, 0, 0, true, |
4712 WebMouseWheelEvent::kPhaseBegan); // sent directly | 4888 WebMouseWheelEvent::kPhaseBegan); // sent directly |
4713 SimulateWheelEventPossiblyIncludingPhase( | 4889 SimulateWheelEventPossiblyIncludingPhase( |
4714 !wheel_scroll_latching_enabled_, -1, 0, 0, true, | 4890 !wheel_scroll_latching_enabled_, -1, 0, 0, true, |
4715 WebMouseWheelEvent::kPhaseChanged); // enqueued | 4891 WebMouseWheelEvent::kPhaseChanged); // enqueued |
4716 SimulateWheelEventPossiblyIncludingPhase( | 4892 SimulateWheelEventPossiblyIncludingPhase( |
4717 !wheel_scroll_latching_enabled_, -10, -3, 0, true, | 4893 !wheel_scroll_latching_enabled_, -10, -3, 0, true, |
4718 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | 4894 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
4719 SimulateWheelEventPossiblyIncludingPhase( | 4895 SimulateWheelEventPossiblyIncludingPhase( |
4720 !wheel_scroll_latching_enabled_, -15, -1, 0, true, | 4896 !wheel_scroll_latching_enabled_, -15, -1, 0, true, |
4721 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | 4897 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
4722 SimulateWheelEventPossiblyIncludingPhase( | 4898 SimulateWheelEventPossiblyIncludingPhase( |
4723 !wheel_scroll_latching_enabled_, -30, -3, 0, true, | 4899 !wheel_scroll_latching_enabled_, -30, -3, 0, true, |
4724 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | 4900 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
4725 | 4901 |
4726 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4902 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4727 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 4903 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4728 | 4904 |
4729 // Receive ACK the first wheel event as not processed. | 4905 // Receive ACK the first wheel event as not processed. |
4730 SendInputEventACK(WebInputEvent::kMouseWheel, | 4906 SendInputEventACK(WebInputEvent::kMouseWheel, |
4731 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4907 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4732 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 4908 ExpectGestureScrollEventsAfterMouseWheelACK(true, 1); |
4733 | 4909 |
4734 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4910 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4735 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4911 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4736 ExpectGestureScrollEndForWheelScrolling(false); | |
4737 | 4912 |
4738 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 4913 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4739 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); | 4914 EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode()); |
4740 | 4915 |
4741 // Receive ACK for the second (coalesced) event as not processed. This will | 4916 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
4742 // start an overcroll gesture. | 4917 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(true); |
4743 SendInputEventACK(WebInputEvent::kMouseWheel, | 4918 } else { |
4744 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4919 ExpectGestureScrollEndForWheelScrolling(false); |
4745 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 4920 // Receive ACK for the second (coalesced) event as not processed. This will |
4921 // start an overcroll gesture. | |
4922 SendInputEventACK(WebInputEvent::kMouseWheel, | |
4923 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4924 ExpectGestureScrollEventsAfterMouseWheelACK(false, 0); | |
4925 } | |
4746 | 4926 |
4747 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 4927 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4748 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4928 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4749 ExpectGestureScrollEndForWheelScrolling(false); | 4929 ExpectGestureScrollEndForWheelScrolling(false); |
4750 | 4930 |
4751 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); | 4931 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); |
4752 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); | 4932 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); |
4753 | 4933 |
4754 // Send a mouse-move event. This should cancel the overscroll navigation | 4934 // Send a mouse-move event. This should cancel the overscroll navigation |
4755 // (since the amount overscrolled is not above the threshold), and so the | 4935 // (since the amount overscrolled is not above the threshold), and so the |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4802 SendInputEventACK(WebInputEvent::kMouseMove, | 4982 SendInputEventACK(WebInputEvent::kMouseMove, |
4803 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 4983 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4804 } | 4984 } |
4805 TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollMouseMoveCompletion) { | 4985 TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollMouseMoveCompletion) { |
4806 OverscrollMouseMoveCompletion(); | 4986 OverscrollMouseMoveCompletion(); |
4807 } | 4987 } |
4808 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 4988 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
4809 OverscrollMouseMoveCompletion) { | 4989 OverscrollMouseMoveCompletion) { |
4810 OverscrollMouseMoveCompletion(); | 4990 OverscrollMouseMoveCompletion(); |
4811 } | 4991 } |
4992 TEST_F(RenderWidgetHostViewAuraOverScrollAsyncWheelEventsEnabledTest, | |
4993 OverscrollMouseMoveCompletion) { | |
4994 OverscrollMouseMoveCompletion(); | |
4995 } | |
4812 | 4996 |
4813 // Tests that if a page scrolled, then the overscroll controller's states are | 4997 // Tests that if a page scrolled, then the overscroll controller's states are |
4814 // reset after the end of the scroll. | 4998 // reset after the end of the scroll. |
4815 void RenderWidgetHostViewAuraOverscrollTest:: | 4999 void RenderWidgetHostViewAuraOverscrollTest:: |
4816 OverscrollStateResetsAfterScroll() { | 5000 OverscrollStateResetsAfterScroll() { |
4817 SetUpOverscrollEnvironment(); | 5001 SetUpOverscrollEnvironment(); |
4818 | 5002 |
4819 SimulateWheelEventPossiblyIncludingPhase( | 5003 SimulateWheelEventPossiblyIncludingPhase( |
4820 !wheel_scroll_latching_enabled_, 0, 5, 0, true, | 5004 !wheel_scroll_latching_enabled_, 0, 5, 0, true, |
4821 WebMouseWheelEvent::kPhaseBegan); // sent directly | 5005 WebMouseWheelEvent::kPhaseBegan); // sent directly |
4822 SimulateWheelEventPossiblyIncludingPhase( | 5006 SimulateWheelEventPossiblyIncludingPhase( |
4823 !wheel_scroll_latching_enabled_, 0, 30, 0, true, | 5007 !wheel_scroll_latching_enabled_, 0, 30, 0, true, |
4824 WebMouseWheelEvent::kPhaseChanged); // enqueued | 5008 WebMouseWheelEvent::kPhaseChanged); // enqueued |
4825 SimulateWheelEventPossiblyIncludingPhase( | 5009 SimulateWheelEventPossiblyIncludingPhase( |
4826 !wheel_scroll_latching_enabled_, 0, 40, 0, true, | 5010 !wheel_scroll_latching_enabled_, 0, 40, 0, true, |
4827 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | 5011 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
4828 SimulateWheelEventPossiblyIncludingPhase( | 5012 SimulateWheelEventPossiblyIncludingPhase( |
4829 !wheel_scroll_latching_enabled_, 0, 10, 0, true, | 5013 !wheel_scroll_latching_enabled_, 0, 10, 0, true, |
4830 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | 5014 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
4831 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 5015 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4832 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 5016 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4833 | 5017 |
4834 // The first wheel event is consumed. Dispatches the queued wheel event. | 5018 // The first wheel event is consumed. Dispatches the queued wheel event. |
4835 SendInputEventACK(WebInputEvent::kMouseWheel, | 5019 SendInputEventACK(WebInputEvent::kMouseWheel, |
4836 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5020 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4837 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 5021 ExpectGestureScrollEventsAfterMouseWheelACK(true, 1); |
4838 | 5022 |
4839 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 5023 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4840 INPUT_EVENT_ACK_STATE_CONSUMED); | 5024 INPUT_EVENT_ACK_STATE_CONSUMED); |
4841 ExpectGestureScrollEndForWheelScrolling(false); | |
4842 EXPECT_TRUE(ScrollStateIsContentScrolling()); | 5025 EXPECT_TRUE(ScrollStateIsContentScrolling()); |
4843 | 5026 |
4844 // The second wheel event is consumed. | 5027 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
4845 SendInputEventACK(WebInputEvent::kMouseWheel, | 5028 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(true); |
4846 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5029 } else { |
4847 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | 5030 ExpectGestureScrollEndForWheelScrolling(false); |
5031 // The second wheel event is consumed. | |
5032 SendInputEventACK(WebInputEvent::kMouseWheel, | |
5033 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
5034 ExpectGestureScrollEventsAfterMouseWheelACK(false, 0); | |
5035 } | |
4848 | 5036 |
4849 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 5037 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4850 INPUT_EVENT_ACK_STATE_CONSUMED); | 5038 INPUT_EVENT_ACK_STATE_CONSUMED); |
4851 | 5039 |
4852 if (wheel_scroll_latching_enabled_) { | 5040 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { |
5041 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); | |
5042 ExpectGestureScrollEndAfterNonBlockingMouseWheelACK(); | |
5043 } else if (wheel_scroll_latching_enabled_) { | |
4853 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); | 5044 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); |
4854 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 5045 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4855 SendInputEventACK(WebInputEvent::kMouseWheel, | 5046 SendInputEventACK(WebInputEvent::kMouseWheel, |
4856 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5047 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
5048 ExpectGestureScrollEndForWheelScrolling(true); | |
5049 } else { | |
5050 ExpectGestureScrollEndForWheelScrolling(true); | |
4857 } | 5051 } |
4858 ExpectGestureScrollEndForWheelScrolling(true); | |
4859 EXPECT_TRUE(ScrollStateIsContentScrolling()); | 5052 EXPECT_TRUE(ScrollStateIsContentScrolling()); |
4860 | 5053 |
4861 // Touchpad scroll can end with a zero-velocity fling. But it is not | 5054 // Touchpad scroll can end with a zero-velocity fling which is not dispatched, |
4862 // dispatched, but it should still reset the overscroll controller state. | 5055 // but it should still reset the overscroll controller state. |
4863 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, | 5056 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, |
4864 blink::kWebGestureDeviceTouchscreen); | 5057 blink::kWebGestureDeviceTouchscreen); |
4865 SimulateGestureFlingStartEvent(0.f, 0.f, blink::kWebGestureDeviceTouchpad); | 5058 SimulateGestureFlingStartEvent(0.f, 0.f, blink::kWebGestureDeviceTouchpad); |
4866 EXPECT_TRUE(ScrollStateIsUnknown()); | 5059 EXPECT_TRUE(ScrollStateIsUnknown()); |
4867 // ScrollBegin will be queued events. | 5060 // ScrollBegin will be queued events. |
4868 EXPECT_EQ(1U, sink_->message_count()); | 5061 EXPECT_EQ(1U, sink_->message_count()); |
4869 | 5062 |
4870 // Dropped flings should neither propagate *nor* indicate that they were | 5063 // Dropped flings should neither propagate *nor* indicate that they were |
4871 // consumed and have triggered a fling animation (as tracked by the router). | 5064 // consumed and have triggered a fling animation (as tracked by the router). |
4872 EXPECT_FALSE(parent_host_->input_router()->HasPendingEvents()); | 5065 EXPECT_FALSE(parent_host_->input_router()->HasPendingEvents()); |
(...skipping 13 matching lines...) Expand all Loading... | |
4886 !wheel_scroll_latching_enabled_, -100, 0, 0, true, | 5079 !wheel_scroll_latching_enabled_, -100, 0, 0, true, |
4887 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event | 5080 WebMouseWheelEvent::kPhaseChanged); // coalesced into previous event |
4888 | 5081 |
4889 EXPECT_TRUE(ScrollStateIsUnknown()); | 5082 EXPECT_TRUE(ScrollStateIsUnknown()); |
4890 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 5083 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4891 | 5084 |
4892 // The first wheel scroll did not scroll content. Overscroll should not start | 5085 // The first wheel scroll did not scroll content. Overscroll should not start |
4893 // yet, since enough hasn't been scrolled. | 5086 // yet, since enough hasn't been scrolled. |
4894 SendInputEventACK(WebInputEvent::kMouseWheel, | 5087 SendInputEventACK(WebInputEvent::kMouseWheel, |
4895 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5088 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4896 ExpectGestureScrollEventsAfterMouseWheelACK(true, true); | 5089 ExpectGestureScrollEventsAfterMouseWheelACK(true, 1); |
4897 | |
4898 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | |
4899 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4900 ExpectGestureScrollEndForWheelScrolling(false); | |
4901 EXPECT_TRUE(ScrollStateIsUnknown()); | |
4902 | |
4903 SendInputEventACK(WebInputEvent::kMouseWheel, | |
4904 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
4905 ExpectGestureScrollEventsAfterMouseWheelACK(false, false); | |
4906 | 5090 |
4907 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 5091 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
4908 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5092 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
4909 | 5093 |
4910 if (wheel_scroll_latching_enabled_) { | 5094 EXPECT_TRUE(ScrollStateIsUnknown()); |
5095 | |
5096 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { | |
5097 ExpectGestureScrollUpdateAfterNonBlockingMouseWheelACK(true); | |
5098 } else { | |
5099 ExpectGestureScrollEndForWheelScrolling(false); | |
5100 SendInputEventACK(WebInputEvent::kMouseWheel, | |
5101 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
5102 ExpectGestureScrollEventsAfterMouseWheelACK(false, 0); | |
5103 } | |
5104 | |
5105 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | |
5106 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
5107 | |
5108 if (wheel_scrolling_mode_ == kAsyncWheelEvents) { | |
5109 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); | |
5110 ExpectGestureScrollEndAfterNonBlockingMouseWheelACK(); | |
5111 } else if (wheel_scroll_latching_enabled_) { | |
4911 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); | 5112 SimulateWheelEventWithPhase(0, 0, 0, true, WebMouseWheelEvent::kPhaseEnded); |
4912 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); | 5113 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); |
4913 SendInputEventACK(WebInputEvent::kMouseWheel, | 5114 SendInputEventACK(WebInputEvent::kMouseWheel, |
4914 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5115 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
5116 ExpectGestureScrollEndForWheelScrolling(true); | |
5117 } else { | |
5118 ExpectGestureScrollEndForWheelScrolling(true); | |
4915 } | 5119 } |
4916 | |
4917 ExpectGestureScrollEndForWheelScrolling(true); | |
4918 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); | 5120 EXPECT_EQ(OVERSCROLL_WEST, overscroll_mode()); |
4919 EXPECT_TRUE(ScrollStateIsOverscrolling()); | 5121 EXPECT_TRUE(ScrollStateIsOverscrolling()); |
4920 | 5122 |
4921 // The GestureScrollBegin will reset the delegate's mode, so check it here. | 5123 // The GestureScrollBegin will reset the delegate's mode, so check it here. |
4922 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); | 5124 EXPECT_EQ(OVERSCROLL_WEST, overscroll_delegate()->current_mode()); |
4923 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, | 5125 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, |
4924 blink::kWebGestureDeviceTouchscreen); | 5126 blink::kWebGestureDeviceTouchscreen); |
4925 SimulateGestureFlingStartEvent(0.f, 0.f, blink::kWebGestureDeviceTouchpad); | 5127 SimulateGestureFlingStartEvent(0.f, 0.f, blink::kWebGestureDeviceTouchpad); |
4926 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 5128 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
4927 EXPECT_TRUE(ScrollStateIsUnknown()); | 5129 EXPECT_TRUE(ScrollStateIsUnknown()); |
4928 // ScrollBegin will be the queued event. | 5130 // ScrollBegin will be the queued event. |
4929 EXPECT_EQ(1U, sink_->message_count()); | 5131 EXPECT_EQ(1U, sink_->message_count()); |
4930 EXPECT_FALSE(parent_host_->input_router()->HasPendingEvents()); | 5132 EXPECT_FALSE(parent_host_->input_router()->HasPendingEvents()); |
4931 } | 5133 } |
4932 TEST_F(RenderWidgetHostViewAuraOverscrollTest, | 5134 TEST_F(RenderWidgetHostViewAuraOverscrollTest, |
4933 OverscrollStateResetsAfterScroll) { | 5135 OverscrollStateResetsAfterScroll) { |
4934 OverscrollStateResetsAfterScroll(); | 5136 OverscrollStateResetsAfterScroll(); |
4935 } | 5137 } |
4936 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | 5138 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, |
4937 OverscrollStateResetsAfterScroll) { | 5139 OverscrollStateResetsAfterScroll) { |
4938 OverscrollStateResetsAfterScroll(); | 5140 OverscrollStateResetsAfterScroll(); |
4939 } | 5141 } |
5142 TEST_F(RenderWidgetHostViewAuraOverScrollAsyncWheelEventsEnabledTest, | |
5143 OverscrollStateResetsAfterScroll) { | |
5144 OverscrollStateResetsAfterScroll(); | |
5145 } | |
4940 | 5146 |
4941 TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollResetsOnBlur) { | 5147 TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollResetsOnBlur) { |
4942 SetUpOverscrollEnvironment(); | 5148 SetUpOverscrollEnvironment(); |
4943 | 5149 |
4944 // Start an overscroll with gesture scroll. In the middle of the scroll, blur | 5150 // Start an overscroll with gesture scroll. In the middle of the scroll, blur |
4945 // the host. | 5151 // the host. |
4946 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, | 5152 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, |
4947 blink::kWebGestureDeviceTouchscreen); | 5153 blink::kWebGestureDeviceTouchscreen); |
4948 SimulateGestureScrollUpdateEvent(300, -5, 0); | 5154 SimulateGestureScrollUpdateEvent(300, -5, 0); |
4949 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 5155 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
(...skipping 225 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
5175 view_->OnTouchEvent(&press2); | 5381 view_->OnTouchEvent(&press2); |
5176 SendTouchEventACK(blink::WebInputEvent::kTouchStart, | 5382 SendTouchEventACK(blink::WebInputEvent::kTouchStart, |
5177 INPUT_EVENT_ACK_STATE_CONSUMED, press2.unique_event_id()); | 5383 INPUT_EVENT_ACK_STATE_CONSUMED, press2.unique_event_id()); |
5178 | 5384 |
5179 EXPECT_EQ(2U, view_->dispatcher_->GetAndResetProcessedTouchEventCount()); | 5385 EXPECT_EQ(2U, view_->dispatcher_->GetAndResetProcessedTouchEventCount()); |
5180 } | 5386 } |
5181 | 5387 |
5182 // Tests that the scroll deltas stored within the overscroll controller get | 5388 // Tests that the scroll deltas stored within the overscroll controller get |
5183 // reset at the end of the overscroll gesture even if the overscroll threshold | 5389 // reset at the end of the overscroll gesture even if the overscroll threshold |
5184 // isn't surpassed and the overscroll mode stays OVERSCROLL_NONE. | 5390 // isn't surpassed and the overscroll mode stays OVERSCROLL_NONE. |
5185 TEST_F(RenderWidgetHostViewAuraOverscrollTest, ScrollDeltasResetOnEnd) { | 5391 void RenderWidgetHostViewAuraOverscrollTest::ScrollDeltasResetOnEnd() { |
5186 SetUpOverscrollEnvironment(); | 5392 SetUpOverscrollEnvironment(); |
5187 // Wheel event scroll ending with mouse move. | 5393 // Wheel event scroll ending with mouse move. |
5188 SimulateWheelEvent(-30, -10, 0, true); // sent directly | 5394 SimulateWheelEventPossiblyIncludingPhase( |
5395 !wheel_scroll_latching_enabled_, -30, -10, 0, true, | |
5396 WebMouseWheelEvent::kPhaseBegan); // sent directly | |
5189 SendInputEventACK(WebInputEvent::kMouseWheel, | 5397 SendInputEventACK(WebInputEvent::kMouseWheel, |
5190 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5398 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
5191 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 5399 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
5192 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5400 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
5193 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 5401 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
5194 EXPECT_EQ(-30.f, overscroll_delta_x()); | 5402 EXPECT_EQ(-30.f, overscroll_delta_x()); |
5195 EXPECT_EQ(-10.f, overscroll_delta_y()); | 5403 EXPECT_EQ(-10.f, overscroll_delta_y()); |
5196 SimulateMouseMove(5, 10, 0); | 5404 SimulateMouseMove(5, 10, 0); |
5197 EXPECT_EQ(0.f, overscroll_delta_x()); | 5405 EXPECT_EQ(0.f, overscroll_delta_x()); |
5198 EXPECT_EQ(0.f, overscroll_delta_y()); | 5406 EXPECT_EQ(0.f, overscroll_delta_y()); |
5199 | 5407 |
5200 // Scroll gesture. | 5408 // Scroll gesture. |
5201 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, | 5409 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, |
5202 blink::kWebGestureDeviceTouchscreen); | 5410 blink::kWebGestureDeviceTouchscreen); |
5203 SimulateGestureScrollUpdateEvent(-30, -5, 0); | 5411 SimulateGestureScrollUpdateEvent(-30, -5, 0); |
5204 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 5412 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
5205 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5413 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
5206 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 5414 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
5207 EXPECT_EQ(-30.f, overscroll_delta_x()); | 5415 EXPECT_EQ(-30.f, overscroll_delta_x()); |
5208 EXPECT_EQ(-5.f, overscroll_delta_y()); | 5416 EXPECT_EQ(-5.f, overscroll_delta_y()); |
5209 SimulateGestureEvent(WebInputEvent::kGestureScrollEnd, | 5417 SimulateGestureEvent(WebInputEvent::kGestureScrollEnd, |
5210 blink::kWebGestureDeviceTouchscreen); | 5418 blink::kWebGestureDeviceTouchscreen); |
5211 EXPECT_EQ(0.f, overscroll_delta_x()); | 5419 EXPECT_EQ(0.f, overscroll_delta_x()); |
5212 EXPECT_EQ(0.f, overscroll_delta_y()); | 5420 EXPECT_EQ(0.f, overscroll_delta_y()); |
5213 | 5421 |
5214 // Wheel event scroll ending with a fling. | 5422 // Wheel event scroll ending with a fling. |
5215 SimulateWheelEvent(5, 0, 0, true); | 5423 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 5, |
5216 SendInputEventACK(WebInputEvent::kMouseWheel, | 5424 0, 0, true, |
5217 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5425 WebMouseWheelEvent::kPhaseChanged); |
5426 if (wheel_scrolling_mode_ != kAsyncWheelEvents) { | |
5427 SendInputEventACK(WebInputEvent::kMouseWheel, | |
5428 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
5429 } | |
5218 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 5430 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
5219 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5431 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
5220 SimulateWheelEvent(10, -5, 0, true); | 5432 SimulateWheelEventPossiblyIncludingPhase(!wheel_scroll_latching_enabled_, 10, |
5221 SendInputEventACK(WebInputEvent::kMouseWheel, | 5433 -5, 0, true, |
5222 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5434 WebMouseWheelEvent::kPhaseChanged); |
5435 if (wheel_scrolling_mode_ != kAsyncWheelEvents) { | |
5436 SendInputEventACK(WebInputEvent::kMouseWheel, | |
5437 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
5438 } | |
5223 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, | 5439 SendInputEventACK(WebInputEvent::kGestureScrollUpdate, |
5224 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 5440 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
5225 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); | 5441 EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode()); |
5226 EXPECT_EQ(15.f, overscroll_delta_x()); | 5442 EXPECT_EQ(15.f, overscroll_delta_x()); |
5227 EXPECT_EQ(-5.f, overscroll_delta_y()); | 5443 EXPECT_EQ(-5.f, overscroll_delta_y()); |
5228 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, | 5444 SimulateGestureEvent(WebInputEvent::kGestureScrollBegin, |
5229 blink::kWebGestureDeviceTouchscreen); | 5445 blink::kWebGestureDeviceTouchscreen); |
5230 SimulateGestureFlingStartEvent(0.f, 0.1f, blink::kWebGestureDeviceTouchpad); | 5446 SimulateGestureFlingStartEvent(0.f, 0.1f, blink::kWebGestureDeviceTouchpad); |
5231 EXPECT_EQ(0.f, overscroll_delta_x()); | 5447 EXPECT_EQ(0.f, overscroll_delta_x()); |
5232 EXPECT_EQ(0.f, overscroll_delta_y()); | 5448 EXPECT_EQ(0.f, overscroll_delta_y()); |
5233 } | 5449 } |
5450 TEST_F(RenderWidgetHostViewAuraOverscrollTest, ScrollDeltasResetOnEnd) { | |
5451 ScrollDeltasResetOnEnd(); | |
5452 } | |
5453 TEST_F(RenderWidgetHostViewAuraOverscrollWithoutWheelScrollLatchingTest, | |
5454 ScrollDeltasResetOnEnd) { | |
5455 ScrollDeltasResetOnEnd(); | |
5456 } | |
5457 TEST_F(RenderWidgetHostViewAuraOverScrollAsyncWheelEventsEnabledTest, | |
5458 ScrollDeltasResetOnEnd) { | |
5459 ScrollDeltasResetOnEnd(); | |
5460 } | |
5234 | 5461 |
5235 TEST_F(RenderWidgetHostViewAuraTest, ForwardMouseEvent) { | 5462 TEST_F(RenderWidgetHostViewAuraTest, ForwardMouseEvent) { |
5236 aura::Window* root = parent_view_->GetNativeView()->GetRootWindow(); | 5463 aura::Window* root = parent_view_->GetNativeView()->GetRootWindow(); |
5237 | 5464 |
5238 // Set up test delegate and window hierarchy. | 5465 // Set up test delegate and window hierarchy. |
5239 aura::test::EventCountDelegate delegate; | 5466 aura::test::EventCountDelegate delegate; |
5240 std::unique_ptr<aura::Window> parent(new aura::Window(&delegate)); | 5467 std::unique_ptr<aura::Window> parent(new aura::Window(&delegate)); |
5241 parent->Init(ui::LAYER_TEXTURED); | 5468 parent->Init(ui::LAYER_TEXTURED); |
5242 root->AddChild(parent.get()); | 5469 root->AddChild(parent.get()); |
5243 view_->InitAsChild(parent.get()); | 5470 view_->InitAsChild(parent.get()); |
(...skipping 588 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
5832 // There is no composition in the beginning. | 6059 // There is no composition in the beginning. |
5833 EXPECT_FALSE(has_composition_text()); | 6060 EXPECT_FALSE(has_composition_text()); |
5834 SetHasCompositionTextToTrue(); | 6061 SetHasCompositionTextToTrue(); |
5835 view->ImeCancelComposition(); | 6062 view->ImeCancelComposition(); |
5836 // The composition must have been canceled. | 6063 // The composition must have been canceled. |
5837 EXPECT_FALSE(has_composition_text()); | 6064 EXPECT_FALSE(has_composition_text()); |
5838 } | 6065 } |
5839 } | 6066 } |
5840 | 6067 |
5841 } // namespace content | 6068 } // namespace content |
OLD | NEW |