content/renderer/input/frame_input_handler_impl.cc

// 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 "content/renderer/input/frame_input_handler_impl.h"

#include <utility>

#include "base/bind.h"
#include "base/debug/stack_trace.h"
#include "base/logging.h"
#include "content/common/input/ime_text_span_conversions.h"
#include "content/renderer/compositor/layer_tree_view.h"
#include "content/renderer/ime_event_guard.h"
#include "content/renderer/input/widget_input_handler_manager.h"
#include "content/renderer/render_thread_impl.h"
#include "content/renderer/render_view_impl.h"
#include "content/renderer/render_widget.h"
#include "third_party/blink/public/web/web_input_method_controller.h"
#include "third_party/blink/public/web/web_local_frame.h"

namespace content {

FrameInputHandlerImpl::FrameInputHandlerImpl(
    base::WeakPtr<RenderFrameImpl> render_frame,
    mojom::FrameInputHandlerRequest request)
    : binding_(this),
      render_frame_(render_frame),
      input_event_queue_(
          render_frame->GetLocalRootRenderWidget()->GetInputEventQueue()),
      main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
      weak_ptr_factory_(this) {
  weak_this_ = weak_ptr_factory_.GetWeakPtr();
  // If we have created an input event queue move the mojo request over to the
  // compositor thread.
  if (RenderThreadImpl::current() &&
      RenderThreadImpl::current()->compositor_task_runner() &&
      input_event_queue_) {
    // Mojo channel bound on compositor thread.
    RenderThreadImpl::current()->compositor_task_runner()->PostTask(
        FROM_HERE, base::BindOnce(&FrameInputHandlerImpl::BindNow,
                                  base::Unretained(this), std::move(request)));
  } else {
    // Mojo channel bound on main thread.
    BindNow(std::move(request));
  }
}

FrameInputHandlerImpl::~FrameInputHandlerImpl() {}

// static
void FrameInputHandlerImpl::CreateMojoService(
    base::WeakPtr<RenderFrameImpl> render_frame,
    mojom::FrameInputHandlerRequest request) {
  DCHECK(render_frame);

  // Owns itself. Will be deleted when message pipe is destroyed.
  new FrameInputHandlerImpl(render_frame, std::move(request));
}

void FrameInputHandlerImpl::RunOnMainThread(base::OnceClosure closure) {
  if (input_event_queue_) {
    input_event_queue_->QueueClosure(std::move(closure));
  } else {
    std::move(closure).Run();
  }
}

void FrameInputHandlerImpl::SetCompositionFromExistingText(
    int32_t start,
    int32_t end,
    const std::vector<ui::ImeTextSpan>& ui_ime_text_spans) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    RunOnMainThread(
        base::BindOnce(&FrameInputHandlerImpl::SetCompositionFromExistingText,
                       weak_this_, start, end, ui_ime_text_spans));
    return;
  }

  if (!render_frame_)
    return;

  ImeEventGuard guard(render_frame_->GetLocalRootRenderWidget());

  render_frame_->GetWebFrame()->SetCompositionFromExistingText(
      start, end, ConvertUiImeTextSpansToBlinkImeTextSpans(ui_ime_text_spans));
}

void FrameInputHandlerImpl::ExtendSelectionAndDelete(int32_t before,
                                                     int32_t after) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    RunOnMainThread(
        base::BindOnce(&FrameInputHandlerImpl::ExtendSelectionAndDelete,
                       weak_this_, before, after));
    return;
  }
  if (!render_frame_)
    return;
  render_frame_->GetWebFrame()->ExtendSelectionAndDelete(before, after);
}

void FrameInputHandlerImpl::DeleteSurroundingText(int32_t before,
                                                  int32_t after) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    RunOnMainThread(
        base::BindOnce(&FrameInputHandlerImpl::DeleteSurroundingText,
                       weak_this_, before, after));
    return;
  }
  if (!render_frame_)
    return;
  render_frame_->GetWebFrame()->DeleteSurroundingText(before, after);
}

void FrameInputHandlerImpl::DeleteSurroundingTextInCodePoints(int32_t before,
                                                              int32_t after) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    RunOnMainThread(base::BindOnce(
        &FrameInputHandlerImpl::DeleteSurroundingTextInCodePoints, weak_this_,
        before, after));
    return;
  }
  if (!render_frame_)
    return;
  render_frame_->GetWebFrame()->DeleteSurroundingTextInCodePoints(before,
                                                                  after);
}

void FrameInputHandlerImpl::SetEditableSelectionOffsets(int32_t start,
                                                        int32_t end) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    RunOnMainThread(
        base::BindOnce(&FrameInputHandlerImpl::SetEditableSelectionOffsets,
                       weak_this_, start, end));
    return;
  }
  if (!render_frame_)
    return;
  HandlingState handling_state(render_frame_, UpdateState::kIsSelectingRange);
  render_frame_->GetWebFrame()->SetEditableSelectionOffsets(start, end);
}

void FrameInputHandlerImpl::ExecuteEditCommand(
    const std::string& command,
    const base::Optional<base::string16>& value) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    RunOnMainThread(base::BindOnce(&FrameInputHandlerImpl::ExecuteEditCommand,
                                   weak_this_, command, value));
    return;
  }
  if (!render_frame_)
    return;
  if (value) {
    render_frame_->GetWebFrame()->ExecuteCommand(
        blink::WebString::FromUTF8(command),
        blink::WebString::FromUTF16(value.value()));
    return;
  }

  render_frame_->GetWebFrame()->ExecuteCommand(
      blink::WebString::FromUTF8(command));
}

void FrameInputHandlerImpl::Undo() {
  RunOnMainThread(
      base::BindOnce(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
                     weak_this_, "Undo", UpdateState::kNone));
}

void FrameInputHandlerImpl::Redo() {
  RunOnMainThread(
      base::BindOnce(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
                     weak_this_, "Redo", UpdateState::kNone));
}

void FrameInputHandlerImpl::Cut() {
  RunOnMainThread(
      base::BindOnce(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
                     weak_this_, "Cut", UpdateState::kIsSelectingRange));
}

void FrameInputHandlerImpl::Copy() {
  RunOnMainThread(
      base::BindOnce(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
                     weak_this_, "Copy", UpdateState::kIsSelectingRange));
}

void FrameInputHandlerImpl::CopyToFindPboard() {
#if defined(OS_MACOSX)
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    RunOnMainThread(
        base::Bind(&FrameInputHandlerImpl::CopyToFindPboard, weak_this_));
    return;
  }
  if (!render_frame_)
    return;
  render_frame_->OnCopyToFindPboard();
#endif
}

void FrameInputHandlerImpl::Paste() {
  RunOnMainThread(
      base::BindOnce(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
                     weak_this_, "Paste", UpdateState::kIsPasting));
}

void FrameInputHandlerImpl::PasteAndMatchStyle() {
  RunOnMainThread(base::BindOnce(
      &FrameInputHandlerImpl::ExecuteCommandOnMainThread, weak_this_,
      "PasteAndMatchStyle", UpdateState::kIsPasting));
}

void FrameInputHandlerImpl::Replace(const base::string16& word) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    RunOnMainThread(
        base::BindOnce(&FrameInputHandlerImpl::Replace, weak_this_, word));
    return;
  }
  if (!render_frame_)
    return;
  blink::WebLocalFrame* frame = render_frame_->GetWebFrame();
  if (!frame->HasSelection())
    frame->SelectWordAroundCaret();
  frame->ReplaceSelection(blink::WebString::FromUTF16(word));
  render_frame_->SyncSelectionIfRequired();
}

void FrameInputHandlerImpl::ReplaceMisspelling(const base::string16& word) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    RunOnMainThread(base::BindOnce(&FrameInputHandlerImpl::ReplaceMisspelling,
                                   weak_this_, word));
    return;
  }
  if (!render_frame_)
    return;
  blink::WebLocalFrame* frame = render_frame_->GetWebFrame();
  if (!frame->HasSelection())
    return;
  frame->ReplaceMisspelledRange(blink::WebString::FromUTF16(word));
}

void FrameInputHandlerImpl::Delete() {
  RunOnMainThread(
      base::BindOnce(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
                     weak_this_, "Delete", UpdateState::kNone));
}

void FrameInputHandlerImpl::SelectAll() {
  RunOnMainThread(
      base::BindOnce(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
                     weak_this_, "SelectAll", UpdateState::kIsSelectingRange));
}

void FrameInputHandlerImpl::CollapseSelection() {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    RunOnMainThread(
        base::BindOnce(&FrameInputHandlerImpl::CollapseSelection, weak_this_));
    return;
  }

  if (!render_frame_)
    return;
  const blink::WebRange& range = render_frame_->GetWebFrame()
                                     ->GetInputMethodController()
                                     ->GetSelectionOffsets();
  if (range.IsNull())
    return;

  HandlingState handling_state(render_frame_, UpdateState::kIsSelectingRange);
  render_frame_->GetWebFrame()->SelectRange(
      blink::WebRange(range.EndOffset(), 0),
      blink::WebLocalFrame::kHideSelectionHandle,
      blink::mojom::SelectionMenuBehavior::kHide);
}

void FrameInputHandlerImpl::SelectRange(const gfx::Point& base,
                                        const gfx::Point& extent) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    // 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(&FrameInputHandlerImpl::SelectRange,
                                   weak_this_, base, extent));
    return;
  }

  if (!render_frame_)
    return;
  RenderWidget* window_widget = render_frame_->render_view()->GetWidget();
  HandlingState handling_state(render_frame_, UpdateState::kIsSelectingRange);
  render_frame_->GetWebFrame()->SelectRange(
      window_widget->ConvertWindowPointToViewport(base),
      window_widget->ConvertWindowPointToViewport(extent));
}

#if defined(OS_ANDROID)
void FrameInputHandlerImpl::SelectWordAroundCaret(
    SelectWordAroundCaretCallback callback) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    RunOnMainThread(
        base::BindOnce(&FrameInputHandlerImpl::SelectWordAroundCaret,
                       weak_this_, std::move(callback)));
    return;
  }

  bool did_select = false;
  int start_adjust = 0;
  int end_adjust = 0;
  if (render_frame_) {
    blink::WebLocalFrame* frame = render_frame_->GetWebFrame();
    blink::WebRange initial_range = frame->SelectionRange();
    render_frame_->GetLocalRootRenderWidget()->SetHandlingInputEvent(true);
    if (!initial_range.IsNull())
      did_select = frame->SelectWordAroundCaret();
    if (did_select) {
      blink::WebRange adjusted_range = frame->SelectionRange();
      DCHECK(!adjusted_range.IsNull());
      start_adjust = adjusted_range.StartOffset() - initial_range.StartOffset();
      end_adjust = adjusted_range.EndOffset() - initial_range.EndOffset();
    }
    render_frame_->GetLocalRootRenderWidget()->SetHandlingInputEvent(false);
  }

  // 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 (RenderThreadImpl::current() &&
      RenderThreadImpl::current()->compositor_task_runner() &&
      input_event_queue_) {
    RenderThreadImpl::current()->compositor_task_runner()->PostTask(
        FROM_HERE, base::BindOnce(std::move(callback), did_select, start_adjust,
                                  end_adjust));
  } else {
    std::move(callback).Run(did_select, start_adjust, end_adjust);
  }
}
#endif  // defined(OS_ANDROID)

void FrameInputHandlerImpl::AdjustSelectionByCharacterOffset(
    int32_t start,
    int32_t end,
    blink::mojom::SelectionMenuBehavior selection_menu_behavior) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    RunOnMainThread(
        base::BindOnce(&FrameInputHandlerImpl::AdjustSelectionByCharacterOffset,
                       weak_this_, start, end, selection_menu_behavior));
    return;
  }

  if (!render_frame_)
    return;
  blink::WebRange range = render_frame_->GetWebFrame()
                              ->GetInputMethodController()
                              ->GetSelectionOffsets();
  if (range.IsNull())
    return;

  // Sanity checks to disallow empty and out of range selections.
  if (start - end > range.length() || range.StartOffset() + start < 0)
    return;

  HandlingState handling_state(render_frame_, UpdateState::kIsSelectingRange);
  // A negative adjust amount moves the selection towards the beginning of
  // the document, a positive amount moves the selection towards the end of
  // the document.
  render_frame_->GetWebFrame()->SelectRange(
      blink::WebRange(range.StartOffset() + start,
                      range.length() + end - start),
      blink::WebLocalFrame::kPreserveHandleVisibility, selection_menu_behavior);
}

void FrameInputHandlerImpl::MoveRangeSelectionExtent(const gfx::Point& extent) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    // 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(
        &FrameInputHandlerImpl::MoveRangeSelectionExtent, weak_this_, extent));
    return;
  }

  if (!render_frame_)
    return;
  HandlingState handling_state(render_frame_, UpdateState::kIsSelectingRange);
  render_frame_->GetWebFrame()->MoveRangeSelectionExtent(
      render_frame_->render_view()->GetWidget()->ConvertWindowPointToViewport(
          extent));
}

void FrameInputHandlerImpl::ScrollFocusedEditableNodeIntoRect(
    const gfx::Rect& rect) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    RunOnMainThread(base::BindOnce(
        &FrameInputHandlerImpl::ScrollFocusedEditableNodeIntoRect, weak_this_,
        rect));
    return;
  }

  if (!render_frame_)
    return;

  render_frame_->ScrollFocusedEditableElementIntoRect(rect);
}

void FrameInputHandlerImpl::MoveCaret(const gfx::Point& point) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    RunOnMainThread(
        base::BindOnce(&FrameInputHandlerImpl::MoveCaret, weak_this_, point));
    return;
  }

  if (!render_frame_)
    return;

  render_frame_->GetWebFrame()->MoveCaretSelection(
      render_frame_->render_view()->GetWidget()->ConvertWindowPointToViewport(
          point));
}

void FrameInputHandlerImpl::GetWidgetInputHandler(
    mojom::WidgetInputHandlerAssociatedRequest interface_request,
    mojom::WidgetInputHandlerHostPtr host) {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    main_thread_task_runner_->PostTask(
        FROM_HERE, base::BindOnce(&FrameInputHandlerImpl::GetWidgetInputHandler,
                                  weak_this_, std::move(interface_request),
                                  std::move(host)));
    return;
  }
  if (!render_frame_)
    return;
  render_frame_->GetLocalRootRenderWidget()
      ->widget_input_handler_manager()
      ->AddAssociatedInterface(std::move(interface_request), std::move(host));
}

void FrameInputHandlerImpl::ExecuteCommandOnMainThread(
    const std::string& command,
    UpdateState update_state) {
  if (!render_frame_)
    return;

  HandlingState handling_state(render_frame_, update_state);
  render_frame_->GetWebFrame()->ExecuteCommand(
      blink::WebString::FromUTF8(command));
}

void FrameInputHandlerImpl::Release() {
  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
    // Close the binding on the compositor thread first before telling the main
    // thread to delete this object.
    binding_.Close();
    main_thread_task_runner_->PostTask(
        FROM_HERE, base::BindOnce(&FrameInputHandlerImpl::Release, weak_this_));
    return;
  }
  delete this;
}

void FrameInputHandlerImpl::BindNow(mojom::FrameInputHandlerRequest request) {
  binding_.Bind(std::move(request));
  binding_.set_connection_error_handler(
      base::BindOnce(&FrameInputHandlerImpl::Release, base::Unretained(this)));
}

FrameInputHandlerImpl::HandlingState::HandlingState(
    const base::WeakPtr<RenderFrameImpl>& render_frame,
    UpdateState state)
    : render_frame_(render_frame),
      original_select_range_value_(render_frame->handling_select_range()),
      original_pasting_value_(render_frame->IsPasting()) {
  switch (state) {
    case UpdateState::kIsPasting:
      render_frame->set_is_pasting(true);
      FALLTHROUGH;  // Matches RenderFrameImpl::OnPaste() which sets both.
    case UpdateState::kIsSelectingRange:
      render_frame->set_handling_select_range(true);
      break;
    case UpdateState::kNone:
      break;
  }
}

FrameInputHandlerImpl::HandlingState::~HandlingState() {
  // RenderFrame may have been destroyed while this object was on the stack.
  if (!render_frame_)
    return;
  render_frame_->set_handling_select_range(original_select_range_value_);
  render_frame_->set_is_pasting(original_pasting_value_);
}

}  // namespace content