| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #ifndef CHROME_BROWSER_CHROMEOS_LOGIN_USER_MANAGER_IMPL_H_ | |
| 6 #define CHROME_BROWSER_CHROMEOS_LOGIN_USER_MANAGER_IMPL_H_ | |
| 7 | |
| 8 #include <map> | |
| 9 #include <string> | |
| 10 #include <vector> | |
| 11 | |
| 12 #include "base/basictypes.h" | |
| 13 #include "base/containers/hash_tables.h" | |
| 14 #include "base/memory/linked_ptr.h" | |
| 15 #include "base/memory/scoped_ptr.h" | |
| 16 #include "base/observer_list.h" | |
| 17 #include "base/synchronization/lock.h" | |
| 18 #include "base/time/time.h" | |
| 19 #include "chrome/browser/chromeos/login/login_utils.h" | |
| 20 #include "chrome/browser/chromeos/login/multi_profile_user_controller_delegate.h
" | |
| 21 #include "chrome/browser/chromeos/login/user.h" | |
| 22 #include "chrome/browser/chromeos/login/user_image_manager_impl.h" | |
| 23 #include "chrome/browser/chromeos/login/user_manager.h" | |
| 24 #include "chrome/browser/chromeos/login/wallpaper_manager.h" | |
| 25 #include "chrome/browser/chromeos/policy/cloud_external_data_policy_observer.h" | |
| 26 #include "chrome/browser/chromeos/policy/device_local_account_policy_service.h" | |
| 27 #include "chrome/browser/chromeos/settings/cros_settings.h" | |
| 28 #include "chrome/browser/chromeos/settings/device_settings_service.h" | |
| 29 #include "chromeos/dbus/session_manager_client.h" | |
| 30 #include "content/public/browser/notification_observer.h" | |
| 31 #include "content/public/browser/notification_registrar.h" | |
| 32 | |
| 33 class PrefService; | |
| 34 class ProfileSyncService; | |
| 35 | |
| 36 namespace policy { | |
| 37 struct DeviceLocalAccount; | |
| 38 } | |
| 39 | |
| 40 namespace chromeos { | |
| 41 | |
| 42 class MultiProfileUserController; | |
| 43 class RemoveUserDelegate; | |
| 44 class SupervisedUserManagerImpl; | |
| 45 class SessionLengthLimiter; | |
| 46 | |
| 47 // Implementation of the UserManager. | |
| 48 class UserManagerImpl | |
| 49 : public UserManager, | |
| 50 public LoginUtils::Delegate, | |
| 51 public content::NotificationObserver, | |
| 52 public policy::CloudExternalDataPolicyObserver::Delegate, | |
| 53 public policy::DeviceLocalAccountPolicyService::Observer, | |
| 54 public MultiProfileUserControllerDelegate { | |
| 55 public: | |
| 56 virtual ~UserManagerImpl(); | |
| 57 | |
| 58 // UserManager implementation: | |
| 59 virtual void Shutdown() OVERRIDE; | |
| 60 virtual MultiProfileUserController* GetMultiProfileUserController() OVERRIDE; | |
| 61 virtual UserImageManager* GetUserImageManager( | |
| 62 const std::string& user_id) OVERRIDE; | |
| 63 virtual SupervisedUserManager* GetSupervisedUserManager() OVERRIDE; | |
| 64 virtual const UserList& GetUsers() const OVERRIDE; | |
| 65 virtual UserList GetUsersAdmittedForMultiProfile() const OVERRIDE; | |
| 66 virtual const UserList& GetLoggedInUsers() const OVERRIDE; | |
| 67 virtual const UserList& GetLRULoggedInUsers() OVERRIDE; | |
| 68 virtual UserList GetUnlockUsers() const OVERRIDE; | |
| 69 virtual const std::string& GetOwnerEmail() OVERRIDE; | |
| 70 virtual void UserLoggedIn(const std::string& user_id, | |
| 71 const std::string& user_id_hash, | |
| 72 bool browser_restart) OVERRIDE; | |
| 73 virtual void SwitchActiveUser(const std::string& user_id) OVERRIDE; | |
| 74 virtual void RestoreActiveSessions() OVERRIDE; | |
| 75 virtual void SessionStarted() OVERRIDE; | |
| 76 virtual void RemoveUser(const std::string& user_id, | |
| 77 RemoveUserDelegate* delegate) OVERRIDE; | |
| 78 virtual void RemoveUserFromList(const std::string& user_id) OVERRIDE; | |
| 79 virtual bool IsKnownUser(const std::string& user_id) const OVERRIDE; | |
| 80 virtual const User* FindUser(const std::string& user_id) const OVERRIDE; | |
| 81 virtual User* FindUserAndModify(const std::string& user_id) OVERRIDE; | |
| 82 virtual const User* GetLoggedInUser() const OVERRIDE; | |
| 83 virtual User* GetLoggedInUser() OVERRIDE; | |
| 84 virtual const User* GetActiveUser() const OVERRIDE; | |
| 85 virtual User* GetActiveUser() OVERRIDE; | |
| 86 virtual const User* GetPrimaryUser() const OVERRIDE; | |
| 87 virtual User* GetUserByProfile(Profile* profile) const OVERRIDE; | |
| 88 virtual Profile* GetProfileByUser(const User* user) const OVERRIDE; | |
| 89 virtual void SaveUserOAuthStatus( | |
| 90 const std::string& user_id, | |
| 91 User::OAuthTokenStatus oauth_token_status) OVERRIDE; | |
| 92 virtual void SaveForceOnlineSignin(const std::string& user_id, | |
| 93 bool force_online_signin) OVERRIDE; | |
| 94 virtual void SaveUserDisplayName(const std::string& user_id, | |
| 95 const base::string16& display_name) OVERRIDE; | |
| 96 virtual base::string16 GetUserDisplayName( | |
| 97 const std::string& user_id) const OVERRIDE; | |
| 98 virtual void SaveUserDisplayEmail(const std::string& user_id, | |
| 99 const std::string& display_email) OVERRIDE; | |
| 100 virtual std::string GetUserDisplayEmail( | |
| 101 const std::string& user_id) const OVERRIDE; | |
| 102 virtual void UpdateUserAccountData( | |
| 103 const std::string& user_id, | |
| 104 const UserAccountData& account_data) OVERRIDE; | |
| 105 virtual bool IsCurrentUserOwner() const OVERRIDE; | |
| 106 virtual bool IsCurrentUserNew() const OVERRIDE; | |
| 107 virtual bool IsCurrentUserNonCryptohomeDataEphemeral() const OVERRIDE; | |
| 108 virtual bool CanCurrentUserLock() const OVERRIDE; | |
| 109 virtual bool IsUserLoggedIn() const OVERRIDE; | |
| 110 virtual bool IsLoggedInAsRegularUser() const OVERRIDE; | |
| 111 virtual bool IsLoggedInAsDemoUser() const OVERRIDE; | |
| 112 virtual bool IsLoggedInAsPublicAccount() const OVERRIDE; | |
| 113 virtual bool IsLoggedInAsGuest() const OVERRIDE; | |
| 114 virtual bool IsLoggedInAsLocallyManagedUser() const OVERRIDE; | |
| 115 virtual bool IsLoggedInAsKioskApp() const OVERRIDE; | |
| 116 virtual bool IsLoggedInAsStub() const OVERRIDE; | |
| 117 virtual bool IsSessionStarted() const OVERRIDE; | |
| 118 virtual bool UserSessionsRestored() const OVERRIDE; | |
| 119 virtual bool HasBrowserRestarted() const OVERRIDE; | |
| 120 virtual bool IsUserNonCryptohomeDataEphemeral( | |
| 121 const std::string& user_id) const OVERRIDE; | |
| 122 virtual void AddObserver(UserManager::Observer* obs) OVERRIDE; | |
| 123 virtual void RemoveObserver(UserManager::Observer* obs) OVERRIDE; | |
| 124 virtual void AddSessionStateObserver( | |
| 125 UserManager::UserSessionStateObserver* obs) OVERRIDE; | |
| 126 virtual void RemoveSessionStateObserver( | |
| 127 UserManager::UserSessionStateObserver* obs) OVERRIDE; | |
| 128 virtual void NotifyLocalStateChanged() OVERRIDE; | |
| 129 | |
| 130 virtual UserFlow* GetCurrentUserFlow() const OVERRIDE; | |
| 131 virtual UserFlow* GetUserFlow(const std::string& user_id) const OVERRIDE; | |
| 132 virtual void SetUserFlow(const std::string& user_id, UserFlow* flow) OVERRIDE; | |
| 133 virtual void ResetUserFlow(const std::string& user_id) OVERRIDE; | |
| 134 virtual bool GetAppModeChromeClientOAuthInfo( | |
| 135 std::string* chrome_client_id, | |
| 136 std::string* chrome_client_secret) OVERRIDE; | |
| 137 virtual void SetAppModeChromeClientOAuthInfo( | |
| 138 const std::string& chrome_client_id, | |
| 139 const std::string& chrome_client_secret) OVERRIDE; | |
| 140 virtual bool AreLocallyManagedUsersAllowed() const OVERRIDE; | |
| 141 virtual base::FilePath GetUserProfileDir( | |
| 142 const std::string& user_id) const OVERRIDE; | |
| 143 | |
| 144 // content::NotificationObserver implementation. | |
| 145 virtual void Observe(int type, | |
| 146 const content::NotificationSource& source, | |
| 147 const content::NotificationDetails& details) OVERRIDE; | |
| 148 | |
| 149 // policy::CloudExternalDataPolicyObserver::Delegate: | |
| 150 virtual void OnExternalDataSet(const std::string& policy, | |
| 151 const std::string& user_id) OVERRIDE; | |
| 152 virtual void OnExternalDataCleared(const std::string& policy, | |
| 153 const std::string& user_id) OVERRIDE; | |
| 154 virtual void OnExternalDataFetched(const std::string& policy, | |
| 155 const std::string& user_id, | |
| 156 scoped_ptr<std::string> data) OVERRIDE; | |
| 157 | |
| 158 // policy::DeviceLocalAccountPolicyService::Observer implementation. | |
| 159 virtual void OnPolicyUpdated(const std::string& user_id) OVERRIDE; | |
| 160 virtual void OnDeviceLocalAccountsChanged() OVERRIDE; | |
| 161 | |
| 162 virtual bool RespectLocalePreference( | |
| 163 Profile* profile, | |
| 164 const User* user, | |
| 165 scoped_ptr<locale_util::SwitchLanguageCallback> callback) const OVERRIDE; | |
| 166 | |
| 167 void StopPolicyObserverForTesting(); | |
| 168 | |
| 169 private: | |
| 170 friend class SupervisedUserManagerImpl; | |
| 171 friend class UserManager; | |
| 172 friend class WallpaperManager; | |
| 173 friend class UserManagerTest; | |
| 174 friend class WallpaperManagerTest; | |
| 175 | |
| 176 typedef base::hash_map<std::string, | |
| 177 linked_ptr<UserImageManager> > UserImageManagerMap; | |
| 178 | |
| 179 // Stages of loading user list from preferences. Some methods can have | |
| 180 // different behavior depending on stage. | |
| 181 enum UserLoadStage { | |
| 182 STAGE_NOT_LOADED = 0, | |
| 183 STAGE_LOADING, | |
| 184 STAGE_LOADED | |
| 185 }; | |
| 186 | |
| 187 UserManagerImpl(); | |
| 188 | |
| 189 // LoginUtils::Delegate implementation: | |
| 190 // Used when restoring user sessions after crash. | |
| 191 virtual void OnProfilePrepared(Profile* profile) OVERRIDE; | |
| 192 | |
| 193 // Loads |users_| from Local State if the list has not been loaded yet. | |
| 194 // Subsequent calls have no effect. Must be called on the UI thread. | |
| 195 void EnsureUsersLoaded(); | |
| 196 | |
| 197 // Retrieves trusted device policies and removes users from the persistent | |
| 198 // list if ephemeral users are enabled. Schedules a callback to itself if | |
| 199 // trusted device policies are not yet available. | |
| 200 void RetrieveTrustedDevicePolicies(); | |
| 201 | |
| 202 // Returns true if trusted device policies have successfully been retrieved | |
| 203 // and ephemeral users are enabled. | |
| 204 bool AreEphemeralUsersEnabled() const; | |
| 205 | |
| 206 // Returns a list of users who have logged into this device previously. | |
| 207 // Same as GetUsers but used if you need to modify User from that list. | |
| 208 UserList& GetUsersAndModify(); | |
| 209 | |
| 210 // Returns the user with the given email address if found in the persistent | |
| 211 // list. Returns |NULL| otherwise. | |
| 212 const User* FindUserInList(const std::string& user_id) const; | |
| 213 | |
| 214 // Returns |true| if user with the given id is found in the persistent list. | |
| 215 // Returns |false| otherwise. Does not trigger user loading. | |
| 216 const bool UserExistsInList(const std::string& user_id) const; | |
| 217 | |
| 218 // Same as FindUserInList but returns non-const pointer to User object. | |
| 219 User* FindUserInListAndModify(const std::string& user_id); | |
| 220 | |
| 221 // Indicates that a user just logged in as guest. | |
| 222 void GuestUserLoggedIn(); | |
| 223 | |
| 224 // Indicates that a regular user just logged in. | |
| 225 void RegularUserLoggedIn(const std::string& user_id); | |
| 226 | |
| 227 // Indicates that a regular user just logged in as ephemeral. | |
| 228 void RegularUserLoggedInAsEphemeral(const std::string& user_id); | |
| 229 | |
| 230 // Indicates that a locally managed user just logged in. | |
| 231 void LocallyManagedUserLoggedIn(const std::string& user_id); | |
| 232 | |
| 233 // Indicates that a user just logged into a public session. | |
| 234 void PublicAccountUserLoggedIn(User* user); | |
| 235 | |
| 236 // Indicates that a kiosk app robot just logged in. | |
| 237 void KioskAppLoggedIn(const std::string& app_id); | |
| 238 | |
| 239 // Indicates that the demo account has just logged in. | |
| 240 void DemoAccountLoggedIn(); | |
| 241 | |
| 242 // Indicates that a user just logged into a retail mode session. | |
| 243 void RetailModeUserLoggedIn(); | |
| 244 | |
| 245 // Notifies that user has logged in. | |
| 246 // Sends NOTIFICATION_LOGIN_USER_CHANGED notification. | |
| 247 void NotifyOnLogin(); | |
| 248 | |
| 249 // Reads user's oauth token status from local state preferences. | |
| 250 User::OAuthTokenStatus LoadUserOAuthStatus(const std::string& user_id) const; | |
| 251 | |
| 252 // Read a flag indicating whether online authentication against GAIA should | |
| 253 // be enforced during the user's next sign-in from local state preferences. | |
| 254 bool LoadForceOnlineSignin(const std::string& user_id) const; | |
| 255 | |
| 256 void SetCurrentUserIsOwner(bool is_current_user_owner); | |
| 257 | |
| 258 // Updates current user ownership on UI thread. | |
| 259 void UpdateOwnership(); | |
| 260 | |
| 261 // Removes data stored or cached outside the user's cryptohome (wallpaper, | |
| 262 // avatar, OAuth token status, display name, display email). | |
| 263 void RemoveNonCryptohomeData(const std::string& user_id); | |
| 264 | |
| 265 // Removes a regular or locally managed user from the user list. | |
| 266 // Returns the user if found or NULL otherwise. | |
| 267 // Also removes the user from the persistent user list. | |
| 268 User* RemoveRegularOrLocallyManagedUserFromList(const std::string& user_id); | |
| 269 | |
| 270 // If data for a public account is marked as pending removal and the user is | |
| 271 // no longer logged into that account, removes the data. | |
| 272 void CleanUpPublicAccountNonCryptohomeDataPendingRemoval(); | |
| 273 | |
| 274 // Removes data belonging to public accounts that are no longer found on the | |
| 275 // user list. If the user is currently logged into one of these accounts, the | |
| 276 // data for that account is not removed immediately but marked as pending | |
| 277 // removal after logout. | |
| 278 void CleanUpPublicAccountNonCryptohomeData( | |
| 279 const std::vector<std::string>& old_public_accounts); | |
| 280 | |
| 281 // Replaces the list of public accounts with those found in | |
| 282 // |device_local_accounts|. Ensures that data belonging to accounts no longer | |
| 283 // on the list is removed. Returns |true| if the list has changed. | |
| 284 // Public accounts are defined by policy. This method is called whenever an | |
| 285 // updated list of public accounts is received from policy. | |
| 286 bool UpdateAndCleanUpPublicAccounts( | |
| 287 const std::vector<policy::DeviceLocalAccount>& device_local_accounts); | |
| 288 | |
| 289 // Updates the display name for public account |username| from policy settings | |
| 290 // associated with that username. | |
| 291 void UpdatePublicAccountDisplayName(const std::string& user_id); | |
| 292 | |
| 293 // Notifies the UI about a change to the user list. | |
| 294 void NotifyUserListChanged(); | |
| 295 | |
| 296 // Notifies observers that merge session state had changed. | |
| 297 void NotifyMergeSessionStateChanged(); | |
| 298 | |
| 299 // Notifies observers that active user has changed. | |
| 300 void NotifyActiveUserChanged(const User* active_user); | |
| 301 | |
| 302 // Notifies observers that another user was added to the session. | |
| 303 void NotifyUserAddedToSession(const User* added_user); | |
| 304 | |
| 305 // Notifies observers that active user_id hash has changed. | |
| 306 void NotifyActiveUserHashChanged(const std::string& hash); | |
| 307 | |
| 308 // Notifies observers that user pending sessions restore has finished. | |
| 309 void NotifyPendingUserSessionsRestoreFinished(); | |
| 310 | |
| 311 // Lazily creates default user flow. | |
| 312 UserFlow* GetDefaultUserFlow() const; | |
| 313 | |
| 314 // Update the global LoginState. | |
| 315 void UpdateLoginState(); | |
| 316 | |
| 317 // Insert |user| at the front of the LRU user list. | |
| 318 void SetLRUUser(User* user); | |
| 319 | |
| 320 // Adds |user| to users list, and adds it to front of LRU list. It is assumed | |
| 321 // that there is no user with same id. | |
| 322 void AddUserRecord(User* user); | |
| 323 | |
| 324 // Callback to process RetrieveActiveSessions() request results. | |
| 325 void OnRestoreActiveSessions( | |
| 326 const SessionManagerClient::ActiveSessionsMap& sessions, | |
| 327 bool success); | |
| 328 | |
| 329 // Called by OnRestoreActiveSessions() when there're user sessions in | |
| 330 // |pending_user_sessions_| that has to be restored one by one. | |
| 331 // Also called after first user session from that list is restored and so on. | |
| 332 // Process continues till |pending_user_sessions_| map is not empty. | |
| 333 void RestorePendingUserSessions(); | |
| 334 | |
| 335 // Sends metrics in response to a regular user logging in. | |
| 336 void SendRegularUserLoginMetrics(const std::string& user_id); | |
| 337 | |
| 338 // Implementation for RemoveUser method. This is an asynchronous part of the | |
| 339 // method, that verifies that owner will not get deleted, and calls | |
| 340 // |RemoveNonOwnerUserInternal|. | |
| 341 void RemoveUserInternal(const std::string& user_email, | |
| 342 RemoveUserDelegate* delegate); | |
| 343 | |
| 344 // Implementation for RemoveUser method. It is synchronous. It is called from | |
| 345 // RemoveUserInternal after owner check. | |
| 346 void RemoveNonOwnerUserInternal(const std::string& user_email, | |
| 347 RemoveUserDelegate* delegate); | |
| 348 | |
| 349 // MultiProfileUserControllerDelegate implementation: | |
| 350 virtual void OnUserNotAllowed(const std::string& user_email) OVERRIDE; | |
| 351 | |
| 352 // Sets account locale for user with id |user_id|. | |
| 353 virtual void UpdateUserAccountLocale(const std::string& user_id, | |
| 354 const std::string& locale); | |
| 355 | |
| 356 // Updates user account after locale was resolved. | |
| 357 void DoUpdateAccountLocale(const std::string& user_id, | |
| 358 const std::string& resolved_locale); | |
| 359 | |
| 360 // Update the number of users. | |
| 361 void UpdateNumberOfUsers(); | |
| 362 | |
| 363 // A wrapper around C++ delete operator. Deletes |user|, and when |user| | |
| 364 // equals to active_user_, active_user_ is reset to NULL. | |
| 365 void DeleteUser(User* user); | |
| 366 | |
| 367 // Interface to the signed settings store. | |
| 368 CrosSettings* cros_settings_; | |
| 369 | |
| 370 // Interface to device-local account definitions and associated policy. | |
| 371 policy::DeviceLocalAccountPolicyService* device_local_account_policy_service_; | |
| 372 | |
| 373 // Indicates stage of loading user from prefs. | |
| 374 UserLoadStage user_loading_stage_; | |
| 375 | |
| 376 // List of all known users. User instances are owned by |this|. Regular users | |
| 377 // are removed by |RemoveUserFromList|, public accounts by | |
| 378 // |UpdateAndCleanUpPublicAccounts|. | |
| 379 UserList users_; | |
| 380 | |
| 381 // List of all users that are logged in current session. These point to User | |
| 382 // instances in |users_|. Only one of them could be marked as active. | |
| 383 UserList logged_in_users_; | |
| 384 | |
| 385 // A list of all users that are logged in the current session. In contrast to | |
| 386 // |logged_in_users|, the order of this list is least recently used so that | |
| 387 // the active user should always be the first one in the list. | |
| 388 UserList lru_logged_in_users_; | |
| 389 | |
| 390 // The list which gets reported when the |lru_logged_in_users_| list is empty. | |
| 391 UserList temp_single_logged_in_users_; | |
| 392 | |
| 393 // The logged-in user that is currently active in current session. | |
| 394 // NULL until a user has logged in, then points to one | |
| 395 // of the User instances in |users_|, the |guest_user_| instance or an | |
| 396 // ephemeral user instance. | |
| 397 User* active_user_; | |
| 398 | |
| 399 // The primary user of the current session. It is recorded for the first | |
| 400 // signed-in user and does not change thereafter. | |
| 401 User* primary_user_; | |
| 402 | |
| 403 // True if SessionStarted() has been called. | |
| 404 bool session_started_; | |
| 405 | |
| 406 // True is user sessions has been restored after crash. | |
| 407 // On a normal boot then login into user sessions this will be false. | |
| 408 bool user_sessions_restored_; | |
| 409 | |
| 410 // Cached flag of whether currently logged-in user is owner or not. | |
| 411 // May be accessed on different threads, requires locking. | |
| 412 bool is_current_user_owner_; | |
| 413 mutable base::Lock is_current_user_owner_lock_; | |
| 414 | |
| 415 // Cached flag of whether the currently logged-in user existed before this | |
| 416 // login. | |
| 417 bool is_current_user_new_; | |
| 418 | |
| 419 // Cached flag of whether the currently logged-in user is a regular user who | |
| 420 // logged in as ephemeral. Storage of persistent information is avoided for | |
| 421 // such users by not adding them to the persistent user list, not downloading | |
| 422 // their custom avatars and mounting their cryptohomes using tmpfs. Defaults | |
| 423 // to |false|. | |
| 424 bool is_current_user_ephemeral_regular_user_; | |
| 425 | |
| 426 // Cached flag indicating whether the ephemeral user policy is enabled. | |
| 427 // Defaults to |false| if the value has not been read from trusted device | |
| 428 // policy yet. | |
| 429 bool ephemeral_users_enabled_; | |
| 430 | |
| 431 // Cached name of device owner. Defaults to empty string if the value has not | |
| 432 // been read from trusted device policy yet. | |
| 433 std::string owner_email_; | |
| 434 | |
| 435 // Chrome oauth client id and secret - override values for kiosk mode. | |
| 436 std::string chrome_client_id_; | |
| 437 std::string chrome_client_secret_; | |
| 438 | |
| 439 content::NotificationRegistrar registrar_; | |
| 440 | |
| 441 ObserverList<UserManager::Observer> observer_list_; | |
| 442 | |
| 443 // TODO(nkostylev): Merge with session state refactoring CL. | |
| 444 ObserverList<UserManager::UserSessionStateObserver> | |
| 445 session_state_observer_list_; | |
| 446 | |
| 447 // User avatar managers. | |
| 448 UserImageManagerMap user_image_managers_; | |
| 449 | |
| 450 // Supervised user manager. | |
| 451 scoped_ptr<SupervisedUserManagerImpl> supervised_user_manager_; | |
| 452 | |
| 453 // Session length limiter. | |
| 454 scoped_ptr<SessionLengthLimiter> session_length_limiter_; | |
| 455 | |
| 456 typedef std::map<std::string, UserFlow*> FlowMap; | |
| 457 | |
| 458 // Lazy-initialized default flow. | |
| 459 mutable scoped_ptr<UserFlow> default_flow_; | |
| 460 | |
| 461 // Specific flows by user e-mail. Keys should be canonicalized before | |
| 462 // access. | |
| 463 FlowMap specific_flows_; | |
| 464 | |
| 465 // User sessions that have to be restored after browser crash. | |
| 466 // [user_id] > [user_id_hash] | |
| 467 SessionManagerClient::ActiveSessionsMap pending_user_sessions_; | |
| 468 | |
| 469 // Time at which this object was created. | |
| 470 base::TimeTicks manager_creation_time_; | |
| 471 | |
| 472 scoped_ptr<CrosSettings::ObserverSubscription> | |
| 473 local_accounts_subscription_; | |
| 474 scoped_ptr<CrosSettings::ObserverSubscription> | |
| 475 supervised_users_subscription_; | |
| 476 | |
| 477 scoped_ptr<MultiProfileUserController> multi_profile_user_controller_; | |
| 478 | |
| 479 // Observer for the policy that can be used to manage user images. | |
| 480 scoped_ptr<policy::CloudExternalDataPolicyObserver> avatar_policy_observer_; | |
| 481 | |
| 482 // Observer for the policy that can be used to manage wallpapers. | |
| 483 scoped_ptr<policy::CloudExternalDataPolicyObserver> | |
| 484 wallpaper_policy_observer_; | |
| 485 | |
| 486 // ID of the user just added to the session that needs to be activated | |
| 487 // as soon as user's profile is loaded. | |
| 488 std::string pending_user_switch_; | |
| 489 | |
| 490 DISALLOW_COPY_AND_ASSIGN(UserManagerImpl); | |
| 491 }; | |
| 492 | |
| 493 } // namespace chromeos | |
| 494 | |
| 495 #endif // CHROME_BROWSER_CHROMEOS_LOGIN_USER_MANAGER_IMPL_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 286933002:
[cros login] Split login related classes into subfolders. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src