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