Enable basic IME functionality under Ash on Windows

win8/metro_driver/chrome_app_view_ash.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 "win8/metro_driver/stdafx.h"
 #include "win8/metro_driver/chrome_app_view_ash.h"
 
 #include <corewindow.h>
 #include <shellapi.h>
 #include <windows.foundation.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/threading/thread.h"
 #include "base/win/metro.h"
 #include "base/win/win_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_sender.h"
 #include "ui/events/gestures/gesture_sequence.h"
 #include "ui/metro_viewer/metro_viewer_messages.h"
 #include "win8/metro_driver/file_picker_ash.h"
+#include "win8/metro_driver/ime/text_service.h"
 #include "win8/metro_driver/metro_driver.h"
 #include "win8/metro_driver/winrt_utils.h"
 #include "win8/viewer/metro_viewer_constants.h"
 
 typedef winfoundtn::ITypedEventHandler<
     winapp::Core::CoreApplicationView*,
     winapp::Activation::IActivatedEventArgs*> ActivatedHandler;
 
 typedef winfoundtn::ITypedEventHandler<
     winui::Core::CoreWindow*,
@@ skipping 120 matching lines @@
       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_OpenURLOnDesktop,
                           OnOpenURLOnDesktop)
       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_SetCursor, OnSetCursor)
       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_DisplayFileOpen,
                           OnDisplayFileOpenDialog)
       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_DisplayFileSaveAs,
                           OnDisplayFileSaveAsDialog)
       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_DisplaySelectFolder,
                           OnDisplayFolderPicker)
       IPC_MESSAGE_HANDLER(MetroViewerHostMsg_SetCursorPos, OnSetCursorPos)
+      IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ImeCancelComposition,
+                          OnImeCancelComposition)
+      IPC_MESSAGE_HANDLER(MetroViewerHostMsg_ImeTextInputClientUpdated,
+                          OnImeTextInputClientChanged)
       IPC_MESSAGE_UNHANDLED(__debugbreak())
     IPC_END_MESSAGE_MAP()
     return true;
   }
 
   virtual void OnChannelError() OVERRIDE {
     DVLOG(1) << "Channel error. Exiting.";
     MetroExit(app_view_->core_window_hwnd());
     // In early Windows 8 versions the code above sometimes fails so we call
     // it a second time with a NULL window which just calls Exit().
@@ skipping 57 matching lines @@
 
   void OnSetCursorPos(int x, int y) {
     VLOG(1) << "In IPC OnSetCursorPos: " << x << ", " << y;
     ui_proxy_->PostTask(
         FROM_HERE,
         base::Bind(&ChromeAppViewAsh::OnSetCursorPos,
                    base::Unretained(app_view_),
                    x, y));
   }
 
+  void OnImeCancelComposition() {
+    ui_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&ChromeAppViewAsh::OnImeCancelComposition,
+                   base::Unretained(app_view_)));
+  }
+
+  void OnImeTextInputClientChanged(
+      const std::vector<int32>& input_scopes,
+      const std::vector<metro_viewer::CharacterBounds>& character_bounds) {
+    ui_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&ChromeAppViewAsh::OnImeUpdateTextInputClient,
+                   base::Unretained(app_view_),
+                   input_scopes,
+                   character_bounds));
+  }
 
   scoped_refptr<base::MessageLoopProxy> ui_proxy_;
   ChromeAppViewAsh* app_view_;
 };
 
 bool WaitForChromeIPCConnection(const std::string& channel_name) {
   int ms_elapsed = 0;
   while (!IPC::Channel::IsNamedServerInitialized(channel_name) &&
          ms_elapsed < 10000) {
     ms_elapsed += 500;
@@ skipping 211 matching lines @@
   window_ = window;
   DVLOG(1) << __FUNCTION__;
 
   // Retrieve the native window handle via the interop layer.
   mswr::ComPtr<ICoreWindowInterop> interop;
   HRESULT hr = window->QueryInterface(interop.GetAddressOf());
   CheckHR(hr);
   hr = interop->get_WindowHandle(&core_window_hwnd_);
   CheckHR(hr);
 
+  text_service_ = metro_driver::CreateTextService(this, core_window_hwnd_);
+
   hr = window_->add_SizeChanged(mswr::Callback<SizeChangedHandler>(
       this, &ChromeAppViewAsh::OnSizeChanged).Get(),
       &sizechange_token_);
   CheckHR(hr);
 
   // Register for pointer and keyboard notifications. We forward
   // them to the browser process via IPC.
   hr = window_->add_PointerMoved(mswr::Callback<PointerEventHandler>(
       this, &ChromeAppViewAsh::OnPointerMoved).Get(),
       &pointermoved_token_);
@@ skipping 127 matching lines @@
   ui_loop_.PostTask(FROM_HERE, base::Bind(&RunMessageLoop, dispatcher.Get()));
   ui_loop_.Run();
 
   DVLOG(0) << "ProcessEvents done, hr=" << hr;
   return hr;
 }
 
 IFACEMETHODIMP
 ChromeAppViewAsh::Uninitialize() {
   DVLOG(1) << __FUNCTION__;
+  text_service_.reset();
   window_ = nullptr;
   view_ = nullptr;
   core_window_hwnd_ = NULL;
   return S_OK;
 }
 
 // static
 HRESULT ChromeAppViewAsh::Unsnap() {
   mswr::ComPtr<winui::ViewManagement::IApplicationViewStatics> view_statics;
   HRESULT hr = winrt_utils::CreateActivationFactory(
@@ skipping 148 matching lines @@
   DVLOG(1) << __FUNCTION__;
   DVLOG(1) << "Success: " << success;
   if (ui_channel_) {
     ui_channel_->Send(new MetroViewerHostMsg_SelectFolderDone(
         success,
         base::FilePath(folder_picker->result())));
   }
   delete folder_picker;
 }
 
+void ChromeAppViewAsh::OnImeCancelComposition() {
+  if (!text_service_)

[ananta, 2013/11/27 20:02:47]

Can text_service_ be NULL here and in other Ime handlers below?

[yukawa, 2013/11/28 06:06:20]

Less likely but Yes. Currently metro_driver::CreateTextService() can return
nullptr to indicate failure.

Another option is implementing a NullTextService or something that does nothing
in practice to ensure that metro_driver::CreateTextService() never returns
non-null object.

Which do you like better?

[ananta, 2013/12/02 23:15:23]

The LOG(ERROR) statements you have in the CreateTextService function should help
here. Ideally I would like a CHECK there at least initially to see how many
failures occur there. 

+    return;
+  text_service_->CancelComposition();
+}
+
+void ChromeAppViewAsh::OnImeUpdateTextInputClient(
+    const std::vector<int32>& input_scopes,
+    const std::vector<metro_viewer::CharacterBounds>& character_bounds) {
+  if (!text_service_)
+    return;
+  text_service_->OnDocumentChanged(input_scopes, character_bounds);
+}
+
+void ChromeAppViewAsh::OnCompositionChanged(
+    const string16& text,
+    int32 selection_start,
+    int32 selection_end,
+    const std::vector<metro_viewer::UnderlineInfo>& underlines) {
+  ui_channel_->Send(new MetroViewerHostMsg_ImeCompositionChanged(
+      text, selection_start, selection_end, underlines));
+}
+
+void ChromeAppViewAsh::OnTextCommitted(const string16& text) {
+  ui_channel_->Send(new MetroViewerHostMsg_ImeTextCommitted(text));
+}
+
 HRESULT ChromeAppViewAsh::OnActivate(
     winapp::Core::ICoreApplicationView*,
     winapp::Activation::IActivatedEventArgs* args) {
   DVLOG(1) << __FUNCTION__;
   // Note: If doing more work in this function, you migth need to call
   // get_PreviousExecutionState() and skip the work if  the result is
   // ApplicationExecutionState_Running and globals.previous_state is too.
   args->get_PreviousExecutionState(&globals.previous_state);
   DVLOG(1) << "Previous Execution State: " << globals.previous_state;
 
@@ skipping 226 matching lines @@
   winui::Core::CoreWindowActivationState state;
   HRESULT hr = args->get_WindowActivationState(&state);
   if (FAILED(hr))
     return hr;
 
   // Treat both full activation (Ash was reopened from the Start Screen or from
   // any other Metro entry point in Windows) and pointer activation (user
   // clicked back in Ash after using another app on another monitor) the same.
   if (state == winui::Core::CoreWindowActivationState_CodeActivated ||
       state == winui::Core::CoreWindowActivationState_PointerActivated) {
+    if (text_service_)
+      text_service_->OnWindowActivated();
     ui_channel_->Send(new MetroViewerHostMsg_WindowActivated());
   }
   return S_OK;
 }
 
 HRESULT ChromeAppViewAsh::HandleSearchRequest(
     winapp::Activation::IActivatedEventArgs* args) {
   mswr::ComPtr<winapp::Activation::ISearchActivatedEventArgs> search_args;
   CheckHR(args->QueryInterface(
           winapp::Activation::IID_ISearchActivatedEventArgs, &search_args));
@@ skipping 90 matching lines @@
   mswr::ComPtr<winapp::Core::ICoreApplicationExit> app_exit;
   CheckHR(core_app.As(&app_exit));
   globals.app_exit = app_exit.Detach();
 }
 
 IFACEMETHODIMP
 ChromeAppViewFactory::CreateView(winapp::Core::IFrameworkView** view) {
   *view = mswr::Make<ChromeAppViewAsh>().Detach();
   return (*view) ? S_OK :  E_OUTOFMEMORY;
 }