| // Copyright 2017 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "third_party/blink/renderer/platform/widget/input/frame_widget_input_handler_impl.h" |
| |
| #include <utility> |
| |
| #include "base/bind.h" |
| #include "base/check.h" |
| #include "base/memory/weak_ptr.h" |
| #include "mojo/public/cpp/bindings/pending_receiver.h" |
| #include "mojo/public/cpp/bindings/receiver.h" |
| #include "third_party/blink/public/platform/scheduler/web_thread_scheduler.h" |
| #include "third_party/blink/renderer/platform/widget/frame_widget.h" |
| #include "third_party/blink/renderer/platform/widget/input/ime_event_guard.h" |
| #include "third_party/blink/renderer/platform/widget/input/main_thread_event_queue.h" |
| #include "third_party/blink/renderer/platform/widget/widget_base.h" |
| #include "third_party/blink/renderer/platform/widget/widget_base_client.h" |
| |
| namespace blink { |
| |
| FrameWidgetInputHandlerImpl::FrameWidgetInputHandlerImpl( |
| base::WeakPtr<WidgetBase> widget, |
| base::WeakPtr<mojom::blink::FrameWidgetInputHandler> |
| frame_widget_input_handler, |
| scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner, |
| scoped_refptr<MainThreadEventQueue> input_event_queue) |
| : widget_(std::move(widget)), |
| main_thread_frame_widget_input_handler_( |
| std::move(frame_widget_input_handler)), |
| input_event_queue_(input_event_queue), |
| main_thread_task_runner_(main_thread_task_runner) {} |
| |
| FrameWidgetInputHandlerImpl::~FrameWidgetInputHandlerImpl() = default; |
| |
| void FrameWidgetInputHandlerImpl::RunOnMainThread(base::OnceClosure closure) { |
| if (input_event_queue_) { |
| input_event_queue_->QueueClosure(std::move(closure)); |
| } else { |
| std::move(closure).Run(); |
| } |
| } |
| |
| void FrameWidgetInputHandlerImpl::AddImeTextSpansToExistingText( |
| uint32_t start, |
| uint32_t end, |
| const Vector<ui::ImeTextSpan>& ui_ime_text_spans) { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<WidgetBase> widget, |
| base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| uint32_t start, uint32_t end, |
| const Vector<ui::ImeTextSpan>& ui_ime_text_spans) { |
| DCHECK_EQ(!!widget, !!handler); |
| if (!widget) |
| return; |
| ImeEventGuard guard(widget); |
| handler->AddImeTextSpansToExistingText(start, end, ui_ime_text_spans); |
| }, |
| widget_, main_thread_frame_widget_input_handler_, start, end, |
| ui_ime_text_spans)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::ClearImeTextSpansByType( |
| uint32_t start, |
| uint32_t end, |
| ui::ImeTextSpan::Type type) { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<WidgetBase> widget, |
| base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| uint32_t start, uint32_t end, ui::ImeTextSpan::Type type) { |
| DCHECK_EQ(!!widget, !!handler); |
| if (!widget) |
| return; |
| ImeEventGuard guard(widget); |
| handler->ClearImeTextSpansByType(start, end, type); |
| }, |
| widget_, main_thread_frame_widget_input_handler_, start, end, type)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::SetCompositionFromExistingText( |
| int32_t start, |
| int32_t end, |
| const Vector<ui::ImeTextSpan>& ui_ime_text_spans) { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<WidgetBase> widget, |
| base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| int32_t start, int32_t end, |
| const Vector<ui::ImeTextSpan>& ui_ime_text_spans) { |
| DCHECK_EQ(!!widget, !!handler); |
| if (!widget) |
| return; |
| ImeEventGuard guard(widget); |
| handler->SetCompositionFromExistingText(start, end, ui_ime_text_spans); |
| }, |
| widget_, main_thread_frame_widget_input_handler_, start, end, |
| ui_ime_text_spans)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::ExtendSelectionAndDelete(int32_t before, |
| int32_t after) { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| int32_t before, int32_t after) { |
| if (handler) |
| handler->ExtendSelectionAndDelete(before, after); |
| }, |
| main_thread_frame_widget_input_handler_, before, after)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::DeleteSurroundingText(int32_t before, |
| int32_t after) { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| int32_t before, int32_t after) { |
| if (handler) |
| handler->DeleteSurroundingText(before, after); |
| }, |
| main_thread_frame_widget_input_handler_, before, after)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::DeleteSurroundingTextInCodePoints( |
| int32_t before, |
| int32_t after) { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| int32_t before, int32_t after) { |
| if (handler) |
| handler->DeleteSurroundingTextInCodePoints(before, after); |
| }, |
| main_thread_frame_widget_input_handler_, before, after)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::SetEditableSelectionOffsets(int32_t start, |
| int32_t end) { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<WidgetBase> widget, |
| base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| int32_t start, int32_t end) { |
| DCHECK_EQ(!!widget, !!handler); |
| if (!widget) |
| return; |
| HandlingState handling_state(widget, UpdateState::kIsSelectingRange); |
| handler->SetEditableSelectionOffsets(start, end); |
| }, |
| widget_, main_thread_frame_widget_input_handler_, start, end)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::ExecuteEditCommand(const String& command, |
| const String& value) { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| const String& command, const String& value) { |
| if (handler) |
| handler->ExecuteEditCommand(command, value); |
| }, |
| main_thread_frame_widget_input_handler_, command.IsolatedCopy(), |
| value.IsolatedCopy())); |
| } |
| |
| void FrameWidgetInputHandlerImpl::Undo() { |
| RunOnMainThread(base::BindOnce( |
| &FrameWidgetInputHandlerImpl::ExecuteCommandOnMainThread, widget_, |
| main_thread_frame_widget_input_handler_, "Undo", UpdateState::kNone)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::Redo() { |
| RunOnMainThread(base::BindOnce( |
| &FrameWidgetInputHandlerImpl::ExecuteCommandOnMainThread, widget_, |
| main_thread_frame_widget_input_handler_, "Redo", UpdateState::kNone)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::Cut() { |
| RunOnMainThread( |
| base::BindOnce(&FrameWidgetInputHandlerImpl::ExecuteCommandOnMainThread, |
| widget_, main_thread_frame_widget_input_handler_, "Cut", |
| UpdateState::kIsSelectingRange)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::Copy() { |
| RunOnMainThread( |
| base::BindOnce(&FrameWidgetInputHandlerImpl::ExecuteCommandOnMainThread, |
| widget_, main_thread_frame_widget_input_handler_, "Copy", |
| UpdateState::kIsSelectingRange)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::CopyToFindPboard() { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler) { |
| if (handler) |
| handler->CopyToFindPboard(); |
| }, |
| main_thread_frame_widget_input_handler_)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::Paste() { |
| RunOnMainThread( |
| base::BindOnce(&FrameWidgetInputHandlerImpl::ExecuteCommandOnMainThread, |
| widget_, main_thread_frame_widget_input_handler_, "Paste", |
| UpdateState::kIsPasting)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::PasteAndMatchStyle() { |
| RunOnMainThread( |
| base::BindOnce(&FrameWidgetInputHandlerImpl::ExecuteCommandOnMainThread, |
| widget_, main_thread_frame_widget_input_handler_, |
| "PasteAndMatchStyle", UpdateState::kIsPasting)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::Replace(const String& word) { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| const String& word) { |
| if (handler) |
| handler->Replace(word); |
| }, |
| main_thread_frame_widget_input_handler_, word.IsolatedCopy())); |
| } |
| |
| void FrameWidgetInputHandlerImpl::ReplaceMisspelling(const String& word) { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| const String& word) { |
| if (handler) |
| handler->ReplaceMisspelling(word); |
| }, |
| main_thread_frame_widget_input_handler_, word.IsolatedCopy())); |
| } |
| |
| void FrameWidgetInputHandlerImpl::Delete() { |
| RunOnMainThread(base::BindOnce( |
| &FrameWidgetInputHandlerImpl::ExecuteCommandOnMainThread, widget_, |
| main_thread_frame_widget_input_handler_, "Delete", UpdateState::kNone)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::SelectAll() { |
| RunOnMainThread( |
| base::BindOnce(&FrameWidgetInputHandlerImpl::ExecuteCommandOnMainThread, |
| widget_, main_thread_frame_widget_input_handler_, |
| "SelectAll", UpdateState::kIsSelectingRange)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::CollapseSelection() { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<WidgetBase> widget, |
| base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler) { |
| DCHECK_EQ(!!widget, !!handler); |
| if (!widget) |
| return; |
| HandlingState handling_state(widget, UpdateState::kIsSelectingRange); |
| handler->CollapseSelection(); |
| }, |
| widget_, main_thread_frame_widget_input_handler_)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::SelectRange(const gfx::Point& base, |
| const gfx::Point& extent) { |
| // TODO(dtapuska): This event should be coalesced. Chrome IPC uses |
| // one outstanding event and an ACK to handle coalescing on the browser |
| // side. We should be able to clobber them in the main thread event queue. |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<WidgetBase> widget, |
| base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| const gfx::Point& base, const gfx::Point& extent) { |
| DCHECK_EQ(!!widget, !!handler); |
| if (!widget) |
| return; |
| HandlingState handling_state(widget, UpdateState::kIsSelectingRange); |
| handler->SelectRange(base, extent); |
| }, |
| widget_, main_thread_frame_widget_input_handler_, base, extent)); |
| } |
| |
| #if defined(OS_ANDROID) |
| |
| void FrameWidgetInputHandlerImpl::SelectWordAroundCaret( |
| SelectWordAroundCaretCallback callback) { |
| // If the mojom channel is registered with compositor thread, we have to run |
| // the callback on compositor thread. Otherwise run it on main thread. Mojom |
| // requires the callback runs on the same thread. |
| if (!main_thread_task_runner_->BelongsToCurrentThread()) { |
| callback = base::BindOnce( |
| [](scoped_refptr<base::SingleThreadTaskRunner> callback_task_runner, |
| SelectWordAroundCaretCallback callback, bool did_select, |
| int start_adjust, int end_adjust) { |
| callback_task_runner->PostTask( |
| FROM_HERE, base::BindOnce(std::move(callback), did_select, |
| start_adjust, end_adjust)); |
| }, |
| base::ThreadTaskRunnerHandle::Get(), std::move(callback)); |
| } |
| |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| SelectWordAroundCaretCallback callback) { |
| if (handler) { |
| handler->SelectWordAroundCaret(std::move(callback)); |
| } else { |
| std::move(callback).Run(false, 0, 0); |
| } |
| }, |
| main_thread_frame_widget_input_handler_, std::move(callback))); |
| } |
| #endif // defined(OS_ANDROID) |
| |
| void FrameWidgetInputHandlerImpl::AdjustSelectionByCharacterOffset( |
| int32_t start, |
| int32_t end, |
| blink::mojom::SelectionMenuBehavior selection_menu_behavior) { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<WidgetBase> widget, |
| base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| int32_t start, int32_t end, |
| blink::mojom::SelectionMenuBehavior selection_menu_behavior) { |
| DCHECK_EQ(!!widget, !!handler); |
| if (!widget) |
| return; |
| HandlingState handling_state(widget, UpdateState::kIsSelectingRange); |
| handler->AdjustSelectionByCharacterOffset(start, end, |
| selection_menu_behavior); |
| }, |
| widget_, main_thread_frame_widget_input_handler_, start, end, |
| selection_menu_behavior)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::MoveRangeSelectionExtent( |
| const gfx::Point& extent) { |
| // TODO(dtapuska): This event should be coalesced. Chrome IPC uses |
| // one outstanding event and an ACK to handle coalescing on the browser |
| // side. We should be able to clobber them in the main thread event queue. |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<WidgetBase> widget, |
| base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| const gfx::Point& extent) { |
| DCHECK_EQ(!!widget, !!handler); |
| if (!widget) |
| return; |
| HandlingState handling_state(widget, UpdateState::kIsSelectingRange); |
| handler->MoveRangeSelectionExtent(extent); |
| }, |
| widget_, main_thread_frame_widget_input_handler_, extent)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::ScrollFocusedEditableNodeIntoRect( |
| const gfx::Rect& rect) { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| const gfx::Rect& rect) { |
| if (handler) |
| handler->ScrollFocusedEditableNodeIntoRect(rect); |
| }, |
| main_thread_frame_widget_input_handler_, rect)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::MoveCaret(const gfx::Point& point) { |
| RunOnMainThread(base::BindOnce( |
| [](base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| const gfx::Point& point) { |
| if (handler) |
| handler->MoveCaret(point); |
| }, |
| main_thread_frame_widget_input_handler_, point)); |
| } |
| |
| void FrameWidgetInputHandlerImpl::ExecuteCommandOnMainThread( |
| base::WeakPtr<WidgetBase> widget, |
| base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler, |
| const char* command, |
| UpdateState update_state) { |
| DCHECK_EQ(!!widget, !!handler); |
| if (!widget) |
| return; |
| HandlingState handling_state(widget, update_state); |
| handler->ExecuteEditCommand(command, String()); |
| } |
| |
| FrameWidgetInputHandlerImpl::HandlingState::HandlingState( |
| const base::WeakPtr<WidgetBase>& widget, |
| UpdateState state) |
| : widget_(widget), |
| original_select_range_value_(widget->handling_select_range()), |
| original_pasting_value_(widget->is_pasting()) { |
| switch (state) { |
| case UpdateState::kIsPasting: |
| widget->set_is_pasting(true); |
| FALLTHROUGH; // Set both |
| case UpdateState::kIsSelectingRange: |
| widget->set_handling_select_range(true); |
| break; |
| case UpdateState::kNone: |
| break; |
| } |
| } |
| |
| FrameWidgetInputHandlerImpl::HandlingState::~HandlingState() { |
| // FrameWidget may have been destroyed while this object was on the stack. |
| if (!widget_) |
| return; |
| widget_->set_handling_select_range(original_select_range_value_); |
| widget_->set_is_pasting(original_pasting_value_); |
| } |
| |
| } // namespace blink |
