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/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()) {

[Alexander Alekseev, 2014/06/30 21:22:23]

This seems to be dangerous (what if Component Extension has not
been initialized yet?).

The problem might arise if browser process was restarted on user log
in, so all initialization is (currently) started at the same time
asynchronously.

shuchen@ : After crbug.com/378348 - can we be sure that IME is initialized at
this point?

[michaelpg, 2014/07/10 00:46:01]

I wouldn't say "dangerous", the scenario is that during your first sync, your
synced component extension IMEs don't get added locally. You would still keep
any you've already added locally. And if the alternative is to wait around and
check at a later time, we run the risk of adding IMEs after-the-fact.
How often does this happen?

[Alexander Alekseev, 2014/07/10 17:47:49]

Ok, it's not "dangerous", but it just disables sync.

Restart happens when device owner (or domain policy) has non-default flags set.
So adding new user will result in chrome restart.

The question is if asynchronous IME initialization will work here. But it is
beyond this CL.

+        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(
+      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(
+      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