[session_manager] Move user session initialization code out of ExistingUserController

chrome/browser/chromeos/login/session/user_session_manager.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_SESSION_USER_SESSION_MANAGER_H_
 #define CHROME_BROWSER_CHROMEOS_LOGIN_SESSION_USER_SESSION_MANAGER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 23 matching lines @@
 
 }  // namespace user_manager
 
 namespace chromeos {
 
 class EasyUnlockKeyManager;
 
 class UserSessionManagerDelegate {
  public:
   // Called after profile is loaded and prepared for the session.
-  virtual void OnProfilePrepared(Profile* profile) = 0;
+  // |browser_launched| will be true is browser has been launched, otherwise
+  // it will return false and client is responsible on launching browser.
+  virtual void OnProfilePrepared(Profile* profile,
+                                 bool browser_launched) = 0;
 
 #if defined(ENABLE_RLZ)
   // Called after post-profile RLZ initialization.
   virtual void OnRlzInitialized();
 #endif
  protected:
   virtual ~UserSessionManagerDelegate();
 };
 
 class UserSessionStateObserver {
  public:
   // Called when UserManager finishes restoring user sessions after crash.
   virtual void PendingUserSessionsRestoreFinished();
 
  protected:
   virtual ~UserSessionStateObserver();
 };
 
 // UserSessionManager is responsible for starting user session which includes:
-// load and initialize Profile (including custom Profile preferences),
-// mark user as logged in and notify observers,
-// initialize OAuth2 authentication session,
-// initialize and launch user session based on the user type.
+// * load and initialize Profile (including custom Profile preferences),
+// * mark user as logged in and notify observers,
+// * initialize OAuth2 authentication session,
+// * initialize and launch user session based on the user type.
 // Also supports restoring active user sessions after browser crash:
 // load profile, restore OAuth authentication session etc.
 class UserSessionManager
     : public OAuth2LoginManager::Observer,
       public net::NetworkChangeNotifier::ConnectionTypeObserver,
       public base::SupportsWeakPtr<UserSessionManager>,
       public UserSessionManagerDelegate,
       public user_manager::UserManager::UserSessionStateObserver {
  public:
+  // Context of StartSession calls.
+  typedef enum {
+    // Starting primary user session, through login UI.
+    PRIMARY_USER_SESSION,
+
+    // Starting secondary user session, through multi-profiles login UI.
+    SECONDARY_USER_SESSION,
+
+    // Starting primary user session after browser crash.
+    PRIMARY_USER_SESSION_AFTER_CRASH,
+
+    // Starting secondary user session after browser crash.
+    SECONDARY_USER_SESSION_AFTER_CRASH,
+  } StartSessionType;
+
   // Returns UserSessionManager instance.
   static UserSessionManager* GetInstance();
 
   // Called when user is logged in to override base::DIR_HOME path.
   static void OverrideHomedir();
 
   // Registers session related preferences.
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
   // Invoked after the tmpfs is successfully mounted.
   // Asks session_manager to restart Chrome in Guest session mode.
   // |start_url| is an optional URL to be opened in Guest session browser.
   void CompleteGuestSessionLogin(const GURL& start_url);
 
   // Start user session given |user_context| and |authenticator| which holds
   // authentication context (profile).
   void StartSession(const UserContext& user_context,
+                    StartSessionType start_session_type,
                     scoped_refptr<Authenticator> authenticator,
                     bool has_auth_cookies,
                     bool has_active_session,
                     UserSessionManagerDelegate* delegate);
 
   // Perform additional actions once system wide notification
   // "UserLoggedIn" has been sent.
   void PerformPostUserLoggedInActions();
 
   // Restores authentication session after crash.
@@ skipping 87 matching lines @@
       Profile* user_profile,
       OAuth2LoginManager::SessionRestoreState state) override;
   virtual void OnNewRefreshTokenAvaiable(Profile* user_profile) override;
 
   // net::NetworkChangeNotifier::ConnectionTypeObserver overrides:
   virtual void OnConnectionTypeChanged(
       net::NetworkChangeNotifier::ConnectionType type) override;
 
   // UserSessionManagerDelegate overrides:
   // Used when restoring user sessions after crash.
-  virtual void OnProfilePrepared(Profile* profile) override;
+  virtual void OnProfilePrepared(Profile* profile,
+                                 bool browser_launched) override;
 
   void CreateUserSession(const UserContext& user_context,
                          bool has_auth_cookies);
   void PreStartSession();
   void StartCrosSession();
   void NotifyUserLoggedIn();
   void PrepareProfile();
 
   // Callback for asynchronous profile creation.
   void OnProfileCreated(const UserContext& user_context,
@@ skipping 14 matching lines @@
                               bool is_incognito_profile,
                               const std::string& user_id);
 
   // Callback to resume profile creation after transferring auth data from
   // the authentication profile.
   void CompleteProfileCreateAfterAuthTransfer(Profile* profile);
 
   // Finalized profile preparation.
   void FinalizePrepareProfile(Profile* profile);
 
+  // Starts out-of-box flow with the specified screen.
+  void ActivateWizard(const std::string& screen_name);
+
+  // Adds first-time login URLs.
+  void InitializeStartUrls() const;
+
+  // Perform session initialization and either move to additional login flows
+  // such as TOS (public sessions), priority pref sync UI (new users) or
+  // launch browser.
+  // Returns true if browser has been launched or false otherwise.
+  bool InitializeUserSession(Profile* profile);
+
   // Initializes member variables needed for session restore process via
   // OAuthLoginManager.
   void InitSessionRestoreStrategy();
 
   // Restores GAIA auth cookies for the created user profile from OAuth2 token.
   void RestoreAuthSessionImpl(Profile* profile,
                               bool restore_from_auth_cookies);
 
   // Initializes RLZ. If |disabled| is true, RLZ pings are disabled.
   void InitRlzImpl(Profile* profile, bool disabled);
@@ skipping 17 matching lines @@
 
   // Callback invoked when Easy unlock key operations are finished.
   void OnEasyUnlockKeyOpsFinished(const std::string& user_id,
                                   bool success);
 
   UserSessionManagerDelegate* delegate_;
 
   // Authentication/user context.
   UserContext user_context_;
   scoped_refptr<Authenticator> authenticator_;
+  StartSessionType start_session_type_;
 
   // True if the authentication context's cookie jar contains authentication
   // cookies from the authentication extension login flow.
   bool has_auth_cookies_;
 
   // Active user session restoration related members.
 
   // True if user sessions has been restored after crash.
   // On a normal boot then login into user sessions this will be false.
   bool user_sessions_restored_;
@@ skipping 35 matching lines @@
   scoped_ptr<EasyUnlockKeyManager> easy_unlock_key_manager_;
   bool running_easy_unlock_key_ops_;
   base::Closure easy_unlock_key_ops_finished_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(UserSessionManager);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_LOGIN_SESSION_USER_SESSION_MANAGER_H_