ChromeOS NetworkScreenHandler should not call CheckAndResolveLocale on UI thread.

chrome/browser/ui/webui/chromeos/login/network_screen_handler.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/ui/webui/chromeos/login/network_screen_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/weak_ptr.h"
 #include "base/prefs/pref_service.h"
+#include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_runner_util.h"
+#include "base/threading/worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
 #include "chrome/browser/chromeos/base/locale_util.h"
 #include "chrome/browser/chromeos/customization_document.h"
 #include "chrome/browser/chromeos/idle_detector.h"
 #include "chrome/browser/chromeos/login/screens/core_oobe_actor.h"
 #include "chrome/browser/chromeos/login/ui/input_events_blocker.h"
 #include "chrome/browser/chromeos/system/input_device_settings.h"
 #include "chrome/browser/chromeos/system/timezone_util.h"
 #include "chrome/browser/ui/webui/chromeos/login/l10n_util.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "chromeos/ime/extension_ime_util.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state_handler.h"
+#include "content/public/browser/browser_thread.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
 const char kJsScreenPath[] = "login.NetworkScreen";
 
 // JS API callbacks names.
@@ skipping 11 matching lines @@
   std::string resolved_locale;
   if (!l10n_util::CheckAndResolveLocale(requested_locale, &resolved_locale))
     return loaded_locale;
 
   if (resolved_locale == loaded_locale)
     return requested_locale;
 
   return loaded_locale;
 }
 
+void ResolveLanguageListOnBlockingPool(const std::string& requested_locale,

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

Pass LanguageSwitchResult instead of first three parameters here.

[Alexander Alekseev, 2014/10/02 13:12:07]

Done.

+                                       const std::string& loaded_locale,
+                                       bool success,
+                                       scoped_ptr<base::ListValue>* list,
+                                       std::string* list_locale,
+                                       std::string* selected_language) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+
+  if (success) {
+    if (requested_locale == loaded_locale) {
+      *selected_language = requested_locale;
+    } else {
+      *selected_language =
+          CalculateSelectedLanguage(requested_locale, loaded_locale);
+    }
+  } else {
+    *selected_language = loaded_locale;
+  }
+  const std::string selected_code =
+      selected_language->empty() ? g_browser_process->GetApplicationLocale()
+                                 : *selected_language;
+
+  *list_locale = loaded_locale;
+  list->reset(chromeos::GetUILanguageList(NULL, selected_code).release());
+}
+
 }  // namespace
 
 namespace chromeos {
 
 // NetworkScreenHandler, public: -----------------------------------------------
 
 NetworkScreenHandler::NetworkScreenHandler(CoreOobeActor* core_oobe_actor)
     : BaseScreenHandler(kJsScreenPath),
       screen_(NULL),
       core_oobe_actor_(core_oobe_actor),
@@ skipping 93 matching lines @@
   builder->Add("networkScreenAccessibleTitle",
                IDS_NETWORK_SCREEN_ACCESSIBLE_TITLE);
   builder->Add("selectLanguage", IDS_LANGUAGE_SELECTION_SELECT);
   builder->Add("selectKeyboard", IDS_KEYBOARD_SELECTION_SELECT);
   builder->Add("selectNetwork", IDS_NETWORK_SELECTION_SELECT);
   builder->Add("selectTimezone", IDS_OPTIONS_SETTINGS_TIMEZONE_DESCRIPTION);
   builder->Add("proxySettings", IDS_OPTIONS_PROXIES_CONFIGURE_BUTTON);
   builder->Add("continueButton", IDS_NETWORK_SELECTION_CONTINUE_BUTTON);
 }
 
+void NetworkScreenHandler::OnLanguageListResolved(
+    scoped_ptr<scoped_ptr<base::ListValue>> new_language_list,
+    scoped_ptr<std::string> new_language_list_locale,
+    scoped_ptr<std::string> new_selected_language) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  language_list_.reset(new_language_list->release());
+  language_list_locale_ = *new_language_list_locale;
+  selected_language_code_ = *new_selected_language;
+
+  g_browser_process->local_state()->SetString(prefs::kApplicationLocale,
+                                              selected_language_code_);
+  ReloadLocalizedContent();
+}
+
+void NetworkScreenHandler::ScheduleResolveLanguageList() {

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

Add |callback| param and move to l10n_util.

[Alexander Alekseev, 2014/10/02 13:12:07]

Done.

+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  scoped_ptr<scoped_ptr<base::ListValue>> new_language_list(
+      new scoped_ptr<base::ListValue>());
+  scoped_ptr<std::string> new_language_list_locale(new std::string);
+  scoped_ptr<std::string> new_selected_language(new std::string);
+  content::BrowserThread::GetBlockingPool()->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&ResolveLanguageListOnBlockingPool,
+                 language_switch_result_.requested_locale,
+                 language_switch_result_.loaded_locale,
+                 language_switch_result_.success,
+                 base::Unretained(new_language_list.get()),
+                 base::Unretained(new_language_list_locale.get()),
+                 base::Unretained(new_selected_language.get())),
+      base::Bind(&NetworkScreenHandler::OnLanguageListResolved,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(new_language_list.Pass()),
+                 base::Passed(new_language_list_locale.Pass()),
+                 base::Passed(new_selected_language.Pass())));
+}
+
 void NetworkScreenHandler::GetAdditionalParameters(
     base::DictionaryValue* dict) {
   const std::string application_locale =
       g_browser_process->GetApplicationLocale();
-  const std::string selected_language = selected_language_code_.empty() ?
-      application_locale : selected_language_code_;
   const std::string selected_input_method =
       input_method::InputMethodManager::Get()
           ->GetActiveIMEState()
           ->GetCurrentInputMethod()
           .id();
 
-  dict->Set("languageList",
-            GetUILanguageList(NULL, selected_language).release());
+  scoped_ptr<base::ListValue> language_list;
+  if (language_list_.get() && language_list_locale_ == application_locale) {
+    language_list.reset(language_list_->DeepCopy());
+  } else {
+    ScheduleResolveLanguageList();
+
+    base::string16 language_native_display_name =
+        l10n_util::GetDisplayNameForLocale(
+            application_locale, application_locale, true);
+
+    language_list.reset(new base::ListValue());
+    const bool markup_removal = base::i18n::UnadjustStringForLocaleDirection(
+        &language_native_display_name);
+    DCHECK(markup_removal);
+    language_list->Append(CreateLanguageEntry(
+        application_locale,
+        language_native_display_name,
+        GetLanguageDirectionality(language_native_display_name),
+        language_native_display_name));

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

You forgot to add 'title', 'value', and 'selected' fields.

[Alexander Alekseev, 2014/10/02 13:12:07]

Done.

+  }
+
+  dict->Set("languageList", language_list.release());
   dict->Set("inputMethodsList",
             GetAndActivateLoginKeyboardLayouts(
                 application_locale, selected_input_method).release());
   dict->Set("timezoneList", GetTimezoneList());
 }
 
 void NetworkScreenHandler::Initialize() {
   EnableContinue(is_continue_enabled_);
   if (show_on_init_) {
     show_on_init_ = false;
@@ skipping 43 matching lines @@
 // static
 void NetworkScreenHandler::OnLanguageChangedCallback(
     scoped_ptr<NetworkScreenHandlerOnLanguageChangedCallbackData> context,
     const std::string& requested_locale,
     const std::string& loaded_locale,
     const bool success) {
   if (!context || !context->handler)
     return;
 
   NetworkScreenHandler* const self = context->handler.get();
+  self->language_switch_result_.requested_locale = requested_locale;
+  self->language_switch_result_.loaded_locale = loaded_locale;
+  self->language_switch_result_.success = success;
 
-  if (success) {
-    if (requested_locale == loaded_locale) {
-      self->selected_language_code_ = requested_locale;
-    } else {
-      self->selected_language_code_ =
-          CalculateSelectedLanguage(requested_locale, loaded_locale);
-    }
-  } else {
-    self->selected_language_code_ = loaded_locale;
+  if (!self->selected_language_code_.empty()) {
+    // We still do not have device owner, so owner settings are not applied.
+    // But Guest session can be started before owner is created, so we need to
+    // save locale settings directly here.
+    g_browser_process->local_state()->SetString(prefs::kApplicationLocale,
+                                                self->selected_language_code_);
   }
 
-  self->ReloadLocalizedContent();
-
-  // We still do not have device owner, so owner settings are not applied.
-  // But Guest session can be started before owner is created, so we need to
-  // save locale settings directly here.
-  g_browser_process->local_state()->SetString(prefs::kApplicationLocale,
-                                              self->selected_language_code_);
+  self->ScheduleResolveLanguageList();
 
   AccessibilityManager::Get()->OnLocaleChanged();
 }
 
 void NetworkScreenHandler::HandleOnLanguageChanged(const std::string& locale) {
   const std::string app_locale = g_browser_process->GetApplicationLocale();
   if (app_locale == locale)
     return;
 
   base::WeakPtr<NetworkScreenHandler> weak_self =
@@ skipping 70 matching lines @@
     timezone_option->SetString("value", timezone_id);
     timezone_option->SetString("title", timezone_name);
     timezone_option->SetBoolean("selected", timezone_id == current_timezone_id);
     timezone_list->Append(timezone_option.release());
   }
 
   return timezone_list.release();
 }
 
 }  // namespace chromeos