[CrOS multi-profiles] Restore user sessions after crash

chrome/browser/chromeos/login/user_manager_impl.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_LOGIN_USER_MANAGER_IMPL_H_
 #define CHROME_BROWSER_CHROMEOS_LOGIN_USER_MANAGER_IMPL_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/synchronization/lock.h"
+#include "chrome/browser/chromeos/login/login_utils.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/user_image_manager_impl.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/login/wallpaper_manager.h"
 #include "chrome/browser/chromeos/policy/device_local_account_policy_service.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chrome/browser/sync/profile_sync_service_observer.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 class PrefService;
 class ProfileSyncService;
 
 namespace policy {
 struct DeviceLocalAccount;
 }
 
 namespace chromeos {
 
 class RemoveUserDelegate;
 class SessionLengthLimiter;
 
 // Implementation of the UserManager.
 class UserManagerImpl
     : public UserManager,
+      public LoginUtils::Delegate,
       public ProfileSyncServiceObserver,
       public content::NotificationObserver,
       public policy::DeviceLocalAccountPolicyService::Observer {
  public:
   virtual ~UserManagerImpl();
 
   // UserManager implementation:
   virtual void Shutdown() OVERRIDE;
   virtual UserImageManager* GetUserImageManager() OVERRIDE;
   virtual const UserList& GetUsers() const OVERRIDE;
@@ skipping 33 matching lines @@
   virtual bool CanCurrentUserLock() const OVERRIDE;
   virtual bool IsUserLoggedIn() const OVERRIDE;
   virtual bool IsLoggedInAsRegularUser() const OVERRIDE;
   virtual bool IsLoggedInAsDemoUser() const OVERRIDE;
   virtual bool IsLoggedInAsPublicAccount() const OVERRIDE;
   virtual bool IsLoggedInAsGuest() const OVERRIDE;
   virtual bool IsLoggedInAsLocallyManagedUser() const OVERRIDE;
   virtual bool IsLoggedInAsKioskApp() const OVERRIDE;
   virtual bool IsLoggedInAsStub() const OVERRIDE;
   virtual bool IsSessionStarted() const OVERRIDE;
+  virtual bool UserSessionsRestored() const OVERRIDE;
   virtual MergeSessionState GetMergeSessionState() const OVERRIDE;
   virtual void SetMergeSessionState(MergeSessionState status) OVERRIDE;
   virtual bool HasBrowserRestarted() const OVERRIDE;
   virtual bool IsUserNonCryptohomeDataEphemeral(
       const std::string& email) const OVERRIDE;
   virtual void AddObserver(UserManager::Observer* obs) OVERRIDE;
   virtual void RemoveObserver(UserManager::Observer* obs) OVERRIDE;
   virtual void AddSessionStateObserver(
       UserManager::UserSessionStateObserver* obs) OVERRIDE;
   virtual void RemoveSessionStateObserver(
@@ skipping 34 matching lines @@
   virtual void OnPolicyUpdated(const std::string& user_id) OVERRIDE;
   virtual void OnDeviceLocalAccountsChanged() OVERRIDE;
 
  private:
   friend class UserManager;
   friend class WallpaperManager;
   friend class UserManagerTest;
 
   UserManagerImpl();
 
+  // LoginUtils::Delegate implementation:
+  // Used when restoring user sessions after crash.
+  virtual void OnProfilePrepared(Profile* profile) OVERRIDE;
+
   // Loads |users_| from Local State if the list has not been loaded yet.
   // Subsequent calls have no effect. Must be called on the UI thread.
   void EnsureUsersLoaded();
 
   // Retrieves trusted device policies and removes users from the persistent
   // list if ephemeral users are enabled. Schedules a callback to itself if
   // trusted device policies are not yet available.
   void RetrieveTrustedDevicePolicies();
 
   // Returns true if trusted device policies have successfully been retrieved
@@ skipping 87 matching lines @@
 
   // Notifies the UI about a change to the user list.
   void NotifyUserListChanged();
 
   // Notifies observers that merge session state had changed.
   void NotifyMergeSessionStateChanged();
 
   // Notifies observers that active user_id hash has changed.
   void NotifyActiveUserHashChanged(const std::string& hash);
 
+  // Notifies observers that user pending sessions restore has finished.
+  void NotifyPendingUserSessionsRestoreFinished();
+
   // Returns true if there is non-committed user creation transaction.
   bool HasFailedLocallyManagedUserCreationTransaction();
 
   // Attempts to clean up data that could be left from failed user creation.
   void RollbackLocallyManagedUserCreationTransaction();
 
   // Lazily creates default user flow.
   UserFlow* GetDefaultUserFlow() const;
 
   // Update the global LoginState.
   void UpdateLoginState();
 
   // Insert |user| at the front of the LRU user list..
   void SetLRUUser(User* user);
 
   // Callback to process RetrieveActiveSessions() request results.
   void OnRestoreActiveSessions(
       const SessionManagerClient::ActiveSessionsMap& sessions,
       bool success);
 
+  // Called by OnRestoreActiveSessions() when there're user sessions in
+  // |pending_user_sessions_| that has to be restored one by one.
+  // Also called after first user session from that list is restored and so on.
+  // Process continues till |pending_user_sessions_| map is not empty.
+  void RestorePendingUserSessions();
+
   // Interface to the signed settings store.
   CrosSettings* cros_settings_;
 
   // Interface to device-local account definitions and associated policy.
   policy::DeviceLocalAccountPolicyService* device_local_account_policy_service_;
 
   // True if users have been loaded from prefs already.
   bool users_loaded_;
 
   // List of all known users. User instances are owned by |this|. Regular users
@@ skipping 15 matching lines @@
 
   // The logged-in user that is currently active in current session.
   // NULL until a user has logged in, then points to one
   // of the User instances in |users_|, the |guest_user_| instance or an
   // ephemeral user instance.
   User* active_user_;
 
   // True if SessionStarted() has been called.
   bool session_started_;
 
+  // True is user sessions has been restored after crash.
+  // On a normal boot then login into user sessions this will be false.
+  bool user_sessions_restored_;
+
   // Cached flag of whether currently logged-in user is owner or not.
   // May be accessed on different threads, requires locking.
   bool is_current_user_owner_;
   mutable base::Lock is_current_user_owner_lock_;
 
   // Cached flag of whether the currently logged-in user existed before this
   // login.
   bool is_current_user_new_;
 
   // Cached flag of whether the currently logged-in user is a regular user who
@@ skipping 39 matching lines @@
   scoped_ptr<SessionLengthLimiter> session_length_limiter_;
 
   typedef std::map<std::string, UserFlow*> FlowMap;
 
   // Lazy-initialized default flow.
   mutable scoped_ptr<UserFlow> default_flow_;
 
   // Specific flows by user e-mail.
   FlowMap specific_flows_;
 
+  // User sessions that have to be restored after browser crash.
+  // [user_id] > [user_id_hash]
+  SessionManagerClient::ActiveSessionsMap pending_user_sessions_;
+
   DISALLOW_COPY_AND_ASSIGN(UserManagerImpl);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_LOGIN_USER_MANAGER_IMPL_H_