chrome/browser/chromeos/input_method/ refactoring [part 5 of 6]

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 "base/chromeos/chromeos_version.h"
 #include "base/command_line.h"
 #include "base/i18n/time_formatting.h"
 #include "base/metrics/histogram.h"
@@ skipping 28 matching lines @@
   std::string board;
   system::StatisticsProvider::GetInstance()->GetMachineStatistic(
       "CHROMEOS_RELEASE_BOARD", &board);
   return StartsWithASCII(board, "lumpy", false);
 }
 
 }  // namespace
 
 static const char kFallbackInputMethodLocale[] = "en-US";
 
-Preferences::Preferences() {}
+Preferences::Preferences()
+    : input_method_manager_(input_method::InputMethodManager::GetInstance()) {
+}
+
+Preferences::Preferences(input_method::InputMethodManager* input_method_manager)
+    : input_method_manager_(input_method_manager) {
+}
 
 Preferences::~Preferences() {}
 
 // static
 void Preferences::RegisterUserPrefs(PrefService* prefs) {
-  input_method::InputMethodManager* manager =
-      input_method::InputMethodManager::GetInstance();
+  std::string hardware_keyboard_id;
+  // TODO(yusukes): Remove the runtime hack.
+  if (base::chromeos::IsRunningOnChromeOS()) {
+    input_method::InputMethodManager* manager =
+        input_method::InputMethodManager::GetInstance();
+    hardware_keyboard_id =
+        manager->GetInputMethodUtil()->GetHardwareInputMethodId();
+  } else {
+    hardware_keyboard_id = "xkb:us::eng";  // only for testing.
+  }
 
   const bool enable_tap_to_click_default = IsLumpy();
   prefs->RegisterBooleanPref(prefs::kTapToClickEnabled,
                              enable_tap_to_click_default,
                              PrefService::SYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kNaturalScroll,
                              false,
                              PrefService::SYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kPrimaryMouseButtonRight,
                              false,
@@ skipping 59 matching lines @@
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(prefs::kLanguageHotkeyPreviousEngine,
                             language_prefs::kHotkeyPreviousEngine,
                             PrefService::UNSYNCABLE_PREF);
   // We don't sync the list of input methods and preferred languages since a
   // user might use two or more devices with different hardware keyboards.
   // crosbug.com/15181
   prefs->RegisterStringPref(prefs::kLanguagePreferredLanguages,
                             kFallbackInputMethodLocale,
                             PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterStringPref(
-      prefs::kLanguagePreloadEngines,
-      manager->GetInputMethodUtil()->GetHardwareInputMethodId(),
-      PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterStringPref(prefs::kLanguagePreloadEngines,
+                            hardware_keyboard_id,
+                            PrefService::UNSYNCABLE_PREF);
   for (size_t i = 0; i < language_prefs::kNumChewingBooleanPrefs; ++i) {
     prefs->RegisterBooleanPref(
         language_prefs::kChewingBooleanPrefs[i].pref_name,
         language_prefs::kChewingBooleanPrefs[i].default_pref_value,
         language_prefs::kChewingBooleanPrefs[i].sync_status);
   }
   for (size_t i = 0; i < language_prefs::kNumChewingMultipleChoicePrefs; ++i) {
     prefs->RegisterStringPref(
         language_prefs::kChewingMultipleChoicePrefs[i].pref_name,
         language_prefs::kChewingMultipleChoicePrefs[i].default_pref_value,
@@ skipping 94 matching lines @@
 
   // OAuth1 all access token and secret pair.
   prefs->RegisterStringPref(prefs::kOAuth1Token,
                             "",
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(prefs::kOAuth1Secret,
                             "",
                             PrefService::UNSYNCABLE_PREF);
 }
 
-void Preferences::Init(PrefService* prefs) {
+void Preferences::InitUserPrefs(PrefService* prefs) {
   tap_to_click_enabled_.Init(prefs::kTapToClickEnabled, prefs, this);
   natural_scroll_.Init(prefs::kNaturalScroll, prefs, this);
   accessibility_enabled_.Init(prefs::kSpokenFeedbackEnabled, prefs, this);
   mouse_sensitivity_.Init(prefs::kMouseSensitivity, prefs, this);
   touchpad_sensitivity_.Init(prefs::kTouchpadSensitivity, prefs, this);
   use_24hour_clock_.Init(prefs::kUse24HourClock, prefs, this);
   disable_gdata_.Init(prefs::kDisableGData, prefs, this);
   disable_gdata_over_cellular_.Init(prefs::kDisableGDataOverCellular,
                                    prefs, this);
   disable_gdata_hosted_files_.Init(prefs::kDisableGDataHostedFiles,
@@ skipping 56 matching lines @@
   xkb_remap_alt_key_to_.Init(
       prefs::kLanguageXkbRemapAltKeyTo, prefs, this);
   xkb_auto_repeat_enabled_.Init(
       prefs::kLanguageXkbAutoRepeatEnabled, prefs, this);
   xkb_auto_repeat_delay_pref_.Init(
       prefs::kLanguageXkbAutoRepeatDelay, prefs, this);
   xkb_auto_repeat_interval_pref_.Init(
       prefs::kLanguageXkbAutoRepeatInterval, prefs, this);
 
   enable_screen_lock_.Init(prefs::kEnableScreenLock, prefs, this);
+}
+
+void Preferences::Init(PrefService* prefs) {
+  InitUserPrefs(prefs);
 
   // Initialize preferences to currently saved state.
   NotifyPrefChanged(NULL);
 
   // Initialize virtual keyboard settings to currently saved state.
   UpdateVirturalKeyboardPreference(prefs);
 
   // If a guest is logged in, initialize the prefs as if this is the first
   // login.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kGuestSession)) {
     LoginUtils::Get()->SetFirstLoginPrefs(prefs);
   }
 }
 
+void Preferences::InitUserPrefsForTesting(PrefService* prefs) {
+  InitUserPrefs(prefs);
+}
+
+void Preferences::SetInputMethodListForTesting() {
+  SetInputMethodList();
+}
+
 void Preferences::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_PREF_CHANGED)
     NotifyPrefChanged(content::Details<std::string>(details).ptr());
 }
 
 void Preferences::NotifyPrefChanged(const std::string* pref_name) {
   if (!pref_name || *pref_name == prefs::kTapToClickEnabled) {
     const bool enabled = tap_to_click_enabled_.GetValue();
@@ skipping 71 matching lines @@
   }
   if (!pref_name || *pref_name == prefs::kLanguageXkbAutoRepeatEnabled) {
     const bool enabled = xkb_auto_repeat_enabled_.GetValue();
     input_method::XKeyboard::SetAutoRepeatEnabled(enabled);
   }
   if (!pref_name || ((*pref_name == prefs::kLanguageXkbAutoRepeatDelay) ||
                      (*pref_name == prefs::kLanguageXkbAutoRepeatInterval))) {
     UpdateAutoRepeatRate();
   }
 
-  if (!pref_name || *pref_name == prefs::kLanguagePreloadEngines) {
+  if (!pref_name) {
+    SetInputMethodList();
+  } else if (*pref_name == prefs::kLanguagePreloadEngines) {
     SetLanguageConfigStringListAsCSV(language_prefs::kGeneralSectionName,
                                      language_prefs::kPreloadEnginesConfigName,
                                      preload_engines_.GetValue());
   }
 
-  // Do not check |*pref_name| for the two prefs. We're only interested in
-  // initial values of the prefs.
-  if (!pref_name) {
-    const std::string previous_input_method_id =
-        previous_input_method_.GetValue();
-    const std::string current_input_method_id =
-        current_input_method_.GetValue();
-    // NOTICE: 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.
-    input_method::InputMethodManager* manager =
-        input_method::InputMethodManager::GetInstance();
-    if (!previous_input_method_id.empty())
-      manager->ChangeInputMethod(previous_input_method_id);
-    if (!current_input_method_id.empty())
-      manager->ChangeInputMethod(current_input_method_id);
-  }
+  // Do not check |*pref_name| of the prefs for remembering current/previous
+  // input methods here. We're only interested in initial values of the prefs.
 
   for (size_t i = 0; i < language_prefs::kNumChewingBooleanPrefs; ++i) {
     if (!pref_name ||
         *pref_name == language_prefs::kChewingBooleanPrefs[i].pref_name) {
       SetLanguageConfigBoolean(
           language_prefs::kChewingSectionName,
           language_prefs::kChewingBooleanPrefs[i].ibus_config_name,
           chewing_boolean_prefs_[i].GetValue());
     }
   }
@@ skipping 93 matching lines @@
         enable_screen_lock_.GetValue());
   }
 }
 
 void Preferences::SetLanguageConfigBoolean(const char* section,
                                            const char* name,
                                            bool value) {
   input_method::InputMethodConfigValue config;
   config.type = input_method::InputMethodConfigValue::kValueTypeBool;
   config.bool_value = value;
-  input_method::InputMethodManager::GetInstance()->
-      SetInputMethodConfig(section, name, config);
+  input_method_manager_->SetInputMethodConfig(section, name, config);
 }
 
 void Preferences::SetLanguageConfigInteger(const char* section,
                                            const char* name,
                                            int value) {
   input_method::InputMethodConfigValue config;
   config.type = input_method::InputMethodConfigValue::kValueTypeInt;
   config.int_value = value;
-  input_method::InputMethodManager::GetInstance()->
-      SetInputMethodConfig(section, name, config);
+  input_method_manager_->SetInputMethodConfig(section, name, config);
 }
 
 void Preferences::SetLanguageConfigString(const char* section,
                                           const char* name,
                                           const std::string& value) {
   input_method::InputMethodConfigValue config;
   config.type = input_method::InputMethodConfigValue::kValueTypeString;
   config.string_value = value;
-  input_method::InputMethodManager::GetInstance()->
-      SetInputMethodConfig(section, name, config);
+  input_method_manager_->SetInputMethodConfig(section, name, config);
 }
 
 void Preferences::SetLanguageConfigStringList(
     const char* section,
     const char* name,
     const std::vector<std::string>& values) {
   input_method::InputMethodConfigValue config;
   config.type = input_method::InputMethodConfigValue::kValueTypeStringList;
   for (size_t i = 0; i < values.size(); ++i)
     config.string_list_value.push_back(values[i]);
 
-  input_method::InputMethodManager::GetInstance()->
-      SetInputMethodConfig(section, name, config);
+  input_method_manager_->SetInputMethodConfig(section, name, config);
 }
 
 void Preferences::SetLanguageConfigStringListAsCSV(const char* section,
                                                    const char* name,
                                                    const std::string& value) {
   VLOG(1) << "Setting " << name << " to '" << value << "'";
 
   std::vector<std::string> split_values;
   if (!value.empty())
     base::SplitString(value, ',', &split_values);
 
   // We should call the cros API even when |value| is empty, to disable default
   // config.
   SetLanguageConfigStringList(section, name, split_values);
 }
 
+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);
+  if (!current_input_method_id.empty())
+    input_method_manager_->ChangeInputMethod(current_input_method_id);
+}
+
 void Preferences::UpdateModifierKeyMapping() {
   const int search_remap = xkb_remap_search_key_to_.GetValue();
   const int control_remap = xkb_remap_control_key_to_.GetValue();
   const int alt_remap = xkb_remap_alt_key_to_.GetValue();
   if ((search_remap < input_method::kNumModifierKeys) && (search_remap >= 0) &&
       (control_remap < input_method::kNumModifierKeys) &&
       (control_remap >= 0) &&
       (alt_remap < input_method::kNumModifierKeys) && (alt_remap >= 0)) {
     input_method::ModifierMap modifier_map;
     modifier_map.push_back(
         input_method::ModifierKeyPair(
             input_method::kSearchKey,
             input_method::ModifierKey(search_remap)));
     modifier_map.push_back(
         input_method::ModifierKeyPair(
             input_method::kLeftControlKey,
             input_method::ModifierKey(control_remap)));
     modifier_map.push_back(
         input_method::ModifierKeyPair(
             input_method::kLeftAltKey,
             input_method::ModifierKey(alt_remap)));
-    input_method::InputMethodManager::GetInstance()->GetXKeyboard()->
-        RemapModifierKeys(modifier_map);
+    input_method_manager_->GetXKeyboard()->RemapModifierKeys(modifier_map);
   } else {
     LOG(ERROR) << "Failed to remap modifier keys. Unexpected value(s): "
                << search_remap << ", " << control_remap << ", " << alt_remap;
   }
 }
 
 void Preferences::UpdateAutoRepeatRate() {
   // Avoid setting repeat rate on desktop dev environment.
   if (!base::chromeos::IsRunningOnChromeOS())
     return;
 
   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::XKeyboard::SetAutoRepeatRate(rate);
 }
 
 void Preferences::UpdateVirturalKeyboardPreference(PrefService* prefs) {
   const DictionaryValue* virtual_keyboard_pref =
       prefs->GetDictionary(prefs::kLanguagePreferredVirtualKeyboard);
   DCHECK(virtual_keyboard_pref);
 
   input_method::InputMethodManager* input_method_manager =
       input_method::InputMethodManager::GetInstance();

[kinaba, 2012/04/12 06:02:01]

Just for confirmation, shouldn't this be replaced with the input_method_manager_
member variable? (Perhaps not, since this part is removed in the 6/6 CL.)

[Yusuke Sato, 2012/04/12 09:21:25]

good point, but actually the method is static. let me keep this as-is.

On 2012/04/12 06:02:01, kinaba wrote:

   input_method_manager->ClearAllVirtualKeyboardPreferences();
 
   std::string url;
   std::vector<std::string> layouts_to_remove;
   for (DictionaryValue::key_iterator iter = virtual_keyboard_pref->begin_keys();
        iter != virtual_keyboard_pref->end_keys();
        ++iter) {
     const std::string& layout_id = *iter;  // e.g. "us", "handwriting-vk"
     if (!virtual_keyboard_pref->GetString(layout_id, &url))
       continue;
     if (!input_method_manager->SetVirtualKeyboardPreference(
             layout_id, GURL(url))) {
       // Either |layout_id| or |url| is invalid. Remove the key from |prefs|
       // later.
       layouts_to_remove.push_back(layout_id);
       LOG(ERROR) << "Removing invalid virtual keyboard pref: layout="
                  << layout_id;
     }
   }
 
   // Remove invalid prefs.
   DictionaryPrefUpdate updater(prefs, prefs::kLanguagePreferredVirtualKeyboard);
   DictionaryValue* pref_value = updater.Get();
   for (size_t i = 0; i < layouts_to_remove.size(); ++i) {
     pref_value->RemoveWithoutPathExpansion(layouts_to_remove[i], NULL);
   }
 }
 
 }  // namespace chromeos