Set the active input method correctly when EnableLayouts is called.

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 "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 273 matching lines @@
     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.";
     }
   }
 
-  if (!component_extension_ime_manager_->IsInitialized()) {
+  if (!component_extension_ime_manager_->IsInitialized() &&
+      !InputMethodUtil::IsKeyboardLayout(input_method_id_to_switch)) {
     // We can't change input method before the initialization of
     // component extension ime manager.  ChangeInputMethod will be
     // called with |pending_input_method_| when the initialization is
     // done.
     pending_input_method_ = input_method_id_to_switch;
     return false;
   }
-
   pending_input_method_.clear();
-  IBusEngineHandlerInterface* engine =
-      IBusBridge::Get()->GetCurrentEngineHandler();
 
   // Hide candidate window and info list.
   if (candidate_window_controller_.get())
     candidate_window_controller_->Hide();
 
-  const std::string current_input_method_id = current_input_method_.id();
+  // Disable the current engine handler.
+  IBusEngineHandlerInterface* engine =
+      IBusBridge::Get()->GetCurrentEngineHandler();
+  if (engine)
+    engine->Disable();
+
+  // Configure the next engine handler.
   if (InputMethodUtil::IsKeyboardLayout(input_method_id_to_switch)) {
-    if (engine) {
-      engine->Disable();
-      IBusBridge::Get()->SetCurrentEngineHandler(NULL);
-    }
+    IBusBridge::Get()->SetCurrentEngineHandler(NULL);
   } else {
-    // Disable the current engine and enable the next engine.
-    if (engine)
-      engine->Disable();
-
     IBusEngineHandlerInterface* next_engine =
         IBusBridge::Get()->SetCurrentEngineHandlerById(
             input_method_id_to_switch);
 
     if (next_engine)
       next_engine->Enable();
   }
 
-  if (current_input_method_id != input_method_id_to_switch) {
+  // TODO(komatsu): Check if it is necessary to perform the above routine
+  // when the current input method is equal to |input_method_id_to_swich|.
+  if (current_input_method_.id() != input_method_id_to_switch) {

[Seigo Nonaka, 2013/12/19 03:41:12]

How about remove this condition?

This condition can be false? (probably yes in past, but now I think no).

And seems safe to execute this statement even current and next input method id
is equal.

[Hiro Komatsu, 2013/12/19 04:32:04]

This can be false when the sanity check from line:283 is performed.  In that
case line:294 will be true too though.

I will remove the condition.  Please let me know if you get additional concerns.

     // Clear property list.  Property list would be updated by
-    // extension IMEs via InputMethodEngineIBus::(Set|Update)MenuItems.
+    // extension IMEs via InputMethodEngine::(Set|Update)MenuItems.
     // If the current input method is a keyboard layout, empty
     // properties are sufficient.
     const InputMethodPropertyList empty_property_list;
     SetCurrentInputMethodProperties(empty_property_list);
 
     const InputMethodDescriptor* descriptor = NULL;
-    if (!extension_ime_util::IsExtensionIME(input_method_id_to_switch)) {
+    if (extension_ime_util::IsExtensionIME(input_method_id_to_switch)) {
+      DCHECK(extra_input_methods_.find(input_method_id_to_switch) !=
+             extra_input_methods_.end());
+      descriptor = &(extra_input_methods_[input_method_id_to_switch]);
+    } else {
       descriptor =
           util_.GetInputMethodDescriptorFromId(input_method_id_to_switch);
-    } else {
-      std::map<std::string, InputMethodDescriptor>::const_iterator i =
-          extra_input_methods_.find(input_method_id_to_switch);
-      DCHECK(i != extra_input_methods_.end());
-      descriptor = &(i->second);
     }
     DCHECK(descriptor);
 
     previous_input_method_ = current_input_method_;
     current_input_method_ = *descriptor;
   }
 
   // Change the keyboard layout to a preferred layout for the input method.
   if (!xkeyboard_->SetCurrentKeyboardLayoutByName(
           current_input_method_.GetPreferredKeyboardLayout())) {
@@ skipping 304 matching lines @@
   if (iter != input_method_ids.end())
     ++iter;
   if (iter == input_method_ids.end())
     iter = input_method_ids.begin();
   ChangeInputMethodInternal(*iter, true);
 }
 
 InputMethodDescriptor InputMethodManagerImpl::GetCurrentInputMethod() const {
   if (current_input_method_.id().empty())
     return InputMethodUtil::GetFallbackInputMethodDescriptor();
+
   return current_input_method_;
 }
 
 InputMethodPropertyList
 InputMethodManagerImpl::GetCurrentInputMethodProperties() const {
   // This check is necessary since an IME property (e.g. for Pinyin) might be
   // sent from ibus-daemon AFTER the current input method is switched to XKB.
   if (InputMethodUtil::IsKeyboardLayout(GetCurrentInputMethod().id()))
     return InputMethodPropertyList();  // Empty list.
   return property_list_;
@@ skipping 136 matching lines @@
   if (candidate_window_controller_.get())
     return;
 
   candidate_window_controller_.reset(
       CandidateWindowController::CreateCandidateWindowController());
   candidate_window_controller_->AddObserver(this);
 }
 
 }  // namespace input_method
 }  // namespace chromeos