Adding missing UpdateTextInputState calls after each ime event.

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 128 matching lines @@
       update_reply_pending_(false),
       need_update_rect_for_auto_resize_(false),
       using_asynchronous_swapbuffers_(false),
       num_swapbuffers_complete_pending_(0),
       did_show_(false),
       is_hidden_(false),
       is_fullscreen_(false),
       needs_repainting_on_restore_(false),
       has_focus_(false),
       handling_input_event_(false),
+      handling_ime_event_(false),
       closing_(false),
       is_swapped_out_(swapped_out),
       input_method_is_active_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       can_compose_inline_(true),
       popup_type_(popup_type),
       pending_window_rect_count_(0),
       suppress_next_char_events_(false),
       is_accelerated_compositing_active_(false),
       animation_update_pending_(false),
@@ skipping 1175 matching lines @@
 }
 
 void RenderWidget::willBeginCompositorFrame() {
   TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
 
   DCHECK(RenderThreadImpl::current()->compositor_thread());
 
   // The following two can result in further layout and possibly
   // enable GPU acceleration so they need to be called before any painting
   // is done.
-#if !defined(OS_ANDROID)
   UpdateTextInputState(DO_NOT_SHOW_IME);
-#endif  // OS_ANDROID
   UpdateSelectionBounds();
 
   WillInitiatePaint();
 }
 
 void RenderWidget::didBecomeReadyForAdditionalInput() {
   TRACE_EVENT0("renderer", "RenderWidget::didBecomeReadyForAdditionalInput");
   if (pending_input_event_ack_.get())
     Send(pending_input_event_ack_.release());
 }
@@ skipping 197 matching lines @@
   Send(new ViewHostMsg_ImeCompositionRangeChanged(
       routing_id(), composition_range_, composition_character_bounds_));
 }
 
 void RenderWidget::OnImeSetComposition(
     const string16& text,
     const std::vector<WebCompositionUnderline>& underlines,
     int selection_start, int selection_end) {
   if (!webwidget_)
     return;
+  handling_ime_event_ = true;

[jamesr, 2013/02/12 22:54:34]

can you put an RAII object on the stack to be responsible for resetting this?
this function is fairly long and it'd be somewhat easy for someone to add an
early return and accidentally break it.  perhaps DCHECK(!handling_ime_event_)
and then use a base::AutoReset<bool> would do the trick?

[aurimas (slooooooooow), 2013/02/13 00:35:51]

Done.

   if (webwidget_->setComposition(
       text, WebVector<WebCompositionUnderline>(underlines),
       selection_start, selection_end)) {
     // Setting the IME composition was successful. Send the new composition
     // range to the browser.
     ui::Range range(ui::Range::InvalidRange());
     size_t location, length;
     if (webwidget_->compositionRange(&location, &length)) {
       range.set_start(location);
       range.set_end(location + length);
@@ skipping 14 matching lines @@
 
     // Send an updated IME range with just the caret range.
     ui::Range range(ui::Range::InvalidRange());
     size_t location, length;
     if (webwidget_->caretOrSelectionRange(&location, &length)) {
       range.set_start(location);
       range.set_end(location + length);
     }
     UpdateCompositionInfo(range, std::vector<gfx::Rect>());
   }
+  handling_ime_event_ = false;
+  UpdateTextInputState(DO_NOT_SHOW_IME);
 }
 
 void RenderWidget::OnImeConfirmComposition(
     const string16& text, const ui::Range& replacement_range) {
   if (!webwidget_)
     return;
-
+  handling_ime_event_ = true;
   handling_input_event_ = true;
   webwidget_->confirmComposition(text);
   handling_input_event_ = false;
 
   // Send an updated IME range with just the caret range.
   ui::Range range(ui::Range::InvalidRange());
   size_t location, length;
   if (webwidget_->caretOrSelectionRange(&location, &length)) {
     range.set_start(location);
     range.set_end(location + length);
   }
+  handling_ime_event_ = false;
   UpdateCompositionInfo(range, std::vector<gfx::Rect>());
+  UpdateTextInputState(DO_NOT_SHOW_IME);
 }
 
 // This message causes the renderer to render an image of the
 // desired_size, regardless of whether the tab is hidden or not.
 void RenderWidget::OnPaintAtSize(const TransportDIB::Handle& dib_handle,
                                  int tag,
                                  const gfx::Size& page_size,
                                  const gfx::Size& desired_size) {
   if (!webwidget_ || !TransportDIB::is_valid_handle(dib_handle)) {
     if (TransportDIB::is_valid_handle(dib_handle)) {
@@ skipping 205 matching lines @@
   return type == ui::TEXT_INPUT_TYPE_DATE ||
       type == ui::TEXT_INPUT_TYPE_DATE_TIME ||
       type == ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL ||
       type == ui::TEXT_INPUT_TYPE_MONTH ||
       type == ui::TEXT_INPUT_TYPE_TIME ||
       type == ui::TEXT_INPUT_TYPE_WEEK;
 }
 
 
 void RenderWidget::UpdateTextInputState(ShowIme show_ime) {
+  if (handling_ime_event_)
+    return;
   bool show_ime_if_needed = (show_ime == SHOW_IME_IF_NEEDED);
   if (!show_ime_if_needed && !input_method_is_active_)
     return;
   ui::TextInputType new_type = GetTextInputType();
   if (IsDateTimeInput(new_type))
     return;  // Not considered as a text input field in WebKit/Chromium.
 
   WebKit::WebTextInputInfo new_info;
   if (webwidget_)
     new_info = webwidget_->textInputInfo();
@@ skipping 247 matching lines @@
 bool RenderWidget::WillHandleGestureEvent(
     const WebKit::WebGestureEvent& event) {
   return false;
 }
 
 bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
   return true;
 }
 
 }  // namespace content