chrome/browser/chromeos/input_method/ refactoring [part 6 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 116 matching lines @@
                              false,
                              PrefService::SYNCABLE_PREF);
   // We don't sync prefs::kLanguageCurrentInputMethod and PreviousInputMethod
   // because they're just used to track the logout state of the device.
   prefs->RegisterStringPref(prefs::kLanguageCurrentInputMethod,
                             "",
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(prefs::kLanguagePreviousInputMethod,
                             "",
                             PrefService::UNSYNCABLE_PREF);
-  // We don't sync input method hotkeys since they're not configurable.
-  prefs->RegisterStringPref(prefs::kLanguageHotkeyNextEngineInMenu,
-                            language_prefs::kHotkeyNextEngineInMenu,
-                            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,
                             hardware_keyboard_id,
                             PrefService::UNSYNCABLE_PREF);
   for (size_t i = 0; i < language_prefs::kNumChewingBooleanPrefs; ++i) {
@@ skipping 117 matching lines @@
   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,
                                    prefs, this);
   primary_mouse_button_right_.Init(prefs::kPrimaryMouseButtonRight,
                                    prefs, this);
-  hotkey_next_engine_in_menu_.Init(
-      prefs::kLanguageHotkeyNextEngineInMenu, prefs, this);
-  hotkey_previous_engine_.Init(
-      prefs::kLanguageHotkeyPreviousEngine, prefs, this);
   preferred_languages_.Init(prefs::kLanguagePreferredLanguages,
                             prefs, this);
   preload_engines_.Init(prefs::kLanguagePreloadEngines, prefs, this);
   current_input_method_.Init(prefs::kLanguageCurrentInputMethod, prefs, this);
   previous_input_method_.Init(prefs::kLanguagePreviousInputMethod, prefs, this);
 
   for (size_t i = 0; i < language_prefs::kNumChewingBooleanPrefs; ++i) {
     chewing_boolean_prefs_[i].Init(
         language_prefs::kChewingBooleanPrefs[i].pref_name, prefs, this);
   }
@@ skipping 120 matching lines @@
   }
   if (!pref_name || *pref_name == prefs::kPrimaryMouseButtonRight) {
     const bool right = primary_mouse_button_right_.GetValue();
     system::mouse_settings::SetPrimaryButtonRight(right);
     if (pref_name)
       UMA_HISTOGRAM_BOOLEAN("Mouse.PrimaryButtonRight.Changed", right);
     else
       UMA_HISTOGRAM_BOOLEAN("Mouse.PrimaryButtonRight.Started", right);
   }
 
-  if (!pref_name || *pref_name == prefs::kLanguageHotkeyNextEngineInMenu) {
-    SetLanguageConfigStringListAsCSV(
-        language_prefs::kHotKeySectionName,
-        language_prefs::kNextEngineInMenuConfigName,
-        hotkey_next_engine_in_menu_.GetValue());
-  }
-  if (!pref_name || *pref_name == prefs::kLanguageHotkeyPreviousEngine) {
-    SetLanguageConfigStringListAsCSV(
-        language_prefs::kHotKeySectionName,
-        language_prefs::kPreviousEngineConfigName,
-        hotkey_previous_engine_.GetValue());
-  }
   if (!pref_name || *pref_name == prefs::kLanguagePreferredLanguages) {
     // Unlike kLanguagePreloadEngines and some other input method
     // preferencs, we don't need to send this to ibus-daemon.
   }
 
   // Here, we set up the the modifier key mapping. This has to be done
   // before changing the current keyboard layout, so that the modifier key
   // preference is properly preserved. For this reason, we should do this
   // before setting preload engines, that could change the current
   // keyboard layout as needed.
@@ skipping 169 matching lines @@
 
 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);
 
+  if (section == std::string(language_prefs::kGeneralSectionName) &&
+      name == std::string(language_prefs::kPreloadEnginesConfigName)) {
+    input_method_manager_->EnableInputMethods(split_values);
+    return;
+  }
+
   // 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
@@ skipping 56 matching lines @@
   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();
-  input_method_manager->ClearAllVirtualKeyboardPreferences();
-
+  // TODO(yusukes): Clear all virtual keyboard preferences here.
   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;
-    }
+    // TODO(yusukes): add the virtual keyboard preferences here.
   }
 
   // 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