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

chrome/browser/chromeos/login/screens/user_selection_screen.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_USER_SELECTION_SCREEN_H_
 #define CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_USER_SELECTION_SCREEN_H_
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/memory/weak_ptr.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
+#include "chrome/browser/chromeos/policy/device_local_account_policy_service.h"

[Nikita (slow), 2014/07/30 09:27:58]

Would it be possible to encapsulate chrome/browser/chromeos/policy dependency
somehow and move it out of this class as much as possible so that it would be
trivial to extract UserSelectionScreen out of src/chrome even if Policy code
stays in src/chrome for now?

This is needed for login code refactoring for Athena. End goal is to extract as
much as possible while extracted components are not allowed to depend on
src/chrome.

[bartfab (slow), 2014/08/04 13:46:49]

I moved all policy-related code to a ChromeUserSelectionScreen subclass. The
base UserSelectionScreen is not getting any new dependencies anymore.

 #include "chrome/browser/signin/screenlock_bridge.h"
 #include "components/user_manager/user.h"
 #include "ui/wm/core/user_activity_observer.h"
 
+namespace policy {
+class DeviceLocalAccountPolicyBroker;
+}
+
 namespace chromeos {
 
 class LoginDisplayWebUIHandler;
 
 // This class represents User Selection screen: user pod-based login screen.
-class UserSelectionScreen : public wm::UserActivityObserver {
+class UserSelectionScreen
+    : public wm::UserActivityObserver,
+      public policy::DeviceLocalAccountPolicyService::Observer {
  public:
   UserSelectionScreen();
   virtual ~UserSelectionScreen();
 
   static const user_manager::UserList PrepareUserListForSending(
       const user_manager::UserList& users,
       std::string owner,
       bool is_signin_to_add);
 
   void SetHandler(LoginDisplayWebUIHandler* handler);
 
   void Init(const user_manager::UserList& users, bool show_guest);
   const user_manager::UserList& GetUsers() const;
   void OnUserImageChanged(const user_manager::User& user);
   void OnBeforeUserRemoved(const std::string& username);
   void OnUserRemoved(const std::string& username);
 
   void OnPasswordClearTimerExpired();
   void SendUserList();
   void HandleGetUsers();
   void SetAuthType(const std::string& username,
                    ScreenlockBridge::LockHandler::AuthType auth_type);
   ScreenlockBridge::LockHandler::AuthType GetAuthType(
       const std::string& username) const;
 
   // wm::UserActivityDetector implementation:
   virtual void OnUserActivity(const ui::Event* event) OVERRIDE;
 
+  // policy::DeviceLocalAccountPolicyService::Observer implementation:
+  virtual void OnPolicyUpdated(const std::string& user_id) OVERRIDE;
+  virtual void OnDeviceLocalAccountsChanged() OVERRIDE;
+
   // Fills |user_dict| with information about |user|.
   static void FillUserDictionary(
       user_manager::User* user,
       bool is_owner,
       bool is_signin_to_add,
       ScreenlockBridge::LockHandler::AuthType auth_type,
       base::DictionaryValue* user_dict);
 
   // Determines if user auth status requires online sign in.
   static bool ShouldForceOnlineSignIn(const user_manager::User* user);
 
  private:
+  // Check whether the display name set by policy for a public session has
+  // changed and if so, notify the UI.
+  void CheckForPublicSessionDisplayNameChange(
+      policy::DeviceLocalAccountPolicyBroker* broker);
+
+  // Notify the UI that the display name for a public session has changed,
+  // taking the display name from the |User| owned by |UserManager|.
+  void SetPublicSessionDisplayName(const std::string& user_id);
+
   LoginDisplayWebUIHandler* handler_;
+  bool handler_initialized_;
+
+  policy::DeviceLocalAccountPolicyService* device_local_account_policy_service_;
 
   // Set of Users that are visible.
   user_manager::UserList users_;
 
   // Whether to show guest login.
   bool show_guest_;
 
+  // Map from public session user IDs to their display names set by policy.
+  typedef std::map<std::string, std::string> DisplayNamesMap;
+  DisplayNamesMap public_session_display_names_;
+
   // Map of usernames to their current authentication type. If a user is not
   // contained in the map, it is using the default authentication type.
   std::map<std::string, ScreenlockBridge::LockHandler::AuthType>
       user_auth_type_map_;
 
   // Timer for measuring idle state duration before password clear.
   base::OneShotTimer<UserSelectionScreen> password_clear_timer_;
 
+  base::WeakPtrFactory<UserSelectionScreen> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(UserSelectionScreen);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_LOGIN_SCREENS_USER_SELECTION_SCREEN_H_