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);
 }
 
+// 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;
+
+  if (resolved_locale == loaded_locale)
+    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 26 matching lines @@
 
 void NetworkScreenHandler::PrepareToShow() {
 }
 
 void NetworkScreenHandler::Show() {
   if (!page_is_ready()) {
     show_on_init_ = true;
     return;
   }
 
+  // Here we should handle default locales, for which we do not have UI
+  // resources. This would load fallback, but properly show "selected" locale
+  // in the UI.
+  if (selected_language_code_.empty()) {

[Nikita (slow), 2014/04/08 07:56:01]

What happens for this scenario:

1. First boot, out-of-box starts
2. Initial locale gets applied
3. User changes it to another locales
4. Proceeds to EULA and back (i.e. doesn't accept EULA).
5. Reboot.

So technically out-of-box hasn't been finished, even EULA hasn't been accepted
but user has changed locale.

Does this mean that on the next boot to network screen initial_locale will be
set again?
I'm not quite sure that this scenario works correctly now either so just
checking.

[Alexander Alekseev, 2014/04/08 11:58:19]

Yes. Now each time network screen is shown after reboot, language will be set to
device default. I don't see easy way to fix it. We would need to store another
value in Local State to keep the initial user choice. I think that the
implemented behavior is less confusing.

[Nikita (slow), 2014/04/08 12:19:25]

Ok then.

+    const StartupCustomizationDocument* startup_manifest =
+        StartupCustomizationDocument::GetInstance();
+    HandleOnLanguageChanged(startup_manifest->initial_locale_default());
+  }
+
   ShowScreen(OobeUI::kScreenOobeNetwork, NULL);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableDemoMode))
     return;
 
   if (IsDerelict())
     StartIdleDetection();
   else
     StartOobeTimer();
 }
@@ skipping 101 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;
+  }
+
   self->ReloadLocalizedContent();
 
   AccessibilityManager::Get()->OnLocaleChanged();
 }
 
 void NetworkScreenHandler::HandleOnLanguageChanged(const std::string& locale) {
   const std::string app_locale = g_browser_process->GetApplicationLocale();
   if (app_locale == locale)
     return;
 
@@ skipping 108 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 119 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