Allow recommended locales to be set for public sessions

chrome/browser/chromeos/login/screens/user_selection_screen.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/chromeos/login/screens/user_selection_screen.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/users/multi_profile_user_controller.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/signin/screenlock_bridge.h"
 #include "chrome/browser/ui/webui/chromeos/login/l10n_util.h"
 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
 #include "chrome/common/pref_names.h"
+#include "components/policy/core/common/cloud/cloud_policy_core.h"
+#include "components/policy/core/common/cloud/cloud_policy_store.h"
+#include "components/policy/core/common/policy_map.h"
+#include "components/policy/core/common/policy_types.h"
 #include "components/user_manager/user_type.h"
+#include "policy/policy_constants.h"
 #include "ui/wm/core/user_activity_detector.h"
 
 namespace chromeos {
 
 namespace {
 
 // User dictionary keys.
 const char kKeyUsername[] = "username";
 const char kKeyDisplayName[] = "displayName";
 const char kKeyEmailAddress[] = "emailAddress";
 const char kKeyEnterpriseDomain[] = "enterpriseDomain";
 const char kKeyPublicAccount[] = "publicAccount";
 const char kKeySupervisedUser[] = "locallyManagedUser";
 const char kKeySignedIn[] = "signedIn";
 const char kKeyCanRemove[] = "canRemove";
 const char kKeyIsOwner[] = "isOwner";
 const char kKeyInitialAuthType[] = "initialAuthType";
 const char kKeyMultiProfilesAllowed[] = "isMultiProfilesAllowed";
 const char kKeyMultiProfilesPolicy[] = "multiProfilesPolicy";
 const char kKeyInitialLocales[] = "initialLocales";
+const char kKeyInitialLocale[] = "initialLocale";
+const char kKeyInitialMultipleRecommendedLocales[] =
+    "initialMultipleRecommendedLocales";
 const char kKeyInitialKeyboardLayout[] = "initialKeyboardLayout";
 
 // Max number of users to show.
 // Please keep synced with one in signin_userlist_unittest.cc.
 const size_t kMaxUsers = 18;
 
 const int kPasswordClearTimeoutSec = 60;
 
 }  // namespace
 
@@ skipping 13 matching lines @@
   if (activity_detector->HasObserver(this))
     activity_detector->RemoveObserver(this);
 }
 
 // static
 void UserSelectionScreen::FillUserDictionary(
     user_manager::User* user,
     bool is_owner,
     bool is_signin_to_add,
     ScreenlockBridge::LockHandler::AuthType auth_type,
+    const std::vector<std::string>* public_session_recommended_locales,
     base::DictionaryValue* user_dict) {
   const std::string& user_id = user->email();
   const bool is_public_account =
       user->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT;
   const bool is_supervised_user =
       user->GetType() == user_manager::USER_TYPE_SUPERVISED;
 
   user_dict->SetString(kKeyUsername, user_id);
   user_dict->SetString(kKeyEmailAddress, user->display_email());
   user_dict->SetString(kKeyDisplayName, user->GetDisplayName());
@@ skipping 11 matching lines @@
         multi_profile_user_controller->GetCachedValue(user_id);
     user_dict->SetBoolean(kKeyMultiProfilesAllowed,
                           multi_profile_user_controller->IsUserAllowedInSession(
                               user_id) == MultiProfileUserController::ALLOWED);
     user_dict->SetString(kKeyMultiProfilesPolicy, behavior);
   } else {
     user_dict->SetBoolean(kKeyMultiProfilesAllowed, true);
   }
 
   if (is_public_account) {
     policy::BrowserPolicyConnectorChromeOS* policy_connector =

[Nikita (slow), 2014/07/30 11:22:59]

I suggest extracting code that's under if (is_public_account) condition into a
separate helper function.

[bartfab (slow), 2014/08/05 17:16:23]

Done.

         g_browser_process->platform_part()->browser_policy_connector_chromeos();
 
     if (policy_connector->IsEnterpriseManaged()) {
       user_dict->SetString(kKeyEnterpriseDomain,
                            policy_connector->GetEnterpriseDomain());
     }
 
-    // TODO(bartfab): Initialize |most_relevant_languages| and |locale| based on
-    // policy.
-    const std::string locale = g_browser_process->GetApplicationLocale();
-    std::vector<std::string> most_relevant_languages;
+    std::vector<std::string> kEmptyRecommendedLocales;
+    const std::vector<std::string>* recommended_locales =
+        public_session_recommended_locales ?
+            public_session_recommended_locales : &kEmptyRecommendedLocales;
+    // Set |kKeyInitialLocales| to the list of available locales. This list

[Nikita (slow), 2014/07/30 11:22:59]

nit: insert empty line before comment here and below.

[bartfab (slow), 2014/08/05 17:16:23]

Done.

+    // consists of the recommended locales, followed by all others.
     user_dict->Set(
         kKeyInitialLocales,
-        GetUILanguageList(&most_relevant_languages, locale).release());
+        GetUILanguageList(recommended_locales, std::string()).release());
+    // Set |kKeyInitialLocale| to the initially selected locale. If the list of
+    // recommended locales is not empty, select its first entry. Otherwise,
+    // select the current UI locale.
+    user_dict->SetString(kKeyInitialLocale,
+                         recommended_locales->empty() ?
+                             g_browser_process->GetApplicationLocale() :
+                             recommended_locales->front());
+    // Set |kKeyInitialMultipleRecommendedLocales| to indicate whether the list
+    // of recommended locales contains at least two entries. This is used to
+    // decide whether the public session pod expands to its basic form (for zero
+    // or one recommended locales) or the advanced form (two or more recommended
+    // locales).
+    user_dict->SetBoolean(kKeyInitialMultipleRecommendedLocales,
+                          recommended_locales->size() >= 2);
+    // Set |kKeyInitialKeyboardLayout| to the current keyboard layout. This
+    // value will be used temporarily only because the UI immediately requests a
+    // list of keyboard layouts suitable for the currently selected locale.
     user_dict->Set(kKeyInitialKeyboardLayout,
                    GetCurrentKeyboardLayout().release());
   }
 }
 
 // static
 bool UserSelectionScreen::ShouldForceOnlineSignIn(
     const user_manager::User* user) {
   // Public sessions are always allowed to log in offline.
   // Supervised user are allowed to log in offline if their OAuth token status
@@ skipping 92 matching lines @@
   password_clear_timer_.Reset();
 }
 
 void UserSelectionScreen::OnPolicyUpdated(const std::string& user_id) {
   policy::DeviceLocalAccountPolicyBroker* broker =
       device_local_account_policy_service_->GetBrokerForUser(user_id);
   if (!broker)
     return;
 
   CheckForPublicSessionDisplayNameChange(broker);
+  CheckForPublicSessionLocalePolicyChange(broker);
 }
 
 void UserSelectionScreen::OnDeviceLocalAccountsChanged() {
   // Nothing to do here. When the list of device-local accounts changes, the
   // entire UI is reloaded.
 }
 
 // static
 const user_manager::UserList UserSelectionScreen::PrepareUserListForSending(
     const user_manager::UserList& users,
@@ skipping 44 matching lines @@
 
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   bool is_enterprise_managed = connector->IsEnterpriseManaged();
 
   const user_manager::UserList users_to_send =
       PrepareUserListForSending(users, owner, is_signin_to_add);
 
   user_auth_type_map_.clear();
 
+  const std::vector<std::string> kEmptyRecommendedLocales;
   for (user_manager::UserList::const_iterator it = users_to_send.begin();
        it != users_to_send.end();
        ++it) {
     const std::string& user_id = (*it)->email();
     bool is_owner = (user_id == owner);
     const bool is_public_account =
         ((*it)->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT);
     const ScreenlockBridge::LockHandler::AuthType initial_auth_type =
         is_public_account
             ? ScreenlockBridge::LockHandler::EXPAND_THEN_USER_CLICK
             : (ShouldForceOnlineSignIn(*it)
                    ? ScreenlockBridge::LockHandler::ONLINE_SIGN_IN
                    : ScreenlockBridge::LockHandler::OFFLINE_PASSWORD);
     user_auth_type_map_[user_id] = initial_auth_type;
 
     base::DictionaryValue* user_dict = new base::DictionaryValue();
-    FillUserDictionary(
-        *it, is_owner, is_signin_to_add, initial_auth_type, user_dict);
+    FillUserDictionary(*it,
+                       is_owner,
+                       is_signin_to_add,
+                       initial_auth_type,
+                       public_session_recommended_locales_.find(user_id) ==

[Nikita (slow), 2014/07/30 11:22:59]

nit: please extract public_session_recommended_locales parameter to a local tmp
variable.

[bartfab (slow), 2014/08/05 17:16:23]

Done.

+                           public_session_recommended_locales_.end() ?
+                               &kEmptyRecommendedLocales :
+                               &public_session_recommended_locales_[user_id],
+                       user_dict);
     bool signed_in = (*it)->is_logged_in();
     // Single user check here is necessary because owner info might not be
     // available when running into login screen on first boot.
     // See http://crosbug.com/12723
     bool can_remove_user =
         ((!single_user || is_enterprise_managed) && !user_id.empty() &&
          !is_owner && !is_public_account && !signed_in && !is_signin_to_add);
     user_dict->SetBoolean(kKeyCanRemove, can_remove_user);
     users_list.Append(user_dict);
   }
@@ skipping 16 matching lines @@
     const std::string& username) const {
   if (user_auth_type_map_.find(username) == user_auth_type_map_.end())
     return ScreenlockBridge::LockHandler::OFFLINE_PASSWORD;
   return user_auth_type_map_.find(username)->second;
 }
 
 void UserSelectionScreen::CheckForPublicSessionDisplayNameChange(
     policy::DeviceLocalAccountPolicyBroker* broker) {
   const std::string& user_id = broker->user_id();
   const std::string& display_name = broker->GetDisplayName();
+
+  // If the display name has not changed, do nothing.
   if (display_name == public_session_display_names_[user_id])
     return;
 
   public_session_display_names_[user_id] = display_name;
 
   if (!handler_initialized_)
     return;
 
   if (!display_name.empty()) {
     // If a new display name was set by policy, notify the UI about it.
@@ skipping 17 matching lines @@
     const std::string& user_id) {
   const user_manager::User* user = UserManager::Get()->FindUser(user_id);
   if (!user || user->GetType() != user_manager::USER_TYPE_PUBLIC_ACCOUNT)
     return;
 
   handler_->SetPublicSessionDisplayName(
       user_id,
       base::UTF16ToUTF8(user->GetDisplayName()));
 }
 
+void UserSelectionScreen::CheckForPublicSessionLocalePolicyChange(
+    policy::DeviceLocalAccountPolicyBroker* broker) {
+  const std::string& user_id = broker->user_id();
+  const policy::PolicyMap::Entry* entry =
+      broker->core()->store()->policy_map().Get(policy::key::kSessionLocales);
+
+  // Parse the list of recommended locales set by policy.
+  std::vector<std::string> new_recommended_locales;
+  base::ListValue const* list = NULL;
+  if (entry &&
+      entry->level == policy::POLICY_LEVEL_RECOMMENDED &&
+      entry->value &&
+      entry->value->GetAsList(&list)) {
+    for (base::ListValue::const_iterator it = list->begin(); it != list->end();
+         ++it) {
+      std::string locale;
+      if (!(*it)->GetAsString(&locale)) {
+        new_recommended_locales.clear();

[Nikita (slow), 2014/07/30 11:22:59]

NOTREACHED()?

[bartfab (slow), 2014/08/05 17:16:23]

Done.

+        break;
+      }
+      new_recommended_locales.push_back(locale);
+    }
+  }
+
+  if (new_recommended_locales.empty()) {
+    // There are no recommended locales.
+    PublicSessionRecommendedLocaleMap::iterator it =
+        public_session_recommended_locales_.find(user_id);
+    if (it != public_session_recommended_locales_.end()) {
+      // If there previously were recommended locales, remove them from
+      // |public_session_recommended_locales_| and notify the UI.
+      public_session_recommended_locales_.erase(it);
+      SetPublicSessionLocales(user_id, &new_recommended_locales);
+    }
+    return;
+  }
+
+  // There are recommended locales.
+  std::vector<std::string>& recommended_locales =
+      public_session_recommended_locales_[user_id];
+  if (new_recommended_locales != recommended_locales) {
+    // If the list of recommended locales has changed, update
+    // |public_session_recommended_locales_| and notify the UI.
+    recommended_locales = new_recommended_locales;
+    SetPublicSessionLocales(user_id, &new_recommended_locales);
+  }
+}
+
+void UserSelectionScreen::SetPublicSessionLocales(
+    const std::string& user_id,
+    const std::vector<std::string>* recommended_locales) {
+  if (!handler_initialized_)
+    return;
+
+  // Construct the list of available locales. This list consists of the
+  // recommended locales, followed by all others.
+  scoped_ptr<base::ListValue> locales =
+      GetUILanguageList(recommended_locales, std::string());
+
+  // Set the initially selected locale. If the list of recommended locales is
+  // not empty, select its first entry. Otherwise, select the current UI locale.
+  const std::string& default_locale = recommended_locales->empty() ?
+      g_browser_process->GetApplicationLocale() : recommended_locales->front();
+
+  // Set a flag to indicate whether the list of recommended locales contains at
+  // least two entries. This is used to decide whether the public session pod
+  // expands to its basic form (for zero or one recommended locales) or the
+  // advanced form (two or more recommended locales).
+  const bool two_or_more_recommended_locales = recommended_locales->size() >= 2;
+
+  // Notify the UI.
+  handler_->SetPublicSessionLocales(user_id,
+                                    locales.Pass(),
+                                    default_locale,
+                                    two_or_more_recommended_locales);
+}
+
 }  // namespace chromeos