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