Retrieve the list of keyboard layouts for public sessions async

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 "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 "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace chromeos {
 
 namespace {
 
-base::DictionaryValue* CreateInputMethodsEntry(
+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();
   scoped_ptr<base::DictionaryValue> input_method(new base::DictionaryValue);
   input_method->SetString("value", ime_id);
   input_method->SetString("title", util->GetInputMethodLongName(method));
   input_method->SetBoolean("selected", ime_id == selected);
-  return input_method.release();
+  return input_method.Pass();
 }
 
 // Returns true if element was inserted.
 bool InsertString(const std::string& str, std::set<std::string>& to) {
   const std::pair<std::set<std::string>::iterator, bool> result =
       to.insert(str);
   return result.second;
 }
 
 void AddOptgroupOtherLayouts(base::ListValue* input_methods_list) {
@@ skipping 209 matching lines @@
     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) {
+  input_method::InputMethodUtil* util =
+      input_method::InputMethodManager::Get()->GetInputMethodUtil();
+  std::vector<std::string> layouts = util->GetHardwareInputMethodIds();
+  std::vector<std::string> layouts_from_locale;
+  util->GetInputMethodIdsFromLanguageCode(
+      resolved_locale,
+      input_method::kKeyboardLayoutsOnly,
+      &layouts_from_locale);
+  layouts.insert(layouts.end(), layouts_from_locale.begin(),
+                 layouts_from_locale.end());
+
+  std::string selected;
+  if (!layouts_from_locale.empty()) {
+    selected =
+        util->GetInputMethodDescriptorFromId(layouts_from_locale[0])->id();
+  }
+
+  scoped_ptr<base::ListValue> input_methods_list(new base::ListValue);
+  std::set<std::string> input_methods_added;
+  for (std::vector<std::string>::const_iterator it = layouts.begin();
+       it != layouts.end(); ++it) {
+    const input_method::InputMethodDescriptor* ime =
+        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());
+}
+
 }  // namespace
 
 const char kMostRelevantLanguagesDivider[] = "MOST_RELEVANT_LANGUAGES_DIVIDER";
 
 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();
@@ skipping 69 matching lines @@
 
   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 =
         util->GetInputMethodDescriptorFromId(*i);
     // Do not crash in case of misconfiguration.
     if (ime) {
       input_methods_added.insert(*i);
-      input_methods_list->Append(CreateInputMethodsEntry(*ime, selected));
+      input_methods_list->Append(
+          CreateInputMethodsEntry(*ime, selected).release());
     } else {
       NOTREACHED();
     }
   }
 
   bool optgroup_added = false;
   for (size_t i = 0; i < input_methods->size(); ++i) {
     // Makes sure the id is in legacy xkb id format.
     const std::string& ime_id = (*input_methods)[i].id();
     if (!InsertString(ime_id, input_methods_added))
       continue;
     if (!optgroup_added) {
       optgroup_added = true;
       AddOptgroupOtherLayouts(input_methods_list.get());
     }
     input_methods_list->Append(CreateInputMethodsEntry((*input_methods)[i],
-                                                       selected));
+                                                       selected).release());
   }
 
   // "xkb:us::eng" should always be in the list of available layouts.
   const std::string us_keyboard_id =
       util->GetFallbackInputMethodDescriptor().id();
   if (input_methods_added.find(us_keyboard_id) == input_methods_added.end()) {
     const input_method::InputMethodDescriptor* us_eng_descriptor =
         util->GetInputMethodDescriptorFromId(us_keyboard_id);
     DCHECK(us_eng_descriptor);
     if (!optgroup_added) {
       optgroup_added = true;
       AddOptgroupOtherLayouts(input_methods_list.get());
     }
     input_methods_list->Append(CreateInputMethodsEntry(*us_eng_descriptor,
-                                                       selected));
+                                                       selected).release());
   }
   return input_methods_list.Pass();
 }
 
-scoped_ptr<base::ListValue> GetKeyboardLayoutsForLocale(
+void GetKeyboardLayoutsForLocale(
+    const GetKeyboardLayoutsForLocaleCallback& callback,
     const std::string& locale) {
-  input_method::InputMethodUtil* util =
-      input_method::InputMethodManager::Get()->GetInputMethodUtil();
-  std::vector<std::string> layouts = util->GetHardwareInputMethodIds();
-  std::vector<std::string> layouts_from_locale;
-  util->GetInputMethodIdsFromLanguageCode(
-      l10n_util::GetApplicationLocale(locale),
-      input_method::kKeyboardLayoutsOnly,
-      &layouts_from_locale);
-  layouts.insert(layouts.end(), layouts_from_locale.begin(),
-                 layouts_from_locale.end());
+  base::SequencedWorkerPool* worker_pool =
+      content::BrowserThread::GetBlockingPool();
+  scoped_refptr<base::SequencedTaskRunner> background_task_runner =
+      worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
+          worker_pool->GetNamedSequenceToken(kSequenceToken),
+          base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
 
-  std::string selected;
-  if (!layouts_from_locale.empty()) {
-    selected =
-        util->GetInputMethodDescriptorFromId(layouts_from_locale[0])->id();
-  }
+  // Resolve |locale| on a background thread, then continue on the current
+  // thread.
+  base::PostTaskAndReplyWithResult(
+      background_task_runner,
+      FROM_HERE,
+      base::Bind(&l10n_util::GetApplicationLocale,
+                 locale),
+      base::Bind(&GetKeyboardLayoutsForResolvedLocale,
+                 callback));
+}
 
-  scoped_ptr<base::ListValue> input_methods_list(new base::ListValue);
-  std::set<std::string> input_methods_added;
-  for (std::vector<std::string>::const_iterator it = layouts.begin();
-       it != layouts.end(); ++it) {
-    const input_method::InputMethodDescriptor* ime =
-        util->GetInputMethodDescriptorFromId(*it);
-    if (!InsertString(ime->id(), input_methods_added))
-      continue;
-    input_methods_list->Append(CreateInputMethodsEntry(*ime, selected));
-  }
-  return input_methods_list.Pass();
+scoped_ptr<base::DictionaryValue> GetCurrentKeyboardLayout() {
+  const input_method::InputMethodDescriptor current_input_method =
+      input_method::InputMethodManager::Get()->GetCurrentInputMethod();
+  return CreateInputMethodsEntry(current_input_method,
+                                 current_input_method.id());
 }
 
 }  // namespace chromeos