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 15 matching lines @@
 // 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 PasswordChangedView::Delegate {
+                               public PasswordChangedView::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();
+
+  // UserActivityObserver::Observer overrides:

[bartfab (slow), 2013/02/11 17:11:21]

nit:

s/overrides/implementation/
or
s/overrides//

[dconnelly, 2013/02/11 17:21:41]

Done.

+  virtual void OnUserActivity() OVERRIDE;
+
   // 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 Signout() OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
@@ skipping 13 matching lines @@
 
   // Returns the LoginDisplayHost for this controller.
   LoginDisplayHost* login_display_host() {
     return host_;
   }
 
  private:
   friend class ExistingUserControllerTest;
   friend class MockLoginPerformerDelegate;
 
+  // Retrieve public session auto-login policy and update the timer.
+  void ConfigurePublicSessionAutoLogin();
+
   // 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;
@@ skipping 64 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);
 
+  // Public session auto-login timer.
+  base::OneShotTimer<ExistingUserController> auto_login_timer_;
+
+  // Public session auto-login timeout, in milliseconds.
+  int public_session_auto_login_timer_;

[bartfab (slow), 2013/02/11 17:11:21]

nit: Calling this "timer" is not really accurate. It should be "timeout" or,
even better, matching the policy, "delay".

[dconnelly, 2013/02/11 17:21:41]

Done.

+
+  // Username for public session auto-login.
+  std::string public_session_auto_login_username_;

[bartfab (slow), 2013/02/11 17:11:21]

I think in the case of device local accounts (aka public accounts, aka public
sessions), Mattias called this "account id", not "username". But it's the same
thing, so treat this comment as a non-actionable FYI.

+
   // 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 43 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);
 
   DISALLOW_COPY_AND_ASSIGN(ExistingUserController);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_LOGIN_EXISTING_USER_CONTROLLER_H_