OLD | NEW |
---|---|
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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 <stddef.h> | 5 #include <stddef.h> |
6 | 6 |
7 #include <new> | 7 #include <new> |
8 #include <utility> | 8 #include <utility> |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
11 #include "base/macros.h" | 11 #include "base/macros.h" |
12 #include "base/test/histogram_tester.h" | |
12 #include "base/test/test_simple_task_runner.h" | 13 #include "base/test/test_simple_task_runner.h" |
13 #include "build/build_config.h" | 14 #include "build/build_config.h" |
14 #include "content/common/input/synthetic_web_input_event_builders.h" | 15 #include "content/common/input/synthetic_web_input_event_builders.h" |
15 #include "content/renderer/input/main_thread_event_queue.h" | 16 #include "content/renderer/input/main_thread_event_queue.h" |
16 #include "content/renderer/render_thread_impl.h" | 17 #include "content/renderer/render_thread_impl.h" |
17 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
18 #include "third_party/WebKit/public/platform/scheduler/test/mock_renderer_schedu ler.h" | 19 #include "third_party/WebKit/public/platform/scheduler/test/mock_renderer_schedu ler.h" |
19 | 20 |
20 using blink::WebInputEvent; | 21 using blink::WebInputEvent; |
21 using blink::WebMouseEvent; | 22 using blink::WebMouseEvent; |
22 using blink::WebMouseWheelEvent; | 23 using blink::WebMouseWheelEvent; |
23 using blink::WebTouchEvent; | 24 using blink::WebTouchEvent; |
24 | 25 |
25 namespace blink { | 26 namespace blink { |
26 bool operator==(const WebMouseWheelEvent& lhs, const WebMouseWheelEvent& rhs) { | 27 bool operator==(const WebMouseWheelEvent& lhs, const WebMouseWheelEvent& rhs) { |
27 return memcmp(&lhs, &rhs, lhs.size) == 0; | 28 return memcmp(&lhs, &rhs, lhs.size) == 0; |
28 } | 29 } |
29 | 30 |
30 bool operator==(const WebTouchEvent& lhs, const WebTouchEvent& rhs) { | 31 bool operator==(const WebTouchEvent& lhs, const WebTouchEvent& rhs) { |
31 return memcmp(&lhs, &rhs, lhs.size) == 0; | 32 return memcmp(&lhs, &rhs, lhs.size) == 0; |
32 } | 33 } |
33 } // namespace blink | 34 } // namespace blink |
34 | 35 |
35 namespace content { | 36 namespace content { |
36 namespace { | 37 namespace { |
37 | 38 |
38 const int kTestRoutingID = 13; | 39 const int kTestRoutingID = 13; |
40 const char* kCoalescedCountHistogram = | |
41 "Event.MainThreadEventQueue.CoalescedCount"; | |
tdresser
2016/08/24 13:43:00
Missing space
dtapuska
2016/08/24 17:10:06
you mean a LF? done.
| |
39 } | 42 } |
40 | 43 |
41 class MainThreadEventQueueTest : public testing::Test, | 44 class MainThreadEventQueueTest : public testing::TestWithParam<bool>, |
42 public MainThreadEventQueueClient { | 45 public MainThreadEventQueueClient { |
43 public: | 46 public: |
44 MainThreadEventQueueTest() | 47 MainThreadEventQueueTest() |
45 : main_task_runner_(new base::TestSimpleTaskRunner()), | 48 : main_task_runner_(new base::TestSimpleTaskRunner()), |
46 queue_(new MainThreadEventQueue(kTestRoutingID, | 49 queue_(new MainThreadEventQueue(kTestRoutingID, |
47 this, | 50 this, |
48 main_task_runner_, | 51 main_task_runner_, |
49 &renderer_scheduler_)) {} | 52 &renderer_scheduler_, |
53 GetParam())), | |
54 needs_main_frame_(false) {} | |
tdresser
2016/08/24 13:43:00
This indentation looks off.
dtapuska
2016/08/24 17:10:07
how so; this is run through git cl format.
tdresser
2016/08/24 17:45:16
Nevermind.
| |
50 | 55 |
51 void HandleEventOnMainThread(int routing_id, | 56 void HandleEventOnMainThread(int routing_id, |
52 const blink::WebInputEvent* event, | 57 const blink::WebInputEvent* event, |
53 const ui::LatencyInfo& latency, | 58 const ui::LatencyInfo& latency, |
54 InputEventDispatchType type) override { | 59 InputEventDispatchType type) override { |
55 EXPECT_EQ(kTestRoutingID, routing_id); | 60 EXPECT_EQ(kTestRoutingID, routing_id); |
56 handled_events_.push_back(ui::WebInputEventTraits::Clone(*event)); | 61 handled_events_.push_back(ui::WebInputEventTraits::Clone(*event)); |
57 queue_->EventHandled(event->type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 62 queue_->EventHandled(event->type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
58 } | 63 } |
59 | 64 |
60 void SendInputEventAck(int routing_id, | 65 void SendInputEventAck(int routing_id, |
61 blink::WebInputEvent::Type type, | 66 blink::WebInputEvent::Type type, |
62 InputEventAckState ack_result, | 67 InputEventAckState ack_result, |
63 uint32_t touch_event_id) override { | 68 uint32_t touch_event_id) override { |
64 additional_acked_events_.push_back(touch_event_id); | 69 additional_acked_events_.push_back(touch_event_id); |
65 } | 70 } |
66 | 71 |
67 void HandleEvent(WebInputEvent& event, InputEventAckState ack_result) { | 72 void HandleEvent(WebInputEvent& event, InputEventAckState ack_result) { |
68 queue_->HandleEvent(ui::WebInputEventTraits::Clone(event), | 73 queue_->HandleEvent(ui::WebInputEventTraits::Clone(event), |
69 ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, ack_result); | 74 ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, ack_result); |
70 } | 75 } |
71 | 76 |
77 void NeedsMainFrame(int routing_id) override { needs_main_frame_ = true; } | |
78 | |
72 WebInputEventQueue<EventWithDispatchType>& event_queue() { | 79 WebInputEventQueue<EventWithDispatchType>& event_queue() { |
73 return queue_->events_; | 80 return queue_->events_; |
74 } | 81 } |
75 | 82 |
76 void set_is_flinging(bool is_flinging) { | 83 void set_is_flinging(bool is_flinging) { |
77 queue_->set_is_flinging(is_flinging); | 84 queue_->set_is_flinging(is_flinging); |
78 } | 85 } |
79 | 86 |
80 bool last_touch_start_forced_nonblocking_due_to_fling() { | 87 bool last_touch_start_forced_nonblocking_due_to_fling() { |
81 return queue_->last_touch_start_forced_nonblocking_due_to_fling_; | 88 return queue_->last_touch_start_forced_nonblocking_due_to_fling_; |
82 } | 89 } |
83 | 90 |
84 void set_enable_fling_passive_listener_flag(bool enable_flag) { | 91 void set_enable_fling_passive_listener_flag(bool enable_flag) { |
85 queue_->enable_fling_passive_listener_flag_ = enable_flag; | 92 queue_->enable_fling_passive_listener_flag_ = enable_flag; |
86 } | 93 } |
87 | 94 |
95 void RunPendingTasksWithSimulatedRaf() { | |
96 while (needs_main_frame_ || main_task_runner_->HasPendingTask()) { | |
97 main_task_runner_->RunUntilIdle(); | |
98 needs_main_frame_ = false; | |
99 queue_->DispatchRafAlignedInput(); | |
100 } | |
101 } | |
102 | |
103 void RunSimulatedRafOnce() { | |
104 if (needs_main_frame_) { | |
105 needs_main_frame_ = false; | |
106 queue_->DispatchRafAlignedInput(); | |
107 } | |
108 } | |
109 | |
88 protected: | 110 protected: |
89 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; | 111 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; |
90 blink::scheduler::MockRendererScheduler renderer_scheduler_; | 112 blink::scheduler::MockRendererScheduler renderer_scheduler_; |
91 scoped_refptr<MainThreadEventQueue> queue_; | 113 scoped_refptr<MainThreadEventQueue> queue_; |
92 std::vector<ui::ScopedWebInputEvent> handled_events_; | 114 std::vector<ui::ScopedWebInputEvent> handled_events_; |
93 std::vector<uint32_t> additional_acked_events_; | 115 std::vector<uint32_t> additional_acked_events_; |
116 bool needs_main_frame_; | |
94 }; | 117 }; |
95 | 118 |
96 TEST_F(MainThreadEventQueueTest, NonBlockingWheel) { | 119 TEST_P(MainThreadEventQueueTest, NonBlockingWheel) { |
120 base::HistogramTester histogram_tester; | |
121 | |
97 WebMouseWheelEvent kEvents[4] = { | 122 WebMouseWheelEvent kEvents[4] = { |
98 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false), | 123 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false), |
99 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), | 124 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), |
100 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), | 125 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), |
101 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), | 126 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), |
102 }; | 127 }; |
103 | 128 |
104 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 129 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
105 EXPECT_EQ(0u, event_queue().size()); | 130 EXPECT_EQ(0u, event_queue().size()); |
106 | 131 |
107 for (WebMouseWheelEvent& event : kEvents) | 132 for (WebMouseWheelEvent& event : kEvents) |
108 HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 133 HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
109 | 134 |
110 EXPECT_EQ(2u, event_queue().size()); | 135 EXPECT_EQ(2u, event_queue().size()); |
111 EXPECT_TRUE(main_task_runner_->HasPendingTask()); | 136 EXPECT_EQ(GetParam(), !main_task_runner_->HasPendingTask()); |
112 main_task_runner_->RunUntilIdle(); | 137 RunPendingTasksWithSimulatedRaf(); |
113 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 138 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
114 EXPECT_EQ(0u, event_queue().size()); | 139 EXPECT_EQ(0u, event_queue().size()); |
115 EXPECT_EQ(2u, handled_events_.size()); | 140 EXPECT_EQ(2u, handled_events_.size()); |
116 | 141 |
117 { | 142 { |
118 EXPECT_EQ(kEvents[0].size, handled_events_.at(0)->size); | 143 EXPECT_EQ(kEvents[0].size, handled_events_.at(0)->size); |
119 EXPECT_EQ(kEvents[0].type, handled_events_.at(0)->type); | 144 EXPECT_EQ(kEvents[0].type, handled_events_.at(0)->type); |
120 const WebMouseWheelEvent* last_wheel_event = | 145 const WebMouseWheelEvent* last_wheel_event = |
121 static_cast<const WebMouseWheelEvent*>(handled_events_.at(0).get()); | 146 static_cast<const WebMouseWheelEvent*>(handled_events_.at(0).get()); |
122 EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive, | 147 EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive, |
123 last_wheel_event->dispatchType); | 148 last_wheel_event->dispatchType); |
124 WebMouseWheelEvent coalesced_event = kEvents[0]; | 149 WebMouseWheelEvent coalesced_event = kEvents[0]; |
125 internal::Coalesce(kEvents[1], &coalesced_event); | 150 internal::Coalesce(kEvents[1], &coalesced_event); |
126 coalesced_event.dispatchType = | 151 coalesced_event.dispatchType = |
127 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 152 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
128 EXPECT_EQ(coalesced_event, *last_wheel_event); | 153 EXPECT_EQ(coalesced_event, *last_wheel_event); |
129 } | 154 } |
130 | 155 |
131 { | 156 { |
132 const WebMouseWheelEvent* last_wheel_event = | 157 const WebMouseWheelEvent* last_wheel_event = |
133 static_cast<const WebMouseWheelEvent*>(handled_events_.at(1).get()); | 158 static_cast<const WebMouseWheelEvent*>(handled_events_.at(1).get()); |
134 WebMouseWheelEvent coalesced_event = kEvents[2]; | 159 WebMouseWheelEvent coalesced_event = kEvents[2]; |
135 internal::Coalesce(kEvents[3], &coalesced_event); | 160 internal::Coalesce(kEvents[3], &coalesced_event); |
136 coalesced_event.dispatchType = | 161 coalesced_event.dispatchType = |
137 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 162 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
138 EXPECT_EQ(coalesced_event, *last_wheel_event); | 163 EXPECT_EQ(coalesced_event, *last_wheel_event); |
139 } | 164 } |
165 histogram_tester.ExpectUniqueSample(kCoalescedCountHistogram, 1, 2); | |
140 } | 166 } |
141 | 167 |
142 TEST_F(MainThreadEventQueueTest, NonBlockingTouch) { | 168 TEST_P(MainThreadEventQueueTest, NonBlockingTouch) { |
169 base::HistogramTester histogram_tester; | |
170 | |
143 SyntheticWebTouchEvent kEvents[4]; | 171 SyntheticWebTouchEvent kEvents[4]; |
144 kEvents[0].PressPoint(10, 10); | 172 kEvents[0].PressPoint(10, 10); |
145 kEvents[1].PressPoint(10, 10); | 173 kEvents[1].PressPoint(10, 10); |
146 kEvents[1].modifiers = 1; | 174 kEvents[1].modifiers = 1; |
147 kEvents[1].MovePoint(0, 20, 20); | 175 kEvents[1].MovePoint(0, 20, 20); |
148 kEvents[2].PressPoint(10, 10); | 176 kEvents[2].PressPoint(10, 10); |
149 kEvents[2].MovePoint(0, 30, 30); | 177 kEvents[2].MovePoint(0, 30, 30); |
150 kEvents[3].PressPoint(10, 10); | 178 kEvents[3].PressPoint(10, 10); |
151 kEvents[3].MovePoint(0, 35, 35); | 179 kEvents[3].MovePoint(0, 35, 35); |
152 | 180 |
153 for (SyntheticWebTouchEvent& event : kEvents) | 181 for (SyntheticWebTouchEvent& event : kEvents) |
154 HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 182 HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
155 | 183 |
156 EXPECT_EQ(3u, event_queue().size()); | 184 EXPECT_EQ(3u, event_queue().size()); |
157 EXPECT_TRUE(main_task_runner_->HasPendingTask()); | 185 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
158 main_task_runner_->RunUntilIdle(); | 186 RunPendingTasksWithSimulatedRaf(); |
159 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 187 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
160 EXPECT_EQ(0u, event_queue().size()); | 188 EXPECT_EQ(0u, event_queue().size()); |
161 EXPECT_EQ(3u, handled_events_.size()); | 189 EXPECT_EQ(3u, handled_events_.size()); |
162 | 190 |
163 EXPECT_EQ(kEvents[0].size, handled_events_.at(0)->size); | 191 EXPECT_EQ(kEvents[0].size, handled_events_.at(0)->size); |
164 EXPECT_EQ(kEvents[0].type, handled_events_.at(0)->type); | 192 EXPECT_EQ(kEvents[0].type, handled_events_.at(0)->type); |
165 const WebTouchEvent* last_touch_event = | 193 const WebTouchEvent* last_touch_event = |
166 static_cast<const WebTouchEvent*>(handled_events_.at(0).get()); | 194 static_cast<const WebTouchEvent*>(handled_events_.at(0).get()); |
167 kEvents[0].dispatchType = | 195 kEvents[0].dispatchType = |
168 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 196 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
169 EXPECT_EQ(kEvents[0], *last_touch_event); | 197 EXPECT_EQ(kEvents[0], *last_touch_event); |
170 | 198 |
171 EXPECT_EQ(kEvents[1].size, handled_events_.at(1)->size); | 199 EXPECT_EQ(kEvents[1].size, handled_events_.at(1)->size); |
172 EXPECT_EQ(kEvents[1].type, handled_events_.at(1)->type); | 200 EXPECT_EQ(kEvents[1].type, handled_events_.at(1)->type); |
173 last_touch_event = | 201 last_touch_event = |
174 static_cast<const WebTouchEvent*>(handled_events_.at(1).get()); | 202 static_cast<const WebTouchEvent*>(handled_events_.at(1).get()); |
175 kEvents[1].dispatchType = | 203 kEvents[1].dispatchType = |
176 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 204 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
177 EXPECT_EQ(kEvents[1], *last_touch_event); | 205 EXPECT_EQ(kEvents[1], *last_touch_event); |
178 | 206 |
179 EXPECT_EQ(kEvents[2].size, handled_events_.at(1)->size); | 207 EXPECT_EQ(kEvents[2].size, handled_events_.at(1)->size); |
180 EXPECT_EQ(kEvents[2].type, handled_events_.at(2)->type); | 208 EXPECT_EQ(kEvents[2].type, handled_events_.at(2)->type); |
181 last_touch_event = | 209 last_touch_event = |
182 static_cast<const WebTouchEvent*>(handled_events_.at(2).get()); | 210 static_cast<const WebTouchEvent*>(handled_events_.at(2).get()); |
183 WebTouchEvent coalesced_event = kEvents[2]; | 211 WebTouchEvent coalesced_event = kEvents[2]; |
184 internal::Coalesce(kEvents[3], &coalesced_event); | 212 internal::Coalesce(kEvents[3], &coalesced_event); |
185 coalesced_event.dispatchType = | 213 coalesced_event.dispatchType = |
186 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 214 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
187 EXPECT_EQ(coalesced_event, *last_touch_event); | 215 EXPECT_EQ(coalesced_event, *last_touch_event); |
216 histogram_tester.ExpectBucketCount(kCoalescedCountHistogram, 0, 1); | |
217 histogram_tester.ExpectBucketCount(kCoalescedCountHistogram, 1, 1); | |
188 } | 218 } |
189 | 219 |
190 TEST_F(MainThreadEventQueueTest, BlockingTouch) { | 220 TEST_P(MainThreadEventQueueTest, BlockingTouch) { |
221 base::HistogramTester histogram_tester; | |
222 | |
191 SyntheticWebTouchEvent kEvents[4]; | 223 SyntheticWebTouchEvent kEvents[4]; |
192 kEvents[0].PressPoint(10, 10); | 224 kEvents[0].PressPoint(10, 10); |
193 kEvents[1].PressPoint(10, 10); | 225 kEvents[1].PressPoint(10, 10); |
194 kEvents[1].MovePoint(0, 20, 20); | 226 kEvents[1].MovePoint(0, 20, 20); |
195 kEvents[2].PressPoint(10, 10); | 227 kEvents[2].PressPoint(10, 10); |
196 kEvents[2].MovePoint(0, 30, 30); | 228 kEvents[2].MovePoint(0, 30, 30); |
197 kEvents[3].PressPoint(10, 10); | 229 kEvents[3].PressPoint(10, 10); |
198 kEvents[3].MovePoint(0, 35, 35); | 230 kEvents[3].MovePoint(0, 35, 35); |
199 | 231 |
200 EXPECT_CALL(renderer_scheduler_, DidHandleInputEventOnMainThread(testing::_)) | 232 EXPECT_CALL(renderer_scheduler_, DidHandleInputEventOnMainThread(testing::_)) |
201 .Times(2); | 233 .Times(2); |
202 // Ensure that coalescing takes place. | 234 // Ensure that coalescing takes place. |
203 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 235 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
204 HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 236 HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
205 HandleEvent(kEvents[2], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 237 HandleEvent(kEvents[2], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
206 HandleEvent(kEvents[3], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 238 HandleEvent(kEvents[3], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
207 | 239 |
208 EXPECT_EQ(2u, event_queue().size()); | 240 EXPECT_EQ(2u, event_queue().size()); |
209 EXPECT_TRUE(main_task_runner_->HasPendingTask()); | 241 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
210 main_task_runner_->RunUntilIdle(); | 242 RunPendingTasksWithSimulatedRaf(); |
243 | |
211 EXPECT_EQ(0u, event_queue().size()); | 244 EXPECT_EQ(0u, event_queue().size()); |
212 EXPECT_EQ(2u, additional_acked_events_.size()); | 245 EXPECT_EQ(2u, additional_acked_events_.size()); |
213 EXPECT_EQ(kEvents[2].uniqueTouchEventId, additional_acked_events_.at(0)); | 246 EXPECT_EQ(kEvents[2].uniqueTouchEventId, additional_acked_events_.at(0)); |
214 EXPECT_EQ(kEvents[3].uniqueTouchEventId, additional_acked_events_.at(1)); | 247 EXPECT_EQ(kEvents[3].uniqueTouchEventId, additional_acked_events_.at(1)); |
248 | |
249 histogram_tester.ExpectUniqueSample(kCoalescedCountHistogram, 2, 1); | |
215 } | 250 } |
216 | 251 |
217 TEST_F(MainThreadEventQueueTest, InterleavedEvents) { | 252 TEST_P(MainThreadEventQueueTest, InterleavedEvents) { |
218 WebMouseWheelEvent kWheelEvents[2] = { | 253 WebMouseWheelEvent kWheelEvents[2] = { |
219 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false), | 254 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false), |
220 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), | 255 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), |
221 }; | 256 }; |
222 SyntheticWebTouchEvent kTouchEvents[2]; | 257 SyntheticWebTouchEvent kTouchEvents[2]; |
223 kTouchEvents[0].PressPoint(10, 10); | 258 kTouchEvents[0].PressPoint(10, 10); |
224 kTouchEvents[0].MovePoint(0, 20, 20); | 259 kTouchEvents[0].MovePoint(0, 20, 20); |
225 kTouchEvents[1].PressPoint(10, 10); | 260 kTouchEvents[1].PressPoint(10, 10); |
226 kTouchEvents[1].MovePoint(0, 30, 30); | 261 kTouchEvents[1].MovePoint(0, 30, 30); |
227 | 262 |
228 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 263 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
229 EXPECT_EQ(0u, event_queue().size()); | 264 EXPECT_EQ(0u, event_queue().size()); |
230 | 265 |
231 HandleEvent(kWheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 266 HandleEvent(kWheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
232 HandleEvent(kTouchEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 267 HandleEvent(kTouchEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
233 HandleEvent(kWheelEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 268 HandleEvent(kWheelEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
234 HandleEvent(kTouchEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 269 HandleEvent(kTouchEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
235 | 270 |
236 EXPECT_EQ(2u, event_queue().size()); | 271 EXPECT_EQ(2u, event_queue().size()); |
237 EXPECT_TRUE(main_task_runner_->HasPendingTask()); | 272 EXPECT_EQ(GetParam(), !main_task_runner_->HasPendingTask()); |
tdresser
2016/08/24 13:43:00
Save the parameter into a well named variable.
I
dtapuska
2016/08/24 17:10:07
done
| |
238 main_task_runner_->RunUntilIdle(); | 273 RunPendingTasksWithSimulatedRaf(); |
239 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 274 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
240 EXPECT_EQ(0u, event_queue().size()); | 275 EXPECT_EQ(0u, event_queue().size()); |
241 EXPECT_EQ(2u, handled_events_.size()); | 276 EXPECT_EQ(2u, handled_events_.size()); |
242 { | 277 { |
243 EXPECT_EQ(kWheelEvents[0].size, handled_events_.at(0)->size); | 278 EXPECT_EQ(kWheelEvents[0].size, handled_events_.at(0)->size); |
244 EXPECT_EQ(kWheelEvents[0].type, handled_events_.at(0)->type); | 279 EXPECT_EQ(kWheelEvents[0].type, handled_events_.at(0)->type); |
245 const WebMouseWheelEvent* last_wheel_event = | 280 const WebMouseWheelEvent* last_wheel_event = |
246 static_cast<const WebMouseWheelEvent*>(handled_events_.at(0).get()); | 281 static_cast<const WebMouseWheelEvent*>(handled_events_.at(0).get()); |
247 EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive, | 282 EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive, |
248 last_wheel_event->dispatchType); | 283 last_wheel_event->dispatchType); |
249 WebMouseWheelEvent coalesced_event = kWheelEvents[0]; | 284 WebMouseWheelEvent coalesced_event = kWheelEvents[0]; |
250 internal::Coalesce(kWheelEvents[1], &coalesced_event); | 285 internal::Coalesce(kWheelEvents[1], &coalesced_event); |
251 coalesced_event.dispatchType = | 286 coalesced_event.dispatchType = |
252 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 287 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
253 EXPECT_EQ(coalesced_event, *last_wheel_event); | 288 EXPECT_EQ(coalesced_event, *last_wheel_event); |
254 } | 289 } |
255 { | 290 { |
256 EXPECT_EQ(kTouchEvents[0].size, handled_events_.at(1)->size); | 291 EXPECT_EQ(kTouchEvents[0].size, handled_events_.at(1)->size); |
257 EXPECT_EQ(kTouchEvents[0].type, handled_events_.at(1)->type); | 292 EXPECT_EQ(kTouchEvents[0].type, handled_events_.at(1)->type); |
258 const WebTouchEvent* last_touch_event = | 293 const WebTouchEvent* last_touch_event = |
259 static_cast<const WebTouchEvent*>(handled_events_.at(1).get()); | 294 static_cast<const WebTouchEvent*>(handled_events_.at(1).get()); |
260 WebTouchEvent coalesced_event = kTouchEvents[0]; | 295 WebTouchEvent coalesced_event = kTouchEvents[0]; |
261 internal::Coalesce(kTouchEvents[1], &coalesced_event); | 296 internal::Coalesce(kTouchEvents[1], &coalesced_event); |
262 coalesced_event.dispatchType = | 297 coalesced_event.dispatchType = |
263 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 298 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
264 EXPECT_EQ(coalesced_event, *last_touch_event); | 299 EXPECT_EQ(coalesced_event, *last_touch_event); |
265 } | 300 } |
266 } | 301 } |
267 | 302 |
268 TEST_F(MainThreadEventQueueTest, BlockingTouchesDuringFling) { | 303 TEST_P(MainThreadEventQueueTest, RafAlignedMouseInput) { |
304 // Don't run the test for when we aren't supporting raf aligned. | |
tdresser
2016/08/24 13:43:00
Don't run the test when we aren't supporting rAF a
dtapuska
2016/08/24 17:10:06
done
| |
305 if (!GetParam()) | |
306 return; | |
307 | |
308 WebMouseEvent kMouseEvents[3] = { | |
309 SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseDown, 10, 10, 0), | |
310 SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseMove, 10, 10, 0), | |
311 SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseUp, 10, 10, 0), | |
312 }; | |
313 | |
314 WebMouseWheelEvent kWheelEvents[2] = { | |
315 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false), | |
316 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), | |
317 }; | |
318 | |
319 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | |
320 EXPECT_EQ(0u, event_queue().size()); | |
321 | |
322 // Simulate enqueing a normal event, followed by "continious" events and then | |
tdresser
2016/08/24 13:43:00
continuous
dtapuska
2016/08/24 17:10:06
done
| |
323 // a normal event. The "continious" events should not wait for RAF. | |
tdresser
2016/08/24 13:43:00
nittiest nit: We normally write rAF, as it abbrevi
tdresser
2016/08/24 13:43:00
Is the above comment correct? Isn't it the discret
dtapuska
2016/08/24 17:10:06
done
| |
324 HandleEvent(kMouseEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
325 HandleEvent(kMouseEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
326 HandleEvent(kWheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
tdresser
2016/08/24 13:43:00
If we aren't iterating through the events, I'd rat
dtapuska
2016/08/24 17:10:07
done
| |
327 HandleEvent(kWheelEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
328 HandleEvent(kMouseEvents[2], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
329 | |
330 EXPECT_EQ(4u, event_queue().size()); | |
331 EXPECT_TRUE(main_task_runner_->HasPendingTask()); | |
332 EXPECT_TRUE(needs_main_frame_); | |
333 main_task_runner_->RunUntilIdle(); | |
334 EXPECT_EQ(0u, event_queue().size()); | |
335 RunPendingTasksWithSimulatedRaf(); | |
336 | |
337 // Simulate the RAF running before the PostTask occurs. The first RAF | |
338 // shouldn't do anything. | |
339 HandleEvent(kMouseEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
340 HandleEvent(kWheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
341 EXPECT_EQ(2u, event_queue().size()); | |
342 EXPECT_TRUE(needs_main_frame_); | |
343 RunSimulatedRafOnce(); | |
344 EXPECT_FALSE(needs_main_frame_); | |
345 EXPECT_EQ(2u, event_queue().size()); | |
346 main_task_runner_->RunUntilIdle(); | |
347 EXPECT_TRUE(needs_main_frame_); | |
348 EXPECT_EQ(1u, event_queue().size()); | |
349 RunPendingTasksWithSimulatedRaf(); | |
350 EXPECT_EQ(0u, event_queue().size()); | |
351 } | |
352 | |
353 TEST_P(MainThreadEventQueueTest, RafAlignedTouchInput) { | |
354 // Don't run the test for when we aren't supporting raf aligned. | |
355 if (!GetParam()) | |
356 return; | |
357 | |
358 SyntheticWebTouchEvent kEvents[3]; | |
359 kEvents[0].PressPoint(10, 10); | |
360 kEvents[1].PressPoint(10, 10); | |
361 kEvents[1].MovePoint(0, 50, 50); | |
362 kEvents[2].PressPoint(10, 10); | |
363 kEvents[2].ReleasePoint(0); | |
364 | |
365 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | |
366 EXPECT_EQ(0u, event_queue().size()); | |
367 | |
368 // Simulate enqueing a normal event, followed by "continious" events and then | |
369 // a normal event. The "continious" events should not wait for RAF. | |
370 for (SyntheticWebTouchEvent& event : kEvents) | |
371 HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
372 | |
373 EXPECT_EQ(3u, event_queue().size()); | |
374 EXPECT_TRUE(main_task_runner_->HasPendingTask()); | |
375 EXPECT_TRUE(needs_main_frame_); | |
376 main_task_runner_->RunUntilIdle(); | |
377 EXPECT_EQ(0u, event_queue().size()); | |
378 RunPendingTasksWithSimulatedRaf(); | |
379 | |
380 // Simulate the RAF running before the PostTask occurs. The first RAF | |
381 // shouldn't do anything. | |
382 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
383 HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
384 EXPECT_EQ(2u, event_queue().size()); | |
385 EXPECT_TRUE(needs_main_frame_); | |
386 RunSimulatedRafOnce(); | |
387 EXPECT_FALSE(needs_main_frame_); | |
388 EXPECT_EQ(2u, event_queue().size()); | |
389 RunPendingTasksWithSimulatedRaf(); | |
390 EXPECT_EQ(0u, event_queue().size()); | |
391 } | |
392 | |
393 TEST_P(MainThreadEventQueueTest, RafAlignedMaxSize) { | |
394 // Don't run the test for when we aren't supporting raf aligned. | |
395 if (!GetParam()) | |
396 return; | |
397 | |
398 const size_t kNumEventsToQueue = 16; | |
399 WebMouseWheelEvent mouseEvent = | |
400 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false); | |
401 | |
402 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | |
403 EXPECT_EQ(0u, event_queue().size()); | |
404 | |
405 for (size_t i = 0; i < kNumEventsToQueue; ++i) { | |
406 mouseEvent.modifiers = i; | |
407 HandleEvent(mouseEvent, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
408 } | |
409 | |
410 // There is a maximum number of events we handle in a RAF. kNumEventsToQueue | |
411 // exceeds that. Ensure that two RAF calls need to run. | |
412 EXPECT_EQ(kNumEventsToQueue, event_queue().size()); | |
413 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | |
414 EXPECT_TRUE(needs_main_frame_); | |
415 RunSimulatedRafOnce(); | |
416 EXPECT_TRUE(needs_main_frame_); | |
417 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | |
418 RunSimulatedRafOnce(); | |
419 EXPECT_EQ(0u, event_queue().size()); | |
420 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | |
421 } | |
422 | |
423 TEST_P(MainThreadEventQueueTest, BlockingTouchesDuringFling) { | |
269 SyntheticWebTouchEvent kEvents[1]; | 424 SyntheticWebTouchEvent kEvents[1]; |
270 kEvents[0].PressPoint(10, 10); | 425 kEvents[0].PressPoint(10, 10); |
271 kEvents[0].touchStartOrFirstTouchMove = true; | 426 kEvents[0].touchStartOrFirstTouchMove = true; |
272 set_is_flinging(true); | 427 set_is_flinging(true); |
273 set_enable_fling_passive_listener_flag(true); | 428 set_enable_fling_passive_listener_flag(true); |
274 | 429 |
275 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); | 430 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); |
276 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 431 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
277 main_task_runner_->RunUntilIdle(); | 432 RunPendingTasksWithSimulatedRaf(); |
278 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 433 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
279 EXPECT_EQ(0u, event_queue().size()); | 434 EXPECT_EQ(0u, event_queue().size()); |
280 EXPECT_EQ(1u, handled_events_.size()); | 435 EXPECT_EQ(1u, handled_events_.size()); |
281 EXPECT_EQ(kEvents[0].size, handled_events_.at(0)->size); | 436 EXPECT_EQ(kEvents[0].size, handled_events_.at(0)->size); |
282 EXPECT_EQ(kEvents[0].type, handled_events_.at(0)->type); | 437 EXPECT_EQ(kEvents[0].type, handled_events_.at(0)->type); |
283 EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling()); | 438 EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling()); |
284 const WebTouchEvent* last_touch_event = | 439 const WebTouchEvent* last_touch_event = |
285 static_cast<const WebTouchEvent*>(handled_events_.at(0).get()); | 440 static_cast<const WebTouchEvent*>(handled_events_.at(0).get()); |
286 kEvents[0].dispatchedDuringFling = true; | 441 kEvents[0].dispatchedDuringFling = true; |
287 kEvents[0].dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling; | 442 kEvents[0].dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling; |
288 EXPECT_EQ(kEvents[0], *last_touch_event); | 443 EXPECT_EQ(kEvents[0], *last_touch_event); |
289 | 444 |
290 kEvents[0].MovePoint(0, 30, 30); | 445 kEvents[0].MovePoint(0, 30, 30); |
291 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 446 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
292 main_task_runner_->RunUntilIdle(); | 447 RunPendingTasksWithSimulatedRaf(); |
293 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 448 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
294 EXPECT_EQ(0u, event_queue().size()); | 449 EXPECT_EQ(0u, event_queue().size()); |
295 EXPECT_EQ(2u, handled_events_.size()); | 450 EXPECT_EQ(2u, handled_events_.size()); |
296 EXPECT_EQ(kEvents[0].size, handled_events_.at(1)->size); | 451 EXPECT_EQ(kEvents[0].size, handled_events_.at(1)->size); |
297 EXPECT_EQ(kEvents[0].type, handled_events_.at(1)->type); | 452 EXPECT_EQ(kEvents[0].type, handled_events_.at(1)->type); |
298 EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling()); | 453 EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling()); |
299 last_touch_event = | 454 last_touch_event = |
300 static_cast<const WebTouchEvent*>(handled_events_.at(1).get()); | 455 static_cast<const WebTouchEvent*>(handled_events_.at(1).get()); |
301 kEvents[0].dispatchedDuringFling = true; | 456 kEvents[0].dispatchedDuringFling = true; |
302 kEvents[0].dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling; | 457 kEvents[0].dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling; |
303 EXPECT_EQ(kEvents[0], *last_touch_event); | 458 EXPECT_EQ(kEvents[0], *last_touch_event); |
304 | 459 |
305 kEvents[0].MovePoint(0, 50, 50); | 460 kEvents[0].MovePoint(0, 50, 50); |
306 kEvents[0].touchStartOrFirstTouchMove = false; | 461 kEvents[0].touchStartOrFirstTouchMove = false; |
307 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 462 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
308 main_task_runner_->RunUntilIdle(); | 463 RunPendingTasksWithSimulatedRaf(); |
309 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 464 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
310 EXPECT_EQ(0u, event_queue().size()); | 465 EXPECT_EQ(0u, event_queue().size()); |
311 EXPECT_EQ(3u, handled_events_.size()); | 466 EXPECT_EQ(3u, handled_events_.size()); |
312 EXPECT_EQ(kEvents[0].size, handled_events_.at(2)->size); | 467 EXPECT_EQ(kEvents[0].size, handled_events_.at(2)->size); |
313 EXPECT_EQ(kEvents[0].type, handled_events_.at(2)->type); | 468 EXPECT_EQ(kEvents[0].type, handled_events_.at(2)->type); |
314 EXPECT_TRUE(kEvents[0].dispatchedDuringFling); | 469 EXPECT_TRUE(kEvents[0].dispatchedDuringFling); |
315 EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking); | 470 EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking); |
316 last_touch_event = | 471 last_touch_event = |
317 static_cast<const WebTouchEvent*>(handled_events_.at(2).get()); | 472 static_cast<const WebTouchEvent*>(handled_events_.at(2).get()); |
318 EXPECT_EQ(kEvents[0], *last_touch_event); | 473 EXPECT_EQ(kEvents[0], *last_touch_event); |
319 | 474 |
320 kEvents[0].ReleasePoint(0); | 475 kEvents[0].ReleasePoint(0); |
321 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 476 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
322 main_task_runner_->RunUntilIdle(); | 477 RunPendingTasksWithSimulatedRaf(); |
323 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 478 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
324 EXPECT_EQ(0u, event_queue().size()); | 479 EXPECT_EQ(0u, event_queue().size()); |
325 EXPECT_EQ(4u, handled_events_.size()); | 480 EXPECT_EQ(4u, handled_events_.size()); |
326 EXPECT_EQ(kEvents[0].size, handled_events_.at(3)->size); | 481 EXPECT_EQ(kEvents[0].size, handled_events_.at(3)->size); |
327 EXPECT_EQ(kEvents[0].type, handled_events_.at(3)->type); | 482 EXPECT_EQ(kEvents[0].type, handled_events_.at(3)->type); |
328 EXPECT_TRUE(kEvents[0].dispatchedDuringFling); | 483 EXPECT_TRUE(kEvents[0].dispatchedDuringFling); |
329 EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking); | 484 EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking); |
330 last_touch_event = | 485 last_touch_event = |
331 static_cast<const WebTouchEvent*>(handled_events_.at(3).get()); | 486 static_cast<const WebTouchEvent*>(handled_events_.at(3).get()); |
332 EXPECT_EQ(kEvents[0], *last_touch_event); | 487 EXPECT_EQ(kEvents[0], *last_touch_event); |
333 } | 488 } |
334 | 489 |
335 TEST_F(MainThreadEventQueueTest, BlockingTouchesOutsideFling) { | 490 TEST_P(MainThreadEventQueueTest, BlockingTouchesOutsideFling) { |
336 SyntheticWebTouchEvent kEvents[1]; | 491 SyntheticWebTouchEvent kEvents[1]; |
337 kEvents[0].PressPoint(10, 10); | 492 kEvents[0].PressPoint(10, 10); |
338 kEvents[0].touchStartOrFirstTouchMove = true; | 493 kEvents[0].touchStartOrFirstTouchMove = true; |
339 set_is_flinging(false); | 494 set_is_flinging(false); |
340 set_enable_fling_passive_listener_flag(false); | 495 set_enable_fling_passive_listener_flag(false); |
341 | 496 |
342 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 497 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
343 main_task_runner_->RunUntilIdle(); | 498 RunPendingTasksWithSimulatedRaf(); |
344 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 499 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
345 EXPECT_EQ(0u, event_queue().size()); | 500 EXPECT_EQ(0u, event_queue().size()); |
346 EXPECT_EQ(1u, handled_events_.size()); | 501 EXPECT_EQ(1u, handled_events_.size()); |
347 EXPECT_EQ(kEvents[0].size, handled_events_.at(0)->size); | 502 EXPECT_EQ(kEvents[0].size, handled_events_.at(0)->size); |
348 EXPECT_EQ(kEvents[0].type, handled_events_.at(0)->type); | 503 EXPECT_EQ(kEvents[0].type, handled_events_.at(0)->type); |
349 EXPECT_FALSE(kEvents[0].dispatchedDuringFling); | 504 EXPECT_FALSE(kEvents[0].dispatchedDuringFling); |
350 EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking); | 505 EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking); |
351 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); | 506 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); |
352 const WebTouchEvent* last_touch_event = | 507 const WebTouchEvent* last_touch_event = |
353 static_cast<const WebTouchEvent*>(handled_events_.at(0).get()); | 508 static_cast<const WebTouchEvent*>(handled_events_.at(0).get()); |
354 EXPECT_EQ(kEvents[0], *last_touch_event); | 509 EXPECT_EQ(kEvents[0], *last_touch_event); |
355 | 510 |
356 set_is_flinging(true); | 511 set_is_flinging(true); |
357 set_enable_fling_passive_listener_flag(false); | 512 set_enable_fling_passive_listener_flag(false); |
358 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 513 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
359 main_task_runner_->RunUntilIdle(); | 514 RunPendingTasksWithSimulatedRaf(); |
360 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 515 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
361 EXPECT_EQ(0u, event_queue().size()); | 516 EXPECT_EQ(0u, event_queue().size()); |
362 EXPECT_EQ(2u, handled_events_.size()); | 517 EXPECT_EQ(2u, handled_events_.size()); |
363 EXPECT_EQ(kEvents[0].size, handled_events_.at(1)->size); | 518 EXPECT_EQ(kEvents[0].size, handled_events_.at(1)->size); |
364 EXPECT_EQ(kEvents[0].type, handled_events_.at(1)->type); | 519 EXPECT_EQ(kEvents[0].type, handled_events_.at(1)->type); |
365 EXPECT_FALSE(kEvents[0].dispatchedDuringFling); | 520 EXPECT_FALSE(kEvents[0].dispatchedDuringFling); |
366 EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking); | 521 EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking); |
367 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); | 522 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); |
368 last_touch_event = | 523 last_touch_event = |
369 static_cast<const WebTouchEvent*>(handled_events_.at(1).get()); | 524 static_cast<const WebTouchEvent*>(handled_events_.at(1).get()); |
370 kEvents[0].dispatchedDuringFling = true; | 525 kEvents[0].dispatchedDuringFling = true; |
371 EXPECT_EQ(kEvents[0], *last_touch_event); | 526 EXPECT_EQ(kEvents[0], *last_touch_event); |
372 | 527 |
373 set_is_flinging(false); | 528 set_is_flinging(false); |
374 set_enable_fling_passive_listener_flag(true); | 529 set_enable_fling_passive_listener_flag(true); |
375 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 530 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
376 main_task_runner_->RunUntilIdle(); | 531 RunPendingTasksWithSimulatedRaf(); |
377 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 532 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
378 EXPECT_EQ(0u, event_queue().size()); | 533 EXPECT_EQ(0u, event_queue().size()); |
379 EXPECT_EQ(3u, handled_events_.size()); | 534 EXPECT_EQ(3u, handled_events_.size()); |
380 EXPECT_EQ(kEvents[0].size, handled_events_.at(2)->size); | 535 EXPECT_EQ(kEvents[0].size, handled_events_.at(2)->size); |
381 EXPECT_EQ(kEvents[0].type, handled_events_.at(2)->type); | 536 EXPECT_EQ(kEvents[0].type, handled_events_.at(2)->type); |
382 EXPECT_TRUE(kEvents[0].dispatchedDuringFling); | 537 EXPECT_TRUE(kEvents[0].dispatchedDuringFling); |
383 EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking); | 538 EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking); |
384 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); | 539 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); |
385 last_touch_event = | 540 last_touch_event = |
386 static_cast<const WebTouchEvent*>(handled_events_.at(2).get()); | 541 static_cast<const WebTouchEvent*>(handled_events_.at(2).get()); |
387 kEvents[0].dispatchedDuringFling = false; | 542 kEvents[0].dispatchedDuringFling = false; |
388 EXPECT_EQ(kEvents[0], *last_touch_event); | 543 EXPECT_EQ(kEvents[0], *last_touch_event); |
389 | 544 |
390 kEvents[0].MovePoint(0, 30, 30); | 545 kEvents[0].MovePoint(0, 30, 30); |
391 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 546 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
392 main_task_runner_->RunUntilIdle(); | 547 RunPendingTasksWithSimulatedRaf(); |
393 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 548 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
394 EXPECT_EQ(0u, event_queue().size()); | 549 EXPECT_EQ(0u, event_queue().size()); |
395 EXPECT_EQ(4u, handled_events_.size()); | 550 EXPECT_EQ(4u, handled_events_.size()); |
396 EXPECT_EQ(kEvents[0].size, handled_events_.at(3)->size); | 551 EXPECT_EQ(kEvents[0].size, handled_events_.at(3)->size); |
397 EXPECT_EQ(kEvents[0].type, handled_events_.at(3)->type); | 552 EXPECT_EQ(kEvents[0].type, handled_events_.at(3)->type); |
398 EXPECT_FALSE(kEvents[0].dispatchedDuringFling); | 553 EXPECT_FALSE(kEvents[0].dispatchedDuringFling); |
399 EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking); | 554 EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking); |
400 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); | 555 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); |
401 last_touch_event = | 556 last_touch_event = |
402 static_cast<const WebTouchEvent*>(handled_events_.at(3).get()); | 557 static_cast<const WebTouchEvent*>(handled_events_.at(3).get()); |
403 EXPECT_EQ(kEvents[0], *last_touch_event); | 558 EXPECT_EQ(kEvents[0], *last_touch_event); |
404 } | 559 } |
405 | 560 |
406 } // namespace content | 561 INSTANTIATE_TEST_CASE_P(MainThreadEventQueueTests, |
tdresser
2016/08/24 13:43:00
Add a comment indicating what the bool means.
dtapuska
2016/08/24 17:10:07
done
| |
562 MainThreadEventQueueTest, | |
563 testing::Bool()); | |
564 | |
565 } // namespace content | |
OLD | NEW |