Implement a policy to autologin a public account.

chrome/browser/chromeos/login/existing_user_controller.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_EXISTING_USER_CONTROLLER_H_
 #define CHROME_BROWSER_CHROMEOS_LOGIN_EXISTING_USER_CONTROLLER_H_
 
 #include <string>
 
+#include "ash/wm/user_activity_observer.h"
 #include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/string16.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "chrome/browser/chromeos/login/login_display.h"
 #include "chrome/browser/chromeos/login/login_performer.h"
@@ skipping 13 matching lines @@
 // ExistingUserController is used to handle login when someone has
 // already logged into the machine.
 // To use ExistingUserController create an instance of it and invoke Init.
 // When Init is called it creates LoginDisplay instance which encapsulates
 // all login UI implementation.
 // ExistingUserController maintains it's own life cycle and deletes itself when
 // the user logs in (or chooses to see other settings).
 class ExistingUserController : public LoginDisplay::Delegate,
                                public content::NotificationObserver,
                                public LoginPerformer::Delegate,
-                               public LoginUtils::Delegate {
+                               public LoginUtils::Delegate,
+                               public ash::UserActivityObserver {
  public:
   // All UI initialization is deferred till Init() call.
   explicit ExistingUserController(LoginDisplayHost* host);
   virtual ~ExistingUserController();
 
   // Returns the current existing user controller if it has been created.
   static ExistingUserController* current_controller() {
     return current_controller_;
   }
 
   // Creates and shows login UI for known users.
   void Init(const UserList& users);
 
   // Tells the controller to enter the Enterprise Enrollment screen when
   // appropriate.
   void DoAutoEnrollment();
 
   // Tells the controller to resume a pending login.
   void ResumeLogin();
 
+  // Start the public session auto-login timer.
+  void StartPublicSessionAutoLoginTimer();
+
+  // Stop the public session auto-login timer when a login attempt begins.
+  void StopPublicSessionAutoLoginTimer();
+
   // LoginDisplay::Delegate: implementation
   virtual void CancelPasswordChangedFlow() OVERRIDE;
   virtual void CreateAccount() OVERRIDE;
   virtual void CreateLocallyManagedUser(const string16& display_name,
                                         const std::string& password) OVERRIDE;
   virtual void CompleteLogin(const std::string& username,
                              const std::string& password) OVERRIDE;
   virtual string16 GetConnectedNetworkName() OVERRIDE;
   virtual void Login(const std::string& username,
                      const std::string& password) OVERRIDE;
   virtual void MigrateUserData(const std::string& old_password) OVERRIDE;
   virtual void LoginAsRetailModeUser() OVERRIDE;
   virtual void LoginAsGuest() OVERRIDE;
   virtual void LoginAsPublicAccount(const std::string& username) OVERRIDE;
+  virtual void OnSigninScreenReady() OVERRIDE;
   virtual void OnUserSelected(const std::string& username) OVERRIDE;
   virtual void OnStartEnterpriseEnrollment() OVERRIDE;
   virtual void OnStartDeviceReset() OVERRIDE;
   virtual void ResyncUserData() OVERRIDE;
   virtual void SetDisplayEmail(const std::string& email) OVERRIDE;
   virtual void ShowWrongHWIDScreen() OVERRIDE;
   virtual void Signout() OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
@@ skipping 12 matching lines @@
     return login_display_.get();
   }
 
   // Returns the LoginDisplayHost for this controller.
   LoginDisplayHost* login_display_host() {
     return host_;
   }
 
  private:
   friend class ExistingUserControllerTest;
+  friend class ExistingUserControllerPublicSessionTest;
   friend class MockLoginPerformerDelegate;
 
+  // Retrieve public session auto-login policy and update the timer.
+  void ConfigurePublicSessionAutoLogin();
+
+  // Trigger public session auto-login.
+  void OnPublicSessionAutoLoginTimerFire();
+
   // LoginPerformer::Delegate implementation:
   virtual void OnLoginFailure(const LoginFailure& error) OVERRIDE;
   virtual void OnLoginSuccess(
       const std::string& username,
       const std::string& password,
       bool pending_requests,
       bool using_oauth) OVERRIDE;
   virtual void OnOffTheRecordLoginSuccess() OVERRIDE;
   virtual void OnPasswordChangeDetected() OVERRIDE;
   virtual void WhiteListCheckFailed(const std::string& email) OVERRIDE;
   virtual void PolicyLoadFailed() OVERRIDE;
   virtual void OnOnlineChecked(
       const std::string& username, bool success) OVERRIDE;
 
   // LoginUtils::Delegate implementation:
   virtual void OnProfilePrepared(Profile* profile) OVERRIDE;
 
+  // UserActivityObserver::Observer implementation.
+  virtual void OnUserActivity() OVERRIDE;
+
   // Starts WizardController with the specified screen.
   void ActivateWizard(const std::string& screen_name);
 
   // Returns corresponding native window.
   gfx::NativeWindow GetNativeWindow() const;
 
   // Adds first-time login URLs.
   void InitializeStartUrls() const;
 
   // Shows "Release Notes"/"What's new"/Getting started guide on update.
@@ skipping 43 matching lines @@
                     std::string password,
                     LoginPerformer::AuthorizationMode auth_mode);
 
   void set_login_performer_delegate(LoginPerformer::Delegate* d) {
     login_performer_delegate_.reset(d);
   }
 
   // Updates the |login_display_| attached to this controller.
   void UpdateLoginDisplay(const UserList& users);
 
+  // Accesses (and lazily constructs if necessary) the auto-login timer.
+  base::OneShotTimer<ExistingUserController>& auto_login_timer();
+
+  // Public session auto-login timer.
+  scoped_ptr<base::OneShotTimer<ExistingUserController> > auto_login_timer_;
+
+  // Public session auto-login timeout, in milliseconds.
+  int public_session_auto_login_delay_;
+
+  // Username for public session auto-login.
+  std::string public_session_auto_login_username_;
+
   // Used to execute login operations.
   scoped_ptr<LoginPerformer> login_performer_;
 
   // Delegate for login performer to be overridden by tests.
   // |this| is used if |login_performer_delegate_| is NULL.
   scoped_ptr<LoginPerformer::Delegate> login_performer_delegate_;
 
   // Delegate to forward all login status events to.
   // Tests can use this to receive login status events.
   LoginStatusConsumer* login_status_consumer_;
@@ skipping 40 matching lines @@
   std::string online_succeeded_for_;
 
   // True if password has been changed for user who is completing sign in.
   // Set in OnLoginSuccess. Before that use LoginPerformer::password_changed().
   bool password_changed_;
 
   // True if auto-enrollment should be performed before starting the user's
   // session.
   bool do_auto_enrollment_;
 
+  // Whether the sign-in UI is finished loading.
+  bool signin_screen_ready_;
+
   // The username used for auto-enrollment, if it was triggered.
   std::string auto_enrollment_username_;
 
   // Callback to invoke to resume login, after auto-enrollment has completed.
   base::Closure resume_login_callback_;
 
   // Time when the signin screen was first displayed. Used to measure the time
   // from showing the screen until a successful login is performed.
   base::Time time_init_;
 
   // Timer for the interval to wait for the reboot after TPM error UI was shown.
   base::OneShotTimer<ExistingUserController> reboot_timer_;
 
   FRIEND_TEST_ALL_PREFIXES(ExistingUserControllerTest, ExistingUserLogin);
+  FRIEND_TEST_ALL_PREFIXES(ExistingUserControllerPublicSessionTest,
+                           ConfigureAutoLogin);
+  FRIEND_TEST_ALL_PREFIXES(ExistingUserControllerPublicSessionTest,
+                           UserActivityRestartsAutoLogin);
+  FRIEND_TEST_ALL_PREFIXES(ExistingUserControllerPublicSessionTest,
+                           OnAutoLoginFire);
 
   DISALLOW_COPY_AND_ASSIGN(ExistingUserController);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_LOGIN_EXISTING_USER_CONTROLLER_H_