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