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/test_simple_task_runner.h" |
12 #include "build/build_config.h" | 13 #include "build/build_config.h" |
13 #include "content/common/input/synthetic_web_input_event_builders.h" | 14 #include "content/common/input/synthetic_web_input_event_builders.h" |
14 #include "content/renderer/input/main_thread_event_queue.h" | 15 #include "content/renderer/input/main_thread_event_queue.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
16 | 17 |
17 using blink::WebInputEvent; | 18 using blink::WebInputEvent; |
18 using blink::WebMouseEvent; | 19 using blink::WebMouseEvent; |
19 using blink::WebMouseWheelEvent; | 20 using blink::WebMouseWheelEvent; |
20 using blink::WebTouchEvent; | 21 using blink::WebTouchEvent; |
21 | 22 |
| 23 namespace blink { |
| 24 bool operator==(const WebMouseWheelEvent& lhs, const WebMouseWheelEvent& rhs) { |
| 25 return memcmp(&lhs, &rhs, lhs.size) == 0; |
| 26 } |
| 27 |
| 28 bool operator==(const WebTouchEvent& lhs, const WebTouchEvent& rhs) { |
| 29 return memcmp(&lhs, &rhs, lhs.size) == 0; |
| 30 } |
| 31 } // namespace blink |
| 32 |
22 namespace content { | 33 namespace content { |
23 namespace { | 34 namespace { |
24 | 35 |
25 const int kTestRoutingID = 13; | 36 const int kTestRoutingID = 13; |
26 } | 37 } |
27 | 38 |
28 class MainThreadEventQueueTest : public testing::Test, | 39 class MainThreadEventQueueTest : public testing::Test, |
29 public MainThreadEventQueueClient { | 40 public MainThreadEventQueueClient { |
30 public: | 41 public: |
31 MainThreadEventQueueTest() : queue_(kTestRoutingID, this) {} | 42 MainThreadEventQueueTest() |
| 43 : main_task_runner_(new base::TestSimpleTaskRunner()), |
| 44 queue_(kTestRoutingID, this, main_task_runner_) {} |
32 | 45 |
33 void SendEventToMainThread(int routing_id, | 46 void HandleEventOnMainThread(int routing_id, |
34 const blink::WebInputEvent* event, | 47 const blink::WebInputEvent* event, |
35 const ui::LatencyInfo& latency, | 48 const ui::LatencyInfo& latency, |
36 InputEventDispatchType type) override { | 49 InputEventDispatchType type) override { |
37 ASSERT_EQ(kTestRoutingID, routing_id); | 50 EXPECT_EQ(kTestRoutingID, routing_id); |
38 const unsigned char* eventPtr = | 51 last_event_ = WebInputEventTraits::Clone(*event); |
39 reinterpret_cast<const unsigned char*>(event); | 52 queue_.EventHandled(event->type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
40 last_event_.assign(eventPtr, eventPtr + event->size); | |
41 } | 53 } |
42 | 54 |
43 void SendInputEventAck(int routing_id, | 55 void SendInputEventAck(int routing_id, |
44 blink::WebInputEvent::Type type, | 56 blink::WebInputEvent::Type type, |
45 InputEventAckState ack_result, | 57 InputEventAckState ack_result, |
46 uint32_t touch_event_id) override { | 58 uint32_t touch_event_id) override { |
47 additional_acked_events_.push_back(touch_event_id); | 59 additional_acked_events_.push_back(touch_event_id); |
48 } | 60 } |
49 | 61 |
50 WebInputEventQueue<EventWithDispatchType>& event_queue() { | 62 WebInputEventQueue<EventWithDispatchType>& event_queue() { |
51 return queue_.events_; | 63 return queue_.events_; |
52 } | 64 } |
53 | 65 |
54 bool eventPendingToMain() const { return queue_.sent_notification_to_main_; } | 66 bool eventPendingToMain() const { return queue_.sent_notification_to_main_; } |
55 | 67 |
56 protected: | 68 protected: |
| 69 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; |
57 MainThreadEventQueue queue_; | 70 MainThreadEventQueue queue_; |
58 std::vector<unsigned char> last_event_; | 71 ScopedWebInputEvent last_event_; |
59 std::vector<uint32_t> additional_acked_events_; | 72 std::vector<uint32_t> additional_acked_events_; |
60 }; | 73 }; |
61 | 74 |
62 TEST_F(MainThreadEventQueueTest, NonBlockingWheel) { | 75 TEST_F(MainThreadEventQueueTest, NonBlockingWheel) { |
63 WebMouseWheelEvent kEvents[4] = { | 76 WebMouseWheelEvent kEvents[4] = { |
64 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false), | 77 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false), |
65 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), | 78 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), |
66 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), | 79 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), |
67 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), | 80 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), |
68 }; | 81 }; |
69 | 82 |
70 ASSERT_FALSE(eventPendingToMain()); | 83 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
| 84 EXPECT_EQ(0u, event_queue().size()); |
71 queue_.HandleEvent(&kEvents[0], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | 85 queue_.HandleEvent(&kEvents[0], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, |
72 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 86 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
73 ASSERT_TRUE(eventPendingToMain()); | |
74 queue_.HandleEvent(&kEvents[1], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | 87 queue_.HandleEvent(&kEvents[1], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, |
75 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 88 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
76 ASSERT_EQ(kEvents[0].size, last_event_.size()); | |
77 kEvents[0].dispatchType = | |
78 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | |
79 ASSERT_TRUE(memcmp(&last_event_[0], &kEvents[0], kEvents[0].size) == 0); | |
80 queue_.EventHandled(blink::WebInputEvent::MouseWheel, | |
81 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
82 ASSERT_EQ(kEvents[1].size, last_event_.size()); | |
83 kEvents[1].dispatchType = | |
84 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | |
85 ASSERT_TRUE(memcmp(&last_event_[0], &kEvents[1], kEvents[1].size) == 0); | |
86 ASSERT_TRUE(eventPendingToMain()); | |
87 queue_.EventHandled(blink::WebInputEvent::MouseWheel, | |
88 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
89 ASSERT_FALSE(eventPendingToMain()); | |
90 | |
91 // Ensure that coalescing takes place. | |
92 queue_.HandleEvent(&kEvents[0], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | |
93 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
94 queue_.HandleEvent(&kEvents[2], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | 89 queue_.HandleEvent(&kEvents[2], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, |
95 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 90 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
96 queue_.HandleEvent(&kEvents[3], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | 91 queue_.HandleEvent(&kEvents[3], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, |
97 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 92 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
98 ASSERT_EQ(1u, event_queue().size()); | 93 EXPECT_EQ(2u, event_queue().size()); |
99 ASSERT_TRUE(eventPendingToMain()); | 94 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
| 95 main_task_runner_->RunPendingTasks(); |
| 96 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
| 97 |
| 98 { |
| 99 EXPECT_EQ(kEvents[0].size, last_event_->size); |
| 100 EXPECT_EQ(kEvents[0].type, last_event_->type); |
| 101 const WebMouseWheelEvent* last_wheel_event = |
| 102 static_cast<const WebMouseWheelEvent*>(last_event_.get()); |
| 103 EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive, |
| 104 last_wheel_event->dispatchType); |
| 105 WebMouseWheelEvent coalesced_event = kEvents[0]; |
| 106 internal::Coalesce(kEvents[1], &coalesced_event); |
| 107 coalesced_event.dispatchType = |
| 108 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
| 109 EXPECT_EQ(coalesced_event, *last_wheel_event); |
| 110 } |
| 111 |
| 112 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
| 113 main_task_runner_->RunPendingTasks(); |
| 114 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
| 115 EXPECT_EQ(0u, event_queue().size()); |
| 116 { |
| 117 const WebMouseWheelEvent* last_wheel_event = |
| 118 static_cast<const WebMouseWheelEvent*>(last_event_.get()); |
| 119 WebMouseWheelEvent coalesced_event = kEvents[2]; |
| 120 internal::Coalesce(kEvents[3], &coalesced_event); |
| 121 coalesced_event.dispatchType = |
| 122 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
| 123 EXPECT_EQ(coalesced_event, *last_wheel_event); |
| 124 } |
100 } | 125 } |
101 | 126 |
102 TEST_F(MainThreadEventQueueTest, NonBlockingTouch) { | 127 TEST_F(MainThreadEventQueueTest, NonBlockingTouch) { |
103 SyntheticWebTouchEvent kEvents[4]; | 128 SyntheticWebTouchEvent kEvents[4]; |
104 kEvents[0].PressPoint(10, 10); | 129 kEvents[0].PressPoint(10, 10); |
105 kEvents[1].PressPoint(10, 10); | 130 kEvents[1].PressPoint(10, 10); |
106 kEvents[1].modifiers = 1; | 131 kEvents[1].modifiers = 1; |
107 kEvents[1].MovePoint(0, 20, 20); | 132 kEvents[1].MovePoint(0, 20, 20); |
108 kEvents[2].PressPoint(10, 10); | 133 kEvents[2].PressPoint(10, 10); |
109 kEvents[2].MovePoint(0, 30, 30); | 134 kEvents[2].MovePoint(0, 30, 30); |
110 kEvents[3].PressPoint(10, 10); | 135 kEvents[3].PressPoint(10, 10); |
111 kEvents[3].MovePoint(0, 35, 35); | 136 kEvents[3].MovePoint(0, 35, 35); |
112 | |
113 ASSERT_FALSE(eventPendingToMain()); | |
114 queue_.HandleEvent(&kEvents[0], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | 137 queue_.HandleEvent(&kEvents[0], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, |
115 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 138 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
116 ASSERT_TRUE(eventPendingToMain()); | |
117 queue_.HandleEvent(&kEvents[1], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | 139 queue_.HandleEvent(&kEvents[1], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, |
118 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 140 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
119 ASSERT_EQ(kEvents[0].size, last_event_.size()); | |
120 kEvents[0].dispatchType = | |
121 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | |
122 ASSERT_TRUE(memcmp(&last_event_[0], &kEvents[0], kEvents[0].size) == 0); | |
123 queue_.EventHandled(blink::WebInputEvent::TouchStart, | |
124 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
125 ASSERT_EQ(kEvents[1].size, last_event_.size()); | |
126 kEvents[1].dispatchType = | |
127 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | |
128 ASSERT_TRUE(memcmp(&last_event_[0], &kEvents[1], kEvents[1].size) == 0); | |
129 ASSERT_TRUE(eventPendingToMain()); | |
130 queue_.EventHandled(blink::WebInputEvent::TouchMove, | |
131 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
132 ASSERT_FALSE(eventPendingToMain()); | |
133 | |
134 // Ensure that coalescing takes place. | |
135 queue_.HandleEvent(&kEvents[0], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | |
136 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | |
137 queue_.HandleEvent(&kEvents[2], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | 141 queue_.HandleEvent(&kEvents[2], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, |
138 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 142 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
139 queue_.HandleEvent(&kEvents[3], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | 143 queue_.HandleEvent(&kEvents[3], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, |
140 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 144 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
141 ASSERT_EQ(1u, event_queue().size()); | 145 |
142 ASSERT_TRUE(eventPendingToMain()); | 146 EXPECT_EQ(3u, event_queue().size()); |
| 147 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
| 148 main_task_runner_->RunPendingTasks(); |
| 149 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
| 150 EXPECT_EQ(2u, event_queue().size()); |
| 151 |
| 152 EXPECT_EQ(kEvents[0].size, last_event_->size); |
| 153 EXPECT_EQ(kEvents[0].type, last_event_->type); |
| 154 const WebTouchEvent* last_touch_event = |
| 155 static_cast<const WebTouchEvent*>(last_event_.get()); |
| 156 kEvents[0].dispatchType = |
| 157 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
| 158 EXPECT_EQ(kEvents[0], *last_touch_event); |
| 159 |
| 160 main_task_runner_->RunPendingTasks(); |
| 161 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
| 162 EXPECT_EQ(1u, event_queue().size()); |
| 163 |
| 164 EXPECT_EQ(kEvents[1].size, last_event_->size); |
| 165 EXPECT_EQ(kEvents[1].type, last_event_->type); |
| 166 last_touch_event = static_cast<const WebTouchEvent*>(last_event_.get()); |
| 167 kEvents[1].dispatchType = |
| 168 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
| 169 EXPECT_EQ(kEvents[1], *last_touch_event); |
| 170 |
| 171 main_task_runner_->RunPendingTasks(); |
| 172 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
| 173 EXPECT_EQ(0u, event_queue().size()); |
| 174 |
| 175 EXPECT_EQ(kEvents[2].size, last_event_->size); |
| 176 EXPECT_EQ(kEvents[2].type, last_event_->type); |
| 177 last_touch_event = static_cast<const WebTouchEvent*>(last_event_.get()); |
| 178 WebTouchEvent coalesced_event = kEvents[2]; |
| 179 internal::Coalesce(kEvents[3], &coalesced_event); |
| 180 coalesced_event.dispatchType = |
| 181 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
| 182 EXPECT_EQ(coalesced_event, *last_touch_event); |
143 } | 183 } |
144 | 184 |
145 TEST_F(MainThreadEventQueueTest, BlockingTouch) { | 185 TEST_F(MainThreadEventQueueTest, BlockingTouch) { |
146 SyntheticWebTouchEvent kEvents[4]; | 186 SyntheticWebTouchEvent kEvents[4]; |
147 kEvents[0].PressPoint(10, 10); | 187 kEvents[0].PressPoint(10, 10); |
148 kEvents[1].PressPoint(10, 10); | 188 kEvents[1].PressPoint(10, 10); |
149 kEvents[1].MovePoint(0, 20, 20); | 189 kEvents[1].MovePoint(0, 20, 20); |
150 kEvents[2].PressPoint(10, 10); | 190 kEvents[2].PressPoint(10, 10); |
151 kEvents[2].MovePoint(0, 30, 30); | 191 kEvents[2].MovePoint(0, 30, 30); |
152 kEvents[3].PressPoint(10, 10); | 192 kEvents[3].PressPoint(10, 10); |
153 kEvents[3].MovePoint(0, 35, 35); | 193 kEvents[3].MovePoint(0, 35, 35); |
154 | |
155 ASSERT_FALSE(eventPendingToMain()); | |
156 // Ensure that coalescing takes place. | 194 // Ensure that coalescing takes place. |
157 queue_.HandleEvent(&kEvents[0], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | 195 queue_.HandleEvent(&kEvents[0], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, |
158 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); | 196 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
159 queue_.HandleEvent(&kEvents[1], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | 197 queue_.HandleEvent(&kEvents[1], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, |
160 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 198 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
161 queue_.HandleEvent(&kEvents[2], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | 199 queue_.HandleEvent(&kEvents[2], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, |
162 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 200 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
163 queue_.HandleEvent(&kEvents[3], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, | 201 queue_.HandleEvent(&kEvents[3], ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING, |
164 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 202 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
165 ASSERT_EQ(1u, event_queue().size()); | 203 EXPECT_EQ(2u, event_queue().size()); |
166 ASSERT_TRUE(eventPendingToMain()); | 204 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
167 queue_.EventHandled(kEvents[0].type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 205 main_task_runner_->RunPendingTasks(); |
168 ASSERT_EQ(0u, event_queue().size()); | 206 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
169 queue_.EventHandled(kEvents[1].type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 207 EXPECT_EQ(1u, event_queue().size()); |
170 ASSERT_EQ(2u, additional_acked_events_.size()); | 208 main_task_runner_->RunPendingTasks(); |
171 ASSERT_EQ(kEvents[2].uniqueTouchEventId, additional_acked_events_.at(0)); | 209 EXPECT_EQ(0u, event_queue().size()); |
172 ASSERT_EQ(kEvents[3].uniqueTouchEventId, additional_acked_events_.at(1)); | 210 EXPECT_EQ(2u, additional_acked_events_.size()); |
| 211 EXPECT_EQ(kEvents[2].uniqueTouchEventId, additional_acked_events_.at(0)); |
| 212 EXPECT_EQ(kEvents[3].uniqueTouchEventId, additional_acked_events_.at(1)); |
| 213 } |
| 214 |
| 215 TEST_F(MainThreadEventQueueTest, InterleavedEvents) { |
| 216 WebMouseWheelEvent kWheelEvents[2] = { |
| 217 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false), |
| 218 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), |
| 219 }; |
| 220 SyntheticWebTouchEvent kTouchEvents[2]; |
| 221 kTouchEvents[0].PressPoint(10, 10); |
| 222 kTouchEvents[0].MovePoint(0, 20, 20); |
| 223 kTouchEvents[1].PressPoint(10, 10); |
| 224 kTouchEvents[1].MovePoint(0, 30, 30); |
| 225 |
| 226 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
| 227 EXPECT_EQ(0u, event_queue().size()); |
| 228 queue_.HandleEvent(&kWheelEvents[0], ui::LatencyInfo(), |
| 229 DISPATCH_TYPE_BLOCKING, |
| 230 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
| 231 queue_.HandleEvent(&kTouchEvents[0], ui::LatencyInfo(), |
| 232 DISPATCH_TYPE_BLOCKING, |
| 233 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
| 234 queue_.HandleEvent(&kWheelEvents[1], ui::LatencyInfo(), |
| 235 DISPATCH_TYPE_BLOCKING, |
| 236 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
| 237 queue_.HandleEvent(&kTouchEvents[1], ui::LatencyInfo(), |
| 238 DISPATCH_TYPE_BLOCKING, |
| 239 INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING); |
| 240 EXPECT_EQ(2u, event_queue().size()); |
| 241 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
| 242 main_task_runner_->RunPendingTasks(); |
| 243 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
| 244 |
| 245 { |
| 246 EXPECT_EQ(kWheelEvents[0].size, last_event_->size); |
| 247 EXPECT_EQ(kWheelEvents[0].type, last_event_->type); |
| 248 const WebMouseWheelEvent* last_wheel_event = |
| 249 static_cast<const WebMouseWheelEvent*>(last_event_.get()); |
| 250 EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive, |
| 251 last_wheel_event->dispatchType); |
| 252 WebMouseWheelEvent coalesced_event = kWheelEvents[0]; |
| 253 internal::Coalesce(kWheelEvents[1], &coalesced_event); |
| 254 coalesced_event.dispatchType = |
| 255 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
| 256 EXPECT_EQ(coalesced_event, *last_wheel_event); |
| 257 } |
| 258 |
| 259 EXPECT_TRUE(main_task_runner_->HasPendingTask()); |
| 260 main_task_runner_->RunPendingTasks(); |
| 261 EXPECT_FALSE(main_task_runner_->HasPendingTask()); |
| 262 EXPECT_EQ(0u, event_queue().size()); |
| 263 { |
| 264 EXPECT_EQ(kTouchEvents[0].size, last_event_->size); |
| 265 EXPECT_EQ(kTouchEvents[0].type, last_event_->type); |
| 266 const WebTouchEvent* last_touch_event = |
| 267 static_cast<const WebTouchEvent*>(last_event_.get()); |
| 268 WebTouchEvent coalesced_event = kTouchEvents[0]; |
| 269 internal::Coalesce(kTouchEvents[1], &coalesced_event); |
| 270 coalesced_event.dispatchType = |
| 271 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
| 272 EXPECT_EQ(coalesced_event, *last_touch_event); |
| 273 } |
173 } | 274 } |
174 | 275 |
175 } // namespace content | 276 } // namespace content |
OLD | NEW |