Revert of ChromeOS NetworkScreenHandler should not call CheckAndResolveLocale on UI thread. (patchs…

chrome/browser/ui/webui/chromeos/login/l10n_util.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/ui/webui/chromeos/login/l10n_util.h"
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 #include <set>
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/customization_document.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
-#include "chrome/browser/chromeos/profiles/profile_helper.h"
-#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/grit/generated_resources.h"
 #include "chromeos/ime/component_extension_ime_manager.h"
 #include "chromeos/ime/input_method_descriptor.h"
 #include "chromeos/ime/input_method_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace chromeos {
 
-const char kMostRelevantLanguagesDivider[] = "MOST_RELEVANT_LANGUAGES_DIVIDER";
-
 namespace {
 
 const char kSequenceToken[] = "chromeos_login_l10n_util";
 
 scoped_ptr<base::DictionaryValue> CreateInputMethodsEntry(
     const input_method::InputMethodDescriptor& method,
     const std::string selected) {
   input_method::InputMethodUtil* util =
       input_method::InputMethodManager::Get()->GetInputMethodUtil();
   const std::string& ime_id = method.id();
@@ skipping 16 matching lines @@
 // TODO(dpolukhin): crbug.com/407579
 void AddOptgroupOtherLayouts(base::ListValue* input_methods_list) {
   scoped_ptr<base::DictionaryValue> optgroup(new base::DictionaryValue);
   optgroup->SetString(
       "optionGroupName",
       l10n_util::GetStringUTF16(IDS_OOBE_OTHER_KEYBOARD_LAYOUTS));
   input_methods_list->Append(optgroup.release());
 }
 #endif
 
-base::DictionaryValue* CreateLanguageEntry(
-    const std::string& language_code,
-    const base::string16& language_display_name,
-    const base::string16& language_native_display_name) {
-  base::string16 display_name = language_display_name;
-  const bool markup_removal =
-      base::i18n::UnadjustStringForLocaleDirection(&display_name);
-  DCHECK(markup_removal);
-
-  const bool has_rtl_chars =
-      base::i18n::StringContainsStrongRTLChars(display_name);
-  const std::string directionality = has_rtl_chars ? "rtl" : "ltr";
-
-  scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
-  dictionary->SetString("code", language_code);
-  dictionary->SetString("displayName", language_display_name);
-  dictionary->SetString("textDirection", directionality);
-  dictionary->SetString("nativeDisplayName", language_native_display_name);
-  return dictionary.release();
-}
-
 // Gets the list of languages with |descriptors| based on |base_language_codes|.
 // The |most_relevant_language_codes| will be first in the list. If
 // |insert_divider| is true, an entry with its "code" attribute set to
 // kMostRelevantLanguagesDivider is placed between the most relevant languages
 // and all others.
 scoped_ptr<base::ListValue> GetLanguageList(
     const input_method::InputMethodDescriptors& descriptors,
     const std::vector<std::string>& base_language_codes,
     const std::vector<std::string>& most_relevant_language_codes,
     bool insert_divider) {
@@ skipping 164 matching lines @@
   for (size_t i = 0; i < out_display_names.size(); ++i) {
     // Sets the directionality of the display language name.
     base::string16 display_name(out_display_names[i]);
     if (insert_divider && display_name == divider16) {
       // Insert divider.
       base::DictionaryValue* dictionary = new base::DictionaryValue();
       dictionary->SetString("code", kMostRelevantLanguagesDivider);
       language_list->Append(dictionary);
       continue;
     }
+    const bool markup_removal =
+        base::i18n::UnadjustStringForLocaleDirection(&display_name);
+    DCHECK(markup_removal);
+    const bool has_rtl_chars =
+        base::i18n::StringContainsStrongRTLChars(display_name);
+    const std::string directionality = has_rtl_chars ? "rtl" : "ltr";
 
     const LanguagePair& pair = language_map[out_display_names[i]];
-    language_list->Append(
-        CreateLanguageEntry(pair.first, out_display_names[i], pair.second));
+    base::DictionaryValue* dictionary = new base::DictionaryValue();
+    dictionary->SetString("code", pair.first);
+    dictionary->SetString("displayName", out_display_names[i]);
+    dictionary->SetString("textDirection", directionality);
+    dictionary->SetString("nativeDisplayName", pair.second);
+    language_list->Append(dictionary);
   }
 
   return language_list.Pass();
 }
 
 // Invokes |callback| with a list of keyboard layouts that can be used for
 // |resolved_locale|.
 void GetKeyboardLayoutsForResolvedLocale(
     const GetKeyboardLayoutsForLocaleCallback& callback,
     const std::string& resolved_locale) {
@@ skipping 22 matching lines @@
         util->GetInputMethodDescriptorFromId(*it);
     if (!InsertString(ime->id(), &input_methods_added))
       continue;
     input_methods_list->Append(
         CreateInputMethodsEntry(*ime, selected).release());
   }
 
   callback.Run(input_methods_list.Pass());
 }
 
-// For "UI Language" drop-down menu at OOBE screen we need to decide which
-// entry to mark "selected". If user has just selected "requested_locale",
-// but "loaded_locale" was actually loaded, we mark original user choice
-// "selected" only if loaded_locale is a backup for "requested_locale".
-std::string CalculateSelectedLanguage(const std::string& requested_locale,
-                                      const std::string& loaded_locale) {
-  std::string resolved_locale;
-  if (!l10n_util::CheckAndResolveLocale(requested_locale, &resolved_locale))
-    return loaded_locale;
+}  // namespace
 
-  if (resolved_locale == loaded_locale)
-    return requested_locale;
+const char kMostRelevantLanguagesDivider[] = "MOST_RELEVANT_LANGUAGES_DIVIDER";
 
-  return loaded_locale;
-}
+scoped_ptr<base::ListValue> GetUILanguageList(
+    const std::vector<std::string>* most_relevant_language_codes,
+    const std::string& selected) {
+  ComponentExtensionIMEManager* manager =
+      input_method::InputMethodManager::Get()->
+          GetComponentExtensionIMEManager();
+  input_method::InputMethodDescriptors descriptors =
+      manager->GetXkbIMEAsInputMethodDescriptor();
+  scoped_ptr<base::ListValue> languages_list(GetLanguageList(
+      descriptors,
+      l10n_util::GetAvailableLocales(),
+      most_relevant_language_codes
+          ? *most_relevant_language_codes
+          : StartupCustomizationDocument::GetInstance()->configured_locales(),
+      true));
 
-void ResolveLanguageListOnBlockingPool(
-    const chromeos::locale_util::LanguageSwitchResult* language_switch_result,
-    scoped_ptr<base::ListValue>* list,
-    std::string* list_locale,
-    std::string* selected_language) {
-  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
-
-  if (!language_switch_result) {
-    *selected_language =
-        StartupCustomizationDocument::GetInstance()->initial_locale_default();
-  } else {
-    if (language_switch_result->success) {
-      if (language_switch_result->requested_locale ==
-          language_switch_result->loaded_locale) {
-        *selected_language = language_switch_result->requested_locale;
-      } else {
-        *selected_language =
-            CalculateSelectedLanguage(language_switch_result->requested_locale,
-                                      language_switch_result->loaded_locale);
-      }
-    } else {
-      *selected_language = language_switch_result->loaded_locale;
-    }
-  }
-  const std::string selected_code =
-      selected_language->empty() ? g_browser_process->GetApplicationLocale()
-                                 : *selected_language;
-
-  *list_locale = language_switch_result
-                     ? language_switch_result->loaded_locale
-                     : g_browser_process->GetApplicationLocale();
-  list->reset(chromeos::GetUILanguageList(NULL, selected_code).release());
-}
-
-void OnLanguageListResolved(
-    UILanguageListResolvedCallback callback,
-    scoped_ptr<scoped_ptr<base::ListValue>> new_language_list,
-    scoped_ptr<std::string> new_language_list_locale,
-    scoped_ptr<std::string> new_selected_language) {
-  callback.Run(new_language_list->Pass(),
-               *new_language_list_locale,
-               *new_selected_language);
-}
-
-void AdjustUILanguageList(const std::string& selected,
-                          base::ListValue* languages_list) {
   for (size_t i = 0; i < languages_list->GetSize(); ++i) {
     base::DictionaryValue* language_info = NULL;
     if (!languages_list->GetDictionary(i, &language_info))
       NOTREACHED();
 
     std::string value;
     language_info->GetString("code", &value);
     std::string display_name;
     language_info->GetString("displayName", &display_name);
     std::string native_name;
     language_info->GetString("nativeDisplayName", &native_name);
 
     // If it's an option group divider, add field name.
     if (value == kMostRelevantLanguagesDivider) {
       language_info->SetString(
           "optionGroupName",
           l10n_util::GetStringUTF16(IDS_OOBE_OTHER_LANGUAGES));
     }
     if (display_name != native_name) {
       display_name = base::StringPrintf("%s - %s",
                                         display_name.c_str(),
                                         native_name.c_str());
     }
 
     language_info->SetString("value", value);
     language_info->SetString("title", display_name);
     if (value == selected)
       language_info->SetBoolean("selected", true);
   }
-}
-
-}  // namespace
-
-void ResolveUILanguageList(
-    scoped_ptr<chromeos::locale_util::LanguageSwitchResult>
-        language_switch_result,
-    UILanguageListResolvedCallback callback) {
-  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);
-
-  base::Closure resolve_on_pool =
-      base::Bind(&ResolveLanguageListOnBlockingPool,
-                 base::Owned(language_switch_result.release()),
-                 base::Unretained(new_language_list.get()),
-                 base::Unretained(new_language_list_locale.get()),
-                 base::Unretained(new_selected_language.get()));
-
-  base::Closure on_language_list_resolved =
-      base::Bind(&OnLanguageListResolved,
-                 callback,
-                 base::Passed(new_language_list.Pass()),
-                 base::Passed(new_language_list_locale.Pass()),
-                 base::Passed(new_selected_language.Pass()));
-
-  content::BrowserThread::GetBlockingPool()->PostTaskAndReply(
-      FROM_HERE, resolve_on_pool, on_language_list_resolved);
-}
-
-scoped_ptr<base::ListValue> GetMinimalUILanguageList() {
-  const std::string application_locale =
-      g_browser_process->GetApplicationLocale();
-  base::string16 language_native_display_name =
-      l10n_util::GetDisplayNameForLocale(
-          application_locale, application_locale, true);
-
-  scoped_ptr<base::ListValue> language_list(new base::ListValue());
-  language_list->Append(CreateLanguageEntry(application_locale,
-                                            language_native_display_name,
-                                            language_native_display_name));
-  AdjustUILanguageList(std::string(), language_list.get());
-  return language_list.Pass();
-}
-
-scoped_ptr<base::ListValue> GetUILanguageList(
-    const std::vector<std::string>* most_relevant_language_codes,
-    const std::string& selected) {
-  ComponentExtensionIMEManager* manager =
-      input_method::InputMethodManager::Get()
-          ->GetComponentExtensionIMEManager();
-  input_method::InputMethodDescriptors descriptors =
-      manager->GetXkbIMEAsInputMethodDescriptor();
-  scoped_ptr<base::ListValue> languages_list(GetLanguageList(
-      descriptors,
-      l10n_util::GetAvailableLocales(),
-      most_relevant_language_codes
-          ? *most_relevant_language_codes
-          : StartupCustomizationDocument::GetInstance()->configured_locales(),
-      true));
-  AdjustUILanguageList(selected, languages_list.get());
   return languages_list.Pass();
 }
 
 std::string FindMostRelevantLocale(
     const std::vector<std::string>& most_relevant_language_codes,
     const base::ListValue& available_locales,
     const std::string& fallback_locale) {
   for (std::vector<std::string>::const_iterator most_relevant_it =
           most_relevant_language_codes.begin();
        most_relevant_it != most_relevant_language_codes.end();
@@ skipping 23 matching lines @@
   l10n_util::GetAcceptLanguagesForLocale(app_locale, &accept_language_codes);
   return GetLanguageList(
       *input_method::InputMethodManager::Get()->GetSupportedInputMethods(),
       accept_language_codes,
       StartupCustomizationDocument::GetInstance()->configured_locales(),
       false);
 }
 
 scoped_ptr<base::ListValue> GetAndActivateLoginKeyboardLayouts(
     const std::string& locale,
-    const std::string& selected,
-    bool activate_keyboards) {
+    const std::string& selected) {
   scoped_ptr<base::ListValue> input_methods_list(new base::ListValue);
 #if !defined(USE_ATHENA)
   // TODO(dpolukhin): crbug.com/407579
   input_method::InputMethodManager* manager =
       input_method::InputMethodManager::Get();
   input_method::InputMethodUtil* util = manager->GetInputMethodUtil();
 
   const std::vector<std::string>& hardware_login_input_methods =
       util->GetHardwareLoginInputMethodIds();
 
-  if (activate_keyboards) {
-    DCHECK(
-        ProfileHelper::IsSigninProfile(ProfileManager::GetActiveUserProfile()));
-    manager->GetActiveIMEState()->EnableLoginLayouts(
-        locale, hardware_login_input_methods);
-  }
+  manager->GetActiveIMEState()->EnableLoginLayouts(
+      locale, hardware_login_input_methods);
 
   scoped_ptr<input_method::InputMethodDescriptors> input_methods(
       manager->GetActiveIMEState()->GetActiveInputMethods());
   std::set<std::string> input_methods_added;
 
   for (std::vector<std::string>::const_iterator i =
            hardware_login_input_methods.begin();
        i != hardware_login_input_methods.end();
        ++i) {
     const input_method::InputMethodDescriptor* ime =
@@ skipping 64 matching lines @@
 scoped_ptr<base::DictionaryValue> GetCurrentKeyboardLayout() {
   const input_method::InputMethodDescriptor current_input_method =
       input_method::InputMethodManager::Get()
           ->GetActiveIMEState()
           ->GetCurrentInputMethod();
   return CreateInputMethodsEntry(current_input_method,
                                  current_input_method.id());
 }
 
 }  // namespace chromeos