Start the IME Daemon when adding an extension IME

chrome/browser/chromeos/input_method/input_method_manager.cc

 // Copyright (c) 2011 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.h"
 
 #include <algorithm>
 
 #include <glib.h>
 
@@ skipping 366 matching lines @@
     // Before calling FlushImeConfig(), start input method process if necessary.
     MaybeStartInputMethodDaemon(section, config_name, value);
 
     const ConfigKeyType key = std::make_pair(section, config_name);
     current_config_values_[key] = value;
     if (ime_connected_) {
       pending_config_requests_[key] = value;
       FlushImeConfig();
     }
 
-    // Stop input method process if necessary.
-    MaybeStopInputMethodDaemon(section, config_name, value);
+    if (section == language_prefs::kGeneralSectionName &&
+        config_name == language_prefs::kPreloadEnginesConfigName) {
+      // Stop input method process if necessary.
+      MaybeStopInputMethodDaemon();
+    }
     // Change the current keyboard layout if necessary.
     MaybeChangeCurrentKeyboardLayout(section, config_name, value);
     return pending_config_requests_.empty();
   }
 
   // TODO(yusukes): Support input method specific hotkeys.
   virtual void AddActiveIme(const std::string& id,
                             const std::string& name,
                             const std::vector<std::string>& layouts,
                             const std::string& language) {
     std::string virtual_layouts = JoinString(layouts, ',');
 
     extra_input_method_ids_[id] = ibus_controller_->CreateInputMethodDescriptor(
         id, name, virtual_layouts, language);
     active_input_method_ids_.push_back(id);
     // TODO(yusukes): Call UpdateInputMethodSpecificHotkeys() here once IME
     // extension supports hotkeys.
+
+    // Ensure that the input method daemon is running.
+    StartInputMethodDaemon();
   }
 
   virtual void RemoveActiveIme(const std::string& id) {
     std::vector<std::string>::iterator ix =
         std::find(active_input_method_ids_.begin(),
                   active_input_method_ids_.end(),
                   id);
     if (ix != active_input_method_ids_.end()) {
       active_input_method_ids_.erase(ix);
     }
     extra_input_method_ids_.erase(id);
     // TODO(yusukes): Call UpdateInputMethodSpecificHotkeys() here once IME
     // extension supports hotkeys.
+
+    // Stop the IME daemon if needed.
+    MaybeStopInputMethodDaemon();
   }
 
   virtual bool GetExtraDescriptor(const std::string& id,
                                   InputMethodDescriptor* descriptor) {
     std::map<std::string, InputMethodDescriptor>::const_iterator ix =
         extra_input_method_ids_.find(id);
     if (ix != extra_input_method_ids_.end()) {
       *descriptor = ix->second;
       return true;
     } else {
@@ skipping 152 matching lines @@
   static InputMethodManagerImpl* GetInstance() {
     return Singleton<InputMethodManagerImpl,
         DefaultSingletonTraits<InputMethodManagerImpl> >::get();
   }
 
  private:
   friend struct DefaultSingletonTraits<InputMethodManagerImpl>;
 
   // Returns true if the given input method config value is a string list
   // that only contains an input method ID of a keyboard layout.
-  bool ContainOnlyKeyboardLayout(const ImeConfigValue& value) {
-    if (value.type != ImeConfigValue::kValueTypeStringList) {
-      return false;
-    }
-    for (size_t i = 0; i < value.string_list_value.size(); ++i) {
-      if (!InputMethodUtil::IsKeyboardLayout(value.string_list_value[i])) {
+  bool ContainOnlyKeyboardLayout(const std::vector<std::string>& value) {
+    for (size_t i = 0; i < value.size(); ++i) {
+      if (!InputMethodUtil::IsKeyboardLayout(value[i])) {
         return false;
       }
     }
     return true;
   }
 
   // Starts input method daemon based on the |defer_ime_startup_| flag and
   // input method configuration being updated. |section| is a section name of
   // the input method configuration (e.g. "general", "general/hotkey").
   // |config_name| is a name of the configuration (e.g. "preload_engines",
   // "previous_engine"). |value| is the configuration value to be set.
   void MaybeStartInputMethodDaemon(const std::string& section,
                                    const std::string& config_name,
                                    const ImeConfigValue& value) {
     if (section == language_prefs::kGeneralSectionName &&
         config_name == language_prefs::kPreloadEnginesConfigName &&
         value.type == ImeConfigValue::kValueTypeStringList &&
         !value.string_list_value.empty()) {
       // If there is only one input method which is a keyboard layout,
       // we don't start the input method processes.  When
       // |defer_ime_startup_| is true, we don't start it either.
-      if (ContainOnlyKeyboardLayout(value) || defer_ime_startup_) {
+      if (ContainOnlyKeyboardLayout(value.string_list_value) ||
+          defer_ime_startup_) {
         // Do not start the input method daemon.
         return;
       }
 
       // Otherwise, start the input method daemon.
       const bool just_started = StartInputMethodDaemon();
       if (!just_started) {
         // The daemon is already running.
         // Do not |update tentative_current_input_method_id_|.
         return;
@@ skipping 23 matching lines @@
         // in the list, |value.string_list_value[0]|, and send global engine
         // changed signal to Chrome. See crosbug.com/13406.
         tentative_current_input_method_id_.clear();
       }
     }
   }
 
   // Stops input method daemon based on the |enable_auto_ime_shutdown_| flag
   // and input method configuration being updated.
   // See also: MaybeStartInputMethodDaemon().
-  void MaybeStopInputMethodDaemon(const std::string& section,
-                                  const std::string& config_name,
-                                  const ImeConfigValue& value) {
+  void MaybeStopInputMethodDaemon() {
     // If there is only one input method which is a keyboard layout,
     // and |enable_auto_ime_shutdown_| is true, we'll stop the input
     // method daemon.
-    if (section == language_prefs::kGeneralSectionName &&
-        config_name == language_prefs::kPreloadEnginesConfigName &&
-        ContainOnlyKeyboardLayout(value) &&
+    if (ContainOnlyKeyboardLayout(active_input_method_ids_) &&
         enable_auto_ime_shutdown_) {
       if (StopInputMethodDaemon()) {
         // The process is killed. Change the current keyboard layout.
         // We shouldn't use SetCurrentKeyboardLayoutByName() here. See
         // comments at ChangeCurrentInputMethod() for details.
-        ChangeCurrentInputMethodFromId(value.string_list_value[0]);
+        ChangeCurrentInputMethodFromId(active_input_method_ids_[0]);
       }
     }
   }
 
   // Change the keyboard layout per input method configuration being
   // updated, if necessary. See also: MaybeStartInputMethodDaemon().
   void MaybeChangeCurrentKeyboardLayout(const std::string& section,
                                         const std::string& config_name,
                                         const ImeConfigValue& value) {
     if (section == language_prefs::kGeneralSectionName &&
@@ skipping 702 matching lines @@
   return InputMethodManagerImpl::GetInstance();
 }
 
 }  // namespace input_method
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(
     chromeos::input_method::InputMethodManagerImpl);