Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(426)

Side by Side Diff: content/browser/renderer_host/input/touch_event_queue_unittest.cc

Issue 130993003: Prevent partial touch sequences from reaching the renderer (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Rebase Created 6 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2013 The Chromium Authors. All rights reserved. 1 // Copyright 2013 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 "base/basictypes.h" 5 #include "base/basictypes.h"
6 #include "base/logging.h" 6 #include "base/logging.h"
7 #include "base/memory/scoped_ptr.h" 7 #include "base/memory/scoped_ptr.h"
8 #include "base/message_loop/message_loop.h" 8 #include "base/message_loop/message_loop.h"
9 #include "content/browser/renderer_host/input/timeout_monitor.h" 9 #include "content/browser/renderer_host/input/timeout_monitor.h"
10 #include "content/browser/renderer_host/input/touch_event_queue.h" 10 #include "content/browser/renderer_host/input/touch_event_queue.h"
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after
143 } 143 }
144 144
145 bool IsPendingAckTouchStart() const { 145 bool IsPendingAckTouchStart() const {
146 return queue_->IsPendingAckTouchStart(); 146 return queue_->IsPendingAckTouchStart();
147 } 147 }
148 148
149 void OnHasTouchEventHandlers(bool has_handlers) { 149 void OnHasTouchEventHandlers(bool has_handlers) {
150 queue_->OnHasTouchEventHandlers(has_handlers); 150 queue_->OnHasTouchEventHandlers(has_handlers);
151 } 151 }
152 152
153 bool WillForwardTouchEvents() {
154 return queue_->has_handlers_ &&
155 !queue_->scroll_in_progress_ &&
156 !queue_->HasTimeoutEvent();
157 }
158
159 bool IsTimeoutRunning() { 153 bool IsTimeoutRunning() {
160 return queue_->IsTimeoutRunningForTesting(); 154 return queue_->IsTimeoutRunningForTesting();
161 } 155 }
162 156
163 size_t queued_event_count() const { 157 size_t queued_event_count() const {
164 return queue_->size(); 158 return queue_->size();
165 } 159 }
166 160
167 const WebTouchEvent& latest_event() const { 161 const WebTouchEvent& latest_event() const {
168 return queue_->GetLatestEventForTesting().event; 162 return queue_->GetLatestEventForTesting().event;
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after
257 EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type); 251 EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
258 252
259 // Flush the queue. The touch-event queue should now be emptied, but none of 253 // Flush the queue. The touch-event queue should now be emptied, but none of
260 // the queued touch-events should be sent to the renderer. 254 // the queued touch-events should be sent to the renderer.
261 OnHasTouchEventHandlers(false); 255 OnHasTouchEventHandlers(false);
262 EXPECT_EQ(0U, queued_event_count()); 256 EXPECT_EQ(0U, queued_event_count());
263 EXPECT_EQ(0U, GetAndResetSentEventCount()); 257 EXPECT_EQ(0U, GetAndResetSentEventCount());
264 EXPECT_EQ(31U, GetAndResetAckedEventCount()); 258 EXPECT_EQ(31U, GetAndResetAckedEventCount());
265 } 259 }
266 260
261 // Tests that addition of a touch handler during a touch sequence will not cause
262 // the remaining sequence to be forwarded.
263 TEST_F(TouchEventQueueTest, ActiveSequenceNotForwardedWhenHandlersAdded) {
264 OnHasTouchEventHandlers(false);
265
266 // Send a touch-press event while there is no handler.
267 PressTouchPoint(1, 1);
268 EXPECT_EQ(1U, GetAndResetAckedEventCount());
269 EXPECT_EQ(0U, GetAndResetSentEventCount());
270 EXPECT_EQ(0U, queued_event_count());
271
272 OnHasTouchEventHandlers(true);
273
274 // The remaining touch sequence should not be forwarded.
275 MoveTouchPoint(0, 5, 5);
276 ReleaseTouchPoint(0);
277 EXPECT_EQ(2U, GetAndResetAckedEventCount());
278 EXPECT_EQ(0U, GetAndResetSentEventCount());
279 EXPECT_EQ(0U, queued_event_count());
280
281 // A new touch sequence should resume forwarding.
282 PressTouchPoint(1, 1);
283 EXPECT_EQ(1U, queued_event_count());
284 EXPECT_EQ(1U, GetAndResetSentEventCount());
285 }
286
267 // Tests that removal of a touch handler during a touch sequence will prevent 287 // Tests that removal of a touch handler during a touch sequence will prevent
268 // the remaining sequence from being forwarded, even if another touch handler is 288 // the remaining sequence from being forwarded, even if another touch handler is
269 // registered during the same touch sequence. 289 // registered during the same touch sequence.
270 TEST_F(TouchEventQueueTest, ActiveSequenceDroppedWhenHandlersRemoved) { 290 TEST_F(TouchEventQueueTest, ActiveSequenceDroppedWhenHandlersRemoved) {
271 // Send a touch-press event. 291 // Send a touch-press event.
272 PressTouchPoint(1, 1); 292 PressTouchPoint(1, 1);
273 EXPECT_EQ(1U, GetAndResetSentEventCount()); 293 EXPECT_EQ(1U, GetAndResetSentEventCount());
274 EXPECT_EQ(1U, queued_event_count()); 294 EXPECT_EQ(1U, queued_event_count());
275 295
276 // Queue a touch-move event. 296 // Queue a touch-move event.
(...skipping 439 matching lines...) Expand 10 before | Expand all | Expand 10 after
716 EXPECT_EQ(1U, GetAndResetSentEventCount()); 736 EXPECT_EQ(1U, GetAndResetSentEventCount());
717 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 737 EXPECT_EQ(1U, GetAndResetAckedEventCount());
718 EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state()); 738 EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
719 EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type); 739 EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
720 } 740 }
721 741
722 // Tests basic TouchEvent forwarding suppression. 742 // Tests basic TouchEvent forwarding suppression.
723 TEST_F(TouchEventQueueTest, NoTouchBasic) { 743 TEST_F(TouchEventQueueTest, NoTouchBasic) {
724 // Disable TouchEvent forwarding. 744 // Disable TouchEvent forwarding.
725 OnHasTouchEventHandlers(false); 745 OnHasTouchEventHandlers(false);
726 MoveTouchPoint(0, 30, 5); 746 PressTouchPoint(30, 5);
727 EXPECT_EQ(0U, GetAndResetSentEventCount()); 747 EXPECT_EQ(0U, GetAndResetSentEventCount());
728 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 748 EXPECT_EQ(1U, GetAndResetAckedEventCount());
729 749
730 // TouchMove should not be sent to renderer. 750 // TouchMove should not be sent to renderer.
731 MoveTouchPoint(0, 65, 10); 751 MoveTouchPoint(0, 65, 10);
732 EXPECT_EQ(0U, GetAndResetSentEventCount()); 752 EXPECT_EQ(0U, GetAndResetSentEventCount());
733 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 753 EXPECT_EQ(1U, GetAndResetAckedEventCount());
734 754
735 // TouchEnd should not be sent to renderer. 755 // TouchEnd should not be sent to renderer.
736 ReleaseTouchPoint(0); 756 ReleaseTouchPoint(0);
737 EXPECT_EQ(0U, GetAndResetSentEventCount()); 757 EXPECT_EQ(0U, GetAndResetSentEventCount());
738 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 758 EXPECT_EQ(1U, GetAndResetAckedEventCount());
739 759
740 // TouchStart should not be sent to renderer.
741 PressTouchPoint(5, 5);
742 EXPECT_EQ(0U, GetAndResetSentEventCount());
743 EXPECT_EQ(1U, GetAndResetAckedEventCount());
744
745 // Enable TouchEvent forwarding. 760 // Enable TouchEvent forwarding.
746 OnHasTouchEventHandlers(true); 761 OnHasTouchEventHandlers(true);
747 762
748 PressTouchPoint(80, 10); 763 PressTouchPoint(80, 10);
749 EXPECT_EQ(1U, GetAndResetSentEventCount()); 764 EXPECT_EQ(1U, GetAndResetSentEventCount());
750 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 765 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
751 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 766 EXPECT_EQ(1U, GetAndResetAckedEventCount());
752 767
753 MoveTouchPoint(0, 80, 20); 768 MoveTouchPoint(0, 80, 20);
754 EXPECT_EQ(1U, GetAndResetSentEventCount()); 769 EXPECT_EQ(1U, GetAndResetSentEventCount());
(...skipping 21 matching lines...) Expand all
776 // Queue another TouchStart. 791 // Queue another TouchStart.
777 PressTouchPoint(20, 20); 792 PressTouchPoint(20, 20);
778 EXPECT_EQ(2U, queued_event_count()); 793 EXPECT_EQ(2U, queued_event_count());
779 EXPECT_EQ(0U, GetAndResetSentEventCount()); 794 EXPECT_EQ(0U, GetAndResetSentEventCount());
780 EXPECT_EQ(WebInputEvent::TouchStart, latest_event().type); 795 EXPECT_EQ(WebInputEvent::TouchStart, latest_event().type);
781 796
782 // GestureScrollBegin inserts a synthetic TouchCancel before the TouchStart. 797 // GestureScrollBegin inserts a synthetic TouchCancel before the TouchStart.
783 WebGestureEvent followup_scroll; 798 WebGestureEvent followup_scroll;
784 followup_scroll.type = WebInputEvent::GestureScrollBegin; 799 followup_scroll.type = WebInputEvent::GestureScrollBegin;
785 SetFollowupEvent(followup_scroll); 800 SetFollowupEvent(followup_scroll);
786 ASSERT_TRUE(WillForwardTouchEvents());
787 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 801 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
788 EXPECT_FALSE(WillForwardTouchEvents());
789 EXPECT_EQ(1U, GetAndResetSentEventCount()); 802 EXPECT_EQ(1U, GetAndResetSentEventCount());
790 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 803 EXPECT_EQ(1U, GetAndResetAckedEventCount());
791 EXPECT_EQ(2U, queued_event_count()); 804 EXPECT_EQ(2U, queued_event_count());
792 EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type); 805 EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type);
793 EXPECT_EQ(WebInputEvent::TouchStart, latest_event().type); 806 EXPECT_EQ(WebInputEvent::TouchStart, latest_event().type);
794 807
795 // Acking the TouchCancel will result in dispatch of the next TouchStart. 808 // Acking the TouchCancel will result in dispatch of the next TouchStart.
796 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 809 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
797 // The synthetic TouchCancel should not reach client, only the TouchStart. 810 // The synthetic TouchCancel should not reach client, only the TouchStart.
798 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 811 EXPECT_EQ(1U, GetAndResetAckedEventCount());
799 EXPECT_EQ(0U, GetAndResetSentEventCount()); 812 EXPECT_EQ(0U, GetAndResetSentEventCount());
800 EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type); 813 EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
801 814
802 // TouchMove should not be sent to the renderer. 815 // TouchMove should not be sent to the renderer.
803 MoveTouchPoint(0, 30, 5); 816 MoveTouchPoint(0, 30, 5);
804 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 817 EXPECT_EQ(1U, GetAndResetAckedEventCount());
805 EXPECT_EQ(0U, GetAndResetSentEventCount()); 818 EXPECT_EQ(0U, GetAndResetSentEventCount());
806 EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state()); 819 EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
807 820
808 // GestureScrollUpdates should not change affect touch forwarding. 821 // GestureScrollUpdates should not change affect touch forwarding.
809 SendGestureEvent(WebInputEvent::GestureScrollUpdate); 822 SendGestureEvent(WebInputEvent::GestureScrollUpdate);
810 EXPECT_FALSE(WillForwardTouchEvents());
811 823
812 // TouchEnd should not be sent to the renderer. 824 // TouchEnd should not be sent to the renderer.
813 ReleaseTouchPoint(0); 825 ReleaseTouchPoint(0);
814 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 826 EXPECT_EQ(1U, GetAndResetAckedEventCount());
815 EXPECT_EQ(0U, GetAndResetSentEventCount()); 827 EXPECT_EQ(0U, GetAndResetSentEventCount());
816 EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state()); 828 EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
817 829
818 // GestureScrollEnd will resume the sending of TouchEvents to renderer. 830 ReleaseTouchPoint(0);
819 SendGestureEvent(blink::WebInputEvent::GestureScrollEnd); 831 EXPECT_EQ(1U, GetAndResetAckedEventCount());
820 EXPECT_TRUE(WillForwardTouchEvents()); 832 EXPECT_EQ(0U, GetAndResetSentEventCount());
833 EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
821 834
822 // Now TouchEvents should be forwarded normally. 835 // Touch events from a new gesture sequence should be forwarded normally.
823 PressTouchPoint(80, 10); 836 PressTouchPoint(80, 10);
824 EXPECT_EQ(1U, GetAndResetSentEventCount()); 837 EXPECT_EQ(1U, GetAndResetSentEventCount());
825 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 838 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
826 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 839 EXPECT_EQ(1U, GetAndResetAckedEventCount());
827 840
828 MoveTouchPoint(0, 80, 20); 841 MoveTouchPoint(0, 80, 20);
829 EXPECT_EQ(1U, GetAndResetSentEventCount()); 842 EXPECT_EQ(1U, GetAndResetSentEventCount());
830 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 843 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
831 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 844 EXPECT_EQ(1U, GetAndResetAckedEventCount());
832 845
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after
920 TEST_F(TouchEventQueueTest, TouchTimeoutBasic) { 933 TEST_F(TouchEventQueueTest, TouchTimeoutBasic) {
921 SetUpForTimeoutTesting(kDefaultTouchTimeoutDelayMs); 934 SetUpForTimeoutTesting(kDefaultTouchTimeoutDelayMs);
922 935
923 // Queue a TouchStart. 936 // Queue a TouchStart.
924 GetAndResetSentEventCount(); 937 GetAndResetSentEventCount();
925 GetAndResetAckedEventCount(); 938 GetAndResetAckedEventCount();
926 PressTouchPoint(0, 1); 939 PressTouchPoint(0, 1);
927 ASSERT_EQ(1U, GetAndResetSentEventCount()); 940 ASSERT_EQ(1U, GetAndResetSentEventCount());
928 ASSERT_EQ(0U, GetAndResetAckedEventCount()); 941 ASSERT_EQ(0U, GetAndResetAckedEventCount());
929 EXPECT_TRUE(IsTimeoutRunning()); 942 EXPECT_TRUE(IsTimeoutRunning());
930 EXPECT_TRUE(WillForwardTouchEvents());
931 943
932 // Delay the ack. 944 // Delay the ack.
933 base::MessageLoop::current()->PostDelayedTask( 945 base::MessageLoop::current()->PostDelayedTask(
934 FROM_HERE, 946 FROM_HERE,
935 base::MessageLoop::QuitClosure(), 947 base::MessageLoop::QuitClosure(),
936 base::TimeDelta::FromMilliseconds(kDefaultTouchTimeoutDelayMs * 2)); 948 base::TimeDelta::FromMilliseconds(kDefaultTouchTimeoutDelayMs * 2));
937 base::MessageLoop::current()->Run(); 949 base::MessageLoop::current()->Run();
938 950
939 // The timeout should have fired, synthetically ack'ing the timed-out event. 951 // The timeout should have fired, synthetically ack'ing the timed-out event.
940 // TouchEvent forwarding is disabled until the ack is received for the 952 // TouchEvent forwarding is disabled until the ack is received for the
941 // timed-out event and the future cancel event. 953 // timed-out event and the future cancel event.
942 EXPECT_FALSE(IsTimeoutRunning()); 954 EXPECT_FALSE(IsTimeoutRunning());
943 EXPECT_FALSE(WillForwardTouchEvents());
944 EXPECT_EQ(0U, GetAndResetSentEventCount()); 955 EXPECT_EQ(0U, GetAndResetSentEventCount());
945 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 956 EXPECT_EQ(1U, GetAndResetAckedEventCount());
946 957
947 // Ack'ing the original event should trigger a cancel event. 958 // Ack'ing the original event should trigger a cancel event.
948 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 959 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
949 EXPECT_FALSE(IsTimeoutRunning()); 960 EXPECT_FALSE(IsTimeoutRunning());
950 EXPECT_FALSE(WillForwardTouchEvents());
951 EXPECT_EQ(0U, GetAndResetAckedEventCount()); 961 EXPECT_EQ(0U, GetAndResetAckedEventCount());
952 EXPECT_EQ(1U, GetAndResetSentEventCount()); 962 EXPECT_EQ(1U, GetAndResetSentEventCount());
953 963
954 // Touch events should not be forwarded until we receive the cancel acks. 964 // Touch events should not be forwarded until we receive the cancel acks.
955 PressTouchPoint(0, 1); 965 MoveTouchPoint(0, 1, 1);
956 ASSERT_EQ(0U, GetAndResetSentEventCount()); 966 ASSERT_EQ(0U, GetAndResetSentEventCount());
957 ASSERT_EQ(1U, GetAndResetAckedEventCount()); 967 ASSERT_EQ(1U, GetAndResetAckedEventCount());
958 968
969 ReleaseTouchPoint(0);
970 ASSERT_EQ(0U, GetAndResetSentEventCount());
971 ASSERT_EQ(1U, GetAndResetAckedEventCount());
972
959 // The synthetic TouchCancel ack should not reach the client, but should 973 // The synthetic TouchCancel ack should not reach the client, but should
960 // resume touch forwarding. 974 // resume touch forwarding.
961 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 975 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
962 EXPECT_EQ(0U, GetAndResetSentEventCount()); 976 EXPECT_EQ(0U, GetAndResetSentEventCount());
963 EXPECT_EQ(0U, GetAndResetAckedEventCount()); 977 EXPECT_EQ(0U, GetAndResetAckedEventCount());
964 EXPECT_TRUE(WillForwardTouchEvents());
965 978
966 // Subsequent events should be handled normally. 979 // Subsequent events should be handled normally.
967 PressTouchPoint(0, 1); 980 PressTouchPoint(0, 1);
968 EXPECT_EQ(1U, GetAndResetSentEventCount()); 981 EXPECT_EQ(1U, GetAndResetSentEventCount());
969 EXPECT_EQ(0U, GetAndResetAckedEventCount()); 982 EXPECT_EQ(0U, GetAndResetAckedEventCount());
970 } 983 }
971 984
972 // Tests that the timeout is never started if the renderer consumes 985 // Tests that the timeout is never started if the renderer consumes
973 // a TouchEvent from the current touch sequence. 986 // a TouchEvent from the current touch sequence.
974 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfRendererIsConsumingGesture) { 987 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfRendererIsConsumingGesture) {
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after
1028 } 1041 }
1029 1042
1030 // Tests that a TouchCancel timeout plays nice when the timed out touch stream 1043 // Tests that a TouchCancel timeout plays nice when the timed out touch stream
1031 // turns into a scroll gesture sequence. 1044 // turns into a scroll gesture sequence.
1032 TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGesture) { 1045 TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGesture) {
1033 SetUpForTimeoutTesting(kDefaultTouchTimeoutDelayMs); 1046 SetUpForTimeoutTesting(kDefaultTouchTimeoutDelayMs);
1034 1047
1035 // Queue a TouchStart. 1048 // Queue a TouchStart.
1036 PressTouchPoint(0, 1); 1049 PressTouchPoint(0, 1);
1037 EXPECT_TRUE(IsTimeoutRunning()); 1050 EXPECT_TRUE(IsTimeoutRunning());
1038 EXPECT_TRUE(WillForwardTouchEvents());
1039 EXPECT_EQ(1U, GetAndResetSentEventCount()); 1051 EXPECT_EQ(1U, GetAndResetSentEventCount());
1040 1052
1041 // The cancelled sequence may turn into a scroll gesture. 1053 // The cancelled sequence may turn into a scroll gesture.
1042 WebGestureEvent followup_scroll; 1054 WebGestureEvent followup_scroll;
1043 followup_scroll.type = WebInputEvent::GestureScrollBegin; 1055 followup_scroll.type = WebInputEvent::GestureScrollBegin;
1044 SetFollowupEvent(followup_scroll); 1056 SetFollowupEvent(followup_scroll);
1045 1057
1046 // Delay the ack. 1058 // Delay the ack.
1047 base::MessageLoop::current()->PostDelayedTask( 1059 base::MessageLoop::current()->PostDelayedTask(
1048 FROM_HERE, 1060 FROM_HERE,
1049 base::MessageLoop::QuitClosure(), 1061 base::MessageLoop::QuitClosure(),
1050 base::TimeDelta::FromMilliseconds(kDefaultTouchTimeoutDelayMs * 2)); 1062 base::TimeDelta::FromMilliseconds(kDefaultTouchTimeoutDelayMs * 2));
1051 base::MessageLoop::current()->Run(); 1063 base::MessageLoop::current()->Run();
1052 1064
1053 // The timeout should have fired, disabling touch forwarding until both acks 1065 // The timeout should have fired, disabling touch forwarding until both acks
1054 // are received, acking the timed out event. 1066 // are received, acking the timed out event.
1055 EXPECT_FALSE(IsTimeoutRunning()); 1067 EXPECT_FALSE(IsTimeoutRunning());
1056 EXPECT_FALSE(WillForwardTouchEvents());
1057 EXPECT_EQ(0U, GetAndResetSentEventCount()); 1068 EXPECT_EQ(0U, GetAndResetSentEventCount());
1058 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 1069 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1059 1070
1060 // Ack the original event, triggering a TouchCancel. 1071 // Ack the original event, triggering a TouchCancel.
1061 SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED); 1072 SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
1062 EXPECT_FALSE(IsTimeoutRunning()); 1073 EXPECT_FALSE(IsTimeoutRunning());
1063 EXPECT_FALSE(WillForwardTouchEvents());
1064 EXPECT_EQ(1U, GetAndResetSentEventCount()); 1074 EXPECT_EQ(1U, GetAndResetSentEventCount());
1065 EXPECT_EQ(0U, GetAndResetAckedEventCount()); 1075 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1066 1076
1067 // Ack the cancel event. Normally, this would resume touch forwarding, 1077 // Ack the cancel event. Normally, this would resume touch forwarding,
1068 // but we're still within a scroll gesture so it remains disabled. 1078 // but we're still within a scroll gesture so it remains disabled.
1069 SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED); 1079 SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
1070 EXPECT_FALSE(IsTimeoutRunning()); 1080 EXPECT_FALSE(IsTimeoutRunning());
1071 EXPECT_FALSE(WillForwardTouchEvents());
1072 EXPECT_EQ(0U, GetAndResetSentEventCount()); 1081 EXPECT_EQ(0U, GetAndResetSentEventCount());
1073 EXPECT_EQ(0U, GetAndResetAckedEventCount()); 1082 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1074 1083
1075 // Try to forward a touch event. 1084 // Try to forward touch events for the current sequence.
1076 GetAndResetSentEventCount(); 1085 GetAndResetSentEventCount();
1077 GetAndResetAckedEventCount(); 1086 GetAndResetAckedEventCount();
1078 PressTouchPoint(0, 1); 1087 MoveTouchPoint(0, 1, 1);
1088 ReleaseTouchPoint(0);
1079 EXPECT_FALSE(IsTimeoutRunning()); 1089 EXPECT_FALSE(IsTimeoutRunning());
1080 EXPECT_EQ(0U, GetAndResetSentEventCount()); 1090 EXPECT_EQ(0U, GetAndResetSentEventCount());
1081 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 1091 EXPECT_EQ(2U, GetAndResetAckedEventCount());
1082 1092
1083 // Now end the scroll sequence, resuming touch handling. 1093 // Now end the scroll sequence, resuming touch handling.
1084 SendGestureEvent(blink::WebInputEvent::GestureScrollEnd); 1094 SendGestureEvent(blink::WebInputEvent::GestureScrollEnd);
1085 EXPECT_TRUE(WillForwardTouchEvents());
1086 PressTouchPoint(0, 1); 1095 PressTouchPoint(0, 1);
1087 EXPECT_TRUE(IsTimeoutRunning()); 1096 EXPECT_TRUE(IsTimeoutRunning());
1088 EXPECT_EQ(1U, GetAndResetSentEventCount()); 1097 EXPECT_EQ(1U, GetAndResetSentEventCount());
1089 EXPECT_EQ(0U, GetAndResetAckedEventCount()); 1098 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1090 } 1099 }
1091 1100
1092 // Tests that a TouchCancel timeout plays nice when the timed out touch stream 1101 // Tests that a TouchCancel timeout plays nice when the timed out touch stream
1093 // turns into a scroll gesture sequence, but the original event acks are 1102 // turns into a scroll gesture sequence, but the original event acks are
1094 // significantly delayed. 1103 // significantly delayed.
1095 TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGestureAndDelayedAck) { 1104 TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGestureAndDelayedAck) {
1096 SetUpForTimeoutTesting(kDefaultTouchTimeoutDelayMs); 1105 SetUpForTimeoutTesting(kDefaultTouchTimeoutDelayMs);
1097 1106
1098 // Queue a TouchStart. 1107 // Queue a TouchStart.
1099 PressTouchPoint(0, 1); 1108 PressTouchPoint(0, 1);
1100 EXPECT_TRUE(IsTimeoutRunning()); 1109 EXPECT_TRUE(IsTimeoutRunning());
1101 EXPECT_TRUE(WillForwardTouchEvents());
1102 EXPECT_EQ(1U, GetAndResetSentEventCount()); 1110 EXPECT_EQ(1U, GetAndResetSentEventCount());
1103 1111
1104 // The cancelled sequence may turn into a scroll gesture. 1112 // The cancelled sequence may turn into a scroll gesture.
1105 WebGestureEvent followup_scroll; 1113 WebGestureEvent followup_scroll;
1106 followup_scroll.type = WebInputEvent::GestureScrollBegin; 1114 followup_scroll.type = WebInputEvent::GestureScrollBegin;
1107 SetFollowupEvent(followup_scroll); 1115 SetFollowupEvent(followup_scroll);
1108 1116
1109 // Delay the ack. 1117 // Delay the ack.
1110 base::MessageLoop::current()->PostDelayedTask( 1118 base::MessageLoop::current()->PostDelayedTask(
1111 FROM_HERE, 1119 FROM_HERE,
1112 base::MessageLoop::QuitClosure(), 1120 base::MessageLoop::QuitClosure(),
1113 base::TimeDelta::FromMilliseconds(kDefaultTouchTimeoutDelayMs * 2)); 1121 base::TimeDelta::FromMilliseconds(kDefaultTouchTimeoutDelayMs * 2));
1114 base::MessageLoop::current()->Run(); 1122 base::MessageLoop::current()->Run();
1115 1123
1116 // The timeout should have fired, disabling touch forwarding until both acks 1124 // The timeout should have fired, disabling touch forwarding until both acks
1117 // are received and acking the timed out event. 1125 // are received and acking the timed out event.
1118 EXPECT_FALSE(IsTimeoutRunning()); 1126 EXPECT_FALSE(IsTimeoutRunning());
1119 EXPECT_FALSE(WillForwardTouchEvents());
1120 EXPECT_EQ(0U, GetAndResetSentEventCount()); 1127 EXPECT_EQ(0U, GetAndResetSentEventCount());
1121 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 1128 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1122 1129
1123 // Try to forward a touch event. 1130 // Try to forward a touch event.
1124 GetAndResetSentEventCount(); 1131 GetAndResetSentEventCount();
1125 GetAndResetAckedEventCount(); 1132 GetAndResetAckedEventCount();
1126 PressTouchPoint(0, 1); 1133 MoveTouchPoint(0, 1, 1);
1127 EXPECT_FALSE(IsTimeoutRunning()); 1134 EXPECT_FALSE(IsTimeoutRunning());
1128 EXPECT_EQ(0U, GetAndResetSentEventCount()); 1135 EXPECT_EQ(0U, GetAndResetSentEventCount());
1129 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 1136 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1130 1137
1131 // Now end the scroll sequence. Events will not be forwarded until the two 1138 // Now end the scroll sequence. Events will not be forwarded until the two
1132 // outstanding touch acks are received. 1139 // outstanding touch acks are received.
1133 SendGestureEvent(blink::WebInputEvent::GestureScrollEnd); 1140 SendGestureEvent(blink::WebInputEvent::GestureScrollEnd);
1134 PressTouchPoint(0, 1); 1141 MoveTouchPoint(0, 2, 2);
1142 ReleaseTouchPoint(0);
1135 EXPECT_FALSE(IsTimeoutRunning()); 1143 EXPECT_FALSE(IsTimeoutRunning());
1136 EXPECT_EQ(0U, GetAndResetSentEventCount()); 1144 EXPECT_EQ(0U, GetAndResetSentEventCount());
1137 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 1145 EXPECT_EQ(2U, GetAndResetAckedEventCount());
1138 1146
1139 // Ack the original event, triggering a cancel. 1147 // Ack the original event, triggering a cancel.
1140 SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED); 1148 SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
1141 EXPECT_EQ(1U, GetAndResetSentEventCount()); 1149 EXPECT_EQ(1U, GetAndResetSentEventCount());
1142 EXPECT_EQ(0U, GetAndResetAckedEventCount()); 1150 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1143 1151
1144 // Ack the cancel event, resuming touch forwarding. 1152 // Ack the cancel event, resuming touch forwarding.
1145 SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED); 1153 SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
1146 EXPECT_EQ(0U, GetAndResetSentEventCount()); 1154 EXPECT_EQ(0U, GetAndResetSentEventCount());
1147 EXPECT_EQ(0U, GetAndResetAckedEventCount()); 1155 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1148 1156
1149 PressTouchPoint(0, 1); 1157 PressTouchPoint(0, 1);
1150 EXPECT_TRUE(IsTimeoutRunning()); 1158 EXPECT_TRUE(IsTimeoutRunning());
1151 EXPECT_EQ(1U, GetAndResetSentEventCount()); 1159 EXPECT_EQ(1U, GetAndResetSentEventCount());
1152 } 1160 }
1153 1161
1154 // Tests that a delayed TouchEvent ack will not trigger a TouchCancel timeout if 1162 // Tests that a delayed TouchEvent ack will not trigger a TouchCancel timeout if
1155 // the timed-out event had no consumer. 1163 // the timed-out event had no consumer.
1156 TEST_F(TouchEventQueueTest, NoCancelOnTouchTimeoutWithoutConsumer) { 1164 TEST_F(TouchEventQueueTest, NoCancelOnTouchTimeoutWithoutConsumer) {
1157 SetUpForTimeoutTesting(kDefaultTouchTimeoutDelayMs); 1165 SetUpForTimeoutTesting(kDefaultTouchTimeoutDelayMs);
1158 1166
1159 // Queue a TouchStart. 1167 // Queue a TouchStart.
1160 PressTouchPoint(0, 1); 1168 PressTouchPoint(0, 1);
1161 ASSERT_EQ(1U, GetAndResetSentEventCount()); 1169 ASSERT_EQ(1U, GetAndResetSentEventCount());
1162 ASSERT_EQ(0U, GetAndResetAckedEventCount()); 1170 ASSERT_EQ(0U, GetAndResetAckedEventCount());
1163 EXPECT_TRUE(IsTimeoutRunning()); 1171 EXPECT_TRUE(IsTimeoutRunning());
1164 EXPECT_TRUE(WillForwardTouchEvents());
1165 1172
1166 // Delay the ack. 1173 // Delay the ack.
1167 base::MessageLoop::current()->PostDelayedTask( 1174 base::MessageLoop::current()->PostDelayedTask(
1168 FROM_HERE, 1175 FROM_HERE,
1169 base::MessageLoop::QuitClosure(), 1176 base::MessageLoop::QuitClosure(),
1170 base::TimeDelta::FromMilliseconds(kDefaultTouchTimeoutDelayMs * 2)); 1177 base::TimeDelta::FromMilliseconds(kDefaultTouchTimeoutDelayMs * 2));
1171 base::MessageLoop::current()->Run(); 1178 base::MessageLoop::current()->Run();
1172 1179
1173 // The timeout should have fired, synthetically ack'ing the timed out event. 1180 // The timeout should have fired, synthetically ack'ing the timed out event.
1174 // TouchEvent forwarding is disabled until the original ack is received. 1181 // TouchEvent forwarding is disabled until the original ack is received.
1175 EXPECT_FALSE(IsTimeoutRunning()); 1182 EXPECT_FALSE(IsTimeoutRunning());
1176 EXPECT_FALSE(WillForwardTouchEvents());
1177 EXPECT_EQ(0U, GetAndResetSentEventCount()); 1183 EXPECT_EQ(0U, GetAndResetSentEventCount());
1178 EXPECT_EQ(1U, GetAndResetAckedEventCount()); 1184 EXPECT_EQ(1U, GetAndResetAckedEventCount());
1179 1185
1180 // Touch events should not be forwarded until we receive the original ack. 1186 // Touch events should not be forwarded until we receive the original ack.
1181 PressTouchPoint(0, 1); 1187 MoveTouchPoint(0, 1, 1);
1188 ReleaseTouchPoint(0);
1182 ASSERT_EQ(0U, GetAndResetSentEventCount()); 1189 ASSERT_EQ(0U, GetAndResetSentEventCount());
1183 ASSERT_EQ(1U, GetAndResetAckedEventCount()); 1190 ASSERT_EQ(2U, GetAndResetAckedEventCount());
1184 1191
1185 // Ack'ing the original event should not trigger a cancel event, as the 1192 // Ack'ing the original event should not trigger a cancel event, as the
1186 // TouchStart had no consumer. However, it should re-enable touch forwarding. 1193 // TouchStart had no consumer. However, it should re-enable touch forwarding.
1187 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); 1194 SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
1188 EXPECT_FALSE(IsTimeoutRunning()); 1195 EXPECT_FALSE(IsTimeoutRunning());
1189 EXPECT_TRUE(WillForwardTouchEvents());
1190 EXPECT_EQ(0U, GetAndResetAckedEventCount()); 1196 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1191 EXPECT_EQ(0U, GetAndResetSentEventCount()); 1197 EXPECT_EQ(0U, GetAndResetSentEventCount());
1192 1198
1193 // Subsequent events should be handled normally. 1199 // Subsequent events should be handled normally.
1194 PressTouchPoint(0, 1); 1200 PressTouchPoint(0, 1);
1195 EXPECT_EQ(1U, GetAndResetSentEventCount()); 1201 EXPECT_EQ(1U, GetAndResetSentEventCount());
1196 EXPECT_EQ(0U, GetAndResetAckedEventCount()); 1202 EXPECT_EQ(0U, GetAndResetAckedEventCount());
1197 } 1203 }
1198 } // namespace content 1204 } // namespace content
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698