[WIP Approach 1] Straighten up input method reactivation

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 <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 203 matching lines @@
       next_paint_flags_(0),
       auto_resize_mode_(false),
       need_update_rect_for_auto_resize_(false),
       did_show_(false),
       is_hidden_(hidden),
       compositor_never_visible_(never_visible),
       is_fullscreen_granted_(false),
       display_mode_(blink::WebDisplayModeUndefined),
       ime_event_guard_(nullptr),
       ime_in_batch_edit_(false),
+      ime_ignore_until_acked_(false),
       closing_(false),
       host_closing_(false),
       is_swapped_out_(swapped_out),
       for_oopif_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
       text_input_flags_(0),
       can_compose_inline_(true),
       composition_range_(gfx::Range::InvalidRange()),
       popup_type_(popup_type),
@@ skipping 29 matching lines @@
     render_widget_scheduling_state_->SetHidden(is_hidden_);
   }
 }
 
 RenderWidget::~RenderWidget() {
   DCHECK(!webwidget_internal_) << "Leaking our WebWidget!";
 
   // If we are swapped out, we have released already.
   if (!is_swapped_out_ && RenderProcess::current())
     RenderProcess::current()->ReleaseProcess();
+
+  for (size_t i = 0; i < ime_messages_to_send_after_update_.size(); ++i)
+    delete ime_messages_to_send_after_update_[i];
 }
 
 // static
 void RenderWidget::InstallCreateHook(
     CreateRenderWidgetFunction create_render_widget,
     RenderWidgetInitializedCallback render_widget_initialized) {
   CHECK(!g_create_render_widget && !g_render_widget_initialized);
   g_create_render_widget = create_render_widget;
   g_render_widget_initialized = render_widget_initialized;
 }
@@ skipping 605 matching lines @@
   }
 }
 
 void RenderWidget::SetInputHandler(RenderWidgetInputHandler* input_handler) {
   // Nothing to do here. RenderWidget created the |input_handler| and will take
   // ownership of it. We just verify here that we don't already have an input
   // handler.
   DCHECK(!input_handler_);
 }
 
+void RenderWidget::CancelComposition() {
+  ImeEventGuard guard(this);
+  ime_ignore_until_acked_ = true;
+  ime_messages_to_send_after_update_.push_back(
+      new InputHostMsg_ImeCancelComposition(routing_id()));
+}
+
+void RenderWidget::OnFocusedNodeChanged(bool is_editable,
+                                        const gfx::Rect& node_bounds) {
+  ImeEventGuard guard(this);
+  ime_ignore_until_acked_ = true;
+  ime_messages_to_send_after_update_.push_back(
+      new ViewHostMsg_FocusedNodeChanged(
+          routing_id(), is_editable, node_bounds));
+}
+
 void RenderWidget::UpdateTextInputState(ShowIme show_ime,
                                         ChangeSource change_source) {
   TRACE_EVENT0("renderer", "RenderWidget::UpdateTextInputState");
   if (ime_event_guard_) {
     // show_ime should still be effective even if it was set inside the IME
     // event guard.
     if (show_ime == ShowIme::IF_NEEDED) {
       ime_event_guard_->set_show_ime(true);
     }
     return;
@@ skipping 10 matching lines @@
       ConvertWebTextInputMode(new_info.inputMode);
 
   bool new_can_compose_inline = CanComposeInline();
 
   // Only sends text input params if they are changed or if the ime should be
   // shown.
   if (show_ime == ShowIme::IF_NEEDED ||
       (IsUsingImeThread() && 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)
+       can_compose_inline_ != new_can_compose_inline) || ime_ignore_until_acked_
 #if defined(OS_ANDROID)
       || text_field_is_dirty_
 #endif
       ) {
     TextInputState params;
     params.type = new_type;
     params.mode = new_mode;
     params.flags = new_info.flags;
     params.value = new_info.value.utf8();
     params.selection_start = new_info.selectionStart;
     params.selection_end = new_info.selectionEnd;
     params.composition_start = new_info.compositionStart;
     params.composition_end = new_info.compositionEnd;
     params.can_compose_inline = new_can_compose_inline;
     params.show_ime_if_needed = (show_ime == ShowIme::IF_NEEDED);
 #if defined(USE_AURA)
     params.is_non_ime_change = true;
 #endif
 #if defined(OS_ANDROID)
     params.is_non_ime_change =
         (change_source == ChangeSource::FROM_NON_IME) || text_field_is_dirty_;
     params.batch_edit = ime_in_batch_edit_;
-    if (params.is_non_ime_change)
+    if (ime_ignore_until_acked_ ||
+        (!IsUsingImeThread() && params.is_non_ime_change)) {
+      params.requires_ack = true;
       OnImeEventSentForAck(new_info);
+      ime_ignore_until_acked_ = false;
+    }
     text_field_is_dirty_ = false;
 #endif
     Send(new ViewHostMsg_TextInputStateChanged(routing_id(), params));
 
     text_input_info_ = new_info;
     text_input_type_ = new_type;
     text_input_mode_ = new_mode;
     can_compose_inline_ = new_can_compose_inline;
     text_input_flags_ = new_info.flags;
   }
+
+  for (size_t i = 0; i < ime_messages_to_send_after_update_.size(); ++i)
+    Send(ime_messages_to_send_after_update_[i]);
+
+  ime_messages_to_send_after_update_.clear();
 }
 
 bool RenderWidget::WillHandleGestureEvent(const blink::WebGestureEvent& event) {
   if (owner_delegate_)
     return owner_delegate_->RenderWidgetWillHandleGestureEvent(event);
 
   return false;
 }
 
 bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
@@ skipping 422 matching lines @@
 
   if (!ShouldHandleImeEvent())
     return;
   ImeEventGuard guard(this);
   if (!GetWebWidget()->setComposition(
           text, WebVector<WebCompositionUnderline>(underlines), selection_start,
           selection_end)) {
     // If we failed to set the composition text, then we need to let the browser
     // process to cancel the input method's ongoing composition session, to make
     // sure we are in a consistent state.
-    Send(new InputHostMsg_ImeCancelComposition(routing_id()));
+    CancelComposition();
   }
   UpdateCompositionInfo(false /* not an immediate request */);
 }
 
 void RenderWidget::OnImeCommitText(const base::string16& text,
                                    const gfx::Range& replacement_range,
                                    int relative_cursor_pos) {
 #if defined(ENABLE_PLUGINS)
   if (focused_pepper_plugin_) {
     focused_pepper_plugin_->render_frame()->OnImeCommitText(
@@ skipping 212 matching lines @@
   monitor_composition_info_ = monitor_request;
   if (!immediate_request)
     return;
   UpdateCompositionInfo(true /* immediate request */);
 }
 
 bool RenderWidget::ShouldHandleImeEvent() {
 #if defined(OS_ANDROID)
   if (!GetWebWidget())
     return false;
-  if (IsUsingImeThread())
-    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 102 matching lines @@
         ime_event_guard_->from_ime() && guard->from_ime());
 #endif
     return;
   }
   ime_event_guard_ = nullptr;
 
   // While handling an ime event, text input state and selection bounds updates
   // are ignored. These must explicitly be updated once finished handling the
   // ime event.
   UpdateSelectionBounds();
-#if defined(OS_ANDROID)
   UpdateTextInputState(
       guard->show_ime() ? ShowIme::IF_NEEDED : ShowIme::HIDE_IME,
       guard->from_ime() ? ChangeSource::FROM_IME : ChangeSource::FROM_NON_IME);
-#endif
 }
 
 void RenderWidget::GetSelectionBounds(gfx::Rect* focus, gfx::Rect* anchor) {
 #if defined(ENABLE_PLUGINS)
   if (focused_pepper_plugin_) {
     // TODO(kinaba) http://crbug.com/101101
     // Current Pepper IME API does not handle selection bounds. So we simply
     // use the caret position as an empty range for now. It will be updated
     // after Pepper API equips features related to surrounding text retrieval.
     blink::WebRect caret(focused_pepper_plugin_->GetCaretBounds());
@@ skipping 169 matching lines @@
   return web_screen_info;
 }
 
 void RenderWidget::resetInputMethod() {
   ImeEventGuard guard(this);
   // If the last text input type is not None, then we should finish any
   // ongoing composition regardless of the new text input type.
   if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE) {
     // If a composition text exists, then we need to let the browser process
     // to cancel the input method's ongoing composition session.
-    if (GetWebWidget()->finishComposingText(WebWidget::DoNotKeepSelection))
-      Send(new InputHostMsg_ImeCancelComposition(routing_id()));
+    if (GetWebWidget()->finishComposingText(WebWidget::DoNotKeepSelection)) {
+      CancelComposition();
+    }
   }
 
   UpdateCompositionInfo(false /* not an immediate request */);
 }
 
 #if defined(OS_ANDROID)
 void RenderWidget::showUnhandledTapUIIfNeeded(
     const WebPoint& tapped_position,
     const WebNode& tapped_node,
     bool page_changed) {
@@ skipping 120 matching lines @@
 bool RenderWidget::isPointerLocked() {
   return mouse_lock_dispatcher_->IsMouseLockedTo(
       webwidget_mouse_lock_target_.get());
 }
 
 blink::WebWidget* RenderWidget::GetWebWidget() const {
   return webwidget_internal_;
 }
 
 }  // namespace content