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 <algorithm>
 
 #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/login/users/user.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/component_extension_ime_manager.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"
 #include "components/feedback/tracing_manager.h"
 #include "components/pref_registry/pref_registry_syncable.h"
+#include "content/public/browser/browser_thread.h"
 #include "third_party/icu/source/i18n/unicode/timezone.h"
+#include "ui/base/l10n/l10n_util.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";
 
+// Checks input method IDs, converting engine IDs to input method IDs and
+// removing unsupported IDs from |values|.
+void CheckAndResolveInputMethodIDs(
+    std::vector<std::string>* values,
+    const input_method::InputMethodDescriptors& supported_descriptors) {
+  // Extract the supported input method IDs into a set.
+  std::set<std::string> supported_input_method_ids;
+  for (size_t i = 0; i < supported_descriptors.size(); i++)
+    supported_input_method_ids.insert(supported_descriptors[i].id());
+
+  // Convert engine IDs to input method extension IDs.
+  std::transform(values->begin(), values->end(), values->begin(),
+                 extension_ime_util::GetInputMethodIDByEngineID);
+
+  // Remove values that aren't found in the set of supported input method IDs.
+  std::vector<std::string>::iterator it = values->begin();
+  while (it != values->end()) {
+    if (it->size() && std::find(supported_input_method_ids.begin(),
+                                supported_input_method_ids.end(),
+                                *it) != supported_input_method_ids.end()) {
+      ++it;
+    } else {
+      it = values->erase(it);
+    }
+  }
+}
+
+// Checks whether each language is supported, replacing locales with variants
+// if they are available. Must be called on a thread that allows IO.
+void CheckAndResolveLocales(std::string* languages) {
+  if (languages->empty())
+    return;
+  std::vector<std::string> values;
+  base::SplitString(*languages, ',', &values);
+
+  // Remove unsupported language values and set the resolved locales.
+  std::vector<std::string>::iterator value_iter = values.begin();
+  while (value_iter != values.end()) {
+    std::string resolved_locale;
+    if (l10n_util::CheckAndResolveLocale(*value_iter, &resolved_locale)) {
+      *value_iter = resolved_locale;
+      ++value_iter;
+    } else {
+      value_iter = values.erase(value_iter);
+    }
+  }
+
+  *languages = JoinString(values, ',');
+}
+
+// Appends tokens from |src| that are not in |dest| to |dest|. Quadratic
+// runtime; use only for small lists.
+void MergeLists(std::vector<std::string>* dest,
+                const std::vector<std::string>& src) {
+  for (size_t i = 0; i < src.size(); i++) {
+    // Skip token if it's already in |dest|.
+    if (std::find(dest->begin(), dest->end(), src[i]) == dest->end())
+      dest->push_back(src[i]);
+  }
+}
+
+// For the given input method pref, adds unique values from |synced_pref| to
+// values in |pref|. The new values are converted from legacy engine IDs to
+// input method IDs if necessary.
+std::string AddSupportedInputMethodValues(const std::string& pref,
+                                          const std::string& synced_pref,
+                                          const char* pref_name) {
+  std::vector<std::string> old_tokens;
+  std::vector<std::string> new_tokens;
+  base::SplitString(pref, ',', &old_tokens);
+  base::SplitString(synced_pref, ',', &new_tokens);
+
+  // Check and convert the new tokens.
+  if (pref_name == prefs::kLanguagePreloadEngines ||
+      pref_name == prefs::kLanguageEnabledExtensionImes) {
+    input_method::InputMethodManager* manager =
+        input_method::InputMethodManager::Get();
+    scoped_ptr<input_method::InputMethodDescriptors> supported_descriptors;
+
+    if (pref_name == prefs::kLanguagePreloadEngines) {
+      // Set the known input methods.
+      supported_descriptors = manager->GetSupportedInputMethods();
+      // Add the available component extension IMEs.
+      ComponentExtensionIMEManager* component_extension_manager =
+          manager->GetComponentExtensionIMEManager();
+      if (component_extension_manager->IsInitialized()) {
+        input_method::InputMethodDescriptors component_descriptors =
+            component_extension_manager->GetAllIMEAsInputMethodDescriptor();
+        supported_descriptors->insert(supported_descriptors->end(),
+                                      component_descriptors.begin(),
+                                      component_descriptors.end());
+      }
+    } else {
+      supported_descriptors.reset(new input_method::InputMethodDescriptors);
+      manager->GetInputMethodExtensions(supported_descriptors.get());
+    }
+    CheckAndResolveInputMethodIDs(&new_tokens, *supported_descriptors);
+  } else if (pref_name != prefs::kLanguagePreferredLanguages) {
+    NOTREACHED() << "Attempting to merge an invalid preference.";
+  }
+
+  // Do the actual merging.
+  MergeLists(&old_tokens, new_tokens);
+  return JoinString(old_tokens, ',');
+}
+
+}  // anonymous namespace
+
 Preferences::Preferences()
     : prefs_(NULL),
       input_method_manager_(input_method::InputMethodManager::Get()),
       user_(NULL),
-      user_is_primary_(false) {
+      user_is_primary_(false),
+      weak_factory_(this) {
   // 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),
       user_(NULL),
-      user_is_primary_(false) {
+      user_is_primary_(false),
+      weak_factory_(this) {
   // 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);
   UserManager::Get()->RemoveSessionStateObserver(this);
   // If shell instance is destoryed before this preferences instance, there is
@@ skipping 131 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,
       kFallbackInputMethodLocale,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(
+      prefs::kLanguagePreferredLanguagesSyncable,
+      "",
+      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+  registry->RegisterStringPref(
       prefs::kLanguagePreloadEngines,
       hardware_keyboard_id,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(
+      prefs::kLanguagePreloadEnginesSyncable,
+      "",
+      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+  registry->RegisterStringPref(
       prefs::kLanguageEnabledExtensionImes,
       "",
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterStringPref(
+      prefs::kLanguageEnabledExtensionImesSyncable,
+      "",
+      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+  registry->RegisterBooleanPref(
+      prefs::kLanguageShouldMergeInputMethods,
+      false,
+      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);
   registry->RegisterIntegerPref(
@@ skipping 86 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);
   preload_engines_.Init(prefs::kLanguagePreloadEngines, prefs, callback);
   enabled_extension_imes_.Init(prefs::kLanguageEnabledExtensionImes,
                                prefs, callback);
+  preferred_languages_syncable_.Init(prefs::kLanguagePreferredLanguagesSyncable,
+                                     prefs, callback);
+  preload_engines_syncable_.Init(prefs::kLanguagePreloadEnginesSyncable,
+                                 prefs, callback);
+  enabled_extension_imes_syncable_.Init(
+      prefs::kLanguageEnabledExtensionImesSyncable, 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 159 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::kLanguagePreferredLanguages)
+    SetSyncableInputMethodPrefs();
+
   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::kLanguagePreloadEngines) {
+    if (user_is_active) {
+      SetLanguageConfigStringListAsCSV(
+          language_prefs::kGeneralSectionName,
+          language_prefs::kPreloadEnginesConfigName,
+          preload_engines_.GetValue());
+    }
+    SetSyncableInputMethodPrefs();
   }
 
   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);
-    }
+    if (user_is_active)
+      SetEnabledExtensionImes();
+    if (reason == REASON_PREF_CHANGED)
+      SetSyncableInputMethodPrefs();
   }
 
   if (user_is_active) {
     system::InputDeviceSettings::Get()->UpdateTouchpadSettings(
         touchpad_settings);
     system::InputDeviceSettings::Get()->UpdateMouseSettings(mouse_settings);
   }
 }
 
 void Preferences::OnIsSyncingChanged() {
   DVLOG(1) << "OnIsSyncingChanged";
   ForceNaturalScrollDefault();
+  if (prefs_->GetBoolean(prefs::kLanguageShouldMergeInputMethods) &&
+      prefs_->IsSyncing()) {
+    MergeSyncedInputMethods();
+  }
 }
 
 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);
@@ skipping 14 matching lines @@
   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);
     return;
   }
 }
 
+void Preferences::SetPreferredLanguages(scoped_ptr<std::string> languages) {
+  // Since this only removes locales that are unsupported on this system, we
+  // don't need to update the syncable prefs. If the local preference changes
+  // later, the sync server will lose the values we dropped, but that's okay
+  // since the values from this device would become the new defaults anyway.
+  if (*languages != preferred_languages_.GetValue())
+    preferred_languages_.SetValue(*languages);
+}
+
 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::SetEnabledExtensionImes() {
+  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);
+}
+
+void Preferences::SetSyncableInputMethodPrefs() {
+  // 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.
+  preferred_languages_syncable_.SetValue(preferred_languages_.GetValue());
+  enabled_extension_imes_syncable_.SetValue(
+      enabled_extension_imes_.GetValue());
+
+  // For preload engines, use legacy xkb IDs so the preference can sync
+  // across Chrome OS and Chromium OS.
+  std::vector<std::string> engines;
+  base::SplitString(preload_engines_.GetValue(), ',', &engines);
+  std::transform(engines.begin(), engines.end(), engines.begin(),
+                 extension_ime_util::GetEngineIDByInputMethodID);
+  preload_engines_syncable_.SetValue(JoinString(engines, ','));
+}
+
+void Preferences::MergeSyncedInputMethods() {
+  // This should only be done on the first ever sync.
+  DCHECK(prefs_->GetBoolean(prefs::kLanguageShouldMergeInputMethods));
+  prefs_->SetBoolean(prefs::kLanguageShouldMergeInputMethods, false);
+
+  // Merge the values from the sync server into the local values.
+  preferred_languages_.SetValue(

[dzhioev (left Google), 2014/07/24 20:31:34]

I can't understand why do you set preferred languages with unchecked value, and
later make checks (CheckAndResolveLocales) and set them again. Can you explain?

[michaelpg, 2014/07/25 23:49:08]

The check is asynchronous. So this way, the changes are made immediately (e.g.,
input methods are added). Removing the unsupported languages is important so
that languages don't suddenly get added in the future if Chrome adds support for
them, but I don't think it should block these settings.

That said, the time it takes for CheckAndResolveLocales to return will probably
never be that long, so if you would rather see all of the updates and checks
happen once, after the CheckAndResolveLocales callback is called, I'll do it
that way.

[dzhioev (left Google), 2014/08/01 15:30:41]

I understand part about checking. But still I don't understand why we need to
set |preferred_languages_| twice. First we set it here (with unchecked values),
then in the end of this method we call CheckAndResolveLocales and after it
finished we call SetPreferredLanguages which sets |preferred_languages_| again,
but with values that were filtered of unsupported languages.
Yep, I prefer that way. BTW, don't we need to check other two preferences?

+      AddSupportedInputMethodValues(preferred_languages_.GetValue(),
+                                    preferred_languages_syncable_.GetValue(),
+                                    prefs::kLanguagePreferredLanguages));
+  preload_engines_.SetValue(
+      AddSupportedInputMethodValues(preload_engines_.GetValue(),
+                                    preload_engines_syncable_.GetValue(),
+                                    prefs::kLanguagePreloadEngines));
+  enabled_extension_imes_.SetValue(

[dzhioev (left Google), 2014/07/24 20:31:34]

I think the better idea is to set prefs directly through prefs_ (and not through
PrefMember-s). In this case we will be notified about change through
|ApplyPreferences|, which knows how to handle pref changes correctly.
|SetLanguageConfigStringListAsCSV|, |SetEnabledExtensionImes|,
|SetSyncableInputMethodPrefs| calls below can be dropped in this case.

[michaelpg, 2014/07/25 23:49:08]

Does this look better?

When any of these prefs are changed, SetInputMethodsSyncable() is called, which
sets all 3 of the syncable prefs at the same time. This is important so that we
don't push one preference from this machine while the server still has two prefs
from another machine with a totally different setup.

I thought about adding a comment to explain that, but I think this is a simpler
solution and it lets me set the prefs directly: Cache the syncable prefs, so
that we don't care when they're changed, and then we can set the prefs directly
and don't have to duplicate the change handlers.

[dzhioev (left Google), 2014/08/01 15:30:41]

Yes, it's better.

+      AddSupportedInputMethodValues(enabled_extension_imes_.GetValue(),
+                                    enabled_extension_imes_syncable_.GetValue(),
+                                    prefs::kLanguageEnabledExtensionImes));
+
+  // Apply the new values.
+  SetLanguageConfigStringListAsCSV(language_prefs::kGeneralSectionName,
+                                   language_prefs::kPreloadEnginesConfigName,
+                                   preload_engines_.GetValue());
+  SetEnabledExtensionImes();
+  SetSyncableInputMethodPrefs();
+
+  // Check the new list of preferred languages to remove unsupported locales.
+  scoped_ptr<std::string> languages(
+      new std::string(preferred_languages_.GetValue()));
+  content::BrowserThread::PostTaskAndReply(
+      content::BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&CheckAndResolveLocales, languages.get()),
+      base::Bind(&Preferences::SetPreferredLanguages,
+                 weak_factory_.GetWeakPtr(),
+                 base::Passed(&languages)));
+}
+
 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