Limit display of the virtual keyboard to state changes triggered from a user gesture.

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 337 matching lines @@
       pending_window_rect_count_(0),
       suppress_next_char_events_(false),
       is_accelerated_compositing_active_(false),
       was_accelerated_compositing_ever_active_(false),
       animation_update_pending_(false),
       invalidation_task_posted_(false),
       screen_info_(screen_info),
       device_scale_factor_(screen_info_.deviceScaleFactor),
       is_threaded_compositing_enabled_(false),
       next_output_surface_id_(0),
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(USE_AURA)
       outstanding_ime_acks_(0),
 #endif
       popup_origin_scale_for_emulation_(0.f),
       weak_ptr_factory_(this) {
   if (!swapped_out)
     RenderProcess::current()->AddRefProcess();
   DCHECK(RenderThread::Get());
   has_disable_gpu_vsync_switch_ = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableGpuVsync);
   is_threaded_compositing_enabled_ =
@@ skipping 221 matching lines @@
     IPC_MESSAGE_HANDLER(ViewMsg_ImeConfirmComposition, OnImeConfirmComposition)
     IPC_MESSAGE_HANDLER(ViewMsg_PaintAtSize, OnPaintAtSize)
     IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
     IPC_MESSAGE_HANDLER(ViewMsg_SyntheticGestureCompleted,
                         OnSyntheticGestureCompleted)
     IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
     IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
     IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
 #if defined(OS_ANDROID)
     IPC_MESSAGE_HANDLER(ViewMsg_ShowImeIfNeeded, OnShowImeIfNeeded)
+#endif
+#if defined(OS_ANDROID) || defined(USE_AURA)
     IPC_MESSAGE_HANDLER(ViewMsg_ImeEventAck, OnImeEventAck)
 #endif
     IPC_MESSAGE_HANDLER(ViewMsg_Snapshot, OnSnapshot)
     IPC_MESSAGE_HANDLER(ViewMsg_SetBrowserRenderingStats,
                         OnSetBrowserRenderingStats)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
@@ skipping 518 matching lines @@
       // send us the same kind of event we are delaying the ack for.
       Send(pending_input_event_ack_.release());
     }
     pending_input_event_ack_.reset(response);
     if (compositor_)
       compositor_->NotifyInputThrottledUntilCommit();
   } else {
     Send(response);
   }
 
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(USE_AURA)
   // Allow the IME to be shown when the focus changes as a consequence
   // of a processed touch end event.
   if (input_event->type == WebInputEvent::TouchEnd && processed)
     UpdateTextInputState(true, true);
 #endif
+#if defined(USE_AURA)
+  if (input_event->type == WebInputEvent::MouseUp && processed)
+    UpdateTextInputState(true, true);
+#endif
 
   handling_input_event_ = false;
 
   if (!prevent_default) {
     if (WebInputEvent::isKeyboardEventType(input_event->type))
       DidHandleKeyEvent();
     if (WebInputEvent::isMouseEventType(input_event->type))
       DidHandleMouseEvent(*(static_cast<const WebMouseEvent*>(input_event)));
     if (WebInputEvent::isTouchEventType(input_event->type))
       DidHandleTouchEvent(*(static_cast<const WebTouchEvent*>(input_event)));
@@ skipping 654 matching lines @@
 
 void RenderWidget::willBeginCompositorFrame() {
   TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
 
   DCHECK(RenderThreadImpl::current()->compositor_message_loop_proxy().get());
 
   // The following two can result in further layout and possibly
   // enable GPU acceleration so they need to be called before any painting
   // is done.
   UpdateTextInputType();
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(USE_AURA)
   UpdateTextInputState(false, true);
 #endif
   UpdateSelectionBounds();
 }
 
 void RenderWidget::didBecomeReadyForAdditionalInput() {
   TRACE_EVENT0("renderer", "RenderWidget::didBecomeReadyForAdditionalInput");
   if (pending_input_event_ack_)
     Send(pending_input_event_ack_.release());
 }
@@ skipping 406 matching lines @@
     view_screen_rect_ = view_screen_rect;
     window_screen_rect_ = window_screen_rect;
   }
   Send(new ViewHostMsg_UpdateScreenRects_ACK(routing_id()));
 }
 
 #if defined(OS_ANDROID)
 void RenderWidget::OnShowImeIfNeeded() {
   UpdateTextInputState(true, true);
 }
+#endif
 
+#if defined(OS_ANDROID) || defined(USE_AURA)
 void RenderWidget::IncrementOutstandingImeEventAcks() {
   ++outstanding_ime_acks_;
 }
 
 void RenderWidget::OnImeEventAck() {
   --outstanding_ime_acks_;
   DCHECK(outstanding_ime_acks_ >= 0);
 }
 #endif
 
 bool RenderWidget::ShouldHandleImeEvent() {
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(USE_AURA)
   return !!webwidget_ && outstanding_ime_acks_ == 0;
 #else
   return !!webwidget_;
 #endif
 }
 
 void RenderWidget::SetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor_ == device_scale_factor)
     return;
 
@@ skipping 97 matching lines @@
   handling_ime_event_ = true;
 }
 
 void RenderWidget::FinishHandlingImeEvent() {
   DCHECK(handling_ime_event_);
   handling_ime_event_ = false;
   // 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)
+#if defined(OS_ANDROID) || defined(USE_AURA)
   UpdateTextInputState(false, false);
 #endif
 }
 
 void RenderWidget::UpdateTextInputType() {
   // On Windows, not only an IME but also an on-screen keyboard relies on the
   // latest TextInputType to optimize its layout and functionality. Thus
   // |input_method_is_active_| is no longer an appropriate condition to suppress
   // TextInputTypeChanged IPC on Windows.
   // TODO(yukawa, yoichio): Consider to stop checking |input_method_is_active_|
@@ skipping 20 matching lines @@
     Send(new ViewHostMsg_TextInputTypeChanged(routing_id(),
                                               new_type,
                                               new_mode,
                                               new_can_compose_inline));
     text_input_type_ = new_type;
     can_compose_inline_ = new_can_compose_inline;
     text_input_mode_ = new_mode;
   }
 }
 
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(USE_AURA)
 void RenderWidget::UpdateTextInputState(bool show_ime_if_needed,
                                         bool send_ime_ack) {
   if (handling_ime_event_)
     return;
   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();
 
+  const ui::TextInputMode new_mode = ConvertInputMode(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_if_needed || (text_input_type_ != new_type
       || text_input_info_ != new_info
       || can_compose_inline_ != new_can_compose_inline)) {
     ViewHostMsg_TextInputState_Params p;
     p.type = new_type;
+    p.mode = new_mode;
     p.value = new_info.value.utf8();
     p.selection_start = new_info.selectionStart;
     p.selection_end = new_info.selectionEnd;
     p.composition_start = new_info.compositionStart;
     p.composition_end = new_info.compositionEnd;
     p.can_compose_inline = new_can_compose_inline;
     p.show_ime_if_needed = show_ime_if_needed;
     p.require_ack = send_ime_ack;
     if (p.require_ack)
       IncrementOutstandingImeEventAcks();
@@ skipping 165 matching lines @@
   }
 
 #if defined(OS_MACOSX) || defined(OS_WIN) || defined(USE_AURA)
   UpdateCompositionInfo(true);
 #endif
 }
 
 void RenderWidget::didHandleGestureEvent(
     const WebGestureEvent& event,
     bool event_cancelled) {
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(USE_AURA)
   if (event_cancelled)
     return;
   if (event.type == WebInputEvent::GestureTap ||
       event.type == WebInputEvent::GestureLongPress) {
     UpdateTextInputState(true, true);
   }
 #endif
 }
 
 void RenderWidget::SchedulePluginMove(const WebPluginGeometry& move) {
@@ skipping 157 matching lines @@
           kDefaultCommandBufferSize,
           kDefaultStartTransferBufferSize,
           kDefaultMinTransferBufferSize,
           kDefaultMaxTransferBufferSize,
           mapped_memory_reclaim_limit))
     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
   return context.Pass();
 }
 
 }  // namespace content