If user profile doesn't contain language setting, default to his Google account settings.

chrome/browser/chromeos/login/user_manager_impl.cc

 // Copyright (c) 2013 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/login/user_manager_impl.h"
 
 #include <cstddef>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/auth_sync_observer.h"
 #include "chrome/browser/chromeos/login/auth_sync_observer_factory.h"
 #include "chrome/browser/chromeos/login/default_pinned_apps_field_trial.h"
+#include "chrome/browser/chromeos/login/language_switch_menu.h"
 #include "chrome/browser/chromeos/login/login_display.h"
 #include "chrome/browser/chromeos/login/login_utils.h"
 #include "chrome/browser/chromeos/login/remove_user_delegate.h"
 #include "chrome/browser/chromeos/login/user_image_manager_impl.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/session_length_limiter.h"
 #include "chrome/browser/chromeos/settings/cros_settings_names.h"
 #include "chrome/browser/managed_mode/managed_user_service.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/login/login_state.h"
@@ skipping 176 matching lines @@
       is_current_user_ephemeral_regular_user_(false),
       ephemeral_users_enabled_(false),
       user_image_manager_(new UserImageManagerImpl),
       manager_creation_time_(base::TimeTicks::Now()) {
   // UserManager instance should be used only on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   registrar_.Add(this, chrome::NOTIFICATION_OWNERSHIP_STATUS_CHANGED,
       content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
       content::NotificationService::AllSources());
+  registrar_.Add(this,
+                 chrome::NOTIFICATION_PROFILE_CREATED,
+                 content::NotificationService::AllSources());
   RetrieveTrustedDevicePolicies();
   local_accounts_subscription_ = cros_settings_->AddSettingsObserver(
       kAccountsPrefDeviceLocalAccounts,
       base::Bind(&UserManagerImpl::RetrieveTrustedDevicePolicies,
                  base::Unretained(this)));
   supervised_users_subscription_ = cros_settings_->AddSettingsObserver(
       kAccountsPrefSupervisedUsersEnabled,
       base::Bind(&UserManagerImpl::RetrieveTrustedDevicePolicies,
                  base::Unretained(this)));
   UpdateLoginState();
@@ skipping 442 matching lines @@
         static_cast<User::OAuthTokenStatus>(oauth_token_status);
     if (result == User::OAUTH2_TOKEN_STATUS_INVALID)
       GetUserFlow(username)->HandleOAuthTokenStatusChange(result);
     return result;
   }
   return User::OAUTH_TOKEN_STATUS_UNKNOWN;
 }
 
 void UserManagerImpl::SaveUserDisplayName(const std::string& username,
                                           const string16& display_name) {
+  UpdateUserAccountDataImpl(username, display_name, NULL);
+}
+
+void UserManagerImpl::UpdateUserAccountData(const std::string& username,
+                                            const string16& display_name,
+                                            const std::string& locale) {
+  UpdateUserAccountDataImpl(username, display_name, &locale);
+}
+
+void UserManagerImpl::UpdateUserAccountDataImpl(const std::string& username,
+                                                const string16& display_name,
+                                                const std::string* locale) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   User* user = FindUserAndModify(username);
   if (!user)
     return;  // Ignore if there is no such user.
 
+  // locale is not NULL if User Account has been downloaded
+  // (i.e. it is UpdateUserAccountData(), not SaveUserDisplayName() )
+  if (locale != NULL) {
+    user->SetAccountLocale(*locale);
+    RespectLocalePreference(GetProfileByUser(user), user);
+  }
+
+  if (display_name.empty())
+    return;
+
   user->set_display_name(display_name);
 
   // Do not update local store if data stored or cached outside the user's
   // cryptohome is to be treated as ephemeral.
   if (IsUserNonCryptohomeDataEphemeral(username))
     return;
 
   PrefService* local_state = g_browser_process->local_state();
 
   DictionaryPrefUpdate display_name_update(local_state, kUserDisplayName);
@@ skipping 48 matching lines @@
       username,
       new base::StringValue(display_email));
 }
 
 std::string UserManagerImpl::GetUserDisplayEmail(
     const std::string& username) const {
   const User* user = FindUser(username);
   return user ? user->display_email() : username;
 }
 
+// TODO(alemate): http://crbug.com/288941 : Respect preferred language list in
+// the Google user profile.
+void UserManagerImpl::RespectLocalePreference(Profile* profile,
+                                              const User* user) const {
+  if (g_browser_process == NULL)
+    return;
+  if ((user == NULL) || (user != GetPrimaryUser()) ||
+      (!user->is_profile_created()))
+    return;
+
+  // In case of Multi Profile mode we don't apply profile locale because it is
+  // unsafe.
+  if (GetLoggedInUsers().size() != 1)
+    return;
+  const PrefService* prefs = profile->GetPrefs();
+  if (prefs == NULL)
+    return;
+
+  std::string pref_locale;
+  const std::string pref_app_locale =
+      prefs->GetString(prefs::kApplicationLocale);
+  const std::string pref_bkup_locale =
+      prefs->GetString(prefs::kApplicationLocaleBackup);
+
+  pref_locale = pref_app_locale;
+  if (pref_locale.empty())
+    pref_locale = pref_bkup_locale;
+
+  const std::string* account_locale = NULL;
+  if (pref_locale.empty() && user->has_gaia_account()) {
+    if (user->GetAccountLocale() == NULL)
+      return;  // wait until Account profile is loaded.
+    account_locale = user->GetAccountLocale();
+    pref_locale = *account_locale;
+  }
+  const std::string global_app_locale =
+      g_browser_process->GetApplicationLocale();
+  if (pref_locale.empty())
+    pref_locale = global_app_locale;
+  DCHECK(!pref_locale.empty());
+  LOG(WARNING) << "RespectLocalePreference: "
+               << "app_locale='" << pref_app_locale << "', "
+               << "bkup_locale='" << pref_bkup_locale << "', "
+               << (account_locale != NULL
+                       ? (std::string("account_locale='") + (*account_locale) +
+                          "'. ")
+                       : (std::string("account_locale - unused. ")))
+               << " Selected '" << pref_locale << "'";
+  profile->ChangeAppLocale(pref_locale, Profile::APP_LOCALE_CHANGED_VIA_LOGIN);
+  // Here we don't enable keyboard layouts. Input methods are set up when
+  // the user first logs in. Then the user may customize the input methods.
+  // Hence changing input methods here, just because the user's UI language
+  // is different from the login screen UI language, is not desirable. Note
+  // that input method preferences are synced, so users can use their
+  // farovite input methods as soon as the preferences are synced.
+  chromeos::LanguageSwitchMenu::SwitchLanguage(pref_locale);
+}
+
+class UserHashMatcher {
+ public:
+  explicit UserHashMatcher(const std::string& h) : username_hash(h) {}
+  bool operator()(const User* user) const {
+    return user->username_hash() == username_hash;
+  }
+
+ private:
+  const std::string& username_hash;
+};
+
+// Returns NULL if user is not created
+User* UserManagerImpl::GetUserByProfile(Profile* profile) const {
+  if (IsMultipleProfilesAllowed()) {
+    const std::string username_hash =
+        ProfileHelper::GetUserIdHashFromProfile(profile);
+    const UserList& users = GetUsers();
+    const UserList::const_iterator pos = std::find_if(
+        users.begin(), users.end(), UserHashMatcher(username_hash));
+    return (pos != users.end()) ? *pos : NULL;
+  }
+  return active_user_;
+}
+
+Profile* UserManagerImpl::GetProfileByUser(const User* user) const {
+  if (IsMultipleProfilesAllowed())
+    return ProfileHelper::GetProfileByUserIdHash(user->username_hash());
+  return g_browser_process->profile_manager()->GetDefaultProfile();
+}
+
 void UserManagerImpl::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_OWNERSHIP_STATUS_CHANGED:
       if (!device_local_account_policy_service_) {
         device_local_account_policy_service_ =
             g_browser_process->browser_policy_connector()->
                 GetDeviceLocalAccountPolicyService();
         if (device_local_account_policy_service_)
           device_local_account_policy_service_->AddObserver(this);
       }
       RetrieveTrustedDevicePolicies();
       UpdateOwnership();
       break;
     case chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED:
       if (IsUserLoggedIn() &&
           !IsLoggedInAsGuest() &&
           !IsLoggedInAsKioskApp()) {
         Profile* profile = content::Details<Profile>(details).ptr();
         if (!profile->IsOffTheRecord()) {
           AuthSyncObserver* sync_observer =
               AuthSyncObserverFactory::GetInstance()->GetForProfile(profile);
           sync_observer->StartObserving();
         }
       }
       break;
+    case chrome::NOTIFICATION_PROFILE_CREATED: {
+      Profile* profile = content::Source<Profile>(source).ptr();
+      User* user = GetUserByProfile(profile);
+      if (user != NULL) {
+        user->set_profile_is_created();
+        if (user == active_user_)
+          RespectLocalePreference(profile, user);
+      }
+      break;
+    }
     default:
       NOTREACHED();
   }
 }
 
 void UserManagerImpl::OnPolicyUpdated(const std::string& user_id) {
   UpdatePublicAccountDisplayName(user_id);
   NotifyUserListChanged();
 }
 
@@ skipping 1013 matching lines @@
         base::TimeTicks::Now() - manager_creation_time_;
     if (!last_email.empty() && email != last_email &&
         time_to_login.InSeconds() <= kLogoutToLoginDelayMaxSec) {
       UMA_HISTOGRAM_CUSTOM_COUNTS("UserManager.LogoutToLoginDelay",
           time_to_login.InSeconds(), 0, kLogoutToLoginDelayMaxSec, 50);
     }
   }
 }
 
 }  // namespace chromeos