IME (input method editor) support for Aura, part 3 of 3: Use ui::InputMethod in ash.

content/browser/renderer_host/render_widget_host_view_aura.cc

 // Copyright (c) 2011 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/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/logging.h"
 #include "content/browser/renderer_host/backing_store_skia.h"
 #include "content/browser/renderer_host/render_widget_host.h"
 #include "content/browser/renderer_host/web_input_event_aura.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/common/gpu/gpu_messages.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositionUnderline.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/tooltip_client.h"
 #include "ui/aura/client/window_types.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/base/hit_test.h"
+#include "ui/base/ime/input_method.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/screen.h"
 
 #if defined(UI_COMPOSITOR_IMAGE_TRANSPORT)
 #include "base/bind.h"
 #include "content/browser/renderer_host/accelerated_surface_container_linux.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #endif
@@ skipping 55 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, public:
 
 RenderWidgetHostViewAura::RenderWidgetHostViewAura(RenderWidgetHost* host)
     : host_(host),
       ALLOW_THIS_IN_INITIALIZER_LIST(window_(new aura::Window(this))),
       is_fullscreen_(false),
       popup_parent_host_view_(NULL),
       is_loading_(false),
+      text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
+      has_composition_text_(false),
 #if defined(UI_COMPOSITOR_IMAGE_TRANSPORT)
       current_surface_(gfx::kNullPluginWindow),
 #endif
       skip_schedule_paint_(false) {
   host_->SetView(this);
   aura::client::SetTooltipText(window_, &tooltip_);
   aura::client::SetActivationDelegate(window_, this);
 }
 
 RenderWidgetHostViewAura::~RenderWidgetHostViewAura() {
@@ skipping 123 matching lines @@
 }
 
 void RenderWidgetHostViewAura::SetIsLoading(bool is_loading) {
   is_loading_ = is_loading;
   UpdateCursorIfOverSelf();
 }
 
 void RenderWidgetHostViewAura::TextInputStateChanged(
     ui::TextInputType type,
     bool can_compose_inline) {
-  // http://crbug.com/102569
-  NOTIMPLEMENTED();
+  // TODO(kinaba): currently, can_compose_inline is ignored and always treated
+  // as true. We need to support "can_compose_inline=false" for PPAPI plugins
+  // that may want to avoid drawing composition-text by themselves and pass
+  // the responsibility to the browser.
+  if (text_input_type_ != type) {
+    text_input_type_ = type;
+    GetInputMethod()->OnTextInputTypeChanged(this);
+  }
 }
 
 void RenderWidgetHostViewAura::ImeCancelComposition() {
-  // http://crbug.com/102569
-  NOTIMPLEMENTED();
+  GetInputMethod()->CancelComposition(this);
+  has_composition_text_ = false;
 }
 
 void RenderWidgetHostViewAura::DidUpdateBackingStore(
     const gfx::Rect& scroll_rect, int scroll_dx, int scroll_dy,
     const std::vector<gfx::Rect>& copy_rects) {
   if (!window_->IsVisible() || skip_schedule_paint_)
     return;
 
   if (!scroll_rect.IsEmpty())
     window_->SchedulePaintInRect(scroll_rect);
@@ skipping 16 matching lines @@
 void RenderWidgetHostViewAura::Destroy() {
   delete window_;
 }
 
 void RenderWidgetHostViewAura::SetTooltipText(const string16& tooltip_text) {
   tooltip_ = tooltip_text;
   if (aura::client::GetTooltipClient())
     aura::client::GetTooltipClient()->UpdateTooltip(window_);
 }
 
+void RenderWidgetHostViewAura::SelectionBoundsChanged(
+    const gfx::Rect& start_rect,
+    const gfx::Rect& end_rect) {
+  if (selection_start_rect_ == start_rect && selection_end_rect_ == end_rect)
+    return;
+
+  selection_start_rect_ = start_rect;
+  selection_end_rect_ = end_rect;
+
+  GetInputMethod()->OnCaretBoundsChanged(this);
+}
+
 BackingStore* RenderWidgetHostViewAura::AllocBackingStore(
     const gfx::Size& size) {
   return new BackingStoreSkia(host_, size);
 }
 
 void RenderWidgetHostViewAura::OnAcceleratedCompositingStateChange() {
   UpdateExternalTexture();
 }
 
 void RenderWidgetHostViewAura::UpdateExternalTexture() {
@@ skipping 161 matching lines @@
   return false;
 }
 
 void RenderWidgetHostViewAura::UnlockMouse() {
   // http://crbug.com/102563
   NOTIMPLEMENTED();
   host_->LostMouseLock();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// RenderWidgetHostViewAura, ui::TextInputClient implementation:
+void RenderWidgetHostViewAura::SetCompositionText(
+    const ui::CompositionText& composition) {
+  if (!host_)
+    return;
+
+  // ui::CompositionUnderline should be identical to
+  // WebKit::WebCompositionUnderline, so that we can do reinterpret_cast safely.
+  COMPILE_ASSERT(sizeof(ui::CompositionUnderline) ==
+                 sizeof(WebKit::WebCompositionUnderline),
+                 ui_CompositionUnderline__WebKit_WebCompositionUnderline_diff);
+
+  // TODO(suzhe): convert both renderer_host and renderer to use
+  // ui::CompositionText.
+  const std::vector<WebKit::WebCompositionUnderline>& underlines =
+      reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
+          composition.underlines);
+
+  // TODO(suzhe): due to a bug of webkit, we can't use selection range with
+  // composition string. See: https://bugs.webkit.org/show_bug.cgi?id=37788
+  host_->ImeSetComposition(composition.text, underlines,
+                           composition.selection.end(),
+                           composition.selection.end());
+
+  has_composition_text_ = !composition.text.empty();
+}
+
+void RenderWidgetHostViewAura::ConfirmCompositionText() {
+  if (host_ && has_composition_text_)
+    host_->ImeConfirmComposition();
+  has_composition_text_ = false;
+}
+
+void RenderWidgetHostViewAura::ClearCompositionText() {
+  if (host_ && has_composition_text_)
+    host_->ImeCancelComposition();
+  has_composition_text_ = false;
+}
+
+void RenderWidgetHostViewAura::InsertText(const string16& text) {
+  DCHECK(text_input_type_ != ui::TEXT_INPUT_TYPE_NONE);
+  if (host_)
+    host_->ImeConfirmComposition(text);
+  has_composition_text_ = false;
+}
+
+void RenderWidgetHostViewAura::InsertChar(char16 ch, int flags) {
+  if (host_) {
+    // Send a WebKit::WebInputEvent::Char event to |host_|.
+    NativeWebKeyboardEvent webkit_event(ui::ET_KEY_PRESSED,
+                                        true /* is_char */,
+                                        ch,
+                                        flags,
+                                        base::Time::Now().ToDoubleT());
+    host_->ForwardKeyboardEvent(webkit_event);
+  }
+}
+
+ui::TextInputType RenderWidgetHostViewAura::GetTextInputType() const {
+  return text_input_type_;
+}
+
+gfx::Rect RenderWidgetHostViewAura::GetCaretBounds() {
+  const gfx::Rect rect = selection_start_rect_.Union(selection_end_rect_);
+  gfx::Point origin = rect.origin();
+  gfx::Point end = gfx::Point(rect.right(), rect.bottom());
+
+  aura::RootWindow* root_window = aura::RootWindow::GetInstance();
+  aura::Window::ConvertPointToWindow(window_, root_window, &origin);
+  aura::Window::ConvertPointToWindow(window_, root_window, &end);
+  // TODO(yusukes): Unlike Chrome OS, |root_window| origin might not be the
+  // same as the system screen origin on Windows and Linux. Probably we should
+  // (implement and) use something like ConvertPointToScreen().
+
+  return gfx::Rect(origin.x(),
+                   origin.y(),
+                   end.x() - origin.x(),
+                   end.y() - origin.y());
+}
+
+bool RenderWidgetHostViewAura::HasCompositionText() {
+  return has_composition_text_;
+}
+
+bool RenderWidgetHostViewAura::GetTextRange(ui::Range* range) {
+  range->set_start(selection_text_offset_);
+  range->set_end(selection_text_offset_ + selection_text_.length());
+  return true;
+}
+
+bool RenderWidgetHostViewAura::GetCompositionTextRange(ui::Range* range) {
+  // TODO(suzhe): implement this method when fixing http://crbug.com/55130.
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool RenderWidgetHostViewAura::GetSelectionRange(ui::Range* range) {
+  range->set_start(selection_range_.start());
+  range->set_end(selection_range_.end());
+  return true;
+}
+
+bool RenderWidgetHostViewAura::SetSelectionRange(const ui::Range& range) {
+  // TODO(suzhe): implement this method when fixing http://crbug.com/55130.
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool RenderWidgetHostViewAura::DeleteRange(const ui::Range& range) {
+  // TODO(suzhe): implement this method when fixing http://crbug.com/55130.
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool RenderWidgetHostViewAura::GetTextFromRange(
+    const ui::Range& range,
+    string16* text) {
+  ui::Range selection_text_range(selection_text_offset_,
+      selection_text_offset_ + selection_text_.length());
+
+  if (!selection_text_range.Contains(range)) {
+    text->clear();
+    return false;
+  }
+  if (selection_text_range.EqualsIgnoringDirection(range)) {
+    // Avoid calling substr whose performance is low.
+    *text = selection_text_;
+  } else {
+    *text = selection_text_.substr(
+        range.GetMin() - selection_text_offset_,
+        range.length());
+  }
+  return true;
+}
+
+void RenderWidgetHostViewAura::OnInputMethodChanged() {
+  if (!host_)
+    return;
+
+  host_->SetInputMethodActive(GetInputMethod()->IsActive());
+
+  // TODO(suzhe): implement the newly added “locale” property of HTML DOM
+  // TextEvent.
+}
+
+bool RenderWidgetHostViewAura::ChangeTextDirectionAndLayoutAlignment(
+      base::i18n::TextDirection direction) {
+  if (!host_)
+    return false;
+  host_->UpdateTextDirection(
+      direction == base::i18n::RIGHT_TO_LEFT ?
+      WebKit::WebTextDirectionRightToLeft :
+      WebKit::WebTextDirectionLeftToRight);
+  host_->NotifyTextDirection();
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, aura::WindowDelegate implementation:
 
 gfx::Size RenderWidgetHostViewAura::GetMinimumSize() const {
   return gfx::Size();
 }
 
 void RenderWidgetHostViewAura::OnBoundsChanged(const gfx::Rect& old_bounds,
                                                const gfx::Rect& new_bounds) {
   // We don't care about this one, we are always sized via SetSize() or
   // SetBounds().
 }
 
 void RenderWidgetHostViewAura::OnFocus() {
   host_->GotFocus();
   host_->SetActive(true);
+
+  ui::InputMethod* input_method = GetInputMethod();
+  if (input_method) {
+    // Ask the system-wide IME to send all TextInputClient messages to |this|
+    // object.
+    input_method->SetFocusedTextInputClient(this);
+    host_->SetInputMethodActive(input_method->IsActive());
+  } else {
+    host_->SetInputMethodActive(false);
+  }
 }
 
 void RenderWidgetHostViewAura::OnBlur() {
   host_->SetActive(false);
   host_->Blur();
+
+  ui::InputMethod* input_method = GetInputMethod();
+  if (input_method) {
+    if (input_method->GetTextInputClient() == this)
+      input_method->SetFocusedTextInputClient(NULL);
+  }
+  host_->SetInputMethodActive(false);
 }
 
 bool RenderWidgetHostViewAura::OnKeyEvent(aura::KeyEvent* event) {
   // We need to handle the Escape key for Pepper Flash.
   if (is_fullscreen_ && event->key_code() == ui::VKEY_ESCAPE) {
     host_->Shutdown();
   } else {
-    NativeWebKeyboardEvent webkit_event(event);
-    host_->ForwardKeyboardEvent(webkit_event);
+    // We don't have to communicate with an input method here.
+    if (!event->HasNativeEvent()) {
+      // Send a fabricated event, which is usually a VKEY_PROCESSKEY IME event.
+      NativeWebKeyboardEvent webkit_event(event->type(),
+                                          false /* is_char */,
+                                          event->GetCharacter(),
+                                          event->flags(),
+                                          base::Time::Now().ToDoubleT());
+      host_->ForwardKeyboardEvent(webkit_event);
+    } else {
+      NativeWebKeyboardEvent webkit_event(event);
+      host_->ForwardKeyboardEvent(webkit_event);
+    }
   }
   return true;
 }
 
 gfx::NativeCursor RenderWidgetHostViewAura::GetCursor(const gfx::Point& point) {
   return current_cursor_.GetNativeCursor();
 }
 
 int RenderWidgetHostViewAura::GetNonClientComponent(
     const gfx::Point& point) const {
   return HTCLIENT;
 }
 
 bool RenderWidgetHostViewAura::OnMouseEvent(aura::MouseEvent* event) {
   if (event->type() == ui::ET_MOUSEWHEEL)
     host_->ForwardWheelEvent(content::MakeWebMouseWheelEvent(event));
   else if (event->type() == ui::ET_SCROLL)
     host_->ForwardWheelEvent(
         content::MakeWebMouseWheelEvent(
             static_cast<aura::ScrollEvent*>(event)));
   else if (CanRendererHandleEvent(event->native_event()))
     host_->ForwardMouseEvent(content::MakeWebMouseEvent(event));
 
   switch (event->type()) {
     case ui::ET_MOUSE_PRESSED:
       window_->SetCapture();
+      // Confirm existing composition text on mouse click events, to make sure
+      // the input caret won't be moved with an ongoing composition text.
+      FinishImeCompositionSession();
       break;
     case ui::ET_MOUSE_RELEASED:
       window_->ReleaseCapture();
       break;
     default:
       break;
   }
 
   // Needed to propagate mouse event to native_tab_contents_view_aura.
   // TODO(pkotwicz): Find a better way of doing this.
@@ skipping 90 matching lines @@
   if (root_window->GetEventHandlerForPoint(screen_point) != window_)
     return;
 
   gfx::NativeCursor cursor = current_cursor_.GetNativeCursor();
   if (is_loading_ && cursor == aura::kCursorPointer)
     cursor = aura::kCursorProgress;
 
   aura::RootWindow::GetInstance()->SetCursor(cursor);
 }
 
+ui::InputMethod* RenderWidgetHostViewAura::GetInputMethod() const {
+  aura::RootWindow* root_window = aura::RootWindow::GetInstance();
+  return reinterpret_cast<ui::InputMethod*>(
+      root_window->GetProperty(aura::client::kRootWindowInputMethod));
+}
+
+void RenderWidgetHostViewAura::FinishImeCompositionSession() {
+  if (!has_composition_text_)
+    return;
+  if (host_)
+    host_->ImeConfirmComposition();
+  ImeCancelComposition();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostView, public:
 
 // static
 void RenderWidgetHostView::GetDefaultScreenInfo(
     WebKit::WebScreenInfo* results) {
   const gfx::Size size = gfx::Screen::GetPrimaryMonitorSize();
   results->rect = WebKit::WebRect(0, 0, size.width(), size.height());
   results->availableRect = results->rect;
   // TODO(derat): Don't hardcode this?
   results->depth = 24;
   results->depthPerComponent = 8;
 }