Add a mojo channel for frame messages.

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/renderer/ime_event_guard.h"
+#include "content/renderer/render_thread_impl.h"
+#include "content/renderer/render_view_impl.h"
+#include "content/renderer/render_widget.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
+
+namespace content {
+
+FrameInputHandlerImpl::FrameInputHandlerImpl(
+    base::WeakPtr<RenderFrameImpl> render_frame,
+    mojom::FrameInputHandlerRequest request)
+    : binding_(this),
+      render_frame_(render_frame),
+      input_event_queue_(
+          render_frame->GetRenderWidget()->GetInputEventQueue()) {
+  // Once the binding is connected the error handler will be set to
+  // Release.
+  AddRef();
+
+  // If we have created an input event queue move the mojo request over to the
+  // compositor thread.
+  if (input_event_queue_) {
+    // Mojo channel bound on compositor thread.
+    RenderThreadImpl::current()->compositor_task_runner()->PostTask(
+        FROM_HERE, base::BindOnce(&FrameInputHandlerImpl::BindOnCompositor,
+                                  this, std::move(request)));
+  } else {
+    // Mojo channel bound on main thread.
+    BindNow(std::move(request));
+  }
+  main_thread_task_runner_ = base::ThreadTaskRunnerHandle::Get();

[dcheng, 2017/05/25 00:03:58]

Nit: bind this in the initializer list for consistency

[dtapuska, 2017/05/26 14:02:06]

Done.

+}
+
+FrameInputHandlerImpl::~FrameInputHandlerImpl() {}
+
+// static
+void FrameInputHandlerImpl::CreateMojoService(
+    base::WeakPtr<RenderFrameImpl> render_frame,
+    const service_manager::BindSourceInfo& source_info,
+    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(const base::Closure& closure) {
+  if (input_event_queue_) {
+    input_event_queue_->QueueClosure(closure);
+  } else {
+    closure.Run();
+  }
+}
+
+void FrameInputHandlerImpl::SetCompositionFromExistingText(
+    int32_t start,
+    int32_t end,
+    const std::vector<ui::CompositionUnderline>& ui_underlines) {
+  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
+    RunOnMainThread(
+        base::Bind(&FrameInputHandlerImpl::SetCompositionFromExistingText, this,

[dcheng, 2017/05/25 00:03:58]

It's safe to vend weak pointers from another thread. However, there's a catch:
if the internal flag object has not been created yet, then GetWeakPtr() is racy.

So to make this all safe:
1. Make this class not refcounted.
2. Add a WeakPtr<FrameInputHandlerImpl> weak_this_.
3. In the constructor body, weak_this_ = weak_ptr_factory_.GetWeakPtr(). Note
that this can't go in the initializer list because the clang plugin enforces
that WeakPtrFactory is the last member.
4. Then there's no need to try dereferencing the weak pointer below; the
callback machinery will do that automatically.

[dtapuska, 2017/05/26 14:02:06]

Done. Although I needed to clear the bindings in the Release on the compositor
thread and then proxy the delete over to the main thread of the object. Either
way it was fundamentally wrong with the ref counted object because the bindings
could end up getting destroyed on the main thread which isn't allowed.

+                   start, end, ui_underlines));
+    return;
+  }
+
+  if (!render_frame_)
+    return;
+
+  ImeEventGuard guard(render_frame_->GetRenderWidget());
+  std::vector<blink::WebCompositionUnderline> underlines;
+  for (const auto& underline : ui_underlines) {
+    blink::WebCompositionUnderline blink_underline(
+        underline.start_offset, underline.end_offset, underline.color,
+        underline.thick, underline.background_color);
+    underlines.push_back(blink_underline);
+  }
+
+  render_frame_->GetWebFrame()->SetCompositionFromExistingText(start, end,
+                                                               underlines);
+}
+
+void FrameInputHandlerImpl::ExtendSelectionAndDelete(int32_t before,
+                                                     int32_t after) {
+  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
+    RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExtendSelectionAndDelete,
+                               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::Bind(&FrameInputHandlerImpl::DeleteSurroundingText,
+                               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::Bind(&FrameInputHandlerImpl::DeleteSurroundingTextInCodePoints,
+                   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::Bind(
+        &FrameInputHandlerImpl::SetEditableSelectionOffsets, this, start, end));
+    return;
+  }
+  if (!render_frame_)
+    return;
+  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::Bind(&FrameInputHandlerImpl::ExecuteEditCommand, 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::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
+                             this, "Undo", UpdateState::kNone));
+}
+
+void FrameInputHandlerImpl::Redo() {
+  RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
+                             this, "Redo", UpdateState::kNone));
+}
+
+void FrameInputHandlerImpl::Cut() {
+  RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
+                             this, "Cut", UpdateState::kIsSelectingRange));
+}
+
+void FrameInputHandlerImpl::Copy() {
+  RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
+                             this, "Copy", UpdateState::kIsSelectingRange));
+}
+
+void FrameInputHandlerImpl::CopyToFindPboard() {
+#if defined(OS_MACOSX)
+  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
+    RunOnMainThread(base::Bind(&FrameInputHandlerImpl::CopyToFindPboard, this));
+    return;
+  }
+  if (!render_frame_)
+    return;
+  render_frame_->OnCopyToFindPboard();
+#endif
+}
+
+void FrameInputHandlerImpl::Paste() {
+  RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
+                             this, "Paste", UpdateState::kIsPasting));
+}
+
+void FrameInputHandlerImpl::PasteAndMatchStyle() {
+  RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
+                             this, "PasteAndMatchStyle",
+                             UpdateState::kIsPasting));
+}
+
+void FrameInputHandlerImpl::Replace(const base::string16& word) {
+  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
+    RunOnMainThread(base::Bind(&FrameInputHandlerImpl::Replace, 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(true);
+}
+
+void FrameInputHandlerImpl::ReplaceMisspelling(const base::string16& word) {
+  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
+    RunOnMainThread(
+        base::Bind(&FrameInputHandlerImpl::ReplaceMisspelling, 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::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
+                             this, "Delete", UpdateState::kNone));
+}
+
+void FrameInputHandlerImpl::SelectAll() {
+  RunOnMainThread(base::Bind(&FrameInputHandlerImpl::ExecuteCommandOnMainThread,
+                             this, "SelectAll",
+                             UpdateState::kIsSelectingRange));
+}
+
+void FrameInputHandlerImpl::CollapseSelection() {
+  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
+    RunOnMainThread(
+        base::Bind(&FrameInputHandlerImpl::CollapseSelection, this));
+    return;
+  }
+
+  if (!render_frame_)
+    return;
+  const blink::WebRange& range =
+      render_frame_->GetRenderWidget()->GetWebWidget()->CaretOrSelectionRange();
+  if (range.IsNull())
+    return;
+
+  HandlingState handling_state(render_frame_.get(),
+                               UpdateState::kIsSelectingRange);
+  render_frame_->GetWebFrame()->SelectRange(
+      blink::WebRange(range.EndOffset(), 0));
+}
+
+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 used
+    // and ack scheme for this. We should be able to clobber them in the
+    // main thread event queue.
+    RunOnMainThread(
+        base::Bind(&FrameInputHandlerImpl::SelectRange, this, base, extent));
+    return;
+  }
+
+  if (!render_frame_)
+    return;
+  RenderViewImpl* render_view = render_frame_->render_view();
+  HandlingState handling_state(render_frame_.get(),
+                               UpdateState::kIsSelectingRange);
+  render_frame_->GetWebFrame()->SelectRange(
+      render_view->ConvertWindowPointToViewport(base),
+      render_view->ConvertWindowPointToViewport(extent));
+}
+
+void FrameInputHandlerImpl::AdjustSelectionByCharacterOffset(int32_t start,
+                                                             int32_t end) {
+  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
+    RunOnMainThread(
+        base::Bind(&FrameInputHandlerImpl::AdjustSelectionByCharacterOffset,
+                   this, start, end));
+    return;
+  }
+
+  if (!render_frame_)
+    return;
+  blink::WebRange range =
+      render_frame_->GetRenderWidget()->GetWebWidget()->CaretOrSelectionRange();
+  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_.get(),
+                               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);
+}
+
+void FrameInputHandlerImpl::MoveRangeSelectionExtent(const gfx::Point& extent) {
+  if (!main_thread_task_runner_->BelongsToCurrentThread()) {
+    // TODO(dtapuska): This event should be coalesced. Chrome IPC used
+    // and ack scheme for this. We should be able to clobber them in the
+    // main thread event queue.
+    RunOnMainThread(base::Bind(&FrameInputHandlerImpl::MoveRangeSelectionExtent,
+                               this, extent));
+    return;
+  }
+
+  if (!render_frame_)
+    return;
+  HandlingState handling_state(render_frame_.get(),
+                               UpdateState::kIsSelectingRange);
+  render_frame_->GetWebFrame()->MoveRangeSelectionExtent(
+      render_frame_->render_view()->ConvertWindowPointToViewport(extent));
+}
+
+void FrameInputHandlerImpl::ExecuteCommandOnMainThread(
+    const std::string& command,
+    UpdateState update_state) {
+  if (!render_frame_)
+    return;
+
+  HandlingState handling_state(render_frame_.get(), update_state);
+  render_frame_->GetWebFrame()->ExecuteCommand(
+      blink::WebString::FromUTF8(command));
+}
+
+void FrameInputHandlerImpl::BindOnCompositor(
+    mojom::FrameInputHandlerRequest request) {
+  BindNow(std::move(request));
+}
+
+void FrameInputHandlerImpl::BindNow(mojom::FrameInputHandlerRequest request) {
+  binding_.Bind(std::move(request));
+
+  // This will Release the ref-counted AddRef that was added in the constructor.
+  binding_.set_connection_error_handler(
+      base::Bind(&FrameInputHandlerImpl::Release, this));
+}
+
+FrameInputHandlerImpl::HandlingState::HandlingState(
+    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);
+    case UpdateState::kIsSelectingRange:
+      render_frame->set_handling_select_range(true);
+      break;
+    case UpdateState::kNone:
+      break;
+  }
+}
+
+FrameInputHandlerImpl::HandlingState::~HandlingState() {
+  render_frame_->set_handling_select_range(original_select_range_value_);
+  render_frame_->set_is_pasting(original_pasting_value_);
+}
+
+}  // namespace content