ui/base/ime/remote_input_method_win.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/base/ime/remote_input_method_win.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/observer_list.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "base/win/metro.h"
  11 #include "base/win/scoped_handle.h"
  12 #include "ui/base/ime/input_method.h"
  13 #include "ui/base/ime/input_method_delegate.h"
  14 #include "ui/base/ime/input_method_observer.h"
  15 #include "ui/base/ime/remote_input_method_delegate_win.h"
  16 #include "ui/base/ime/text_input_client.h"
  17 #include "ui/base/ime/win/tsf_input_scope.h"
  18 #include "ui/base/ui_base_switches.h"
  19 #include "ui/events/event.h"
  20 #include "ui/events/event_utils.h"
  21 #include "ui/gfx/geometry/rect.h"
  22
  23 namespace ui {
  24 namespace {
  25
  26 const LANGID kFallbackLangID =
  27     MAKELANGID(LANG_NEUTRAL, SUBLANG_UI_CUSTOM_DEFAULT);
  28
  29 InputMethod* g_public_interface_ = NULL;
  30 RemoteInputMethodPrivateWin* g_private_interface_ = NULL;
  31
  32 void RegisterInstance(InputMethod* public_interface,
  33                       RemoteInputMethodPrivateWin* private_interface) {
  34   CHECK(g_public_interface_ == NULL)
  35       << "Only one instance is supported at the same time";
  36   CHECK(g_private_interface_ == NULL)
  37       << "Only one instance is supported at the same time";
  38   g_public_interface_ = public_interface;
  39   g_private_interface_ = private_interface;
  40 }
  41
  42 RemoteInputMethodPrivateWin* GetPrivate(InputMethod* public_interface) {
  43   if (g_public_interface_ != public_interface)
  44     return NULL;
  45   return g_private_interface_;
  46 }
  47
  48 void UnregisterInstance(InputMethod* public_interface) {
  49   RemoteInputMethodPrivateWin* private_interface = GetPrivate(public_interface);
  50   if (g_public_interface_ == public_interface &&
  51       g_private_interface_ == private_interface) {
  52     g_public_interface_ = NULL;
  53     g_private_interface_ = NULL;
  54   }
  55 }
  56
  57 std::string GetLocaleString(LCID Locale_id, LCTYPE locale_type) {
  58   wchar_t buffer[16] = {};
  59
  60   //|chars_written| includes NUL terminator.
  61   const int chars_written =
  62       GetLocaleInfo(Locale_id, locale_type, buffer, arraysize(buffer));
  63   if (chars_written <= 1 || arraysize(buffer) < chars_written)
  64     return std::string();
  65   std::string result;
  66   base::WideToUTF8(buffer, chars_written - 1, &result);
  67   return result;
  68 }
  69
  70 std::vector<int32> GetInputScopesAsInt(TextInputType text_input_type,
  71                                        TextInputMode text_input_mode) {
  72   std::vector<int32> result;
  73   // An empty vector represents |text_input_type| is TEXT_INPUT_TYPE_NONE.
  74   if (text_input_type == TEXT_INPUT_TYPE_NONE)
  75     return result;
  76
  77   const std::vector<InputScope>& input_scopes =
  78       tsf_inputscope::GetInputScopes(text_input_type, text_input_mode);
  79   result.reserve(input_scopes.size());
  80   for (size_t i = 0; i < input_scopes.size(); ++i)
  81     result.push_back(static_cast<int32>(input_scopes[i]));
  82   return result;
  83 }
  84
  85 std::vector<gfx::Rect> GetCompositionCharacterBounds(
  86     const TextInputClient* client) {
  87   if (!client)
  88     return std::vector<gfx::Rect>();
  89
  90   std::vector<gfx::Rect> bounds;
  91   if (client->HasCompositionText()) {
  92     gfx::Range range;
  93     if (client->GetCompositionTextRange(&range)) {
  94       for (uint32 i = 0; i < range.length(); ++i) {
  95         gfx::Rect rect;
  96         if (!client->GetCompositionCharacterBounds(i, &rect))
  97           break;
  98         bounds.push_back(rect);
  99       }
 100     }
 101   }
 102
 103   // Use the caret bounds as a fallback if no composition character bounds is
 104   // available. One typical use case is PPAPI Flash, which does not support
 105   // GetCompositionCharacterBounds at all. crbug.com/133472
 106   if (bounds.empty())
 107     bounds.push_back(client->GetCaretBounds());
 108   return bounds;
 109 }
 110
 111 class RemoteInputMethodWin : public InputMethod,
 112                              public RemoteInputMethodPrivateWin {
 113  public:
 114   explicit RemoteInputMethodWin(internal::InputMethodDelegate* delegate)
 115       : delegate_(delegate),
 116         remote_delegate_(NULL),
 117         text_input_client_(NULL),
 118         is_candidate_popup_open_(false),
 119         is_ime_(false),
 120         langid_(kFallbackLangID) {
 121     RegisterInstance(this, this);
 122   }
 123
 124   ~RemoteInputMethodWin() override {
 125     FOR_EACH_OBSERVER(InputMethodObserver,
 126                       observer_list_,
 127                       OnInputMethodDestroyed(this));
 128     UnregisterInstance(this);
 129   }
 130
 131  private:
 132   // Overridden from InputMethod:
 133   void SetDelegate(internal::InputMethodDelegate* delegate) override {
 134     delegate_ = delegate;
 135   }
 136
 137   void OnFocus() override {}
 138
 139   void OnBlur() override {}
 140
 141   bool OnUntranslatedIMEMessage(const base::NativeEvent& event,
 142                                 NativeEventResult* result) override {
 143     return false;
 144   }
 145
 146   void SetFocusedTextInputClient(TextInputClient* client) override {
 147     std::vector<int32> prev_input_scopes;
 148     std::swap(input_scopes_, prev_input_scopes);
 149     std::vector<gfx::Rect> prev_bounds;
 150     std::swap(composition_character_bounds_, prev_bounds);
 151     if (client) {
 152       input_scopes_ = GetInputScopesAsInt(client->GetTextInputType(),
 153                                           client->GetTextInputMode());
 154       composition_character_bounds_ = GetCompositionCharacterBounds(client);
 155     }
 156
 157     const bool text_input_client_changed = text_input_client_ != client;
 158     text_input_client_ = client;
 159     if (text_input_client_changed) {
 160       FOR_EACH_OBSERVER(InputMethodObserver,
 161                         observer_list_,
 162                         OnTextInputStateChanged(client));
 163     }
 164
 165     if (!remote_delegate_ || (prev_input_scopes == input_scopes_ &&
 166                               prev_bounds == composition_character_bounds_))
 167       return;
 168     remote_delegate_->OnTextInputClientUpdated(input_scopes_,
 169                                                composition_character_bounds_);
 170   }
 171
 172   void DetachTextInputClient(TextInputClient* client) override {
 173     if (text_input_client_ != client)
 174       return;
 175     SetFocusedTextInputClient(NULL);
 176   }
 177
 178   TextInputClient* GetTextInputClient() const override {
 179     return text_input_client_;
 180   }
 181
 182   bool DispatchKeyEvent(const ui::KeyEvent& event) override {
 183     if (event.HasNativeEvent()) {
 184       const base::NativeEvent& native_key_event = event.native_event();
 185       if (native_key_event.message != WM_CHAR)
 186         return false;
 187       if (!text_input_client_)
 188         return false;
 189       text_input_client_->InsertChar(
 190           static_cast<base::char16>(native_key_event.wParam),
 191           ui::GetModifiersFromKeyState());
 192       return true;
 193     }
 194
 195     if (event.is_char()) {
 196       if (text_input_client_) {
 197         text_input_client_->InsertChar(
 198             event.GetCharacter(),
 199             ui::GetModifiersFromKeyState());
 200       }
 201       return true;
 202     }
 203     if (!delegate_)
 204       return false;
 205     return delegate_->DispatchKeyEventPostIME(event);
 206   }
 207
 208   void OnTextInputTypeChanged(const TextInputClient* client) override {
 209     if (!text_input_client_ || text_input_client_ != client)
 210       return;
 211     std::vector<int32> prev_input_scopes;
 212     std::swap(input_scopes_, prev_input_scopes);
 213     input_scopes_ = GetInputScopesAsInt(client->GetTextInputType(),
 214                                         client->GetTextInputMode());
 215     if (input_scopes_ != prev_input_scopes && remote_delegate_) {
 216       remote_delegate_->OnTextInputClientUpdated(
 217           input_scopes_, composition_character_bounds_);
 218     }
 219   }
 220
 221   void OnCaretBoundsChanged(const TextInputClient* client) override {
 222     if (!text_input_client_ || text_input_client_ != client)
 223       return;
 224     std::vector<gfx::Rect> prev_rects;
 225     std::swap(composition_character_bounds_, prev_rects);
 226     composition_character_bounds_ = GetCompositionCharacterBounds(client);
 227     if (composition_character_bounds_ != prev_rects && remote_delegate_) {
 228       remote_delegate_->OnTextInputClientUpdated(
 229           input_scopes_, composition_character_bounds_);
 230     }
 231   }
 232
 233   void CancelComposition(const TextInputClient* client) override {
 234     if (CanSendRemoteNotification(client))
 235       remote_delegate_->CancelComposition();
 236   }
 237
 238   void OnInputLocaleChanged() override {}
 239
 240   std::string GetInputLocale() override {
 241     const LCID locale_id = MAKELCID(langid_, SORT_DEFAULT);
 242     std::string language =
 243         GetLocaleString(locale_id, LOCALE_SISO639LANGNAME);
 244     if (SUBLANGID(langid_) == SUBLANG_NEUTRAL || language.empty())
 245       return language;
 246     const std::string& region =
 247         GetLocaleString(locale_id, LOCALE_SISO3166CTRYNAME);
 248     if (region.empty())
 249       return language;
 250     return language.append(1, '-').append(region);
 251   }
 252
 253   TextInputType GetTextInputType() const override {
 254     return text_input_client_ ? text_input_client_->GetTextInputType()
 255                               : TEXT_INPUT_TYPE_NONE;
 256   }
 257
 258   TextInputMode GetTextInputMode() const override {
 259     return text_input_client_ ? text_input_client_->GetTextInputMode()
 260                               : TEXT_INPUT_MODE_DEFAULT;
 261   }
 262
 263   int GetTextInputFlags() const override {
 264     return text_input_client_ ? text_input_client_->GetTextInputFlags()
 265                               : 0;
 266   }
 267
 268   bool CanComposeInline() const override {
 269     return text_input_client_ ? text_input_client_->CanComposeInline() : true;
 270   }
 271
 272   bool IsCandidatePopupOpen() const override {
 273     return is_candidate_popup_open_;
 274   }
 275
 276   void ShowImeIfNeeded() override {}
 277
 278   void AddObserver(InputMethodObserver* observer) override {
 279     observer_list_.AddObserver(observer);
 280   }
 281
 282   void RemoveObserver(InputMethodObserver* observer) override {
 283     observer_list_.RemoveObserver(observer);
 284   }
 285
 286   // Overridden from RemoteInputMethodPrivateWin:
 287   void SetRemoteDelegate(
 288       internal::RemoteInputMethodDelegateWin* delegate) override {
 289     remote_delegate_ = delegate;
 290
 291     // Sync initial state.
 292     if (remote_delegate_) {
 293       remote_delegate_->OnTextInputClientUpdated(
 294           input_scopes_, composition_character_bounds_);
 295     }
 296   }
 297
 298   void OnCandidatePopupChanged(bool visible) override {
 299     is_candidate_popup_open_ = visible;
 300   }
 301
 302   void OnInputSourceChanged(LANGID langid, bool /*is_ime*/) override {
 303     // Note: Currently |is_ime| is not utilized yet.
 304     const bool changed = (langid_ != langid);
 305     langid_ = langid;
 306     if (changed && GetTextInputClient())
 307       GetTextInputClient()->OnInputMethodChanged();
 308   }
 309
 310   void OnCompositionChanged(const CompositionText& composition_text) override {
 311     if (!text_input_client_)
 312       return;
 313     text_input_client_->SetCompositionText(composition_text);
 314   }
 315
 316   void OnTextCommitted(const base::string16& text) override {
 317     if (!text_input_client_)
 318       return;
 319     if (text_input_client_->GetTextInputType() == TEXT_INPUT_TYPE_NONE) {
 320       // According to the comment in text_input_client.h,
 321       // TextInputClient::InsertText should never be called when the
 322       // text input type is TEXT_INPUT_TYPE_NONE.
 323       for (size_t i = 0; i < text.size(); ++i)
 324         text_input_client_->InsertChar(text[i], 0);
 325       return;
 326     }
 327     text_input_client_->InsertText(text);
 328   }
 329
 330   bool CanSendRemoteNotification(
 331       const TextInputClient* text_input_client) const {
 332     return text_input_client_ &&
 333            text_input_client_ == text_input_client &&
 334            remote_delegate_;
 335   }
 336
 337   base::ObserverList<InputMethodObserver> observer_list_;
 338
 339   internal::InputMethodDelegate* delegate_;
 340   internal::RemoteInputMethodDelegateWin* remote_delegate_;
 341
 342   TextInputClient* text_input_client_;
 343   std::vector<int32> input_scopes_;
 344   std::vector<gfx::Rect> composition_character_bounds_;
 345   bool is_candidate_popup_open_;
 346   bool is_ime_;
 347   LANGID langid_;
 348
 349   DISALLOW_COPY_AND_ASSIGN(RemoteInputMethodWin);
 350 };
 351
 352 }  // namespace
 353
 354 bool IsRemoteInputMethodWinRequired(gfx::AcceleratedWidget widget) {
 355   // If the remote input method is already registered then don't do it again.
 356   if (ui::g_public_interface_ && ui::g_private_interface_)
 357     return false;
 358
 359   DWORD process_id = 0;
 360   if (GetWindowThreadProcessId(widget, &process_id) == 0)
 361     return false;
 362   base::win::ScopedHandle process_handle(::OpenProcess(
 363       PROCESS_QUERY_LIMITED_INFORMATION, FALSE, process_id));
 364   if (!process_handle.IsValid())
 365     return false;
 366   return base::win::IsProcessImmersive(process_handle.Get()) ||
 367          base::CommandLine::ForCurrentProcess()->HasSwitch(
 368              switches::kViewerConnect);
 369 }
 370
 371 RemoteInputMethodPrivateWin::RemoteInputMethodPrivateWin() {}
 372
 373 scoped_ptr<InputMethod> CreateRemoteInputMethodWin(
 374     internal::InputMethodDelegate* delegate) {
 375   return make_scoped_ptr(new RemoteInputMethodWin(delegate));
 376 }
 377
 378 // static
 379 RemoteInputMethodPrivateWin* RemoteInputMethodPrivateWin::Get(
 380     InputMethod* input_method) {
 381   return GetPrivate(input_method);
 382 }
 383
 384 }  // namespace ui