IME refactoring: ChromeOS introduce input methods State.

chrome/browser/chromeos/preferences.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/preferences.h"
 
 #include <vector>
 
 #include "ash/autoclick/autoclick_controller.h"
 #include "ash/magnifier/magnifier_constants.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/i18n/time_formatting.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/accessibility/magnification_manager.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/system/input_device_settings.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/ime/extension_ime_util.h"
 #include "chromeos/ime/ime_keyboard.h"
 #include "chromeos/ime/input_method_manager.h"
 #include "chromeos/system/statistics_provider.h"
@@ skipping 304 matching lines @@
                               prefs, callback);
 
   xkb_auto_repeat_enabled_.Init(
       prefs::kLanguageXkbAutoRepeatEnabled, prefs, callback);
   xkb_auto_repeat_delay_pref_.Init(
       prefs::kLanguageXkbAutoRepeatDelay, prefs, callback);
   xkb_auto_repeat_interval_pref_.Init(
       prefs::kLanguageXkbAutoRepeatInterval, prefs, callback);
 }
 
-void Preferences::Init(PrefServiceSyncable* prefs,
-                       const user_manager::User* user) {
+void Preferences::Init(Profile* profile, const user_manager::User* user) {
+  DCHECK(profile);
   DCHECK(user);
+  PrefServiceSyncable* prefs = PrefServiceSyncable::FromProfile(profile);
   user_ = user;
   user_is_primary_ =
       user_manager::UserManager::Get()->GetPrimaryUser() == user_;
   InitUserPrefs(prefs);
 
   user_manager::UserManager::Get()->AddSessionStateObserver(this);
 
   // This causes OnIsSyncingChanged to be called when the value of
   // PrefService::IsSyncing() changes.
   prefs->AddObserver(this);
 
+  UserSessionManager* session_manager = UserSessionManager::GetInstance();
+  DCHECK(session_manager);
+  ime_state_ = session_manager->GetDefaultIMEState(
+      ProfileHelper::Get()->GetProfileByUser(user_));
+  input_method_manager_->SetState(ime_state_);
+
   // Initialize preferences to currently saved state.
   ApplyPreferences(REASON_INITIALIZATION, "");
 
   // If a guest is logged in, initialize the prefs as if this is the first
   // login. For a regular user this is done in
   // UserSessionManager::InitProfilePreferences().
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kGuestSession))
-    UserSessionManager::SetFirstLoginPrefs(prefs, std::string(), std::string());
+    session_manager->SetFirstLoginPrefs(profile, std::string(), std::string());
 }
 
-void Preferences::InitUserPrefsForTesting(PrefServiceSyncable* prefs,
-                                          const user_manager::User* user) {
+void Preferences::InitUserPrefsForTesting(
+    PrefServiceSyncable* prefs,
+    const user_manager::User* user,
+    scoped_refptr<input_method::InputMethodManager::State> ime_state) {
   user_ = user;
+  ime_state_ = ime_state;
+
+  if (ime_state)
+    input_method_manager_->SetState(ime_state);
+
   InitUserPrefs(prefs);
 }
 
 void Preferences::SetInputMethodListForTesting() {
   SetInputMethodList();
 }
 
 void Preferences::OnPreferenceChanged(const std::string& pref_name) {
   ApplyPreferences(REASON_PREF_CHANGED, pref_name);
 }
@@ skipping 141 matching lines @@
           ->SetAutoRepeatEnabled(enabled);
     }
   }
   if (reason != REASON_PREF_CHANGED ||
       pref_name == prefs::kLanguageXkbAutoRepeatDelay ||
       pref_name == prefs::kLanguageXkbAutoRepeatInterval) {
     if (user_is_active)
       UpdateAutoRepeatRate();
   }
 
-  if (reason != REASON_PREF_CHANGED && user_is_active) {
+  if (reason == REASON_INITIALIZATION)
     SetInputMethodList();
-  } else if (pref_name == prefs::kLanguagePreloadEngines && user_is_active) {
+
+  if (pref_name == prefs::kLanguagePreloadEngines &&
+      reason == REASON_PREF_CHANGED) {
     SetLanguageConfigStringListAsCSV(language_prefs::kGeneralSectionName,
                                      language_prefs::kPreloadEnginesConfigName,
                                      preload_engines_.GetValue());
   }
 
-  if (reason != REASON_PREF_CHANGED ||
-      pref_name == prefs::kLanguageEnabledExtensionImes) {
-    if (user_is_active) {
-      std::string value(enabled_extension_imes_.GetValue());
+  if ((reason == REASON_INITIALIZATION) ||
+      (pref_name == prefs::kLanguageEnabledExtensionImes &&
+       reason == REASON_PREF_CHANGED)) {
+    std::string value(enabled_extension_imes_.GetValue());
 
-      std::vector<std::string> split_values;
-      if (!value.empty())
-        base::SplitString(value, ',', &split_values);
+    std::vector<std::string> split_values;
+    if (!value.empty())
+      base::SplitString(value, ',', &split_values);
 
-      input_method_manager_->SetEnabledExtensionImes(&split_values);
-    }
+    ime_state_->SetEnabledExtensionImes(&split_values);
   }
 
   if (user_is_active) {
     system::InputDeviceSettings::Get()->UpdateTouchpadSettings(
         touchpad_settings);
     system::InputDeviceSettings::Get()->UpdateMouseSettings(mouse_settings);
   }
 }
 
 void Preferences::OnIsSyncingChanged() {
@@ skipping 21 matching lines @@
   std::vector<std::string> split_values;
   if (!value.empty())
     base::SplitString(value, ',', &split_values);
 
   // Transfers the xkb id to extension-xkb id.
   if (input_method_manager_->MigrateInputMethods(&split_values))
     preload_engines_.SetValue(JoinString(split_values, ','));
 
   if (section == std::string(language_prefs::kGeneralSectionName) &&
       name == std::string(language_prefs::kPreloadEnginesConfigName)) {
-    input_method_manager_->ReplaceEnabledInputMethods(split_values);
+    ime_state_->ReplaceEnabledInputMethods(split_values);
     return;
   }
 }
 
 void Preferences::SetInputMethodList() {
   // When |preload_engines_| are set, InputMethodManager::ChangeInputMethod()
   // might be called to change the current input method to the first one in the
   // |preload_engines_| list. This also updates previous/current input method
   // prefs. That's why GetValue() calls are placed before the
   // SetLanguageConfigStringListAsCSV() call below.
   const std::string previous_input_method_id =
       previous_input_method_.GetValue();
   const std::string current_input_method_id = current_input_method_.GetValue();
   SetLanguageConfigStringListAsCSV(language_prefs::kGeneralSectionName,
                                    language_prefs::kPreloadEnginesConfigName,
                                    preload_engines_.GetValue());
 
   // ChangeInputMethod() has to be called AFTER the value of |preload_engines_|
   // is sent to the InputMethodManager. Otherwise, the ChangeInputMethod request
   // might be ignored as an invalid input method ID. The ChangeInputMethod()
   // calls are also necessary to restore the previous/current input method prefs
   // which could have been modified by the SetLanguageConfigStringListAsCSV call
   // above to the original state.
   if (!previous_input_method_id.empty())
-    input_method_manager_->ChangeInputMethod(previous_input_method_id);
+    ime_state_->ChangeInputMethod(previous_input_method_id,
+                                  false /* show_message */);
   if (!current_input_method_id.empty())
-    input_method_manager_->ChangeInputMethod(current_input_method_id);
+    ime_state_->ChangeInputMethod(current_input_method_id,
+                                  false /* show_message */);
 }
 
 void Preferences::UpdateAutoRepeatRate() {
   input_method::AutoRepeatRate rate;
   rate.initial_delay_in_ms = xkb_auto_repeat_delay_pref_.GetValue();
   rate.repeat_interval_in_ms = xkb_auto_repeat_interval_pref_.GetValue();
   DCHECK(rate.initial_delay_in_ms > 0);
   DCHECK(rate.repeat_interval_in_ms > 0);
   input_method::InputMethodManager::Get()
       ->GetImeKeyboard()
       ->SetAutoRepeatRate(rate);
 }
 
 void Preferences::OnTouchHudProjectionToggled(bool enabled) {
   if (touch_hud_projection_enabled_.GetValue() == enabled)
     return;
   if (!user_->is_active())
     return;
   touch_hud_projection_enabled_.SetValue(enabled);
 }
 
 void Preferences::ActiveUserChanged(const user_manager::User* active_user) {
   if (active_user != user_)
     return;
   ApplyPreferences(REASON_ACTIVE_USER_CHANGED, "");
 }
 
 }  // namespace chromeos