Allow country-specific languages in UI list at OOBE.

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 54 matching lines @@
 }
 
 void AddOptgroupOtherLayouts(base::ListValue* input_methods_list) {
   base::DictionaryValue* optgroup = new base::DictionaryValue;
   optgroup->SetString(
       "optionGroupName",
       l10n_util::GetStringUTF16(IDS_OOBE_OTHER_KEYBOARD_LAYOUTS));
   input_methods_list->Append(optgroup);
 }
 
+std::string CalculateSelectedLanguage(const std::string& requested_locale,
+                                      const std::string& loaded_locale) {

[jungshik at Google, 2014/04/04 08:37:22]

JFYI: It's also possible to ICU's Locale class (getLanguage()) here [1] , but  I
think what's necessary here is simple enough so that we don't need to bother. 

[1]
http://icu-project.org/apiref/icu4c/classicu_1_1Locale.html#af36d821adced72a8...

+  const size_t dash_pos_requested = requested_locale.find_first_of('-');
+
+  // Requested language doesn't have specific country.
+  if (dash_pos_requested == std::string::npos || dash_pos_requested == 0)
+    return loaded_locale;
+
+  const size_t dash_pos_loaded = loaded_locale.find_first_of('-');
+
+  // loaded_locale doesn't have 'country' name and requested_locale
+  // is a country-specific language of loaded_locale.
+  if (dash_pos_loaded == std::string::npos || dash_pos_loaded == 0) {
+    if (requested_locale.substr(0, dash_pos_requested) == loaded_locale)
+      return requested_locale;
+    // languages differ
+    return loaded_locale;
+  }
+  // Both locales are country-specific. Check that languages are the same.
+  if (requested_locale.substr(0, dash_pos_requested) ==
+      loaded_locale.substr(0, dash_pos_loaded))
+    return requested_locale;
+
+  return loaded_locale;
+}
+
 }  // namespace
 
 namespace chromeos {
 
 // NetworkScreenHandler, public: -----------------------------------------------
 
 NetworkScreenHandler::NetworkScreenHandler(CoreOobeActor* core_oobe_actor)
     : BaseScreenHandler(kJsScreenPath),
       screen_(NULL),
       core_oobe_actor_(core_oobe_actor),
@@ skipping 149 matching lines @@
 
   base::WeakPtr<NetworkScreenHandler> handler_;
 
   // Block UI while resource bundle is being reloaded.
   chromeos::InputEventsBlocker input_events_blocker;
 };
 
 // static
 void NetworkScreenHandler::OnLanguageChangedCallback(
     scoped_ptr<NetworkScreenHandlerOnLanguageChangedCallbackData> context,
-    const std::string& /*requested locale*/,
-    const std::string& /*loaded_locale*/,
-    const bool /*success*/) {
+    const std::string& requested_locale,
+    const std::string& loaded_locale,
+    const bool success) {
   if (!context or !context->handler_)
     return;
 
   NetworkScreenHandler* const self = context->handler_.get();
 
+  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;
+  }
+
   base::DictionaryValue localized_strings;
   static_cast<OobeUI*>(self->web_ui()->GetController())
       ->GetLocalizedStrings(&localized_strings);
   self->core_oobe_actor_->ReloadContent(localized_strings);
 
   // Buttons are recreated, updated "Continue" button state.
   self->EnableContinue(self->is_continue_enabled_);
 
   AccessibilityManager::Get()->OnLocaleChanged();
 }
@@ skipping 114 matching lines @@
   oobe_timer_update_interval_ =
       std::max(std::min(oobe_timer_update_interval_,
                         derelict_detection_timeout_ - time_on_oobe_),
                base::TimeDelta::FromSeconds(0));
 }
 
 bool NetworkScreenHandler::IsDerelict() {
   return time_on_oobe_ >= derelict_detection_timeout_;
 }
 
-// static
 base::ListValue* NetworkScreenHandler::GetLanguageList() {
   const std::string app_locale = g_browser_process->GetApplicationLocale();
   input_method::InputMethodManager* manager =
       input_method::InputMethodManager::Get();
   ComponentExtensionIMEManager* comp_manager =
       manager->GetComponentExtensionIMEManager();
   input_method::InputMethodDescriptors descriptors;
   if (extension_ime_util::UseWrappedExtensionKeyboardLayouts()) {
     if (comp_manager->IsInitialized())
       descriptors = comp_manager->GetXkbIMEAsInputMethodDescriptor();
@@ skipping 21 matching lines @@
           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);
-    language_info->SetBoolean("selected", value == app_locale);
+    if (selected_language_code_.empty()) {
+      if (value == app_locale)
+        language_info->SetBoolean("selected", true);
+    } else {
+      if (value == selected_language_code_)
+        language_info->SetBoolean("selected", true);
+    }
   }
   return languages_list;
 }
 
 base::DictionaryValue* CreateInputMethodsEntry(
     const input_method::InputMethodDescriptor& method,
     const std::string current_input_method_id) {
   input_method::InputMethodUtil* util =
       input_method::InputMethodManager::Get()->GetInputMethodUtil();
   const std::string& ime_id = method.id();
@@ skipping 109 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