OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "content/renderer/input/frame_input_handler_impl.h" | |
6 | |
7 #include <utility> | |
8 | |
9 #include "base/bind.h" | |
10 #include "base/debug/stack_trace.h" | |
11 #include "base/logging.h" | |
12 #include "content/renderer/ime_event_guard.h" | |
13 #include "content/renderer/render_thread_impl.h" | |
14 #include "content/renderer/render_view_impl.h" | |
15 #include "content/renderer/render_widget.h" | |
16 #include "third_party/WebKit/public/web/WebLocalFrame.h" | |
17 | |
18 namespace content { | |
19 | |
20 FrameInputHandlerImpl::FrameInputHandlerImpl( | |
21 base::WeakPtr<RenderFrameImpl> render_frame, | |
22 mojom::FrameInputHandlerRequest request) | |
23 : binding_(this), | |
24 render_frame_(render_frame), | |
25 input_event_queue_(render_frame->GetRenderWidget()->GetInputEventQueue()), | |
26 main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()), | |
27 weak_ptr_factory_(this) | |
28 | |
29 { | |
30 weak_this_ = weak_ptr_factory_.GetWeakPtr(); | |
31 // If we have created an input event queue move the mojo request over to the | |
32 // compositor thread. | |
33 if (input_event_queue_) { | |
34 // Mojo channel bound on compositor thread. | |
35 RenderThreadImpl::current()->compositor_task_runner()->PostTask( | |
36 FROM_HERE, base::BindOnce(&FrameInputHandlerImpl::BindNow, | |
37 base::Unretained(this), std::move(request))); | |
38 } else { | |
39 // Mojo channel bound on main thread. | |
40 BindNow(std::move(request)); | |
41 } | |
42 } | |
43 | |
44 FrameInputHandlerImpl::~FrameInputHandlerImpl() {} | |
45 | |
46 // static | |
47 void FrameInputHandlerImpl::CreateMojoService( | |
48 base::WeakPtr<RenderFrameImpl> render_frame, | |
49 const service_manager::BindSourceInfo& source_info, | |
50 mojom::FrameInputHandlerRequest request) { | |
51 DCHECK(render_frame); | |
52 | |
53 // Owns itself. Will be deleted when message pipe is destroyed. | |
54 new FrameInputHandlerImpl(render_frame, std::move(request)); | |
55 } | |
56 | |
57 void FrameInputHandlerImpl::RunOnMainThread(const base::Closure& closure) { | |
58 if (input_event_queue_) { | |
59 input_event_queue_->QueueClosure(closure); | |
60 } else { | |
61 closure.Run(); | |
62 } | |
63 } | |
64 | |
65 void FrameInputHandlerImpl::SetCompositionFromExistingText( | |
66 int32_t start, | |
67 int32_t end, | |
68 const std::vector<ui::CompositionUnderline>& ui_underlines) { | |
69 if (!main_thread_task_runner_->BelongsToCurrentThread()) { | |
70 RunOnMainThread( | |
71 base::Bind(&FrameInputHandlerImpl::SetCompositionFromExistingText, | |
72 weak_this_, start, end, ui_underlines)); | |
73 return; | |
74 } | |
75 | |
76 if (!render_frame_) | |
77 return; | |
78 | |
79 ImeEventGuard guard(render_frame_->GetRenderWidget()); | |
80 std::vector<blink::WebCompositionUnderline> underlines; | |
81 for (const auto& underline : ui_underlines) { | |
82 blink::WebCompositionUnderline blink_underline( | |
83 underline.start_offset, underline.end_offset, underline.color, | |
84 underline.thick, underline.background_color); | |
85 underlines.push_back(blink_underline); | |
86 } | |
87 | |
88 render_frame_->GetWebFrame()->SetCompositionFromExistingText(start, end, | |
89 underlines); | |
90 } | |
91 | |
92 void FrameInputHandlerImpl::ExtendSelectionAndDelete(int32_t before, | |
93 int32_t after) { | |
94 if (!main_thread_task_runner_->BelongsToCurrentThread()) { | |
95 RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExtendSelectionAndDelete, | |
96 weak_this_, before, after)); | |
97 return; | |
98 } | |
99 if (!render_frame_) | |
100 return; | |
101 render_frame_->GetWebFrame()->ExtendSelectionAndDelete(before, after); | |
102 } | |
103 | |
104 void FrameInputHandlerImpl::DeleteSurroundingText(int32_t before, | |
105 int32_t after) { | |
106 if (!main_thread_task_runner_->BelongsToCurrentThread()) { | |
107 RunOnMainThread(base::Bind(&FrameInputHandlerImpl::DeleteSurroundingText, | |
108 weak_this_, before, after)); | |
109 return; | |
110 } | |
111 if (!render_frame_) | |
112 return; | |
113 render_frame_->GetWebFrame()->DeleteSurroundingText(before, after); | |
114 } | |
115 | |
116 void FrameInputHandlerImpl::DeleteSurroundingTextInCodePoints(int32_t before, | |
117 int32_t after) { | |
118 if (!main_thread_task_runner_->BelongsToCurrentThread()) { | |
119 RunOnMainThread( | |
120 base::Bind(&FrameInputHandlerImpl::DeleteSurroundingTextInCodePoints, | |
121 weak_this_, before, after)); | |
122 return; | |
123 } | |
124 if (!render_frame_) | |
125 return; | |
126 render_frame_->GetWebFrame()->DeleteSurroundingTextInCodePoints(before, | |
127 after); | |
128 } | |
129 | |
130 void FrameInputHandlerImpl::SetEditableSelectionOffsets(int32_t start, | |
131 int32_t end) { | |
132 if (!main_thread_task_runner_->BelongsToCurrentThread()) { | |
133 RunOnMainThread( | |
134 base::Bind(&FrameInputHandlerImpl::SetEditableSelectionOffsets, | |
135 weak_this_, start, end)); | |
136 return; | |
137 } | |
138 if (!render_frame_) | |
139 return; | |
140 render_frame_->GetWebFrame()->SetEditableSelectionOffsets(start, end); | |
141 } | |
142 | |
143 void FrameInputHandlerImpl::ExecuteEditCommand( | |
144 const std::string& command, | |
145 const base::Optional<base::string16>& value) { | |
146 if (!main_thread_task_runner_->BelongsToCurrentThread()) { | |
147 RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteEditCommand, | |
148 weak_this_, command, value)); | |
149 return; | |
150 } | |
151 if (!render_frame_) | |
152 return; | |
153 if (value) { | |
154 render_frame_->GetWebFrame()->ExecuteCommand( | |
155 blink::WebString::FromUTF8(command), | |
156 blink::WebString::FromUTF16(value.value())); | |
157 return; | |
158 } | |
159 | |
160 render_frame_->GetWebFrame()->ExecuteCommand( | |
161 blink::WebString::FromUTF8(command)); | |
162 } | |
163 | |
164 void FrameInputHandlerImpl::Undo() { | |
165 RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread, | |
166 weak_this_, "Undo", UpdateState::kNone)); | |
167 } | |
168 | |
169 void FrameInputHandlerImpl::Redo() { | |
170 RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread, | |
171 weak_this_, "Redo", UpdateState::kNone)); | |
172 } | |
173 | |
174 void FrameInputHandlerImpl::Cut() { | |
175 RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread, | |
176 weak_this_, "Cut", | |
177 UpdateState::kIsSelectingRange)); | |
178 } | |
179 | |
180 void FrameInputHandlerImpl::Copy() { | |
181 RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread, | |
182 weak_this_, "Copy", | |
183 UpdateState::kIsSelectingRange)); | |
184 } | |
185 | |
186 void FrameInputHandlerImpl::CopyToFindPboard() { | |
187 #if defined(OS_MACOSX) | |
188 if (!main_thread_task_runner_->BelongsToCurrentThread()) { | |
189 RunOnMainThread( | |
190 base::Bind(&FrameInputHandlerImpl::CopyToFindPboard, weak_this_)); | |
191 return; | |
192 } | |
193 if (!render_frame_) | |
194 return; | |
195 render_frame_->OnCopyToFindPboard(); | |
196 #endif | |
197 } | |
198 | |
199 void FrameInputHandlerImpl::Paste() { | |
200 RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread, | |
201 weak_this_, "Paste", UpdateState::kIsPasting)); | |
202 } | |
203 | |
204 void FrameInputHandlerImpl::PasteAndMatchStyle() { | |
205 RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread, | |
206 weak_this_, "PasteAndMatchStyle", | |
207 UpdateState::kIsPasting)); | |
208 } | |
209 | |
210 void FrameInputHandlerImpl::Replace(const base::string16& word) { | |
211 if (!main_thread_task_runner_->BelongsToCurrentThread()) { | |
212 RunOnMainThread( | |
213 base::Bind(&FrameInputHandlerImpl::Replace, weak_this_, word)); | |
214 return; | |
215 } | |
216 if (!render_frame_) | |
217 return; | |
218 blink::WebLocalFrame* frame = render_frame_->GetWebFrame(); | |
219 if (frame->HasSelection()) | |
220 frame->SelectWordAroundCaret(); | |
221 frame->ReplaceSelection(blink::WebString::FromUTF16(word)); | |
222 render_frame_->SyncSelectionIfRequired(); | |
223 } | |
224 | |
225 void FrameInputHandlerImpl::ReplaceMisspelling(const base::string16& word) { | |
226 if (!main_thread_task_runner_->BelongsToCurrentThread()) { | |
227 RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ReplaceMisspelling, | |
228 weak_this_, word)); | |
229 return; | |
230 } | |
231 if (!render_frame_) | |
232 return; | |
233 blink::WebLocalFrame* frame = render_frame_->GetWebFrame(); | |
234 if (!frame->HasSelection()) | |
235 return; | |
236 frame->ReplaceMisspelledRange(blink::WebString::FromUTF16(word)); | |
237 } | |
238 | |
239 void FrameInputHandlerImpl::Delete() { | |
240 RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread, | |
241 weak_this_, "Delete", UpdateState::kNone)); | |
242 } | |
243 | |
244 void FrameInputHandlerImpl::SelectAll() { | |
245 RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread, | |
246 weak_this_, "SelectAll", | |
247 UpdateState::kIsSelectingRange)); | |
248 } | |
249 | |
250 void FrameInputHandlerImpl::CollapseSelection() { | |
251 if (!main_thread_task_runner_->BelongsToCurrentThread()) { | |
252 RunOnMainThread( | |
253 base::Bind(&FrameInputHandlerImpl::CollapseSelection, weak_this_)); | |
254 return; | |
255 } | |
256 | |
257 if (!render_frame_) | |
258 return; | |
259 const blink::WebRange& range = | |
260 render_frame_->GetRenderWidget()->GetWebWidget()->CaretOrSelectionRange(); | |
261 if (range.IsNull()) | |
262 return; | |
263 | |
264 HandlingState handling_state(render_frame_.get(), | |
265 UpdateState::kIsSelectingRange); | |
266 render_frame_->GetWebFrame()->SelectRange( | |
267 blink::WebRange(range.EndOffset(), 0)); | |
268 } | |
269 | |
270 void FrameInputHandlerImpl::SelectRange(const gfx::Point& base, | |
271 const gfx::Point& extent) { | |
272 if (!main_thread_task_runner_->BelongsToCurrentThread()) { | |
273 // TODO(dtapuska): This event should be coalesced. Chrome IPC used | |
274 // and ack scheme for this. We should be able to clobber them in the | |
Avi (use Gerrit)
2017/05/26 16:08:40
"an ack scheme"?
dtapuska
2017/05/26 16:25:24
Done.
| |
275 // main thread event queue. | |
276 RunOnMainThread(base::Bind(&FrameInputHandlerImpl::SelectRange, weak_this_, | |
277 base, extent)); | |
278 return; | |
279 } | |
280 | |
281 if (!render_frame_) | |
282 return; | |
283 RenderViewImpl* render_view = render_frame_->render_view(); | |
284 HandlingState handling_state(render_frame_.get(), | |
285 UpdateState::kIsSelectingRange); | |
286 render_frame_->GetWebFrame()->SelectRange( | |
287 render_view->ConvertWindowPointToViewport(base), | |
288 render_view->ConvertWindowPointToViewport(extent)); | |
289 } | |
290 | |
291 void FrameInputHandlerImpl::AdjustSelectionByCharacterOffset(int32_t start, | |
292 int32_t end) { | |
293 if (!main_thread_task_runner_->BelongsToCurrentThread()) { | |
294 RunOnMainThread( | |
295 base::Bind(&FrameInputHandlerImpl::AdjustSelectionByCharacterOffset, | |
296 weak_this_, start, end)); | |
297 return; | |
298 } | |
299 | |
300 if (!render_frame_) | |
301 return; | |
302 blink::WebRange range = | |
303 render_frame_->GetRenderWidget()->GetWebWidget()->CaretOrSelectionRange(); | |
304 if (range.IsNull()) | |
305 return; | |
306 | |
307 // Sanity checks to disallow empty and out of range selections. | |
308 if (start - end > range.length() || range.StartOffset() + start < 0) | |
309 return; | |
310 | |
311 HandlingState handling_state(render_frame_.get(), | |
312 UpdateState::kIsSelectingRange); | |
313 // A negative adjust amount moves the selection towards the beginning of | |
314 // the document, a positive amount moves the selection towards the end of | |
315 // the document. | |
316 render_frame_->GetWebFrame()->SelectRange( | |
317 blink::WebRange(range.StartOffset() + start, | |
318 range.length() + end - start), | |
319 blink::WebLocalFrame::kPreserveHandleVisibility); | |
320 } | |
321 | |
322 void FrameInputHandlerImpl::MoveRangeSelectionExtent(const gfx::Point& extent) { | |
323 if (!main_thread_task_runner_->BelongsToCurrentThread()) { | |
324 // TODO(dtapuska): This event should be coalesced. Chrome IPC used | |
325 // and ack scheme for this. We should be able to clobber them in the | |
Avi (use Gerrit)
2017/05/26 16:08:40
"an ack scheme"?
dtapuska
2017/05/26 16:25:24
Done.
| |
326 // main thread event queue. | |
327 RunOnMainThread(base::Bind(&FrameInputHandlerImpl::MoveRangeSelectionExtent, | |
328 weak_this_, extent)); | |
329 return; | |
330 } | |
331 | |
332 if (!render_frame_) | |
333 return; | |
334 HandlingState handling_state(render_frame_.get(), | |
335 UpdateState::kIsSelectingRange); | |
336 render_frame_->GetWebFrame()->MoveRangeSelectionExtent( | |
337 render_frame_->render_view()->ConvertWindowPointToViewport(extent)); | |
338 } | |
339 | |
340 void FrameInputHandlerImpl::ExecuteCommandOnMainThread( | |
341 const std::string& command, | |
342 UpdateState update_state) { | |
343 if (!render_frame_) | |
344 return; | |
345 | |
346 HandlingState handling_state(render_frame_.get(), update_state); | |
347 render_frame_->GetWebFrame()->ExecuteCommand( | |
348 blink::WebString::FromUTF8(command)); | |
349 } | |
350 | |
351 void FrameInputHandlerImpl::Release() { | |
352 if (!main_thread_task_runner_->BelongsToCurrentThread()) { | |
353 // Close the binding on the compositor thread first before telling the main | |
354 // thread to delete this object. | |
355 binding_.Close(); | |
356 main_thread_task_runner_->PostTask( | |
357 FROM_HERE, base::Bind(&FrameInputHandlerImpl::Release, weak_this_)); | |
358 return; | |
359 } | |
360 delete this; | |
361 } | |
362 | |
363 void FrameInputHandlerImpl::BindNow(mojom::FrameInputHandlerRequest request) { | |
364 binding_.Bind(std::move(request)); | |
365 binding_.set_connection_error_handler( | |
366 base::Bind(&FrameInputHandlerImpl::Release, base::Unretained(this))); | |
367 } | |
368 | |
369 FrameInputHandlerImpl::HandlingState::HandlingState( | |
370 RenderFrameImpl* render_frame, | |
371 UpdateState state) | |
372 : render_frame_(render_frame), | |
373 original_select_range_value_(render_frame->handling_select_range()), | |
374 original_pasting_value_(render_frame->IsPasting()) { | |
375 switch (state) { | |
376 case UpdateState::kIsPasting: | |
377 render_frame->set_is_pasting(true); | |
378 case UpdateState::kIsSelectingRange: | |
379 render_frame->set_handling_select_range(true); | |
380 break; | |
381 case UpdateState::kNone: | |
382 break; | |
383 } | |
384 } | |
385 | |
386 FrameInputHandlerImpl::HandlingState::~HandlingState() { | |
387 render_frame_->set_handling_select_range(original_select_range_value_); | |
388 render_frame_->set_is_pasting(original_pasting_value_); | |
389 } | |
390 | |
391 } // namespace content | |
OLD | NEW |