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 "content/renderer/input/input_handler_manager.h" | 5 #include "content/renderer/input/input_handler_manager.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/location.h" | 10 #include "base/location.h" |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
62 client_->SetInputHandlerManager(this); | 62 client_->SetInputHandlerManager(this); |
63 } | 63 } |
64 | 64 |
65 InputHandlerManager::~InputHandlerManager() { | 65 InputHandlerManager::~InputHandlerManager() { |
66 client_->SetInputHandlerManager(nullptr); | 66 client_->SetInputHandlerManager(nullptr); |
67 } | 67 } |
68 | 68 |
69 void InputHandlerManager::AddInputHandler( | 69 void InputHandlerManager::AddInputHandler( |
70 int routing_id, | 70 int routing_id, |
71 const base::WeakPtr<cc::InputHandler>& input_handler, | 71 const base::WeakPtr<cc::InputHandler>& input_handler, |
| 72 const scoped_refptr<MainThreadEventQueue>& input_event_queue, |
72 const base::WeakPtr<RenderWidget>& render_widget, | 73 const base::WeakPtr<RenderWidget>& render_widget, |
73 bool enable_smooth_scrolling) { | 74 bool enable_smooth_scrolling) { |
74 if (task_runner_->BelongsToCurrentThread()) { | 75 if (task_runner_->BelongsToCurrentThread()) { |
75 AddInputHandlerOnCompositorThread( | 76 AddInputHandlerOnCompositorThread( |
76 routing_id, base::ThreadTaskRunnerHandle::Get(), input_handler, | 77 routing_id, base::ThreadTaskRunnerHandle::Get(), input_handler, |
77 render_widget, enable_smooth_scrolling); | 78 input_event_queue, render_widget, enable_smooth_scrolling); |
78 } else { | 79 } else { |
79 task_runner_->PostTask( | 80 task_runner_->PostTask( |
80 FROM_HERE, | 81 FROM_HERE, |
81 base::Bind(&InputHandlerManager::AddInputHandlerOnCompositorThread, | 82 base::Bind(&InputHandlerManager::AddInputHandlerOnCompositorThread, |
82 base::Unretained(this), routing_id, | 83 base::Unretained(this), routing_id, |
83 base::ThreadTaskRunnerHandle::Get(), input_handler, | 84 base::ThreadTaskRunnerHandle::Get(), input_handler, |
84 render_widget, enable_smooth_scrolling)); | 85 input_event_queue, render_widget, enable_smooth_scrolling)); |
85 } | 86 } |
86 } | 87 } |
87 | 88 |
88 void InputHandlerManager::AddInputHandlerOnCompositorThread( | 89 void InputHandlerManager::AddInputHandlerOnCompositorThread( |
89 int routing_id, | 90 int routing_id, |
90 const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner, | 91 const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner, |
91 const base::WeakPtr<cc::InputHandler>& input_handler, | 92 const base::WeakPtr<cc::InputHandler>& input_handler, |
| 93 const scoped_refptr<MainThreadEventQueue>& input_event_queue, |
92 const base::WeakPtr<RenderWidget>& render_widget, | 94 const base::WeakPtr<RenderWidget>& render_widget, |
93 bool enable_smooth_scrolling) { | 95 bool enable_smooth_scrolling) { |
94 DCHECK(task_runner_->BelongsToCurrentThread()); | 96 DCHECK(task_runner_->BelongsToCurrentThread()); |
95 | 97 |
96 // The handler could be gone by this point if the compositor has shut down. | 98 // The handler could be gone by this point if the compositor has shut down. |
97 if (!input_handler) | 99 if (!input_handler) |
98 return; | 100 return; |
99 | 101 |
100 // The same handler may be registered for a route multiple times. | 102 // The same handler may be registered for a route multiple times. |
101 if (input_handlers_.count(routing_id) != 0) | 103 if (input_handlers_.count(routing_id) != 0) |
102 return; | 104 return; |
103 | 105 |
104 TRACE_EVENT1("input", | 106 TRACE_EVENT1("input", |
105 "InputHandlerManager::AddInputHandlerOnCompositorThread", | 107 "InputHandlerManager::AddInputHandlerOnCompositorThread", |
106 "result", "AddingRoute"); | 108 "result", "AddingRoute"); |
107 std::unique_ptr<InputHandlerWrapper> wrapper( | 109 std::unique_ptr<InputHandlerWrapper> wrapper( |
108 new InputHandlerWrapper(this, routing_id, main_task_runner, input_handler, | 110 new InputHandlerWrapper(this, routing_id, main_task_runner, input_handler, |
109 render_widget, enable_smooth_scrolling)); | 111 render_widget, enable_smooth_scrolling)); |
110 client_->RegisterRoutingID(routing_id); | 112 client_->RegisterRoutingID(routing_id, input_event_queue); |
111 if (synchronous_handler_proxy_client_) { | 113 if (synchronous_handler_proxy_client_) { |
112 synchronous_handler_proxy_client_->DidAddSynchronousHandlerProxy( | 114 synchronous_handler_proxy_client_->DidAddSynchronousHandlerProxy( |
113 routing_id, wrapper->input_handler_proxy()); | 115 routing_id, wrapper->input_handler_proxy()); |
114 } | 116 } |
115 input_handlers_[routing_id] = std::move(wrapper); | 117 input_handlers_[routing_id] = std::move(wrapper); |
116 } | 118 } |
117 | 119 |
118 void InputHandlerManager::RemoveInputHandler(int routing_id) { | 120 void InputHandlerManager::RemoveInputHandler(int routing_id) { |
119 DCHECK(task_runner_->BelongsToCurrentThread()); | 121 DCHECK(task_runner_->BelongsToCurrentThread()); |
120 DCHECK(input_handlers_.find(routing_id) != input_handlers_.end()); | 122 DCHECK(input_handlers_.find(routing_id) != input_handlers_.end()); |
(...skipping 26 matching lines...) Expand all Loading... |
147 | 149 |
148 void InputHandlerManager:: | 150 void InputHandlerManager:: |
149 RegisterAssociatedRenderFrameRoutingIDOnCompositorThread( | 151 RegisterAssociatedRenderFrameRoutingIDOnCompositorThread( |
150 int render_frame_routing_id, | 152 int render_frame_routing_id, |
151 int render_view_routing_id) { | 153 int render_view_routing_id) { |
152 DCHECK(task_runner_->BelongsToCurrentThread()); | 154 DCHECK(task_runner_->BelongsToCurrentThread()); |
153 client_->RegisterAssociatedRenderFrameRoutingID(render_frame_routing_id, | 155 client_->RegisterAssociatedRenderFrameRoutingID(render_frame_routing_id, |
154 render_view_routing_id); | 156 render_view_routing_id); |
155 } | 157 } |
156 | 158 |
157 void InputHandlerManager::RegisterRoutingID(int routing_id) { | |
158 if (task_runner_->BelongsToCurrentThread()) { | |
159 RegisterRoutingIDOnCompositorThread(routing_id); | |
160 } else { | |
161 task_runner_->PostTask( | |
162 FROM_HERE, | |
163 base::Bind(&InputHandlerManager::RegisterRoutingIDOnCompositorThread, | |
164 base::Unretained(this), routing_id)); | |
165 } | |
166 } | |
167 | |
168 void InputHandlerManager::RegisterRoutingIDOnCompositorThread(int routing_id) { | |
169 DCHECK(task_runner_->BelongsToCurrentThread()); | |
170 client_->RegisterRoutingID(routing_id); | |
171 } | |
172 | |
173 void InputHandlerManager::UnregisterRoutingID(int routing_id) { | 159 void InputHandlerManager::UnregisterRoutingID(int routing_id) { |
174 if (task_runner_->BelongsToCurrentThread()) { | 160 if (task_runner_->BelongsToCurrentThread()) { |
175 UnregisterRoutingIDOnCompositorThread(routing_id); | 161 UnregisterRoutingIDOnCompositorThread(routing_id); |
176 } else { | 162 } else { |
177 task_runner_->PostTask( | 163 task_runner_->PostTask( |
178 FROM_HERE, | 164 FROM_HERE, |
179 base::Bind(&InputHandlerManager::UnregisterRoutingIDOnCompositorThread, | 165 base::Bind(&InputHandlerManager::UnregisterRoutingIDOnCompositorThread, |
180 base::Unretained(this), routing_id)); | 166 base::Unretained(this), routing_id)); |
181 } | 167 } |
182 } | 168 } |
(...skipping 23 matching lines...) Expand all Loading... |
206 auto it = input_handlers_.find(routing_id); | 192 auto it = input_handlers_.find(routing_id); |
207 if (it == input_handlers_.end()) | 193 if (it == input_handlers_.end()) |
208 return; | 194 return; |
209 | 195 |
210 InputHandlerProxy* proxy = it->second->input_handler_proxy(); | 196 InputHandlerProxy* proxy = it->second->input_handler_proxy(); |
211 DCHECK(proxy->scroll_elasticity_controller()); | 197 DCHECK(proxy->scroll_elasticity_controller()); |
212 proxy->scroll_elasticity_controller()->ObserveGestureEventAndResult( | 198 proxy->scroll_elasticity_controller()->ObserveGestureEventAndResult( |
213 gesture_event, scroll_result); | 199 gesture_event, scroll_result); |
214 } | 200 } |
215 | 201 |
216 void InputHandlerManager::NotifyInputEventHandledOnMainThread( | |
217 int routing_id, | |
218 blink::WebInputEvent::Type type, | |
219 blink::WebInputEventResult result, | |
220 InputEventAckState ack_result) { | |
221 client_->NotifyInputEventHandled(routing_id, type, result, ack_result); | |
222 } | |
223 | |
224 void InputHandlerManager::ProcessRafAlignedInputOnMainThread( | |
225 int routing_id, | |
226 base::TimeTicks frame_time) { | |
227 client_->ProcessRafAlignedInput(routing_id, frame_time); | |
228 } | |
229 | |
230 void InputHandlerManager::HandleInputEvent( | 202 void InputHandlerManager::HandleInputEvent( |
231 int routing_id, | 203 int routing_id, |
232 ui::WebScopedInputEvent input_event, | 204 ui::WebScopedInputEvent input_event, |
233 const ui::LatencyInfo& latency_info, | 205 const ui::LatencyInfo& latency_info, |
234 const InputEventAckStateCallback& callback) { | 206 const InputEventAckStateCallback& callback) { |
235 DCHECK(task_runner_->BelongsToCurrentThread()); | 207 DCHECK(task_runner_->BelongsToCurrentThread()); |
236 TRACE_EVENT1("input,benchmark,rail", "InputHandlerManager::HandleInputEvent", | 208 TRACE_EVENT1("input,benchmark,rail", "InputHandlerManager::HandleInputEvent", |
237 "type", WebInputEvent::GetName(input_event->GetType())); | 209 "type", WebInputEvent::GetName(input_event->GetType())); |
238 | 210 |
239 auto it = input_handlers_.find(routing_id); | 211 auto it = input_handlers_.find(routing_id); |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
294 } | 266 } |
295 | 267 |
296 void InputHandlerManager::DidStopFlinging(int routing_id) { | 268 void InputHandlerManager::DidStopFlinging(int routing_id) { |
297 client_->DidStopFlinging(routing_id); | 269 client_->DidStopFlinging(routing_id); |
298 } | 270 } |
299 | 271 |
300 void InputHandlerManager::DidAnimateForInput() { | 272 void InputHandlerManager::DidAnimateForInput() { |
301 renderer_scheduler_->DidAnimateForInputOnCompositorThread(); | 273 renderer_scheduler_->DidAnimateForInputOnCompositorThread(); |
302 } | 274 } |
303 | 275 |
304 void InputHandlerManager::NeedsMainFrame(int routing_id) { | |
305 DCHECK(task_runner_->BelongsToCurrentThread()); | |
306 auto it = input_handlers_.find(routing_id); | |
307 if (it == input_handlers_.end()) | |
308 return; | |
309 it->second->NeedsMainFrame(); | |
310 } | |
311 | |
312 void InputHandlerManager::DispatchNonBlockingEventToMainThread( | 276 void InputHandlerManager::DispatchNonBlockingEventToMainThread( |
313 int routing_id, | 277 int routing_id, |
314 ui::WebScopedInputEvent event, | 278 ui::WebScopedInputEvent event, |
315 const ui::LatencyInfo& latency_info) { | 279 const ui::LatencyInfo& latency_info) { |
316 DCHECK(task_runner_->BelongsToCurrentThread()); | 280 DCHECK(task_runner_->BelongsToCurrentThread()); |
317 client_->DispatchNonBlockingEventToMainThread(routing_id, std::move(event), | 281 client_->DispatchNonBlockingEventToMainThread(routing_id, std::move(event), |
318 latency_info); | 282 latency_info); |
319 } | 283 } |
320 | 284 |
321 } // namespace content | 285 } // namespace content |
OLD | NEW |