chrome/browser/chromeos/input_method/input_method_manager_impl.cc

   1 // Copyright (c) 2012 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 "chrome/browser/chromeos/input_method/input_method_manager_impl.h"
   6
   7 #include <algorithm>  // std::find
   8
   9 #include <sstream>
  10
  11 #include "base/basictypes.h"
  12 #include "base/bind.h"
  13 #include "base/location.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/metrics/histogram.h"
  16 #include "base/metrics/sparse_histogram.h"
  17 #include "base/prefs/pref_service.h"
  18 #include "base/strings/string_split.h"
  19 #include "base/strings/string_util.h"
  20 #include "base/strings/stringprintf.h"
  21 #include "base/sys_info.h"
  22 #include "chrome/browser/browser_process.h"
  23 #include "chrome/browser/chromeos/input_method/candidate_window_controller.h"
  24 #include "chrome/browser/chromeos/input_method/component_extension_ime_manager_impl.h"
  25 #include "chrome/browser/chromeos/input_method/input_method_engine.h"
  26 #include "chrome/browser/chromeos/input_method/input_method_switch_recorder.h"
  27 #include "chrome/browser/chromeos/language_preferences.h"
  28 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
  29 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  30 #include "chrome/browser/profiles/profile_manager.h"
  31 #include "chrome/common/pref_names.h"
  32 #include "components/user_manager/user_manager.h"
  33 #include "third_party/icu/source/common/unicode/uloc.h"
  34 #include "ui/base/accelerators/accelerator.h"
  35 #include "ui/base/ime/chromeos/component_extension_ime_manager.h"
  36 #include "ui/base/ime/chromeos/extension_ime_util.h"
  37 #include "ui/base/ime/chromeos/fake_ime_keyboard.h"
  38 #include "ui/base/ime/chromeos/ime_keyboard.h"
  39 #include "ui/base/ime/chromeos/input_method_delegate.h"
  40 #include "ui/chromeos/ime/input_method_menu_item.h"
  41 #include "ui/chromeos/ime/input_method_menu_manager.h"
  42 #include "ui/keyboard/keyboard_controller.h"
  43 #include "ui/keyboard/keyboard_util.h"
  44
  45 namespace chromeos {
  46 namespace input_method {
  47
  48 namespace {
  49
  50 bool Contains(const std::vector<std::string>& container,
  51               const std::string& value) {
  52   return std::find(container.begin(), container.end(), value) !=
  53       container.end();
  54 }
  55
  56 enum InputMethodCategory {
  57   INPUT_METHOD_CATEGORY_UNKNOWN = 0,
  58   INPUT_METHOD_CATEGORY_XKB,  // XKB input methods
  59   INPUT_METHOD_CATEGORY_ZH,   // Chinese input methods
  60   INPUT_METHOD_CATEGORY_JA,   // Japanese input methods
  61   INPUT_METHOD_CATEGORY_KO,   // Korean input methods
  62   INPUT_METHOD_CATEGORY_M17N, // Multilingualization input methods
  63   INPUT_METHOD_CATEGORY_T13N, // Transliteration input methods
  64   INPUT_METHOD_CATEGORY_MAX
  65 };
  66
  67 InputMethodCategory GetInputMethodCategory(const std::string& input_method_id,
  68                                            char* first_char = NULL) {
  69   const std::string component_id =
  70       extension_ime_util::GetComponentIDByInputMethodID(input_method_id);
  71   InputMethodCategory category = INPUT_METHOD_CATEGORY_UNKNOWN;
  72   char ch = 0;
  73   if (StartsWithASCII(component_id, "xkb:", true)) {
  74     ch = component_id[4];
  75     category = INPUT_METHOD_CATEGORY_XKB;
  76   } else if (StartsWithASCII(component_id, "zh-", true)) {
  77     size_t pos = component_id.find("-t-i0-");
  78     if (pos > 0)
  79       pos += 6;
  80     ch = component_id[pos];
  81     category = INPUT_METHOD_CATEGORY_ZH;
  82   } else if (StartsWithASCII(component_id, "nacl_mozc_", true)) {
  83     ch = component_id[10];
  84     category = INPUT_METHOD_CATEGORY_JA;
  85   } else if (StartsWithASCII(component_id, "hangul_", true)) {
  86     ch = component_id[7];
  87     category = INPUT_METHOD_CATEGORY_KO;
  88   } else if (StartsWithASCII(component_id, "vkd_", true)) {
  89     ch = component_id[4];
  90     category = INPUT_METHOD_CATEGORY_M17N;
  91   } else if (component_id.find("-t-i0-") > 0) {
  92     ch = component_id[0];
  93     category = INPUT_METHOD_CATEGORY_T13N;
  94   }
  95
  96   if (first_char)
  97     *first_char = ch;
  98   return category;
  99 }
 100
 101 }  // namespace
 102
 103 // ------------------------ InputMethodManagerImpl::StateImpl
 104
 105 InputMethodManagerImpl::StateImpl::StateImpl(InputMethodManagerImpl* manager,
 106                                              Profile* profile)
 107     : profile(profile), manager_(manager) {
 108 }
 109
 110 InputMethodManagerImpl::StateImpl::~StateImpl() {
 111 }
 112
 113 void InputMethodManagerImpl::StateImpl::InitFrom(const StateImpl& other) {
 114   previous_input_method = other.previous_input_method;
 115   current_input_method = other.current_input_method;
 116
 117   active_input_method_ids = other.active_input_method_ids;
 118
 119   pending_input_method_id = other.pending_input_method_id;
 120
 121   enabled_extension_imes = other.enabled_extension_imes;
 122   extra_input_methods = other.extra_input_methods;
 123 }
 124
 125 bool InputMethodManagerImpl::StateImpl::IsActive() const {
 126   return manager_->state_.get() == this;
 127 }
 128
 129 std::string InputMethodManagerImpl::StateImpl::Dump() const {
 130   std::ostringstream os;
 131
 132   os << "################# "
 133      << (profile ? profile->GetProfileUserName() : std::string("NULL"))
 134      << " #################\n";
 135
 136   os << "previous_input_method: '"
 137      << previous_input_method.GetPreferredKeyboardLayout() << "'\n";
 138   os << "current_input_method: '"
 139      << current_input_method.GetPreferredKeyboardLayout() << "'\n";
 140   os << "active_input_method_ids (size=" << active_input_method_ids.size()
 141      << "):";
 142   for (size_t i = 0; i < active_input_method_ids.size(); ++i) {
 143     os << " '" << active_input_method_ids[i] << "',";
 144   }
 145   os << "\n";
 146   os << "enabled_extension_imes (size=" << enabled_extension_imes.size()
 147      << "):";
 148   for (size_t i = 0; i < enabled_extension_imes.size(); ++i) {
 149     os << " '" << enabled_extension_imes[i] << "'\n";
 150   }
 151   os << "\n";
 152   os << "extra_input_methods (size=" << extra_input_methods.size() << "):";
 153   for (std::map<std::string, InputMethodDescriptor>::const_iterator it =
 154            extra_input_methods.begin();
 155        it != extra_input_methods.end();
 156        ++it) {
 157     os << " '" << it->first << "' => '" << it->second.id() << "',\n";
 158   }
 159   os << "pending_input_method_id: '" << pending_input_method_id << "'\n";
 160
 161   return os.str();
 162 }
 163
 164 scoped_refptr<InputMethodManager::State>
 165 InputMethodManagerImpl::StateImpl::Clone() const {
 166   scoped_refptr<StateImpl> new_state(new StateImpl(this->manager_, profile));
 167   new_state->InitFrom(*this);
 168   return scoped_refptr<InputMethodManager::State>(new_state.get());
 169 }
 170
 171 scoped_ptr<InputMethodDescriptors>
 172 InputMethodManagerImpl::StateImpl::GetActiveInputMethods() const {
 173   scoped_ptr<InputMethodDescriptors> result(new InputMethodDescriptors);
 174   // Build the active input method descriptors from the active input
 175   // methods cache |active_input_method_ids|.
 176   for (size_t i = 0; i < active_input_method_ids.size(); ++i) {
 177     const std::string& input_method_id = active_input_method_ids[i];
 178     const InputMethodDescriptor* descriptor =
 179         manager_->util_.GetInputMethodDescriptorFromId(input_method_id);
 180     if (descriptor) {
 181       result->push_back(*descriptor);
 182     } else {
 183       std::map<std::string, InputMethodDescriptor>::const_iterator ix =
 184           extra_input_methods.find(input_method_id);
 185       if (ix != extra_input_methods.end())
 186         result->push_back(ix->second);
 187       else
 188         DVLOG(1) << "Descriptor is not found for: " << input_method_id;
 189     }
 190   }
 191   if (result->empty()) {
 192     // Initially |active_input_method_ids| is empty. browser_tests might take
 193     // this path.
 194     result->push_back(
 195         InputMethodUtil::GetFallbackInputMethodDescriptor());
 196   }
 197   return result.Pass();
 198 }
 199
 200 const std::vector<std::string>&
 201 InputMethodManagerImpl::StateImpl::GetActiveInputMethodIds() const {
 202   return active_input_method_ids;
 203 }
 204
 205 size_t InputMethodManagerImpl::StateImpl::GetNumActiveInputMethods() const {
 206   return active_input_method_ids.size();
 207 }
 208
 209 const InputMethodDescriptor*
 210 InputMethodManagerImpl::StateImpl::GetInputMethodFromId(
 211     const std::string& input_method_id) const {
 212   const InputMethodDescriptor* ime =
 213       manager_->util_.GetInputMethodDescriptorFromId(input_method_id);
 214   if (!ime) {
 215     std::map<std::string, InputMethodDescriptor>::const_iterator ix =
 216         extra_input_methods.find(input_method_id);
 217     if (ix != extra_input_methods.end())
 218       ime = &ix->second;
 219   }
 220   return ime;
 221 }
 222
 223 void InputMethodManagerImpl::StateImpl::EnableLoginLayouts(
 224     const std::string& language_code,
 225     const std::vector<std::string>& initial_layouts) {
 226   if (manager_->ui_session_ == STATE_TERMINATING)
 227     return;
 228
 229   // First, hardware keyboard layout should be shown.
 230   std::vector<std::string> candidates =
 231       manager_->util_.GetHardwareLoginInputMethodIds();
 232
 233   // Second, locale based input method should be shown.
 234   // Add input methods associated with the language.
 235   std::vector<std::string> layouts_from_locale;
 236   manager_->util_.GetInputMethodIdsFromLanguageCode(
 237       language_code, kKeyboardLayoutsOnly, &layouts_from_locale);
 238   candidates.insert(candidates.end(), layouts_from_locale.begin(),
 239                     layouts_from_locale.end());
 240
 241   std::vector<std::string> layouts;
 242   // First, add the initial input method ID, if it's requested, to
 243   // layouts, so it appears first on the list of active input
 244   // methods at the input language status menu.
 245   for (size_t i = 0; i < initial_layouts.size(); ++i) {
 246     if (manager_->util_.IsValidInputMethodId(initial_layouts[i])) {
 247       if (manager_->IsLoginKeyboard(initial_layouts[i])) {
 248         layouts.push_back(initial_layouts[i]);
 249       } else {
 250         DVLOG(1)
 251             << "EnableLoginLayouts: ignoring non-login initial keyboard layout:"
 252             << initial_layouts[i];
 253       }
 254     } else if (!initial_layouts[i].empty()) {
 255       DVLOG(1) << "EnableLoginLayouts: ignoring non-keyboard or invalid ID: "
 256                << initial_layouts[i];
 257     }
 258   }
 259
 260   // Add candidates to layouts, while skipping duplicates.
 261   for (size_t i = 0; i < candidates.size(); ++i) {
 262     const std::string& candidate = candidates[i];
 263     // Not efficient, but should be fine, as the two vectors are very
 264     // short (2-5 items).
 265     if (!Contains(layouts, candidate) && manager_->IsLoginKeyboard(candidate))
 266       layouts.push_back(candidate);
 267   }
 268
 269   manager_->MigrateInputMethods(&layouts);
 270   active_input_method_ids.swap(layouts);
 271
 272   if (IsActive()) {
 273     // Initialize candidate window controller and widgets such as
 274     // candidate window, infolist and mode indicator.  Note, mode
 275     // indicator is used by only keyboard layout input methods.
 276     if (active_input_method_ids.size() > 1)
 277       manager_->MaybeInitializeCandidateWindowController();
 278
 279     // you can pass empty |initial_layout|.
 280     ChangeInputMethod(initial_layouts.empty()
 281                           ? std::string()
 282                           : extension_ime_util::GetInputMethodIDByEngineID(
 283                                 initial_layouts[0]),
 284                       false);
 285   }
 286 }
 287
 288 void InputMethodManagerImpl::StateImpl::EnableLockScreenLayouts() {
 289   std::set<std::string> added_ids;
 290
 291   const std::vector<std::string>& hardware_keyboard_ids =
 292       manager_->util_.GetHardwareLoginInputMethodIds();
 293
 294   std::vector<std::string> new_active_input_method_ids;
 295   for (size_t i = 0; i < active_input_method_ids.size(); ++i) {
 296     const std::string& input_method_id = active_input_method_ids[i];
 297     // Skip if it's not a keyboard layout. Drop input methods including
 298     // extension ones.
 299     if (!manager_->IsLoginKeyboard(input_method_id) ||
 300         added_ids.count(input_method_id)) {
 301       continue;
 302     }
 303     new_active_input_method_ids.push_back(input_method_id);
 304     added_ids.insert(input_method_id);
 305   }
 306
 307   // We'll add the hardware keyboard if it's not included in
 308   // |active_input_method_ids| so that the user can always use the hardware
 309   // keyboard on the screen locker.
 310   for (size_t i = 0; i < hardware_keyboard_ids.size(); ++i) {
 311     if (added_ids.count(hardware_keyboard_ids[i]))
 312       continue;
 313     new_active_input_method_ids.push_back(hardware_keyboard_ids[i]);
 314     added_ids.insert(hardware_keyboard_ids[i]);
 315   }
 316
 317   active_input_method_ids.swap(new_active_input_method_ids);
 318
 319   // Re-check current_input_method.
 320   ChangeInputMethod(current_input_method.id(), false);
 321 }
 322
 323 // Adds new input method to given list.
 324 bool InputMethodManagerImpl::StateImpl::EnableInputMethodImpl(
 325     const std::string& input_method_id,
 326     std::vector<std::string>* new_active_input_method_ids) const {
 327   DCHECK(new_active_input_method_ids);
 328   if (!manager_->util_.IsValidInputMethodId(input_method_id)) {
 329     DVLOG(1) << "EnableInputMethod: Invalid ID: " << input_method_id;
 330     return false;
 331   }
 332
 333   if (!Contains(*new_active_input_method_ids, input_method_id))
 334     new_active_input_method_ids->push_back(input_method_id);
 335
 336   return true;
 337 }
 338
 339 bool InputMethodManagerImpl::StateImpl::EnableInputMethod(
 340     const std::string& input_method_id) {
 341   if (!EnableInputMethodImpl(input_method_id, &active_input_method_ids))
 342     return false;
 343
 344   manager_->ReconfigureIMFramework(this);
 345   return true;
 346 }
 347
 348 bool InputMethodManagerImpl::StateImpl::ReplaceEnabledInputMethods(
 349     const std::vector<std::string>& new_active_input_method_ids) {
 350   if (manager_->ui_session_ == STATE_TERMINATING)
 351     return false;
 352
 353   // Filter unknown or obsolete IDs.
 354   std::vector<std::string> new_active_input_method_ids_filtered;
 355
 356   for (size_t i = 0; i < new_active_input_method_ids.size(); ++i)
 357     EnableInputMethodImpl(new_active_input_method_ids[i],
 358                           &new_active_input_method_ids_filtered);
 359
 360   if (new_active_input_method_ids_filtered.empty()) {
 361     DVLOG(1) << "ReplaceEnabledInputMethods: No valid input method ID";
 362     return false;
 363   }
 364
 365   // Copy extension IDs to |new_active_input_method_ids_filtered|. We have to
 366   // keep relative order of the extension input method IDs.
 367   for (size_t i = 0; i < active_input_method_ids.size(); ++i) {
 368     const std::string& input_method_id = active_input_method_ids[i];
 369     if (extension_ime_util::IsExtensionIME(input_method_id))
 370       new_active_input_method_ids_filtered.push_back(input_method_id);
 371   }
 372   active_input_method_ids.swap(new_active_input_method_ids_filtered);
 373   manager_->MigrateInputMethods(&active_input_method_ids);
 374
 375   manager_->ReconfigureIMFramework(this);
 376
 377   // If |current_input_method| is no longer in |active_input_method_ids|,
 378   // ChangeInputMethod() picks the first one in |active_input_method_ids|.
 379   ChangeInputMethod(current_input_method.id(), false);
 380
 381   // Record histogram for active input method count.
 382   UMA_HISTOGRAM_COUNTS("InputMethod.ActiveCount",
 383                        active_input_method_ids.size());
 384
 385   return true;
 386 }
 387
 388 void InputMethodManagerImpl::StateImpl::ChangeInputMethod(
 389     const std::string& input_method_id,
 390     bool show_message) {
 391   if (manager_->ui_session_ == STATE_TERMINATING)
 392     return;
 393
 394   bool notify_menu = false;
 395
 396   // Always lookup input method, even if it is the same as
 397   // |current_input_method| because If it is no longer in
 398   // |active_input_method_ids|, pick the first one in
 399   // |active_input_method_ids|.
 400   const InputMethodDescriptor* descriptor =
 401       manager_->LookupInputMethod(input_method_id, this);
 402   if (!descriptor) {
 403     descriptor = manager_->LookupInputMethod(
 404         manager_->util_.MigrateInputMethod(input_method_id), this);
 405     if (!descriptor)
 406       return;
 407   }
 408
 409   // For 3rd party IME, when the user just logged in, SetEnabledExtensionImes
 410   // happens after activating the 3rd party IME.
 411   // So here to record the 3rd party IME to be activated, and activate it
 412   // when SetEnabledExtensionImes happens later.
 413   if (MethodAwaitsExtensionLoad(descriptor->id()))
 414     pending_input_method_id = descriptor->id();
 415
 416   if (descriptor->id() != current_input_method.id()) {
 417     previous_input_method = current_input_method;
 418     current_input_method = *descriptor;
 419     notify_menu = true;
 420   }
 421
 422   // Always change input method even if it is the same.
 423   // TODO(komatsu): Revisit if this is neccessary.
 424   if (IsActive())
 425     manager_->ChangeInputMethodInternal(*descriptor, show_message, notify_menu);
 426   manager_->RecordInputMethodUsage(current_input_method.id());
 427 }
 428
 429 bool InputMethodManagerImpl::StateImpl::MethodAwaitsExtensionLoad(
 430     const std::string& input_method_id) const {
 431   // For 3rd party IME, when the user just logged in, SetEnabledExtensionImes
 432   // happens after activating the 3rd party IME.
 433   // So here to record the 3rd party IME to be activated, and activate it
 434   // when SetEnabledExtensionImes happens later.
 435   return !InputMethodIsActivated(input_method_id) &&
 436          extension_ime_util::IsExtensionIME(input_method_id);
 437 }
 438
 439 void InputMethodManagerImpl::StateImpl::AddInputMethodExtension(
 440     const std::string& extension_id,
 441     const InputMethodDescriptors& descriptors,
 442     InputMethodEngineInterface* engine) {
 443   if (manager_->ui_session_ == STATE_TERMINATING)
 444     return;
 445
 446   DCHECK(engine);
 447
 448   manager_->engine_map_[extension_id] = engine;
 449
 450   bool contain = false;
 451   for (size_t i = 0; i < descriptors.size(); i++) {
 452     const InputMethodDescriptor& descriptor = descriptors[i];
 453     const std::string& id = descriptor.id();
 454     extra_input_methods[id] = descriptor;
 455     if (Contains(enabled_extension_imes, id)) {
 456       if (!Contains(active_input_method_ids, id)) {
 457         active_input_method_ids.push_back(id);
 458       } else {
 459         DVLOG(1) << "AddInputMethodExtension: already added: " << id << ", "
 460                  << descriptor.name();
 461       }
 462       contain = true;
 463     }
 464   }
 465
 466   if (IsActive()) {
 467     if (extension_id == extension_ime_util::GetExtensionIDFromInputMethodID(
 468                             current_input_method.id())) {
 469       IMEBridge::Get()->SetCurrentEngineHandler(engine);
 470       engine->Enable(extension_ime_util::GetComponentIDByInputMethodID(
 471           current_input_method.id()));
 472     }
 473
 474     // Ensure that the input method daemon is running.
 475     if (contain)
 476       manager_->MaybeInitializeCandidateWindowController();
 477   }
 478 }
 479
 480 void InputMethodManagerImpl::StateImpl::RemoveInputMethodExtension(
 481     const std::string& extension_id) {
 482   // Remove the active input methods with |extension_id|.
 483   std::vector<std::string> new_active_input_method_ids;
 484   for (size_t i = 0; i < active_input_method_ids.size(); ++i) {
 485     if (extension_id != extension_ime_util::GetExtensionIDFromInputMethodID(
 486                             active_input_method_ids[i]))
 487       new_active_input_method_ids.push_back(active_input_method_ids[i]);
 488   }
 489   active_input_method_ids.swap(new_active_input_method_ids);
 490
 491   // Remove the extra input methods with |extension_id|.
 492   std::map<std::string, InputMethodDescriptor> new_extra_input_methods;
 493   for (std::map<std::string, InputMethodDescriptor>::iterator i =
 494            extra_input_methods.begin();
 495        i != extra_input_methods.end();
 496        ++i) {
 497     if (extension_id !=
 498         extension_ime_util::GetExtensionIDFromInputMethodID(i->first))
 499       new_extra_input_methods[i->first] = i->second;
 500   }
 501   extra_input_methods.swap(new_extra_input_methods);
 502
 503   if (IsActive()) {
 504     if (IMEBridge::Get()->GetCurrentEngineHandler() ==
 505         manager_->engine_map_[extension_id]) {
 506       IMEBridge::Get()->SetCurrentEngineHandler(NULL);
 507     }
 508     manager_->engine_map_.erase(extension_id);
 509   }
 510
 511   // If |current_input_method| is no longer in |active_input_method_ids|,
 512   // switch to the first one in |active_input_method_ids|.
 513   ChangeInputMethod(current_input_method.id(), false);
 514 }
 515
 516 void InputMethodManagerImpl::StateImpl::GetInputMethodExtensions(
 517     InputMethodDescriptors* result) {
 518   // Build the extension input method descriptors from the extra input
 519   // methods cache |extra_input_methods|.
 520   std::map<std::string, InputMethodDescriptor>::iterator iter;
 521   for (iter = extra_input_methods.begin(); iter != extra_input_methods.end();
 522        ++iter) {
 523     if (extension_ime_util::IsExtensionIME(iter->first))
 524       result->push_back(iter->second);
 525   }
 526 }
 527
 528 void InputMethodManagerImpl::StateImpl::SetEnabledExtensionImes(
 529     std::vector<std::string>* ids) {
 530   enabled_extension_imes.clear();
 531   enabled_extension_imes.insert(
 532       enabled_extension_imes.end(), ids->begin(), ids->end());
 533   bool active_imes_changed = false;
 534   bool switch_to_pending = false;
 535
 536   for (std::map<std::string, InputMethodDescriptor>::iterator extra_iter =
 537            extra_input_methods.begin();
 538        extra_iter != extra_input_methods.end();
 539        ++extra_iter) {
 540     if (extension_ime_util::IsComponentExtensionIME(extra_iter->first))
 541       continue;  // Do not filter component extension.
 542
 543     if (pending_input_method_id == extra_iter->first)
 544       switch_to_pending = true;
 545
 546     std::vector<std::string>::iterator active_iter =
 547         std::find(active_input_method_ids.begin(),
 548                   active_input_method_ids.end(),
 549                   extra_iter->first);
 550
 551     bool active = active_iter != active_input_method_ids.end();
 552     bool enabled = Contains(enabled_extension_imes, extra_iter->first);
 553
 554     if (active && !enabled)
 555       active_input_method_ids.erase(active_iter);
 556
 557     if (!active && enabled)
 558       active_input_method_ids.push_back(extra_iter->first);
 559
 560     if (active == !enabled)
 561       active_imes_changed = true;
 562   }
 563
 564   if (IsActive() && active_imes_changed) {
 565     manager_->MaybeInitializeCandidateWindowController();
 566
 567     if (switch_to_pending) {
 568       ChangeInputMethod(pending_input_method_id, false);
 569       pending_input_method_id.clear();
 570     } else {
 571       // If |current_input_method| is no longer in |active_input_method_ids_|,
 572       // switch to the first one in |active_input_method_ids_|.
 573       ChangeInputMethod(current_input_method.id(), false);
 574     }
 575   }
 576 }
 577
 578 void InputMethodManagerImpl::StateImpl::SetInputMethodLoginDefaultFromVPD(
 579     const std::string& locale,
 580     const std::string& oem_layout) {
 581   std::string layout;
 582   if (!oem_layout.empty()) {
 583     // If the OEM layout information is provided, use it.
 584     layout = oem_layout;
 585   } else {
 586     // Otherwise, determine the hardware keyboard from the locale.
 587     std::vector<std::string> input_method_ids;
 588     if (manager_->util_.GetInputMethodIdsFromLanguageCode(
 589             locale,
 590             chromeos::input_method::kKeyboardLayoutsOnly,
 591             &input_method_ids)) {
 592       // The output list |input_method_ids| is sorted by popularity, hence
 593       // input_method_ids[0] now contains the most popular keyboard layout
 594       // for the given locale.
 595       DCHECK_GE(input_method_ids.size(), 1U);
 596       layout = input_method_ids[0];
 597     }
 598   }
 599
 600   if (layout.empty())
 601     return;
 602
 603   std::vector<std::string> layouts;
 604   base::SplitString(layout, ',', &layouts);
 605   manager_->MigrateInputMethods(&layouts);
 606
 607   PrefService* prefs = g_browser_process->local_state();
 608   prefs->SetString(prefs::kHardwareKeyboardLayout, JoinString(layouts, ","));
 609
 610   // This asks the file thread to save the prefs (i.e. doesn't block).
 611   // The latest values of Local State reside in memory so we can safely
 612   // get the value of kHardwareKeyboardLayout even if the data is not
 613   // yet saved to disk.
 614   prefs->CommitPendingWrite();
 615
 616   manager_->util_.UpdateHardwareLayoutCache();
 617
 618   EnableLoginLayouts(locale, layouts);
 619   manager_->LoadNecessaryComponentExtensions(this);
 620 }
 621
 622 void InputMethodManagerImpl::StateImpl::SetInputMethodLoginDefault() {
 623   // Set up keyboards. For example, when |locale| is "en-US", enable US qwerty
 624   // and US dvorak keyboard layouts.
 625   if (g_browser_process && g_browser_process->local_state()) {
 626     const std::string locale = g_browser_process->GetApplicationLocale();
 627     // If the preferred keyboard for the login screen has been saved, use it.
 628     PrefService* prefs = g_browser_process->local_state();
 629     std::string initial_input_method_id =
 630         prefs->GetString(chromeos::language_prefs::kPreferredKeyboardLayout);
 631     std::vector<std::string> input_methods_to_be_enabled;
 632     if (initial_input_method_id.empty()) {
 633       // If kPreferredKeyboardLayout is not specified, use the hardware layout.
 634       input_methods_to_be_enabled =
 635           manager_->util_.GetHardwareLoginInputMethodIds();
 636     } else {
 637       input_methods_to_be_enabled.push_back(initial_input_method_id);
 638     }
 639     EnableLoginLayouts(locale, input_methods_to_be_enabled);
 640     manager_->LoadNecessaryComponentExtensions(this);
 641   }
 642 }
 643
 644 bool InputMethodManagerImpl::StateImpl::CanCycleInputMethod() {
 645   // Sanity checks.
 646   if (active_input_method_ids.empty()) {
 647     DVLOG(1) << "active input method is empty";
 648     return false;
 649   }
 650
 651   if (current_input_method.id().empty()) {
 652     DVLOG(1) << "current_input_method is unknown";
 653     return false;
 654   }
 655
 656   // Do not consume key event if there is only one input method is enabled.
 657   // Ctrl+Space or Alt+Shift may be used by other application.
 658   return active_input_method_ids.size() > 1;
 659 }
 660
 661 void InputMethodManagerImpl::StateImpl::SwitchToNextInputMethod() {
 662   DCHECK(CanCycleInputMethod());
 663   if (!CanCycleInputMethod())
 664     return;
 665
 666   // Find the next input method and switch to it.
 667   SwitchToNextInputMethodInternal(active_input_method_ids,
 668                                   current_input_method.id());
 669   InputMethodSwitchRecorder::Get()->RecordSwitch(false /* by_tray_menu*/);
 670 }
 671
 672 void InputMethodManagerImpl::StateImpl::SwitchToPreviousInputMethod() {
 673   DCHECK(CanCycleInputMethod());
 674   if (!CanCycleInputMethod())
 675     return;
 676
 677   if (previous_input_method.id().empty() ||
 678       previous_input_method.id() == current_input_method.id()) {
 679     SwitchToNextInputMethod();
 680     return;
 681   }
 682
 683   std::vector<std::string>::const_iterator iter =
 684       std::find(active_input_method_ids.begin(),
 685                 active_input_method_ids.end(),
 686                 previous_input_method.id());
 687   if (iter == active_input_method_ids.end()) {
 688     // previous_input_method is not supported.
 689     SwitchToNextInputMethod();
 690     return;
 691   }
 692   ChangeInputMethod(*iter, true);
 693   InputMethodSwitchRecorder::Get()->RecordSwitch(false /* by_tray_menu*/);
 694 }
 695
 696 bool InputMethodManagerImpl::StateImpl::CanSwitchInputMethod(
 697     const ui::Accelerator& accelerator) {
 698   // If none of the input methods associated with |accelerator| are active, we
 699   // should ignore the accelerator. For example, we should just ignore
 700   // VKEY_HANGUL when mozc-hangul is not active.
 701   std::vector<std::string> candidate_ids;
 702   GetCandidateInputMethodsForAccelerator(accelerator, &candidate_ids);
 703   return !candidate_ids.empty();
 704 }
 705
 706 void InputMethodManagerImpl::StateImpl::SwitchInputMethod(
 707     const ui::Accelerator& accelerator) {
 708   std::vector<std::string> candidate_ids;
 709   GetCandidateInputMethodsForAccelerator(accelerator, &candidate_ids);
 710   DCHECK(!candidate_ids.empty());
 711   if (!candidate_ids.empty()) {
 712     SwitchToNextInputMethodInternal(candidate_ids, current_input_method.id());
 713     InputMethodSwitchRecorder::Get()->RecordSwitch(false /* by_tray_menu*/);
 714   }
 715 }
 716
 717 void InputMethodManagerImpl::StateImpl::SwitchToNextInputMethodInternal(
 718     const std::vector<std::string>& input_method_ids,
 719     const std::string& current_input_methodid) {
 720   std::vector<std::string>::const_iterator iter = std::find(
 721       input_method_ids.begin(), input_method_ids.end(), current_input_methodid);
 722   if (iter != input_method_ids.end())
 723     ++iter;
 724   if (iter == input_method_ids.end())
 725     iter = input_method_ids.begin();
 726   ChangeInputMethod(*iter, true);
 727 }
 728
 729 void InputMethodManagerImpl::StateImpl::GetCandidateInputMethodsForAccelerator(
 730     const ui::Accelerator& accelerator,
 731     std::vector<std::string>* out_candidate_ids) {
 732   out_candidate_ids->clear();
 733
 734   // Sanity check.
 735   if (active_input_method_ids.empty()) {
 736     DVLOG(1) << "active input method is empty";
 737     return;
 738   }
 739
 740   std::vector<std::string> input_method_ids_to_switch;
 741   switch (accelerator.key_code()) {
 742     case ui::VKEY_CONVERT:  // Henkan key on JP106 keyboard
 743       input_method_ids_to_switch.push_back(
 744           extension_ime_util::GetInputMethodIDByEngineID("nacl_mozc_jp"));
 745       break;
 746     case ui::VKEY_NONCONVERT:  // Muhenkan key on JP106 keyboard
 747       input_method_ids_to_switch.push_back(
 748           extension_ime_util::GetInputMethodIDByEngineID("xkb:jp::jpn"));
 749       break;
 750     case ui::VKEY_DBE_SBCSCHAR:  // ZenkakuHankaku key on JP106 keyboard
 751     case ui::VKEY_DBE_DBCSCHAR:
 752       input_method_ids_to_switch.push_back(
 753           extension_ime_util::GetInputMethodIDByEngineID("nacl_mozc_jp"));
 754       input_method_ids_to_switch.push_back(
 755           extension_ime_util::GetInputMethodIDByEngineID("xkb:jp::jpn"));
 756       break;
 757     default:
 758       NOTREACHED();
 759       break;
 760   }
 761   if (input_method_ids_to_switch.empty()) {
 762     DVLOG(1) << "Unexpected VKEY: " << accelerator.key_code();
 763     return;
 764   }
 765
 766   // Obtain the intersection of input_method_ids_to_switch and
 767   // active_input_method_ids.
 768   for (size_t i = 0; i < input_method_ids_to_switch.size(); ++i) {
 769     const std::string& id = input_method_ids_to_switch[i];
 770     if (Contains(active_input_method_ids, id))
 771       out_candidate_ids->push_back(id);
 772   }
 773 }
 774
 775 InputMethodDescriptor InputMethodManagerImpl::StateImpl::GetCurrentInputMethod()
 776     const {
 777   if (current_input_method.id().empty())
 778     return InputMethodUtil::GetFallbackInputMethodDescriptor();
 779
 780   return current_input_method;
 781 }
 782
 783 bool InputMethodManagerImpl::StateImpl::InputMethodIsActivated(
 784     const std::string& input_method_id) const {
 785   return Contains(active_input_method_ids, input_method_id);
 786 }
 787
 788 // ------------------------ InputMethodManagerImpl
 789 bool InputMethodManagerImpl::IsLoginKeyboard(
 790     const std::string& layout) const {
 791   return util_.IsLoginKeyboard(layout);
 792 }
 793
 794 bool InputMethodManagerImpl::MigrateInputMethods(
 795     std::vector<std::string>* input_method_ids) {
 796   return util_.MigrateInputMethods(input_method_ids);
 797 }
 798
 799 // Starts or stops the system input method framework as needed.
 800 void InputMethodManagerImpl::ReconfigureIMFramework(
 801     InputMethodManagerImpl::StateImpl* state) {
 802   LoadNecessaryComponentExtensions(state);
 803
 804   // Initialize candidate window controller and widgets such as
 805   // candidate window, infolist and mode indicator.  Note, mode
 806   // indicator is used by only keyboard layout input methods.
 807   if (state_.get() == state)
 808     MaybeInitializeCandidateWindowController();
 809 }
 810
 811 void InputMethodManagerImpl::SetState(
 812     scoped_refptr<InputMethodManager::State> state) {
 813   DCHECK(state.get());
 814   InputMethodManagerImpl::StateImpl* new_impl_state =
 815       static_cast<InputMethodManagerImpl::StateImpl*>(state.get());
 816
 817   state_ = new_impl_state;
 818
 819   if (state_.get() && state_->active_input_method_ids.size()) {
 820     // Initialize candidate window controller and widgets such as
 821     // candidate window, infolist and mode indicator.  Note, mode
 822     // indicator is used by only keyboard layout input methods.
 823     MaybeInitializeCandidateWindowController();
 824
 825     // Always call ChangeInputMethodInternal even when the input method id
 826     // remain unchanged, because onActivate event needs to be sent to IME
 827     // extension to update the current screen type correctly.
 828     ChangeInputMethodInternal(state_->current_input_method,
 829                               false /* show_message */,
 830                               true /* notify_menu */);
 831   }
 832 }
 833
 834 scoped_refptr<InputMethodManager::State>
 835 InputMethodManagerImpl::GetActiveIMEState() {
 836   return scoped_refptr<InputMethodManager::State>(state_.get());
 837 }
 838
 839 InputMethodManagerImpl::InputMethodManagerImpl(
 840     scoped_ptr<InputMethodDelegate> delegate,
 841     bool enable_extension_loading)
 842     : delegate_(delegate.Pass()),
 843       ui_session_(STATE_LOGIN_SCREEN),
 844       state_(NULL),
 845       util_(delegate_.get()),
 846       component_extension_ime_manager_(new ComponentExtensionIMEManager()),
 847       enable_extension_loading_(enable_extension_loading) {
 848   if (base::SysInfo::IsRunningOnChromeOS())
 849     keyboard_.reset(ImeKeyboard::Create());
 850   else
 851     keyboard_.reset(new FakeImeKeyboard());
 852
 853   // Initializes the system IME list.
 854   scoped_ptr<ComponentExtensionIMEManagerDelegate> comp_delegate(
 855       new ComponentExtensionIMEManagerImpl());
 856   component_extension_ime_manager_->Initialize(comp_delegate.Pass());
 857   const InputMethodDescriptors& descriptors =
 858       component_extension_ime_manager_->GetAllIMEAsInputMethodDescriptor();
 859   util_.ResetInputMethods(descriptors);
 860
 861   // Initializes the stat id map.
 862   std::map<int, std::vector<std::string> > buckets;
 863   for (InputMethodDescriptors::const_iterator it = descriptors.begin();
 864        it != descriptors.end(); ++it) {
 865     char first_char;
 866     int cat_id = static_cast<int>(
 867         GetInputMethodCategory(it->id(), &first_char));
 868     int key = cat_id * 1000 + first_char;
 869     buckets[key].push_back(it->id());
 870   }
 871   for (std::map<int, std::vector<std::string>>::iterator i =
 872        buckets.begin(); i != buckets.end(); ++i) {
 873     std::sort(i->second.begin(), i->second.end());
 874     for (size_t j = 0; j < i->second.size() && j < 100; ++j) {
 875       int key = i->first * 100 + j;
 876       stat_id_map_[i->second[j]] = key;
 877     }
 878   }
 879 }
 880
 881 InputMethodManagerImpl::~InputMethodManagerImpl() {
 882   if (candidate_window_controller_.get())
 883     candidate_window_controller_->RemoveObserver(this);
 884 }
 885
 886 void InputMethodManagerImpl::RecordInputMethodUsage(
 887     std::string input_method_id) {
 888   UMA_HISTOGRAM_ENUMERATION("InputMethod.Category",
 889                             GetInputMethodCategory(input_method_id),
 890                             INPUT_METHOD_CATEGORY_MAX);
 891   UMA_HISTOGRAM_SPARSE_SLOWLY("InputMethod.ID",
 892                               stat_id_map_[input_method_id]);
 893 }
 894
 895 void InputMethodManagerImpl::AddObserver(
 896     InputMethodManager::Observer* observer) {
 897   observers_.AddObserver(observer);
 898 }
 899
 900 void InputMethodManagerImpl::AddCandidateWindowObserver(
 901     InputMethodManager::CandidateWindowObserver* observer) {
 902   candidate_window_observers_.AddObserver(observer);
 903 }
 904
 905 void InputMethodManagerImpl::RemoveObserver(
 906     InputMethodManager::Observer* observer) {
 907   observers_.RemoveObserver(observer);
 908 }
 909
 910 void InputMethodManagerImpl::RemoveCandidateWindowObserver(
 911     InputMethodManager::CandidateWindowObserver* observer) {
 912   candidate_window_observers_.RemoveObserver(observer);
 913 }
 914
 915 InputMethodManager::UISessionState InputMethodManagerImpl::GetUISessionState() {
 916   return ui_session_;
 917 }
 918
 919 void InputMethodManagerImpl::SetUISessionState(UISessionState new_ui_session) {
 920   ui_session_ = new_ui_session;
 921   switch (ui_session_) {
 922     case STATE_LOGIN_SCREEN:
 923       break;
 924     case STATE_BROWSER_SCREEN:
 925       break;
 926     case STATE_LOCK_SCREEN:
 927       break;
 928     case STATE_TERMINATING: {
 929       if (candidate_window_controller_.get())
 930         candidate_window_controller_.reset();
 931       break;
 932     }
 933   }
 934 }
 935
 936 scoped_ptr<InputMethodDescriptors>
 937 InputMethodManagerImpl::GetSupportedInputMethods() const {
 938   return scoped_ptr<InputMethodDescriptors>(new InputMethodDescriptors).Pass();
 939 }
 940
 941 const InputMethodDescriptor* InputMethodManagerImpl::LookupInputMethod(
 942     const std::string& input_method_id,
 943     InputMethodManagerImpl::StateImpl* state) {
 944   DCHECK(state);
 945
 946   std::string input_method_id_to_switch = input_method_id;
 947
 948   // Sanity check
 949   if (!state->InputMethodIsActivated(input_method_id)) {
 950     scoped_ptr<InputMethodDescriptors> input_methods(
 951         state->GetActiveInputMethods());
 952     DCHECK(!input_methods->empty());
 953     input_method_id_to_switch = input_methods->at(0).id();
 954     if (!input_method_id.empty()) {
 955       DVLOG(1) << "Can't change the current input method to "
 956                << input_method_id << " since the engine is not enabled. "
 957                << "Switch to " << input_method_id_to_switch << " instead.";
 958     }
 959   }
 960
 961   const InputMethodDescriptor* descriptor = NULL;
 962   if (extension_ime_util::IsExtensionIME(input_method_id_to_switch)) {
 963     DCHECK(state->extra_input_methods.find(input_method_id_to_switch) !=
 964            state->extra_input_methods.end());
 965     descriptor = &(state->extra_input_methods[input_method_id_to_switch]);
 966   } else {
 967     descriptor =
 968         util_.GetInputMethodDescriptorFromId(input_method_id_to_switch);
 969     if (!descriptor)
 970       LOG(ERROR) << "Unknown input method id: " << input_method_id_to_switch;
 971   }
 972   DCHECK(descriptor);
 973   return descriptor;
 974 }
 975
 976 void InputMethodManagerImpl::ChangeInputMethodInternal(
 977     const InputMethodDescriptor& descriptor,
 978     bool show_message,
 979     bool notify_menu) {
 980   // No need to switch input method when terminating.
 981   if (ui_session_ == STATE_TERMINATING)
 982     return;
 983
 984   if (candidate_window_controller_.get())
 985     candidate_window_controller_->Hide();
 986
 987   if (notify_menu) {
 988     // Clear property list.  Property list would be updated by
 989     // extension IMEs via InputMethodEngine::(Set|Update)MenuItems.
 990     // If the current input method is a keyboard layout, empty
 991     // properties are sufficient.
 992     const ui::ime::InputMethodMenuItemList empty_menu_item_list;
 993     ui::ime::InputMethodMenuManager* input_method_menu_manager =
 994         ui::ime::InputMethodMenuManager::GetInstance();
 995     input_method_menu_manager->SetCurrentInputMethodMenuItemList(
 996             empty_menu_item_list);
 997   }
 998
 999   // Disable the current engine handler.
1000   IMEEngineHandlerInterface* engine =
1001       IMEBridge::Get()->GetCurrentEngineHandler();
1002   if (engine)
1003     engine->Disable();
1004
1005   // Configure the next engine handler.
1006   // This must be after |current_input_method| has been set to new input
1007   // method, because engine's Enable() method needs to access it.
1008   const std::string& extension_id =
1009       extension_ime_util::GetExtensionIDFromInputMethodID(descriptor.id());
1010   const std::string& component_id =
1011       extension_ime_util::GetComponentIDByInputMethodID(descriptor.id());
1012   engine = engine_map_[extension_id];
1013
1014   IMEBridge::Get()->SetCurrentEngineHandler(engine);
1015
1016   if (engine) {
1017     engine->Enable(component_id);
1018   } else {
1019     // If no engine to enable, cancel the virtual keyboard url override so that
1020     // it can use the fallback system virtual keyboard UI.
1021     keyboard::SetOverrideContentUrl(GURL());
1022     keyboard::KeyboardController* keyboard_controller =
1023         keyboard::KeyboardController::GetInstance();
1024     if (keyboard_controller)
1025       keyboard_controller->Reload();
1026   }
1027
1028   // Change the keyboard layout to a preferred layout for the input method.
1029   if (!keyboard_->SetCurrentKeyboardLayoutByName(
1030           descriptor.GetPreferredKeyboardLayout())) {
1031     LOG(ERROR) << "Failed to change keyboard layout to "
1032                << descriptor.GetPreferredKeyboardLayout();
1033   }
1034
1035   // Update input method indicators (e.g. "US", "DV") in Chrome windows.
1036   FOR_EACH_OBSERVER(InputMethodManager::Observer,
1037                     observers_,
1038                     InputMethodChanged(this, show_message));
1039 }
1040
1041 void InputMethodManagerImpl::LoadNecessaryComponentExtensions(
1042     InputMethodManagerImpl::StateImpl* state) {
1043   // Load component extensions but also update |active_input_method_ids| as
1044   // some component extension IMEs may have been removed from the Chrome OS
1045   // image. If specified component extension IME no longer exists, falling back
1046   // to an existing IME.
1047   DCHECK(state);
1048   std::vector<std::string> unfiltered_input_method_ids;
1049   unfiltered_input_method_ids.swap(state->active_input_method_ids);
1050   for (size_t i = 0; i < unfiltered_input_method_ids.size(); ++i) {
1051     if (!extension_ime_util::IsComponentExtensionIME(
1052         unfiltered_input_method_ids[i])) {
1053       // Legacy IMEs or xkb layouts are alwayes active.
1054       state->active_input_method_ids.push_back(unfiltered_input_method_ids[i]);
1055     } else if (component_extension_ime_manager_->IsWhitelisted(
1056         unfiltered_input_method_ids[i])) {
1057       if (enable_extension_loading_) {
1058         component_extension_ime_manager_->LoadComponentExtensionIME(
1059             state->profile, unfiltered_input_method_ids[i]);
1060       }
1061
1062       state->active_input_method_ids.push_back(unfiltered_input_method_ids[i]);
1063     }
1064   }
1065 }
1066
1067 void InputMethodManagerImpl::ActivateInputMethodMenuItem(
1068     const std::string& key) {
1069   DCHECK(!key.empty());
1070
1071   if (ui::ime::InputMethodMenuManager::GetInstance()->
1072       HasInputMethodMenuItemForKey(key)) {
1073     IMEEngineHandlerInterface* engine =
1074         IMEBridge::Get()->GetCurrentEngineHandler();
1075     if (engine)
1076       engine->PropertyActivate(key);
1077     return;
1078   }
1079
1080   DVLOG(1) << "ActivateInputMethodMenuItem: unknown key: " << key;
1081 }
1082
1083 bool InputMethodManagerImpl::IsISOLevel5ShiftUsedByCurrentInputMethod() const {
1084   return keyboard_->IsISOLevel5ShiftAvailable();
1085 }
1086
1087 bool InputMethodManagerImpl::IsAltGrUsedByCurrentInputMethod() const {
1088   return keyboard_->IsAltGrAvailable();
1089 }
1090
1091 ImeKeyboard* InputMethodManagerImpl::GetImeKeyboard() {
1092   return keyboard_.get();
1093 }
1094
1095 InputMethodUtil* InputMethodManagerImpl::GetInputMethodUtil() {
1096   return &util_;
1097 }
1098
1099 ComponentExtensionIMEManager*
1100     InputMethodManagerImpl::GetComponentExtensionIMEManager() {
1101   return component_extension_ime_manager_.get();
1102 }
1103
1104 scoped_refptr<InputMethodManager::State> InputMethodManagerImpl::CreateNewState(
1105     Profile* profile) {
1106   StateImpl* new_state = new StateImpl(this, profile);
1107
1108   // Active IM should be set to owner's default.
1109   PrefService* prefs = g_browser_process->local_state();
1110   const std::string initial_input_method_id =
1111       prefs->GetString(chromeos::language_prefs::kPreferredKeyboardLayout);
1112
1113   const InputMethodDescriptor* descriptor =
1114       GetInputMethodUtil()->GetInputMethodDescriptorFromId(
1115           initial_input_method_id.empty()
1116               ? GetInputMethodUtil()->GetFallbackInputMethodDescriptor().id()
1117               : initial_input_method_id);
1118   if (descriptor) {
1119     new_state->active_input_method_ids.push_back(descriptor->id());
1120     new_state->current_input_method = *descriptor;
1121   }
1122   return scoped_refptr<InputMethodManager::State>(new_state);
1123 }
1124
1125 void InputMethodManagerImpl::SetCandidateWindowControllerForTesting(
1126     CandidateWindowController* candidate_window_controller) {
1127   candidate_window_controller_.reset(candidate_window_controller);
1128   candidate_window_controller_->AddObserver(this);
1129 }
1130
1131 void InputMethodManagerImpl::SetImeKeyboardForTesting(ImeKeyboard* keyboard) {
1132   keyboard_.reset(keyboard);
1133 }
1134
1135 void InputMethodManagerImpl::InitializeComponentExtensionForTesting(
1136     scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate) {
1137   component_extension_ime_manager_->Initialize(delegate.Pass());
1138   util_.ResetInputMethods(
1139       component_extension_ime_manager_->GetAllIMEAsInputMethodDescriptor());
1140 }
1141
1142 void InputMethodManagerImpl::CandidateClicked(int index) {
1143   IMEEngineHandlerInterface* engine =
1144       IMEBridge::Get()->GetCurrentEngineHandler();
1145   if (engine)
1146     engine->CandidateClicked(index);
1147 }
1148
1149 void InputMethodManagerImpl::CandidateWindowOpened() {
1150   FOR_EACH_OBSERVER(InputMethodManager::CandidateWindowObserver,
1151                     candidate_window_observers_,
1152                     CandidateWindowOpened(this));
1153 }
1154
1155 void InputMethodManagerImpl::CandidateWindowClosed() {
1156   FOR_EACH_OBSERVER(InputMethodManager::CandidateWindowObserver,
1157                     candidate_window_observers_,
1158                     CandidateWindowClosed(this));
1159 }
1160
1161 void InputMethodManagerImpl::MaybeInitializeCandidateWindowController() {
1162   if (candidate_window_controller_.get())
1163     return;
1164
1165   candidate_window_controller_.reset(
1166       CandidateWindowController::CreateCandidateWindowController());
1167   candidate_window_controller_->AddObserver(this);
1168 }
1169
1170 }  // namespace input_method
1171 }  // namespace chromeos