Do not reload account picker when device-local account policy changes

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/user_manager/user_type.h"
 #include "ui/wm/core/user_activity_detector.h"
 
 namespace chromeos {
 
@@ skipping 16 matching lines @@
 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
 
-UserSelectionScreen::UserSelectionScreen() : handler_(NULL) {
+UserSelectionScreen::UserSelectionScreen()
+    : handler_(NULL),
+      handler_initialized_(false),
+      weak_factory_(this) {
+  device_local_account_policy_service_ = g_browser_process->platform_part()->
+      browser_policy_connector_chromeos()->GetDeviceLocalAccountPolicyService();
+  device_local_account_policy_service_->AddObserver(this);
 }
 
 UserSelectionScreen::~UserSelectionScreen() {
+  device_local_account_policy_service_->RemoveObserver(this);
   wm::UserActivityDetector* activity_detector =
       ash::Shell::GetInstance()->user_activity_detector();
   if (activity_detector->HasObserver(this))
     activity_detector->RemoveObserver(this);
 }
 
 // static
 void UserSelectionScreen::FillUserDictionary(
     user_manager::User* user,
     bool is_owner,
@@ skipping 90 matching lines @@
 
 void UserSelectionScreen::Init(const user_manager::UserList& users,
                                bool show_guest) {
   users_ = users;
   show_guest_ = show_guest;
 
   wm::UserActivityDetector* activity_detector =
       ash::Shell::GetInstance()->user_activity_detector();
   if (!activity_detector->HasObserver(this))
     activity_detector->AddObserver(this);
+
+  // Retrieve the current policy for |users_|.
+  for (user_manager::UserList::const_iterator it = users_.begin();
+       it != users_.end(); ++it) {
+    if ((*it)->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT)
+      OnPolicyUpdated((*it)->GetUserID());
+  }
 }
 
 void UserSelectionScreen::OnBeforeUserRemoved(const std::string& username) {
   for (user_manager::UserList::iterator it = users_.begin(); it != users_.end();
        ++it) {
     if ((*it)->email() == username) {
       users_.erase(it);
       break;
     }
   }
@@ skipping 26 matching lines @@
   if (!password_clear_timer_.IsRunning()) {
     password_clear_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromSeconds(kPasswordClearTimeoutSec),
         this,
         &UserSelectionScreen::OnPasswordClearTimerExpired);
   }
   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);
+}
+
+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,
     std::string owner,
     bool is_signin_to_add) {
   user_manager::UserList users_to_send;
   bool has_owner = owner.size() > 0;
   size_t max_non_owner_users = has_owner ? kMaxUsers - 1 : kMaxUsers;
   size_t non_owner_count = 0;
 
@@ skipping 67 matching lines @@
     // 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);
   }
 
   handler_->LoadUsers(users_list, show_guest_);
+  handler_initialized_ = true;
 }
 
 void UserSelectionScreen::HandleGetUsers() {
   SendUserList();
 }
 
 void UserSelectionScreen::SetAuthType(
     const std::string& username,
     ScreenlockBridge::LockHandler::AuthType auth_type) {
   user_auth_type_map_[username] = auth_type;
 }
 
 ScreenlockBridge::LockHandler::AuthType UserSelectionScreen::GetAuthType(
     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 (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.
+    handler_->SetPublicSessionDisplayName(user_id, display_name);
+    return;
+  }
+
+  // When no display name is set by policy, the |User|, owned by |UserManager|,
+  // decides what display name to use. However, the order in which |UserManager|
+  // and |this| are informed of the display name change is undefined. Post a
+  // task that will update the UI after the UserManager is guaranteed to have
+  // been informed of the change.
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&UserSelectionScreen::SetPublicSessionDisplayName,
+                 weak_factory_.GetWeakPtr(),
+                 user_id));
+}
+
+void UserSelectionScreen::SetPublicSessionDisplayName(
+    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()));
+}
+
 }  // namespace chromeos