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