OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 <tuple> | 8 #include <tuple> |
9 #include <utility> | 9 #include <utility> |
10 #include <vector> | 10 #include <vector> |
11 | 11 |
12 #include "base/bind.h" | 12 #include "base/bind.h" |
13 #include "base/macros.h" | 13 #include "base/macros.h" |
14 #include "base/memory/ptr_util.h" | 14 #include "base/memory/ptr_util.h" |
15 #include "base/run_loop.h" | 15 #include "base/run_loop.h" |
16 #include "base/test/scoped_task_environment.h" | 16 #include "base/test/scoped_task_environment.h" |
17 #include "base/test/test_simple_task_runner.h" | 17 #include "base/test/test_simple_task_runner.h" |
18 #include "base/threading/thread_task_runner_handle.h" | 18 #include "base/threading/thread_task_runner_handle.h" |
19 #include "build/build_config.h" | 19 #include "build/build_config.h" |
20 #include "content/common/input/synthetic_web_input_event_builders.h" | 20 #include "content/common/input/synthetic_web_input_event_builders.h" |
21 #include "content/common/input_messages.h" | 21 #include "content/common/input_messages.h" |
22 #include "content/common/view_messages.h" | 22 #include "content/common/view_messages.h" |
23 #include "content/public/common/content_features.h" | 23 #include "content/public/common/content_features.h" |
24 #include "content/renderer/input/input_event_filter.h" | 24 #include "content/renderer/input/input_event_filter.h" |
25 #include "content/renderer/input/input_handler_manager.h" | 25 #include "content/renderer/input/input_handler_manager.h" |
26 #include "ipc/ipc_listener.h" | 26 #include "ipc/ipc_listener.h" |
27 #include "ipc/ipc_test_sink.h" | 27 #include "ipc/ipc_test_sink.h" |
28 #include "ipc/message_filter.h" | 28 #include "ipc/message_filter.h" |
29 #include "testing/gtest/include/gtest/gtest.h" | 29 #include "testing/gtest/include/gtest/gtest.h" |
| 30 #include "third_party/WebKit/public/platform/scheduler/test/mock_renderer_schedu
ler.h" |
30 #include "ui/events/blink/web_input_event_traits.h" | 31 #include "ui/events/blink/web_input_event_traits.h" |
31 | 32 |
32 using blink::WebInputEvent; | 33 using blink::WebInputEvent; |
33 using blink::WebMouseEvent; | 34 using blink::WebMouseEvent; |
34 using blink::WebMouseWheelEvent; | 35 using blink::WebMouseWheelEvent; |
35 using blink::WebTouchEvent; | 36 using blink::WebTouchEvent; |
36 | 37 |
37 namespace content { | 38 namespace content { |
38 namespace { | 39 namespace { |
39 | 40 |
40 const int kTestRoutingID = 13; | 41 const int kTestRoutingID = 13; |
41 | 42 |
42 // Simulate a 16ms frame signal. | 43 // Simulate a 16ms frame signal. |
43 const base::TimeDelta kFrameInterval = base::TimeDelta::FromMilliseconds(16); | 44 const base::TimeDelta kFrameInterval = base::TimeDelta::FromMilliseconds(16); |
44 | 45 |
45 bool ShouldBlockEventStream(const blink::WebInputEvent& event) { | 46 bool ShouldBlockEventStream(const blink::WebInputEvent& event) { |
46 return ui::WebInputEventTraits::ShouldBlockEventStream( | 47 return ui::WebInputEventTraits::ShouldBlockEventStream( |
47 event, | 48 event, |
48 base::FeatureList::IsEnabled(features::kRafAlignedTouchInputEvents)); | 49 base::FeatureList::IsEnabled(features::kRafAlignedTouchInputEvents)); |
49 } | 50 } |
50 | 51 |
| 52 class MainThreadEventQueueTest; |
| 53 |
51 class InputEventRecorder : public content::InputHandlerManager { | 54 class InputEventRecorder : public content::InputHandlerManager { |
52 public: | 55 public: |
53 InputEventRecorder(InputEventFilter* filter) | 56 InputEventRecorder(InputEventFilter* filter) |
54 : InputHandlerManager(nullptr, filter, nullptr, nullptr), | 57 : InputHandlerManager(nullptr, filter, nullptr, nullptr), |
55 handle_events_(false), | 58 handle_events_(false), |
56 send_to_widget_(false), | 59 send_to_widget_(false), |
57 passive_(false), | 60 passive_(false), |
58 needs_main_frame_(false) {} | 61 needs_main_frame_(false) {} |
59 | 62 |
60 ~InputEventRecorder() override {} | 63 ~InputEventRecorder() override {} |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
93 latency_info, nullptr); | 96 latency_info, nullptr); |
94 else | 97 else |
95 callback.Run(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, std::move(event), | 98 callback.Run(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, std::move(event), |
96 latency_info, nullptr); | 99 latency_info, nullptr); |
97 } else { | 100 } else { |
98 callback.Run(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, std::move(event), | 101 callback.Run(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, std::move(event), |
99 latency_info, nullptr); | 102 latency_info, nullptr); |
100 } | 103 } |
101 } | 104 } |
102 | 105 |
103 void NeedsMainFrame(int routing_id) override { | 106 void NeedsMainFrame() { needs_main_frame_ = true; } |
104 DCHECK_EQ(kTestRoutingID, routing_id); | |
105 needs_main_frame_ = true; | |
106 } | |
107 | 107 |
108 private: | 108 private: |
109 struct Record { | 109 struct Record { |
110 Record(const WebInputEvent* event) { | 110 Record(const WebInputEvent* event) { |
111 const char* ptr = reinterpret_cast<const char*>(event); | 111 const char* ptr = reinterpret_cast<const char*>(event); |
112 event_data.assign(ptr, ptr + event->size()); | 112 event_data.assign(ptr, ptr + event->size()); |
113 } | 113 } |
114 std::vector<char> event_data; | 114 std::vector<char> event_data; |
115 }; | 115 }; |
116 | 116 |
117 bool handle_events_; | 117 bool handle_events_; |
118 bool send_to_widget_; | 118 bool send_to_widget_; |
119 bool passive_; | 119 bool passive_; |
120 bool needs_main_frame_; | 120 bool needs_main_frame_; |
121 std::vector<Record> records_; | 121 std::vector<Record> records_; |
122 }; | 122 }; |
123 | 123 |
| 124 class ReceivedEvent; |
| 125 class ReceivedMessage; |
| 126 |
| 127 class ReceivedItem { |
| 128 public: |
| 129 ReceivedItem() {} |
| 130 virtual ~ReceivedItem() {} |
| 131 |
| 132 virtual const ReceivedMessage* itemAsMessage() const { |
| 133 CHECK(false); |
| 134 return nullptr; |
| 135 } |
| 136 |
| 137 virtual const ReceivedEvent* itemAsEvent() const { |
| 138 CHECK(false); |
| 139 return nullptr; |
| 140 } |
| 141 }; |
| 142 |
| 143 class ReceivedMessage : public ReceivedItem { |
| 144 public: |
| 145 ReceivedMessage(const IPC::Message& message) : message_(message) {} |
| 146 |
| 147 ~ReceivedMessage() override {} |
| 148 |
| 149 const IPC::Message& message() const { return message_; } |
| 150 |
| 151 const ReceivedMessage* itemAsMessage() const override { return this; } |
| 152 |
| 153 private: |
| 154 IPC::Message message_; |
| 155 }; |
| 156 |
| 157 class ReceivedEvent : public ReceivedItem { |
| 158 public: |
| 159 ReceivedEvent(const blink::WebCoalescedInputEvent& event, |
| 160 InputEventDispatchType dispatch_type) |
| 161 : event_(event.Event(), event.GetCoalescedEventsPointers()), |
| 162 dispatch_type_(dispatch_type) {} |
| 163 |
| 164 ~ReceivedEvent() override {} |
| 165 |
| 166 const ReceivedEvent* itemAsEvent() const override { return this; } |
| 167 |
| 168 InputEventDispatchType dispatchType() const { return dispatch_type_; } |
| 169 |
| 170 const blink::WebInputEvent& event() const { return event_.Event(); } |
| 171 |
| 172 private: |
| 173 blink::WebCoalescedInputEvent event_; |
| 174 InputEventDispatchType dispatch_type_; |
| 175 }; |
| 176 |
124 class IPCMessageRecorder : public IPC::Listener { | 177 class IPCMessageRecorder : public IPC::Listener { |
125 public: | 178 public: |
126 bool OnMessageReceived(const IPC::Message& message) override { | 179 bool OnMessageReceived(const IPC::Message& message) override { |
127 messages_.push_back(message); | 180 std::unique_ptr<ReceivedItem> item(new ReceivedMessage(message)); |
| 181 messages_.push_back(std::move(item)); |
128 return true; | 182 return true; |
129 } | 183 } |
130 | 184 |
131 size_t message_count() const { return messages_.size(); } | 185 size_t message_count() const { return messages_.size(); } |
132 | 186 |
133 const IPC::Message& message_at(size_t i) const { | 187 const ReceivedMessage* message_at(size_t i) const { |
134 return messages_[i]; | 188 return messages_[i]->itemAsMessage(); |
| 189 } |
| 190 |
| 191 const ReceivedEvent* event_at(size_t i) const { |
| 192 return messages_[i]->itemAsEvent(); |
| 193 } |
| 194 |
| 195 void AppendEvent(const blink::WebCoalescedInputEvent& event, |
| 196 InputEventDispatchType dispatch_type) { |
| 197 std::unique_ptr<ReceivedItem> item(new ReceivedEvent(event, dispatch_type)); |
| 198 messages_.push_back(std::move(item)); |
135 } | 199 } |
136 | 200 |
137 void Clear() { | 201 void Clear() { |
138 messages_.clear(); | 202 messages_.clear(); |
139 } | 203 } |
140 | 204 |
141 private: | 205 private: |
142 std::vector<IPC::Message> messages_; | 206 std::vector<std::unique_ptr<ReceivedItem>> messages_; |
| 207 }; |
| 208 |
| 209 class MainThreadEventQueueForTest : public MainThreadEventQueue { |
| 210 public: |
| 211 MainThreadEventQueueForTest( |
| 212 const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner, |
| 213 blink::scheduler::RendererScheduler* scheduler, |
| 214 InputEventRecorder* recorder, |
| 215 IPCMessageRecorder* message_recorder) |
| 216 : MainThreadEventQueue(main_task_runner, scheduler), |
| 217 event_recorder_(recorder), |
| 218 message_recorder_(message_recorder) {} |
| 219 |
| 220 InputEventAckState HandleEventOnMainThread( |
| 221 const blink::WebCoalescedInputEvent& event, |
| 222 const ui::LatencyInfo& latency, |
| 223 InputEventDispatchType dispatch_type) override { |
| 224 message_recorder_->AppendEvent(event, dispatch_type); |
| 225 return INPUT_EVENT_ACK_STATE_NOT_CONSUMED; |
| 226 } |
| 227 |
| 228 void SendInputEventAck(blink::WebInputEvent::Type type, |
| 229 InputEventAckState ack_result, |
| 230 uint32_t touch_event_id) override {} |
| 231 |
| 232 void NeedsMainFrame() override { event_recorder_->NeedsMainFrame(); } |
| 233 |
| 234 private: |
| 235 ~MainThreadEventQueueForTest() override {} |
| 236 |
| 237 InputEventRecorder* event_recorder_; |
| 238 IPCMessageRecorder* message_recorder_; |
143 }; | 239 }; |
144 | 240 |
145 } // namespace | 241 } // namespace |
146 | 242 |
147 class InputEventFilterTest : public testing::Test { | 243 class InputEventFilterTest : public testing::Test { |
148 public: | 244 public: |
149 InputEventFilterTest() | 245 InputEventFilterTest() |
150 : main_task_runner_(new base::TestSimpleTaskRunner()) {} | 246 : main_task_runner_(new base::TestSimpleTaskRunner()) {} |
151 | 247 |
152 void SetUp() override { | 248 void SetUp() override { |
(...skipping 11 matching lines...) Expand all Loading... |
164 filter_->OnMessageReceived(events[i]); | 260 filter_->OnMessageReceived(events[i]); |
165 | 261 |
166 // base::RunLoop is the "IO Thread". | 262 // base::RunLoop is the "IO Thread". |
167 base::RunLoop().RunUntilIdle(); | 263 base::RunLoop().RunUntilIdle(); |
168 | 264 |
169 while (event_recorder_->needs_main_frame() || | 265 while (event_recorder_->needs_main_frame() || |
170 main_task_runner_->HasPendingTask()) { | 266 main_task_runner_->HasPendingTask()) { |
171 main_task_runner_->RunUntilIdle(); | 267 main_task_runner_->RunUntilIdle(); |
172 frame_time_ += kFrameInterval; | 268 frame_time_ += kFrameInterval; |
173 event_recorder_->reset_needs_main_frame(); | 269 event_recorder_->reset_needs_main_frame(); |
174 filter_->ProcessRafAlignedInput(kTestRoutingID, frame_time_); | 270 input_event_queue_->DispatchRafAlignedInput(frame_time_); |
175 | 271 |
176 // Run queued io thread tasks. | 272 // Run queued io thread tasks. |
177 base::RunLoop().RunUntilIdle(); | 273 base::RunLoop().RunUntilIdle(); |
178 } | 274 } |
179 } | 275 } |
180 | 276 |
181 template <typename T> | 277 template <typename T> |
182 void AddEventsToFilter(const T events[], size_t count) { | 278 void AddEventsToFilter(const T events[], size_t count) { |
183 std::vector<IPC::Message> messages; | 279 std::vector<IPC::Message> messages; |
184 for (size_t i = 0; i < count; ++i) { | 280 for (size_t i = 0; i < count; ++i) { |
185 messages.push_back(InputMsg_HandleInputEvent( | 281 messages.push_back(InputMsg_HandleInputEvent( |
186 kTestRoutingID, &events[i], std::vector<const WebInputEvent*>(), | 282 kTestRoutingID, &events[i], std::vector<const WebInputEvent*>(), |
187 ui::LatencyInfo(), | 283 ui::LatencyInfo(), |
188 ShouldBlockEventStream(events[i]) | 284 ShouldBlockEventStream(events[i]) |
189 ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING | 285 ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING |
190 : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING)); | 286 : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING)); |
191 } | 287 } |
192 | 288 |
193 AddMessagesToFilter(messages); | 289 AddMessagesToFilter(messages); |
194 } | 290 } |
195 | 291 |
| 292 void RegisterRoute() { |
| 293 input_event_queue_ = new MainThreadEventQueueForTest( |
| 294 main_task_runner_, &renderer_scheduler_, event_recorder_.get(), |
| 295 &message_recorder_); |
| 296 filter_->RegisterRoutingID(kTestRoutingID, input_event_queue_); |
| 297 } |
| 298 |
196 protected: | 299 protected: |
197 base::test::ScopedTaskEnvironment scoped_task_environment_; | 300 base::test::ScopedTaskEnvironment scoped_task_environment_; |
198 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; | 301 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; |
199 | 302 |
200 // Used to record IPCs sent by the filter to the RenderWidgetHost. | 303 // Used to record IPCs sent by the filter to the RenderWidgetHost. |
201 IPC::TestSink ipc_sink_; | 304 IPC::TestSink ipc_sink_; |
202 | 305 |
203 // Used to record IPCs forwarded by the filter to the main thread. | 306 // Used to record IPCs forwarded by the filter to the main thread. |
204 IPCMessageRecorder message_recorder_; | 307 IPCMessageRecorder message_recorder_; |
205 | 308 |
206 scoped_refptr<InputEventFilter> filter_; | 309 scoped_refptr<InputEventFilter> filter_; |
207 | 310 |
| 311 blink::scheduler::MockRendererScheduler renderer_scheduler_; |
| 312 scoped_refptr<MainThreadEventQueue> input_event_queue_; |
| 313 |
208 // Used to record WebInputEvents delivered to the handler. | 314 // Used to record WebInputEvents delivered to the handler. |
209 std::unique_ptr<InputEventRecorder> event_recorder_; | 315 std::unique_ptr<InputEventRecorder> event_recorder_; |
210 | 316 |
211 base::TimeTicks frame_time_; | 317 base::TimeTicks frame_time_; |
212 }; | 318 }; |
213 | 319 |
214 TEST_F(InputEventFilterTest, Basic) { | 320 TEST_F(InputEventFilterTest, Basic) { |
215 WebMouseEvent kEvents[3] = {SyntheticWebMouseEventBuilder::Build( | 321 WebMouseEvent kEvents[3] = {SyntheticWebMouseEventBuilder::Build( |
216 WebMouseEvent::kMouseMove, 10, 10, 0), | 322 WebMouseEvent::kMouseMove, 10, 10, 0), |
217 SyntheticWebMouseEventBuilder::Build( | 323 SyntheticWebMouseEventBuilder::Build( |
218 WebMouseEvent::kMouseMove, 20, 20, 0), | 324 WebMouseEvent::kMouseMove, 20, 20, 0), |
219 SyntheticWebMouseEventBuilder::Build( | 325 SyntheticWebMouseEventBuilder::Build( |
220 WebMouseEvent::kMouseMove, 30, 30, 0)}; | 326 WebMouseEvent::kMouseMove, 30, 30, 0)}; |
221 | 327 |
222 AddEventsToFilter(kEvents, arraysize(kEvents)); | 328 AddEventsToFilter(kEvents, arraysize(kEvents)); |
223 EXPECT_EQ(0U, ipc_sink_.message_count()); | 329 EXPECT_EQ(0U, ipc_sink_.message_count()); |
224 EXPECT_EQ(0U, event_recorder_->record_count()); | 330 EXPECT_EQ(0U, event_recorder_->record_count()); |
225 EXPECT_EQ(0U, message_recorder_.message_count()); | 331 EXPECT_EQ(0U, message_recorder_.message_count()); |
226 | 332 |
227 filter_->RegisterRoutingID(kTestRoutingID); | 333 RegisterRoute(); |
228 | 334 |
229 AddEventsToFilter(kEvents, arraysize(kEvents)); | 335 AddEventsToFilter(kEvents, arraysize(kEvents)); |
230 ASSERT_EQ(arraysize(kEvents), ipc_sink_.message_count()); | 336 ASSERT_EQ(arraysize(kEvents), ipc_sink_.message_count()); |
231 ASSERT_EQ(arraysize(kEvents), event_recorder_->record_count()); | 337 ASSERT_EQ(arraysize(kEvents), event_recorder_->record_count()); |
232 EXPECT_EQ(0U, message_recorder_.message_count()); | 338 EXPECT_EQ(0U, message_recorder_.message_count()); |
233 | 339 |
234 for (size_t i = 0; i < arraysize(kEvents); ++i) { | 340 for (size_t i = 0; i < arraysize(kEvents); ++i) { |
235 const IPC::Message* message = ipc_sink_.GetMessageAt(i); | 341 const IPC::Message* message = ipc_sink_.GetMessageAt(i); |
236 EXPECT_EQ(kTestRoutingID, message->routing_id()); | 342 EXPECT_EQ(kTestRoutingID, message->routing_id()); |
237 EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type()); | 343 EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type()); |
(...skipping 14 matching lines...) Expand all Loading... |
252 } | 358 } |
253 | 359 |
254 event_recorder_->set_send_to_widget(true); | 360 event_recorder_->set_send_to_widget(true); |
255 | 361 |
256 AddEventsToFilter(kEvents, arraysize(kEvents)); | 362 AddEventsToFilter(kEvents, arraysize(kEvents)); |
257 EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count()); | 363 EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count()); |
258 EXPECT_EQ(2 * arraysize(kEvents), event_recorder_->record_count()); | 364 EXPECT_EQ(2 * arraysize(kEvents), event_recorder_->record_count()); |
259 EXPECT_EQ(1u, message_recorder_.message_count()); | 365 EXPECT_EQ(1u, message_recorder_.message_count()); |
260 | 366 |
261 { | 367 { |
262 const IPC::Message& message = message_recorder_.message_at(0); | 368 const WebInputEvent& event = message_recorder_.event_at(0)->event(); |
263 | 369 EXPECT_EQ(kEvents[2].size(), event.size()); |
264 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 370 EXPECT_TRUE(memcmp(&kEvents[2], &event, event.size()) == 0); |
265 InputMsg_HandleInputEvent::Param params; | |
266 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | |
267 const WebInputEvent* event = std::get<0>(params); | |
268 | |
269 EXPECT_EQ(kEvents[2].size(), event->size()); | |
270 EXPECT_TRUE(memcmp(&kEvents[2], event, event->size()) == 0); | |
271 } | 371 } |
272 | 372 |
273 // Now reset everything, and test that DidHandleInputEvent is called. | 373 // Now reset everything, and test that DidHandleInputEvent is called. |
274 | 374 |
275 ipc_sink_.ClearMessages(); | 375 ipc_sink_.ClearMessages(); |
276 event_recorder_->Clear(); | 376 event_recorder_->Clear(); |
277 message_recorder_.Clear(); | 377 message_recorder_.Clear(); |
278 | 378 |
279 event_recorder_->set_handle_events(true); | 379 event_recorder_->set_handle_events(true); |
280 | 380 |
(...skipping 12 matching lines...) Expand all Loading... |
293 WebInputEvent::Type event_type = std::get<0>(params).type; | 393 WebInputEvent::Type event_type = std::get<0>(params).type; |
294 InputEventAckState ack_result = std::get<0>(params).state; | 394 InputEventAckState ack_result = std::get<0>(params).state; |
295 EXPECT_EQ(kEvents[i].GetType(), event_type); | 395 EXPECT_EQ(kEvents[i].GetType(), event_type); |
296 EXPECT_EQ(ack_result, INPUT_EVENT_ACK_STATE_CONSUMED); | 396 EXPECT_EQ(ack_result, INPUT_EVENT_ACK_STATE_CONSUMED); |
297 } | 397 } |
298 | 398 |
299 filter_->OnFilterRemoved(); | 399 filter_->OnFilterRemoved(); |
300 } | 400 } |
301 | 401 |
302 TEST_F(InputEventFilterTest, PreserveRelativeOrder) { | 402 TEST_F(InputEventFilterTest, PreserveRelativeOrder) { |
303 filter_->RegisterRoutingID(kTestRoutingID); | 403 RegisterRoute(); |
304 event_recorder_->set_send_to_widget(true); | 404 event_recorder_->set_send_to_widget(true); |
305 | 405 |
306 WebMouseEvent mouse_down = | 406 WebMouseEvent mouse_down = |
307 SyntheticWebMouseEventBuilder::Build(WebMouseEvent::kMouseDown); | 407 SyntheticWebMouseEventBuilder::Build(WebMouseEvent::kMouseDown); |
308 WebMouseEvent mouse_up = | 408 WebMouseEvent mouse_up = |
309 SyntheticWebMouseEventBuilder::Build(WebMouseEvent::kMouseUp); | 409 SyntheticWebMouseEventBuilder::Build(WebMouseEvent::kMouseUp); |
310 | 410 |
311 std::vector<IPC::Message> messages; | 411 std::vector<IPC::Message> messages; |
312 messages.push_back(InputMsg_HandleInputEvent( | 412 messages.push_back(InputMsg_HandleInputEvent( |
313 kTestRoutingID, &mouse_down, std::vector<const WebInputEvent*>(), | 413 kTestRoutingID, &mouse_down, std::vector<const WebInputEvent*>(), |
(...skipping 30 matching lines...) Expand all Loading... |
344 kTestRoutingID, &mouse_up, std::vector<const WebInputEvent*>(), | 444 kTestRoutingID, &mouse_up, std::vector<const WebInputEvent*>(), |
345 ui::LatencyInfo(), | 445 ui::LatencyInfo(), |
346 ShouldBlockEventStream(mouse_up) | 446 ShouldBlockEventStream(mouse_up) |
347 ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING | 447 ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING |
348 : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING)); | 448 : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING)); |
349 AddMessagesToFilter(messages); | 449 AddMessagesToFilter(messages); |
350 | 450 |
351 // We should have sent all messages back to the main thread and preserved | 451 // We should have sent all messages back to the main thread and preserved |
352 // their relative order. | 452 // their relative order. |
353 ASSERT_EQ(message_recorder_.message_count(), messages.size()); | 453 ASSERT_EQ(message_recorder_.message_count(), messages.size()); |
354 for (size_t i = 0; i < messages.size(); ++i) { | 454 EXPECT_TRUE(message_recorder_.event_at(0)); |
355 EXPECT_EQ(message_recorder_.message_at(i).type(), messages[i].type()) << i; | 455 for (size_t i = 1; i < messages.size() - 1; ++i) { |
| 456 EXPECT_EQ(message_recorder_.message_at(i)->message().type(), |
| 457 messages[i].type()) |
| 458 << i; |
356 } | 459 } |
| 460 EXPECT_TRUE(message_recorder_.event_at(messages.size() - 1)); |
357 } | 461 } |
358 | 462 |
359 TEST_F(InputEventFilterTest, NonBlockingWheel) { | 463 TEST_F(InputEventFilterTest, NonBlockingWheel) { |
360 WebMouseWheelEvent kEvents[4] = { | 464 WebMouseWheelEvent kEvents[4] = { |
361 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 1, false), | 465 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 1, false), |
362 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), | 466 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), |
363 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), | 467 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), |
364 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), | 468 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), |
365 }; | 469 }; |
366 | 470 |
367 filter_->RegisterRoutingID(kTestRoutingID); | 471 RegisterRoute(); |
368 event_recorder_->set_send_to_widget(true); | 472 event_recorder_->set_send_to_widget(true); |
369 event_recorder_->set_passive(true); | 473 event_recorder_->set_passive(true); |
370 | 474 |
371 AddEventsToFilter(kEvents, arraysize(kEvents)); | 475 AddEventsToFilter(kEvents, arraysize(kEvents)); |
372 EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count()); | 476 EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count()); |
373 ASSERT_EQ(4u, ipc_sink_.message_count()); | 477 ASSERT_EQ(4u, ipc_sink_.message_count()); |
374 | 478 |
375 // All events are handled, one is coalesced. | 479 // All events are handled, one is coalesced. |
376 EXPECT_EQ(3u, message_recorder_.message_count()); | 480 EXPECT_EQ(3u, message_recorder_.message_count()); |
377 | 481 |
378 // First two messages should be identical. | 482 // First two messages should be identical. |
379 for (size_t i = 0; i < 2; ++i) { | 483 for (size_t i = 0; i < 2; ++i) { |
380 const IPC::Message& message = message_recorder_.message_at(i); | 484 const ReceivedEvent* message = message_recorder_.event_at(i); |
381 | 485 |
382 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 486 const WebInputEvent& event = message->event(); |
383 InputMsg_HandleInputEvent::Param params; | 487 InputEventDispatchType dispatch_type = message->dispatchType(); |
384 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | |
385 const WebInputEvent* event = std::get<0>(params); | |
386 InputEventDispatchType dispatch_type = std::get<3>(params); | |
387 | 488 |
388 EXPECT_EQ(kEvents[i].size(), event->size()); | 489 EXPECT_EQ(kEvents[i].size(), event.size()); |
389 kEvents[i].dispatch_type = | 490 kEvents[i].dispatch_type = |
390 WebInputEvent::DispatchType::kListenersNonBlockingPassive; | 491 WebInputEvent::DispatchType::kListenersNonBlockingPassive; |
391 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size()) == 0); | 492 EXPECT_TRUE(memcmp(&kEvents[i], &event, event.size()) == 0); |
392 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, | 493 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
393 dispatch_type); | 494 dispatch_type); |
394 } | 495 } |
395 | 496 |
396 // Third message is coalesced. | 497 // Third message is coalesced. |
397 { | 498 { |
398 const IPC::Message& message = message_recorder_.message_at(2); | 499 const ReceivedEvent* message = message_recorder_.event_at(2); |
399 | 500 |
400 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 501 const WebMouseWheelEvent& event = |
401 InputMsg_HandleInputEvent::Param params; | 502 static_cast<const WebMouseWheelEvent&>(message->event()); |
402 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 503 InputEventDispatchType dispatch_type = message->dispatchType(); |
403 const WebMouseWheelEvent* event = | |
404 static_cast<const WebMouseWheelEvent*>(std::get<0>(params)); | |
405 InputEventDispatchType dispatch_type = std::get<3>(params); | |
406 | 504 |
407 kEvents[2].dispatch_type = | 505 kEvents[2].dispatch_type = |
408 WebInputEvent::DispatchType::kListenersNonBlockingPassive; | 506 WebInputEvent::DispatchType::kListenersNonBlockingPassive; |
409 EXPECT_EQ(kEvents[2].size(), event->size()); | 507 EXPECT_EQ(kEvents[2].size(), event.size()); |
410 EXPECT_EQ(kEvents[2].delta_x + kEvents[3].delta_x, event->delta_x); | 508 EXPECT_EQ(kEvents[2].delta_x + kEvents[3].delta_x, event.delta_x); |
411 EXPECT_EQ(kEvents[2].delta_y + kEvents[3].delta_y, event->delta_y); | 509 EXPECT_EQ(kEvents[2].delta_y + kEvents[3].delta_y, event.delta_y); |
412 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, | 510 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
413 dispatch_type); | 511 dispatch_type); |
414 } | 512 } |
415 } | 513 } |
416 | 514 |
417 TEST_F(InputEventFilterTest, NonBlockingTouch) { | 515 TEST_F(InputEventFilterTest, NonBlockingTouch) { |
418 SyntheticWebTouchEvent kEvents[4]; | 516 SyntheticWebTouchEvent kEvents[4]; |
419 kEvents[0].PressPoint(10, 10); | 517 kEvents[0].PressPoint(10, 10); |
420 kEvents[1].PressPoint(10, 10); | 518 kEvents[1].PressPoint(10, 10); |
421 kEvents[1].SetModifiers(1); | 519 kEvents[1].SetModifiers(1); |
422 kEvents[1].MovePoint(0, 20, 20); | 520 kEvents[1].MovePoint(0, 20, 20); |
423 kEvents[2].PressPoint(10, 10); | 521 kEvents[2].PressPoint(10, 10); |
424 kEvents[2].MovePoint(0, 30, 30); | 522 kEvents[2].MovePoint(0, 30, 30); |
425 kEvents[3].PressPoint(10, 10); | 523 kEvents[3].PressPoint(10, 10); |
426 kEvents[3].MovePoint(0, 35, 35); | 524 kEvents[3].MovePoint(0, 35, 35); |
427 | 525 |
428 filter_->RegisterRoutingID(kTestRoutingID); | 526 RegisterRoute(); |
429 event_recorder_->set_send_to_widget(true); | 527 event_recorder_->set_send_to_widget(true); |
430 event_recorder_->set_passive(true); | 528 event_recorder_->set_passive(true); |
431 | 529 |
432 AddEventsToFilter(kEvents, arraysize(kEvents)); | 530 AddEventsToFilter(kEvents, arraysize(kEvents)); |
433 EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count()); | 531 EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count()); |
434 ASSERT_EQ(4u, ipc_sink_.message_count()); | 532 ASSERT_EQ(4u, ipc_sink_.message_count()); |
435 | 533 |
436 // All events are handled and one set was coalesced. | 534 // All events are handled and one set was coalesced. |
437 EXPECT_EQ(3u, message_recorder_.message_count()); | 535 EXPECT_EQ(3u, message_recorder_.message_count()); |
438 | 536 |
439 // First two messages should be identical. | 537 // First two messages should be identical. |
440 for (size_t i = 0; i < 2; ++i) { | 538 for (size_t i = 0; i < 2; ++i) { |
441 const IPC::Message& message = message_recorder_.message_at(i); | 539 const ReceivedEvent* message = message_recorder_.event_at(i); |
442 | 540 |
443 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 541 const WebInputEvent& event = message->event(); |
444 InputMsg_HandleInputEvent::Param params; | 542 InputEventDispatchType dispatch_type = message->dispatchType(); |
445 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | |
446 const WebInputEvent* event = std::get<0>(params); | |
447 InputEventDispatchType dispatch_type = std::get<3>(params); | |
448 | 543 |
449 EXPECT_EQ(kEvents[i].size(), event->size()); | 544 EXPECT_EQ(kEvents[i].size(), event.size()); |
450 kEvents[i].dispatch_type = | 545 kEvents[i].dispatch_type = |
451 WebInputEvent::DispatchType::kListenersNonBlockingPassive; | 546 WebInputEvent::DispatchType::kListenersNonBlockingPassive; |
452 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size()) == 0); | 547 EXPECT_TRUE(memcmp(&kEvents[i], &event, event.size()) == 0); |
453 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, | 548 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
454 dispatch_type); | 549 dispatch_type); |
455 } | 550 } |
456 | 551 |
457 // Third message is coalesced. | 552 // Third message is coalesced. |
458 { | 553 { |
459 const IPC::Message& message = message_recorder_.message_at(2); | 554 const ReceivedEvent* message = message_recorder_.event_at(2); |
460 | 555 |
461 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 556 const WebTouchEvent& event = |
462 InputMsg_HandleInputEvent::Param params; | 557 static_cast<const WebTouchEvent&>(message->event()); |
463 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 558 InputEventDispatchType dispatch_type = message->dispatchType(); |
464 const WebTouchEvent* event = | |
465 static_cast<const WebTouchEvent*>(std::get<0>(params)); | |
466 InputEventDispatchType dispatch_type = std::get<3>(params); | |
467 | 559 |
468 EXPECT_EQ(kEvents[3].size(), event->size()); | 560 EXPECT_EQ(kEvents[3].size(), event.size()); |
469 EXPECT_EQ(1u, kEvents[3].touches_length); | 561 EXPECT_EQ(1u, kEvents[3].touches_length); |
470 EXPECT_EQ(kEvents[3].touches[0].position.x, event->touches[0].position.x); | 562 EXPECT_EQ(kEvents[3].touches[0].position.x, event.touches[0].position.x); |
471 EXPECT_EQ(kEvents[3].touches[0].position.y, event->touches[0].position.y); | 563 EXPECT_EQ(kEvents[3].touches[0].position.y, event.touches[0].position.y); |
472 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, | 564 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
473 dispatch_type); | 565 dispatch_type); |
474 } | 566 } |
475 } | 567 } |
476 | 568 |
477 TEST_F(InputEventFilterTest, IntermingledNonBlockingTouch) { | 569 TEST_F(InputEventFilterTest, IntermingledNonBlockingTouch) { |
478 SyntheticWebTouchEvent kEvents[2]; | 570 SyntheticWebTouchEvent kEvents[2]; |
479 kEvents[0].PressPoint(10, 10); | 571 kEvents[0].PressPoint(10, 10); |
480 kEvents[1].PressPoint(10, 10); | 572 kEvents[1].PressPoint(10, 10); |
481 kEvents[1].ReleasePoint(0); | 573 kEvents[1].ReleasePoint(0); |
482 SyntheticWebTouchEvent kBlockingEvents[1]; | 574 SyntheticWebTouchEvent kBlockingEvents[1]; |
483 kBlockingEvents[0].PressPoint(10, 10); | 575 kBlockingEvents[0].PressPoint(10, 10); |
484 | 576 |
485 filter_->RegisterRoutingID(kTestRoutingID); | 577 RegisterRoute(); |
486 event_recorder_->set_send_to_widget(true); | 578 event_recorder_->set_send_to_widget(true); |
487 event_recorder_->set_passive(true); | 579 event_recorder_->set_passive(true); |
488 AddEventsToFilter(kEvents, arraysize(kEvents)); | 580 AddEventsToFilter(kEvents, arraysize(kEvents)); |
489 EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count()); | 581 EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count()); |
490 | 582 |
491 event_recorder_->set_passive(false); | 583 event_recorder_->set_passive(false); |
492 AddEventsToFilter(kBlockingEvents, arraysize(kBlockingEvents)); | 584 AddEventsToFilter(kBlockingEvents, arraysize(kBlockingEvents)); |
493 EXPECT_EQ(arraysize(kEvents) + arraysize(kBlockingEvents), | 585 EXPECT_EQ(arraysize(kEvents) + arraysize(kBlockingEvents), |
494 event_recorder_->record_count()); | 586 event_recorder_->record_count()); |
495 ASSERT_EQ(3u, event_recorder_->record_count()); | 587 ASSERT_EQ(3u, event_recorder_->record_count()); |
496 EXPECT_EQ(3u, message_recorder_.message_count()); | 588 EXPECT_EQ(3u, message_recorder_.message_count()); |
497 | 589 |
498 { | 590 { |
499 const IPC::Message& message = message_recorder_.message_at(0); | 591 const ReceivedEvent* message = message_recorder_.event_at(0); |
500 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 592 const WebInputEvent& event = message->event(); |
501 InputMsg_HandleInputEvent::Param params; | 593 InputEventDispatchType dispatch_type = message->dispatchType(); |
502 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | |
503 const WebInputEvent* event = std::get<0>(params); | |
504 InputEventDispatchType dispatch_type = std::get<3>(params); | |
505 | 594 |
506 EXPECT_EQ(kEvents[0].size(), event->size()); | 595 EXPECT_EQ(kEvents[0].size(), event.size()); |
507 kEvents[0].dispatch_type = | 596 kEvents[0].dispatch_type = |
508 WebInputEvent::DispatchType::kListenersNonBlockingPassive; | 597 WebInputEvent::DispatchType::kListenersNonBlockingPassive; |
509 EXPECT_TRUE(memcmp(&kEvents[0], event, event->size()) == 0); | 598 EXPECT_TRUE(memcmp(&kEvents[0], &event, event.size()) == 0); |
510 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, | 599 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
511 dispatch_type); | 600 dispatch_type); |
512 } | 601 } |
513 | 602 |
514 { | 603 { |
515 const IPC::Message& message = message_recorder_.message_at(1); | 604 const ReceivedEvent* message = message_recorder_.event_at(1); |
516 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 605 const WebInputEvent& event = message->event(); |
517 InputMsg_HandleInputEvent::Param params; | 606 InputEventDispatchType dispatch_type = message->dispatchType(); |
518 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | |
519 const WebInputEvent* event = std::get<0>(params); | |
520 InputEventDispatchType dispatch_type = std::get<3>(params); | |
521 | 607 |
522 EXPECT_EQ(kEvents[1].size(), event->size()); | 608 EXPECT_EQ(kEvents[1].size(), event.size()); |
523 kEvents[1].dispatch_type = | 609 kEvents[1].dispatch_type = |
524 WebInputEvent::DispatchType::kListenersNonBlockingPassive; | 610 WebInputEvent::DispatchType::kListenersNonBlockingPassive; |
525 EXPECT_TRUE(memcmp(&kEvents[1], event, event->size()) == 0); | 611 EXPECT_TRUE(memcmp(&kEvents[1], &event, event.size()) == 0); |
526 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, | 612 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
527 dispatch_type); | 613 dispatch_type); |
528 } | 614 } |
529 | 615 |
530 { | 616 { |
531 const IPC::Message& message = message_recorder_.message_at(2); | 617 const ReceivedEvent* message = message_recorder_.event_at(2); |
532 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 618 const WebInputEvent& event = message->event(); |
533 InputMsg_HandleInputEvent::Param params; | 619 InputEventDispatchType dispatch_type = message->dispatchType(); |
534 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | |
535 const WebInputEvent* event = std::get<0>(params); | |
536 InputEventDispatchType dispatch_type = std::get<3>(params); | |
537 | 620 |
538 EXPECT_EQ(kBlockingEvents[0].size(), event->size()); | 621 EXPECT_EQ(kBlockingEvents[0].size(), event.size()); |
539 EXPECT_TRUE(memcmp(&kBlockingEvents[0], event, event->size()) == 0); | 622 EXPECT_TRUE(memcmp(&kBlockingEvents[0], &event, event.size()) == 0); |
540 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_BLOCKING, dispatch_type); | 623 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_BLOCKING, dispatch_type); |
541 } | 624 } |
542 } | 625 } |
543 | 626 |
544 } // namespace content | 627 } // namespace content |
OLD | NEW |