Enable basic IME functionality under Ash on Windows

ui/aura/remote_root_window_host_win.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 "ui/aura/remote_root_window_host_win.h"
 
 #include <windows.h>
 
 #include <algorithm>
 
 #include "base/message_loop/message_loop.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sender.h"
+#include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/root_window.h"
+#include "ui/aura/window_property.h"
 #include "ui/base/cursor/cursor_loader_win.h"
+#include "ui/base/ime/composition_text.h"
+#include "ui/base/ime/input_method.h"
+#include "ui/base/ime/remote_input_method_win.h"
+#include "ui/base/ime/text_input_client.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_code_conversion_win.h"
 #include "ui/base/view_prop.h"
 #include "ui/gfx/insets.h"
 #include "ui/metro_viewer/metro_viewer_messages.h"
 
 namespace aura {
 
 namespace {
 
@@ skipping 20 matching lines @@
   SetKeyState(keyboard_state, !!(flags & ui::EF_CAPS_LOCK_DOWN), VK_CAPITAL);
   SetKeyState(keyboard_state, !!(flags & ui::EF_LEFT_MOUSE_BUTTON), VK_LBUTTON);
   SetKeyState(keyboard_state, !!(flags & ui::EF_RIGHT_MOUSE_BUTTON),
               VK_RBUTTON);
   SetKeyState(keyboard_state, !!(flags & ui::EF_MIDDLE_MOUSE_BUTTON),
               VK_MBUTTON);
 
   ::SetKeyboardState(keyboard_state);
 }
 
+void FillCompositionText(
+    const string16& text,
+    int32 selection_start,
+    int32 selection_end,
+    const std::vector<metro_viewer::UnderlineInfo>& underlines,
+    ui::CompositionText* composition_text) {
+  composition_text->Clear();
+  composition_text->text = text;
+  composition_text->selection.set_start(selection_start);
+  composition_text->selection.set_end(selection_end);
+  composition_text->underlines.resize(underlines.size());
+  for (size_t i = 0; i < underlines.size(); ++i) {
+    composition_text->underlines[i].start_offset = underlines[i].start_offset;
+    composition_text->underlines[i].end_offset = underlines[i].end_offset;
+    composition_text->underlines[i].color = SK_ColorBLACK;
+    composition_text->underlines[i].thick = underlines[i].thick;
+  }
+}
+
 }  // namespace
 
 void HandleOpenFile(const base::string16& title,
                     const base::FilePath& default_path,
                     const base::string16& filter,
                     const OpenFileCompletion& on_success,
                     const FileSelectionCanceled& on_failure) {
   DCHECK(aura::RemoteRootWindowHostWin::Instance());
   aura::RemoteRootWindowHostWin::Instance()->HandleOpenFile(title,
                                                             default_path,
@@ skipping 78 matching lines @@
 
 void RemoteRootWindowHostWin::Connected(IPC::Sender* host, HWND remote_window) {
   CHECK(host_ == NULL);
   host_ = host;
   remote_window_ = remote_window;
 }
 
 void RemoteRootWindowHostWin::Disconnected() {
   // Don't CHECK here, Disconnected is called on a channel error which can
   // happen before we're successfully Connected.
+  ui::RemoteInputMethodPrivateWin* remote_input_method_private =
+      GetRemoteInputMethodPrivate();
+  if (remote_input_method_private)
+    remote_input_method_private->SetRemoteDelegate(NULL);
   host_ = NULL;
   remote_window_ = NULL;
 }
 
 bool RemoteRootWindowHostWin::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RemoteRootWindowHostWin, message)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_MouseMoved, OnMouseMoved)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_MouseButton, OnMouseButton)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_KeyDown, OnKeyDown)
@@ skipping 12 matching lines @@
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_FileOpenDone,
                         OnFileOpenDone)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_MultiFileOpenDone,
                         OnMultiFileOpenDone)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_SelectFolderDone,
                         OnSelectFolderDone)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_SetCursorPosAck,
                         OnSetCursorPosAck)
     IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ActivateDesktopDone,
                         OnDesktopActivated)
+    IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ImeCompositionChanged,
+                        OnImeCompositionChanged)
+    IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ImeTextCommitted,
+                        OnImeTextCommitted)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void RemoteRootWindowHostWin::HandleOpenURLOnDesktop(
     const base::FilePath& shortcut,
     const base::string16& url) {
   if (!host_)
     return;
@@ skipping 114 matching lines @@
 }
 
 gfx::AcceleratedWidget RemoteRootWindowHostWin::GetAcceleratedWidget() {
   if (remote_window_)
     return remote_window_;
   // Getting here should only happen for ash_unittests.exe and related code.
   return ::GetDesktopWindow();
 }
 
 void RemoteRootWindowHostWin::Show() {
+  ui::RemoteInputMethodPrivateWin* remote_input_method_private =
+      GetRemoteInputMethodPrivate();
+  if (remote_input_method_private)
+    remote_input_method_private->SetRemoteDelegate(this);
 }
 
 void RemoteRootWindowHostWin::Hide() {
   NOTIMPLEMENTED();
 }
 
 void RemoteRootWindowHostWin::ToggleFullScreen() {
 }
 
 gfx::Rect RemoteRootWindowHostWin::GetBounds() const {
@@ skipping 84 matching lines @@
 }
 
 void RemoteRootWindowHostWin::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
   NOTIMPLEMENTED();
 }
 
 void RemoteRootWindowHostWin::PrepareForShutdown() {
 }
 
+void RemoteRootWindowHostWin::CancelComposition() {
+  host_->Send(new MetroViewerHostMsg_ImeCancelComposition);
+}
+
+void RemoteRootWindowHostWin::OnTextInputClientUpdated(
+    const std::vector<int32>& input_scopes,
+    const std::vector<gfx::Rect>& composition_character_bounds) {
+  std::vector<metro_viewer::CharacterBounds> character_bounds;
+  for (size_t i = 0; i < composition_character_bounds.size(); ++i) {
+    const gfx::Rect& rect = composition_character_bounds[i];
+    metro_viewer::CharacterBounds bounds;
+    bounds.left = rect.x();
+    bounds.top = rect.y();
+    bounds.right = rect.right();
+    bounds.bottom = rect.bottom();
+    character_bounds.push_back(bounds);
+  }
+  host_->Send(new MetroViewerHostMsg_ImeTextInputClientUpdated(
+      input_scopes, character_bounds));
+}
+
 void RemoteRootWindowHostWin::OnMouseMoved(int32 x, int32 y, int32 flags) {
   if (ignore_mouse_moves_until_set_cursor_ack_)
     return;
 
   gfx::Point location(x, y);
   ui::MouseEvent event(ui::ET_MOUSE_MOVED, location, location, flags);
   delegate_->OnHostMouseEvent(&event);
 }
 
 void RemoteRootWindowHostWin::OnMouseButton(
@@ skipping 139 matching lines @@
   DCHECK(ignore_mouse_moves_until_set_cursor_ack_);
   ignore_mouse_moves_until_set_cursor_ack_ = false;
 }
 
 void RemoteRootWindowHostWin::OnDesktopActivated() {
   ActivateDesktopCompleted temp = activate_completed_callback_;
   activate_completed_callback_.Reset();
   temp.Run();
 }
 
+ui::RemoteInputMethodPrivateWin*
+RemoteRootWindowHostWin::GetRemoteInputMethodPrivate() {
+  ui::InputMethod* input_method = GetAshWindow()->GetProperty(
+      aura::client::kRootWindowInputMethodKey);
+  return ui::RemoteInputMethodPrivateWin::Get(input_method);
+}
+
+void RemoteRootWindowHostWin::OnImeCompositionChanged(
+    const string16& text,
+    int32 selection_start,
+    int32 selection_end,
+    const std::vector<metro_viewer::UnderlineInfo>& underlines) {
+  ui::RemoteInputMethodPrivateWin* remote_input_method_private =
+      GetRemoteInputMethodPrivate();
+  if (!remote_input_method_private)
+    return;
+  ui::CompositionText composition_text;
+  FillCompositionText(
+      text, selection_start, selection_end, underlines, &composition_text);
+  remote_input_method_private->OnCompositionChanged(composition_text);
+}
+
+void RemoteRootWindowHostWin::OnImeTextCommitted(const string16& text) {
+  ui::RemoteInputMethodPrivateWin* remote_input_method_private =
+      GetRemoteInputMethodPrivate();
+  if (!remote_input_method_private)
+    return;
+  remote_input_method_private->OnTextCommitted(text);
+}
+
 void RemoteRootWindowHostWin::DispatchKeyboardMessage(ui::EventType type,
                                                       uint32 vkey,
                                                       uint32 repeat_count,
                                                       uint32 scan_code,
                                                       uint32 flags,
                                                       bool is_character) {
   SetEventFlags(flags | mouse_event_flags());
   if (base::MessageLoop::current()->IsNested()) {
     uint32 message = is_character ? WM_CHAR :
         (type == ui::ET_KEY_PRESSED ? WM_KEYDOWN : WM_KEYUP);
@@ skipping 11 matching lines @@
 }
 
 void RemoteRootWindowHostWin::SetEventFlags(uint32 flags) {
   if (flags == event_flags_)
     return;
   event_flags_ = flags;
   SetVirtualKeyStates(event_flags_);
 }
 
 }  // namespace aura