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 |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
45 | 45 |
46 // Simulate a 16ms frame signal. | 46 // Simulate a 16ms frame signal. |
47 const base::TimeDelta kFrameInterval = base::TimeDelta::FromMilliseconds(16); | 47 const base::TimeDelta kFrameInterval = base::TimeDelta::FromMilliseconds(16); |
48 | 48 |
49 const int kTestRoutingID = 13; | 49 const int kTestRoutingID = 13; |
50 const char* kCoalescedCountHistogram = | 50 const char* kCoalescedCountHistogram = |
51 "Event.MainThreadEventQueue.CoalescedCount"; | 51 "Event.MainThreadEventQueue.CoalescedCount"; |
52 | 52 |
53 } // namespace | 53 } // namespace |
54 | 54 |
55 class HandledTask { | |
56 public: | |
57 virtual ~HandledTask() {} | |
58 | |
59 virtual blink::WebCoalescedInputEvent* taskAsEvent() = 0; | |
60 virtual unsigned taskAsClosure() const = 0; | |
61 }; | |
62 | |
63 class HandledEvent : public HandledTask { | |
64 public: | |
65 explicit HandledEvent(const blink::WebCoalescedInputEvent* event) | |
66 : event_(event->event(), event->getCoalescedEventsPointers()) {} | |
67 ~HandledEvent() override {} | |
68 | |
69 blink::WebCoalescedInputEvent* taskAsEvent() override { return &event_; } | |
70 unsigned taskAsClosure() const override { | |
71 NOTREACHED(); | |
72 return 0; | |
73 } | |
74 | |
75 private: | |
76 blink::WebCoalescedInputEvent event_; | |
77 }; | |
78 | |
79 class HandledClosure : public HandledTask { | |
80 public: | |
81 explicit HandledClosure(unsigned closure_id) : closure_id_(closure_id) {} | |
82 ~HandledClosure() override {} | |
83 | |
84 blink::WebCoalescedInputEvent* taskAsEvent() override { | |
85 NOTREACHED(); | |
86 return nullptr; | |
87 } | |
88 unsigned taskAsClosure() const override { return closure_id_; } | |
89 | |
90 private: | |
91 unsigned closure_id_; | |
92 }; | |
93 | |
55 class MainThreadEventQueueTest : public testing::TestWithParam<unsigned>, | 94 class MainThreadEventQueueTest : public testing::TestWithParam<unsigned>, |
56 public MainThreadEventQueueClient { | 95 public MainThreadEventQueueClient { |
57 public: | 96 public: |
58 MainThreadEventQueueTest() | 97 MainThreadEventQueueTest() |
59 : main_task_runner_(new base::TestSimpleTaskRunner()), | 98 : main_task_runner_(new base::TestSimpleTaskRunner()), |
60 raf_aligned_input_setting_(GetParam()), | 99 raf_aligned_input_setting_(GetParam()), |
61 needs_main_frame_(false) { | 100 needs_main_frame_(false), |
101 closure_count_(0) { | |
62 std::vector<base::StringPiece> features; | 102 std::vector<base::StringPiece> features; |
63 std::vector<base::StringPiece> disabled_features; | 103 std::vector<base::StringPiece> disabled_features; |
64 if (raf_aligned_input_setting_ & kRafAlignedEnabledTouch) { | 104 if (raf_aligned_input_setting_ & kRafAlignedEnabledTouch) { |
65 features.push_back(features::kRafAlignedTouchInputEvents.name); | 105 features.push_back(features::kRafAlignedTouchInputEvents.name); |
66 } else { | 106 } else { |
67 disabled_features.push_back(features::kRafAlignedTouchInputEvents.name); | 107 disabled_features.push_back(features::kRafAlignedTouchInputEvents.name); |
68 } | 108 } |
69 if (raf_aligned_input_setting_ & kRafAlignedEnabledMouse) { | 109 if (raf_aligned_input_setting_ & kRafAlignedEnabledMouse) { |
70 features.push_back(features::kRafAlignedMouseInputEvents.name); | 110 features.push_back(features::kRafAlignedMouseInputEvents.name); |
71 } else { | 111 } else { |
72 disabled_features.push_back(features::kRafAlignedMouseInputEvents.name); | 112 disabled_features.push_back(features::kRafAlignedMouseInputEvents.name); |
73 } | 113 } |
74 | 114 |
75 feature_list_.InitFromCommandLine(base::JoinString(features, ","), | 115 feature_list_.InitFromCommandLine(base::JoinString(features, ","), |
76 base::JoinString(disabled_features, ",")); | 116 base::JoinString(disabled_features, ",")); |
77 } | 117 } |
78 | 118 |
79 void SetUp() override { | 119 void SetUp() override { |
80 queue_ = new MainThreadEventQueue(kTestRoutingID, this, main_task_runner_, | 120 queue_ = new MainThreadEventQueue(kTestRoutingID, this, main_task_runner_, |
81 &renderer_scheduler_); | 121 &renderer_scheduler_); |
82 } | 122 } |
83 | 123 |
84 void HandleEventOnMainThread(int routing_id, | 124 void HandleEventOnMainThread(int routing_id, |
85 const blink::WebCoalescedInputEvent* event, | 125 const blink::WebCoalescedInputEvent* event, |
86 const ui::LatencyInfo& latency, | 126 const ui::LatencyInfo& latency, |
87 InputEventDispatchType type) override { | 127 InputEventDispatchType type) override { |
88 EXPECT_EQ(kTestRoutingID, routing_id); | 128 EXPECT_EQ(kTestRoutingID, routing_id); |
89 handled_events_.push_back(blink::WebCoalescedInputEvent( | 129 |
90 event->event(), event->getCoalescedEventsPointers())); | 130 std::unique_ptr<HandledTask> handled_event(new HandledEvent(event)); |
131 handled_tasks_.push_back(std::move(handled_event)); | |
91 | 132 |
92 queue_->EventHandled(event->event().type(), | 133 queue_->EventHandled(event->event().type(), |
93 blink::WebInputEventResult::HandledApplication, | 134 blink::WebInputEventResult::HandledApplication, |
94 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 135 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
95 } | 136 } |
96 | 137 |
97 void SendInputEventAck(int routing_id, | 138 void SendInputEventAck(int routing_id, |
98 blink::WebInputEvent::Type type, | 139 blink::WebInputEvent::Type type, |
99 InputEventAckState ack_result, | 140 InputEventAckState ack_result, |
100 uint32_t touch_event_id) override { | 141 uint32_t touch_event_id) override { |
101 additional_acked_events_.push_back(touch_event_id); | 142 additional_acked_events_.push_back(touch_event_id); |
102 } | 143 } |
103 | 144 |
104 bool HandleEvent(WebInputEvent& event, InputEventAckState ack_result) { | 145 bool HandleEvent(WebInputEvent& event, InputEventAckState ack_result) { |
105 return queue_->HandleEvent(ui::WebInputEventTraits::Clone(event), | 146 return queue_->HandleEvent(ui::WebInputEventTraits::Clone(event), |
106 ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | 147 ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, |
107 ack_result); | 148 ack_result); |
108 } | 149 } |
109 | 150 |
151 void RunClosure(unsigned closure_id) { | |
152 std::unique_ptr<HandledTask> closure(new HandledClosure(closure_id)); | |
153 handled_tasks_.push_back(std::move(closure)); | |
154 } | |
155 | |
156 void QueueClosure() { | |
157 unsigned closure_id = ++closure_count_; | |
158 queue_->QueueClosure(base::Bind(&MainThreadEventQueueTest::RunClosure, | |
159 base::Unretained(this), closure_id)); | |
160 } | |
161 | |
110 void NeedsMainFrame(int routing_id) override { needs_main_frame_ = true; } | 162 void NeedsMainFrame(int routing_id) override { needs_main_frame_ = true; } |
111 | 163 |
112 WebInputEventQueue<EventWithDispatchType>& event_queue() { | 164 MainThreadEventQueueTaskList& event_queue() { |
113 return queue_->shared_state_.events_; | 165 return queue_->shared_state_.events_; |
114 } | 166 } |
115 | 167 |
116 bool last_touch_start_forced_nonblocking_due_to_fling() { | 168 bool last_touch_start_forced_nonblocking_due_to_fling() { |
117 return queue_->last_touch_start_forced_nonblocking_due_to_fling_; | 169 return queue_->last_touch_start_forced_nonblocking_due_to_fling_; |
118 } | 170 } |
119 | 171 |
120 void set_enable_fling_passive_listener_flag(bool enable_flag) { | 172 void set_enable_fling_passive_listener_flag(bool enable_flag) { |
121 queue_->enable_fling_passive_listener_flag_ = enable_flag; | 173 queue_->enable_fling_passive_listener_flag_ = enable_flag; |
122 } | 174 } |
(...skipping 13 matching lines...) Expand all Loading... | |
136 frame_time_ += kFrameInterval; | 188 frame_time_ += kFrameInterval; |
137 queue_->DispatchRafAlignedInput(frame_time_); | 189 queue_->DispatchRafAlignedInput(frame_time_); |
138 } | 190 } |
139 } | 191 } |
140 | 192 |
141 protected: | 193 protected: |
142 base::test::ScopedFeatureList feature_list_; | 194 base::test::ScopedFeatureList feature_list_; |
143 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; | 195 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; |
144 blink::scheduler::MockRendererScheduler renderer_scheduler_; | 196 blink::scheduler::MockRendererScheduler renderer_scheduler_; |
145 scoped_refptr<MainThreadEventQueue> queue_; | 197 scoped_refptr<MainThreadEventQueue> queue_; |
146 std::vector<blink::WebCoalescedInputEvent> handled_events_; | 198 std::vector<std::unique_ptr<HandledTask>> handled_tasks_; |
147 | 199 |
148 std::vector<uint32_t> additional_acked_events_; | 200 std::vector<uint32_t> additional_acked_events_; |
149 int raf_aligned_input_setting_; | 201 int raf_aligned_input_setting_; |
150 bool needs_main_frame_; | 202 bool needs_main_frame_; |
151 base::TimeTicks frame_time_; | 203 base::TimeTicks frame_time_; |
204 unsigned closure_count_; | |
152 }; | 205 }; |
153 | 206 |
154 TEST_P(MainThreadEventQueueTest, NonBlockingWheel) { | 207 TEST_P(MainThreadEventQueueTest, NonBlockingWheel) { |
155 base::HistogramTester histogram_tester; | 208 base::HistogramTester histogram_tester; |
156 | 209 |
157 WebMouseWheelEvent kEvents[4] = { | 210 WebMouseWheelEvent kEvents[4] = { |
158 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false), | 211 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false), |
159 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), | 212 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), |
160 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), | 213 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), |
161 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), | 214 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), |
162 }; | 215 }; |
163 | 216 |
164 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 217 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
165 EXPECT_EQ(0u, event_queue().size()); | 218 EXPECT_EQ(0u, event_queue().size()); |
166 | 219 |
167 for (WebMouseWheelEvent& event : kEvents) | 220 for (WebMouseWheelEvent& event : kEvents) |
168 HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 221 HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
169 | 222 |
170 EXPECT_EQ(2u, event_queue().size()); | 223 EXPECT_EQ(2u, event_queue().size()); |
171 EXPECT_EQ((raf_aligned_input_setting_ & kRafAlignedEnabledMouse) == 0, | 224 EXPECT_EQ((raf_aligned_input_setting_ & kRafAlignedEnabledMouse) == 0, |
172 main_task_runner_->HasPendingTask()); | 225 main_task_runner_->HasPendingTask()); |
173 RunPendingTasksWithSimulatedRaf(); | 226 RunPendingTasksWithSimulatedRaf(); |
174 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 227 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
175 EXPECT_EQ(0u, event_queue().size()); | 228 EXPECT_EQ(0u, event_queue().size()); |
176 EXPECT_EQ(2u, handled_events_.size()); | 229 EXPECT_EQ(2u, handled_tasks_.size()); |
177 for (const auto& coalesced_event : handled_events_) { | 230 for (const auto& task : handled_tasks_) { |
178 EXPECT_EQ(2u, coalesced_event.coalescedEventSize()); | 231 EXPECT_EQ(2u, task->taskAsEvent()->coalescedEventSize()); |
179 } | 232 } |
180 | 233 |
181 { | 234 { |
182 EXPECT_EQ(kEvents[0].size(), handled_events_.at(0).event().size()); | 235 EXPECT_EQ(kEvents[0].size(), |
183 EXPECT_EQ(kEvents[0].type(), handled_events_.at(0).event().type()); | 236 handled_tasks_.at(0)->taskAsEvent()->event().size()); |
237 EXPECT_EQ(kEvents[0].type(), | |
238 handled_tasks_.at(0)->taskAsEvent()->event().type()); | |
184 const WebMouseWheelEvent* last_wheel_event = | 239 const WebMouseWheelEvent* last_wheel_event = |
185 static_cast<const WebMouseWheelEvent*>( | 240 static_cast<const WebMouseWheelEvent*>( |
186 handled_events_.at(0).eventPointer()); | 241 handled_tasks_.at(0)->taskAsEvent()->eventPointer()); |
187 EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive, | 242 EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive, |
188 last_wheel_event->dispatchType); | 243 last_wheel_event->dispatchType); |
189 WebMouseWheelEvent coalesced_event = kEvents[0]; | 244 WebMouseWheelEvent coalesced_event = kEvents[0]; |
190 ui::Coalesce(kEvents[1], &coalesced_event); | 245 ui::Coalesce(kEvents[1], &coalesced_event); |
191 coalesced_event.dispatchType = | 246 coalesced_event.dispatchType = |
192 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 247 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
193 EXPECT_EQ(coalesced_event, *last_wheel_event); | 248 EXPECT_EQ(coalesced_event, *last_wheel_event); |
194 } | 249 } |
195 | 250 |
196 { | 251 { |
197 WebMouseWheelEvent coalesced_event = kEvents[0]; | 252 WebMouseWheelEvent coalesced_event = kEvents[0]; |
198 std::vector<const WebInputEvent*> coalesced_events = | 253 std::vector<const WebInputEvent*> coalesced_events = |
199 handled_events_[0].getCoalescedEventsPointers(); | 254 handled_tasks_[0]->taskAsEvent()->getCoalescedEventsPointers(); |
200 const WebMouseWheelEvent* coalesced_wheel_event0 = | 255 const WebMouseWheelEvent* coalesced_wheel_event0 = |
201 static_cast<const WebMouseWheelEvent*>(coalesced_events[0]); | 256 static_cast<const WebMouseWheelEvent*>(coalesced_events[0]); |
202 coalesced_event.dispatchType = | 257 coalesced_event.dispatchType = |
203 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 258 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
204 EXPECT_EQ(coalesced_event, *coalesced_wheel_event0); | 259 EXPECT_EQ(coalesced_event, *coalesced_wheel_event0); |
205 | 260 |
206 coalesced_event = kEvents[1]; | 261 coalesced_event = kEvents[1]; |
207 const WebMouseWheelEvent* coalesced_wheel_event1 = | 262 const WebMouseWheelEvent* coalesced_wheel_event1 = |
208 static_cast<const WebMouseWheelEvent*>(coalesced_events[1]); | 263 static_cast<const WebMouseWheelEvent*>(coalesced_events[1]); |
209 coalesced_event.dispatchType = | 264 coalesced_event.dispatchType = |
210 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 265 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
211 EXPECT_EQ(coalesced_event, *coalesced_wheel_event1); | 266 EXPECT_EQ(coalesced_event, *coalesced_wheel_event1); |
212 } | 267 } |
213 | 268 |
214 { | 269 { |
215 const WebMouseWheelEvent* last_wheel_event = | 270 const WebMouseWheelEvent* last_wheel_event = |
216 static_cast<const WebMouseWheelEvent*>( | 271 static_cast<const WebMouseWheelEvent*>( |
217 handled_events_.at(1).eventPointer()); | 272 handled_tasks_.at(1)->taskAsEvent()->eventPointer()); |
218 WebMouseWheelEvent coalesced_event = kEvents[2]; | 273 WebMouseWheelEvent coalesced_event = kEvents[2]; |
219 ui::Coalesce(kEvents[3], &coalesced_event); | 274 ui::Coalesce(kEvents[3], &coalesced_event); |
220 coalesced_event.dispatchType = | 275 coalesced_event.dispatchType = |
221 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 276 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
222 EXPECT_EQ(coalesced_event, *last_wheel_event); | 277 EXPECT_EQ(coalesced_event, *last_wheel_event); |
223 } | 278 } |
224 | 279 |
225 { | 280 { |
226 WebMouseWheelEvent coalesced_event = kEvents[2]; | 281 WebMouseWheelEvent coalesced_event = kEvents[2]; |
227 std::vector<const WebInputEvent*> coalesced_events = | 282 std::vector<const WebInputEvent*> coalesced_events = |
228 handled_events_[1].getCoalescedEventsPointers(); | 283 handled_tasks_[1]->taskAsEvent()->getCoalescedEventsPointers(); |
229 const WebMouseWheelEvent* coalesced_wheel_event0 = | 284 const WebMouseWheelEvent* coalesced_wheel_event0 = |
230 static_cast<const WebMouseWheelEvent*>(coalesced_events[0]); | 285 static_cast<const WebMouseWheelEvent*>(coalesced_events[0]); |
231 coalesced_event.dispatchType = | 286 coalesced_event.dispatchType = |
232 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 287 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
233 EXPECT_EQ(coalesced_event, *coalesced_wheel_event0); | 288 EXPECT_EQ(coalesced_event, *coalesced_wheel_event0); |
234 | 289 |
235 coalesced_event = kEvents[3]; | 290 coalesced_event = kEvents[3]; |
236 const WebMouseWheelEvent* coalesced_wheel_event1 = | 291 const WebMouseWheelEvent* coalesced_wheel_event1 = |
237 static_cast<const WebMouseWheelEvent*>(coalesced_events[1]); | 292 static_cast<const WebMouseWheelEvent*>(coalesced_events[1]); |
238 coalesced_event.dispatchType = | 293 coalesced_event.dispatchType = |
(...skipping 18 matching lines...) Expand all Loading... | |
257 kEvents[3].MovePoint(0, 35, 35); | 312 kEvents[3].MovePoint(0, 35, 35); |
258 | 313 |
259 for (SyntheticWebTouchEvent& event : kEvents) | 314 for (SyntheticWebTouchEvent& event : kEvents) |
260 HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 315 HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
261 | 316 |
262 EXPECT_EQ(3u, event_queue().size()); | 317 EXPECT_EQ(3u, event_queue().size()); |
263 EXPECT_TRUE(main_task_runner_->HasPendingTask()); | 318 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
264 RunPendingTasksWithSimulatedRaf(); | 319 RunPendingTasksWithSimulatedRaf(); |
265 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 320 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
266 EXPECT_EQ(0u, event_queue().size()); | 321 EXPECT_EQ(0u, event_queue().size()); |
267 EXPECT_EQ(3u, handled_events_.size()); | 322 EXPECT_EQ(3u, handled_tasks_.size()); |
268 | 323 |
269 EXPECT_EQ(kEvents[0].size(), handled_events_.at(0).event().size()); | 324 EXPECT_EQ(kEvents[0].size(), |
270 EXPECT_EQ(kEvents[0].type(), handled_events_.at(0).event().type()); | 325 handled_tasks_.at(0)->taskAsEvent()->event().size()); |
271 const WebTouchEvent* last_touch_event = | 326 EXPECT_EQ(kEvents[0].type(), |
272 static_cast<const WebTouchEvent*>(handled_events_.at(0).eventPointer()); | 327 handled_tasks_.at(0)->taskAsEvent()->event().type()); |
328 const WebTouchEvent* last_touch_event = static_cast<const WebTouchEvent*>( | |
329 handled_tasks_.at(0)->taskAsEvent()->eventPointer()); | |
273 kEvents[0].dispatchType = | 330 kEvents[0].dispatchType = |
274 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 331 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
275 EXPECT_EQ(kEvents[0], *last_touch_event); | 332 EXPECT_EQ(kEvents[0], *last_touch_event); |
276 | 333 |
277 { | 334 { |
278 EXPECT_EQ(1u, handled_events_[0].coalescedEventSize()); | 335 EXPECT_EQ(1u, handled_tasks_[0]->taskAsEvent()->coalescedEventSize()); |
279 const WebTouchEvent* coalesced_touch_event = | 336 const WebTouchEvent* coalesced_touch_event = |
280 static_cast<const WebTouchEvent*>( | 337 static_cast<const WebTouchEvent*>( |
281 handled_events_[0].getCoalescedEventsPointers()[0]); | 338 handled_tasks_[0]->taskAsEvent()->getCoalescedEventsPointers()[0]); |
282 EXPECT_EQ(kEvents[0], *coalesced_touch_event); | 339 EXPECT_EQ(kEvents[0], *coalesced_touch_event); |
283 } | 340 } |
284 | 341 |
285 EXPECT_EQ(kEvents[1].size(), handled_events_.at(1).event().size()); | 342 EXPECT_EQ(kEvents[1].size(), |
286 EXPECT_EQ(kEvents[1].type(), handled_events_.at(1).event().type()); | 343 handled_tasks_.at(1)->taskAsEvent()->event().size()); |
287 last_touch_event = | 344 EXPECT_EQ(kEvents[1].type(), |
288 static_cast<const WebTouchEvent*>(handled_events_.at(1).eventPointer()); | 345 handled_tasks_.at(1)->taskAsEvent()->event().type()); |
346 last_touch_event = static_cast<const WebTouchEvent*>( | |
347 handled_tasks_.at(1)->taskAsEvent()->eventPointer()); | |
289 kEvents[1].dispatchType = | 348 kEvents[1].dispatchType = |
290 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 349 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
291 EXPECT_EQ(kEvents[1], *last_touch_event); | 350 EXPECT_EQ(kEvents[1], *last_touch_event); |
292 | 351 |
293 { | 352 { |
294 EXPECT_EQ(1u, handled_events_[1].coalescedEventSize()); | 353 EXPECT_EQ(1u, handled_tasks_[1]->taskAsEvent()->coalescedEventSize()); |
295 const WebTouchEvent* coalesced_touch_event = | 354 const WebTouchEvent* coalesced_touch_event = |
296 static_cast<const WebTouchEvent*>( | 355 static_cast<const WebTouchEvent*>( |
297 handled_events_[1].getCoalescedEventsPointers()[0]); | 356 handled_tasks_[1]->taskAsEvent()->getCoalescedEventsPointers()[0]); |
298 EXPECT_EQ(kEvents[1], *coalesced_touch_event); | 357 EXPECT_EQ(kEvents[1], *coalesced_touch_event); |
299 } | 358 } |
300 | 359 |
301 EXPECT_EQ(kEvents[2].size(), handled_events_.at(1).event().size()); | 360 EXPECT_EQ(kEvents[2].size(), |
302 EXPECT_EQ(kEvents[2].type(), handled_events_.at(2).event().type()); | 361 handled_tasks_.at(1)->taskAsEvent()->event().size()); |
303 last_touch_event = | 362 EXPECT_EQ(kEvents[2].type(), |
304 static_cast<const WebTouchEvent*>(handled_events_.at(2).eventPointer()); | 363 handled_tasks_.at(2)->taskAsEvent()->event().type()); |
364 last_touch_event = static_cast<const WebTouchEvent*>( | |
365 handled_tasks_.at(2)->taskAsEvent()->eventPointer()); | |
305 WebTouchEvent coalesced_event = kEvents[2]; | 366 WebTouchEvent coalesced_event = kEvents[2]; |
306 ui::Coalesce(kEvents[3], &coalesced_event); | 367 ui::Coalesce(kEvents[3], &coalesced_event); |
307 coalesced_event.dispatchType = | 368 coalesced_event.dispatchType = |
308 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 369 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
309 EXPECT_EQ(coalesced_event, *last_touch_event); | 370 EXPECT_EQ(coalesced_event, *last_touch_event); |
310 | 371 |
311 { | 372 { |
312 EXPECT_EQ(2u, handled_events_[2].coalescedEventSize()); | 373 EXPECT_EQ(2u, handled_tasks_[2]->taskAsEvent()->coalescedEventSize()); |
313 WebTouchEvent coalesced_event = kEvents[2]; | 374 WebTouchEvent coalesced_event = kEvents[2]; |
314 std::vector<const WebInputEvent*> coalesced_events = | 375 std::vector<const WebInputEvent*> coalesced_events = |
315 handled_events_[2].getCoalescedEventsPointers(); | 376 handled_tasks_[2]->taskAsEvent()->getCoalescedEventsPointers(); |
316 const WebTouchEvent* coalesced_touch_event0 = | 377 const WebTouchEvent* coalesced_touch_event0 = |
317 static_cast<const WebTouchEvent*>(coalesced_events[0]); | 378 static_cast<const WebTouchEvent*>(coalesced_events[0]); |
318 coalesced_event.dispatchType = | 379 coalesced_event.dispatchType = |
319 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 380 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
320 EXPECT_EQ(coalesced_event, *coalesced_touch_event0); | 381 EXPECT_EQ(coalesced_event, *coalesced_touch_event0); |
321 | 382 |
322 coalesced_event = kEvents[3]; | 383 coalesced_event = kEvents[3]; |
323 const WebTouchEvent* coalesced_touch_event1 = | 384 const WebTouchEvent* coalesced_touch_event1 = |
324 static_cast<const WebTouchEvent*>(coalesced_events[1]); | 385 static_cast<const WebTouchEvent*>(coalesced_events[1]); |
325 coalesced_event.dispatchType = | 386 coalesced_event.dispatchType = |
(...skipping 27 matching lines...) Expand all Loading... | |
353 | 414 |
354 EXPECT_EQ(2u, event_queue().size()); | 415 EXPECT_EQ(2u, event_queue().size()); |
355 EXPECT_TRUE(main_task_runner_->HasPendingTask()); | 416 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
356 RunPendingTasksWithSimulatedRaf(); | 417 RunPendingTasksWithSimulatedRaf(); |
357 | 418 |
358 EXPECT_EQ(0u, event_queue().size()); | 419 EXPECT_EQ(0u, event_queue().size()); |
359 EXPECT_EQ(2u, additional_acked_events_.size()); | 420 EXPECT_EQ(2u, additional_acked_events_.size()); |
360 EXPECT_EQ(kEvents[1].uniqueTouchEventId, additional_acked_events_.at(0)); | 421 EXPECT_EQ(kEvents[1].uniqueTouchEventId, additional_acked_events_.at(0)); |
361 EXPECT_EQ(kEvents[2].uniqueTouchEventId, additional_acked_events_.at(1)); | 422 EXPECT_EQ(kEvents[2].uniqueTouchEventId, additional_acked_events_.at(1)); |
362 | 423 |
363 const WebTouchEvent* last_touch_event = | 424 const WebTouchEvent* last_touch_event = static_cast<const WebTouchEvent*>( |
364 static_cast<const WebTouchEvent*>(handled_events_.at(1).eventPointer()); | 425 handled_tasks_.at(1)->taskAsEvent()->eventPointer()); |
365 EXPECT_EQ(kEvents[3].uniqueTouchEventId, | 426 EXPECT_EQ(kEvents[3].uniqueTouchEventId, |
366 last_touch_event->uniqueTouchEventId); | 427 last_touch_event->uniqueTouchEventId); |
367 | 428 |
368 HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 429 HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
369 HandleEvent(kEvents[2], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 430 HandleEvent(kEvents[2], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
370 HandleEvent(kEvents[3], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 431 HandleEvent(kEvents[3], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
371 EXPECT_EQ(1u, event_queue().size()); | 432 EXPECT_EQ(1u, event_queue().size()); |
372 RunPendingTasksWithSimulatedRaf(); | 433 RunPendingTasksWithSimulatedRaf(); |
373 histogram_tester.ExpectUniqueSample(kCoalescedCountHistogram, 2, 2); | 434 histogram_tester.ExpectUniqueSample(kCoalescedCountHistogram, 2, 2); |
374 } | 435 } |
(...skipping 17 matching lines...) Expand all Loading... | |
392 HandleEvent(kWheelEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 453 HandleEvent(kWheelEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
393 HandleEvent(kTouchEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 454 HandleEvent(kTouchEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
394 | 455 |
395 EXPECT_EQ(2u, event_queue().size()); | 456 EXPECT_EQ(2u, event_queue().size()); |
396 EXPECT_EQ(raf_aligned_input_setting_ != | 457 EXPECT_EQ(raf_aligned_input_setting_ != |
397 (kRafAlignedEnabledMouse | kRafAlignedEnabledTouch), | 458 (kRafAlignedEnabledMouse | kRafAlignedEnabledTouch), |
398 main_task_runner_->HasPendingTask()); | 459 main_task_runner_->HasPendingTask()); |
399 RunPendingTasksWithSimulatedRaf(); | 460 RunPendingTasksWithSimulatedRaf(); |
400 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 461 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
401 EXPECT_EQ(0u, event_queue().size()); | 462 EXPECT_EQ(0u, event_queue().size()); |
402 EXPECT_EQ(2u, handled_events_.size()); | 463 EXPECT_EQ(2u, handled_tasks_.size()); |
403 { | 464 { |
404 EXPECT_EQ(kWheelEvents[0].size(), handled_events_.at(0).event().size()); | 465 EXPECT_EQ(kWheelEvents[0].size(), |
405 EXPECT_EQ(kWheelEvents[0].type(), handled_events_.at(0).event().type()); | 466 handled_tasks_.at(0)->taskAsEvent()->event().size()); |
467 EXPECT_EQ(kWheelEvents[0].type(), | |
468 handled_tasks_.at(0)->taskAsEvent()->event().type()); | |
406 const WebMouseWheelEvent* last_wheel_event = | 469 const WebMouseWheelEvent* last_wheel_event = |
407 static_cast<const WebMouseWheelEvent*>( | 470 static_cast<const WebMouseWheelEvent*>( |
408 handled_events_.at(0).eventPointer()); | 471 handled_tasks_.at(0)->taskAsEvent()->eventPointer()); |
409 EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive, | 472 EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive, |
410 last_wheel_event->dispatchType); | 473 last_wheel_event->dispatchType); |
411 WebMouseWheelEvent coalesced_event = kWheelEvents[0]; | 474 WebMouseWheelEvent coalesced_event = kWheelEvents[0]; |
412 ui::Coalesce(kWheelEvents[1], &coalesced_event); | 475 ui::Coalesce(kWheelEvents[1], &coalesced_event); |
413 coalesced_event.dispatchType = | 476 coalesced_event.dispatchType = |
414 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 477 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
415 EXPECT_EQ(coalesced_event, *last_wheel_event); | 478 EXPECT_EQ(coalesced_event, *last_wheel_event); |
416 } | 479 } |
417 { | 480 { |
418 EXPECT_EQ(kTouchEvents[0].size(), handled_events_.at(1).event().size()); | 481 EXPECT_EQ(kTouchEvents[0].size(), |
419 EXPECT_EQ(kTouchEvents[0].type(), handled_events_.at(1).event().type()); | 482 handled_tasks_.at(1)->taskAsEvent()->event().size()); |
420 const WebTouchEvent* last_touch_event = | 483 EXPECT_EQ(kTouchEvents[0].type(), |
421 static_cast<const WebTouchEvent*>(handled_events_.at(1).eventPointer()); | 484 handled_tasks_.at(1)->taskAsEvent()->event().type()); |
485 const WebTouchEvent* last_touch_event = static_cast<const WebTouchEvent*>( | |
486 handled_tasks_.at(1)->taskAsEvent()->eventPointer()); | |
422 WebTouchEvent coalesced_event = kTouchEvents[0]; | 487 WebTouchEvent coalesced_event = kTouchEvents[0]; |
423 ui::Coalesce(kTouchEvents[1], &coalesced_event); | 488 ui::Coalesce(kTouchEvents[1], &coalesced_event); |
424 coalesced_event.dispatchType = | 489 coalesced_event.dispatchType = |
425 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 490 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
426 EXPECT_EQ(coalesced_event, *last_touch_event); | 491 EXPECT_EQ(coalesced_event, *last_touch_event); |
427 } | 492 } |
428 } | 493 } |
429 | 494 |
430 TEST_P(MainThreadEventQueueTest, RafAlignedMouseInput) { | 495 TEST_P(MainThreadEventQueueTest, RafAlignedMouseInput) { |
431 // Don't run the test when we aren't supporting rAF aligned input. | 496 // Don't run the test when we aren't supporting rAF aligned input. |
432 if ((raf_aligned_input_setting_ & kRafAlignedEnabledMouse) == 0) | 497 if ((raf_aligned_input_setting_ & kRafAlignedEnabledMouse) == 0) |
433 return; | 498 return; |
434 | 499 |
435 WebMouseEvent mouseDown = | 500 WebMouseEvent mouseDown = |
436 SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseDown, 10, 10, 0); | 501 SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseDown, 10, 10, 0); |
437 | 502 |
438 WebMouseEvent mouseMove = | 503 WebMouseEvent mouseMove = |
439 SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseMove, 10, 10, 0); | 504 SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseMove, 10, 10, 0); |
440 | 505 |
441 WebMouseEvent mouseUp = | 506 WebMouseEvent mouseUp = |
442 SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseUp, 10, 10, 0); | 507 SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseUp, 10, 10, 0); |
443 | 508 |
444 WebMouseWheelEvent wheelEvents[2] = { | 509 WebMouseWheelEvent wheelEvents[3] = { |
445 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false), | 510 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false), |
446 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), | 511 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), |
512 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 1, false), | |
447 }; | 513 }; |
448 | 514 |
449 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 515 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
450 EXPECT_EQ(0u, event_queue().size()); | 516 EXPECT_EQ(0u, event_queue().size()); |
451 | 517 |
452 // Simulate enqueing a discrete event, followed by continuous events and | 518 // Simulate enqueing a discrete event, followed by continuous events and |
453 // then a discrete event. The last discrete event should flush the | 519 // then a discrete event. The last discrete event should flush the |
454 // continuous events so the aren't aligned to rAF and are processed | 520 // continuous events so the aren't aligned to rAF and are processed |
455 // immediately. | 521 // immediately. |
456 HandleEvent(mouseDown, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 522 HandleEvent(mouseDown, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
457 HandleEvent(mouseMove, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 523 HandleEvent(mouseMove, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
458 HandleEvent(wheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 524 HandleEvent(wheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
459 HandleEvent(wheelEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 525 HandleEvent(wheelEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
460 HandleEvent(mouseUp, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 526 HandleEvent(mouseUp, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
461 | 527 |
462 EXPECT_EQ(4u, event_queue().size()); | 528 EXPECT_EQ(4u, event_queue().size()); |
463 EXPECT_TRUE(main_task_runner_->HasPendingTask()); | 529 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
464 EXPECT_TRUE(needs_main_frame_); | 530 EXPECT_TRUE(needs_main_frame_); |
465 main_task_runner_->RunUntilIdle(); | 531 main_task_runner_->RunUntilIdle(); |
466 EXPECT_EQ(0u, event_queue().size()); | 532 EXPECT_EQ(0u, event_queue().size()); |
467 RunPendingTasksWithSimulatedRaf(); | 533 RunPendingTasksWithSimulatedRaf(); |
468 | 534 |
469 // Simulate the rAF running before the PostTask occurs. The first rAF | 535 // Simulate the rAF running before the PostTask occurs. The rAF |
470 // shouldn't do anything. | 536 // will consume everything. |
471 HandleEvent(mouseDown, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 537 HandleEvent(mouseDown, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
472 HandleEvent(wheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 538 HandleEvent(wheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
473 EXPECT_EQ(2u, event_queue().size()); | 539 EXPECT_EQ(2u, event_queue().size()); |
474 EXPECT_TRUE(needs_main_frame_); | 540 EXPECT_TRUE(needs_main_frame_); |
475 RunSimulatedRafOnce(); | 541 RunSimulatedRafOnce(); |
476 EXPECT_FALSE(needs_main_frame_); | 542 EXPECT_FALSE(needs_main_frame_); |
477 EXPECT_EQ(2u, event_queue().size()); | 543 EXPECT_EQ(0u, event_queue().size()); |
544 main_task_runner_->RunUntilIdle(); | |
545 | |
546 // Simulate event consumption but no rAF signal. The mouse wheel events | |
547 // should still be in the queue. | |
548 handled_tasks_.clear(); | |
549 HandleEvent(mouseDown, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
550 HandleEvent(wheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
551 HandleEvent(mouseUp, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
552 HandleEvent(wheelEvents[2], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
553 HandleEvent(wheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
554 EXPECT_EQ(5u, event_queue().size()); | |
555 EXPECT_TRUE(needs_main_frame_); | |
478 main_task_runner_->RunUntilIdle(); | 556 main_task_runner_->RunUntilIdle(); |
479 EXPECT_TRUE(needs_main_frame_); | 557 EXPECT_TRUE(needs_main_frame_); |
480 EXPECT_EQ(1u, event_queue().size()); | 558 EXPECT_EQ(2u, event_queue().size()); |
481 RunPendingTasksWithSimulatedRaf(); | 559 RunSimulatedRafOnce(); |
482 EXPECT_EQ(0u, event_queue().size()); | 560 EXPECT_EQ(wheelEvents[2].modifiers(), |
561 handled_tasks_.at(3)->taskAsEvent()->event().modifiers()); | |
562 EXPECT_EQ(wheelEvents[0].modifiers(), | |
563 handled_tasks_.at(4)->taskAsEvent()->event().modifiers()); | |
483 } | 564 } |
484 | 565 |
485 TEST_P(MainThreadEventQueueTest, RafAlignedTouchInput) { | 566 TEST_P(MainThreadEventQueueTest, RafAlignedTouchInput) { |
486 // Don't run the test when we aren't supporting rAF aligned input. | 567 // Don't run the test when we aren't supporting rAF aligned input. |
487 if ((raf_aligned_input_setting_ & kRafAlignedEnabledTouch) == 0) | 568 if ((raf_aligned_input_setting_ & kRafAlignedEnabledTouch) == 0) |
488 return; | 569 return; |
489 | 570 |
490 SyntheticWebTouchEvent kEvents[3]; | 571 SyntheticWebTouchEvent kEvents[3]; |
491 kEvents[0].PressPoint(10, 10); | 572 kEvents[0].PressPoint(10, 10); |
492 kEvents[1].PressPoint(10, 10); | 573 kEvents[1].PressPoint(10, 10); |
(...skipping 11 matching lines...) Expand all Loading... | |
504 for (SyntheticWebTouchEvent& event : kEvents) | 585 for (SyntheticWebTouchEvent& event : kEvents) |
505 HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 586 HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
506 | 587 |
507 EXPECT_EQ(3u, event_queue().size()); | 588 EXPECT_EQ(3u, event_queue().size()); |
508 EXPECT_TRUE(main_task_runner_->HasPendingTask()); | 589 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
509 EXPECT_TRUE(needs_main_frame_); | 590 EXPECT_TRUE(needs_main_frame_); |
510 main_task_runner_->RunUntilIdle(); | 591 main_task_runner_->RunUntilIdle(); |
511 EXPECT_EQ(0u, event_queue().size()); | 592 EXPECT_EQ(0u, event_queue().size()); |
512 RunPendingTasksWithSimulatedRaf(); | 593 RunPendingTasksWithSimulatedRaf(); |
513 | 594 |
514 // Simulate the rAF running before the PostTask occurs. The first rAF | 595 // Simulate the rAF running before the PostTask occurs. The rAF |
515 // shouldn't do anything. | 596 // will consume everything. |
516 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 597 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
517 HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 598 HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
518 EXPECT_EQ(2u, event_queue().size()); | 599 EXPECT_EQ(2u, event_queue().size()); |
519 EXPECT_TRUE(needs_main_frame_); | 600 EXPECT_TRUE(needs_main_frame_); |
520 RunSimulatedRafOnce(); | 601 RunSimulatedRafOnce(); |
521 EXPECT_FALSE(needs_main_frame_); | 602 EXPECT_FALSE(needs_main_frame_); |
603 EXPECT_EQ(0u, event_queue().size()); | |
604 main_task_runner_->RunUntilIdle(); | |
605 | |
606 // Simulate event consumption but no rAF signal. The touch events | |
607 // should still be in the queue. | |
608 handled_tasks_.clear(); | |
609 HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
610 HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
522 EXPECT_EQ(2u, event_queue().size()); | 611 EXPECT_EQ(2u, event_queue().size()); |
523 RunPendingTasksWithSimulatedRaf(); | 612 EXPECT_TRUE(needs_main_frame_); |
524 EXPECT_EQ(0u, event_queue().size()); | 613 main_task_runner_->RunUntilIdle(); |
614 EXPECT_TRUE(needs_main_frame_); | |
615 EXPECT_EQ(1u, event_queue().size()); | |
616 RunSimulatedRafOnce(); | |
525 | 617 |
526 // Simulate the touch move being discrete | 618 // Simulate the touch move being discrete |
527 kEvents[0].touchStartOrFirstTouchMove = true; | 619 kEvents[0].touchStartOrFirstTouchMove = true; |
528 kEvents[1].touchStartOrFirstTouchMove = true; | 620 kEvents[1].touchStartOrFirstTouchMove = true; |
529 | 621 |
530 for (SyntheticWebTouchEvent& event : kEvents) | 622 for (SyntheticWebTouchEvent& event : kEvents) |
531 HandleEvent(event, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 623 HandleEvent(event, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
532 | 624 |
533 EXPECT_EQ(3u, event_queue().size()); | 625 EXPECT_EQ(3u, event_queue().size()); |
534 EXPECT_TRUE(main_task_runner_->HasPendingTask()); | 626 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
641 SyntheticWebTouchEvent kEvents; | 733 SyntheticWebTouchEvent kEvents; |
642 kEvents.PressPoint(10, 10); | 734 kEvents.PressPoint(10, 10); |
643 kEvents.touchStartOrFirstTouchMove = true; | 735 kEvents.touchStartOrFirstTouchMove = true; |
644 set_enable_fling_passive_listener_flag(true); | 736 set_enable_fling_passive_listener_flag(true); |
645 | 737 |
646 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); | 738 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); |
647 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING); | 739 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING); |
648 RunPendingTasksWithSimulatedRaf(); | 740 RunPendingTasksWithSimulatedRaf(); |
649 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 741 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
650 EXPECT_EQ(0u, event_queue().size()); | 742 EXPECT_EQ(0u, event_queue().size()); |
651 EXPECT_EQ(1u, handled_events_.size()); | 743 EXPECT_EQ(1u, handled_tasks_.size()); |
652 EXPECT_EQ(kEvents.size(), handled_events_.at(0).event().size()); | 744 EXPECT_EQ(kEvents.size(), |
653 EXPECT_EQ(kEvents.type(), handled_events_.at(0).event().type()); | 745 handled_tasks_.at(0)->taskAsEvent()->event().size()); |
746 EXPECT_EQ(kEvents.type(), | |
747 handled_tasks_.at(0)->taskAsEvent()->event().type()); | |
654 EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling()); | 748 EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling()); |
655 const WebTouchEvent* last_touch_event = | 749 const WebTouchEvent* last_touch_event = static_cast<const WebTouchEvent*>( |
656 static_cast<const WebTouchEvent*>(handled_events_.at(0).eventPointer()); | 750 handled_tasks_.at(0)->taskAsEvent()->eventPointer()); |
657 kEvents.dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling; | 751 kEvents.dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling; |
658 EXPECT_EQ(kEvents, *last_touch_event); | 752 EXPECT_EQ(kEvents, *last_touch_event); |
659 | 753 |
660 kEvents.MovePoint(0, 30, 30); | 754 kEvents.MovePoint(0, 30, 30); |
661 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 755 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
662 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING); | 756 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING); |
663 EXPECT_EQ((raf_aligned_input_setting_ & kRafAlignedEnabledTouch) == 0, | 757 EXPECT_EQ((raf_aligned_input_setting_ & kRafAlignedEnabledTouch) == 0, |
664 main_task_runner_->HasPendingTask()); | 758 main_task_runner_->HasPendingTask()); |
665 RunPendingTasksWithSimulatedRaf(); | 759 RunPendingTasksWithSimulatedRaf(); |
666 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 760 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
667 EXPECT_EQ(0u, event_queue().size()); | 761 EXPECT_EQ(0u, event_queue().size()); |
668 EXPECT_EQ(2u, handled_events_.size()); | 762 EXPECT_EQ(2u, handled_tasks_.size()); |
669 EXPECT_EQ(kEvents.size(), handled_events_.at(1).event().size()); | 763 EXPECT_EQ(kEvents.size(), |
670 EXPECT_EQ(kEvents.type(), handled_events_.at(1).event().type()); | 764 handled_tasks_.at(1)->taskAsEvent()->event().size()); |
765 EXPECT_EQ(kEvents.type(), | |
766 handled_tasks_.at(1)->taskAsEvent()->event().type()); | |
671 EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling()); | 767 EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling()); |
672 last_touch_event = | 768 last_touch_event = static_cast<const WebTouchEvent*>( |
673 static_cast<const WebTouchEvent*>(handled_events_.at(1).eventPointer()); | 769 handled_tasks_.at(1)->taskAsEvent()->eventPointer()); |
674 kEvents.dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling; | 770 kEvents.dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling; |
675 EXPECT_EQ(kEvents, *last_touch_event); | 771 EXPECT_EQ(kEvents, *last_touch_event); |
676 | 772 |
677 kEvents.MovePoint(0, 50, 50); | 773 kEvents.MovePoint(0, 50, 50); |
678 kEvents.touchStartOrFirstTouchMove = false; | 774 kEvents.touchStartOrFirstTouchMove = false; |
679 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING); | 775 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING); |
680 RunPendingTasksWithSimulatedRaf(); | 776 RunPendingTasksWithSimulatedRaf(); |
681 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 777 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
682 EXPECT_EQ(0u, event_queue().size()); | 778 EXPECT_EQ(0u, event_queue().size()); |
683 EXPECT_EQ(3u, handled_events_.size()); | 779 EXPECT_EQ(3u, handled_tasks_.size()); |
684 EXPECT_EQ(kEvents.size(), handled_events_.at(2).event().size()); | 780 EXPECT_EQ(kEvents.size(), |
685 EXPECT_EQ(kEvents.type(), handled_events_.at(2).event().type()); | 781 handled_tasks_.at(2)->taskAsEvent()->event().size()); |
782 EXPECT_EQ(kEvents.type(), | |
783 handled_tasks_.at(2)->taskAsEvent()->event().type()); | |
686 EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); | 784 EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); |
687 last_touch_event = | 785 last_touch_event = static_cast<const WebTouchEvent*>( |
688 static_cast<const WebTouchEvent*>(handled_events_.at(2).eventPointer()); | 786 handled_tasks_.at(2)->taskAsEvent()->eventPointer()); |
689 EXPECT_EQ(kEvents, *last_touch_event); | 787 EXPECT_EQ(kEvents, *last_touch_event); |
690 | 788 |
691 kEvents.ReleasePoint(0); | 789 kEvents.ReleasePoint(0); |
692 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING); | 790 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING); |
693 RunPendingTasksWithSimulatedRaf(); | 791 RunPendingTasksWithSimulatedRaf(); |
694 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 792 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
695 EXPECT_EQ(0u, event_queue().size()); | 793 EXPECT_EQ(0u, event_queue().size()); |
696 EXPECT_EQ(4u, handled_events_.size()); | 794 EXPECT_EQ(4u, handled_tasks_.size()); |
697 EXPECT_EQ(kEvents.size(), handled_events_.at(3).event().size()); | 795 EXPECT_EQ(kEvents.size(), |
698 EXPECT_EQ(kEvents.type(), handled_events_.at(3).event().type()); | 796 handled_tasks_.at(3)->taskAsEvent()->event().size()); |
797 EXPECT_EQ(kEvents.type(), | |
798 handled_tasks_.at(3)->taskAsEvent()->event().type()); | |
699 EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); | 799 EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); |
700 last_touch_event = | 800 last_touch_event = static_cast<const WebTouchEvent*>( |
701 static_cast<const WebTouchEvent*>(handled_events_.at(3).eventPointer()); | 801 handled_tasks_.at(3)->taskAsEvent()->eventPointer()); |
702 EXPECT_EQ(kEvents, *last_touch_event); | 802 EXPECT_EQ(kEvents, *last_touch_event); |
703 } | 803 } |
704 | 804 |
705 TEST_P(MainThreadEventQueueTest, BlockingTouchesOutsideFling) { | 805 TEST_P(MainThreadEventQueueTest, BlockingTouchesOutsideFling) { |
706 SyntheticWebTouchEvent kEvents; | 806 SyntheticWebTouchEvent kEvents; |
707 kEvents.PressPoint(10, 10); | 807 kEvents.PressPoint(10, 10); |
708 kEvents.touchStartOrFirstTouchMove = true; | 808 kEvents.touchStartOrFirstTouchMove = true; |
709 set_enable_fling_passive_listener_flag(false); | 809 set_enable_fling_passive_listener_flag(false); |
710 | 810 |
711 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 811 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
712 RunPendingTasksWithSimulatedRaf(); | 812 RunPendingTasksWithSimulatedRaf(); |
713 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 813 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
714 EXPECT_EQ(0u, event_queue().size()); | 814 EXPECT_EQ(0u, event_queue().size()); |
715 EXPECT_EQ(1u, handled_events_.size()); | 815 EXPECT_EQ(1u, handled_tasks_.size()); |
716 EXPECT_EQ(kEvents.size(), handled_events_.at(0).event().size()); | 816 EXPECT_EQ(kEvents.size(), |
717 EXPECT_EQ(kEvents.type(), handled_events_.at(0).event().type()); | 817 handled_tasks_.at(0)->taskAsEvent()->event().size()); |
818 EXPECT_EQ(kEvents.type(), | |
819 handled_tasks_.at(0)->taskAsEvent()->event().type()); | |
718 EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); | 820 EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); |
719 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); | 821 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); |
720 const WebTouchEvent* last_touch_event = | 822 const WebTouchEvent* last_touch_event = static_cast<const WebTouchEvent*>( |
721 static_cast<const WebTouchEvent*>(handled_events_.at(0).eventPointer()); | 823 handled_tasks_.at(0)->taskAsEvent()->eventPointer()); |
722 EXPECT_EQ(kEvents, *last_touch_event); | 824 EXPECT_EQ(kEvents, *last_touch_event); |
723 | 825 |
724 set_enable_fling_passive_listener_flag(false); | 826 set_enable_fling_passive_listener_flag(false); |
725 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 827 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
726 RunPendingTasksWithSimulatedRaf(); | 828 RunPendingTasksWithSimulatedRaf(); |
727 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 829 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
728 EXPECT_EQ(0u, event_queue().size()); | 830 EXPECT_EQ(0u, event_queue().size()); |
729 EXPECT_EQ(2u, handled_events_.size()); | 831 EXPECT_EQ(2u, handled_tasks_.size()); |
730 EXPECT_EQ(kEvents.size(), handled_events_.at(1).event().size()); | 832 EXPECT_EQ(kEvents.size(), |
731 EXPECT_EQ(kEvents.type(), handled_events_.at(1).event().type()); | 833 handled_tasks_.at(1)->taskAsEvent()->event().size()); |
834 EXPECT_EQ(kEvents.type(), | |
835 handled_tasks_.at(1)->taskAsEvent()->event().type()); | |
732 EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); | 836 EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); |
733 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); | 837 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); |
734 last_touch_event = | 838 last_touch_event = static_cast<const WebTouchEvent*>( |
735 static_cast<const WebTouchEvent*>(handled_events_.at(1).eventPointer()); | 839 handled_tasks_.at(1)->taskAsEvent()->eventPointer()); |
736 EXPECT_EQ(kEvents, *last_touch_event); | 840 EXPECT_EQ(kEvents, *last_touch_event); |
737 | 841 |
738 set_enable_fling_passive_listener_flag(true); | 842 set_enable_fling_passive_listener_flag(true); |
739 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 843 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
740 RunPendingTasksWithSimulatedRaf(); | 844 RunPendingTasksWithSimulatedRaf(); |
741 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 845 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
742 EXPECT_EQ(0u, event_queue().size()); | 846 EXPECT_EQ(0u, event_queue().size()); |
743 EXPECT_EQ(3u, handled_events_.size()); | 847 EXPECT_EQ(3u, handled_tasks_.size()); |
744 EXPECT_EQ(kEvents.size(), handled_events_.at(2).event().size()); | 848 EXPECT_EQ(kEvents.size(), |
745 EXPECT_EQ(kEvents.type(), handled_events_.at(2).event().type()); | 849 handled_tasks_.at(2)->taskAsEvent()->event().size()); |
850 EXPECT_EQ(kEvents.type(), | |
851 handled_tasks_.at(2)->taskAsEvent()->event().type()); | |
746 EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); | 852 EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); |
747 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); | 853 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); |
748 last_touch_event = | 854 last_touch_event = static_cast<const WebTouchEvent*>( |
749 static_cast<const WebTouchEvent*>(handled_events_.at(2).eventPointer()); | 855 handled_tasks_.at(2)->taskAsEvent()->eventPointer()); |
750 EXPECT_EQ(kEvents, *last_touch_event); | 856 EXPECT_EQ(kEvents, *last_touch_event); |
751 | 857 |
752 kEvents.MovePoint(0, 30, 30); | 858 kEvents.MovePoint(0, 30, 30); |
753 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 859 HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
754 RunPendingTasksWithSimulatedRaf(); | 860 RunPendingTasksWithSimulatedRaf(); |
755 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | 861 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
756 EXPECT_EQ(0u, event_queue().size()); | 862 EXPECT_EQ(0u, event_queue().size()); |
757 EXPECT_EQ(4u, handled_events_.size()); | 863 EXPECT_EQ(4u, handled_tasks_.size()); |
758 EXPECT_EQ(kEvents.size(), handled_events_.at(3).event().size()); | 864 EXPECT_EQ(kEvents.size(), |
759 EXPECT_EQ(kEvents.type(), handled_events_.at(3).event().type()); | 865 handled_tasks_.at(3)->taskAsEvent()->event().size()); |
866 EXPECT_EQ(kEvents.type(), | |
867 handled_tasks_.at(3)->taskAsEvent()->event().type()); | |
760 EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); | 868 EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking); |
761 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); | 869 EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling()); |
762 last_touch_event = | 870 last_touch_event = static_cast<const WebTouchEvent*>( |
763 static_cast<const WebTouchEvent*>(handled_events_.at(3).eventPointer()); | 871 handled_tasks_.at(3)->taskAsEvent()->eventPointer()); |
764 EXPECT_EQ(kEvents, *last_touch_event); | 872 EXPECT_EQ(kEvents, *last_touch_event); |
765 } | 873 } |
766 | 874 |
767 // The boolean parameterized test varies whether rAF aligned input | 875 // The boolean parameterized test varies whether rAF aligned input |
768 // is enabled or not. | 876 // is enabled or not. |
769 INSTANTIATE_TEST_CASE_P( | 877 INSTANTIATE_TEST_CASE_P( |
770 MainThreadEventQueueTests, | 878 MainThreadEventQueueTests, |
771 MainThreadEventQueueTest, | 879 MainThreadEventQueueTest, |
772 testing::Range(0u, | 880 testing::Range(0u, |
773 (kRafAlignedEnabledTouch | kRafAlignedEnabledMouse) + 1)); | 881 (kRafAlignedEnabledTouch | kRafAlignedEnabledMouse) + 1)); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
829 base::FieldTrialList::CreateFieldTrial( | 937 base::FieldTrialList::CreateFieldTrial( |
830 "MainThreadResponsivenessScrollIntervention", "Control"); | 938 "MainThreadResponsivenessScrollIntervention", "Control"); |
831 queue_ = new MainThreadEventQueue(kTestRoutingID, | 939 queue_ = new MainThreadEventQueue(kTestRoutingID, |
832 &dummy_main_thread_event_queue_client_, | 940 &dummy_main_thread_event_queue_client_, |
833 main_task_runner_, &renderer_scheduler_); | 941 main_task_runner_, &renderer_scheduler_); |
834 EXPECT_FALSE(enable_non_blocking_due_to_main_thread_responsiveness_flag()); | 942 EXPECT_FALSE(enable_non_blocking_due_to_main_thread_responsiveness_flag()); |
835 EXPECT_EQ(base::TimeDelta::FromMilliseconds(0), | 943 EXPECT_EQ(base::TimeDelta::FromMilliseconds(0), |
836 main_thread_responsiveness_threshold()); | 944 main_thread_responsiveness_threshold()); |
837 } | 945 } |
838 | 946 |
947 TEST_P(MainThreadEventQueueTest, QueuingClosures) { | |
mustaq
2017/03/29 14:47:07
I would like tests for the following sequences (E=
dtapuska
2017/03/29 20:08:14
I've adjusted the tests to ensure there is suffici
| |
948 SyntheticWebTouchEvent kEvents[2]; | |
949 kEvents[0].PressPoint(10, 10); | |
950 kEvents[1].PressPoint(10, 10); | |
951 kEvents[1].MovePoint(0, 20, 20); | |
952 | |
953 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | |
954 EXPECT_EQ(0u, event_queue().size()); | |
955 | |
956 QueueClosure(); | |
957 EXPECT_EQ(1u, event_queue().size()); | |
958 EXPECT_TRUE(main_task_runner_->HasPendingTask()); | |
959 EXPECT_FALSE(needs_main_frame_); | |
960 | |
961 EXPECT_FALSE(HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED)); | |
962 QueueClosure(); | |
963 EXPECT_EQ(3u, event_queue().size()); | |
964 EXPECT_TRUE(main_task_runner_->HasPendingTask()); | |
965 EXPECT_FALSE(needs_main_frame_); | |
966 EXPECT_FALSE(HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_NOT_CONSUMED)); | |
967 RunPendingTasksWithSimulatedRaf(); | |
mustaq
2017/03/29 14:47:07
Please add an EXPECT_EQ for event_queue.size == 4
dtapuska
2017/03/29 20:08:14
Done.
| |
968 | |
969 EXPECT_EQ(0u, event_queue().size()); | |
970 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | |
971 EXPECT_FALSE(needs_main_frame_); | |
972 | |
973 EXPECT_EQ(1u, handled_tasks_.at(0)->taskAsClosure()); | |
974 EXPECT_EQ(kEvents[0].type(), | |
975 handled_tasks_.at(1)->taskAsEvent()->event().type()); | |
976 EXPECT_EQ(2u, handled_tasks_.at(2)->taskAsClosure()); | |
977 EXPECT_EQ(kEvents[1].type(), | |
978 handled_tasks_.at(3)->taskAsEvent()->event().type()); | |
979 } | |
980 | |
981 TEST_P(MainThreadEventQueueTest, QueuingClosuresBetweenEvents) { | |
982 SyntheticWebTouchEvent kEvents[2]; | |
983 kEvents[0].PressPoint(10, 10); | |
984 kEvents[1].PressPoint(10, 10); | |
985 kEvents[1].ReleasePoint(0); | |
986 | |
987 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | |
988 EXPECT_EQ(0u, event_queue().size()); | |
989 | |
990 EXPECT_FALSE(HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED)); | |
991 QueueClosure(); | |
992 QueueClosure(); | |
993 EXPECT_FALSE(HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_NOT_CONSUMED)); | |
994 main_task_runner_->RunUntilIdle(); | |
995 EXPECT_EQ(0u, event_queue().size()); | |
996 EXPECT_FALSE(main_task_runner_->HasPendingTask()); | |
997 EXPECT_FALSE(needs_main_frame_); | |
998 | |
999 EXPECT_EQ(kEvents[0].type(), | |
1000 handled_tasks_.at(0)->taskAsEvent()->event().type()); | |
1001 EXPECT_EQ(1u, handled_tasks_.at(1)->taskAsClosure()); | |
1002 EXPECT_EQ(2u, handled_tasks_.at(2)->taskAsClosure()); | |
1003 EXPECT_EQ(kEvents[1].type(), | |
1004 handled_tasks_.at(3)->taskAsEvent()->event().type()); | |
1005 } | |
1006 | |
839 } // namespace content | 1007 } // namespace content |
OLD | NEW |