Introduce ThreadedInputConnection behind a switch

content/renderer/render_widget.cc

 // Copyright (c) 2012 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/render_widget.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 696 matching lines @@
     IPC_MESSAGE_HANDLER(ViewMsg_ChangeResizeRect, OnChangeResizeRect)
     IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
     IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
     IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
     IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
     IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
     IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
     IPC_MESSAGE_HANDLER(ViewMsg_SetSurfaceIdNamespace, OnSetSurfaceIdNamespace)
 #if defined(OS_ANDROID)
     IPC_MESSAGE_HANDLER(InputMsg_ImeEventAck, OnImeEventAck)
+    IPC_MESSAGE_HANDLER(InputMsg_RequestTextInputStateUpdate,
+                        OnRequestTextInputStateUpdate)
     IPC_MESSAGE_HANDLER(ViewMsg_ShowImeIfNeeded, OnShowImeIfNeeded)
 #endif
     IPC_MESSAGE_HANDLER(ViewMsg_HandleCompositorProto, OnHandleCompositorProto)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 bool RenderWidget::Send(IPC::Message* message) {
   // Don't send any messages after the browser has told us to close, and filter
@@ skipping 561 matching lines @@
   if (IsDateTimeInput(new_type))
     return;  // Not considered as a text input field in WebKit/Chromium.
 
   blink::WebTextInputInfo new_info;
   if (webwidget_)
     new_info = webwidget_->textInputInfo();
   const ui::TextInputMode new_mode = ConvertInputMode(new_info.inputMode);
 
   bool new_can_compose_inline = CanComposeInline();
 
+  bool use_ime_thread = false;

[aelias_OOO_until_Jul13, 2016/01/23 03:21:39]

Let's make this default true on non-Android so that deleting ime-thread flag
becomes no-op change.

[Changwan Ryu, 2016/01/26 03:25:29]

Hmm... For other platforms if we set this as true they may send
UpdateTextInputState() even when the state hasn't changed. Is this ok?

[aelias_OOO_until_Jul13, 2016/01/26 05:21:18]

No, that shouldn't happen because change_source is always FROM_NON_IME now on
non-Android, right?

+#if defined(OS_ANDROID)
+  use_ime_thread = base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kUseImeThread);
+#endif
+
   // Only sends text input params if they are changed or if the ime should be
   // shown.
   if (show_ime == ShowIme::IF_NEEDED ||
+      (use_ime_thread && change_source == ChangeSource::FROM_IME) ||
       (text_input_type_ != new_type || text_input_mode_ != new_mode ||
        text_input_info_ != new_info ||
        can_compose_inline_ != new_can_compose_inline)
 #if defined(OS_ANDROID)
       || text_field_is_dirty_
 #endif
       ) {
     ViewHostMsg_TextInputState_Params params;
     params.type = new_type;
     params.mode = new_mode;
@@ skipping 477 matching lines @@
 
 #if defined(OS_ANDROID)
 void RenderWidget::OnImeEventSentForAck(const blink::WebTextInputInfo& info) {
   text_input_info_history_.push_back(info);
 }
 
 void RenderWidget::OnImeEventAck() {
   DCHECK_GE(text_input_info_history_.size(), 1u);
   text_input_info_history_.pop_front();
 }
+
+void RenderWidget::OnRequestTextInputStateUpdate() {
+  ImeEventGuard guard(this, false, true);

[aelias_OOO_until_Jul13, 2016/01/23 03:21:39]

This can't be nested so it seems unnecessarily indirect to use the guard. 
Please write:

  UpdateSelectionBounds();
  UpdateTextInputState(ShowIme::HIDE_IME, ChangeSource::FROM_IME);

[Changwan Ryu, 2016/01/26 03:25:29]

Done.

+}
 #endif
 
 bool RenderWidget::ShouldHandleImeEvent() {
 #if defined(OS_ANDROID)
   if (!webwidget_)
     return false;
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kUseImeThread))
+    return true;
 
   // We cannot handle IME events if there is any chance that the event we are
   // receiving here from the browser is based on the state that is different
   // from our current one as indicated by |text_input_info_|.
   // The states the browser might be in are:
   // text_input_info_history_[0] - current state ack'd by browser
   // text_input_info_history_[1...N] - pending state changes
   for (size_t i = 0u; i < text_input_info_history_.size() - 1u; ++i) {
     if (text_input_info_history_[i] != text_input_info_)
       return false;
@@ skipping 72 matching lines @@
 }
 
 void RenderWidget::set_next_paint_is_resize_ack() {
   next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_RESIZE_ACK;
 }
 
 void RenderWidget::set_next_paint_is_repaint_ack() {
   next_paint_flags_ |= ViewHostMsg_UpdateRect_Flags::IS_REPAINT_ACK;
 }
 
+bool RenderWidget::IsFromImeDefault() {
+#if defined(OS_ANDROID)
+  // When ChromiumInputConnection is used, we want to make sure that FROM_IME
+  // is set only for OnRequestTextInputStateUpdate() so that we can distinguish
+  // it from other updates so that we can wait for it safely.
+  return !base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kUseImeThread);
+#else
+  return true;

[aelias_OOO_until_Jul13, 2016/01/23 03:21:40]

Let's make this default false on non-Android.  It's no-op anyway (see #if
defined(USE_AURA) clause in UpdateTextInputState).

[Changwan Ryu, 2016/01/26 03:25:29]

Done.

+#endif
+}
+
 void RenderWidget::OnImeEventGuardStart(ImeEventGuard* guard) {
   if (!ime_event_guard_)
     ime_event_guard_ = guard;
 }
 
 void RenderWidget::OnImeEventGuardFinish(ImeEventGuard* guard) {
   if (ime_event_guard_ != guard) {
 #if defined(OS_ANDROID)
     // In case a from-IME event (e.g. touch) ends up in not-from-IME event
     // (e.g. long press gesture), we want to treat it as not-from-IME event
@@ skipping 276 matching lines @@
    STATIC_ASSERT_WTI_ENUM_MATCH(DoubleTapZoom, DOUBLE_TAP_ZOOM);
    STATIC_ASSERT_WTI_ENUM_MATCH(Auto,      AUTO);
 
    content::TouchAction content_touch_action =
        static_cast<content::TouchAction>(web_touch_action);
   Send(new InputHostMsg_SetTouchAction(routing_id_, content_touch_action));
 }
 
 void RenderWidget::didUpdateTextOfFocusedElementByNonUserInput() {
 #if defined(OS_ANDROID)
-  text_field_is_dirty_ = true;
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kUseImeThread))
+    text_field_is_dirty_ = true;
 #endif
 }
 
 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
 RenderWidget::CreateGraphicsContext3D(GpuChannelHost* gpu_channel_host) {
   // Explicitly disable antialiasing for the compositor. As of the time of
   // this writing, the only platform that supported antialiasing for the
   // compositor was Mac OS X, because the on-screen OpenGL context creation
   // code paths on Windows and Linux didn't yet have multisampling support.
   // Mac OS X essentially always behaves as though it's rendering offscreen.
@@ skipping 68 matching lines @@
 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.RemoveObserver(frame);
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content