Fix the issue that 3rd party IME cannot be activated after user login.

chrome/browser/chromeos/input_method/input_method_manager_impl.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 "chrome/browser/chromeos/input_method/input_method_manager_impl.h"
 
 #include <algorithm>  // std::find
 
 #include "ash/ime/input_method_menu_item.h"
 #include "ash/ime/input_method_menu_manager.h"
@@ skipping 299 matching lines @@
 bool InputMethodManagerImpl::ChangeInputMethodInternal(
     const std::string& input_method_id,
     bool show_message) {
   if (state_ == STATE_TERMINATING)
     return false;
 
   std::string input_method_id_to_switch = input_method_id;
 
   // Sanity check.
   if (!InputMethodIsActivated(input_method_id)) {
+    // For 3rd party IME, when the user just logged in, SetEnabledExtensionImes
+    // happens after activating the 3rd party IME.
+    // So here to record the 3rd party IME to be activated, and activate it
+    // when SetEnabledExtensionImes happens later.
+    if (extension_ime_util::IsExtensionIME(input_method_id))
+      pending_input_method_id_ = input_method_id;
+
     scoped_ptr<InputMethodDescriptors> input_methods(GetActiveInputMethods());
     DCHECK(!input_methods->empty());
     input_method_id_to_switch = input_methods->at(0).id();
     if (!input_method_id.empty()) {
       DVLOG(1) << "Can't change the current input method to "
                << input_method_id << " since the engine is not enabled. "
                << "Switch to " << input_method_id_to_switch << " instead.";
     }
   }
 
@@ skipping 189 matching lines @@
 }
 
 void InputMethodManagerImpl::SetEnabledExtensionImes(
     std::vector<std::string>* ids) {
   enabled_extension_imes_.clear();
   enabled_extension_imes_.insert(enabled_extension_imes_.end(),
                                  ids->begin(),
                                  ids->end());
 
   bool active_imes_changed = false;
+  bool switch_to_pending = false;
 
   for (std::map<std::string, InputMethodDescriptor>::iterator extra_iter =
        extra_input_methods_.begin(); extra_iter != extra_input_methods_.end();
        ++extra_iter) {
     if (extension_ime_util::IsComponentExtensionIME(
         extra_iter->first))
       continue;  // Do not filter component extension.
+
+    if (pending_input_method_id_ == extra_iter->first)
+      switch_to_pending = true;
+
     std::vector<std::string>::iterator active_iter = std::find(
         active_input_method_ids_.begin(), active_input_method_ids_.end(),
         extra_iter->first);
 
     bool active = active_iter != active_input_method_ids_.end();
     bool enabled = Contains(enabled_extension_imes_, extra_iter->first);
 
     if (active && !enabled)
       active_input_method_ids_.erase(active_iter);
 
     if (!active && enabled)
       active_input_method_ids_.push_back(extra_iter->first);
 
     if (active == !enabled)
       active_imes_changed = true;
   }
 
   if (active_imes_changed) {
     MaybeInitializeCandidateWindowController();
 
-    // If |current_input_method| is no longer in |active_input_method_ids_|,
-    // switch to the first one in |active_input_method_ids_|.
-    ChangeInputMethod(current_input_method_.id());
+    if (switch_to_pending) {
+      ChangeInputMethod(pending_input_method_id_);
+      pending_input_method_id_.clear();
+    } else {
+      // If |current_input_method| is no longer in |active_input_method_ids_|,
+      // switch to the first one in |active_input_method_ids_|.
+      ChangeInputMethod(current_input_method_.id());
+    }
   }
 }
 
 void InputMethodManagerImpl::SetInputMethodLoginDefaultFromVPD(
     const std::string& locale, const std::string& oem_layout) {
   std::string layout;
   if (!oem_layout.empty()) {
     // If the OEM layout information is provided, use it.
     layout = oem_layout;
   } else {
@@ skipping 305 matching lines @@
   if (candidate_window_controller_.get())
     return;
 
   candidate_window_controller_.reset(
       CandidateWindowController::CreateCandidateWindowController());
   candidate_window_controller_->AddObserver(this);
 }
 
 }  // namespace input_method
 }  // namespace chromeos