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 { | |
ncarter (slow)
2017/04/20 22:04:44
These method names aren't in Chromium C++ style.
dtapuska
2017/04/21 14:27:30
ugh.. yes you are correct!
| |
133 NOTREACHED(); | |
134 return nullptr; | |
135 } | |
136 | |
137 virtual const ReceivedEvent* itemAsEvent() const { | |
138 NOTREACHED(); | |
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_; |
143 }; | 207 }; |
144 | 208 |
145 } // namespace | 209 } // namespace |
146 | 210 |
147 class InputEventFilterTest : public testing::Test { | 211 class InputEventFilterTest : public testing::Test, |
212 public MainThreadEventQueueClient { | |
148 public: | 213 public: |
149 InputEventFilterTest() | 214 InputEventFilterTest() |
150 : main_task_runner_(new base::TestSimpleTaskRunner()) {} | 215 : main_task_runner_(new base::TestSimpleTaskRunner()) {} |
151 | 216 |
152 void SetUp() override { | 217 void SetUp() override { |
153 filter_ = new InputEventFilter( | 218 filter_ = new InputEventFilter( |
154 base::Bind(base::IgnoreResult(&IPCMessageRecorder::OnMessageReceived), | 219 base::Bind(base::IgnoreResult(&IPCMessageRecorder::OnMessageReceived), |
155 base::Unretained(&message_recorder_)), | 220 base::Unretained(&message_recorder_)), |
156 main_task_runner_, main_task_runner_); | 221 main_task_runner_, main_task_runner_); |
157 event_recorder_ = base::MakeUnique<InputEventRecorder>(filter_.get()); | 222 event_recorder_ = base::MakeUnique<InputEventRecorder>(filter_.get()); |
158 filter_->SetInputHandlerManager(event_recorder_.get()); | 223 filter_->SetInputHandlerManager(event_recorder_.get()); |
159 filter_->OnFilterAdded(&ipc_sink_); | 224 filter_->OnFilterAdded(&ipc_sink_); |
160 } | 225 } |
161 | 226 |
162 void AddMessagesToFilter(const std::vector<IPC::Message>& events) { | 227 void AddMessagesToFilter(const std::vector<IPC::Message>& events) { |
163 for (size_t i = 0; i < events.size(); ++i) | 228 for (size_t i = 0; i < events.size(); ++i) |
164 filter_->OnMessageReceived(events[i]); | 229 filter_->OnMessageReceived(events[i]); |
165 | 230 |
166 // base::RunLoop is the "IO Thread". | 231 // base::RunLoop is the "IO Thread". |
167 base::RunLoop().RunUntilIdle(); | 232 base::RunLoop().RunUntilIdle(); |
168 | 233 |
169 while (event_recorder_->needs_main_frame() || | 234 while (event_recorder_->needs_main_frame() || |
170 main_task_runner_->HasPendingTask()) { | 235 main_task_runner_->HasPendingTask()) { |
171 main_task_runner_->RunUntilIdle(); | 236 main_task_runner_->RunUntilIdle(); |
172 frame_time_ += kFrameInterval; | 237 frame_time_ += kFrameInterval; |
173 event_recorder_->reset_needs_main_frame(); | 238 event_recorder_->reset_needs_main_frame(); |
174 filter_->ProcessRafAlignedInput(kTestRoutingID, frame_time_); | 239 input_event_queue_->DispatchRafAlignedInput(frame_time_); |
175 | 240 |
176 // Run queued io thread tasks. | 241 // Run queued io thread tasks. |
177 base::RunLoop().RunUntilIdle(); | 242 base::RunLoop().RunUntilIdle(); |
178 } | 243 } |
179 } | 244 } |
180 | 245 |
181 template <typename T> | 246 template <typename T> |
182 void AddEventsToFilter(const T events[], size_t count) { | 247 void AddEventsToFilter(const T events[], size_t count) { |
183 std::vector<IPC::Message> messages; | 248 std::vector<IPC::Message> messages; |
184 for (size_t i = 0; i < count; ++i) { | 249 for (size_t i = 0; i < count; ++i) { |
185 messages.push_back(InputMsg_HandleInputEvent( | 250 messages.push_back(InputMsg_HandleInputEvent( |
186 kTestRoutingID, &events[i], std::vector<const WebInputEvent*>(), | 251 kTestRoutingID, &events[i], std::vector<const WebInputEvent*>(), |
187 ui::LatencyInfo(), | 252 ui::LatencyInfo(), |
188 ShouldBlockEventStream(events[i]) | 253 ShouldBlockEventStream(events[i]) |
189 ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING | 254 ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING |
190 : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING)); | 255 : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING)); |
191 } | 256 } |
192 | 257 |
193 AddMessagesToFilter(messages); | 258 AddMessagesToFilter(messages); |
194 } | 259 } |
195 | 260 |
261 void RegisterRoute() { | |
262 input_event_queue_ = | |
263 new MainThreadEventQueue(this, main_task_runner_, &renderer_scheduler_); | |
264 filter_->RegisterRoutingID(kTestRoutingID, input_event_queue_); | |
265 } | |
266 | |
267 InputEventAckState HandleInputEvent( | |
268 const blink::WebCoalescedInputEvent& event, | |
269 const ui::LatencyInfo& latency, | |
270 InputEventDispatchType dispatch_type) override { | |
271 message_recorder_.AppendEvent(event, dispatch_type); | |
272 return INPUT_EVENT_ACK_STATE_NOT_CONSUMED; | |
273 } | |
274 | |
275 void SendInputEventAck(blink::WebInputEvent::Type type, | |
276 InputEventAckState ack_result, | |
277 uint32_t touch_event_id) override {} | |
278 | |
279 void SetNeedsMainFrame() override { event_recorder_->NeedsMainFrame(); } | |
280 | |
196 protected: | 281 protected: |
197 base::test::ScopedTaskEnvironment scoped_task_environment_; | 282 base::test::ScopedTaskEnvironment scoped_task_environment_; |
198 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; | 283 scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_; |
199 | 284 |
200 // Used to record IPCs sent by the filter to the RenderWidgetHost. | 285 // Used to record IPCs sent by the filter to the RenderWidgetHost. |
201 IPC::TestSink ipc_sink_; | 286 IPC::TestSink ipc_sink_; |
202 | 287 |
203 // Used to record IPCs forwarded by the filter to the main thread. | 288 // Used to record IPCs forwarded by the filter to the main thread. |
204 IPCMessageRecorder message_recorder_; | 289 IPCMessageRecorder message_recorder_; |
205 | 290 |
206 scoped_refptr<InputEventFilter> filter_; | 291 scoped_refptr<InputEventFilter> filter_; |
207 | 292 |
293 blink::scheduler::MockRendererScheduler renderer_scheduler_; | |
294 scoped_refptr<MainThreadEventQueue> input_event_queue_; | |
295 | |
208 // Used to record WebInputEvents delivered to the handler. | 296 // Used to record WebInputEvents delivered to the handler. |
209 std::unique_ptr<InputEventRecorder> event_recorder_; | 297 std::unique_ptr<InputEventRecorder> event_recorder_; |
210 | 298 |
211 base::TimeTicks frame_time_; | 299 base::TimeTicks frame_time_; |
212 }; | 300 }; |
213 | 301 |
214 TEST_F(InputEventFilterTest, Basic) { | 302 TEST_F(InputEventFilterTest, Basic) { |
215 WebMouseEvent kEvents[3] = {SyntheticWebMouseEventBuilder::Build( | 303 WebMouseEvent kEvents[3] = {SyntheticWebMouseEventBuilder::Build( |
216 WebMouseEvent::kMouseMove, 10, 10, 0), | 304 WebMouseEvent::kMouseMove, 10, 10, 0), |
217 SyntheticWebMouseEventBuilder::Build( | 305 SyntheticWebMouseEventBuilder::Build( |
218 WebMouseEvent::kMouseMove, 20, 20, 0), | 306 WebMouseEvent::kMouseMove, 20, 20, 0), |
219 SyntheticWebMouseEventBuilder::Build( | 307 SyntheticWebMouseEventBuilder::Build( |
220 WebMouseEvent::kMouseMove, 30, 30, 0)}; | 308 WebMouseEvent::kMouseMove, 30, 30, 0)}; |
221 | 309 |
222 AddEventsToFilter(kEvents, arraysize(kEvents)); | 310 AddEventsToFilter(kEvents, arraysize(kEvents)); |
223 EXPECT_EQ(0U, ipc_sink_.message_count()); | 311 EXPECT_EQ(0U, ipc_sink_.message_count()); |
224 EXPECT_EQ(0U, event_recorder_->record_count()); | 312 EXPECT_EQ(0U, event_recorder_->record_count()); |
225 EXPECT_EQ(0U, message_recorder_.message_count()); | 313 EXPECT_EQ(0U, message_recorder_.message_count()); |
226 | 314 |
227 filter_->RegisterRoutingID(kTestRoutingID); | 315 RegisterRoute(); |
228 | 316 |
229 AddEventsToFilter(kEvents, arraysize(kEvents)); | 317 AddEventsToFilter(kEvents, arraysize(kEvents)); |
230 ASSERT_EQ(arraysize(kEvents), ipc_sink_.message_count()); | 318 ASSERT_EQ(arraysize(kEvents), ipc_sink_.message_count()); |
231 ASSERT_EQ(arraysize(kEvents), event_recorder_->record_count()); | 319 ASSERT_EQ(arraysize(kEvents), event_recorder_->record_count()); |
232 EXPECT_EQ(0U, message_recorder_.message_count()); | 320 EXPECT_EQ(0U, message_recorder_.message_count()); |
233 | 321 |
234 for (size_t i = 0; i < arraysize(kEvents); ++i) { | 322 for (size_t i = 0; i < arraysize(kEvents); ++i) { |
235 const IPC::Message* message = ipc_sink_.GetMessageAt(i); | 323 const IPC::Message* message = ipc_sink_.GetMessageAt(i); |
236 EXPECT_EQ(kTestRoutingID, message->routing_id()); | 324 EXPECT_EQ(kTestRoutingID, message->routing_id()); |
237 EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type()); | 325 EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type()); |
(...skipping 14 matching lines...) Expand all Loading... | |
252 } | 340 } |
253 | 341 |
254 event_recorder_->set_send_to_widget(true); | 342 event_recorder_->set_send_to_widget(true); |
255 | 343 |
256 AddEventsToFilter(kEvents, arraysize(kEvents)); | 344 AddEventsToFilter(kEvents, arraysize(kEvents)); |
257 EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count()); | 345 EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count()); |
258 EXPECT_EQ(2 * arraysize(kEvents), event_recorder_->record_count()); | 346 EXPECT_EQ(2 * arraysize(kEvents), event_recorder_->record_count()); |
259 EXPECT_EQ(1u, message_recorder_.message_count()); | 347 EXPECT_EQ(1u, message_recorder_.message_count()); |
260 | 348 |
261 { | 349 { |
262 const IPC::Message& message = message_recorder_.message_at(0); | 350 const WebInputEvent& event = message_recorder_.event_at(0).event(); |
263 | 351 EXPECT_EQ(kEvents[2].size(), event.size()); |
264 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 352 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 } | 353 } |
272 | 354 |
273 // Now reset everything, and test that DidHandleInputEvent is called. | 355 // Now reset everything, and test that DidHandleInputEvent is called. |
274 | 356 |
275 ipc_sink_.ClearMessages(); | 357 ipc_sink_.ClearMessages(); |
276 event_recorder_->Clear(); | 358 event_recorder_->Clear(); |
277 message_recorder_.Clear(); | 359 message_recorder_.Clear(); |
278 | 360 |
279 event_recorder_->set_handle_events(true); | 361 event_recorder_->set_handle_events(true); |
280 | 362 |
(...skipping 12 matching lines...) Expand all Loading... | |
293 WebInputEvent::Type event_type = std::get<0>(params).type; | 375 WebInputEvent::Type event_type = std::get<0>(params).type; |
294 InputEventAckState ack_result = std::get<0>(params).state; | 376 InputEventAckState ack_result = std::get<0>(params).state; |
295 EXPECT_EQ(kEvents[i].GetType(), event_type); | 377 EXPECT_EQ(kEvents[i].GetType(), event_type); |
296 EXPECT_EQ(ack_result, INPUT_EVENT_ACK_STATE_CONSUMED); | 378 EXPECT_EQ(ack_result, INPUT_EVENT_ACK_STATE_CONSUMED); |
297 } | 379 } |
298 | 380 |
299 filter_->OnFilterRemoved(); | 381 filter_->OnFilterRemoved(); |
300 } | 382 } |
301 | 383 |
302 TEST_F(InputEventFilterTest, PreserveRelativeOrder) { | 384 TEST_F(InputEventFilterTest, PreserveRelativeOrder) { |
303 filter_->RegisterRoutingID(kTestRoutingID); | 385 RegisterRoute(); |
304 event_recorder_->set_send_to_widget(true); | 386 event_recorder_->set_send_to_widget(true); |
305 | 387 |
306 WebMouseEvent mouse_down = | 388 WebMouseEvent mouse_down = |
307 SyntheticWebMouseEventBuilder::Build(WebMouseEvent::kMouseDown); | 389 SyntheticWebMouseEventBuilder::Build(WebMouseEvent::kMouseDown); |
308 WebMouseEvent mouse_up = | 390 WebMouseEvent mouse_up = |
309 SyntheticWebMouseEventBuilder::Build(WebMouseEvent::kMouseUp); | 391 SyntheticWebMouseEventBuilder::Build(WebMouseEvent::kMouseUp); |
310 | 392 |
311 std::vector<IPC::Message> messages; | 393 std::vector<IPC::Message> messages; |
312 messages.push_back(InputMsg_HandleInputEvent( | 394 messages.push_back(InputMsg_HandleInputEvent( |
313 kTestRoutingID, &mouse_down, std::vector<const WebInputEvent*>(), | 395 kTestRoutingID, &mouse_down, std::vector<const WebInputEvent*>(), |
(...skipping 30 matching lines...) Expand all Loading... | |
344 kTestRoutingID, &mouse_up, std::vector<const WebInputEvent*>(), | 426 kTestRoutingID, &mouse_up, std::vector<const WebInputEvent*>(), |
345 ui::LatencyInfo(), | 427 ui::LatencyInfo(), |
346 ShouldBlockEventStream(mouse_up) | 428 ShouldBlockEventStream(mouse_up) |
347 ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING | 429 ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING |
348 : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING)); | 430 : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING)); |
349 AddMessagesToFilter(messages); | 431 AddMessagesToFilter(messages); |
350 | 432 |
351 // We should have sent all messages back to the main thread and preserved | 433 // We should have sent all messages back to the main thread and preserved |
352 // their relative order. | 434 // their relative order. |
353 ASSERT_EQ(message_recorder_.message_count(), messages.size()); | 435 ASSERT_EQ(message_recorder_.message_count(), messages.size()); |
354 for (size_t i = 0; i < messages.size(); ++i) { | 436 EXPECT_EQ(WebMouseEvent::kMouseDown, |
355 EXPECT_EQ(message_recorder_.message_at(i).type(), messages[i].type()) << i; | 437 message_recorder_.event_at(0).event().GetType()); |
438 for (size_t i = 1; i < messages.size() - 1; ++i) { | |
439 EXPECT_EQ(message_recorder_.message_at(i).message().type(), | |
440 messages[i].type()) | |
441 << i; | |
356 } | 442 } |
443 EXPECT_EQ(WebMouseEvent::kMouseUp, | |
444 message_recorder_.event_at(messages.size() - 1).event().GetType()); | |
357 } | 445 } |
358 | 446 |
359 TEST_F(InputEventFilterTest, NonBlockingWheel) { | 447 TEST_F(InputEventFilterTest, NonBlockingWheel) { |
360 WebMouseWheelEvent kEvents[4] = { | 448 WebMouseWheelEvent kEvents[4] = { |
361 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 1, false), | 449 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 1, false), |
362 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), | 450 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), |
363 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), | 451 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), |
364 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), | 452 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), |
365 }; | 453 }; |
366 | 454 |
367 filter_->RegisterRoutingID(kTestRoutingID); | 455 RegisterRoute(); |
368 event_recorder_->set_send_to_widget(true); | 456 event_recorder_->set_send_to_widget(true); |
369 event_recorder_->set_passive(true); | 457 event_recorder_->set_passive(true); |
370 | 458 |
371 AddEventsToFilter(kEvents, arraysize(kEvents)); | 459 AddEventsToFilter(kEvents, arraysize(kEvents)); |
372 EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count()); | 460 EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count()); |
373 ASSERT_EQ(4u, ipc_sink_.message_count()); | 461 ASSERT_EQ(4u, ipc_sink_.message_count()); |
374 | 462 |
375 // All events are handled, one is coalesced. | 463 // All events are handled, one is coalesced. |
376 EXPECT_EQ(3u, message_recorder_.message_count()); | 464 EXPECT_EQ(3u, message_recorder_.message_count()); |
377 | 465 |
378 // First two messages should be identical. | 466 // First two messages should be identical. |
379 for (size_t i = 0; i < 2; ++i) { | 467 for (size_t i = 0; i < 2; ++i) { |
380 const IPC::Message& message = message_recorder_.message_at(i); | 468 const ReceivedEvent& message = message_recorder_.event_at(i); |
381 | 469 |
382 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 470 const WebInputEvent& event = message.event(); |
383 InputMsg_HandleInputEvent::Param params; | 471 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 | 472 |
388 EXPECT_EQ(kEvents[i].size(), event->size()); | 473 EXPECT_EQ(kEvents[i].size(), event.size()); |
389 kEvents[i].dispatch_type = | 474 kEvents[i].dispatch_type = |
390 WebInputEvent::DispatchType::kListenersNonBlockingPassive; | 475 WebInputEvent::DispatchType::kListenersNonBlockingPassive; |
391 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size()) == 0); | 476 EXPECT_TRUE(memcmp(&kEvents[i], &event, event.size()) == 0); |
392 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, | 477 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
393 dispatch_type); | 478 dispatch_type); |
394 } | 479 } |
395 | 480 |
396 // Third message is coalesced. | 481 // Third message is coalesced. |
397 { | 482 { |
398 const IPC::Message& message = message_recorder_.message_at(2); | 483 const ReceivedEvent& message = message_recorder_.event_at(2); |
399 | 484 |
400 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 485 const WebMouseWheelEvent& event = |
401 InputMsg_HandleInputEvent::Param params; | 486 static_cast<const WebMouseWheelEvent&>(message.event()); |
402 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 487 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 | 488 |
407 kEvents[2].dispatch_type = | 489 kEvents[2].dispatch_type = |
408 WebInputEvent::DispatchType::kListenersNonBlockingPassive; | 490 WebInputEvent::DispatchType::kListenersNonBlockingPassive; |
409 EXPECT_EQ(kEvents[2].size(), event->size()); | 491 EXPECT_EQ(kEvents[2].size(), event.size()); |
410 EXPECT_EQ(kEvents[2].delta_x + kEvents[3].delta_x, event->delta_x); | 492 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); | 493 EXPECT_EQ(kEvents[2].delta_y + kEvents[3].delta_y, event.delta_y); |
412 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, | 494 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
413 dispatch_type); | 495 dispatch_type); |
414 } | 496 } |
415 } | 497 } |
416 | 498 |
417 TEST_F(InputEventFilterTest, NonBlockingTouch) { | 499 TEST_F(InputEventFilterTest, NonBlockingTouch) { |
418 SyntheticWebTouchEvent kEvents[4]; | 500 SyntheticWebTouchEvent kEvents[4]; |
419 kEvents[0].PressPoint(10, 10); | 501 kEvents[0].PressPoint(10, 10); |
420 kEvents[1].PressPoint(10, 10); | 502 kEvents[1].PressPoint(10, 10); |
421 kEvents[1].SetModifiers(1); | 503 kEvents[1].SetModifiers(1); |
422 kEvents[1].MovePoint(0, 20, 20); | 504 kEvents[1].MovePoint(0, 20, 20); |
423 kEvents[2].PressPoint(10, 10); | 505 kEvents[2].PressPoint(10, 10); |
424 kEvents[2].MovePoint(0, 30, 30); | 506 kEvents[2].MovePoint(0, 30, 30); |
425 kEvents[3].PressPoint(10, 10); | 507 kEvents[3].PressPoint(10, 10); |
426 kEvents[3].MovePoint(0, 35, 35); | 508 kEvents[3].MovePoint(0, 35, 35); |
427 | 509 |
428 filter_->RegisterRoutingID(kTestRoutingID); | 510 RegisterRoute(); |
429 event_recorder_->set_send_to_widget(true); | 511 event_recorder_->set_send_to_widget(true); |
430 event_recorder_->set_passive(true); | 512 event_recorder_->set_passive(true); |
431 | 513 |
432 AddEventsToFilter(kEvents, arraysize(kEvents)); | 514 AddEventsToFilter(kEvents, arraysize(kEvents)); |
433 EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count()); | 515 EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count()); |
434 ASSERT_EQ(4u, ipc_sink_.message_count()); | 516 ASSERT_EQ(4u, ipc_sink_.message_count()); |
435 | 517 |
436 // All events are handled and one set was coalesced. | 518 // All events are handled and one set was coalesced. |
437 EXPECT_EQ(3u, message_recorder_.message_count()); | 519 EXPECT_EQ(3u, message_recorder_.message_count()); |
438 | 520 |
439 // First two messages should be identical. | 521 // First two messages should be identical. |
440 for (size_t i = 0; i < 2; ++i) { | 522 for (size_t i = 0; i < 2; ++i) { |
441 const IPC::Message& message = message_recorder_.message_at(i); | 523 const ReceivedEvent& message = message_recorder_.event_at(i); |
442 | 524 |
443 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 525 const WebInputEvent& event = message.event(); |
444 InputMsg_HandleInputEvent::Param params; | 526 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 | 527 |
449 EXPECT_EQ(kEvents[i].size(), event->size()); | 528 EXPECT_EQ(kEvents[i].size(), event.size()); |
450 kEvents[i].dispatch_type = | 529 kEvents[i].dispatch_type = |
451 WebInputEvent::DispatchType::kListenersNonBlockingPassive; | 530 WebInputEvent::DispatchType::kListenersNonBlockingPassive; |
452 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size()) == 0); | 531 EXPECT_TRUE(memcmp(&kEvents[i], &event, event.size()) == 0); |
453 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, | 532 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
454 dispatch_type); | 533 dispatch_type); |
455 } | 534 } |
456 | 535 |
457 // Third message is coalesced. | 536 // Third message is coalesced. |
458 { | 537 { |
459 const IPC::Message& message = message_recorder_.message_at(2); | 538 const ReceivedEvent& message = message_recorder_.event_at(2); |
460 | 539 |
461 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 540 const WebTouchEvent& event = |
462 InputMsg_HandleInputEvent::Param params; | 541 static_cast<const WebTouchEvent&>(message.event()); |
463 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 542 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 | 543 |
468 EXPECT_EQ(kEvents[3].size(), event->size()); | 544 EXPECT_EQ(kEvents[3].size(), event.size()); |
469 EXPECT_EQ(1u, kEvents[3].touches_length); | 545 EXPECT_EQ(1u, kEvents[3].touches_length); |
470 EXPECT_EQ(kEvents[3].touches[0].position.x, event->touches[0].position.x); | 546 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); | 547 EXPECT_EQ(kEvents[3].touches[0].position.y, event.touches[0].position.y); |
472 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, | 548 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
473 dispatch_type); | 549 dispatch_type); |
474 } | 550 } |
475 } | 551 } |
476 | 552 |
477 TEST_F(InputEventFilterTest, IntermingledNonBlockingTouch) { | 553 TEST_F(InputEventFilterTest, IntermingledNonBlockingTouch) { |
478 SyntheticWebTouchEvent kEvents[2]; | 554 SyntheticWebTouchEvent kEvents[2]; |
479 kEvents[0].PressPoint(10, 10); | 555 kEvents[0].PressPoint(10, 10); |
480 kEvents[1].PressPoint(10, 10); | 556 kEvents[1].PressPoint(10, 10); |
481 kEvents[1].ReleasePoint(0); | 557 kEvents[1].ReleasePoint(0); |
482 SyntheticWebTouchEvent kBlockingEvents[1]; | 558 SyntheticWebTouchEvent kBlockingEvents[1]; |
483 kBlockingEvents[0].PressPoint(10, 10); | 559 kBlockingEvents[0].PressPoint(10, 10); |
484 | 560 |
485 filter_->RegisterRoutingID(kTestRoutingID); | 561 RegisterRoute(); |
486 event_recorder_->set_send_to_widget(true); | 562 event_recorder_->set_send_to_widget(true); |
487 event_recorder_->set_passive(true); | 563 event_recorder_->set_passive(true); |
488 AddEventsToFilter(kEvents, arraysize(kEvents)); | 564 AddEventsToFilter(kEvents, arraysize(kEvents)); |
489 EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count()); | 565 EXPECT_EQ(arraysize(kEvents), event_recorder_->record_count()); |
490 | 566 |
491 event_recorder_->set_passive(false); | 567 event_recorder_->set_passive(false); |
492 AddEventsToFilter(kBlockingEvents, arraysize(kBlockingEvents)); | 568 AddEventsToFilter(kBlockingEvents, arraysize(kBlockingEvents)); |
493 EXPECT_EQ(arraysize(kEvents) + arraysize(kBlockingEvents), | 569 EXPECT_EQ(arraysize(kEvents) + arraysize(kBlockingEvents), |
494 event_recorder_->record_count()); | 570 event_recorder_->record_count()); |
495 ASSERT_EQ(3u, event_recorder_->record_count()); | 571 ASSERT_EQ(3u, event_recorder_->record_count()); |
496 EXPECT_EQ(3u, message_recorder_.message_count()); | 572 EXPECT_EQ(3u, message_recorder_.message_count()); |
497 | 573 |
498 { | 574 { |
499 const IPC::Message& message = message_recorder_.message_at(0); | 575 const ReceivedEvent& message = message_recorder_.event_at(0); |
500 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 576 const WebInputEvent& event = message.event(); |
501 InputMsg_HandleInputEvent::Param params; | 577 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 | 578 |
506 EXPECT_EQ(kEvents[0].size(), event->size()); | 579 EXPECT_EQ(kEvents[0].size(), event.size()); |
507 kEvents[0].dispatch_type = | 580 kEvents[0].dispatch_type = |
508 WebInputEvent::DispatchType::kListenersNonBlockingPassive; | 581 WebInputEvent::DispatchType::kListenersNonBlockingPassive; |
509 EXPECT_TRUE(memcmp(&kEvents[0], event, event->size()) == 0); | 582 EXPECT_TRUE(memcmp(&kEvents[0], &event, event.size()) == 0); |
510 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, | 583 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
511 dispatch_type); | 584 dispatch_type); |
512 } | 585 } |
513 | 586 |
514 { | 587 { |
515 const IPC::Message& message = message_recorder_.message_at(1); | 588 const ReceivedEvent& message = message_recorder_.event_at(1); |
516 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 589 const WebInputEvent& event = message.event(); |
517 InputMsg_HandleInputEvent::Param params; | 590 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 | 591 |
522 EXPECT_EQ(kEvents[1].size(), event->size()); | 592 EXPECT_EQ(kEvents[1].size(), event.size()); |
523 kEvents[1].dispatch_type = | 593 kEvents[1].dispatch_type = |
524 WebInputEvent::DispatchType::kListenersNonBlockingPassive; | 594 WebInputEvent::DispatchType::kListenersNonBlockingPassive; |
525 EXPECT_TRUE(memcmp(&kEvents[1], event, event->size()) == 0); | 595 EXPECT_TRUE(memcmp(&kEvents[1], &event, event.size()) == 0); |
526 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, | 596 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
527 dispatch_type); | 597 dispatch_type); |
528 } | 598 } |
529 | 599 |
530 { | 600 { |
531 const IPC::Message& message = message_recorder_.message_at(2); | 601 const ReceivedEvent& message = message_recorder_.event_at(2); |
532 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 602 const WebInputEvent& event = message.event(); |
533 InputMsg_HandleInputEvent::Param params; | 603 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 | 604 |
538 EXPECT_EQ(kBlockingEvents[0].size(), event->size()); | 605 EXPECT_EQ(kBlockingEvents[0].size(), event.size()); |
539 EXPECT_TRUE(memcmp(&kBlockingEvents[0], event, event->size()) == 0); | 606 EXPECT_TRUE(memcmp(&kBlockingEvents[0], &event, event.size()) == 0); |
540 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_BLOCKING, dispatch_type); | 607 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_BLOCKING, dispatch_type); |
541 } | 608 } |
542 } | 609 } |
543 | 610 |
544 } // namespace content | 611 } // namespace content |
OLD | NEW |