ChromeOS: switch UI language before apps are loaded.

chrome/browser/chromeos/login/session/user_session_manager.cc

 // Copyright 2014 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/session/user_session_manager.h"
 
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
+#include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/threading/worker_pool.h"
 #include "chrome/browser/about_flags.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part_chromeos.h"
 #include "chrome/browser/browser_shutdown.h"
@@ skipping 245 matching lines @@
 
 void LogCustomSwitches(const std::set<std::string>& switches) {
   if (!VLOG_IS_ON(1))
     return;
   for (std::set<std::string>::const_iterator it = switches.begin();
        it != switches.end(); ++it) {
     VLOG(1) << "Switch leading to restart: '" << *it << "'";
   }
 }
 
+// Wait until language is switched.
+class LocalePreferenceRespectedWaiter
+    : public base::SupportsWeakPtr<LocalePreferenceRespectedWaiter> {
+ public:
+  LocalePreferenceRespectedWaiter() : done_(false) {}
+
+  locale_util::SwitchLanguageCallback Callback(
+      const locale_util::SwitchLanguageCallback& callback) {
+    return base::Bind(&LocalePreferenceRespectedWaiter::OnLanguageSwitched,
+                      AsWeakPtr(), callback);
+  }
+
+  void RunUntilLocaleSet(void) {
+    if (done_)
+      return;
+
+    base::MessageLoop::ScopedNestableTaskAllower allow(
+        base::MessageLoop::current());
+
+    run_loop_.Run();
+  }
+
+ private:
+  void OnLanguageSwitched(const locale_util::SwitchLanguageCallback& callback,
+                          const locale_util::LanguageSwitchResult& result) {
+    done_ = true;
+    run_loop_.Quit();
+
+    callback.Run(result);
+  }
+
+  base::RunLoop run_loop_;
+  bool done_;
+
+  DISALLOW_COPY_AND_ASSIGN(LocalePreferenceRespectedWaiter);
+};
+
 }  // namespace
 
 UserSessionManagerDelegate::~UserSessionManagerDelegate() {
 }
 
 void UserSessionStateObserver::PendingUserSessionsRestoreFinished() {
 }
 
 UserSessionStateObserver::~UserSessionStateObserver() {
 }
@@ skipping 309 matching lines @@
   // 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.
   //
   // For Guest mode, user locale preferences will never get initialized.
   // So input methods should be enabled somewhere.
   const bool enable_layouts =
       user_manager::UserManager::Get()->IsLoggedInAsGuest();
-  locale_util::SwitchLanguage(
-      pref_locale, enable_layouts, false /* login_layouts_only */, callback);
+  locale_util::SwitchLanguage(pref_locale, enable_layouts,
+                              false /* login_layouts_only */, callback,
+                              profile);
 
   return true;
 }
 
 bool UserSessionManager::RestartToApplyPerSessionFlagsIfNeed(
     Profile* profile,
     bool early_restart) {
   if (ProfileHelper::IsSigninProfile(profile))
     return false;
 
@@ skipping 925 matching lines @@
 void UserSessionManager::DoBrowserLaunchInternal(Profile* profile,
                                                  LoginDisplayHost* login_host,
                                                  bool locale_pref_checked) {
   if (browser_shutdown::IsTryingToQuit())
     return;
 
   if (!locale_pref_checked) {
     RespectLocalePreferenceWrapper(
         profile,
         base::Bind(&UserSessionManager::DoBrowserLaunchInternal, AsWeakPtr(),
-                   profile, login_host, true /* locale_pref_checked */));
+                   profile, login_host, true /* locale_pref_checked */),
+        false /* synchronous */);
     return;
   }
 
   if (!ChromeUserManager::Get()->GetCurrentUserFlow()->ShouldLaunchBrowser()) {
     ChromeUserManager::Get()->GetCurrentUserFlow()->LaunchExtraSteps(profile);
     return;
   }
 
   if (RestartToApplyPerSessionFlagsIfNeed(profile, false))
     return;
@@ skipping 30 matching lines @@
   // browser before it is dereferenced by the login host.
   if (login_host)
     login_host->Finalize();
   user_manager::UserManager::Get()->SessionStarted();
   chromeos::BootTimesRecorder::Get()->LoginDone(
       user_manager::UserManager::Get()->IsCurrentUserNew());
 }
 
 void UserSessionManager::RespectLocalePreferenceWrapper(
     Profile* profile,
-    const base::Closure& callback) {
+    const base::Closure& callback,
+    bool synchronous) {

[robliao, 2015/05/06 18:20:32]

Can this simply be the create mode instead? That way future folks don't have to
guess what true and false means when looking from the caller side.

[Alexander Alekseev, 2015/05/07 15:21:57]

I've reverted this change.

   if (browser_shutdown::IsTryingToQuit())
     return;
 
   const user_manager::User* const user =
       ProfileHelper::Get()->GetUserByProfile(profile);
+
+  LocalePreferenceRespectedWaiter waiter;
+
   locale_util::SwitchLanguageCallback locale_switched_callback(base::Bind(
       &UserSessionManager::RunCallbackOnLocaleLoaded, callback,
       base::Owned(new InputEventsBlocker)));  // Block UI events until
                                               // the ResourceBundle is
                                               // reloaded.
-  if (!RespectLocalePreference(profile, user, locale_switched_callback))
+  if (synchronous)
+    locale_switched_callback = waiter.Callback(locale_switched_callback);
+
+  if (!RespectLocalePreference(profile, user, locale_switched_callback)) {
     callback.Run();
+  } else if (synchronous) {
+    waiter.RunUntilLocaleSet();
+  }
 }
 
 // static
 void UserSessionManager::RunCallbackOnLocaleLoaded(
     const base::Closure& callback,
     InputEventsBlocker* /* input_events_blocker */,
     const locale_util::LanguageSwitchResult& /* result */) {
   callback.Run();
 }
 
@@ skipping 24 matching lines @@
     if (is_enterprise_managed)
       display = USER_PODS_DISPLAY_DISABLED_MANAGED;
     else
       display = USER_PODS_DISPLAY_DISABLED_REGULAR;
   }
   UMA_HISTOGRAM_ENUMERATION("UserSessionManager.UserPodsDisplay", display,
                             NUM_USER_PODS_DISPLAY);
 }
 
 }  // namespace chromeos