Sync starting language and input method preferences

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"
@@ skipping 27 matching lines @@
 #include "chromeos/system/statistics_provider.h"
 #include "components/feedback/tracing_manager.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "third_party/icu/source/i18n/unicode/timezone.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_utils.h"
 #include "url/gurl.h"
 
 namespace chromeos {
 
+namespace {
+
 static const char kFallbackInputMethodLocale[] = "en-US";
 
+// Returns a copy of |old_value| with any unique CSVs from |new_value|
+// appended, a logical union that retains order. Quadratic runtime; use only
+// for small lists.

[michaelpg, 2014/06/04 01:12:02]

Why not use ListValues instead of StringValues for these preferences?

* The existing prefs already use strings
* This function will only be called at most once per device
* Given the nature of the preferences, time complexity is not 
  a concern
* There is no set-union for vectors which retains the pre-existing,
  non-sorted order (AFAIK) so this work is necessary anyway

+std::string MergeCSVs(const std::string& old_value,
+                      const std::string& new_value) {
+  std::string merged;
+  std::vector<std::string> old_tokens;
+  std::vector<std::string> new_tokens;
+
+  base::SplitString(old_value, ',', &old_tokens);
+  base::SplitString(new_value, ',', &new_tokens);
+
+  for (size_t i = 0; i < new_tokens.size(); i++) {
+    // Skip token if it's already in |old_tokens|.
+    if (std::find(old_tokens.begin(), old_tokens.end(), new_tokens[i]) ==
+        old_tokens.end())
+      old_tokens.push_back(new_tokens[i]);
+  }
+  return JoinString(old_tokens, ',');
+}
+
+// Merges one CSV pref into another using MergeCSVs.
+void MergeStringPrefs(StringPrefMember& to_pref,
+                      StringPrefMember& from_pref,
+                      const std::string& pref_name) {
+  std::string to_value = to_pref.GetValue();
+  std::string from_value = from_pref.GetValue();
+
+  std::string merged_value = MergeCSVs(to_value, from_value);
+  if (merged_value != to_value)
+    to_pref.SetValue(merged_value);
+}
+
+}  // anonymous namespace
+
 Preferences::Preferences()
     : prefs_(NULL),
       input_method_manager_(input_method::InputMethodManager::Get()),
+      should_merge_locale_prefs_(false),
       user_(NULL),
       user_is_primary_(false) {
   // Do not observe shell, if there is no shell instance; e.g., in some unit
   // tests.
   if (ash::Shell::HasInstance())
     ash::Shell::GetInstance()->AddShellObserver(this);
 }
 
 Preferences::Preferences(input_method::InputMethodManager* input_method_manager)
     : prefs_(NULL),
       input_method_manager_(input_method_manager),
+      should_merge_locale_prefs_(false),
       user_(NULL),
       user_is_primary_(false) {
   // Do not observe shell, if there is no shell instance; e.g., in some unit
   // tests.
   if (ash::Shell::HasInstance())
     ash::Shell::GetInstance()->AddShellObserver(this);
 }
 
 Preferences::~Preferences() {
   prefs_->RemoveObserver(this);
@@ skipping 132 matching lines @@
   // We don't sync prefs::kLanguageCurrentInputMethod and PreviousInputMethod
   // because they're just used to track the logout state of the device.
   registry->RegisterStringPref(
       prefs::kLanguageCurrentInputMethod,
       "",
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(
       prefs::kLanguagePreviousInputMethod,
       "",
       user_prefs::PrefRegistrySyncable::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
   registry->RegisterStringPref(
       prefs::kLanguagePreferredLanguages,
+      "",
+      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+  registry->RegisterStringPref(
+      prefs::kLanguagePreferredLanguagesLocal,

[Alexander Alekseev, 2014/06/04 14:20:57]

I think it is dangerous to change meaning of existing preference.
Would you mind adding prefs::kLanguagePreferredLanguagesSyncable ?

Even if you found and renamed all existing usage of kLanguagePreferredLanguages,
there might be pending CLs using kLanguagePreferredLanguages in current way.

       kFallbackInputMethodLocale,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(
       prefs::kLanguagePreloadEngines,
+      "",
+      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+  registry->RegisterStringPref(
+      prefs::kLanguagePreloadEnginesLocal,

[Alexander Alekseev, 2014/06/04 14:20:57]

The same for engines.

       hardware_keyboard_id,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(
       prefs::kLanguageEnabledExtensionImes,
       "",
+      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+  registry->RegisterStringPref(
+      prefs::kLanguageEnabledExtensionImesLocal,
+      "",

[Alexander Alekseev, 2014/06/04 14:20:57]

The same for EnabledExtensionsImes

       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 
   registry->RegisterIntegerPref(
       prefs::kLanguageRemapSearchKeyTo,
       input_method::kSearchKey,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF);
   registry->RegisterIntegerPref(
       prefs::kLanguageRemapControlKeyTo,
       input_method::kControlKey,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF);
@@ skipping 82 matching lines @@
       prefs, callback);
   natural_scroll_.Init(prefs::kNaturalScroll, prefs, callback);
   mouse_sensitivity_.Init(prefs::kMouseSensitivity, prefs, callback);
   touchpad_sensitivity_.Init(prefs::kTouchpadSensitivity, prefs, callback);
   primary_mouse_button_right_.Init(prefs::kPrimaryMouseButtonRight,
                                    prefs, callback);
   download_default_directory_.Init(prefs::kDownloadDefaultDirectory,
                                    prefs, callback);
   touch_hud_projection_enabled_.Init(prefs::kTouchHudProjectionEnabled,
                                      prefs, callback);
+  preferred_languages_.Init(prefs::kLanguagePreferredLanguages,
+                            prefs, callback);
+  preferred_languages_local_.Init(prefs::kLanguagePreferredLanguagesLocal,
+                                  prefs, callback);
   preload_engines_.Init(prefs::kLanguagePreloadEngines, prefs, callback);
+  preload_engines_local_.Init(prefs::kLanguagePreloadEnginesLocal,
+                              prefs, callback);
   enabled_extension_imes_.Init(prefs::kLanguageEnabledExtensionImes,
                                prefs, callback);
+  enabled_extension_imes_local_.Init(prefs::kLanguageEnabledExtensionImesLocal,
+                                     prefs, callback);
   current_input_method_.Init(prefs::kLanguageCurrentInputMethod,
                              prefs, callback);
   previous_input_method_.Init(prefs::kLanguagePreviousInputMethod,
                               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(
@@ skipping 36 matching lines @@
   ApplyPreferences(REASON_PREF_CHANGED, pref_name);
 }
 
 void Preferences::ApplyPreferences(ApplyReason reason,
                                    const std::string& pref_name) {
   DCHECK(reason != REASON_PREF_CHANGED || !pref_name.empty());
   const bool user_is_owner =
       UserManager::Get()->GetOwnerEmail() == user_->email();
   const bool user_is_active = user_->is_active();
 
+  if (reason == REASON_INITIALIZATION) {
+    // Check that the global language/input preferences have been set.
+    if (prefs_->FindPreference(prefs::kLanguagePreferredLanguages)->
+        HasUserSetting()) {
+      // If no local value has been set, this is a pre-existing profile.
+      if (!prefs_->FindPreference(prefs::kLanguagePreferredLanguagesLocal)->
+          HasUserSetting()) {
+        // Migrate to using local values by copying the global values.
+        preferred_languages_local_.SetValue(preferred_languages_.GetValue());
+        preload_engines_local_.SetValue(preload_engines_.GetValue());

[Alexander Alekseev, 2014/06/04 14:23:56]

The same as my comment below: the list of supported languages and extensions
might be different across devices.

+        enabled_extension_imes_local_.SetValue(
+            enabled_extension_imes_.GetValue());

[Alexander Alekseev, 2014/06/04 14:20:57]

This is dangerous, as you do not check that remote values are supported locally.
Remote values can be either from older version of chrome, or from newer version.
Also you cannot guarantee that list of supported extensions is the same on all
platforms.

+      } else {
+        should_merge_locale_prefs_ = false;
+      }
+    } else {
+      // The global preference hasn't been set, so we need to sync and merge it.
+      should_merge_locale_prefs_ = true;
+    }
+  }
+
   system::TouchpadSettings touchpad_settings;
   system::MouseSettings mouse_settings;
 
   if (user_is_primary_ && (reason == REASON_INITIALIZATION ||
                            pref_name == prefs::kPerformanceTracingEnabled)) {
     const bool enabled = performance_tracing_enabled_.GetValue();
     if (enabled)
       tracing_manager_ = TracingManager::Create();
     else
       tracing_manager_.reset();
@@ skipping 103 matching lines @@
           default_download_to_drive);
     else if (reason == REASON_INITIALIZATION)
       UMA_HISTOGRAM_BOOLEAN(
           "FileBrowser.DownloadDestination.IsGoogleDrive.Started",
           default_download_to_drive);
   }
   if (reason != REASON_PREF_CHANGED ||
       pref_name == prefs::kTouchHudProjectionEnabled) {
     if (user_is_active) {
       const bool enabled = touch_hud_projection_enabled_.GetValue();
-      ash::Shell::GetInstance()->SetTouchHudProjectionEnabled(enabled);
+      // There may not be a shell, e.g., in some unit tests.
+      if (ash::Shell::HasInstance())
+        ash::Shell::GetInstance()->SetTouchHudProjectionEnabled(enabled);
     }
   }
 
   if (reason != REASON_PREF_CHANGED ||
       pref_name == prefs::kLanguageXkbAutoRepeatEnabled) {
     if (user_is_active) {
       const bool enabled = xkb_auto_repeat_enabled_.GetValue();
       input_method::InputMethodManager::Get()
           ->GetImeKeyboard()
           ->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 &&
+      pref_name == prefs::kLanguagePreferredLanguagesLocal)
+    SetSyncedLocalePrefs();
+
   if (reason != REASON_PREF_CHANGED && user_is_active) {
     SetInputMethodList();
-  } else if (pref_name == prefs::kLanguagePreloadEngines && user_is_active) {
-    SetLanguageConfigStringListAsCSV(language_prefs::kGeneralSectionName,
-                                     language_prefs::kPreloadEnginesConfigName,
-                                     preload_engines_.GetValue());
+  } else if (pref_name == prefs::kLanguagePreloadEnginesLocal) {
+    if (user_is_active) {
+      SetLanguageConfigStringListAsCSV(
+          language_prefs::kGeneralSectionName,
+          language_prefs::kPreloadEnginesConfigName,
+          preload_engines_local_.GetValue());
+    }
+    SetSyncedLocalePrefs();
   }
 
   if (reason != REASON_PREF_CHANGED ||
-      pref_name == prefs::kLanguageEnabledExtensionImes) {
-    if (user_is_active) {
-      std::string value(enabled_extension_imes_.GetValue());
-
-      std::vector<std::string> split_values;
-      if (!value.empty())
-        base::SplitString(value, ',', &split_values);
-
-      input_method_manager_->SetEnabledExtensionImes(&split_values);
-    }
+      pref_name == prefs::kLanguageEnabledExtensionImesLocal) {
+    if (user_is_active)
+      SetEnabledExtensionImes();
+    if (reason == REASON_PREF_CHANGED)
+      SetSyncedLocalePrefs();
   }
 
   if (user_is_active) {
     system::InputDeviceSettings::Get()->UpdateTouchpadSettings(
         touchpad_settings);
     system::InputDeviceSettings::Get()->UpdateMouseSettings(mouse_settings);
   }
 }
 
 void Preferences::OnIsSyncingChanged() {
   DVLOG(1) << "OnIsSyncingChanged";
   ForceNaturalScrollDefault();
+
+  if (should_merge_locale_prefs_ && prefs_->IsSyncing()) {
+    should_merge_locale_prefs_ = false;
+    MergeStringPrefs(preferred_languages_local_,
+                     preferred_languages_,
+                     prefs::kLanguagePreferredLanguagesLocal);
+    MergeStringPrefs(preload_engines_local_,
+                     preload_engines_,
+                     prefs::kLanguagePreloadEnginesLocal);
+    MergeStringPrefs(enabled_extension_imes_local_,
+                     enabled_extension_imes_,
+                     prefs::kLanguageEnabledExtensionImesLocal);
+
+    SetLanguageConfigStringListAsCSV(language_prefs::kGeneralSectionName,
+                                     language_prefs::kPreloadEnginesConfigName,
+                                     preload_engines_local_.GetValue());
+    SetEnabledExtensionImes();
+    SetSyncedLocalePrefs();
+  }
 }
 
 void Preferences::ForceNaturalScrollDefault() {
   DVLOG(1) << "ForceNaturalScrollDefault";
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kNaturalScrollDefault) &&
       prefs_->IsSyncing() &&
       !prefs_->GetUserPrefValue(prefs::kNaturalScroll)) {
     DVLOG(1) << "Natural scroll forced to true";
     natural_scroll_.SetValue(true);
     UMA_HISTOGRAM_BOOLEAN("Touchpad.NaturalScroll.Forced", true);
   }
 }
 
 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);
 
   // Transfers the xkb id to extension-xkb id.
   if (input_method_manager_->MigrateInputMethods(&split_values))
-    preload_engines_.SetValue(JoinString(split_values, ','));
+    preload_engines_local_.SetValue(JoinString(split_values, ','));
 
   if (section == std::string(language_prefs::kGeneralSectionName) &&
       name == std::string(language_prefs::kPreloadEnginesConfigName)) {
     input_method_manager_->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.
+  // When |preload_engines_local_| are set,
+  // InputMethodManager::ChangeInputMethod() might be called to change the
+  // current input method to the first one in the |preload_engines_local_| 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());
+                                   preload_engines_local_.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.
+  // ChangeInputMethod() has to be called AFTER the value of
+  // |preload_engines_local_| 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::SetEnabledExtensionImes() {
+  std::string value(enabled_extension_imes_local_.GetValue());
+  std::vector<std::string> split_values;
+  if (!value.empty())
+    base::SplitString(value, ',', &split_values);
+  input_method_manager_->SetEnabledExtensionImes(&split_values);
+}
+
+void Preferences::SetSyncedLocalePrefs() {
+  // Set the language and input prefs at the same time. Otherwise, we may,
+  // e.g., use a stale languages setting but push a new preload engines setting.
+  if (!should_merge_locale_prefs_) {
+    preferred_languages_.SetValue(preferred_languages_local_.GetValue());
+    preload_engines_.SetValue(preload_engines_local_.GetValue());
+    enabled_extension_imes_.SetValue(enabled_extension_imes_local_.GetValue());
+  }
+}
+
 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* active_user) {
   if (active_user != user_)
     return;
   ApplyPreferences(REASON_ACTIVE_USER_CHANGED, "");
 }
 
 }  // namespace chromeos